~ubuntu-branches/ubuntu/trusty/libnih/trusty

 

/* Skeleton implementation for Bison's Yacc-like parsers in C

   Free Software Foundation, Inc.

   it under the terms of the GNU General Public License as published by

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

 

/* As a special exception, you may create a larger work that contains

   part or all of the Bison parser skeleton and distribute that work

   special exception, which will cause the skeleton and the resulting

   Bison output files to be licensed under the GNU General Public

   License without this special exception.

   This special exception was added by the Free Software Foundation in

   version 2.2 of Bison.  */

 

#define YYBISON 1

 

/* Bison version.  */

 

/* Skeleton name.  */

#define YYSKELETON_NAME "yacc.c"

/* Pure parsers.  */

#define YYPURE 1

 

/* Using locations.  */

#define YYLSP_NEEDED 0

 

/* Substitute the variable and function names.  */

 

 

/* Copy the first part of user declarations.  */

#line 1 "plural.y"

 

/* Expression parsing for plural form selection.

#define YYPARSE_PARAM   arg

 

 

/* Enabling traces.  */

#ifndef YYDEBUG

# define YYDEBUG 0

 

#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED

typedef union YYSTYPE

#line 51 "plural.y"

 

  unsigned long int num;

  enum expression_operator op;

  struct expression *exp;

# define YYSTYPE_IS_TRIVIAL 1

# define yystype YYSTYPE /* obsolescent; will be withdrawn */

# define YYSTYPE_IS_DECLARED 1

#endif

 

 

/* Copy the second part of user declarations.  */

#line 57 "plural.y"

 

/* Prototypes for local functions.  */

}

 

 

 

#ifdef short

# undef short

/* A type that is properly aligned for any stack member.  */

union yyalloc

{

 

/* The size of the maximum gap between one aligned stack and the next.  */

# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

   elements in the stack, and YYPTR gives the new location of the

   stack.  Advance YYPTR to a properly aligned location for the next

   stack.  */

    do                                                                  \

      {                                                                 \

        YYSIZE_T yynewbytes;                                            \

        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

        yyptr += yynewbytes / sizeof (*yyptr);                          \

      }                                                                 \

  /* The symbols being reduced.  */

  for (yyi = 0; yyi < yynrhs; yyi++)

    {

      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],

                       &(yyvsp[(yyi + 1) - (yynrhs)])

                                       );

    }

}

 

        break;

    }

}

 

/* Prevent warnings from -Wmissing-prototypes.  */

#ifdef YYPARSE_PARAM

#if defined __STDC__ || defined __cplusplus

int yyparse (void *YYPARSE_PARAM);

 

 

 

 

#ifdef YYPARSE_PARAM

#if (defined __STDC__ || defined __C99__FUNC__ \

#endif

#endif

{

int yychar;

 

/* The semantic value of the lookahead symbol.  */

YYSTYPE yylval;

 

  int yyn;

  int yyresult;

  /* Lookahead token as an internal (translated) token number.  */

#if YYERROR_VERBOSE

  /* Buffer for error messages, and its allocated size.  */

  char yymsgbuf[128];

  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;

#endif

 

#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))

 

  /* The number of symbols on the RHS of the reduced rule.

     Keep to zero when no symbol should be popped.  */

  int yylen = 0;

 

  YYDPRINTF ((stderr, "Starting parse\n"));

 

  yystate = 0;

  yyerrstatus = 0;

  yynerrs = 0;

 

  /* Initialize stack pointers.

     Waste one element of value and location stack

     so that they stay on the same level as the state stack.

     The wasted elements are never initialized.  */

  yyssp = yyss;

  yyvsp = yyvs;

 

        YYSTYPE *yyvs1 = yyvs;

        yytype_int16 *yyss1 = yyss;

 

        /* Each stack pointer address is followed by the size of the

           data in use in that stack, in bytes.  This used to be a

           conditional around just the two extra args, but that might

        yyoverflow (YY_("memory exhausted"),

                    &yyss1, yysize * sizeof (*yyssp),

                    &yyvs1, yysize * sizeof (*yyvsp),

                    &yystacksize);

 

        yyss = yyss1;

          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));

        if (! yyptr)

          goto yyexhaustedlab;

#  undef YYSTACK_RELOCATE

        if (yyss1 != yyssa)

          YYSTACK_FREE (yyss1);

      yyssp = yyss + yysize - 1;

      yyvsp = yyvs + yysize - 1;

 

      YYDPRINTF ((stderr, "Stack size increased to %lu\n",

                  (unsigned long int) yystacksize));

 

  switch (yyn)

    {

        case 2:

#line 155 "plural.y"

    {

            if ((yyvsp[(1) - (1)].exp) == NULL)

    break;

 

  case 3:

#line 163 "plural.y"

    {

            (yyval.exp) = new_exp_3 (qmop, (yyvsp[(1) - (5)].exp), (yyvsp[(3) - (5)].exp), (yyvsp[(5) - (5)].exp));

    break;

 

  case 4:

#line 167 "plural.y"

    {

            (yyval.exp) = new_exp_2 (lor, (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));

    break;

 

  case 5:

#line 171 "plural.y"

    {

            (yyval.exp) = new_exp_2 (land, (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));

    break;

 

  case 6:

#line 175 "plural.y"

    {

            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));

    break;

 

  case 7:

#line 179 "plural.y"

    {

            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));

    break;

 

  case 8:

#line 183 "plural.y"

    {

            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));

    break;

 

  case 9:

#line 187 "plural.y"

    {

            (yyval.exp) = new_exp_2 ((yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].exp), (yyvsp[(3) - (3)].exp));

    break;

 

  case 10:

#line 191 "plural.y"

    {

            (yyval.exp) = new_exp_1 (lnot, (yyvsp[(2) - (2)].exp));

    break;

 

  case 11:

#line 195 "plural.y"

    {

            (yyval.exp) = new_exp_0 (var);

    break;

 

  case 12:

#line 199 "plural.y"

    {

            if (((yyval.exp) = new_exp_0 (num)) != NULL)

    break;

 

  case 13:

#line 204 "plural.y"

    {

            (yyval.exp) = (yyvsp[(2) - (3)].exp);

    break;

 

 

      default: break;

    }

  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

 

  *++yyvsp = yyval;

 

  /* Now `shift' the result of the reduction.  Determine what state

     that goes to, based on the state we popped back to and the rule

     number reduced by.  */

  yyresult = 1;

  goto yyreturn;

 

/*-------------------------------------------------.

| yyexhaustedlab -- memory exhaustion comes here.  |

`-------------------------------------------------*/

}

 

 

#line 209 "plural.y"