← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/pars/pars0grm.c

  • Committer: Brian Aker
  • Date: 2008-11-04 15:39:09 UTC
  • mfrom: (575.1.2 devel)
  • Revision ID: brian@tangent.org-20081104153909-c72hn65udxs1ccal
Merge of Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/pars/pars0grm.c
1
 
/* A Bison parser, made by GNU Bison 1.875d.  */
 
1
/* A Bison parser, made by GNU Bison 2.0.  */
2
2
 
3
3
/* Skeleton parser for Yacc-like parsing with Bison,
4
4
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
292
292
/* Copy the second part of user declarations.  */
293
293
 
294
294
 
295
 
/* Line 214 of yacc.c.  */
296
 
#line 297 "pars0grm.tab.c"
 
295
/* Line 213 of yacc.c.  */
 
296
#line 297 "pars0grm.c"
297
297
 
298
298
#if ! defined (yyoverflow) || YYERROR_VERBOSE
299
299
 
308
308
 
309
309
# ifdef YYSTACK_USE_ALLOCA
310
310
#  if YYSTACK_USE_ALLOCA
311
 
#   define YYSTACK_ALLOC alloca
312
 
#  endif
313
 
# else
314
 
#  if defined (alloca) || defined (_ALLOCA_H)
315
 
#   define YYSTACK_ALLOC alloca
316
 
#  else
317
311
#   ifdef __GNUC__
318
312
#    define YYSTACK_ALLOC __builtin_alloca
 
313
#   else
 
314
#    define YYSTACK_ALLOC alloca
319
315
#   endif
320
316
#  endif
321
317
# endif
1059
1055
    }                                                           \
1060
1056
while (0)
1061
1057
 
 
1058
 
1062
1059
#define YYTERROR        1
1063
1060
#define YYERRCODE       256
1064
1061
 
1065
 
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
1066
 
   are run).  */
1067
 
 
 
1062
 
 
1063
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 
1064
   If N is 0, then set CURRENT to the empty location which ends
 
1065
   the previous symbol: RHS[0] (always defined).  */
 
1066
 
 
1067
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1068
1068
#ifndef YYLLOC_DEFAULT
1069
 
# define YYLLOC_DEFAULT(Current, Rhs, N)                \
1070
 
   ((Current).first_line   = (Rhs)[1].first_line,       \
1071
 
    (Current).first_column = (Rhs)[1].first_column,     \
1072
 
    (Current).last_line    = (Rhs)[N].last_line,        \
1073
 
    (Current).last_column  = (Rhs)[N].last_column)
1074
 
#endif
 
1069
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
 
1070
    do                                                                  \
 
1071
      if (N)                                                            \
 
1072
        {                                                               \
 
1073
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
 
1074
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
 
1075
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
 
1076
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
 
1077
        }                                                               \
 
1078
      else                                                              \
 
1079
        {                                                               \
 
1080
          (Current).first_line   = (Current).last_line   =              \
 
1081
            YYRHSLOC (Rhs, 0).last_line;                                \
 
1082
          (Current).first_column = (Current).last_column =              \
 
1083
            YYRHSLOC (Rhs, 0).last_column;                              \
 
1084
        }                                                               \
 
1085
    while (0)
 
1086
#endif
 
1087
 
 
1088
 
 
1089
/* YY_LOCATION_PRINT -- Print the location on the stream.
 
1090
   This macro was not mandated originally: define only if we know
 
1091
   we won't break user code: when these are the locations we know.  */
 
1092
 
 
1093
#ifndef YY_LOCATION_PRINT
 
1094
# ifdef YYLTYPE_IS_TRIVIAL
 
1095
#  define YY_LOCATION_PRINT(File, Loc)                  \
 
1096
     fprintf (File, "%d.%d-%d.%d",                      \
 
1097
              (Loc).first_line, (Loc).first_column,     \
 
1098
              (Loc).last_line,  (Loc).last_column)
 
1099
# else
 
1100
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 
1101
# endif
 
1102
#endif
 
1103
 
1075
1104
 
1076
1105
/* YYLEX -- calling `yylex' with the right arguments.  */
1077
1106
 
1095
1124
    YYFPRINTF Args;                             \
1096
1125
} while (0)
1097
1126
 
1098
 
# define YYDSYMPRINT(Args)                      \
1099
 
do {                                            \
1100
 
  if (yydebug)                                  \
1101
 
    yysymprint Args;                            \
1102
 
} while (0)
1103
 
 
1104
 
# define YYDSYMPRINTF(Title, Token, Value, Location)            \
 
1127
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
1105
1128
do {                                                            \
1106
1129
  if (yydebug)                                                  \
1107
1130
    {                                                           \
1108
1131
      YYFPRINTF (stderr, "%s ", Title);                         \
1109
1132
      yysymprint (stderr,                                       \
1110
 
                  Token, Value);        \
 
1133
                  Type, Value); \
1111
1134
      YYFPRINTF (stderr, "\n");                                 \
1112
1135
    }                                                           \
1113
1136
} while (0)
1174
1197
int yydebug;
1175
1198
#else /* !YYDEBUG */
1176
1199
# define YYDPRINTF(Args)
1177
 
# define YYDSYMPRINT(Args)
1178
 
# define YYDSYMPRINTF(Title, Token, Value, Location)
 
1200
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1179
1201
# define YY_STACK_PRINT(Bottom, Top)
1180
1202
# define YY_REDUCE_PRINT(Rule)
1181
1203
#endif /* !YYDEBUG */
1193
1215
   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
1194
1216
   evaluated with infinite-precision integer arithmetic.  */
1195
1217
 
1196
 
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
1197
 
# undef YYMAXDEPTH
1198
 
#endif
1199
 
 
1200
1218
#ifndef YYMAXDEPTH
1201
1219
# define YYMAXDEPTH 10000
1202
1220
#endif
1278
1296
  (void) yyvaluep;
1279
1297
 
1280
1298
  if (yytype < YYNTOKENS)
1281
 
    {
1282
 
      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1283
 
# ifdef YYPRINT
1284
 
      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1285
 
# endif
1286
 
    }
 
1299
    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1287
1300
  else
1288
1301
    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1289
1302
 
 
1303
 
 
1304
# ifdef YYPRINT
 
1305
  if (yytype < YYNTOKENS)
 
1306
    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
 
1307
# endif
1290
1308
  switch (yytype)
