100 |
#define yyerror(Msg) \ |
#define yyerror(Msg) \ |
101 |
gram_error (yycontrol, &yylloc, Msg) |
gram_error (yycontrol, &yylloc, Msg) |
102 |
|
|
|
/* When debugging our pure parser, we want to see values and locations |
|
|
of the tokens. */ |
|
103 |
#define YYPRINT(File, Type, Value) \ |
#define YYPRINT(File, Type, Value) \ |
104 |
yyprint (File, &yylloc, Type, &Value) |
yyprint (File, Type, &Value) |
105 |
static void yyprint (FILE *file, const location_t *loc, |
static void yyprint (FILE *file, int type, const yystype *value); |
|
int type, const yystype *value); |
|
106 |
|
|
107 |
symbol_class current_class = unknown_sym; |
symbol_class current_class = unknown_sym; |
108 |
char *current_type = 0; |
char *current_type = 0; |
222 |
#endif |
#endif |
223 |
|
|
224 |
#ifndef YYSTYPE |
#ifndef YYSTYPE |
225 |
#line 91 "parse-gram.y" |
#line 88 "parse-gram.y" |
226 |
typedef union { |
typedef union { |
227 |
symbol_t *symbol; |
symbol_t *symbol; |
228 |
symbol_list_t *list; |
symbol_list_t *list; |
231 |
associativity assoc; |
associativity assoc; |
232 |
} yystype; |
} yystype; |
233 |
/* Line 232 of /usr/local/share/bison/bison.simple. */ |
/* Line 232 of /usr/local/share/bison/bison.simple. */ |
234 |
#line 238 "parse-gram.c" |
#line 235 "parse-gram.c" |
235 |
# define YYSTYPE yystype |
# define YYSTYPE yystype |
236 |
# define YYSTYPE_IS_TRIVIAL 1 |
# define YYSTYPE_IS_TRIVIAL 1 |
237 |
#endif |
#endif |
252 |
|
|
253 |
|
|
254 |
/* Line 252 of /usr/local/share/bison/bison.simple. */ |
/* Line 252 of /usr/local/share/bison/bison.simple. */ |
255 |
#line 259 "parse-gram.c" |
#line 256 "parse-gram.c" |
256 |
|
|
257 |
#if ! defined (yyoverflow) || YYERROR_VERBOSE |
#if ! defined (yyoverflow) || YYERROR_VERBOSE |
258 |
|
|
441 |
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
442 |
static const unsigned short yyrline[] = |
static const unsigned short yyrline[] = |
443 |
{ |
{ |
444 |
0, 158, 158, 171, 173, 176, 178, 179, 180, 181, |
0, 155, 155, 168, 170, 173, 175, 176, 177, 178, |
445 |
182, 183, 184, 185, 186, 187, 188, 189, 190, 191, |
179, 180, 181, 182, 183, 184, 185, 186, 187, 188, |
446 |
192, 193, 196, 198, 199, 203, 210, 209, 220, 219, |
189, 190, 193, 195, 196, 200, 207, 206, 217, 216, |
447 |
232, 231, 237, 237, 242, 251, 266, 268, 269, 272, |
229, 228, 234, 234, 239, 248, 263, 265, 266, 269, |
448 |
274, 279, 281, 285, 290, 295, 301, 307, 317, 320, |
271, 276, 278, 282, 287, 292, 298, 304, 314, 317, |
449 |
329, 331, 337, 339, 343, 342, 347, 349, 352, 355, |
326, 328, 334, 336, 340, 339, 344, 346, 349, 352, |
450 |
357, 359, 363, 365, 366, 369, 375, 384, 392, 397, |
354, 356, 360, 362, 363, 366, 372, 381, 389, 394, |
451 |
403, 405 |
400, 402 |
452 |
}; |
}; |
453 |
#endif |
#endif |
454 |
|
|
693 |
#ifdef YYLEX_PARAM |
#ifdef YYLEX_PARAM |
694 |
# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) |
# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) |
695 |
#else |
#else |
696 |
# define YYLEX yylex (&yylval, &yylloc, ) |
# define YYLEX yylex (&yylval, &yylloc) |
697 |
#endif |
#endif |
698 |
|
|
699 |
/* Enable debugging if requested. */ |
/* Enable debugging if requested. */ |
709 |
if (yydebug) \ |
if (yydebug) \ |
710 |
YYFPRINTF Args; \ |
YYFPRINTF Args; \ |
711 |
} while (0) |
} while (0) |
712 |
|
# define YYDSYMPRINT(Args) \ |
713 |
|
do { \ |
714 |
|
if (yydebug) \ |
715 |
|
yysymprint Args; \ |
716 |
|
} while (0) |
717 |
/* Nonzero means print parse trace. It is left uninitialized so that |
/* Nonzero means print parse trace. It is left uninitialized so that |
718 |
multiple parsers can coexist. */ |
multiple parsers can coexist. */ |
719 |
int yydebug; |
int yydebug; |
720 |
#else /* !YYDEBUG */ |
#else /* !YYDEBUG */ |
721 |
# define YYDPRINTF(Args) |
# define YYDPRINTF(Args) |
722 |
|
# define YYDSYMPRINT(Args) |
723 |
#endif /* !YYDEBUG */ |
#endif /* !YYDEBUG */ |
724 |
|
|
725 |
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
826 |
int yyparse (void); |
int yyparse (void); |
827 |
# endif |
# endif |
828 |
#endif |
#endif |
829 |
static void yydestructor (int symbol_type, YYSTYPE symbol_value); |
|
830 |
|
#if defined (__STDC__) || defined (__cplusplus) |
831 |
|
static void yydestructor (int yytype, |
832 |
|
YYSTYPE yyvalue, YYLTYPE yylocation); |
833 |
|
# if YYDEBUG |
834 |
|
static void yysymprint (FILE* out, int yytype, |
835 |
|
YYSTYPE yyvalue, YYLTYPE yylocation); |
836 |
|
# endif |
837 |
|
#endif |
838 |
|
|
839 |
|
|
840 |
|
|
1035 |
{ |
{ |
1036 |
yychar1 = YYTRANSLATE (yychar); |
yychar1 = YYTRANSLATE (yychar); |
1037 |
|
|
1038 |
#if YYDEBUG |
/* We have to keep this `#if YYDEBUG', since we use variables |
1039 |
/* We have to keep this `#if YYDEBUG', since we use variables |
which are defined only if `YYDEBUG' is set. */ |
1040 |
which are defined only if `YYDEBUG' is set. */ |
YYDPRINTF ((stderr, "Next token is ")); |
1041 |
if (yydebug) |
YYDSYMPRINT ((stderr, yychar1, yylval, yyloc)); |
1042 |
{ |
YYDPRINTF ((stderr, "\n")); |
|
YYFPRINTF (stderr, "Next token is %d (%s", |
|
|
yychar, yytname[yychar1]); |
|
|
/* Give the individual parser a way to print the precise |
|
|
meaning of a token, for further debugging info. */ |
|
|
# ifdef YYPRINT |
|
|
YYPRINT (stderr, yychar, yylval); |
|
|
# endif |
|
|
YYFPRINTF (stderr, ")\n"); |
|
|
} |
|
|
#endif |
|
1043 |
} |
} |
1044 |
|
|
1045 |
yyn += yychar1; |
yyn += yychar1; |
1137 |
switch (yyn) |
switch (yyn) |
1138 |
{ |
{ |
1139 |
case 2: |
case 2: |
1140 |
#line 160 "parse-gram.y" |
#line 157 "parse-gram.y" |
1141 |
{ |
{ |
1142 |
yycontrol->errcode = 0; |
yycontrol->errcode = 0; |
1143 |
epilogue_set (yyvsp[0].string, yylsp[0]); |
epilogue_set (yyvsp[0].string, yylsp[0]); |
1145 |
break; |
break; |
1146 |
|
|
1147 |
case 6: |
case 6: |
1148 |
#line 178 "parse-gram.y" |
#line 175 "parse-gram.y" |
1149 |
{ prologue_augment (yyvsp[0].string, yylsp[0]); } |
{ prologue_augment (yyvsp[0].string, yylsp[0]); } |
1150 |
break; |
break; |
1151 |
|
|
1152 |
case 7: |
case 7: |
1153 |
#line 179 "parse-gram.y" |
#line 176 "parse-gram.y" |
1154 |
{ debug_flag = 1; } |
{ debug_flag = 1; } |
1155 |
break; |
break; |
1156 |
|
|
1157 |
case 8: |
case 8: |
1158 |
#line 180 "parse-gram.y" |
#line 177 "parse-gram.y" |
1159 |
{ muscle_insert (yyvsp[-1].string, yyvsp[0].string); } |
{ muscle_insert (yyvsp[-1].string, yyvsp[0].string); } |
1160 |
break; |
break; |
1161 |
|
|
1162 |
case 9: |
case 9: |
1163 |
#line 181 "parse-gram.y" |
#line 178 "parse-gram.y" |
1164 |
{ defines_flag = 1; } |
{ defines_flag = 1; } |
1165 |
break; |
break; |
1166 |
|
|
1167 |
case 10: |
case 10: |
1168 |
#line 182 "parse-gram.y" |
#line 179 "parse-gram.y" |
1169 |
{ error_verbose = 1; } |
{ error_verbose = 1; } |
1170 |
break; |
break; |
1171 |
|
|
1172 |
case 11: |
case 11: |
1173 |
#line 183 "parse-gram.y" |
#line 180 "parse-gram.y" |
1174 |
{ expected_conflicts = yyvsp[0].integer; } |
{ expected_conflicts = yyvsp[0].integer; } |
1175 |
break; |
break; |
1176 |
|
|
1177 |
case 12: |
case 12: |
1178 |
#line 184 "parse-gram.y" |
#line 181 "parse-gram.y" |
1179 |
{ spec_file_prefix = yyvsp[0].string; } |
{ spec_file_prefix = yyvsp[0].string; } |
1180 |
break; |
break; |
1181 |
|
|
1182 |
case 13: |
case 13: |
1183 |
#line 185 "parse-gram.y" |
#line 182 "parse-gram.y" |
1184 |
{ locations_flag = 1; } |
{ locations_flag = 1; } |
1185 |
break; |
break; |
1186 |
|
|
1187 |
case 14: |
case 14: |
1188 |
#line 186 "parse-gram.y" |
#line 183 "parse-gram.y" |
1189 |
{ spec_name_prefix = yyvsp[0].string; } |
{ spec_name_prefix = yyvsp[0].string; } |
1190 |
break; |
break; |
1191 |
|
|
1192 |
case 15: |
case 15: |
1193 |
#line 187 "parse-gram.y" |
#line 184 "parse-gram.y" |
1194 |
{ no_lines_flag = 1; } |
{ no_lines_flag = 1; } |
1195 |
break; |
break; |
1196 |
|
|
1197 |
case 16: |
case 16: |
1198 |
#line 188 "parse-gram.y" |
#line 185 "parse-gram.y" |
1199 |
{ spec_outfile = yyvsp[0].string; } |
{ spec_outfile = yyvsp[0].string; } |
1200 |
break; |
break; |
1201 |
|
|
1202 |
case 17: |
case 17: |
1203 |
#line 189 "parse-gram.y" |
#line 186 "parse-gram.y" |
1204 |
{ pure_parser = 1; } |
{ pure_parser = 1; } |
1205 |
break; |
break; |
1206 |
|
|
1207 |
case 18: |
case 18: |
1208 |
#line 190 "parse-gram.y" |
#line 187 "parse-gram.y" |
1209 |
{ skeleton = yyvsp[0].string; } |
{ skeleton = yyvsp[0].string; } |
1210 |
break; |
break; |
1211 |
|
|
1212 |
case 19: |
case 19: |
1213 |
#line 191 "parse-gram.y" |
#line 188 "parse-gram.y" |
1214 |
{ token_table_flag = 1; } |
{ token_table_flag = 1; } |
1215 |
break; |
break; |
1216 |
|
|
1217 |
case 20: |
case 20: |
1218 |
#line 192 "parse-gram.y" |
#line 189 "parse-gram.y" |
1219 |
{ report_flag = 1; } |
{ report_flag = 1; } |
1220 |
break; |
break; |
1221 |
|
|
1222 |
case 21: |
case 21: |
1223 |
#line 193 "parse-gram.y" |
#line 190 "parse-gram.y" |
1224 |
{ yacc_flag = 1; } |
{ yacc_flag = 1; } |
1225 |
break; |
break; |
1226 |
|
|
1227 |
case 24: |
case 24: |
1228 |
#line 200 "parse-gram.y" |
#line 197 "parse-gram.y" |
1229 |
{ |
{ |
1230 |
grammar_start_symbol_set (yyvsp[0].symbol, yylsp[0]); |
grammar_start_symbol_set (yyvsp[0].symbol, yylsp[0]); |
1231 |
} |
} |
1232 |
break; |
break; |
1233 |
|
|
1234 |
case 25: |
case 25: |
1235 |
#line 204 "parse-gram.y" |
#line 201 "parse-gram.y" |
1236 |
{ |
{ |
1237 |
typed = 1; |
typed = 1; |
1238 |
MUSCLE_INSERT_INT ("stype_line", yylsp[0].first_line); |
MUSCLE_INSERT_INT ("stype_line", yylsp[0].first_line); |
1241 |
break; |
break; |
1242 |
|
|
1243 |
case 26: |
case 26: |
1244 |
#line 210 "parse-gram.y" |
#line 207 "parse-gram.y" |
1245 |
{ current_braced_code = destructor_braced_code; } |
{ current_braced_code = destructor_braced_code; } |
1246 |
break; |
break; |
1247 |
|
|
1248 |
case 27: |
case 27: |
1249 |
#line 212 "parse-gram.y" |
#line 209 "parse-gram.y" |
1250 |
{ |
{ |
1251 |
symbol_list_t *list; |
symbol_list_t *list; |
1252 |
for (list = yyvsp[0].list; list; list = list->next) |
for (list = yyvsp[0].list; list; list = list->next) |
1257 |
break; |
break; |
1258 |
|
|
1259 |
case 28: |
case 28: |
1260 |
#line 220 "parse-gram.y" |
#line 217 "parse-gram.y" |
1261 |
{ current_braced_code = printer_braced_code; } |
{ current_braced_code = printer_braced_code; } |
1262 |
break; |
break; |
1263 |
|
|
1264 |
case 29: |
case 29: |
1265 |
#line 222 "parse-gram.y" |
#line 219 "parse-gram.y" |
1266 |
{ |
{ |
1267 |
symbol_list_t *list; |
symbol_list_t *list; |
1268 |
for (list = yyvsp[0].list; list; list = list->next) |
for (list = yyvsp[0].list; list; list = list->next) |
1273 |
break; |
break; |
1274 |
|
|
1275 |
case 30: |
case 30: |
1276 |
#line 232 "parse-gram.y" |
#line 229 "parse-gram.y" |
1277 |
{ current_class = nterm_sym; } |
{ current_class = nterm_sym; } |
1278 |
break; |
break; |
1279 |
|
|
1280 |
case 31: |
case 31: |
1281 |
#line 233 "parse-gram.y" |
#line 230 "parse-gram.y" |
1282 |
{ |
{ |
1283 |
current_class = unknown_sym; |
current_class = unknown_sym; |
1284 |
current_type = NULL; |
current_type = NULL; |
1286 |
break; |
break; |
1287 |
|
|
1288 |
case 32: |
case 32: |
1289 |
#line 237 "parse-gram.y" |
#line 234 "parse-gram.y" |
1290 |
{ current_class = token_sym; } |
{ current_class = token_sym; } |
1291 |
break; |
break; |
1292 |
|
|
1293 |
case 33: |
case 33: |
1294 |
#line 238 "parse-gram.y" |
#line 235 "parse-gram.y" |
1295 |
{ |
{ |
1296 |
current_class = unknown_sym; |
current_class = unknown_sym; |
1297 |
current_type = NULL; |
current_type = NULL; |
1299 |
break; |
break; |
1300 |
|
|
1301 |
case 34: |
case 34: |
1302 |
#line 243 "parse-gram.y" |
#line 240 "parse-gram.y" |
1303 |
{ |
{ |
1304 |
symbol_list_t *list; |
symbol_list_t *list; |
1305 |
for (list = yyvsp[0].list; list; list = list->next) |
for (list = yyvsp[0].list; list; list = list->next) |
1309 |
break; |
break; |
1310 |
|
|
1311 |
case 35: |
case 35: |
1312 |
#line 253 "parse-gram.y" |
#line 250 "parse-gram.y" |
1313 |
{ |
{ |
1314 |
symbol_list_t *list; |
symbol_list_t *list; |
1315 |
++current_prec; |
++current_prec; |
1324 |
break; |
break; |
1325 |
|
|
1326 |
case 36: |
case 36: |
1327 |
#line 267 "parse-gram.y" |
#line 264 "parse-gram.y" |
1328 |
{ yyval.assoc = left_assoc; } |
{ yyval.assoc = left_assoc; } |
1329 |
break; |
break; |
1330 |
|
|
1331 |
case 37: |
case 37: |
1332 |
#line 268 "parse-gram.y" |
#line 265 "parse-gram.y" |
1333 |
{ yyval.assoc = right_assoc; } |
{ yyval.assoc = right_assoc; } |
1334 |
break; |
break; |
1335 |
|
|
1336 |
case 38: |
case 38: |
1337 |
#line 269 "parse-gram.y" |
#line 266 "parse-gram.y" |
1338 |
{ yyval.assoc = non_assoc; } |
{ yyval.assoc = non_assoc; } |
1339 |
break; |
break; |
1340 |
|
|
1341 |
case 39: |
case 39: |
1342 |
#line 273 "parse-gram.y" |
#line 270 "parse-gram.y" |
1343 |
{ current_type = NULL;} |
{ current_type = NULL;} |
1344 |
break; |
break; |
1345 |
|
|
1346 |
case 40: |
case 40: |
1347 |
#line 274 "parse-gram.y" |
#line 271 "parse-gram.y" |
1348 |
{ current_type = yyvsp[0].string; } |
{ current_type = yyvsp[0].string; } |
1349 |
break; |
break; |
1350 |
|
|
1351 |
case 41: |
case 41: |
1352 |
#line 280 "parse-gram.y" |
#line 277 "parse-gram.y" |
1353 |
{ yyval.list = symbol_list_new (yyvsp[0].symbol, yylsp[0]); } |
{ yyval.list = symbol_list_new (yyvsp[0].symbol, yylsp[0]); } |
1354 |
break; |
break; |
1355 |
|
|
1356 |
case 42: |
case 42: |
1357 |
#line 281 "parse-gram.y" |
#line 278 "parse-gram.y" |
1358 |
{ yyval.list = symbol_list_prepend (yyvsp[-1].list, yyvsp[0].symbol, yylsp[0]); } |
{ yyval.list = symbol_list_prepend (yyvsp[-1].list, yyvsp[0].symbol, yylsp[0]); } |
1359 |
break; |
break; |
1360 |
|
|
1361 |
case 43: |
case 43: |
1362 |
#line 287 "parse-gram.y" |
#line 284 "parse-gram.y" |
1363 |
{ |
{ |
1364 |
current_type = yyvsp[0].string; |
current_type = yyvsp[0].string; |
1365 |
} |
} |
1366 |
break; |
break; |
1367 |
|
|
1368 |
case 44: |
case 44: |
1369 |
#line 291 "parse-gram.y" |
#line 288 "parse-gram.y" |
1370 |
{ |
{ |
1371 |
symbol_class_set (yyvsp[0].symbol, current_class); |
symbol_class_set (yyvsp[0].symbol, current_class, yylsp[0]); |
1372 |
symbol_type_set (yyvsp[0].symbol, yylsp[0], current_type); |
symbol_type_set (yyvsp[0].symbol, yylsp[0], current_type); |
1373 |
} |
} |
1374 |
break; |
break; |
1375 |
|
|
1376 |
case 45: |
case 45: |
1377 |
#line 296 "parse-gram.y" |
#line 293 "parse-gram.y" |
1378 |
{ |
{ |
1379 |
symbol_class_set (yyvsp[-1].symbol, current_class); |
symbol_class_set (yyvsp[-1].symbol, current_class, yylsp[-1]); |
1380 |
symbol_type_set (yyvsp[-1].symbol, yylsp[-1], current_type); |
symbol_type_set (yyvsp[-1].symbol, yylsp[-1], current_type); |
1381 |
symbol_user_token_number_set (yyvsp[-1].symbol, yyvsp[0].integer); |
symbol_user_token_number_set (yyvsp[-1].symbol, yyvsp[0].integer, yylsp[0]); |
1382 |
} |
} |
1383 |
break; |
break; |
1384 |
|
|
1385 |
case 46: |
case 46: |
1386 |
#line 302 "parse-gram.y" |
#line 299 "parse-gram.y" |
1387 |
{ |
{ |
1388 |
symbol_class_set (yyvsp[-1].symbol, current_class); |
symbol_class_set (yyvsp[-1].symbol, current_class, yylsp[-1]); |
1389 |
symbol_type_set (yyvsp[-1].symbol, yylsp[-1], current_type); |
symbol_type_set (yyvsp[-1].symbol, yylsp[-1], current_type); |
1390 |
symbol_make_alias (yyvsp[-1].symbol, yyvsp[0].symbol); |
symbol_make_alias (yyvsp[-1].symbol, yyvsp[0].symbol); |
1391 |
} |
} |
1392 |
break; |
break; |
1393 |
|
|
1394 |
case 47: |
case 47: |
1395 |
#line 308 "parse-gram.y" |
#line 305 "parse-gram.y" |
1396 |
{ |
{ |
1397 |
symbol_class_set (yyvsp[-2].symbol, current_class); |
symbol_class_set (yyvsp[-2].symbol, current_class, yylsp[-2]); |
1398 |
symbol_type_set (yyvsp[-2].symbol, yylsp[-2], current_type); |
symbol_type_set (yyvsp[-2].symbol, yylsp[-2], current_type); |
1399 |
symbol_user_token_number_set (yyvsp[-2].symbol, yyvsp[-1].integer); |
symbol_user_token_number_set (yyvsp[-2].symbol, yyvsp[-1].integer, yylsp[-1]); |
1400 |
symbol_make_alias (yyvsp[-2].symbol, yyvsp[0].symbol); |
symbol_make_alias (yyvsp[-2].symbol, yyvsp[0].symbol); |
1401 |
} |
} |
1402 |
break; |
break; |
1403 |
|
|
1404 |
case 48: |
case 48: |
1405 |
#line 319 "parse-gram.y" |
#line 316 "parse-gram.y" |
1406 |
{;} |
{;} |
1407 |
break; |
break; |
1408 |
|
|
1409 |
case 49: |
case 49: |
1410 |
#line 321 "parse-gram.y" |
#line 318 "parse-gram.y" |
1411 |
{;} |
{;} |
1412 |
break; |
break; |
1413 |
|
|
1414 |
case 54: |
case 54: |
1415 |
#line 343 "parse-gram.y" |
#line 340 "parse-gram.y" |
1416 |
{ current_lhs = yyvsp[-1].symbol; current_lhs_location = yylsp[-1]; } |
{ current_lhs = yyvsp[-1].symbol; current_lhs_location = yylsp[-1]; } |
1417 |
break; |
break; |
1418 |
|
|
1419 |
case 55: |
case 55: |
1420 |
#line 344 "parse-gram.y" |
#line 341 "parse-gram.y" |
1421 |
{;} |
{;} |
1422 |
break; |
break; |
1423 |
|
|
1424 |
case 56: |
case 56: |
1425 |
#line 348 "parse-gram.y" |
#line 345 "parse-gram.y" |
1426 |
{ grammar_rule_end (yylsp[0]); } |
{ grammar_rule_end (yylsp[0]); } |
1427 |
break; |
break; |
1428 |
|
|
1429 |
case 57: |
case 57: |
1430 |
#line 349 "parse-gram.y" |
#line 346 "parse-gram.y" |
1431 |
{ grammar_rule_end (yylsp[0]); } |
{ grammar_rule_end (yylsp[0]); } |
1432 |
break; |
break; |
1433 |
|
|
1434 |
case 58: |
case 58: |
1435 |
#line 354 "parse-gram.y" |
#line 351 "parse-gram.y" |
1436 |
{ grammar_rule_begin (current_lhs, current_lhs_location); } |
{ grammar_rule_begin (current_lhs, current_lhs_location); } |
1437 |
break; |
break; |
1438 |
|
|
1439 |
case 59: |
case 59: |
1440 |
#line 356 "parse-gram.y" |
#line 353 "parse-gram.y" |
1441 |
{ grammar_current_rule_symbol_append (yyvsp[0].symbol, yylsp[0]); } |
{ grammar_current_rule_symbol_append (yyvsp[0].symbol, yylsp[0]); } |
1442 |
break; |
break; |
1443 |
|
|
1444 |
case 60: |
case 60: |
1445 |
#line 358 "parse-gram.y" |
#line 355 "parse-gram.y" |
1446 |
{ grammar_current_rule_action_append (yyvsp[0].string, yylsp[0]); } |
{ grammar_current_rule_action_append (yyvsp[0].string, yylsp[0]); } |
1447 |
break; |
break; |
1448 |
|
|
1449 |
case 61: |
case 61: |
1450 |
#line 360 "parse-gram.y" |
#line 357 "parse-gram.y" |
1451 |
{ grammar_current_rule_prec_set (yyvsp[0].symbol); } |
{ grammar_current_rule_prec_set (yyvsp[0].symbol, yylsp[0]); } |
1452 |
break; |
break; |
1453 |
|
|
1454 |
case 62: |
case 62: |
1455 |
#line 364 "parse-gram.y" |
#line 361 "parse-gram.y" |
1456 |
{ yyval.symbol = yyvsp[0].symbol; } |
{ yyval.symbol = yyvsp[0].symbol; } |
1457 |
break; |
break; |
1458 |
|
|
1459 |
case 63: |
case 63: |
1460 |
#line 365 "parse-gram.y" |
#line 362 "parse-gram.y" |
1461 |
{ yyval.symbol = yyvsp[0].symbol; } |
{ yyval.symbol = yyvsp[0].symbol; } |
1462 |
break; |
break; |
1463 |
|
|
1464 |
case 64: |
case 64: |
1465 |
#line 366 "parse-gram.y" |
#line 363 "parse-gram.y" |
1466 |
{ yyval.symbol = getsym (yyvsp[0].string, yylsp[0]); } |
{ yyval.symbol = getsym (yyvsp[0].string, yylsp[0]); } |
1467 |
break; |
break; |
1468 |
|
|
1469 |
case 65: |
case 65: |
1470 |
#line 371 "parse-gram.y" |
#line 368 "parse-gram.y" |
1471 |
{ yyval.string = yyvsp[0].string; } |
{ yyval.string = yyvsp[0].string; } |
1472 |
break; |
break; |
1473 |
|
|
1474 |
case 66: |
case 66: |
1475 |
#line 377 "parse-gram.y" |
#line 374 "parse-gram.y" |
1476 |
{ |
{ |
1477 |
yyval.symbol = getsym (yyvsp[0].string, yylsp[0]); |
yyval.symbol = getsym (yyvsp[0].string, yylsp[0]); |
1478 |
symbol_class_set (yyval.symbol, token_sym); |
symbol_class_set (yyval.symbol, token_sym, yylsp[0]); |
1479 |
} |
} |
1480 |
break; |
break; |
1481 |
|
|
1482 |
case 67: |
case 67: |
1483 |
#line 386 "parse-gram.y" |
#line 383 "parse-gram.y" |
1484 |
{ |
{ |
1485 |
yyval.string = yyvsp[0].string + 1; |
yyval.string = yyvsp[0].string + 1; |
1486 |
yyval.string[strlen (yyval.string) - 1] = '\0'; |
yyval.string[strlen (yyval.string) - 1] = '\0'; |
1488 |
break; |
break; |
1489 |
|
|
1490 |
case 68: |
case 68: |
1491 |
#line 394 "parse-gram.y" |
#line 391 "parse-gram.y" |
1492 |
{ |
{ |
1493 |
yyval.string = xstrdup (""); |
yyval.string = xstrdup (""); |
1494 |
} |
} |
1495 |
break; |
break; |
1496 |
|
|
1497 |
case 69: |
case 69: |
1498 |
#line 398 "parse-gram.y" |
#line 395 "parse-gram.y" |
1499 |
{ |
{ |
1500 |
yyval.string = yyvsp[0].string; |
yyval.string = yyvsp[0].string; |
1501 |
} |
} |
1504 |
|
|
1505 |
} |
} |
1506 |
|
|
1507 |
/* Line 996 of /usr/local/share/bison/bison.simple. */ |
/* Line 1000 of /usr/local/share/bison/bison.simple. */ |
1508 |
#line 1508 "parse-gram.c" |
#line 1509 "parse-gram.c" |
1509 |
|
|
1510 |
yyvsp -= yylen; |
yyvsp -= yylen; |
1511 |
yyssp -= yylen; |
yyssp -= yylen; |
1617 |
/* Pop the rest of the stack. */ |
/* Pop the rest of the stack. */ |
1618 |
while (yyssp > yyss) |
while (yyssp > yyss) |
1619 |
{ |
{ |
1620 |
#if YYDEBUG |
YYDPRINTF ((stderr, "Error: popping ")); |
1621 |
if (yydebug) |
YYDSYMPRINT ((stderr, |
1622 |
{ |
yystos[*yyssp], |
1623 |
if (yystos[*yyssp] < YYNTOKENS) |
*yyvsp, *yylsp)); |
1624 |
{ |
YYDPRINTF ((stderr, "\n")); |
1625 |
YYFPRINTF (stderr, "Error: popping token %d (%s", |
yydestructor (yystos[*yyssp], *yyvsp, *yylsp); |
|
yytoknum[yystos[*yyssp]], |
|
|
yytname[yystos[*yyssp]]); |
|
|
# ifdef YYPRINT |
|
|
YYPRINT (stderr, yytoknum[yystos[*yyssp]], *yyvsp); |
|
|
# endif |
|
|
YYFPRINTF (stderr, ")\n"); |
|
|
} |
|
|
else |
|
|
{ |
|
|
YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n", |
|
|
yytname[yystos[*yyssp]]); |
|
|
} |
|
|
} |
|
|
#endif |
|
|
yydestructor (yystos[*yyssp], *yyvsp); |
|
1626 |
YYPOPSTACK; |
YYPOPSTACK; |
1627 |
} |
} |
1628 |
YYABORT; |
YYABORT; |
1630 |
|
|
1631 |
YYDPRINTF ((stderr, "Discarding token %d (%s).\n", |
YYDPRINTF ((stderr, "Discarding token %d (%s).\n", |
1632 |
yychar, yytname[yychar1])); |
yychar, yytname[yychar1])); |
1633 |
yydestructor (yychar1, yylval); |
yydestructor (yychar1, yylval, yylloc); |
1634 |
yychar = YYEMPTY; |
yychar = YYEMPTY; |
1635 |
} |
} |
1636 |
|
|
1657 |
if (yyssp == yyss) |
if (yyssp == yyss) |
1658 |
YYABORT; |
YYABORT; |
1659 |
|
|
1660 |
#if YYDEBUG |
YYDPRINTF ((stderr, "Error: popping ")); |
1661 |
if (yydebug) |
YYDSYMPRINT ((stderr, |
1662 |
{ |
yystos[*yyssp], *yyvsp, *yylsp)); |
1663 |
if (yystos[yystate] < YYNTOKENS) |
YYDPRINTF ((stderr, "\n")); |
|
{ |
|
|
YYFPRINTF (stderr, "Error: popping token %d (%s", |
|
|
yytoknum[yystos[yystate]], yytname[yystos[yystate]]); |
|
|
# ifdef YYPRINT |
|
|
YYPRINT (stderr, yytoknum[yystos[yystate]], *yyvsp); |
|
|
# endif |
|
|
YYFPRINTF (stderr, ")\n"); |
|
|
} |
|
|
else |
|
|
{ |
|
|
YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n", |
|
|
yytname[yystos[yystate]]); |
|
|
} |
|
|
} |
|
|
#endif |
|
1664 |
|
|
1665 |
yydestructor (yystos[yystate], *yyvsp); |
yydestructor (yystos[yystate], *yyvsp, *yylsp); |
1666 |
yyvsp--; |
yyvsp--; |
1667 |
yystate = *--yyssp; |
yystate = *--yyssp; |
1668 |
yylsp--; |
yylsp--; |
1724 |
} |
} |
1725 |
|
|
1726 |
|
|
1727 |
/*-------------------------------------------------. |
/*-----------------------------------------------. |
1728 |
| Release the memory associated to SYMBOL-NUMBER. | |
| Release the memory associated to this symbol. | |
1729 |
`-------------------------------------------------*/ |
`-----------------------------------------------*/ |
1730 |
|
|
1731 |
|
static void |
1732 |
|
yydestructor (int yytype, |
1733 |
|
YYSTYPE yyvalue, YYLTYPE yylocation) |
1734 |
|
{ |
1735 |
|
switch (yytype) |
1736 |
|
{ |
1737 |
|
default: |
1738 |
|
break; |
1739 |
|
} |
1740 |
|
} |
1741 |
|
|
1742 |
|
|
1743 |
|
#if YYDEBUG |
1744 |
|
/*-----------------------------. |
1745 |
|
| Print this symbol on YYOUT. | |
1746 |
|
`-----------------------------*/ |
1747 |
|
|
1748 |
static void |
static void |
1749 |
yydestructor (int symbol_type, YYSTYPE symbol_value) |
yysymprint (FILE* yyout, int yytype, |
1750 |
|
YYSTYPE yyvalue, YYLTYPE yylocation) |
1751 |
{ |
{ |
1752 |
switch (symbol_type) |
if (yytype < YYNTOKENS) |
1753 |
|
YYFPRINTF (yyout, "token %s (", yytname[yytype]); |
1754 |
|
else |
1755 |
|
YYFPRINTF (yyout, "nterm %s (", yytname[yytype]); |
1756 |
|
# ifdef YYPRINT |
1757 |
|
YYPRINT (yyout, yytype, yyvalue); |
1758 |
|
# else |
1759 |
|
switch (yytype) |
1760 |
{ |
{ |
1761 |
default: |
default: |
|
YYDPRINTF ((stderr, "yydestructor: unknown symbol type: %d (%s)\n", |
|
|
symbol_type, yytname[symbol_type])); |
|
1762 |
break; |
break; |
1763 |
} |
} |
1764 |
|
# endif /* !defined YYPRINT. */ |
1765 |
|
YYFPRINTF (yyout, ")"); |
1766 |
} |
} |
1767 |
|
#endif /* YYDEBUG. */ |
1768 |
|
|
1769 |
#line 407 "parse-gram.y" |
#line 404 "parse-gram.y" |
1770 |
|
|
1771 |
/*------------------------------------------------------------------. |
/*------------------------------------------------------------------. |
1772 |
| When debugging the parser, display tokens' locations and values. | |
| When debugging the parser, display tokens' locations and values. | |
1774 |
|
|
1775 |
static void |
static void |
1776 |
yyprint (FILE *file, |
yyprint (FILE *file, |
1777 |
const location_t *loc, int type, const yystype *value) |
int type, const yystype *value) |
1778 |
{ |
{ |
1779 |
fputs (" (", file); |
fputc (' ', file); |
|
LOCATION_PRINT (file, *loc); |
|
|
fputs (")", file); |
|
1780 |
switch (type) |
switch (type) |
1781 |
{ |
{ |
1782 |
case CHARACTER: |
case CHARACTER: |