path: root/gcc/d/dmd/chkformat.c

/* Compiler implementation of the D programming language
 * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
 * written by Walter Bright
 * http://www.digitalmars.com
 * Distributed under the Boost Software License, Version 1.0.
 * http://www.boost.org/LICENSE_1_0.txt
 */

// Check the arguments to `printf` and `scanf` against the `format` string.

#include "root/dsystem.h"
#include "root/dcompat.h"

#include "arraytypes.h"
#include "cond.h"
#include "errors.h"
#include "expression.h"
#include "globals.h"
#include "identifier.h"
#include "mtype.h"
#include "target.h"


/* 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
{
    Format_d,          // int
    Format_hhd,        // signed char
    Format_hd,         // short int
    Format_ld,         // long int
    Format_lld,        // long long int
    Format_jd,         // intmax_t
    Format_zd,         // size_t
    Format_td,         // ptrdiff_t
    Format_u,          // unsigned int
    Format_hhu,        // unsigned char
    Format_hu,         // unsigned short int
    Format_lu,         // unsigned long int
    Format_llu,        // unsigned long long int
    Format_ju,         // uintmax_t
    Format_g,          // float (scanf) / double (printf)
    Format_lg,         // double (scanf)
    Format_Lg,         // long double (both)
    Format_s,          // char string (both)
    Format_ls,         // wchar_t string (both)
    Format_c,          // char (printf)
    Format_lc,         // wint_t (printf)
    Format_p,          // pointer
    Format_n,          // pointer to int
    Format_hhn,        // pointer to signed char
    Format_hn,         // pointer to short
    Format_ln,         // pointer to long int
    Format_lln,        // pointer to long long int
    Format_jn,         // pointer to intmax_t
    Format_zn,         // pointer to size_t
    Format_tn,         // pointer to ptrdiff_t
    Format_GNU_a,      // GNU ext. : address to a string with no maximum size (scanf)
    Format_GNU_m,      // GNU ext. : string corresponding to the error code in errno (printf) / length modifier (scanf)
    Format_percent,    // %% (i.e. no argument)
    Format_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
 */
static Format parseGenericFormatSpecifier(const char *format,
            size_t &idx, char &genSpecifier, bool useGNUExts =
            findCondition(global.versionids, Identifier::idPool("CRuntime_Glibc")))
{
    genSpecifier = 0;

    const size_t length = strlen(format);

    /* Read the `length modifier`
     */
    const char lm = format[idx];
    bool lm1= false;        // if jztL
    bool lm2= false;        // if `hh` or `ll`
    if (lm == 'j' ||
        lm == 'z' ||
        lm == 't' ||
        lm == 'L')
    {
        ++idx;
        if (idx == length)
            return Format_error;
        lm1 = true;
    }
    else if (lm == 'h' || lm == 'l')
    {
        ++idx;
        if (idx == length)
            return Format_error;
        lm2 = lm == format[idx];
        if (lm2)
        {
            ++idx;
            if (idx == length)
                return Format_error;
        }
    }

    /* Read the `specifier`
     */
    Format specifier;
    const char sc = format[idx];
    genSpecifier = sc;
    switch (sc)
    {
        case 'd':
        case 'i':
            if (lm == 'L')
                specifier = Format_error;
            else
                specifier = lm == 'h' && lm2 ? Format_hhd :
                            lm == 'h'        ? Format_hd  :
                            lm == 'l' && lm2 ? Format_lld :
                            lm == 'l'        ? Format_ld  :
                            lm == 'j'        ? Format_jd  :
                            lm == 'z'        ? Format_zd  :
                            lm == 't'        ? Format_td  :
                                               Format_d;
            break;

        case 'u':
        case 'o':
        case 'x':
        case 'X':
            if (lm == 'L')
                specifier = Format_error;
            else
                specifier = lm == 'h' && lm2 ? Format_hhu :
                            lm == 'h'        ? Format_hu  :
                            lm == 'l' && lm2 ? Format_llu :
                            lm == 'l'        ? Format_lu  :
                            lm == 'j'        ? Format_ju  :
                            lm == 'z'        ? Format_zd  :
                            lm == 't'        ? Format_td  :
                                               Format_u;
            break;

        case 'a':
            if (useGNUExts)
            {
                // https://www.gnu.org/software/libc/manual/html_node/Dynamic-String-Input.html
                specifier = Format_GNU_a;
                break;
            }
            /* fall through */

        case 'f':
        case 'F':
        case 'e':
        case 'E':
        case 'g':
        case 'G':
        case 'A':
            if (lm == 'L')
                specifier = Format_Lg;
            else if (lm1 || lm2 || lm == 'h')
                specifier = Format_error;
            else
                specifier = lm == 'l' ? Format_lg : Format_g;
            break;

        case 'c':
            if (lm1 || lm2 || lm == 'h')
                specifier = Format_error;
            else
                specifier = lm == 'l' ? Format_lc : Format_c;
            break;

        case 's':
            if (lm1 || lm2 || lm == 'h')
                specifier = Format_error;
            else
                specifier = lm == 'l' ? Format_ls : Format_s;
            break;

        case 'p':
            if (lm1 || lm2 || lm == 'h' || lm == 'l')
                specifier = Format_error;
            else
                specifier = Format_p;
            break;

        case 'n':
            if (lm == 'L')
                specifier = Format_error;
            else
                specifier = lm == 'l' && lm2 ? Format_lln :
                            lm == 'l'        ? Format_ln  :
                            lm == 'h' && lm2 ? Format_hhn :
                            lm == 'h'        ? Format_hn  :
                            lm == 'j'        ? Format_jn  :
                            lm == 'z'        ? Format_zn  :
                            lm == 't'        ? Format_tn  :
                                               Format_n;
            break;

        case 'm':
            if (useGNUExts)
            {
                // http://www.gnu.org/software/libc/manual/html_node/Other-Output-Conversions.html
                specifier = Format_GNU_m;
                break;
            }
            goto Ldefault;

        default:
        Ldefault:
            specifier = Format_error;
            break;
    }

    ++idx;
    return specifier; // success
}