1291
1309
    {
1292
1310
      default:
1302
1320
 
1303
1321
#if defined (__STDC__) || defined (__cplusplus)
1304
1322
static void
1305
 
yydestruct (int yytype, YYSTYPE *yyvaluep)
 
1323
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1306
1324
#else
1307
1325
static void
1308
 
yydestruct (yytype, yyvaluep)
 
1326
yydestruct (yymsg, yytype, yyvaluep)
 
1327
    const char *yymsg;
1309
1328
    int yytype;
1310
1329
    YYSTYPE *yyvaluep;
1311
1330
#endif
1313
1332
  /* Pacify ``unused variable'' warnings.  */
1314
1333
  (void) yyvaluep;
1315
1334
 
 
1335
  if (!yymsg)
 
1336
    yymsg = "Deleting";
 
1337
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
 
1338
 
1316
1339
  switch (yytype)
1317
1340
    {
1318
1341
 
1322
1345
}
1323
1346
 
1324
1347
 
1325
 
/* Prevent warnings from -Wmissing-prototypes.  */
1326
 
 
1327
 
#ifdef YYPARSE_PARAM
1328
 
# if defined (__STDC__) || defined (__cplusplus)
1329
 
int yyparse (void *YYPARSE_PARAM);
1330
 
# else
1331
 
int yyparse ();
1332
 
# endif
1333
 
#else /* ! YYPARSE_PARAM */
1334
 
#if defined (__STDC__) || defined (__cplusplus)
1335
 
int yyparse (void);
1336
 
#else
1337
 
int yyparse ();
1338
 
#endif
1339
 
#endif /* ! YYPARSE_PARAM */
1340
 
 
1341
 
 
1342
 
 
1343
 
/* The lookahead symbol.  */
1344
 
int yychar;
1345
 
 
1346
 
/* The semantic value of the lookahead symbol.  */
1347
 
YYSTYPE yylval;
 
1348
 
 
1349
/* The look-ahead symbol.  */
 
1350
static int yychar;
 
1351
 
 
1352
/* The semantic value of the look-ahead symbol.  */
 
1353
UNIV_INTERN YYSTYPE yylval;
1348
1354
 
1349
1355
/* Number of syntax errors so far.  */
1350
 
int yynerrs;
 
1356
static int yynerrs;
1351
1357
 
1352
1358
 
1353
1359
 
1357
1363
 
1358
1364
#ifdef YYPARSE_PARAM
1359
1365
# if defined (__STDC__) || defined (__cplusplus)
1360
 
int yyparse (void *YYPARSE_PARAM)
 
1366
UNIV_INTERN int yyparse (void *YYPARSE_PARAM)
1361
1367
# else
1362
 
int yyparse (YYPARSE_PARAM)
 
1368
UNIV_INTERN int yyparse (YYPARSE_PARAM)
1363
1369
  void *YYPARSE_PARAM;
1364
1370
# endif
1365
1371
#else /* ! YYPARSE_PARAM */
1379
1385
  int yyresult;
1380
1386
  /* Number of tokens to shift before error messages enabled.  */
1381
1387
  int yyerrstatus;
1382
 
  /* Lookahead token as an internal (translated) token number.  */
 
1388
  /* Look-ahead token as an internal (translated) token number.  */
1383
1389
  int yytoken = 0;
1384
1390
 
1385
1391
  /* Three stacks and their tools:
1431
1437
  yyvsp = yyvs;
1432
1438
 
1433
1439
 
 
1440
  yyvsp[0] = yylval;
 
1441
 
1434
1442
  goto yysetstate;
1435
1443
 
1436
1444
/*------------------------------------------------------------.
1520
1528
yybackup:
1521
1529
 
1522
1530
/* Do appropriate processing given the current state.  */
1523
 
/* Read a lookahead token if we need one and don't already have one.  */
 
1531
/* Read a look-ahead token if we need one and don't already have one.  */
1524
1532
/* yyresume: */
1525
1533
 
1526
 
  /* First try to decide what to do without reference to lookahead token.  */
 
1534
  /* First try to decide what to do without reference to look-ahead token.  */
1527
1535
 
1528
1536
  yyn = yypact[yystate];
1529
1537
  if (yyn == YYPACT_NINF)
1530
1538
    goto yydefault;
1531
1539
 
1532
 
  /* Not known => get a lookahead token if don't already have one.  */
 
1540
  /* Not known => get a look-ahead token if don't already have one.  */
1533
1541
 
1534
 
  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
 
1542
  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1535
1543
  if (yychar == YYEMPTY)
1536
1544
    {
1537
1545
      YYDPRINTF ((stderr, "Reading a token: "));
1546
1554
  else
1547
1555
    {
1548
1556
      yytoken = YYTRANSLATE (yychar);
1549
 
      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
 
1557
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1550
1558
    }
1551
1559
 
1552
1560
  /* If the proper action on seeing token YYTOKEN is to reduce or to
1566
1574
  if (yyn == YYFINAL)
1567
1575
    YYACCEPT;
1568
1576
 
1569
 
  /* Shift the lookahead token.  */
1570
 
  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
 
1577
  /* Shift the look-ahead token.  */
 
1578
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1571
1579
 
1572
1580
  /* Discard the token being shifted unless it is eof.  */
1573
1581
  if (yychar != YYEOF)
1618
1626
    {
1619
1627
        case 25:
1620
1628
#line 166 "pars0grm.y"
1621
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
1629
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
1622
1630
    break;
1623
1631
 
1624
1632
  case 26:
1625
1633
#line 168 "pars0grm.y"
1626
 
    { yyval = que_node_list_add_last(yyvsp[-1], yyvsp[0]); ;}
 
1634
    { (yyval) = que_node_list_add_last((yyvsp[-1]), (yyvsp[0])); ;}
1627
1635
    break;
1628
1636
 
1629
1637
  case 27:
1630
1638
#line 172 "pars0grm.y"
1631
 
    { yyval = yyvsp[0];;}
 
1639
    { (yyval) = (yyvsp[0]);;}
1632
1640
    break;
1633
1641
 
1634
1642
  case 28:
1635
1643
#line 174 "pars0grm.y"
1636
 
    { yyval = pars_func(yyvsp[-3], yyvsp[-1]); ;}
 
1644
    { (yyval) = pars_func((yyvsp[-3]), (yyvsp[-1])); ;}
1637
1645
    break;
1638
1646
 
1639
1647
  case 29:
1640
1648
#line 175 "pars0grm.y"
1641
 
    { yyval = yyvsp[0];;}
 
1649
    { (yyval) = (yyvsp[0]);;}
1642
1650
    break;
1643
1651
 
1644
1652
  case 30:
1645
1653
#line 176 "pars0grm.y"
1646
 
    { yyval = yyvsp[0];;}
 
1654
    { (yyval) = (yyvsp[0]);;}
1647
1655
    break;
1648
1656
 
1649
1657
  case 31:
1650
1658
#line 177 "pars0grm.y"
1651
 
    { yyval = yyvsp[0];;}
 
1659
    { (yyval) = (yyvsp[0]);;}
1652
1660
    break;
1653
1661
 
1654
1662
  case 32:
1655
1663
#line 178 "pars0grm.y"
1656
 
    { yyval = yyvsp[0];;}
 
1664
    { (yyval) = (yyvsp[0]);;}
1657
1665
    break;
1658
1666
 
1659
1667
  case 33:
1660
1668
#line 179 "pars0grm.y"
1661
 
    { yyval = yyvsp[0];;}
 
1669
    { (yyval) = (yyvsp[0]);;}
1662
1670
    break;
1663
1671
 
1664
1672
  case 34:
1665
1673
#line 180 "pars0grm.y"
1666
 
    { yyval = yyvsp[0];;}
 
1674
    { (yyval) = (yyvsp[0]);;}
1667
1675
    break;
1668
1676
 
1669
1677
  case 35:
1670
1678
#line 181 "pars0grm.y"
1671
 
    { yyval = yyvsp[0];;}
 
1679
    { (yyval) = (yyvsp[0]);;}
1672
1680
    break;
1673
1681
 
1674
1682
  case 36:
1675
1683
#line 182 "pars0grm.y"
1676
 
    { yyval = pars_op('+', yyvsp[-2], yyvsp[0]); ;}
 
1684
    { (yyval) = pars_op('+', (yyvsp[-2]), (yyvsp[0])); ;}
1677
1685
    break;
1678
1686
 
1679
1687
  case 37:
1680
1688
#line 183 "pars0grm.y"
1681
 
    { yyval = pars_op('-', yyvsp[-2], yyvsp[0]); ;}
 
1689
    { (yyval) = pars_op('-', (yyvsp[-2]), (yyvsp[0])); ;}
1682
1690
    break;
1683
1691
 
1684
1692
  case 38:
1685
1693
#line 184 "pars0grm.y"
1686
 
    { yyval = pars_op('*', yyvsp[-2], yyvsp[0]); ;}
 
1694
    { (yyval) = pars_op('*', (yyvsp[-2]), (yyvsp[0])); ;}
1687
1695
    break;
1688
1696
 
1689
1697
  case 39:
1690
1698
#line 185 "pars0grm.y"
1691
 
    { yyval = pars_op('/', yyvsp[-2], yyvsp[0]); ;}
 
1699
    { (yyval) = pars_op('/', (yyvsp[-2]), (yyvsp[0])); ;}
1692
1700
    break;
1693
1701
 
1694
1702
  case 40:
1695
1703
#line 186 "pars0grm.y"
1696
 
    { yyval = pars_op('-', yyvsp[0], NULL); ;}
 
1704
    { (yyval) = pars_op('-', (yyvsp[0]), NULL); ;}
1697
1705
    break;
1698
1706
 
1699
1707
  case 41:
1700
1708
#line 187 "pars0grm.y"
1701
 
    { yyval = yyvsp[-1]; ;}
 
1709
    { (yyval) = (yyvsp[-1]); ;}
1702
1710
    break;
1703
1711
 
1704
1712
  case 42:
1705
1713
#line 188 "pars0grm.y"
1706
 
    { yyval = pars_op('=', yyvsp[-2], yyvsp[0]); ;}
 
1714
    { (yyval) = pars_op('=', (yyvsp[-2]), (yyvsp[0])); ;}
1707
1715
    break;
1708
1716
 
1709
1717
  case 43:
1710
1718
#line 189 "pars0grm.y"
1711
 
    { yyval = pars_op('<', yyvsp[-2], yyvsp[0]); ;}
 
1719
    { (yyval) = pars_op('<', (yyvsp[-2]), (yyvsp[0])); ;}
1712
1720
    break;
1713
1721
 
1714
1722
  case 44:
1715
1723
#line 190 "pars0grm.y"
1716
 
    { yyval = pars_op('>', yyvsp[-2], yyvsp[0]); ;}
 
1724
    { (yyval) = pars_op('>', (yyvsp[-2]), (yyvsp[0])); ;}
1717
1725
    break;
1718
1726
 
1719
1727
  case 45:
1720
1728
#line 191 "pars0grm.y"
1721
 
    { yyval = pars_op(PARS_GE_TOKEN, yyvsp[-2], yyvsp[0]); ;}
 
1729
    { (yyval) = pars_op(PARS_GE_TOKEN, (yyvsp[-2]), (yyvsp[0])); ;}
1722
1730
    break;
1723
1731
 
1724
1732
  case 46:
1725
1733
#line 192 "pars0grm.y"
1726
 
    { yyval = pars_op(PARS_LE_TOKEN, yyvsp[-2], yyvsp[0]); ;}
 
1734
    { (yyval) = pars_op(PARS_LE_TOKEN, (yyvsp[-2]), (yyvsp[0])); ;}
1727
1735
    break;
1728
1736
 
1729
1737
  case 47:
1730
1738
#line 193 "pars0grm.y"
1731
 
    { yyval = pars_op(PARS_NE_TOKEN, yyvsp[-2], yyvsp[0]); ;}
 
1739
    { (yyval) = pars_op(PARS_NE_TOKEN, (yyvsp[-2]), (yyvsp[0])); ;}
1732
1740
    break;
1733
1741
 
1734
1742
  case 48:
1735
1743
#line 194 "pars0grm.y"
1736
 
    { yyval = pars_op(PARS_AND_TOKEN, yyvsp[-2], yyvsp[0]); ;}
 
1744
    { (yyval) = pars_op(PARS_AND_TOKEN, (yyvsp[-2]), (yyvsp[0])); ;}
1737
1745
    break;
1738
1746
 
1739
1747
  case 49:
1740
1748
#line 195 "pars0grm.y"
1741
 
    { yyval = pars_op(PARS_OR_TOKEN, yyvsp[-2], yyvsp[0]); ;}
 
1749
    { (yyval) = pars_op(PARS_OR_TOKEN, (yyvsp[-2]), (yyvsp[0])); ;}
1742
1750
    break;
1743
1751
 
1744
1752
  case 50:
1745
1753
#line 196 "pars0grm.y"
1746
 
    { yyval = pars_op(PARS_NOT_TOKEN, yyvsp[0], NULL); ;}
 
1754
    { (yyval) = pars_op(PARS_NOT_TOKEN, (yyvsp[0]), NULL); ;}
1747
1755
    break;
1748
1756
 
1749
1757
  case 51:
1750
1758
#line 198 "pars0grm.y"
1751
 
    { yyval = pars_op(PARS_NOTFOUND_TOKEN, yyvsp[-2], NULL); ;}
 
1759
    { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[-2]), NULL); ;}
1752
1760
    break;
1753
1761
 
1754
1762
  case 52:
1755
1763
#line 200 "pars0grm.y"
1756
 
    { yyval = pars_op(PARS_NOTFOUND_TOKEN, yyvsp[-2], NULL); ;}
 
1764
    { (yyval) = pars_op(PARS_NOTFOUND_TOKEN, (yyvsp[-2]), NULL); ;}
1757
1765
    break;
1758
1766
 
1759
1767
  case 53:
1760
1768
#line 204 "pars0grm.y"
1761
 
    { yyval = &pars_to_char_token; ;}
 
1769
    { (yyval) = &pars_to_char_token; ;}
1762
1770
    break;
1763
1771
 
1764
1772
  case 54:
1765
1773
#line 205 "pars0grm.y"
1766
 
    { yyval = &pars_to_number_token; ;}
 
1774
    { (yyval) = &pars_to_number_token; ;}
1767
1775
    break;
1768
1776
 
1769
1777
  case 55:
1770
1778
#line 206 "pars0grm.y"
1771
 
    { yyval = &pars_to_binary_token; ;}
 
1779
    { (yyval) = &pars_to_binary_token; ;}
1772
1780
    break;
1773
1781
 
1774
1782
  case 56:
1775
1783
#line 208 "pars0grm.y"
1776
 
    { yyval = &pars_binary_to_number_token; ;}
 
1784
    { (yyval) = &pars_binary_to_number_token; ;}
1777
1785
    break;
1778
1786
 
1779
1787
  case 57:
1780
1788
#line 209 "pars0grm.y"
1781
 
    { yyval = &pars_substr_token; ;}
 
1789
    { (yyval) = &pars_substr_token; ;}
1782
1790
    break;
1783
1791
 
1784
1792
  case 58:
1785
1793
#line 210 "pars0grm.y"
1786
 
    { yyval = &pars_concat_token; ;}
 
1794
    { (yyval) = &pars_concat_token; ;}
1787
1795
    break;
1788
1796
 
1789
1797
  case 59:
1790
1798
#line 211 "pars0grm.y"
1791
 
    { yyval = &pars_instr_token; ;}
 
1799
    { (yyval) = &pars_instr_token; ;}
1792
1800
    break;
1793
1801
 
1794
1802
  case 60:
1795
1803
#line 212 "pars0grm.y"
1796
 
    { yyval = &pars_length_token; ;}
 
1804
    { (yyval) = &pars_length_token; ;}
1797
1805
    break;
1798
1806
 
1799
1807
  case 61:
1800
1808
#line 213 "pars0grm.y"
1801
 
    { yyval = &pars_sysdate_token; ;}
 
1809
    { (yyval) = &pars_sysdate_token; ;}
1802
1810
    break;
1803
1811
 
1804
1812
  case 62:
1805
1813
#line 214 "pars0grm.y"
1806
 
    { yyval = &pars_rnd_token; ;}
 
1814
    { (yyval) = &pars_rnd_token; ;}
1807
1815
    break;
1808
1816
 
1809
1817
  case 63:
1810
1818
#line 215 "pars0grm.y"
1811
 
    { yyval = &pars_rnd_str_token; ;}
 
1819
    { (yyval) = &pars_rnd_str_token; ;}
1812
1820
    break;
1813
1821
 
1814
1822
  case 67:
1815
1823
#line 226 "pars0grm.y"
1816
 
    { yyval = pars_stored_procedure_call(yyvsp[-4]); ;}
 
1824
    { (yyval) = pars_stored_procedure_call((yyvsp[-4])); ;}
1817
1825
    break;
1818
1826
 
1819
1827
  case 68:
1820
1828
#line 231 "pars0grm.y"
1821
 
    { yyval = pars_procedure_call(yyvsp[-3], yyvsp[-1]); ;}
 
1829
    { (yyval) = pars_procedure_call((yyvsp[-3]), (yyvsp[-1])); ;}
1822
1830
    break;
1823
1831
 
1824
1832
  case 69:
1825
1833
#line 235 "pars0grm.y"
1826
 
    { yyval = &pars_replstr_token; ;}
 
1834
    { (yyval) = &pars_replstr_token; ;}
1827
1835
    break;
1828
1836
 
1829
1837
  case 70:
1830
1838
#line 236 "pars0grm.y"
1831
 
    { yyval = &pars_printf_token; ;}
 
1839
    { (yyval) = &pars_printf_token; ;}
1832
1840
    break;
1833
1841
 
1834
1842
  case 71:
1835
1843
#line 237 "pars0grm.y"
1836
 
    { yyval = &pars_assert_token; ;}
 
1844
    { (yyval) = &pars_assert_token; ;}
1837
1845
    break;
1838
1846
 
1839
1847
  case 72:
1840
1848
#line 241 "pars0grm.y"
1841
 
    { yyval = yyvsp[-2]; ;}
 
1849
    { (yyval) = (yyvsp[-2]); ;}
1842
1850
    break;
1843
1851
 
1844
1852
  case 73:
1845
1853
#line 245 "pars0grm.y"
1846
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
1854
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
1847
1855
    break;
1848
1856
 
1849
1857
  case 74:
1850
1858
#line 247 "pars0grm.y"
1851
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
1859
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
1852
1860
    break;
1853
1861
 
1854
1862
  case 75:
1855
1863
#line 251 "pars0grm.y"
1856
 
    { yyval = NULL; ;}
 
1864
    { (yyval) = NULL; ;}
1857
1865
    break;
1858
1866
 
1859
1867
  case 76:
1860
1868
#line 252 "pars0grm.y"
1861
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
1869
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
1862
1870
    break;
1863
1871
 
1864
1872
  case 77:
1865
1873
#line 254 "pars0grm.y"
1866
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
1874
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
1867
1875
    break;
1868
1876
 
1869
1877
  case 78:
1870
1878
#line 258 "pars0grm.y"
1871
 
    { yyval = NULL; ;}
 
1879
    { (yyval) = NULL; ;}
1872
1880
    break;
1873
1881
 
1874
1882
  case 79:
1875
1883
#line 259 "pars0grm.y"
1876
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]);;}
 
