/**
* Check the arguments to `printf` and `scanf` against the `format` string.
*
* Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/chkformat.d, _chkformat.d)
* Documentation: https://dlang.org/phobos/dmd_chkformat.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/chkformat.d
*/
module dmd.chkformat;
//import core.stdc.stdio : printf, scanf;
import core.stdc.ctype : isdigit;
import dmd.astenums;
import dmd.cond;
import dmd.errors;
import dmd.expression;
import dmd.globals;
import dmd.identifier;
import dmd.location;
import dmd.mtype;
import dmd.target;
/******************************************
* Check that arguments to a printf format string are compatible
* with that string. Issue errors for incompatibilities.
*
* Follows the C99 specification for printf.
*
* Takes a generous, rather than strict, view of compatiblity.
* For example, an unsigned value can be formatted with a signed specifier.
*
* Diagnosed incompatibilities are:
*
* 1. incompatible sizes which will cause argument misalignment
* 2. deferencing arguments that are not pointers
* 3. insufficient number of arguments
* 4. struct arguments
* 5. array and slice arguments
* 6. non-pointer arguments to `s` specifier
* 7. non-standard formats
* 8. undefined behavior per C99
*
* Per the C Standard, extra arguments are ignored.
*
* No attempt is made to fix the arguments or the format string.
*
* Params:
* loc = location for error messages
* format = format string
* args = arguments to match with format string
* isVa_list = if a "v" function (format check only)
*
* Returns:
* `true` if errors occurred
* References:
* C99 7.19.6.1
* https://www.cplusplus.com/reference/cstdio/printf/
*/
bool checkPrintfFormat(ref const Loc loc, scope const char[] format, scope Expression[] args, bool isVa_list)
{
//printf("checkPrintFormat('%.*s')\n", cast(int)format.length, format.ptr);
size_t n; // index in args
for (size_t i = 0; i < format.length;)
{
if (format[i] != '%')
{
++i;
continue;
}
bool widthStar;
bool precisionStar;
size_t j = i;
const fmt = parsePrintfFormatSpecifier(format, j, widthStar, precisionStar);
const slice = format[i .. j];
i = j;
if (fmt == Format.percent)
continue; // "%%", no arguments
if (fmt == Format.GNU_m)
continue; // "%m", no arguments
if (isVa_list)
{
// format check only
if (fmt == Format.error)
deprecation(loc, "format specifier `\"%.*s\"` is invalid", cast(int)slice.length, slice.ptr);
continue;
}
Expression getNextArg(ref bool skip)
{
if (n == args.length)
{
if (args.length < (n + 1))
deprecation(loc, "more format specifiers than %d arguments", cast(int)n);
else
skip = true;
return null;
}
return args[n++];
}
void errorMsg(const char* prefix, Expression arg, const char* texpect, Type tactual)
{
deprecation(arg.loc, "%sargument `%s` for format specification `\"%.*s\"` must be `%s`, not `%s`",
prefix ? prefix : "", arg.toChars(), cast(int)slice.length, slice.ptr, texpect, tactual.toChars());
}
if (widthStar)
{
bool skip;
auto e = getNextArg(skip);
if (skip)
continue;
if (!e)
return true;
auto t = e.type.toBasetype();
if (t.ty != Tint32 && t.ty != Tuns32)
errorMsg("width ", e, "int", t);
}
if (precisionStar)
{
bool skip;
auto e = getNextArg(skip);
if (skip)
continue;
if (!e)
return true;
auto t = e.type.toBasetype();
if (t.ty != Tint32 && t.ty != Tuns32)
errorMsg("precision ", e, "int", t);
}
bool skip;
auto e = getNextArg(skip);
if (skip)
continue;
if (!e)
return true;
auto t = e.type.toBasetype();
auto tnext = t.nextOf();
const c_longsize = target.c.longsize;
const ptrsize = target.ptrsize;
// Types which are promoted to int are allowed.
// Spec: C99 6.5.2.2.7
final switch (fmt)
{
case Format.u: // unsigned int
case Format.d: // int
if (t.ty != Tint32 && t.ty != Tuns32)
errorMsg(null, e, fmt == Format.u ? "uint" : "int", t);
break;
case Format.hhu: // unsigned char
case Format.hhd: // signed char
if (t.ty != Tint32 && t.ty != Tuns32 && t.ty != Tint8 && t.ty != Tuns8)
errorMsg(null, e, fmt == Format.hhu ? "ubyte" : "byte", t);
break;
case Format.hu: // unsigned short int
case Format.hd: // short int
if (t.ty != Tint32 && t.ty != Tuns32 && t.ty != Tint16 && t.ty != Tuns16)
errorMsg(null, e, fmt == Format.hu ? "ushort" : "short", t);
break;
case Format.lu: // unsigned long int
case Format.ld: // long int
if (!(t.isintegral() && t.size() == c_longsize))
{
if (fmt == Format.lu)
errorMsg(null, e, (c_longsize == 4 ? "uint" : "ulong"), t);
else
errorMsg(null, e, (c_longsize == 4 ? "int" : "long"), t);
}
break;
case Format.llu: // unsigned long long int
case Format.lld: // long long int
if (t.ty != Tint64 && t.ty != Tuns64)
errorMsg(null, e, fmt == Format.llu ? "ulong" : "long", t);
break;
case Format.ju: // uintmax_t
case Format.jd: // intmax_t
if (t.ty != Tint64 && t.ty != Tuns64)
{
if (fmt == Format.ju)
errorMsg(null, e, "core.stdc.stdint.uintmax_t", t);
else
errorMsg(null, e, "core.stdc.stdint.intmax_t", t);
}
break;
case Format.zd: // size_t
if (!(t.isintegral() && t.size() == ptrsize))
errorMsg(null, e, "size_t", t);
break;
case Format.td: // ptrdiff_t
if (!(t.isintegral() && t.size() == ptrsize))
errorMsg(null, e, "ptrdiff_t", t);
break;
case Format.lg:
case Format.g: // double
if (t.ty != Tfloat64 && t.ty != Timaginary64)
errorMsg(null, e, "double", t);
break;
case Format.Lg: // long double
if (t.ty != Tfloat80 && t.ty != Timaginary80)
errorMsg(null, e, "real", t);
break;
case Format.p: // pointer
if (t.ty != Tpointer && t.ty != Tnull && t.ty != Tclass && t.ty != Tdelegate && t.ty != Taarray)
errorMsg(null, e, "void*", t);
break;
case Format.n: // pointer to int
if (!(t.ty == Tpointer && tnext.ty == Tint32))
errorMsg(null, e, "int*", t);
break;
case Format.ln: // pointer to long int
if (!(t.ty == Tpointer && tnext.isintegral() && tnext.size() == c_longsize))
errorMsg(null, e, (c_longsize == 4 ? "int*" : "long*"), t);
break;
case Format.lln: // pointer to long long int
if (!(t.ty == Tpointer && tnext.ty == Tint64))
errorMsg(null, e, "long*", t);
break;
case Format.hn: // pointer to short
if (!(t.ty == Tpointer && tnext.ty == Tint16))
errorMsg(null, e, "short*", t);
break;
case Format.hhn: // pointer to signed char
if (!(t.ty == Tpointer && tnext.ty == Tint16))
errorMsg(null, e, "byte*", t);
break;
case Format.jn: // pointer to intmax_t
if (!(t.ty == Tpointer && tnext.ty == Tint64))
errorMsg(null, e, "core.stdc.stdint.intmax_t*", t);
break;
case Format.zn: // pointer to size_t
if (!(t.ty == Tpointer && tnext.isintegral() && tnext.isunsigned() && tnext.size() == ptrsize))
errorMsg(null, e, "size_t*", t);
break;
case Format.tn: // pointer to ptrdiff_t
if (!(t.ty == Tpointer && tnext.isintegral() && !tnext.isunsigned() && tnext.size() == ptrsize))
errorMsg(null, e, "ptrdiff_t*", t);
break;
case Format.c: // char
if (t.ty != Tint32 && t.ty != Tuns32)
errorMsg(null, e, "char", t);
break;
case Format.lc: // wint_t
if (t.ty != Tint32 && t.ty != Tuns32)
errorMsg(null, e, "wchar_t", t);
break;
case Format.s: // pointer to char string
if (!(t.ty == Tpointer && (tnext.ty == Tchar || tnext.ty == Tint8 || tnext.ty == Tuns8)))
errorMsg(null, e, "char*", t);
break;
case Format.ls: // pointer to wchar_t string
if (!(t.ty == Tpointer && tnext.ty.isSomeChar && tnext.size() == target.c.wchar_tsize))
errorMsg(null, e, "wchar_t*", t);
break;
case Format.error:
deprecation(loc, "format specifier `\"%.*s\"` is invalid", cast(int)slice.length, slice.ptr);
break;
case Format.GNU_m:
case Format.POSIX_ms:
case Format.POSIX_mls:
case Format.percent:
assert(0);
}
}
return false;
}
/******************************************
* Check that arguments to a scanf format string are compatible
* with that string. Issue errors for incompatibilities.
*
* Follows the C99 specification for scanf.
*
* Takes a generous, rather than strict, view of compatiblity.
* For example, an unsigned value can be formatted with a signed specifier.
*
* Diagnosed incompatibilities are:
*
* 1. incompatible sizes which will cause argument misalignment
* 2. deferencing arguments that are not pointers
* 3. insufficient number of arguments
* 4. struct arguments
* 5. array and slice arguments
* 6. non-standard formats
* 7. undefined behavior per C99
*
* Per the C Standard, extra arguments are ignored.
*
* No attempt is made to fix the arguments or the format string.
*
* Params:
* loc = location for error messages
* format = format string
* args = arguments to match with format string
* isVa_list = if a "v" function (format check only)
*
* Returns:
* `true` if errors occurred
* References:
* C99 7.19.6.2
* https://www.cplusplus.com/reference/cstdio/scanf/
*/
bool checkScanfFormat(ref const Loc loc, scope const char[] format, scope Expression[] args, bool isVa_list)
{
size_t n = 0;
for (size_t i = 0; i < format.length;)
{
if (format[i] != '%')
{
++i;
continue;
}
bool asterisk;
size_t j = i;
const fmt = parseScanfFormatSpecifier(format, j, asterisk);
const slice = format[i .. j];
i = j;
if (fmt == Format.percent || asterisk)
continue; // "%%", "%*": no arguments
if (isVa_list)
{
// format check only
if (fmt == Format.error)
deprecation(loc, "format specifier `\"%.*s\"` is invalid", cast(int)slice.length, slice.ptr);
continue;
}
Expression getNextArg()
{
if (n == args.length)
{
if (!asterisk)
deprecation(loc, "more format specifiers than %d arguments", cast(int)n);
return null;
}
return args[n++];
}
void errorMsg(const char* prefix, Expression arg, const char* texpect, Type tactual)
{
deprecation(arg.loc, "%sargument `%s` for format specification `\"%.*s\"` must be `%s`, not `%s`",
prefix ? prefix : "", arg.toChars(), cast(int)slice.length, slice.ptr, texpect, tactual.toChars());
}
auto e = getNextArg();
if (!e)
return true;
auto t = e.type.toBasetype();
auto tnext = t.nextOf();
const c_longsize = target.c.longsize;
const ptrsize = target.ptrsize;
final switch (fmt)
{
case Format.n:
case Format.d: // pointer to int
if (!(t.ty == Tpointer && tnext.ty == Tint32))
errorMsg(null, e, "int*", t);
break;
case Format.hhn:
case Format.hhd: // pointer to signed char
if (!(t.ty == Tpointer && tnext.ty == Tint16))
errorMsg(null, e, "byte*", t);
break;
case Format.hn:
case Format.hd: // pointer to short
if (!(t.ty == Tpointer && tnext.ty == Tint16))
errorMsg(null, e, "short*", t);
break;
case Format.ln:
case Format.ld: // pointer to long int
if (!(t.ty == Tpointer && tnext.isintegral() && !tnext.isunsigned() && tnext.size() == c_longsize))
errorMsg(null, e, (c_longsize == 4 ? "int*" : "long*"), t);
break;
case Format.lln:
case Format.lld: // pointer to long long int
if (!(t.ty == Tpointer && tnext.ty == Tint64))
errorMsg(null, e, "long*", t);
break;
case Format.jn:
case Format.jd: // pointer to intmax_t
if (!(t.ty == Tpointer && tnext.ty == Tint64))
errorMsg(null, e, "core.stdc.stdint.intmax_t*", t);
break;
case Format.zn:
case Format.zd: // pointer to size_t
if (!(t.ty == Tpointer && tnext.isintegral() && tnext.isunsigned() && tnext.size() == ptrsize))
errorMsg(null, e, "size_t*", t);
break;
case Format.tn:
case Format.td: // pointer to ptrdiff_t
if (!(t.ty == Tpointer && tnext.isintegral() && !tnext.isunsigned() && tnext.size() == ptrsize))
errorMsg(null, e, "ptrdiff_t*", t);
break;
case Format.u: // pointer to unsigned int
if (!(t.ty == Tpointer && tnext.ty == Tuns32))
errorMsg(null, e, "uint*", t);
break;
case Format.hhu: // pointer to unsigned char
if (!(t.ty == Tpointer && tnext.ty == Tuns8))
errorMsg(null, e, "ubyte*", t);
break;
case Format.hu: // pointer to unsigned short int
if (!(t.ty == Tpointer && tnext.ty == Tuns16))
errorMsg(null, e, "ushort*", t);
break;
case Format.lu: // pointer to unsigned long int
if (!(t.ty == Tpointer && tnext.isintegral() && tnext.isunsigned() && tnext.size() == c_longsize))
errorMsg(null, e, (c_longsize == 4 ? "uint*" : "ulong*"), t);
break;
case Format.llu: // pointer to unsigned long long int
if (!(t.ty == Tpointer && tnext.ty == Tuns64))
errorMsg(null, e, "ulong*", t);
break;
case Format.ju: // pointer to uintmax_t
if (!(t.ty == Tpointer && tnext.ty == Tuns64))
errorMsg(null, e, "core.stdc.stdint.uintmax_t*", t);
break;
case Format.g: // pointer to float
if (!(t.ty == Tpointer && tnext.ty == Tfloat32))
errorMsg(null, e, "float*", t);
break;
case Format.lg: // pointer to double
if (!(t.ty == Tpointer && tnext.ty == Tfloat64))
errorMsg(null, e, "double*", t);
break;
case Format.Lg: // pointer to long double
if (!(t.ty == Tpointer && tnext.ty == Tfloat80))
errorMsg(null, e, "real*", t);
break;
case Format.c:
case Format.s: // pointer to char string
if (!(t.ty == Tpointer && (tnext.ty == Tchar || tnext.ty == Tint8 || tnext.ty == Tuns8)))
errorMsg(null, e, "char*", t);
break;
case Format.lc:
case Format.ls: // pointer to wchar_t string
if (!(t.ty == Tpointer && tnext.ty.isSomeChar && tnext.size() == target.c.wchar_tsize))
errorMsg(null, e, "wchar_t*", t);
break;
case Format.p: // double pointer
if (!(t.ty == Tpointer && tnext.ty == Tpointer))
errorMsg(null, e, "void**", t);
break;
case Format.POSIX_ms: // pointer to pointer to char string
Type tnext2 = tnext ? tnext.nextOf() : null;
if (!(t.ty == Tpointer && tnext.ty == Tpointer && (tnext2.ty == Tchar || tnext2.ty == Tint8 || tnext2.ty == Tuns8)))
errorMsg(null, e, "char**", t);
break;
case Format.POSIX_mls: // pointer to pointer to wchar_t string
Type tnext2 = tnext ? tnext.nextOf() : null;
if (!(t.ty == Tpointer && tnext.ty == Tpointer && tnext2.ty.isSomeChar && tnext2.size() == target.c.wchar_tsize))
errorMsg(null, e, "wchar_t**", t);
break;
case Format.error:
deprecation(loc, "format specifier `\"%.*s\"` is invalid", cast(int)slice.length, slice.ptr);
break;
case Format.GNU_m:
case Format.percent:
assert(0);
}
}
return false;
}
private:
/**************************************
* Parse the *format specifier* which is of the form:
*
* `%[*][width][length]specifier`
*
* Params:
* format = format string
* idx = index of `%` of start of format specifier,
* which gets updated to index past the end of it,
* even if `Format.error` is returned
* asterisk = set if there is a `*` sub-specifier
* Returns:
* Format
*/
Format parseScanfFormatSpecifier(scope const char[] format, ref size_t idx,
out bool asterisk) nothrow pure @safe
{
auto i = idx;
assert(format[i] == '%');
const length = format.length;
Format error()
{
idx = i;
return Format.error;
}
++i;
if (i == length)
return error();
if (format[i] == '%')
{
idx = i + 1;
return Format.percent;
}
// * sub-specifier
if (format[i] == '*')
{
++i;
if (i == length)
return error();
asterisk = true;
}
// fieldWidth
while (isdigit(format[i]))
{
i++;
if (i == length)
return error();
}
/* Read the specifier
*/
Format specifier;
Modifier flags = Modifier.none;
switch (format[i])
{
case 'm':
// https://pubs.opengroup.org/onlinepubs/9699919799/functions/scanf.html
// POSIX.1-2017 C Extension (CX)
flags = Modifier.m;
++i;
if (i == length)
return error();
if (format[i] == 'l')
{
++i;
if (i == length)
return error();
flags = Modifier.ml;
}
// Check valid conversion types for %m.
if (format[i] == 'c' || format[i] == 's')
specifier = flags == Modifier.ml ? Format.POSIX_mls :
Format.POSIX_ms;
else if (format[i] == 'C' || format[i] == 'S')
specifier = flags == Modifier.m ? Format.POSIX_mls :
Format.error;
else if (format[i] == '[')
goto case '[';
else
specifier = Format.error;
++i;
break;
case 'l':
// Look for wchar_t scanset %l[..]
immutable j = i + 1;
if (j < length && format[j] == '[')
{
i = j;
flags = Modifier.l;
goto case '[';
}
goto default;
case '[':
// Read the scanset
i++;
if (i == length)
return error();
// If the conversion specifier begins with `[]` or `[^]`, the right
// bracket character is not the terminator, but in the scanlist.
if (format[i] == '^')
{
i++;
if (i == length)
return error();
}
if (format[i] == ']')
{
i++;
if (i == length)
return error();
}
// A scanset can be anything, so we just check that it is paired
while (i < length)
{
if (format[i] == ']')
break;
++i;
}
// no `]` found
if (i == length)
return error();
specifier = flags == Modifier.none ? Format.s :
flags == Modifier.l ? Format.ls :
flags == Modifier.m ? Format.POSIX_ms :
flags == Modifier.ml ? Format.POSIX_mls :
Format.error;
++i;
break;
default:
char genSpec;
specifier = parseGenericFormatSpecifier(format, i, genSpec);
if (specifier == Format.error)
return error();
break;
}
idx = i;
return specifier; // success
}
/**************************************
* Parse the *format specifier* which is of the form:
*
* `%[flags][field width][.precision][length modifier]specifier`
*
* Params:
* format = format string
* idx = index of `%` of start of format specifier,
* which gets updated to index past the end of it,
* even if `Format.error` is returned
* widthStar = set if * for width
* precisionStar = set if * for precision
* useGNUExts = true if parsing GNU format extensions
* Returns:
* Format
*/
Format parsePrintfFormatSpecifier(scope const char[] format, ref size_t idx,
out bool widthStar, out bool precisionStar, bool useGNUExts =
findCondition(global.versionids, Identifier.idPool("CRuntime_Glibc"))) nothrow pure @safe
{
auto i = idx;
assert(format[i] == '%');
const length = format.length;
bool hash;
bool zero;
bool flags;
bool width;
bool precision;
Format error()
{
idx = i;
return Format.error;
}
++i;
if (i == length)
return error();
if (format[i] == '%')
{
idx = i + 1;
return Format.percent;
}
/* Read the `flags`
*/
while (1)
{
const c = format[i];
if (c == '-' ||
c == '+' ||
c == ' ')
{
flags = true;
}
else if (c == '#')
{
hash = true;
}
else if (c == '0')
{
zero = true;
}
else
break;
++i;
if (i == length)
return error();
}
/* Read the `field width`
*/
{
const c = format[i];
if (c == '*')
{
width = true;
widthStar = true;
++i;
if (i == length)
return error();
}
else if ('1' <= c && c <= '9')
{
width = true;
++i;
if (i == length)
return error();
while ('0' <= format[i] && format[i] <= '9')
{
++i;
if (i == length)
return error();
}
}
}
/* Read the `precision`
*/
if (format[i] == '.')
{
precision = true;
++i;
if (i == length)
return error();
const c = format[i];
if (c == '*')
{
precisionStar = true;
++i;
if (i == length)
return error();
}
else if ('0' <= c && c <= '9')
{
++i;
if (i == length)
return error();
while ('0' <= format[i] && format[i] <= '9')
{
++i;
if (i == length)
return error();
}
}
}
/* Read the specifier
*/
char genSpec;
Format specifier;
switch (format[i])
{
case 'm':
// https://www.gnu.org/software/libc/manual/html_node/Other-Output-Conversions.html
if (useGNUExts)
{
specifier = Format.GNU_m;
genSpec = format[i];
++i;
break;
}
goto default;
default:
specifier = parseGenericFormatSpecifier(format, i, genSpec);
if (specifier == Format.error)
return error();
break;
}
switch (genSpec)
{
case 'c':
case 's':
case 'C':
case 'S':
if (hash || zero)
return error();
break;
case 'd':
case 'i':
if (hash)
return error();
break;
case 'm':
if (hash || zero || flags)
return error();
break;
case 'n':
if (hash || zero || precision || width || flags)
return error();
break;
default:
break;
}
idx = i;
return specifier; // success
}
/* Different kinds of conversion modifiers. */
enum Modifier
{
none,
h, // short
hh, // char
j, // intmax_t
l, // wint_t/wchar_t
ll, // long long int
L, // long double
m, // char**
ml, // wchar_t**
t, // ptrdiff_t
z // size_t
}
/* Different kinds of formatting specifications, variations we don't
care about are merged. (Like we don't care about the difference between
f, e, g, a, etc.)
For `scanf`, every format is a pointer.
*/
enum Format
{
d, // int
hhd, // signed char
hd, // short int
ld, // long int
lld, // long long int
jd, // intmax_t
zd, // size_t
td, // ptrdiff_t
u, // unsigned int
hhu, // unsigned char
hu, // unsigned short int
lu, // unsigned long int
llu, // unsigned long long int
ju, // uintmax_t
g, // float (scanf) / double (printf)
lg, // double (scanf)
Lg, // long double (both)
s, // char string (both)
ls, // wchar_t string (both)
c, // char (printf)
lc, // wint_t (printf)
p, // pointer
n, // pointer to int
hhn, // pointer to signed char
hn, // pointer to short
ln, // pointer to long int
lln, // pointer to long long int
jn, // pointer to intmax_t
zn, // pointer to size_t
tn, // pointer to ptrdiff_t
GNU_m, // GNU ext. : string corresponding to the error code in errno (printf)
POSIX_ms, // POSIX ext. : dynamically allocated char string (scanf)
POSIX_mls, // POSIX ext. : dynamically allocated wchar_t string (scanf)
percent, // %% (i.e. no argument)
error, // invalid format specification
}
/**************************************
* Parse the *length specifier* and the *specifier* of the following form:
* `[length]specifier`
*
* Params:
* format = format string
* idx = index of of start of format specifier,
* which gets updated to index past the end of it,
* even if `Format.error` is returned
* genSpecifier = Generic specifier. For instance, it will be set to `d` if the
* format is `hdd`.
* Returns:
* Format
*/
Format parseGenericFormatSpecifier(scope const char[] format,
ref size_t idx, out char genSpecifier) nothrow pure @safe
{
const length = format.length;
/* Read the `length modifier`
*/
const lm = format[idx];
Modifier flags;
switch (lm)
{
case 'j':
case 'z':
case 't':
case 'L':
flags = lm == 'j' ? Modifier.j :
lm == 'z' ? Modifier.z :
lm == 't' ? Modifier.t :
Modifier.L;
++idx;
if (idx == length)
return Format.error;
break;
case 'h':
case 'l':
++idx;
if (idx == length)
return Format.error;
if (lm == format[idx])
{
flags = lm == 'h' ? Modifier.hh : Modifier.ll;
++idx;
if (idx == length)
return Format.error;
}
else
flags = lm == 'h' ? Modifier.h : Modifier.l;
break;
default:
flags = Modifier.none;
break;
}
/* Read the `specifier`
*/
Format specifier;
const sc = format[idx];
genSpecifier = sc;
switch (sc)
{
case 'd':
case 'i':
specifier = flags == Modifier.none ? Format.d :
flags == Modifier.hh ? Format.hhd :
flags == Modifier.h ? Format.hd :
flags == Modifier.ll ? Format.lld :
flags == Modifier.l ? Format.ld :
flags == Modifier.j ? Format.jd :
flags == Modifier.z ? Format.zd :
flags == Modifier.t ? Format.td :
Format.error;
break;
case 'u':
case 'o':
case 'x':
case 'X':
specifier = flags == Modifier.none ? Format.u :
flags == Modifier.hh ? Format.hhu :
flags == Modifier.h ? Format.hu :
flags == Modifier.ll ? Format.llu :
flags == Modifier.l ? Format.lu :
flags == Modifier.j ? Format.ju :
flags == Modifier.z ? Format.zd :
flags == Modifier.t ? Format.td :
Format.error;
break;
case 'f':
case 'F':
case 'e':
case 'E':
case 'g':
case 'G':
case 'a':
case 'A':
specifier = flags == Modifier.none ? Format.g :
flags == Modifier.L ? Format.Lg :
flags == Modifier.l ? Format.lg :
Format.error;
break;
case 'c':
specifier = flags == Modifier.none ? Format.c :
flags == Modifier.l ? Format.lc :
Format.error;
break;
case 's':
specifier = flags == Modifier.none ? Format.s :
flags == Modifier.l ? Format.ls :
Format.error;
break;
case 'p':
specifier = flags == Modifier.none ? Format.p :
Format.error;
break;
case 'n':
specifier = flags == Modifier.none ? Format.n :
flags == Modifier.ll ? Format.lln :
flags == Modifier.l ? Format.ln :
flags == Modifier.hh ? Format.hhn :
flags == Modifier.h ? Format.hn :
flags == Modifier.j ? Format.jn :
flags == Modifier.z ? Format.zn :
flags == Modifier.t ? Format.tn :
Format.error;
break;
case 'C':
// POSIX.1-2017 X/Open System Interfaces (XSI)
// %C format is equivalent to %lc
specifier = flags == Modifier.none ? Format.lc :
Format.error;
break;
case 'S':
// POSIX.1-2017 X/Open System Interfaces (XSI)
// %S format is equivalent to %ls
specifier = flags == Modifier.none ? Format.ls :
Format.error;
break;
default:
specifier = Format.error;
break;
}
++idx;
return specifier; // success
}
@("parseGenericFormatSpecifier") unittest
{
char genSpecifier;
size_t idx;
void testG(string fmtStr, Format expectedFormat, char expectedGenSpecifier)
{
idx = 0;
assert(parseGenericFormatSpecifier(fmtStr, idx, genSpecifier) == expectedFormat);
assert(genSpecifier == expectedGenSpecifier);
}
testG("hhd", Format.hhd, 'd');
testG("hn", Format.hn, 'n');
testG("ji", Format.jd, 'i');
testG("lu", Format.lu, 'u');
idx = 0;
assert(parseGenericFormatSpecifier("k", idx, genSpecifier) == Format.error);
}
@("parsePrintfFormatSpecifier") unittest
{
bool useGNUExts = false;
size_t idx = 0;
bool widthStar;
bool precisionStar;
void testP(string fmtStr, Format expectedFormat, size_t expectedIdx)
{
idx = 0;
assert(parsePrintfFormatSpecifier(fmtStr, idx, widthStar, precisionStar, useGNUExts) == expectedFormat);
assert(idx == expectedIdx);
}
// one for each Format
testP("%d", Format.d, 2);
assert(!widthStar && !precisionStar);
testP("%ld", Format.ld, 3);
testP("%lld", Format.lld, 4);
testP("%jd", Format.jd, 3);
testP("%zd", Format.zd, 3);
testP("%td", Format.td, 3);
testP("%g", Format.g, 2);
testP("%Lg", Format.Lg, 3);
testP("%p", Format.p, 2);
testP("%n", Format.n, 2);
testP("%ln", Format.ln, 3);
testP("%lln", Format.lln, 4);
testP("%hn", Format.hn, 3);
testP("%hhn", Format.hhn, 4);
testP("%jn", Format.jn, 3);
testP("%zn", Format.zn, 3);
testP("%tn", Format.tn, 3);
testP("%c", Format.c, 2);
testP("%lc", Format.lc, 3);
testP("%s", Format.s, 2);
testP("%ls", Format.ls, 3);
testP("%%", Format.percent, 2);
// Synonyms
testP("%i", Format.d, 2);
testP("%u", Format.u, 2);
testP("%o", Format.u, 2);
testP("%x", Format.u, 2);
testP("%X", Format.u, 2);
testP("%f", Format.g, 2);
testP("%F", Format.g, 2);
testP("%G", Format.g, 2);
testP("%a", Format.g, 2);
testP("%La", Format.Lg, 3);
testP("%A", Format.g, 2);
testP("%lg", Format.lg, 3);
// width, precision
testP("%*d", Format.d, 3);
assert(widthStar && !precisionStar);
testP("%.*d", Format.d, 4);
assert(!widthStar && precisionStar);
testP("%*.*d", Format.d, 5);
assert(widthStar && precisionStar);
// Too short formats
foreach (s; ["%", "%-", "%+", "% ", "%#", "%0", "%*", "%1", "%19", "%.", "%.*", "%.1", "%.12",
"%j", "%z", "%t", "%l", "%h", "%ll", "%hh"])
{
testP(s, Format.error, s.length);
}
// Undefined format combinations
foreach (s; ["%#d", "%llg", "%jg", "%zg", "%tg", "%hg", "%hhg",
"%#c", "%0c", "%jc", "%zc", "%tc", "%Lc", "%hc", "%hhc", "%llc",
"%#s", "%0s", "%js", "%zs", "%ts", "%Ls", "%hs", "%hhs", "%lls",
"%jp", "%zp", "%tp", "%Lp", "%hp", "%lp", "%hhp", "%llp",
"%-n", "%+n", "% n", "%#n", "%0n", "%*n", "%1n", "%19n", "%.n", "%.*n", "%.1n", "%.12n", "%Ln", "%K"])
{
testP(s, Format.error, s.length);
}
testP("%C", Format.lc, 2);
testP("%S", Format.ls, 2);
// GNU extensions: explicitly toggle ISO/GNU flag.
foreach (s; ["%jm", "%zm", "%tm", "%Lm", "%hm", "%hhm", "%lm", "%llm",
"%#m", "%+m", "%-m", "% m", "%0m"])
{
useGNUExts = false;
testP(s, Format.error, s.length);
useGNUExts = true;
testP(s, Format.error, s.length);
}
foreach (s; ["%m", "%md", "%mz", "%mc", "%mm", "%msyz", "%ml", "%mlz", "%mlc", "%mlm"])
{
// valid cases, all parsed as `%m`
// GNU printf()
useGNUExts = true;
testP(s, Format.GNU_m, 2);
// ISO printf()
useGNUExts = false;
testP(s, Format.error, 2);
}
}
@("parseScanfFormatSpecifier") unittest
{
size_t idx;
bool asterisk;
void testS(string fmtStr, Format expectedFormat, size_t expectedIdx)
{
idx = 0;
assert(parseScanfFormatSpecifier(fmtStr, idx, asterisk) == expectedFormat);
assert(idx == expectedIdx);
}
// one for each Format
testS("%d", Format.d, 2);
testS("%hhd", Format.hhd, 4);
testS("%hd", Format.hd, 3);
testS("%ld", Format.ld, 3);
testS("%lld", Format.lld, 4);
testS("%jd", Format.jd, 3);
testS("%zd", Format.zd, 3);
testS("%td", Format.td, 3);
testS("%u", Format.u, 2);
testS("%hhu", Format.hhu, 4);
testS("%hu", Format.hu, 3);
testS("%lu", Format.lu, 3);
testS("%llu", Format.llu, 4);
testS("%ju", Format.ju, 3);
testS("%g", Format.g, 2);
testS("%lg", Format.lg, 3);
testS("%Lg", Format.Lg, 3);
testS("%p", Format.p, 2);
testS("%s", Format.s, 2);
testS("%ls", Format.ls, 3);
testS("%%", Format.percent, 2);
// Synonyms
testS("%i", Format.d, 2);
testS("%n", Format.n, 2);
testS("%o", Format.u, 2);
testS("%x", Format.u, 2);
testS("%f", Format.g, 2);
testS("%e", Format.g, 2);
testS("%a", Format.g, 2);
testS("%c", Format.c, 2);
// asterisk
testS("%*d", Format.d, 3);
assert(asterisk);
testS("%9ld", Format.ld, 4);
assert(!asterisk);
testS("%*25984hhd", Format.hhd, 10);
assert(asterisk);
// scansets
testS("%[a-zA-Z]", Format.s, 9);
assert(!asterisk);
testS("%*25l[a-z]", Format.ls, 10);
assert(asterisk);
testS("%[]]", Format.s, 4);
assert(!asterisk);
testS("%[^]]", Format.s, 5);
assert(!asterisk);
// Too short formats
foreach (s; ["%", "% ", "%#", "%0", "%*", "%1", "%19",
"%j", "%z", "%t", "%l", "%h", "%ll", "%hh", "%K"])
{
testS(s, Format.error, s.length);
}
// Undefined format combinations
foreach (s; ["%Ld", "%llg", "%jg", "%zg", "%tg", "%hg", "%hhg",
"%jc", "%zc", "%tc", "%Lc", "%hc", "%hhc", "%llc",
"%jp", "%zp", "%tp", "%Lp", "%hp", "%lp", "%hhp", "%llp",
"%-", "%+", "%#", "%0", "%.", "%Ln"])
{
testS(s, Format.error, s.length);
}
// Invalid scansets
foreach (s; ["%[]", "%[^", "%[^]", "%[s", "%[0-9lld", "%[", "%l[^]"])
{
testS(s, Format.error, s.length);
}
// Posix extensions
foreach (s; ["%jm", "%zm", "%tm", "%Lm", "%hm", "%hhm", "%lm", "%llm",
"%m", "%ma", "%md", "%ml", "%mm", "%mlb", "%mlj", "%mlr", "%mlz",
"%LC", "%lC", "%llC", "%jC", "%tC", "%hC", "%hhC", "%zC",
"%LS", "%lS", "%llS", "%jS", "%tS", "%hS", "%hhS", "%zS"])
{
testS(s, Format.error, s.length);
}
testS("%mc", Format.POSIX_ms, 3);
testS("%ms", Format.POSIX_ms, 3);
testS("%m[0-9]", Format.POSIX_ms, 7);
testS("%mlc", Format.POSIX_mls, 4);
testS("%mls", Format.POSIX_mls, 4);
testS("%ml[^0-9]", Format.POSIX_mls, 9);
testS("%mC", Format.POSIX_mls, 3);
testS("%mS", Format.POSIX_mls, 3);
testS("%C", Format.lc, 2);
testS("%S", Format.ls, 2);
}