Format formatError(size_t &idx, size_t i)
{
    idx = i;
    return Format_error;
}

/**************************************
 * 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
 */
static Format parseScanfFormatSpecifier(const char *format, size_t &idx,
                bool &asterisk)
{
    asterisk = false;

    size_t i = idx;
    assert(format[i] == '%');
    const size_t length = strlen(format);

    ++i;
    if (i == length)
        return formatError(idx, i);

    if (format[i] == '%')
    {
        idx = i + 1;
        return Format_percent;
    }

    // * sub-specifier
    if (format[i] == '*')
    {
        ++i;
        if (i == length)
            return formatError(idx, i);
        asterisk = true;
    }

    // fieldWidth
    while (isdigit(format[i]))
    {
        i++;
        if (i == length)
            return formatError(idx, i);
    }

    /* Read the scanset
     * A scanset can be anything, so we just check that it is paired
     */
    if (format[i] == '[')
    {
        while (i < length)
        {
            if (format[i] == ']')
                break;
            ++i;
        }

        // no `]` found
        if (i == length)
            return formatError(idx, i);

        ++i;
        // no specifier after `]`
        // it could be mixed with the one above, but then idx won't have the right index
        if (i == length)
            return formatError(idx, i);
    }

    /* Read the specifier
     */
    char genSpec;
    Format specifier = parseGenericFormatSpecifier(format, i, genSpec);
    if (specifier == Format_error)
        return formatError(idx, i);

    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
 * Returns:
 *      Format
 */
static Format parsePrintfFormatSpecifier(const char *format, size_t &idx,
                bool &widthStar, bool &precisionStar)
{
    widthStar = false;
    precisionStar = false;

    size_t i = idx;
    assert(format[i] == '%');
    const size_t format_length = strlen(format);
    const size_t length = format_length;
    bool hash = false;
    bool zero = false;
    bool flags = false;
    bool width = false;
    bool precision = false;

    ++i;
    if (i == length)
        return formatError(idx, i);

    if (format[i] == '%')
    {
        idx = i + 1;
        return Format_percent;
    }

    /* Read the `flags`
     */
    while (1)
    {
        const char 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 formatError(idx, i);
    }

    /* Read the `field width`
     */
    {
        const char c = format[i];
        if (c == '*')
        {
            width = true;
            widthStar = true;
            ++i;
            if (i == length)
                return formatError(idx, i);
        }
        else if ('1' <= c && c <= '9')
        {
            width = true;
            ++i;
            if (i == length)
                return formatError(idx, i);
            while ('0' <= format[i] && format[i] <= '9')
            {
               ++i;
               if (i == length)
                    return formatError(idx, i);
            }
        }
    }

    /* Read the `precision`
     */
    if (format[i] == '.')
    {
        precision = true;
        ++i;
        if (i == length)
            return formatError(idx, i);
        const char c = format[i];
        if (c == '*')
        {
            precisionStar = true;
            ++i;
            if (i == length)
                return formatError(idx, i);
        }
        else if ('0' <= c && c <= '9')
        {
            ++i;
            if (i == length)
                return formatError(idx, i);
            while ('0' <= format[i] && format[i] <= '9')
            {
               ++i;
               if (i == length)
                    return formatError(idx, i);
            }
        }
    }

    /* Read the specifier
     */
    char genSpec;
    Format specifier = parseGenericFormatSpecifier(format, i, genSpec);
    if (specifier == Format_error)
        return formatError(idx, i);

    switch (genSpec)
    {
        case 'c':
        case 's':
            if (hash || zero)
                return formatError(idx, i);
            break;

        case 'd':
        case 'i':
            if (hash)
                return formatError(idx, i);
            break;

        case 'n':
            if (hash || zero || precision || width || flags)
                return formatError(idx, i);
            break;

        default:
            break;
    }

    idx = i;
    return specifier;  // success
}

/*******************************************/

static Expression *getNextPrintfArg(const Loc &loc, Expressions &args, size_t &n,
                size_t gnu_m_count, bool &skip)
{
    if (n == args.length)
    {
        if (args.length < (n + 1) - gnu_m_count)
            deprecation(loc, "more format specifiers than %d arguments", (int)n);
        else
            skip = true;
        return NULL;
    }
    return args[n++];
}

static void errorPrintfFormat(const char *prefix, DString &slice, 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(), (int)slice.length, slice.ptr, texpect, tactual->toChars());
}