1884
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0]));;}
1877
1885
    break;
1878
1886
 
1879
1887
  case 80:
1880
1888
#line 260 "pars0grm.y"
1881
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
1889
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
1882
1890
    break;
1883
1891
 
1884
1892
  case 81:
1885
1893
#line 264 "pars0grm.y"
1886
 
    { yyval = yyvsp[0]; ;}
 
1894
    { (yyval) = (yyvsp[0]); ;}
1887
1895
    break;
1888
1896
 
1889
1897
  case 82:
1890
1898
#line 266 "pars0grm.y"
1891
 
    { yyval = pars_func(&pars_count_token,
 
1899
    { (yyval) = pars_func(&pars_count_token,
1892
1900
                                          que_node_list_add_last(NULL,
1893
1901
                                            sym_tab_add_int_lit(
1894
1902
                                                pars_sym_tab_global, 1))); ;}
1896
1904
 
1897
1905
  case 83:
1898
1906
#line 271 "pars0grm.y"
1899
 
    { yyval = pars_func(&pars_count_token,
 
1907
    { (yyval) = pars_func(&pars_count_token,
1900
1908
                                            que_node_list_add_last(NULL,
1901
1909
                                                pars_func(&pars_distinct_token,
1902
1910
                                                     que_node_list_add_last(
1903
 
                                                                NULL, yyvsp[-1])))); ;}
 
1911
                                                                NULL, (yyvsp[-1]))))); ;}
