openbmc/build/tmp/deploy/sdk/witherspoon-2019-08-08/sysroots/armv6-openbmc-linux-gnueabi/usr/src/debug/libnl/1_3.4.0-r0/build/lib/route/cls/ematch_syntax.c
static int yysyntax_error(YYSIZE_T* yymsg_alloc, char** yymsg,
                          yytype_int16* yyssp, int yytoken)
{
    YYSIZE_T yysize0 = yytnamerr(YY_NULLPTR, yytname[yytoken]);
    YYSIZE_T yysize = yysize0;
    enum
    {
        YYERROR_VERBOSE_ARGS_MAXIMUM = 5
    };
    /* Internationalized format string. */
    const char* yyformat = YY_NULLPTR;
    /* Arguments of yyformat. */
    char const* yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    /* Number of reported tokens (one for the "unexpected", one per
       "expected"). */
    int yycount = 0;

    /* There are many possibilities here to consider:
       - If this state is a consistent state with a default action, then
         the only way this function was invoked is if the default action
         is an error action.  In that case, don't check for expected
         tokens because there are none.
       - The only way there can be no lookahead present (in yychar) is if
         this state is a consistent state with a default action.  Thus,
         detecting the absence of a lookahead is sufficient to determine
         that there is no unexpected or expected token to report.  In that
         case, just report a simple "syntax error".
       - Don't assume there isn't a lookahead just because this state is a
         consistent state with a default action.  There might have been a
         previous inconsistent state, consistent state with a non-default
         action, or user semantic action that manipulated yychar.
       - Of course, the expected token list depends on states to have
         correct lookahead information, and it depends on the parser not
         to perform extra reductions after fetching a lookahead from the
         scanner and before detecting a syntax error.  Thus, state merging
         (from LALR or IELR) and default reductions corrupt the expected
         token list.  However, the list is correct for canonical LR with
         one exception: it will still contain any token that will not be
         accepted due to an error action in a later state.
    */
    if (yytoken != YYEMPTY)
    {
        int yyn = yypact[*yyssp];
        yyarg[yycount++] = yytname[yytoken];
        if (!yypact_value_is_default(yyn))
        {
            /* Start YYX at -YYN if negative to avoid negative indexes in
               YYCHECK.  In other words, skip the first -YYN actions for
               this state because they are default actions.  */
            int yyxbegin = yyn < 0 ? -yyn : 0;
            /* Stay within bounds of both yycheck and yytname.  */
            int yychecklim = YYLAST - yyn + 1;
            int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
            int yyx;

            for (yyx = yyxbegin; yyx < yyxend; ++yyx)
                if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR &&
                    !yytable_value_is_error(yytable[yyx + yyn]))
                {
                    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                    {
                        yycount = 1;
                        yysize = yysize0;
                        break;
                    }
                    yyarg[yycount++] = yytname[yyx];
                    {
                        YYSIZE_T yysize1 =
                            yysize + yytnamerr(YY_NULLPTR, yytname[yyx]);
                        if (yysize <= yysize1 &&
                            yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                            yysize = yysize1;
                        else
                            return 2;
                    }
                }
        }
    }

    switch (yycount)
    {
#define YYCASE_(N, S)                                                          \
    case N:                                                                    \
        yyformat = S;                                                          \
        break
        default: /* Avoid compiler warnings. */
            YYCASE_(0, YY_("syntax error"));
            YYCASE_(1, YY_("syntax error, unexpected %s"));
            YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
            YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
            YYCASE_(
                4,
                YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
            YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or "
                           "%s or %s"));
#undef YYCASE_
    }

    {
        YYSIZE_T yysize1 = yysize + yystrlen(yyformat);
        if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
            yysize = yysize1;
        else
            return 2;
    }

    if (*yymsg_alloc < yysize)
    {
        *yymsg_alloc = 2 * yysize;
        if (!(yysize <= *yymsg_alloc && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
            *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
        return 1;
    }

    /* Avoid sprintf, as that infringes on the user's name space.
       Don't have undefined behavior even if the translation
       produced a string with the wrong number of "%s"s.  */
    {
        char* yyp = *yymsg;
        int yyi = 0;
        while ((*yyp = *yyformat) != '\0')
            if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
            {
                yyp += yytnamerr(yyp, yyarg[yyi++]);
                yyformat += 2;
            }
            else
            {
                yyp++;
                yyformat++;
            }
    }
    return 0;
}
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
   about the unexpected token YYTOKEN for the state stack whose top is
   YYSSP.

   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
   not large enough to hold the message.  In that case, also set
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
   required number of bytes is too large to store.  */
Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.

Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
not large enough to hold the message.  In that case, also set
YYMSG_ALLOC to the required number of bytes.  Return 2 if the
required number of bytes is too large to store.
Copy into * YYMSG which is of size * YYMSG_ALLOC an error message about the unexpected token YYTOKEN for the state stack whose top is YYSSP . Return 0 if * YYMSG was successfully written . Return 1 if * YYMSG is not large enough to hold the message . In that case also set YYMSG_ALLOC to the required number of bytes . Return 2 if the required number of bytes is too large to store .
static int yysyntax_error(YYSIZE_T* yymsg_alloc, char** yymsg,
                          yytype_int16* yyssp, int yytoken)
{
    YYSIZE_T yysize0 = yytnamerr(YY_NULLPTR, yytname[yytoken]);
    YYSIZE_T yysize = yysize0;
    enum
    {
        YYERROR_VERBOSE_ARGS_MAXIMUM = 5
    };
    const char* yyformat = YY_NULLPTR;
    char const* yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    int yycount = 0;
    if (yytoken != YYEMPTY)
    {
        int yyn = yypact[*yyssp];
        yyarg[yycount++] = yytname[yytoken];
        if (!yypact_value_is_default(yyn))
        {
            int yyxbegin = yyn < 0 ? -yyn : 0;
            int yychecklim = YYLAST - yyn + 1;
            int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
            int yyx;
            for (yyx = yyxbegin; yyx < yyxend; ++yyx)
                if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR &&
                    !yytable_value_is_error(yytable[yyx + yyn]))
                {
                    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                    {
                        yycount = 1;
                        yysize = yysize0;
                        break;
                    }
                    yyarg[yycount++] = yytname[yyx];
                    {
                        YYSIZE_T yysize1 =
                            yysize + yytnamerr(YY_NULLPTR, yytname[yyx]);
                        if (yysize <= yysize1 &&
                            yysize1 <= YYSTACK_ALLOC_MAXIMUM)
                            yysize = yysize1;
                        else
                            return 2;
                    }
                }
        }
    }
    switch (yycount)
    {
#define YYCASE_(N, S)                                                          \
    case N:                                                                    \
        yyformat = S;                                                          \
        break
        default: 
            YYCASE_(0, YY_("syntax error"));
            YYCASE_(1, YY_("syntax error, unexpected %s"));
            YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
            YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
            YYCASE_(
                4,
                YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
            YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or "
                           "%s or %s"));
#undef YYCASE_
    }
    {
        YYSIZE_T yysize1 = yysize + yystrlen(yyformat);
        if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
            yysize = yysize1;
        else
            return 2;
    }
    if (*yymsg_alloc < yysize)
    {
        *yymsg_alloc = 2 * yysize;
        if (!(yysize <= *yymsg_alloc && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
            *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
        return 1;
    }
    {
        char* yyp = *yymsg;
        int yyi = 0;
        while ((*yyp = *yyformat) != '\0')
            if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
            {
                yyp += yytnamerr(yyp, yyarg[yyi++]);
                yyformat += 2;
            }
            else
            {
                yyp++;
                yyformat++;
            }
    }
    return 0;
}
static int yysyntax_error ( YYSIZE_T * yymsg_alloc , char * * yymsg , yytype_int16 * yyssp , int yytoken ) { YYSIZE_T yysize0 = yytnamerr ( YY_NULLPTR , yytname [ yytoken ] ) ; YYSIZE_T yysize = yysize0 ; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 } ; const char * yyformat = YY_NULLPTR ; char const * yyarg [ YYERROR_VERBOSE_ARGS_MAXIMUM ] ; int yycount = 0 ; if ( yytoken != YYEMPTY ) { int yyn = yypact [ * yyssp ] ; yyarg [ yycount ++ ] = yytname [ yytoken ] ; if ( ! yypact_value_is_default ( yyn ) ) { int yyxbegin = yyn < 0 ? - yyn : 0 ; int yychecklim = YYLAST - yyn + 1 ; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS ; int yyx ; for ( yyx = yyxbegin ; yyx < yyxend ; ++ yyx ) if ( yycheck [ yyx + yyn ] == yyx && yyx != YYTERROR && ! yytable_value_is_error ( yytable [ yyx + yyn ] ) ) { if ( yycount == YYERROR_VERBOSE_ARGS_MAXIMUM ) { yycount = 1 ; yysize = yysize0 ; break ; } yyarg [ yycount ++ ] = yytname [ yyx ] ; { YYSIZE_T yysize1 = yysize + yytnamerr ( YY_NULLPTR , yytname [ yyx ] ) ; if ( yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM ) yysize = yysize1 ; else return 2 ; } } } } switch ( yycount ) { #define YYCASE_ ( N , S )                                                           \
    case N:                                                                    \
        yyformat = S;                                                          \
        break default : YYCASE_ ( 0 , YY_ ( " " ) ) ; YYCASE_ ( 1 , YY_ ( " " ) ) ; YYCASE_ ( 2 , YY_ ( " " ) ) ; YYCASE_ ( 3 , YY_ ( " " ) ) ; YYCASE_ ( 4 , YY_ ( " " ) ) ; YYCASE_ ( 5 , YY_ ( " " " " ) ) ; #undef  YYCASE_ } { YYSIZE_T yysize1 = yysize + yystrlen ( yyformat ) ; if ( yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM ) yysize = yysize1 ; else return 2 ; } if ( * yymsg_alloc < yysize ) { * yymsg_alloc = 2 * yysize ; if ( ! ( yysize <= * yymsg_alloc && * yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM ) ) * yymsg_alloc = YYSTACK_ALLOC_MAXIMUM ; return 1 ; } { char * yyp = * yymsg ; int yyi = 0 ; while ( ( * yyp = * yyformat ) != ' \0 ' ) if ( * yyp == ' ' && yyformat [ 1 ] == ' ' && yyi < yycount ) { yyp += yytnamerr ( yyp , yyarg [ yyi ++ ] ) ; yyformat += 2 ; } else { yyp ++ ; yyformat ++ ; } } return 0 ; }
Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.
Copy into * YYMSG which is of size * YYMSG_ALLOC an error message about the unexpected token YYTOKEN for the state stack whose top is YYSSP .
/* Internationalized format string. */ /* Arguments of yyformat. */ /* Number of reported tokens (one for the "unexpected", one per
       "expected"). */ /* There are many possibilities here to consider:
       - If this state is a consistent state with a default action, then
         the only way this function was invoked is if the default action
         is an error action.  In that case, don't check for expected
         tokens because there are none.
       - The only way there can be no lookahead present (in yychar) is if
         this state is a consistent state with a default action.  Thus,
         detecting the absence of a lookahead is sufficient to determine
         that there is no unexpected or expected token to report.  In that
         case, just report a simple "syntax error".
       - Don't assume there isn't a lookahead just because this state is a
         consistent state with a default action.  There might have been a
         previous inconsistent state, consistent state with a non-default
         action, or user semantic action that manipulated yychar.
       - Of course, the expected token list depends on states to have
         correct lookahead information, and it depends on the parser not
         to perform extra reductions after fetching a lookahead from the
         scanner and before detecting a syntax error.  Thus, state merging
         (from LALR or IELR) and default reductions corrupt the expected
         token list.  However, the list is correct for canonical LR with
         one exception: it will still contain any token that will not be
         accepted due to an error action in a later state.
    */ /* Start YYX at -YYN if negative to avoid negative indexes in
               YYCHECK.  In other words, skip the first -YYN actions for
               this state because they are default actions.  */ /* Stay within bounds of both yycheck and yytname.  */ /* Avoid compiler warnings. */ /* Avoid sprintf, as that infringes on the user's name space.
       Don't have undefined behavior even if the translation
       produced a string with the wrong number of "%s"s.  */