/******************************************
 * 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
 * http://www.cplusplus.com/reference/cstdio/printf/
 */
bool checkPrintfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list)
{
    //printf("checkPrintFormat('%s')\n", format);
    size_t n = 0;             // index in args
    size_t gnu_m_count = 0;   // number of Format_GNU_m
    const size_t format_length = strlen(format);
    for (size_t i = 0; i < format_length;)
    {
        if (format[i] != '%')
        {
            ++i;
            continue;
        }
        bool widthStar = false;
        bool precisionStar = false;
        size_t j = i;
        const Format fmt = parsePrintfFormatSpecifier(format, j, widthStar, precisionStar);
        DString slice = DString(j - i, format + i);
        i = j;

        if (fmt == Format_percent)
            continue;                   // "%%", no arguments

        if (isVa_list)
        {
            // format check only
            if (fmt == Format_error)
                deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
            continue;
        }

        if (fmt == Format_GNU_m)
            ++gnu_m_count;

        if (widthStar)
        {
            bool skip = false;
            Expression *e = getNextPrintfArg(loc, args, n, gnu_m_count, skip);
            if (skip)
                continue;
            if (!e)
                return true;
            Type *t = e->type->toBasetype();
            if (t->ty != Tint32 && t->ty != Tuns32)
                errorPrintfFormat("width ", slice, e, "int", t);
        }

        if (precisionStar)
        {
            bool skip = false;
            Expression *e = getNextPrintfArg(loc, args, n, gnu_m_count, skip);
            if (skip)
                continue;
            if (!e)
                return true;
            Type *t = e->type->toBasetype();
            if (t->ty != Tint32 && t->ty != Tuns32)
                errorPrintfFormat("precision ", slice, e, "int", t);
        }

        bool skip = false;
        Expression *e = getNextPrintfArg(loc, args, n, gnu_m_count, skip);
        if (skip)
            continue;
        if (!e)
            return true;
        Type *t = e->type->toBasetype();
        Type *tnext = t->nextOf();
        const unsigned c_longsize = target.c.longsize;
        const unsigned ptrsize = target.ptrsize;

        // Types which are promoted to int are allowed.
        // Spec: C99 6.5.2.2.7
        switch (fmt)
        {
            case Format_u:      // unsigned int
            case Format_d:      // int
                if (t->ty != Tint32 && t->ty != Tuns32)
                    errorPrintfFormat(NULL, slice, 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)
                    errorPrintfFormat(NULL, slice, 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)
                    errorPrintfFormat(NULL, slice, 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)
                        errorPrintfFormat(NULL, slice, e, (c_longsize == 4 ? "uint" : "ulong"), t);
                    else
                        errorPrintfFormat(NULL, slice, 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)
                    errorPrintfFormat(NULL, slice, 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)
                        errorPrintfFormat(NULL, slice, e, "core.stdc.stdint.uintmax_t", t);
                    else
                        errorPrintfFormat(NULL, slice, e, "core.stdc.stdint.intmax_t", t);
                }
                break;

            case Format_zd:     // size_t
                if (!(t->isintegral() && t->size() == ptrsize))
                    errorPrintfFormat(NULL, slice, e, "size_t", t);
                break;

            case Format_td:     // ptrdiff_t
                if (!(t->isintegral() && t->size() == ptrsize))
                    errorPrintfFormat(NULL, slice, e, "ptrdiff_t", t);
                break;

            case Format_GNU_a:  // Format_GNU_a is only for scanf
            case Format_lg:
            case Format_g:      // double
                if (t->ty != Tfloat64 && t->ty != Timaginary64)
                    errorPrintfFormat(NULL, slice, e, "double", t);
                break;

            case Format_Lg:     // long double
                if (t->ty != Tfloat80 && t->ty != Timaginary80)
                    errorPrintfFormat(NULL, slice, e, "real", t);
                break;

            case Format_p:      // pointer
                if (t->ty != Tpointer && t->ty != Tnull && t->ty != Tclass && t->ty != Tdelegate && t->ty != Taarray)
                    errorPrintfFormat(NULL, slice, e, "void*", t);
                break;

            case Format_n:      // pointer to int
                if (!(t->ty == Tpointer && tnext->ty == Tint32))
                    errorPrintfFormat(NULL, slice, e, "int*", t);
                break;

            case Format_ln:     // pointer to long int
                if (!(t->ty == Tpointer && tnext->isintegral() && !tnext->isunsigned() && tnext->size() == c_longsize))
                    errorPrintfFormat(NULL, slice, e, (c_longsize == 4 ? "int*" : "long*"), t);
                break;

            case Format_lln:    // pointer to long long int
                if (!(t->ty == Tpointer && tnext->ty == Tint64))
                    errorPrintfFormat(NULL, slice, e, "long*", t);
                break;

            case Format_hn:     // pointer to short
                if (!(t->ty == Tpointer && tnext->ty == Tint16))
                    errorPrintfFormat(NULL, slice, e, "short*", t);
                break;

            case Format_hhn:    // pointer to signed char
                if (!(t->ty == Tpointer && tnext->ty == Tint16))
                    errorPrintfFormat(NULL, slice, e, "byte*", t);
                break;

            case Format_jn:     // pointer to intmax_t
                if (!(t->ty == Tpointer && tnext->ty == Tint64))
                    errorPrintfFormat(NULL, slice, 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))
                    errorPrintfFormat(NULL, slice, e, "size_t*", t);
                break;

            case Format_tn:     // pointer to ptrdiff_t
                if (!(t->ty == Tpointer && tnext->isintegral() && !tnext->isunsigned() && tnext->size() == ptrsize))
                    errorPrintfFormat(NULL, slice, e, "ptrdiff_t*", t);
                break;

            case Format_c:      // char
                if (t->ty != Tint32 && t->ty != Tuns32)
                    errorPrintfFormat(NULL, slice, e, "char", t);
                break;

            case Format_lc:     // wint_t
                if (t->ty != Tint32 && t->ty != Tuns32)
                    errorPrintfFormat(NULL, slice, 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)))
                    errorPrintfFormat(NULL, slice, e, "char*", t);
                break;

            case Format_ls:     // pointer to wchar_t string
            {
                if (!(t->ty == Tpointer && tnext == target.c.twchar_t))
                    errorPrintfFormat(NULL, slice, e, "wchar_t*", t);
                break;
            }
            case Format_error:
                deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
                break;

            case Format_GNU_m:
                break;  // not assert(0) because it may go through it if there are extra arguments

            case Format_percent:
            default:
                assert(0);
        }
    }
    return false;
}

