app/willard/parser.cc

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //  This file is generated automatically using Prop (version 2.3.5),
   3 //  last updated on Jun 18, 1997.
   4 //  The original source file is "parser.pcc".
   5 ///////////////////////////////////////////////////////////////////////////////
   6
   7 #define PROP_REWRITING_USED
   8 #define PROP_PRINTER_USED
   9 #define PROP_REGEXP_MATCHING_USED
  10 #define PROP_STRCMP_USED
  11 #define PROP_PARSER_USED
  12 #define PROP_QUARK_USED
  13 #define PROP_TUPLE2_USED
  14 #include <propdefs.h>
  15 #line 1 "parser.pcc"
  16 #include "willard-ast.h"
  17 #include "parser.h"
  18 #include "paige.h"
  19 #include <AD/strings/quark.h>
  20
  21 #line 6 "parser.pcc"
  22 #line 14 "parser.pcc"
  23 enum Tokens {
  24    XX_t_r_u_eXX = 256, XX_f_a_l_s_eXX = 257, XX_i_nXX = 258,
  25    XX_a_n_dXX = 259, XX_o_rXX = 260, XX_n_o_tXX = 261,
  26    XX_f_o_r_a_l_lXX = 262, XX_e_x_i_s_t_sXX = 263, XX_l_e_tXX = 264,
  27    XX_e_n_dXX = 265, XXhlXX = 266, XXhnXX = 267,
  28    XXcpXX = 268, XXckXX = 269, XXclXX = 270,
  29    XXcnXX = 271, XXciXX = 272, XXcjXX = 273,
  30    XXflXX = 274, XXfnXX = 275, XXdnXX = 276,
  31    XXcpdnXX = 277, XXdmXX = 278, XXdoXX = 279,
  32    XXdmdnXX = 280, XXdodnXX = 281, XXhmXX = 282,
  33    XXcdXX = 283, XXcmXX = 284, XXdlXX = 285,
  34    XXdkXX = 286, XXcoXX = 287, INTEGER = 288,
  35    IDENT = 289
  36 };
  37
  38
  39
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42 //
  43 //  Pretty printing methods for Tokens
  44 //
  45 ///////////////////////////////////////////////////////////////////////////////
  46 class PrettyOStream;
  47 extern ostream& operator<<(ostream&, Tokens);
  48 extern PrettyOStream& operator<<(PrettyOStream&, Tokens);
  49 #line 14 "parser.pcc"
  50 #line 14 "parser.pcc"
  51
  52
  53 //
  54 //  Method to get a token from the lexer stream
  55 //
  56 int QueryParser::get_token()
  57 {
  58 #line 20 "parser.pcc"
  59 #line 23 "parser.pcc"
  60 {
  61    for (;;) {
  62       {
  63 static const DFATables::Offset _X1_base [ 66 ] = {
  64    0, 0, 0, 0, 0, 0, 34, 164, 163, 163, 163, 163, 18, 7, 162, 0,
  65    0, 162, 0, 160, 0, 0, 160, 37, 0, 11, 0, 0, 0, 0, 0, 0,
  66    49, 0, 145, 0, 145, 144, 0, 144, 144, 144, 144, 142, 0, 0, 0, 77,
  67    124, 142, 0, 0, 142, 132, 88, 0, 0, 0, 57, 27, 21, 21, 0, 14,
  68    0, 0
  69 };
  70 static const DFATables::State _X1_check [ 211 ] = {
  71    0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
  72    1, 0, 1, 1, 1, 1, 1, 1, 25, 1, 1, 25, 1, 1, 1, 1,
  73    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 13, 1, 1, 1, 6,
  74    12, 13, 6, 32, 23, 63, 32, 12, 61, 6, 23, 59, 0, 60, 6, 6,
  75    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 47, 47, 47,
  76    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 58, 47, 47, 47,
  77    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
  78    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 54,
  79    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
  80    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
  81    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 53, 52, 43, 49, 42,
  82    22, 0, 41, 40, 0, 19, 39, 17, 37, 36, 34, 0, 0, 0, 0, 0,
  83    0, 0, 0, 10, 0, 0, 14, 11, 9, 8, 7, 0, 0, 0, 0, 0,
  84    0, 0, 0
  85 };
  86 static const DFATables::State _X1_next [ 211 ] = {
  87    0, 0, 32, 33, 0, 32, 31, 30, 29, 28, 27, 26, 0, 25, 24, 23,
  88    22, 0, 21, 20, 19, 18, 17, 6, 48, 16, 15, 22, 6, 6, 14, 6,
  89    13, 12, 11, 10, 9, 8, 6, 6, 7, 6, 6, 42, 5, 4, 3, 6,
  90    40, 41, 6, 32, 47, 65, 32, 39, 64, 6, 46, 62, 0, 63, 6, 6,
  91    6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 47, 47, 47,
  92    33, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 61, 47, 47, 47,
  93    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
  94    47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 60,
  95    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
  96    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
  97    48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 59, 58, 56, 57, 55,
  98    22, 0, 54, 53, 0, 45, 52, 44, 51, 50, 49, 0, 0, 0, 0, 0,
  99    0, 0, 0, 37, 0, 0, 43, 38, 36, 35, 34, 0, 0, 0, 0, 0,
 100    0, 0, 0
 101 };
 102 static const DFATables::State _X1_def [ 66 ] = {
 103    0, 0, 1, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 0,
 104    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 105    0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 0, 0, 23,
 106    47, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 107    6, 6
 108 };
 109 static const unsigned char _X1_equiv_classes [ 256 ] = {
 110    0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 1, 1, 1, 1, 1,
 111    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 112    5, 4, 4, 6, 4, 4, 4, 4, 7, 8, 9, 10, 11, 13, 14, 15,
 113    16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 18, 19, 20, 21, 22, 17,
 114    17, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
 115    23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 25, 24, 26, 24, 28,
 116    27, 30, 29, 29, 31, 32, 33, 29, 29, 34, 29, 29, 35, 29, 36, 37,
 117    29, 29, 38, 39, 40, 41, 29, 29, 42, 29, 29, 44, 45, 46, 43, 43,
 118    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 119    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 120    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 121    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 122    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 123    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 124    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
 125    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43
 126    };
 127 static const DFATables::Rule _X1_accept_rule [ 66 ] = {
 128    -1, 0, 0, -13, -28, -12, 34, 34, 34, 34, 34, 34, 34, 34, 34, -21,
 129    -20, 24, -22, 23, -31, -32, 33, 13, -33, 16, -30, -16, -15, -19, -18, -29,
 130    35, -37, 34, 5, 34, 34, 3, 34, 34, 34, 34, 34, -27, -26, -23, 0,
 131    0, 34, 6, 9, 34, 34, 34, 10, 4, 1, 34, 34, 34, 34, 2, 34,
 132    7, 8
 133 };
 134          static const RegexMatch _X1
 135                           ( _X1_base,
 136                             _X1_check,
 137                             _X1_def,
 138                             _X1_next,
 139                             _X1_accept_rule,
 140                             _X1_equiv_classes );
 141          int rule__;
 142          const char * next;
 143          switch(rule__ = _X1.MatchText(RegexMatch::start_state,lexbuf,next)) {
 144             case 1: {
 145                L2:;
 146 #line 21 "parser.pcc"
 147               return ((Tokens)(rule__ + 255));
 148 #line 21 "parser.pcc"
 149             } break;
 150             case 2: { goto L2; } break;
 151             case 3: { goto L2; } break;
 152             case 4: { goto L2; } break;
 153             case 5: { goto L2; } break;
 154             case 6: { goto L2; } break;
 155             case 7: { goto L2; } break;
 156             case 8: { goto L2; } break;
 157             case 9: { goto L2; } break;
 158             case 10: { goto L2; } break;
 159             case 11: { goto L2; } break;
 160             case 12: { goto L2; } break;
 161             case 13: { goto L2; } break;
 162             case 14: { goto L2; } break;
 163             case 15: { goto L2; } break;
 164             case 16: { goto L2; } break;
 165             case 17: { goto L2; } break;
 166             case 18: { goto L2; } break;
 167             case 19: { goto L2; } break;
 168             case 20: { goto L2; } break;
 169             case 21: { goto L2; } break;
 170             case 22: { goto L2; } break;
 171             case 23: { goto L2; } break;
 172             case 24: { goto L2; } break;
 173             case 25: { goto L2; } break;
 174             case 26: { goto L2; } break;
 175             case 27: { goto L2; } break;
 176             case 28: { goto L2; } break;
 177             case 29: { goto L2; } break;
 178             case 30: { goto L2; } break;
 179             case 31: { goto L2; } break;
 180             case 32: { goto L2; } break;
 181             case 33: { goto L2; } break;
 182             case 34: { goto L2; } break;
 183             case 35: {} break;
 184             case 36: {
 185 #line 23 "parser.pcc"
 186               line_no++;
 187 #line 23 "parser.pcc"
 188             } break;
 189             default: { goto L1; }
 190          }
 191       }
 192    }
 193    L1:;
 194 }
 195 #line 24 "parser.pcc"
 196 #line 24 "parser.pcc"
 197
 198    return EOF;
 199 }
 200
 201 //
 202 //  Method to create a nested definition
 203 //
 204 Exp make_defs (Exp (*f)(Ids,Exps,Exp),
 205 #line 31 "parser.pcc"
 206 a_List<Tuple2<Ids, Exps> > *
 207 #line 31 "parser.pcc"
 208  defs, Exp e)
 209 {
 210 #line 34 "parser.pcc"
 211 {
 212    if (defs) {
 213 #line 34 "parser.pcc"
 214      return f(defs->_1._1,defs->_1._2,make_defs(f,defs->_2,e));
 215 #line 34 "parser.pcc"
 216    } else {
 217 #line 33 "parser.pcc"
 218      return e;
 219 #line 33 "parser.pcc"
 220    }
 221 }
 222 #line 35 "parser.pcc"
 223 #line 35 "parser.pcc"
 224
 225 }
 226
 227 //
 228 //
 229 //  This is our parser
 230 //
 231 #line 42 "parser.pcc"
 232 #line 134 "parser.pcc"
 233 ///////////////////////////////////////////////////////////////////////////////
 234 // Encoded parser tables for syntax class QueryParser
 235 ///////////////////////////////////////////////////////////////////////////////
 236 static const DFATables::Offset QueryParser_base [ 104 ] = {
 237    0, 0, 4, 6, 8, 13, 15, 21, 142, 12, 0, 0, 0, 0, 142, 0,
 238    0, 0, 0, 142, 142, 41, 0, 140, 131, 126, 126, 125, 124, 123, 0, 25,
 239    27, 29, 31, 34, 36, 122, 121, 120, 119, 118, 117, 116, 37, 37, 0, 42,
 240    0, 116, 115, 115, 114, 21, 0, 0, 0, 29, 76, 78, 81, 83, 85, 77,
 241    79, 114, 112, 55, 0, 112, 0, 0, 112, 111, 111, 81, 0, 111, 111, 0,
 242    111, 77, 110, 109, 0, 57, 0, 59, 109, 61, 73, 0, 0, 0, 0, 0,
 243    0, 53, 9, 82, 0, 63, 0, 0
 244 };
 245 static const DFATables::State QueryParser_check [ 192 ] = {
 246    0, 1, 0, 68, 68, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
 247    15, 15, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 53, 53, 1, 1,
 248    1, 1, 57, 57, 1, 1, 98, 1, 2, 2, 3, 3, 4, 4, 1, 1,
 249    1, 5, 5, 6, 6, 6, 7, 9, 21, 21, 21, 45, 9, 31, 31, 32,
 250    32, 33, 33, 34, 34, 7, 35, 35, 36, 36, 44, 44, 97, 45, 45, 47,
 251    47, 58, 58, 59, 59, 45, 60, 60, 61, 61, 62, 62, 63, 63, 63, 64,
 252    64, 67, 75, 81, 85, 87, 90, 67, 99, 85, 89, 87, 101, 89, 75, 101,
 253    88, 0, 0, 0, 0, 0, 0, 0, 0, 81, 99, 99, 0, 81, 0, 0,
 254    0, 69, 99, 65, 29, 66, 77, 0, 73, 72, 0, 74, 78, 28, 27, 26,
 255    20, 0, 83, 82, 80, 25, 0, 52, 51, 43, 42, 41, 40, 39, 38, 37,
 256    24, 23, 19, 50, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 257    0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0
 258    };
 259 static const DFATables::State QueryParser_next [ 192 ] = {
 260    0, 2, 0, 16463, 80, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
 261    42, 43, 3, 4, 5, 0, 6, 0, 7, 0, 8, 9, 33, 34, 16394, 16395,
 262    16396, 16397, 31, 32, 14, 15, 101, 16400, 0, 20, 0, 21, 0, 16406, 16401, 16402,
 263    19, 0, 23, 0, 24, 25, 16397, 28, 0, 0, 0, 67, 29, 0, 53, 0,
 264    54, 0, 16439, 0, 16440, 26, 0, 57, 0, 58, 24, 66, 16484, 68, 69, 24,
 265    16455, 31, 32, 31, 32, 16454, 31, 32, 31, 32, 31, 32, 0, 0, 0, 0,
 266    0, 77, 0, 89, 16478, 16479, 99, 78, 67, 29, 97, 78, 16487, 98, 85, 98,
 267    16480, 0, 0, 0, 0, 0, 0, 0, 0, 90, 16486, 69, 0, 16475, 0, 0,
 268    0, 81, 16454, 0, 52, 16460, 16470, 0, 83, 82, 0, 16468, 87, 51, 50, 49,
 269    45, 0, 93, 92, 88, 16432, 0, 75, 74, 65, 64, 63, 62, 61, 60, 59,
 270    47, 16430, 44, 73, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 271    0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0
 272    };
 273 static const DFATables::State QueryParser_def [ 104 ] = {
 274    0, 0, 1, 1, 1, 1, 1, 0, 7, 7, 0, 0, 0, 0, 0, 0,
 275    0, 0, 0, 0, 15, 15, 0, 15, 15, 0, 0, 0, 0, 0, 0, 1,
 276    1, 1, 1, 1, 1, 36, 36, 36, 36, 36, 36, 36, 36, 7, 0, 36,
 277    0, 7, 7, 36, 36, 0, 53, 0, 0, 53, 53, 53, 53, 53, 53, 15,
 278    15, 15, 0, 7, 0, 0, 0, 0, 0, 0, 15, 15, 0, 0, 0, 0,
 279    36, 7, 36, 36, 0, 7, 0, 7, 15, 7, 0, 0, 15, 15, 0, 0,
 280    0, 0, 0, 7, 0, 7, 0, 0
 281 };
 282 static const DFATables::State QueryParser_defact [ 104 ] = {
 283    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32810, 32811, 32812, 32813, 0, 32768,
 284    32787, 32796, 32797, 32788, 0, 32784, 32785, 0, 32794, 0, 0, 0, 0, 0, 32814, 0,
 285    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32786, 0,
 286    32790, 0, 0, 0, 0, 32771, 32772, 32773, 32774, 32775, 32776, 32777, 32778, 32779, 32780, 32781,
 287    32782, 32783, 0, 0, 0, 0, 32800, 32795, 0, 0, 0, 32804, 32789, 0, 32802, 32769,
 288    0, 0, 0, 0, 32793, 0, 32801, 0, 0, 0, 32798, 32806, 32791, 32792, 32805, 32803,
 289    32770, 0, 32808, 0, 32807, 0, 32799, 32809
 290 };
 291 static const DFATables::ProductionLength QueryParser_len [ 47 ] = {
 292    1, 5, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 293    2, 2, 3, 1, 1, 4, 3, 6, 6, 5, 1, 3, 1, 1, 3, 5,
 294    1, 3, 1, 3, 3, 5, 1, 3, 1, 3, 1, 1, 1, 1, 2
 295 };
 296 static const DFATables::ProductionLength QueryParser_ncount [ 47 ] = {
 297    1, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 298    1, 1, 1, 1, 1, 2, 1, 3, 3, 2, 1, 2, 1, 1, 2, 3,
 299    1, 1, 1, 2, 2, 3, 1, 1, 1, 2, 0, 0, 0, 0, 1
 300 };
 301 static const DFATables::ShortSymbol QueryParser_lhs [ 47 ] = {
 302    36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
 303    37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 39, 39, 40, 40,
 304    41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 47, 47, 48, 49
 305 };
 306 static const DFATables::EquivMap QueryParser_equiv [ 307 ] = {
 307    35, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 308    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 309    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 310    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 311    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 312    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 313    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 314    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 315    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 316    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 317    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 318    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 319    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 320    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 321    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 322    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 323    0, 31, 32, 17, 15, 16, 18, 24, 26, 27, 28, 1, 3, 8, 7, 5,
 324    6, 20, 21, 22, 23, 9, 10, 11, 12, 13, 14, 4, 19, 29, 0, 2,
 325    25, 30, 33, 0, 0, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
 326    47, 48, 49
 327 };
 328 ///////////////////////////////////////////////////////////////////////////////
 329 // Debugging tables for syntax class QueryParser
 330 ///////////////////////////////////////////////////////////////////////////////
 331
 332 #ifdef DEBUG_QueryParser
 333 static const int QueryParser_line[] =
 334 {
 335    55, 60, 62, 63, 64, 65, 66, 67,
 336    68, 69, 70, 71, 72, 73, 74, 75,
 337    76, 77, 78, 79, 80, 81, 82, 83,
 338    84, 85, 88, 89, 92, 93, 97, 98,
 339    101, 102, 105, 106, 110, 113, 116, 117,
 340    120, 121, 124, 127, 128, 131, 0
 341 };
 342
 343 static const char * const QueryParser_symbolname[] =
 344 {
 345    "?", "\"{\"", "\":\"", "\"}\"", "\"|\"", "\"+\"", "\"-\"", "\"*\"",
 346    "\"/\"", "\"=\"", "\"/=\"", "\"<\"", "\">\"", "\"<=\"", "\">=\"", "\"and\"",
 347    "\"or\"", "\"in\"", "\"not\"", "\"#\"", "\"(\"", "\")\"", "\"[\"", "\"]\"",
 348    "\"forall\"", "\".\"", "\"exists\"", "\"let\"", "\"end\"", "\",\"", "INTEGER", "\"true\"",
 349    "\"false\"", "IDENT", "???", "???", "top", "exp", "exps", "literal",
 350    "generators", "rvar", "ids", "defs", "range", "ranges", "integer", "boolean",
 351    "id", "???"
 352 };
 353
 354 static const DFATables::ShortSymbol QueryParser_rhs_0[] = { 37,  -1 };
 355 static const DFATables::ShortSymbol QueryParser_rhs_1[] = { 1, 37, 2, 40, 3,  -1 };
 356 static const DFATables::ShortSymbol QueryParser_rhs_2[] = { 1, 37, 2, 40, 4, 37, 3,  -1 };
 357 static const DFATables::ShortSymbol QueryParser_rhs_3[] = { 37, 5, 37,  -1 };
 358 static const DFATables::ShortSymbol QueryParser_rhs_4[] = { 37, 6, 37,  -1 };
 359 static const DFATables::ShortSymbol QueryParser_rhs_5[] = { 37, 7, 37,  -1 };
 360 static const DFATables::ShortSymbol QueryParser_rhs_6[] = { 37, 8, 37,  -1 };
 361 static const DFATables::ShortSymbol QueryParser_rhs_7[] = { 37, 9, 37,  -1 };
 362 static const DFATables::ShortSymbol QueryParser_rhs_8[] = { 37, 10, 37,  -1 };
 363 static const DFATables::ShortSymbol QueryParser_rhs_9[] = { 37, 11, 37,  -1 };
 364 static const DFATables::ShortSymbol QueryParser_rhs_10[] = { 37, 12, 37,  -1 };
 365 static const DFATables::ShortSymbol QueryParser_rhs_11[] = { 37, 13, 37,  -1 };
 366 static const DFATables::ShortSymbol QueryParser_rhs_12[] = { 37, 14, 37,  -1 };
 367 static const DFATables::ShortSymbol QueryParser_rhs_13[] = { 37, 15, 37,  -1 };
 368 static const DFATables::ShortSymbol QueryParser_rhs_14[] = { 37, 16, 37,  -1 };
 369 static const DFATables::ShortSymbol QueryParser_rhs_15[] = { 37, 17, 37,  -1 };
 370 static const DFATables::ShortSymbol QueryParser_rhs_16[] = { 18, 37,  -1 };
 371 static const DFATables::ShortSymbol QueryParser_rhs_17[] = { 19, 37,  -1 };
 372 static const DFATables::ShortSymbol QueryParser_rhs_18[] = { 20, 37, 21,  -1 };
 373 static const DFATables::ShortSymbol QueryParser_rhs_19[] = { 39,  -1 };
 374 static const DFATables::ShortSymbol QueryParser_rhs_20[] = { 48,  -1 };
 375 static const DFATables::ShortSymbol QueryParser_rhs_21[] = { 48, 20, 38, 21,  -1 };
 376 static const DFATables::ShortSymbol QueryParser_rhs_22[] = { 22, 38, 23,  -1 };
 377 static const DFATables::ShortSymbol QueryParser_rhs_23[] = { 24, 48, 17, 48, 25, 37,  -1 };
 378 static const DFATables::ShortSymbol QueryParser_rhs_24[] = { 26, 48, 17, 48, 25, 37,  -1 };
 379 static const DFATables::ShortSymbol QueryParser_rhs_25[] = { 27, 43, 17, 37, 28,  -1 };
 380 static const DFATables::ShortSymbol QueryParser_rhs_26[] = { 37,  -1 };
 381 static const DFATables::ShortSymbol QueryParser_rhs_27[] = { 37, 29, 38,  -1 };
 382 static const DFATables::ShortSymbol QueryParser_rhs_28[] = { 46,  -1 };
 383 static const DFATables::ShortSymbol QueryParser_rhs_29[] = { 47,  -1 };
 384 static const DFATables::ShortSymbol QueryParser_rhs_30[] = { 41, 17, 44,  -1 };
 385 static const DFATables::ShortSymbol QueryParser_rhs_31[] = { 41, 17, 44, 29, 40,  -1 };
 386 static const DFATables::ShortSymbol QueryParser_rhs_32[] = { 48,  -1 };
 387 static const DFATables::ShortSymbol QueryParser_rhs_33[] = { 22, 42, 23,  -1 };
 388 static const DFATables::ShortSymbol QueryParser_rhs_34[] = { 48,  -1 };
 389 static const DFATables::ShortSymbol QueryParser_rhs_35[] = { 48, 29, 42,  -1 };
 390 static const DFATables::ShortSymbol QueryParser_rhs_36[] = { 48, 9, 37,  -1 };
 391 static const DFATables::ShortSymbol QueryParser_rhs_37[] = { 48, 9, 37, 29, 43,  -1 };
 392 static const DFATables::ShortSymbol QueryParser_rhs_38[] = { 48,  -1 };
 393 static const DFATables::ShortSymbol QueryParser_rhs_39[] = { 22, 45, 23,  -1 };
 394 static const DFATables::ShortSymbol QueryParser_rhs_40[] = { 48,  -1 };
 395 static const DFATables::ShortSymbol QueryParser_rhs_41[] = { 48, 29, 45,  -1 };
 396 static const DFATables::ShortSymbol QueryParser_rhs_42[] = { 30,  -1 };
 397 static const DFATables::ShortSymbol QueryParser_rhs_43[] = { 31,  -1 };
 398 static const DFATables::ShortSymbol QueryParser_rhs_44[] = { 32,  -1 };
 399 static const DFATables::ShortSymbol QueryParser_rhs_45[] = { 33,  -1 };
 400 static const DFATables::ShortSymbol QueryParser_rhs_46[] = { 36, 35,  -1 };
 401 static const DFATables::ShortSymbol * QueryParser_rhs[] =
 402 {
 403    QueryParser_rhs_0,
 404    QueryParser_rhs_1,
 405    QueryParser_rhs_2,
 406    QueryParser_rhs_3,
 407    QueryParser_rhs_4,
 408    QueryParser_rhs_5,
 409    QueryParser_rhs_6,
 410    QueryParser_rhs_7,
 411    QueryParser_rhs_8,
 412    QueryParser_rhs_9,
 413    QueryParser_rhs_10,
 414    QueryParser_rhs_11,
 415    QueryParser_rhs_12,
 416    QueryParser_rhs_13,
 417    QueryParser_rhs_14,
 418    QueryParser_rhs_15,
 419    QueryParser_rhs_16,
 420    QueryParser_rhs_17,
 421    QueryParser_rhs_18,
 422    QueryParser_rhs_19,
 423    QueryParser_rhs_20,
 424    QueryParser_rhs_21,
 425    QueryParser_rhs_22,
 426    QueryParser_rhs_23,
 427    QueryParser_rhs_24,
 428    QueryParser_rhs_25,
 429    QueryParser_rhs_26,
 430    QueryParser_rhs_27,
 431    QueryParser_rhs_28,
 432    QueryParser_rhs_29,
 433    QueryParser_rhs_30,
 434    QueryParser_rhs_31,
 435    QueryParser_rhs_32,
 436    QueryParser_rhs_33,
 437    QueryParser_rhs_34,
 438    QueryParser_rhs_35,
 439    QueryParser_rhs_36,
 440    QueryParser_rhs_37,
 441    QueryParser_rhs_38,
 442    QueryParser_rhs_39,
 443    QueryParser_rhs_40,
 444    QueryParser_rhs_41,
 445    QueryParser_rhs_42,
 446    QueryParser_rhs_43,
 447    QueryParser_rhs_44,
 448    QueryParser_rhs_45,
 449    QueryParser_rhs_46
 450 };
 451
 452
 453 #endif
 454
 455 ///////////////////////////////////////////////////////////////////////////////
 456 // Semantic value stack for syntax class QueryParser
 457 ///////////////////////////////////////////////////////////////////////////////
 458 union QueryParser_semantic_stack_type {
 459    int dummy;
 460 #line 58 "parser.pcc"
 461    typedef Exp ATTRIBUTE_0;
 462    ATTRIBUTE_0 _188, _183, _142, _139, _135, _131, _129, _123, _121, _115, _110, _104, _101, _98, _95, _93, _91, _89, _87, _85, _83, _81, _80, _78, _76, _75, _73, _71, _70, _68, _66, _65, _63, _61, _60, _58, _56, _55, _53, _51, _50, _48, _46, _45, _43, _41, _40, _38, _36, _35, _33, _31, _30, _28, _26, _25, _23, _21, _20, _17, _13, _11, _6, _4, _2;
 463 #line 88 "parser.pcc"
 464    typedef Exps ATTRIBUTE_1;
 465    ATTRIBUTE_1 _144, _141, _138, _112, _107;
 466 #line 92 "parser.pcc"
 467    typedef Literal ATTRIBUTE_2;
 468    ATTRIBUTE_2 _149, _146, _99;
 469 #line 96 "parser.pcc"
 470    typedef a_List<Tuple2<Ids, Exps> > *  ATTRIBUTE_3;
 471    ATTRIBUTE_3 _162, _157, _152, _15, _8;
 472 #line 101 "parser.pcc"
 473    typedef Ids ATTRIBUTE_4;
 474    ATTRIBUTE_4 _167, _164, _158, _153;
 475 #line 105 "parser.pcc"
 476    typedef Ids ATTRIBUTE_5;
 477    ATTRIBUTE_5 _178, _175, _172, _169;
 478 #line 109 "parser.pcc"
 479    typedef struct { Ids ids; Exps exps;  } ATTRIBUTE_6;
 480    ATTRIBUTE_6 _190, _185, _180, _133;
 481 #line 116 "parser.pcc"
 482    typedef Exps ATTRIBUTE_7;
 483    ATTRIBUTE_7 _195, _192, _160, _155;
 484 #line 120 "parser.pcc"
 485    typedef Exps ATTRIBUTE_8;
 486    ATTRIBUTE_8 _206, _203, _200, _197;
 487 #line 124 "parser.pcc"
 488    typedef int ATTRIBUTE_9;
 489    ATTRIBUTE_9 _208, _147;
 490 #line 127 "parser.pcc"
 491    typedef Bool ATTRIBUTE_10;
 492    ATTRIBUTE_10 _214, _211, _150;
 493 #line 131 "parser.pcc"
 494    typedef Id ATTRIBUTE_11;
 495    ATTRIBUTE_11 _217, _204, _201, _193, _186, _181, _176, _173, _165, _127, _125, _119, _117, _105, _102;
 496 };
 497
 498
 499 ///////////////////////////////////////////////////////////////////////////////
 500 // Parser driver for syntax class QueryParser
 501 ///////////////////////////////////////////////////////////////////////////////
 502 inline void QueryParser::action_driver(const Rule _r_)
 503 {
 504    QueryParser_semantic_stack_type syn_;
 505    ////////////////////////////////////////////////////////////////////////////
 506    // Tracing code for syntax class QueryParser
 507    ////////////////////////////////////////////////////////////////////////////
 508 #ifdef DEBUG_QueryParser
 509    {  cerr << "Reducing via rule " << _r_ << " at line "
 510            << QueryParser_line[_r_] << ", "
 511            << QueryParser_symbolname[QueryParser_lhs[_r_]] << " <- ";
 512       for (const DFATables::ShortSymbol * _p_ = QueryParser_rhs[_r_]; *_p_ >= 0; _p_++)
 513          cerr << QueryParser_symbolname[*_p_] << ' ';
 514       cerr << '\n';
 515    }
 516 #endif
 517
 518    ////////////////////////////////////////////////////////////////////////////
 519    // Actions for syntax class QueryParser
 520    ////////////////////////////////////////////////////////////////////////////
 521    t__ -= QueryParser_ncount[_r_];
 522    switch (_r_) {
 523
 524 #undef to__
 525 #define to__ 0
 526       case 0: {
 527 #line 55 "parser.pcc"
 528         query = t__[1+to__]._2;
 529 #line 55 "parser.pcc"
 530 } break;
 531       case 1: {
 532 #line 60 "parser.pcc"
 533         syn_._4 = make_defs(GENERATOR,t__[2+to__]._8,t__[1+to__]._6);
 534 #line 60 "parser.pcc"
 535 } break;
 536       case 2: {
 537 #line 62 "parser.pcc"
 538         syn_._11 = make_defs(GENERATOR,t__[2+to__]._15,GUARD(t__[3+to__]._17,t__[1+to__]._13));
 539 #line 62 "parser.pcc"
 540 } break;
 541       case 3: {
 542 #line 63 "parser.pcc"
 543         syn_._20 = OP("+",
 544 #line 63 "parser.pcc"
 545 #line 63 "parser.pcc"
 546          list_1_(t__[1+to__]._21,list_1_(t__[2+to__]._23))
 547 #line 63 "parser.pcc"
 548 #line 63 "parser.pcc"
 549          );
 550 #line 63 "parser.pcc"
 551 } break;
 552       case 4: {
 553 #line 64 "parser.pcc"
 554         syn_._25 = OP("-",
 555 #line 64 "parser.pcc"
 556 #line 64 "parser.pcc"
 557          list_1_(t__[1+to__]._26,list_1_(t__[2+to__]._28))
 558 #line 64 "parser.pcc"
 559 #line 64 "parser.pcc"
 560          );
 561 #line 64 "parser.pcc"
 562 } break;
 563       case 5: {
 564 #line 65 "parser.pcc"
 565         syn_._30 = OP("*",
 566 #line 65 "parser.pcc"
 567 #line 65 "parser.pcc"
 568          list_1_(t__[1+to__]._31,list_1_(t__[2+to__]._33))
 569 #line 65 "parser.pcc"
 570 #line 65 "parser.pcc"
 571          );
 572 #line 65 "parser.pcc"
 573 } break;
 574       case 6: {
 575 #line 66 "parser.pcc"
 576         syn_._35 = OP("/",
 577 #line 66 "parser.pcc"
 578 #line 66 "parser.pcc"
 579          list_1_(t__[1+to__]._36,list_1_(t__[2+to__]._38))
 580 #line 66 "parser.pcc"
 581 #line 66 "parser.pcc"
 582          );
 583 #line 66 "parser.pcc"
 584 } break;
 585       case 7: {
 586 #line 67 "parser.pcc"
 587         syn_._40 = OP("=",
 588 #line 67 "parser.pcc"
 589 #line 67 "parser.pcc"
 590          list_1_(t__[1+to__]._41,list_1_(t__[2+to__]._43))
 591 #line 67 "parser.pcc"
 592 #line 67 "parser.pcc"
 593          );
 594 #line 67 "parser.pcc"
 595 } break;
 596       case 8: {
 597 #line 68 "parser.pcc"
 598         syn_._45 = OP("/=",
 599 #line 68 "parser.pcc"
 600 #line 68 "parser.pcc"
 601          list_1_(t__[1+to__]._46,list_1_(t__[2+to__]._48))
 602 #line 68 "parser.pcc"
 603 #line 68 "parser.pcc"
 604          );
 605 #line 68 "parser.pcc"
 606 } break;
 607       case 9: {
 608 #line 69 "parser.pcc"
 609         syn_._50 = OP("<",
 610 #line 69 "parser.pcc"
 611 #line 69 "parser.pcc"
 612          list_1_(t__[1+to__]._51,list_1_(t__[2+to__]._53))
 613 #line 69 "parser.pcc"
 614 #line 69 "parser.pcc"
 615          );
 616 #line 69 "parser.pcc"
 617 } break;
 618       case 10: {
 619 #line 70 "parser.pcc"
 620         syn_._55 = OP(">",
 621 #line 70 "parser.pcc"
 622 #line 70 "parser.pcc"
 623          list_1_(t__[1+to__]._56,list_1_(t__[2+to__]._58))
 624 #line 70 "parser.pcc"
 625 #line 70 "parser.pcc"
 626          );
 627 #line 70 "parser.pcc"
 628 } break;
 629       case 11: {
 630 #line 71 "parser.pcc"
 631         syn_._60 = OP("<=",
 632 #line 71 "parser.pcc"
 633 #line 71 "parser.pcc"
 634          list_1_(t__[1+to__]._61,list_1_(t__[2+to__]._63))
 635 #line 71 "parser.pcc"
 636 #line 71 "parser.pcc"
 637          );
 638 #line 71 "parser.pcc"
 639 } break;
 640       case 12: {
 641 #line 72 "parser.pcc"
 642         syn_._65 = OP(">=",
 643 #line 72 "parser.pcc"
 644 #line 72 "parser.pcc"
 645          list_1_(t__[1+to__]._66,list_1_(t__[2+to__]._68))
 646 #line 72 "parser.pcc"
 647 #line 72 "parser.pcc"
 648          );
 649 #line 72 "parser.pcc"
 650 } break;
 651       case 13: {
 652 #line 73 "parser.pcc"
 653         syn_._70 = OP("and",
 654 #line 73 "parser.pcc"
 655 #line 73 "parser.pcc"
 656          list_1_(t__[1+to__]._71,list_1_(t__[2+to__]._73))
 657 #line 73 "parser.pcc"
 658 #line 73 "parser.pcc"
 659          );
 660 #line 73 "parser.pcc"
 661 } break;
 662       case 14: {
 663 #line 74 "parser.pcc"
 664         syn_._75 = OP("or",
 665 #line 74 "parser.pcc"
 666 #line 74 "parser.pcc"
 667          list_1_(t__[1+to__]._76,list_1_(t__[2+to__]._78))
 668 #line 74 "parser.pcc"
 669 #line 74 "parser.pcc"
 670          );
 671 #line 74 "parser.pcc"
 672 } break;
 673       case 15: {
 674 #line 75 "parser.pcc"
 675         syn_._80 = OP("in",
 676 #line 75 "parser.pcc"
 677 #line 75 "parser.pcc"
 678          list_1_(t__[1+to__]._81,list_1_(t__[2+to__]._83))
 679 #line 75 "parser.pcc"
 680 #line 75 "parser.pcc"
 681          );
 682 #line 75 "parser.pcc"
 683 } break;
 684       case 16: {
 685 #line 76 "parser.pcc"
 686         syn_._85 = OP("not",
 687 #line 76 "parser.pcc"
 688 #line 76 "parser.pcc"
 689          list_1_(t__[1+to__]._87)
 690 #line 76 "parser.pcc"
 691 #line 76 "parser.pcc"
 692          );
 693 #line 76 "parser.pcc"
 694 } break;
 695       case 17: {
 696 #line 77 "parser.pcc"
 697         syn_._89 = Count(t__[1+to__]._91);
 698 #line 77 "parser.pcc"
 699 } break;
 700       case 18: {
 701 #line 78 "parser.pcc"
 702         syn_._93 = t__[1+to__]._95;
 703 #line 78 "parser.pcc"
 704 } break;
 705       case 19: {
 706 #line 79 "parser.pcc"
 707         syn_._98 = LIT(t__[1+to__]._99);
 708 #line 79 "parser.pcc"
 709 } break;
 710       case 20: {
 711 #line 80 "parser.pcc"
 712         syn_._101 = ID(t__[1+to__]._102);
 713 #line 80 "parser.pcc"
 714 } break;
 715       case 21: {
 716 #line 81 "parser.pcc"
 717         syn_._104 = APP(t__[1+to__]._105,t__[2+to__]._107);
 718 #line 81 "parser.pcc"
 719 } break;
 720       case 22: {
 721 #line 82 "parser.pcc"
 722         syn_._110 = TUPLE(t__[1+to__]._112);
 723 #line 82 "parser.pcc"
 724 } break;
 725       case 23: {
 726 #line 83 "parser.pcc"
 727         syn_._115 = FORALL(t__[1+to__]._117,ID(t__[2+to__]._119),t__[3+to__]._121);
 728 #line 83 "parser.pcc"
 729 } break;
 730       case 24: {
 731 #line 84 "parser.pcc"
 732         syn_._123 = EXISTS(t__[1+to__]._125,ID(t__[2+to__]._127),t__[3+to__]._129);
 733 #line 84 "parser.pcc"
 734 } break;
 735       case 25: {
 736 #line 85 "parser.pcc"
 737         syn_._131 = PaigeGoyal::make_let(t__[1+to__]._133.ids,t__[1+to__]._133.exps,t__[2+to__]._135);
 738 #line 85 "parser.pcc"
 739 } break;
 740       case 26: {
 741 #line 88 "parser.pcc"
 742         syn_._138 =
 743 #line 88 "parser.pcc"
 744 #line 88 "parser.pcc"
 745          list_1_(t__[1+to__]._139)
 746 #line 88 "parser.pcc"
 747 #line 88 "parser.pcc"
 748          ;
 749 #line 88 "parser.pcc"
 750 } break;
 751       case 27: {
 752 #line 89 "parser.pcc"
 753         syn_._141 =
 754 #line 89 "parser.pcc"
 755 #line 89 "parser.pcc"
 756          list_1_(t__[1+to__]._142,t__[2+to__]._144)
 757 #line 89 "parser.pcc"
 758 #line 89 "parser.pcc"
 759          ;
 760 #line 89 "parser.pcc"
 761 } break;
 762       case 28: {
 763 #line 92 "parser.pcc"
 764         syn_._146 = INT(t__[1+to__]._147);
 765 #line 92 "parser.pcc"
 766 } break;
 767       case 29: {
 768 #line 93 "parser.pcc"
 769         syn_._149 = BOOL(t__[1+to__]._150);
 770 #line 93 "parser.pcc"
 771 } break;
 772       case 30: {
 773 #line 97 "parser.pcc"
 774         syn_._152 =
 775 #line 97 "parser.pcc"
 776 #line 97 "parser.pcc"
 777          list_1_(mkTuple2(t__[1+to__]._153,t__[2+to__]._155))
 778 #line 97 "parser.pcc"
 779 #line 97 "parser.pcc"
 780          ;
 781 #line 97 "parser.pcc"
 782 } break;
 783       case 31: {
 784 #line 98 "parser.pcc"
 785         syn_._157 =
 786 #line 98 "parser.pcc"
 787 #line 98 "parser.pcc"
 788          list_1_(mkTuple2(t__[1+to__]._158,t__[2+to__]._160),t__[3+to__]._162)
 789 #line 98 "parser.pcc"
 790 #line 98 "parser.pcc"
 791          ;
 792 #line 98 "parser.pcc"
 793 } break;
 794       case 32: {
 795 #line 101 "parser.pcc"
 796         syn_._164 =
 797 #line 101 "parser.pcc"
 798 #line 101 "parser.pcc"
 799          list_1_(t__[1+to__]._165)
 800 #line 101 "parser.pcc"
 801 #line 101 "parser.pcc"
 802          ;
 803 #line 101 "parser.pcc"
 804 } break;
 805       case 33: {
 806 #line 102 "parser.pcc"
 807         syn_._167 = t__[1+to__]._169;
 808 #line 102 "parser.pcc"
 809 } break;
 810       case 34: {
 811 #line 105 "parser.pcc"
 812         syn_._172 =
 813 #line 105 "parser.pcc"
 814 #line 105 "parser.pcc"
 815          list_1_(t__[1+to__]._173)
 816 #line 105 "parser.pcc"
 817 #line 105 "parser.pcc"
 818          ;
 819 #line 105 "parser.pcc"
 820 } break;
 821       case 35: {
 822 #line 106 "parser.pcc"
 823         syn_._175 =
 824 #line 106 "parser.pcc"
 825 #line 106 "parser.pcc"
 826          list_1_(t__[1+to__]._176,t__[2+to__]._178)
 827 #line 106 "parser.pcc"
 828 #line 106 "parser.pcc"
 829          ;
 830 #line 106 "parser.pcc"
 831 } break;
 832       case 36: {
 833 #line 110 "parser.pcc"
 834         syn_._180.ids =
 835 #line 110 "parser.pcc"
 836 #line 110 "parser.pcc"
 837          list_1_(t__[1+to__]._181)
 838 #line 110 "parser.pcc"
 839 #line 110 "parser.pcc"
 840          ; syn_._180.exps =
 841 #line 110 "parser.pcc"
 842 #line 110 "parser.pcc"
 843          list_1_(t__[2+to__]._183)
 844 #line 110 "parser.pcc"
 845 #line 110 "parser.pcc"
 846          ;
 847 #line 110 "parser.pcc"
 848 } break;
 849       case 37: {
 850 #line 111 "parser.pcc"
 851         syn_._185.ids  =
 852 #line 111 "parser.pcc"
 853 #line 111 "parser.pcc"
 854          list_1_(t__[1+to__]._186,t__[3+to__]._190.ids)
 855 #line 111 "parser.pcc"
 856 #line 111 "parser.pcc"
 857          ;
 858                                                   syn_._185.exps =
 859 #line 112 "parser.pcc"
 860 #line 112 "parser.pcc"
 861          list_1_(t__[2+to__]._188,t__[3+to__]._190.exps)
 862 #line 112 "parser.pcc"
 863 #line 112 "parser.pcc"
 864          ;
 865
 866 #line 113 "parser.pcc"
 867 } break;
 868       case 38: {
 869 #line 116 "parser.pcc"
 870         syn_._192 =
 871 #line 116 "parser.pcc"
 872 #line 116 "parser.pcc"
 873          list_1_(ID(t__[1+to__]._193))
 874 #line 116 "parser.pcc"
 875 #line 116 "parser.pcc"
 876          ;
 877 #line 116 "parser.pcc"
 878 } break;
 879       case 39: {
 880 #line 117 "parser.pcc"
 881         syn_._195 = t__[1+to__]._197;
 882 #line 117 "parser.pcc"
 883 } break;
 884       case 40: {
 885 #line 120 "parser.pcc"
 886         syn_._200 =
 887 #line 120 "parser.pcc"
 888 #line 120 "parser.pcc"
 889          list_1_(ID(t__[1+to__]._201))
 890 #line 120 "parser.pcc"
 891 #line 120 "parser.pcc"
 892          ;
 893 #line 120 "parser.pcc"
 894 } break;
 895       case 41: {
 896 #line 121 "parser.pcc"
 897         syn_._203 =
 898 #line 121 "parser.pcc"
 899 #line 121 "parser.pcc"
 900          list_1_(ID(t__[1+to__]._204),t__[2+to__]._206)
 901 #line 121 "parser.pcc"
 902 #line 121 "parser.pcc"
 903          ;
 904 #line 121 "parser.pcc"
 905 } break;
 906       case 42: {
 907 #line 124 "parser.pcc"
 908         syn_._208 = atol(lexbuf.text());
 909 #line 124 "parser.pcc"
 910 } break;
 911       case 43: {
 912 #line 127 "parser.pcc"
 913         syn_._211 = true;
 914 #line 127 "parser.pcc"
 915 } break;
 916       case 44: {
 917 #line 128 "parser.pcc"
 918         syn_._214 = false;
 919 #line 128 "parser.pcc"
 920 } break;
 921       case 45: {
 922 #line 131 "parser.pcc"
 923         syn_._217 = Quark(lexbuf.text());
 924 #line 131 "parser.pcc"
 925 } break;
 926    }
 927    if (t__ >= bot__ + stack_size__) grow_semantic_stack();
 928    *++t__ = syn_;
 929 }
 930
 931 ///////////////////////////////////////////////////////////////////////////////
 932 // Parsing method for parser class QueryParser
 933 ///////////////////////////////////////////////////////////////////////////////
 934 void QueryParser::parse()
 935 {
 936    QueryParser_semantic_stack_type stack__[INITIAL_STACK_SIZE_];
 937    t__ = bot__ = stack__;
 938    stack_size__ = sizeof(stack__)/sizeof(stack__[0]) - 1;
 939    heap_allocated__ = 0;
 940    parser_prefix();
 941    LR1ParserDriver<QueryParser,(LR1Parser::State)30> drv;
 942    drv.driver(*this);
 943    parser_suffix();
 944    if (bot__ != stack__) delete [] bot__;
 945 }
 946
 947 void QueryParser::adjust_stack(int offset) { t__ += offset; }
 948
 949 void QueryParser::grow_semantic_stack()
 950 {
 951    int N = (stack_size__ + 1) * 2;
 952    QueryParser_semantic_stack_type * S = new QueryParser_semantic_stack_type [N];
 953    if (N >= LR1Parser::SEMANTIC_STACK_SIZE)
 954       error_report("Warning: semantic stack overflow");
 955    memcpy(S, bot__, sizeof(QueryParser_semantic_stack_type) * (stack_size__ + 1));
 956    if (heap_allocated__) delete [] bot__;
 957    t__ = S + (t__ - bot__);
 958    bot__ = S;
 959    stack_size__ = N - 1;
 960    heap_allocated__ = 1;
 961 }
 962
 963 QueryParser::QueryParser ()
 964   : Super(QueryParser_base,QueryParser_check,QueryParser_def,QueryParser_defact,QueryParser_next,
 965           QueryParser_len,QueryParser_ncount,QueryParser_lhs,QueryParser_equiv,290,290,304)
 966 {
 967 }
 968 #line 134 "parser.pcc"
 969 #line 134 "parser.pcc"
 970
 971
 972
 973 //
 974 //  This is our parser driver routine
 975 //
 976 Exp QueryParser::read()
 977 {  query = ID("x");
 978    line_no = 1;
 979    parse();
 980    return query;
 981 }
 982
 983 //
 984 //  This is the parser error handler
 985 //
 986 QueryParser::ErrorAction QueryParser::error_report(const char message[])
 987 {  cerr << line_no << ": " << message << " near: " << lexbuf.text() << '\n';
 988    return Retry;
 989 }
 990 #line 154 "parser.pcc"
 991 /*
 992 ------------------------------- Statistics -------------------------------
 993 Merge matching rules         = yes
 994 Number of DFA nodes merged   = 33
 995 Number of ifs generated      = 1
 996 Number of switches generated = 1
 997 Number of labels             = 1
 998 Number of gotos              = 33
 999 Adaptive matching            = disabled
1000 Fast string matching         = disabled
1001 Inline downcasts             = disabled
1002 --------------------------------------------------------------------------
1003 */