RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 06:37:44 +00:00
Code Issues Activity Actions

LibC: Convert LengthModifier & ConversionSpecifier to enum classes

Browse source 
These were preventing some AK classes from using the AK Concepts header
due to the non-strictly namespaced ConversionSpecifier::Unsigned, and
are not used as their underlying value, so enum classes are more
appropriate anyways.
This commit is contained in:
Idan Horowitz 2021-07-04 19:59:29 +03:00 • committed by Linus Groh
parent 814195b060
commit 3f70efed9c
1 changed files with 54 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

108
Userland/Libraries/LibC/scanf.cpp
View file

@ -14,7 +14,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
enum LengthModifier { enum class LengthModifier {
None, None,
Default, Default,
Char, Char,
@ -27,7 +27,7 @@ enum LengthModifier {
LongDouble, LongDouble,
}; };
enum ConversionSpecifier { enum class ConversionSpecifier {
Unspecified, Unspecified,
Decimal, Decimal,
Integer, Integer,
@ -254,15 +254,15 @@ struct ReadElement {
{ {
switch (length_modifier) { switch (length_modifier) {
default: default:
case None: case LengthModifier::None:
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
case Default: case LengthModifier::Default:
return ReadElementConcrete<T, T, kind> {}(input_lexer, ap); return ReadElementConcrete<T, T, kind> {}(input_lexer, ap);
case Char: case LengthModifier::Char:
return ReadElementConcrete<T, char, kind> {}(input_lexer, ap); return ReadElementConcrete<T, char, kind> {}(input_lexer, ap);
case Short: case LengthModifier::Short:
return ReadElementConcrete<T, short, kind> {}(input_lexer, ap); return ReadElementConcrete<T, short, kind> {}(input_lexer, ap);
case Long: case LengthModifier::Long:
if constexpr (IsSame<T, int>) if constexpr (IsSame<T, int>)
return ReadElementConcrete<T, long, kind> {}(input_lexer, ap); return ReadElementConcrete<T, long, kind> {}(input_lexer, ap);
if constexpr (IsSame<T, unsigned>) if constexpr (IsSame<T, unsigned>)
@ -270,7 +270,7 @@ struct ReadElement {
if constexpr (IsSame<T, float>) if constexpr (IsSame<T, float>)
return ReadElementConcrete<int, double, kind> {}(input_lexer, ap); return ReadElementConcrete<int, double, kind> {}(input_lexer, ap);
return false; return false;
case LongLong: case LengthModifier::LongLong:
if constexpr (IsSame<T, int>) if constexpr (IsSame<T, int>)
return ReadElementConcrete<long long, long long, kind> {}(input_lexer, ap); return ReadElementConcrete<long long, long long, kind> {}(input_lexer, ap);
if constexpr (IsSame<T, unsigned>) if constexpr (IsSame<T, unsigned>)
@ -278,13 +278,13 @@ struct ReadElement {
if constexpr (IsSame<T, float>) if constexpr (IsSame<T, float>)
return ReadElementConcrete<long long, double, kind> {}(input_lexer, ap); return ReadElementConcrete<long long, double, kind> {}(input_lexer, ap);
return false; return false;
case IntMax: case LengthModifier::IntMax:
return ReadElementConcrete<T, intmax_t, kind> {}(input_lexer, ap); return ReadElementConcrete<T, intmax_t, kind> {}(input_lexer, ap);
case Size: case LengthModifier::Size:
return ReadElementConcrete<T, size_t, kind> {}(input_lexer, ap); return ReadElementConcrete<T, size_t, kind> {}(input_lexer, ap);
case PtrDiff: case LengthModifier::PtrDiff:
return ReadElementConcrete<T, ptrdiff_t, kind> {}(input_lexer, ap); return ReadElementConcrete<T, ptrdiff_t, kind> {}(input_lexer, ap);
case LongDouble: case LengthModifier::LongDouble:
return ReadElementConcrete<T, long double, kind> {}(input_lexer, ap); return ReadElementConcrete<T, long double, kind> {}(input_lexer, ap);
} }
} }
@ -420,84 +420,84 @@ extern "C" int vsscanf(const char* input, const char* format, va_list ap)
bool invert_scanlist = false; bool invert_scanlist = false;
StringView scanlist; StringView scanlist;
LengthModifier length_modifier { None }; LengthModifier length_modifier { LengthModifier::None };
ConversionSpecifier conversion_specifier { Unspecified }; ConversionSpecifier conversion_specifier { ConversionSpecifier::Unspecified };
reread_lookahead:; reread_lookahead:;
auto format_lookahead = format_lexer.peek(); auto format_lookahead = format_lexer.peek();
if (length_modifier == None) { if (length_modifier == LengthModifier::None) {
switch (format_lookahead) { switch (format_lookahead) {
case 'h': case 'h':
if (format_lexer.peek(1) == 'h') { if (format_lexer.peek(1) == 'h') {
format_lexer.consume(2); format_lexer.consume(2);
length_modifier = Char; length_modifier = LengthModifier::Char;
} else { } else {
format_lexer.consume(1); format_lexer.consume(1);
length_modifier = Short; length_modifier = LengthModifier::Short;
} }
break; break;
case 'l': case 'l':
if (format_lexer.peek(1) == 'l') { if (format_lexer.peek(1) == 'l') {
format_lexer.consume(2); format_lexer.consume(2);
length_modifier = LongLong; length_modifier = LengthModifier::LongLong;
} else { } else {
format_lexer.consume(1); format_lexer.consume(1);
length_modifier = Long; length_modifier = LengthModifier::Long;
} }
break; break;
case 'j': case 'j':
format_lexer.consume(); format_lexer.consume();
length_modifier = IntMax; length_modifier = LengthModifier::IntMax;
break; break;
case 'z': case 'z':
format_lexer.consume(); format_lexer.consume();
length_modifier = Size; length_modifier = LengthModifier::Size;
break; break;
case 't': case 't':
format_lexer.consume(); format_lexer.consume();
length_modifier = PtrDiff; length_modifier = LengthModifier::PtrDiff;
break; break;
case 'L': case 'L':
format_lexer.consume(); format_lexer.consume();
length_modifier = LongDouble; length_modifier = LengthModifier::LongDouble;
break; break;
default: default:
length_modifier = Default; length_modifier = LengthModifier::Default;
break; break;
} }
goto reread_lookahead; goto reread_lookahead;
} }
if (conversion_specifier == Unspecified) { if (conversion_specifier == ConversionSpecifier::Unspecified) {
switch (format_lookahead) { switch (format_lookahead) {
case 'd': case 'd':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Decimal; conversion_specifier = ConversionSpecifier::Decimal;
break; break;
case 'i': case 'i':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Integer; conversion_specifier = ConversionSpecifier::Integer;
break; break;
case 'o': case 'o':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Octal; conversion_specifier = ConversionSpecifier::Octal;
break; break;
case 'u': case 'u':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Unsigned; conversion_specifier = ConversionSpecifier::Unsigned;
break; break;
case 'x': case 'x':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Hex; conversion_specifier = ConversionSpecifier::Hex;
break; break;
case 'a': case 'a':
case 'e': case 'e':
case 'f': case 'f':
case 'g': case 'g':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Floating; conversion_specifier = ConversionSpecifier::Floating;
break; break;
case 's': case 's':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = String; conversion_specifier = ConversionSpecifier::String;
break; break;
case '[': case '[':
format_lexer.consume(); format_lexer.consume();
@ -506,33 +506,33 @@ extern "C" int vsscanf(const char* input, const char* format, va_list ap)
scanlist = scanlist.substring_view(1); scanlist = scanlist.substring_view(1);
invert_scanlist = true; invert_scanlist = true;
} }
conversion_specifier = UseScanList; conversion_specifier = ConversionSpecifier::UseScanList;
break; break;
case 'c': case 'c':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Character; conversion_specifier = ConversionSpecifier::Character;
break; break;
case 'p': case 'p':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Pointer; conversion_specifier = ConversionSpecifier::Pointer;
break; break;
case 'n': case 'n':
format_lexer.consume(); format_lexer.consume();
conversion_specifier = OutputNumberOfBytes; conversion_specifier = ConversionSpecifier::OutputNumberOfBytes;
break; break;
case 'C': case 'C':
format_lexer.consume(); format_lexer.consume();
length_modifier = Long; length_modifier = LengthModifier::Long;
conversion_specifier = Character; conversion_specifier = ConversionSpecifier::Character;
break; break;
case 'S': case 'S':
format_lexer.consume(); format_lexer.consume();
length_modifier = Long; length_modifier = LengthModifier::Long;
conversion_specifier = String; conversion_specifier = ConversionSpecifier::String;
break; break;
default: default:
format_lexer.consume(); format_lexer.consume();
conversion_specifier = Invalid; conversion_specifier = ConversionSpecifier::Invalid;
break; break;
} }
} }
@ -541,73 +541,73 @@ extern "C" int vsscanf(const char* input, const char* format, va_list ap)
// Now try to read. // Now try to read.
switch (conversion_specifier) { switch (conversion_specifier) {
case Invalid: case ConversionSpecifier::Invalid:
case Unspecified: case ConversionSpecifier::Unspecified:
default: default:
// "undefined behaviour", let's be nice and crash. // "undefined behaviour", let's be nice and crash.
dbgln("Invalid conversion specifier {} in scanf!", (int)conversion_specifier); dbgln("Invalid conversion specifier {} in scanf!", (int)conversion_specifier);
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
case Decimal: case ConversionSpecifier::Decimal:
if (!ReadElement<int, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<int, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Integer: case ConversionSpecifier::Integer:
if (!ReadElement<int, ReadKind::Infer> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<int, ReadKind::Infer> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Octal: case ConversionSpecifier::Octal:
if (!ReadElement<unsigned, ReadKind::Octal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<unsigned, ReadKind::Octal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Unsigned: case ConversionSpecifier::Unsigned:
if (!ReadElement<unsigned, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<unsigned, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Hex: case ConversionSpecifier::Hex:
if (!ReadElement<unsigned, ReadKind::Hex> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<unsigned, ReadKind::Hex> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Floating: case ConversionSpecifier::Floating:
if (!ReadElement<float, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<float, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case String: case ConversionSpecifier::String:
if (!ReadElement<char*, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<char*, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case UseScanList: case ConversionSpecifier::UseScanList:
if (!ReadElement<char*, ReadKind::Normal> { scanlist, invert_scanlist }(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<char*, ReadKind::Normal> { scanlist, invert_scanlist }(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Character: case ConversionSpecifier::Character:
if (!ReadElement<char, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<char, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case Pointer: case ConversionSpecifier::Pointer:
if (!ReadElement<void*, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null)) if (!ReadElement<void*, ReadKind::Normal> {}(length_modifier, input_lexer, ap_or_null))
format_lexer.consume_all(); format_lexer.consume_all();
else else
++elements_matched; ++elements_matched;
break; break;
case OutputNumberOfBytes: { case ConversionSpecifier::OutputNumberOfBytes: {
if (!suppress_assignment) { if (!suppress_assignment) {
auto* ptr = va_arg(ap, int*); auto* ptr = va_arg(ap, int*);
*ptr = input_lexer.tell(); *ptr = input_lexer.tell();