/*******************************************/

static Expression *getNextScanfArg(const Loc &loc, Expressions &args, size_t &n, bool asterisk)
{
    if (n == args.length)
    {
        if (!asterisk)
            deprecation(loc, "more format specifiers than %d arguments", (int)n);
        return NULL;
    }
    return args[n++];
}

static void errorScanfFormat(const char *prefix, DString &slice,
                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(), (int)slice.length, slice.ptr, texpect, tactual->toChars());
}

/******************************************
 * 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
 * http://www.cplusplus.com/reference/cstdio/scanf/
 */
bool checkScanfFormat(const Loc &loc, const char *format, Expressions &args, bool isVa_list)
{
    size_t n = 0;
    const size_t format_length = strlen(format);
    for (size_t i = 0; i < format_length;)
    {
        if (format[i] != '%')
        {
            ++i;
            continue;
        }
        bool asterisk = false;
        size_t j = i;
        const Format fmt = parseScanfFormatSpecifier(format, j, asterisk);
        DString slice = DString(j - i, format + i);
        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", (int)slice.length, slice.ptr);
            continue;
        }

        Expression *e = getNextScanfArg(loc, args, n, asterisk);
        if (!e)
            return true;

        Type *t = e->type->toBasetype();
        Type *tnext = t->nextOf();
        const unsigned c_longsize = target.c.longsize;
        const unsigned ptrsize = target.ptrsize;

        switch (fmt)
        {
            case Format_n:
            case Format_d:      // pointer to int
                if (!(t->ty == Tpointer && tnext->ty == Tint32))
                    errorScanfFormat(NULL, slice, e, "int*", t);
                break;

            case Format_hhn:
            case Format_hhd:    // pointer to signed char
                if (!(t->ty == Tpointer && tnext->ty == Tint16))
                    errorScanfFormat(NULL, slice, e, "byte*", t);
                break;

            case Format_hn:
            case Format_hd:     // pointer to short
                if (!(t->ty == Tpointer && tnext->ty == Tint16))
                    errorScanfFormat(NULL, slice, e, "short*", t);
                break;

            case Format_ln:
            case Format_ld:     // pointer to long int
                if (!(t->ty == Tpointer && tnext->isintegral() && tnext->size() == c_longsize))
                    errorScanfFormat(NULL, slice, 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))
                    errorScanfFormat(NULL, slice, e, "long*", t);
                break;

            case Format_jn:
            case Format_jd:     // pointer to intmax_t
                if (!(t->ty == Tpointer && tnext->ty == Tint64))
                    errorScanfFormat(NULL, slice, 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))
                    errorScanfFormat(NULL, slice, 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))
                    errorScanfFormat(NULL, slice, e, "ptrdiff_t*", t);
                break;

            case Format_u:      // pointer to unsigned int
                if (!(t->ty == Tpointer && tnext->ty == Tuns32))
                    errorScanfFormat(NULL, slice, e, "uint*", t);
                break;

            case Format_hhu:    // pointer to unsigned char
                if (!(t->ty == Tpointer && tnext->ty == Tuns8))
                    errorScanfFormat(NULL, slice, e, "ubyte*", t);
                break;

            case Format_hu:     // pointer to unsigned short int
                if (!(t->ty == Tpointer && tnext->ty == Tuns16))
                    errorScanfFormat(NULL, slice, e, "ushort*", t);
                break;

            case Format_lu:     // pointer to unsigned long int
                if (!(t->ty == Tpointer && tnext->isintegral() && tnext->isunsigned() && tnext->size() == c_longsize))
                    errorScanfFormat(NULL, slice, e, (c_longsize == 4 ? "uint*" : "ulong*"), t);
                break;

            case Format_llu:    // pointer to unsigned long long int
                if (!(t->ty == Tpointer && tnext->ty == Tuns64))
                    errorScanfFormat(NULL, slice, e, "ulong*", t);
                break;

            case Format_ju:     // pointer to uintmax_t
                if (!(t->ty == Tpointer && tnext->ty == Tuns64))
                    errorScanfFormat(NULL, slice, e, "ulong*", t);
                break;

            case Format_g:      // pointer to float
                if (!(t->ty == Tpointer && tnext->ty == Tfloat32))
                    errorScanfFormat(NULL, slice, e, "float*", t);
                break;

            case Format_lg:     // pointer to double
                if (!(t->ty == Tpointer && tnext->ty == Tfloat64))
                    errorScanfFormat(NULL, slice, e, "double*", t);
                break;

            case Format_Lg:     // pointer to long double
                if (!(t->ty == Tpointer && tnext->ty == Tfloat80))
                    errorScanfFormat(NULL, slice, e, "real*", t);
                break;

            case Format_GNU_a:
            case Format_GNU_m:
            case Format_c:
            case Format_s:      // pointer to char string
                if (!(t->ty == Tpointer && (tnext->ty == Tchar || tnext->ty == Tint8 || tnext->ty == Tuns8)))
                    errorScanfFormat(NULL, slice, e, "char*", t);
                break;

            case Format_lc:
            case Format_ls:     // pointer to wchar_t string
            {
                if (!(t->ty == Tpointer && tnext == target.c.twchar_t))
                    errorScanfFormat(NULL, slice, e, "wchar_t*", t);
                break;
            }
            case Format_p:      // double pointer
                if (!(t->ty == Tpointer && tnext->ty == Tpointer))
                    errorScanfFormat(NULL, slice, e, "void**", t);
                break;

            case Format_error:
                deprecation(loc, "format specifier `\"%.*s\"` is invalid", (int)slice.length, slice.ptr);
                break;

            case Format_percent:
            default:
                assert(0);
        }
    }
    return false;
}