← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

Renamed strings to mystrings, for include/lib naming consistency.

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