1904
1912
    break;
1905
1913
 
1906
1914
  case 84:
1907
1915
#line 277 "pars0grm.y"
1908
 
    { yyval = pars_func(&pars_sum_token,
 
1916
    { (yyval) = pars_func(&pars_sum_token,
1909
1917
                                                que_node_list_add_last(NULL,
1910
 
                                                                        yyvsp[-1])); ;}
 
1918
                                                                        (yyvsp[-1]))); ;}
1911
1919
    break;
1912
1920
 
1913
1921
  case 85:
1914
1922
#line 283 "pars0grm.y"
1915
 
    { yyval = NULL; ;}
 
1923
    { (yyval) = NULL; ;}
1916
1924
    break;
1917
1925
 
1918
1926
  case 86:
1919
1927
#line 284 "pars0grm.y"
1920
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
1928
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
1921
1929
    break;
1922
1930
 
1923
1931
  case 87:
1924
1932
#line 286 "pars0grm.y"
1925
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
1933
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
1926
1934
    break;
1927
1935
 
1928
1936
  case 88:
1929
1937
#line 290 "pars0grm.y"
1930
 
    { yyval = pars_select_list(&pars_star_denoter,
 
1938
    { (yyval) = pars_select_list(&pars_star_denoter,
1931
1939
                                                                NULL); ;}
1932
1940
    break;
1933
1941
 
1934
1942
  case 89:
1935
1943
#line 293 "pars0grm.y"
1936
 
    { yyval = pars_select_list(yyvsp[-2], yyvsp[0]); ;}
 
1944
    { (yyval) = pars_select_list((yyvsp[-2]), (yyvsp[0])); ;}
1937
1945
    break;
1938
1946
 
1939
1947
  case 90:
1940
1948
#line 294 "pars0grm.y"
1941
 
    { yyval = pars_select_list(yyvsp[0], NULL); ;}
 
1949
    { (yyval) = pars_select_list((yyvsp[0]), NULL); ;}
1942
1950
    break;
1943
1951
 
1944
1952
  case 91:
1945
1953
#line 298 "pars0grm.y"
1946
 
    { yyval = NULL; ;}
 
1954
    { (yyval) = NULL; ;}
1947
1955
    break;
1948
1956
 
1949
1957
  case 92:
1950
1958
#line 299 "pars0grm.y"
1951
 
    { yyval = yyvsp[0]; ;}
 
1959
    { (yyval) = (yyvsp[0]); ;}
1952
1960
    break;
1953
1961
 
1954
1962
  case 93:
1955
1963
#line 303 "pars0grm.y"
1956
 
    { yyval = NULL; ;}
 
1964
    { (yyval) = NULL; ;}
1957
1965
    break;
1958
1966
 
1959
1967
  case 94:
1960
1968
#line 305 "pars0grm.y"
1961
 
    { yyval = &pars_update_token; ;}
 
1969
    { (yyval) = &pars_update_token; ;}
1962
1970
    break;
1963
1971
 
1964
1972
  case 95:
1965
1973
#line 309 "pars0grm.y"
1966
 
    { yyval = NULL; ;}
 
1974
    { (yyval) = NULL; ;}
1967
1975
    break;
1968
1976
 
1969
1977
  case 96:
1973
1981
 
1974
1982
  case 97:
1975
1983
#line 315 "pars0grm.y"
1976
 
    { yyval = &pars_asc_token; ;}
 
1984
    { (yyval) = &pars_asc_token; ;}
1977
1985
    break;
1978
1986
 
1979
1987
  case 98:
1980
1988
#line 316 "pars0grm.y"
1981
 
    { yyval = &pars_asc_token; ;}
 
1989
    { (yyval) = &pars_asc_token; ;}
1982
1990
    break;
1983
1991
 
1984
1992
  case 99:
1985
1993
#line 317 "pars0grm.y"
1986
 
    { yyval = &pars_desc_token; ;}
 
1994
    { (yyval) = &pars_desc_token; ;}
1987
1995
    break;
1988
1996
 
1989
1997
  case 100:
1990
1998
#line 321 "pars0grm.y"
1991
 
    { yyval = NULL; ;}
 
1999
    { (yyval) = NULL; ;}
1992
2000
    break;
1993
2001
 
1994
2002
  case 101:
1995
2003
#line 323 "pars0grm.y"
1996
 
    { yyval = pars_order_by(yyvsp[-1], yyvsp[0]); ;}
 
2004
    { (yyval) = pars_order_by((yyvsp[-1]), (yyvsp[0])); ;}
1997
2005
    break;
1998
2006
 
1999
2007
  case 102:
2000
2008
#line 332 "pars0grm.y"
2001
 
    { yyval = pars_select_statement(yyvsp[-6], yyvsp[-4], yyvsp[-3],
2002
 
                                                                yyvsp[-2], yyvsp[-1], yyvsp[0]); ;}
 
2009
    { (yyval) = pars_select_statement((yyvsp[-6]), (yyvsp[-4]), (yyvsp[-3]),
 
2010
                                                                (yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])); ;}
2003
2011
    break;
2004
2012
 
2005
2013
  case 103:
2006
2014
#line 338 "pars0grm.y"
2007
 
    { yyval = yyvsp[0]; ;}
 
2015
    { (yyval) = (yyvsp[0]); ;}
2008
2016
    break;
2009
2017
 
2010
2018
  case 104:
2011
2019
#line 343 "pars0grm.y"
2012
 
    { yyval = pars_insert_statement(yyvsp[-4], yyvsp[-1], NULL); ;}
 
2020
    { (yyval) = pars_insert_statement((yyvsp[-4]), (yyvsp[-1]), NULL); ;}
2013
2021
    break;
2014
2022
 
2015
2023
  case 105:
2016
2024
#line 345 "pars0grm.y"
2017
 
    { yyval = pars_insert_statement(yyvsp[-1], NULL, yyvsp[0]); ;}
 
2025
    { (yyval) = pars_insert_statement((yyvsp[-1]), NULL, (yyvsp[0])); ;}
2018
2026
    break;
2019
2027
 
2020
2028
  case 106:
2021
2029
#line 349 "pars0grm.y"
2022
 
    { yyval = pars_column_assignment(yyvsp[-2], yyvsp[0]); ;}
 
2030
    { (yyval) = pars_column_assignment((yyvsp[-2]), (yyvsp[0])); ;}
2023
2031
    break;
2024
2032
 
2025
2033
  case 107:
2026
2034
#line 353 "pars0grm.y"
2027
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
2035
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
2028
2036
    break;
2029
2037
 
2030
2038
  case 108:
2031
2039
#line 355 "pars0grm.y"
2032
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
2040
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
2033
2041
    break;
2034
2042
 
2035
2043
  case 109:
2036
2044
#line 361 "pars0grm.y"
2037
 
    { yyval = yyvsp[0]; ;}
 
2045
    { (yyval) = (yyvsp[0]); ;}
2038
2046
    break;
2039
2047
 
2040
2048
  case 110:
2041
2049
#line 367 "pars0grm.y"
2042
 
    { yyval = pars_update_statement_start(FALSE,
2043
 
                                                                yyvsp[-2], yyvsp[0]); ;}
 
2050
    { (yyval) = pars_update_statement_start(FALSE,
 
2051
                                                                (yyvsp[-2]), (yyvsp[0])); ;}
2044
2052
    break;
2045
2053
 
2046
2054
  case 111:
2047
2055
#line 373 "pars0grm.y"
2048
 
    { yyval = pars_update_statement(yyvsp[-1], NULL, yyvsp[0]); ;}
 
2056
    { (yyval) = pars_update_statement((yyvsp[-1]), NULL, (yyvsp[0])); ;}
2049
2057
    break;
2050
2058
 
2051
2059
  case 112:
2052
2060
#line 378 "pars0grm.y"
2053
 
    { yyval = pars_update_statement(yyvsp[-1], yyvsp[0], NULL); ;}
 
2061
    { (yyval) = pars_update_statement((yyvsp[-1]), (yyvsp[0]), NULL); ;}
2054
2062
    break;
2055
2063
 
2056
2064
  case 113:
2057
2065
#line 383 "pars0grm.y"
2058
 
    { yyval = pars_update_statement_start(TRUE,
2059
 
                                                                yyvsp[0], NULL); ;}
 
2066
    { (yyval) = pars_update_statement_start(TRUE,
 
2067
                                                                (yyvsp[0]), NULL); ;}
2060
2068
    break;
2061
2069
 
2062
2070
  case 114:
2063
2071
#line 389 "pars0grm.y"
2064
 
    { yyval = pars_update_statement(yyvsp[-1], NULL, yyvsp[0]); ;}
 
2072
    { (yyval) = pars_update_statement((yyvsp[-1]), NULL, (yyvsp[0])); ;}
2065
2073
    break;
2066
2074
 
2067
2075
  case 115:
2068
2076
#line 394 "pars0grm.y"
2069
 
    { yyval = pars_update_statement(yyvsp[-1], yyvsp[0], NULL); ;}
 
2077
    { (yyval) = pars_update_statement((yyvsp[-1]), (yyvsp[0]), NULL); ;}
2070
2078
    break;
2071
2079
 
2072
2080
  case 116:
2073
2081
#line 399 "pars0grm.y"
2074
 
    { yyval = pars_row_printf_statement(yyvsp[0]); ;}
 
2082
    { (yyval) = pars_row_printf_statement((yyvsp[0])); ;}
2075
2083
    break;
2076
2084
 
2077
2085
  case 117:
2078
2086
#line 404 "pars0grm.y"
2079
 
    { yyval = pars_assignment_statement(yyvsp[-2], yyvsp[0]); ;}
 
2087
    { (yyval) = pars_assignment_statement((yyvsp[-2]), (yyvsp[0])); ;}
2080
2088
    break;
2081
2089
 
2082
2090
  case 118:
2083
2091
#line 410 "pars0grm.y"
2084
 
    { yyval = pars_elsif_element(yyvsp[-2], yyvsp[0]); ;}
 
2092
    { (yyval) = pars_elsif_element((yyvsp[-2]), (yyvsp[0])); ;}
2085
2093
    break;
2086
2094
 
2087
2095
  case 119:
2088
2096
#line 414 "pars0grm.y"
2089
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
2097
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
2090
2098
    break;
2091
2099
 
2092
2100
  case 120:
2093
2101
#line 416 "pars0grm.y"
2094
 
    { yyval = que_node_list_add_last(yyvsp[-1], yyvsp[0]); ;}
 
2102
    { (yyval) = que_node_list_add_last((yyvsp[-1]), (yyvsp[0])); ;}
2095
2103
    break;
2096
2104
 
2097
2105
  case 121:
2098
2106
#line 420 "pars0grm.y"
2099
 
    { yyval = NULL; ;}
 
2107
    { (yyval) = NULL; ;}
2100
2108
    break;
2101
2109
 
2102
2110
  case 122:
2103
2111
#line 422 "pars0grm.y"
2104
 
    { yyval = yyvsp[0]; ;}
 
2112
    { (yyval) = (yyvsp[0]); ;}
2105
2113
    break;
2106
2114
 
2107
2115
  case 123:
2108
2116
#line 423 "pars0grm.y"
2109
 
    { yyval = yyvsp[0]; ;}
 
2117
    { (yyval) = (yyvsp[0]); ;}
2110
2118
    break;
2111
2119
 
2112
2120
  case 124:
2113
2121
#line 430 "pars0grm.y"
2114
 
    { yyval = pars_if_statement(yyvsp[-5], yyvsp[-3], yyvsp[-2]); ;}
 
2122
    { (yyval) = pars_if_statement((yyvsp[-5]), (yyvsp[-3]), (yyvsp[-2])); ;}
2115
2123
    break;
2116
2124
 
2117
2125
  case 125:
2118
2126
#line 436 "pars0grm.y"
2119
 
    { yyval = pars_while_statement(yyvsp[-4], yyvsp[-2]); ;}
 
2127
    { (yyval) = pars_while_statement((yyvsp[-4]), (yyvsp[-2])); ;}
2120
2128
    break;
2121
2129
 
2122
2130
  case 126:
2123
2131
#line 444 "pars0grm.y"
2124
 
    { yyval = pars_for_statement(yyvsp[-8], yyvsp[-6], yyvsp[-4], yyvsp[-2]); ;}
 
2132
    { (yyval) = pars_for_statement((yyvsp[-8]), (yyvsp[-6]), (yyvsp[-4]), (yyvsp[-2])); ;}
2125
2133
    break;
2126
2134
 
2127
2135
  case 127:
2128
2136
#line 448 "pars0grm.y"
2129
 
    { yyval = pars_exit_statement(); ;}
 
2137
    { (yyval) = pars_exit_statement(); ;}
2130
2138
    break;
2131
2139
 
2132
2140
  case 128:
2133
2141
#line 452 "pars0grm.y"
2134
 
    { yyval = pars_return_statement(); ;}
 
2142
    { (yyval) = pars_return_statement(); ;}
2135
2143
    break;
2136
2144
 
2137
2145
  case 129:
2138
2146
#line 457 "pars0grm.y"
2139
 
    { yyval = pars_open_statement(
2140
 
                                                ROW_SEL_OPEN_CURSOR, yyvsp[0]); ;}
 
2147
    { (yyval) = pars_open_statement(
 
2148
                                                ROW_SEL_OPEN_CURSOR, (yyvsp[0])); ;}
2141
2149
    break;
2142
2150
 
2143
2151
  case 130:
2144
2152
#line 463 "pars0grm.y"
2145
 
    { yyval = pars_open_statement(
2146
 
                                                ROW_SEL_CLOSE_CURSOR, yyvsp[0]); ;}
 
2153
    { (yyval) = pars_open_statement(
 
2154
                                                ROW_SEL_CLOSE_CURSOR, (yyvsp[0])); ;}
2147
2155
    break;
2148
2156
 
2149
2157
  case 131:
2150
2158
#line 469 "pars0grm.y"
2151
 
    { yyval = pars_fetch_statement(yyvsp[-2], yyvsp[0], NULL); ;}
 
2159
    { (yyval) = pars_fetch_statement((yyvsp[-2]), (yyvsp[0]), NULL); ;}
2152
2160
    break;
2153
2161
 
2154
2162
  case 132:
2155
2163
#line 471 "pars0grm.y"
2156
 
    { yyval = pars_fetch_statement(yyvsp[-2], NULL, yyvsp[0]); ;}
 
2164
    { (yyval) = pars_fetch_statement((yyvsp[-2]), NULL, (yyvsp[0])); ;}
2157
2165
    break;
2158
2166
 
2159
2167
  case 133:
2160
2168
#line 476 "pars0grm.y"
2161
 
    { yyval = pars_column_def(yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;}
 
2169
    { (yyval) = pars_column_def((yyvsp[-4]), (yyvsp[-3]), (yyvsp[-2]), (yyvsp[-1]), (yyvsp[0])); ;}
2162
2170
    break;
2163
2171
 
2164
2172
  case 134:
2165
2173
#line 480 "pars0grm.y"
2166
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
2174
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
2167
2175
    break;
2168
2176
 
2169
2177
  case 135:
2170
2178
#line 482 "pars0grm.y"
2171
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
2179
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
2172
2180
    break;
2173
2181
 
2174
2182
  case 136:
2175
2183
#line 486 "pars0grm.y"
2176
 
    { yyval = NULL; ;}
 
2184
    { (yyval) = NULL; ;}
2177
2185
    break;
2178
2186
 
2179
2187
  case 137:
2180
2188
#line 488 "pars0grm.y"
2181
 
    { yyval = yyvsp[-1]; ;}
 
2189
    { (yyval) = (yyvsp[-1]); ;}
2182
2190
    break;
2183
2191
 
2184
2192
  case 138:
2185
2193
#line 492 "pars0grm.y"
2186
 
    { yyval = NULL; ;}
 
2194
    { (yyval) = NULL; ;}
2187
2195
    break;
2188
2196
 
2189
2197
  case 139:
2190
2198
#line 494 "pars0grm.y"
2191
 
    { yyval = &pars_int_token;
 
2199
    { (yyval) = &pars_int_token;
2192
2200
                                        /* pass any non-NULL pointer */ ;}
2193
2201
    break;
2194
2202
 
2195
2203
  case 140:
2196
2204
#line 499 "pars0grm.y"
2197
 
    { yyval = NULL; ;}
 
2205
    { (yyval) = NULL; ;}
2198
2206
    break;
2199
2207
 
2200
2208
  case 141:
2201
2209
#line 501 "pars0grm.y"
2202
 
    { yyval = &pars_int_token;
 
2210
    { (yyval) = &pars_int_token;
2203
2211
                                        /* pass any non-NULL pointer */ ;}
2204
2212
    break;
2205
2213
 
2206
2214
  case 142:
2207
2215
#line 506 "pars0grm.y"
2208
 
    { yyval = NULL; ;}
 
2216
    { (yyval) = NULL; ;}
2209
2217
    break;
2210
2218
 
2211
2219
  case 143:
2212
2220
#line 508 "pars0grm.y"
2213
 
    { yyval = &pars_int_token;
 
2221
    { (yyval) = &pars_int_token;
2214
2222
                                        /* pass any non-NULL pointer */ ;}
2215
2223
    break;
2216
2224
 
2217
2225
  case 144:
2218
2226
#line 515 "pars0grm.y"
2219
 
    { yyval = pars_create_table(yyvsp[-4], yyvsp[-2], yyvsp[0]); ;}
 
2227
    { (yyval) = pars_create_table((yyvsp[-4]), (yyvsp[-2]), (yyvsp[0])); ;}
2220
2228
    break;
2221
2229
 
2222
2230
  case 145:
2223
2231
#line 519 "pars0grm.y"
2224
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
2232
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
2225
2233
    break;
2226
2234
 
2227
2235
  case 146:
2228
2236
#line 521 "pars0grm.y"
2229
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
2237
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
2230
2238
    break;
2231
2239
 
2232
2240
  case 147:
2233
2241
#line 525 "pars0grm.y"
2234
 
    { yyval = NULL; ;}
 
2242
    { (yyval) = NULL; ;}
2235
2243
    break;
2236
2244
 
2237
2245
  case 148:
2238
2246
#line 526 "pars0grm.y"
2239
 
    { yyval = &pars_unique_token; ;}
 
2247
    { (yyval) = &pars_unique_token; ;}
2240
2248
    break;
2241
2249
 
2242
2250
  case 149:
2243
2251
#line 530 "pars0grm.y"
2244
 
    { yyval = NULL; ;}
 
2252
    { (yyval) = NULL; ;}
2245
2253
    break;
2246
2254
 
2247
2255
  case 150:
2248
2256
#line 531 "pars0grm.y"
2249
 
    { yyval = &pars_clustered_token; ;}
 
2257
    { (yyval) = &pars_clustered_token; ;}
2250
2258
    break;
2251
2259
 
2252
2260
  case 151:
2253
2261
#line 539 "pars0grm.y"
2254
 
    { yyval = pars_create_index(yyvsp[-8], yyvsp[-7], yyvsp[-5], yyvsp[-3], yyvsp[-1]); ;}
 
2262
    { (yyval) = pars_create_index((yyvsp[-8]), (yyvsp[-7]), (yyvsp[-5]), (yyvsp[-3]), (yyvsp[-1])); ;}
2255
2263
    break;
2256
2264
 
2257
2265
  case 152:
2258
2266
#line 544 "pars0grm.y"
2259
 
    { yyval = pars_commit_statement(); ;}
 
2267
    { (yyval) = pars_commit_statement(); ;}
2260
2268
    break;
2261
2269
 
2262
2270
  case 153:
2263
2271
#line 549 "pars0grm.y"
2264
 
    { yyval = pars_rollback_statement(); ;}
 
2272
    { (yyval) = pars_rollback_statement(); ;}
2265
2273
    break;
2266
2274
 
2267
2275
  case 154:
2268
2276
#line 553 "pars0grm.y"
2269
 
    { yyval = &pars_int_token; ;}
 
2277
    { (yyval) = &pars_int_token; ;}
2270
2278
    break;
2271
2279
 
2272
2280
  case 155:
2273
2281
#line 554 "pars0grm.y"
2274
 
    { yyval = &pars_int_token; ;}
 
2282
    { (yyval) = &pars_int_token; ;}
2275
2283
    break;
2276
2284
 
2277
2285
  case 156:
2278
2286
#line 555 "pars0grm.y"
2279
 
    { yyval = &pars_char_token; ;}
 
2287
    { (yyval) = &pars_char_token; ;}
2280
2288
    break;
2281
2289
 
2282
2290
  case 157:
2283
2291
#line 556 "pars0grm.y"
2284
 
    { yyval = &pars_binary_token; ;}
 
2292
    { (yyval) = &pars_binary_token; ;}
2285
2293
    break;
2286
2294
 
2287
2295
  case 158:
2288
2296
#line 557 "pars0grm.y"
2289
 
    { yyval = &pars_blob_token; ;}
 
2297
    { (yyval) = &pars_blob_token; ;}
2290
2298
    break;
2291
2299
 
2292
2300
  case 159:
2293
2301
#line 562 "pars0grm.y"
2294
 
    { yyval = pars_parameter_declaration(yyvsp[-2],
2295
 
                                                        PARS_INPUT, yyvsp[0]); ;}
 
2302
    { (yyval) = pars_parameter_declaration((yyvsp[-2]),
 
2303
                                                        PARS_INPUT, (yyvsp[0])); ;}
2296
2304
    break;
2297
2305
 
2298
2306
  case 160:
2299
2307
#line 565 "pars0grm.y"
2300
 
    { yyval = pars_parameter_declaration(yyvsp[-2],
2301
 
                                                        PARS_OUTPUT, yyvsp[0]); ;}
 
2308
    { (yyval) = pars_parameter_declaration((yyvsp[-2]),
 
2309
                                                        PARS_OUTPUT, (yyvsp[0])); ;}
2302
2310
    break;
2303
2311
 
2304
2312
  case 161:
2305
2313
#line 570 "pars0grm.y"
2306
 
    { yyval = NULL; ;}
 
2314
    { (yyval) = NULL; ;}
2307
2315
    break;
2308
2316
 
2309
2317
  case 162:
2310
2318
#line 571 "pars0grm.y"
2311
 
    { yyval = que_node_list_add_last(NULL, yyvsp[0]); ;}
 
2319
    { (yyval) = que_node_list_add_last(NULL, (yyvsp[0])); ;}
2312
2320
    break;
2313
2321
 
2314
2322
  case 163:
2315
2323
#line 573 "pars0grm.y"
2316
 
    { yyval = que_node_list_add_last(yyvsp[-2], yyvsp[0]); ;}
 
2324
    { (yyval) = que_node_list_add_last((yyvsp[-2]), (yyvsp[0])); ;}
2317
2325
    break;
2318
2326
 
2319
2327
  case 164:
2320
2328
#line 578 "pars0grm.y"
2321
 
    { yyval = pars_variable_declaration(yyvsp[-2], yyvsp[-1]); ;}
 
2329
    { (yyval) = pars_variable_declaration((yyvsp[-2]), (yyvsp[-1])); ;}
2322
2330
    break;
2323
2331
 
2324
2332
  case 168:
2325
2333
#line 590 "pars0grm.y"
2326
 
    { yyval = pars_cursor_declaration(yyvsp[-3], yyvsp[-1]); ;}
 
2334
    { (yyval) = pars_cursor_declaration((yyvsp[-3]), (yyvsp[-1])); ;}
2327
2335
    break;
2328
2336
 
2329
2337
  case 169:
2330
2338
#line 595 "pars0grm.y"
2331
 
    { yyval = pars_function_declaration(yyvsp[-1]); ;}
 
2339
    { (yyval) = pars_function_declaration((yyvsp[-1])); ;}
2332
2340
    break;
2333
2341
 
2334
2342
  case 175:
2335
2343
#line 616 "pars0grm.y"
2336
 
    { yyval = pars_procedure_definition(yyvsp[-9], yyvsp[-7],
2337
 
                                                                yyvsp[-1]); ;}
 
2344
    { (yyval) = pars_procedure_definition((yyvsp[-9]), (yyvsp[-7]),
 
2345
                                                                (yyvsp[-1])); ;}
2338
2346
    break;
2339
2347
 
2340
2348
 
2341
2349
    }
2342
2350
 
2343
2351
/* Line 1010 of yacc.c.  */
2344
 
#line 2345 "pars0grm.tab.c"
 
2352
#line 2345 "pars0grm.c"
2345
2353
 
2346
2354
  yyvsp -= yylen;
2347
2355
  yyssp -= yylen;
2441
2449
 
2442
2450
  if (yyerrstatus == 3)
2443
2451
    {
2444
 
      /* If just tried and failed to reuse lookahead token after an
 
2452
      /* If just tried and failed to reuse look-ahead token after an
2445
2453
         error, discard it.  */
2446
2454
 
2447
2455
      if (yychar <= YYEOF)
2451
2459
          if (yychar == YYEOF)
2452
2460
             for (;;)
2453
2461
               {
 
2462
 
2454
2463
                 YYPOPSTACK;
2455
2464
                 if (yyssp == yyss)
2456
2465
                   YYABORT;
2457
 
                 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
2458
 
                 yydestruct (yystos[*yyssp], yyvsp);
 
2466
                 yydestruct ("Error: popping",
 
2467
                             yystos[*yyssp], yyvsp);
2459
2468
               }
2460
2469
        }
2461
2470
      else
2462
2471
        {
2463
 
          YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
2464
 
          yydestruct (yytoken, &yylval);
 
2472
          yydestruct ("Error: discarding", yytoken, &yylval);
2465
2473
          yychar = YYEMPTY;
2466
 
 
2467
2474
        }
2468
2475
    }
2469
2476
 
2470
 
  /* Else will try to reuse lookahead token after shifting the error
 
2477
  /* Else will try to reuse look-ahead token after shifting the error
2471
2478
     token.  */
2472
2479
  goto yyerrlab1;
2473
2480
 
2484
2491
     goto yyerrorlab;
2485
2492
#endif
2486
2493
 
2487
 
  yyvsp -= yylen;
 
2494
yyvsp -= yylen;
2488
2495
  yyssp -= yylen;
2489
2496
  yystate = *yyssp;
2490
2497
  goto yyerrlab1;
2514
2521
      if (yyssp == yyss)
2515
2522
        YYABORT;
2516
2523
 
2517
 
      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
2518
 
      yydestruct (yystos[yystate], yyvsp);
 
2524
 
 
2525
      yydestruct ("Error: popping", yystos[yystate], yyvsp);
2519
2526
      YYPOPSTACK;
2520
2527
      yystate = *yyssp;
2521
2528
      YY_STACK_PRINT (yyss, yyssp);
2524
2531
  if (yyn == YYFINAL)
2525
2532
    YYACCEPT;
2526
2533
 
2527
 
  YYDPRINTF ((stderr, "Shifting error token, "));
2528
 
 
2529
2534
  *++yyvsp = yylval;
2530
2535
 
2531
2536
 
 
2537
  /* Shift the error token. */
 
2538
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
 
2539
 
2532
2540
  yystate = yyn;
2533
2541
  goto yynewstate;
2534
2542
 
2544
2552
| yyabortlab -- YYABORT comes here.  |
2545
2553
`-----------------------------------*/
2546
2554
yyabortlab:
 
2555
  yydestruct ("Error: discarding lookahead",
 
2556
              yytoken, &yylval);
 
2557
  yychar = YYEMPTY;
2547
2558
  yyresult = 1;
2548
2559
  goto yyreturn;
2549
2560