/[bison]/bison/src/scan-gram.c
ViewVC logotype

Diff of /bison/src/scan-gram.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.31 by akim, Fri Oct 11 11:23:19 2002 UTC revision 1.32 by eggert, Sun Oct 13 09:09:49 2002 UTC
# Line 709  int yy_flex_debug = 1; Line 709  int yy_flex_debug = 1;
709    
710  static yyconst short int yy_rule_linenum[101] =  static yyconst short int yy_rule_linenum[101] =
711      {   0,      {   0,
712        122,  123,  124,  125,  126,  127,  128,  129,  130,  131,        130,  131,  132,  133,  134,  135,  136,  137,  138,  139,
713        132,  133,  134,  135,  136,  137,  138,  139,  140,  141,        140,  141,  142,  143,  144,  145,  146,  147,  148,  149,
714        142,  143,  144,  145,  146,  147,  148,  149,  150,  151,        150,  151,  152,  153,  154,  155,  156,  157,  158,  159,
715        152,  153,  155,  156,  157,  158,  160,  161,  162,  167,        160,  161,  163,  164,  165,  166,  168,  169,  170,  176,
716        170,  173,  176,  177,  180,  183,  186,  194,  200,  216,        179,  182,  185,  186,  189,  192,  195,  203,  209,  225,
717        217,  228,  240,  241,  242,  259,  268,  270,  290,  305,        226,  237,  249,  250,  251,  268,  278,  280,  300,  316,
718        307,  327,  339,  343,  344,  345,  346,  347,  348,  349,        318,  338,  350,  354,  355,  356,  357,  358,  359,  360,
719        350,  351,  357,  368,  374,  375,  377,  379,  397,  403,        361,  362,  368,  379,  385,  386,  388,  390,  408,  414,
720        404,  406,  408,  426,  429,  432,  433,  436,  447,  458,        415,  417,  419,  437,  440,  443,  444,  447,  458,  470,
721        460,  462,  465,  466,  469,  489,  496,  497,  498,  518        472,  474,  477,  478,  481,  501,  508,  509,  510,  530
722    
723      } ;      } ;
724    
# Line 812  scanner_last_string_free (void) Line 812  scanner_last_string_free (void)
812  static int braces_level = 0;  static int braces_level = 0;
813  static int percent_percent_count = 0;  static int percent_percent_count = 0;
814    
815    /* Within well-formed rules, RULE_LENGTH is the number of values in
816       the current rule so far, which says where to find `$0' with respect
817       to the top of the stack.  It is not the same as the rule->length in
818       the case of mid rule actions.
819    
820       Outside of well-formed rules, RULE_LENGTH has an undefined value.  */
821    static int rule_length;
822    
823  static void handle_dollar PARAMS ((braced_code_t code_kind,  static void handle_dollar PARAMS ((braced_code_t code_kind,
824                                     char *cp, location_t location));                                     char *cp, location_t location));
825  static void handle_at PARAMS ((braced_code_t code_kind,  static void handle_at PARAMS ((braced_code_t code_kind,
# Line 829  static void handle_at PARAMS ((braced_co Line 837  static void handle_at PARAMS ((braced_co
837  #define SC_PROLOGUE 7  #define SC_PROLOGUE 7
838  #define SC_EPILOGUE 8  #define SC_EPILOGUE 8
839    
840  #line 833 "scan-gram.c"  #line 841 "scan-gram.c"
841    
842  /* Macros after this point can all be overridden by user definitions in  /* Macros after this point can all be overridden by user definitions in
843   * section 1.   * section 1.
# Line 991  YY_DECL Line 999  YY_DECL
999          register char *yy_cp, *yy_bp;          register char *yy_cp, *yy_bp;
1000          register int yy_act;          register int yy_act;
1001    
1002  #line 98 "scan-gram.l"  #line 106 "scan-gram.l"
1003    
1004    
1005    /* At each yylex invocation, mark the current position as the    /* At each yylex invocation, mark the current position as the
# Line 1014  YY_DECL Line 1022  YY_DECL
1022    /*----------------------------.    /*----------------------------.
1023    | Scanning Bison directives.  |    | Scanning Bison directives.  |
1024    `----------------------------*/    `----------------------------*/
1025  #line 1018 "scan-gram.c"  #line 1026 "scan-gram.c"
1026    
1027          if ( yy_init )          if ( yy_init )
1028                  {                  {
# Line 1116  do_action:     /* This label is used only to Line 1124  do_action:     /* This label is used only to
1124    
1125  case 1:  case 1:
1126  YY_RULE_SETUP  YY_RULE_SETUP
1127  #line 122 "scan-gram.l"  #line 130 "scan-gram.l"
1128  return PERCENT_NONASSOC;  return PERCENT_NONASSOC;
1129          YY_BREAK          YY_BREAK
1130  case 2:  case 2:
1131  YY_RULE_SETUP  YY_RULE_SETUP
1132  #line 123 "scan-gram.l"  #line 131 "scan-gram.l"
1133  return PERCENT_DEBUG;  return PERCENT_DEBUG;
1134          YY_BREAK          YY_BREAK
1135  case 3:  case 3:
1136  YY_RULE_SETUP  YY_RULE_SETUP
1137  #line 124 "scan-gram.l"  #line 132 "scan-gram.l"
1138  return PERCENT_DEFINE;  return PERCENT_DEFINE;
1139          YY_BREAK          YY_BREAK
1140  case 4:  case 4:
1141  YY_RULE_SETUP  YY_RULE_SETUP
1142  #line 125 "scan-gram.l"  #line 133 "scan-gram.l"
1143  return PERCENT_DEFINES;  return PERCENT_DEFINES;
1144          YY_BREAK          YY_BREAK
1145  case 5:  case 5:
1146  YY_RULE_SETUP  YY_RULE_SETUP
1147  #line 126 "scan-gram.l"  #line 134 "scan-gram.l"
1148  return PERCENT_DESTRUCTOR;  return PERCENT_DESTRUCTOR;
1149          YY_BREAK          YY_BREAK
1150  case 6:  case 6:
1151  YY_RULE_SETUP  YY_RULE_SETUP
1152  #line 127 "scan-gram.l"  #line 135 "scan-gram.l"
1153  return PERCENT_DPREC;  return PERCENT_DPREC;
1154          YY_BREAK          YY_BREAK
1155  case 7:  case 7:
1156  YY_RULE_SETUP  YY_RULE_SETUP
1157  #line 128 "scan-gram.l"  #line 136 "scan-gram.l"
1158  return PERCENT_ERROR_VERBOSE;  return PERCENT_ERROR_VERBOSE;
1159          YY_BREAK          YY_BREAK
1160  case 8:  case 8:
1161  YY_RULE_SETUP  YY_RULE_SETUP
1162  #line 129 "scan-gram.l"  #line 137 "scan-gram.l"
1163  return PERCENT_EXPECT;  return PERCENT_EXPECT;
1164          YY_BREAK          YY_BREAK
1165  case 9:  case 9:
1166  YY_RULE_SETUP  YY_RULE_SETUP
1167  #line 130 "scan-gram.l"  #line 138 "scan-gram.l"
1168  return PERCENT_FILE_PREFIX;  return PERCENT_FILE_PREFIX;
1169          YY_BREAK          YY_BREAK
1170  case 10:  case 10:
1171  YY_RULE_SETUP  YY_RULE_SETUP
1172  #line 131 "scan-gram.l"  #line 139 "scan-gram.l"
1173  return PERCENT_YACC;  return PERCENT_YACC;
1174          YY_BREAK          YY_BREAK
1175  case 11:  case 11:
1176  YY_RULE_SETUP  YY_RULE_SETUP
1177  #line 132 "scan-gram.l"  #line 140 "scan-gram.l"
1178  return PERCENT_GLR_PARSER;  return PERCENT_GLR_PARSER;
1179          YY_BREAK          YY_BREAK
1180  case 12:  case 12:
1181  YY_RULE_SETUP  YY_RULE_SETUP
1182  #line 133 "scan-gram.l"  #line 141 "scan-gram.l"
1183  return PERCENT_LEFT;  return PERCENT_LEFT;
1184          YY_BREAK          YY_BREAK
1185  case 13:  case 13:
1186  YY_RULE_SETUP  YY_RULE_SETUP
1187  #line 134 "scan-gram.l"  #line 142 "scan-gram.l"
1188  return PERCENT_LOCATIONS;  return PERCENT_LOCATIONS;
1189          YY_BREAK          YY_BREAK
1190  case 14:  case 14:
1191  YY_RULE_SETUP  YY_RULE_SETUP
1192  #line 135 "scan-gram.l"  #line 143 "scan-gram.l"
1193  return PERCENT_MERGE;  return PERCENT_MERGE;
1194          YY_BREAK          YY_BREAK
1195  case 15:  case 15:
1196  YY_RULE_SETUP  YY_RULE_SETUP
1197  #line 136 "scan-gram.l"  #line 144 "scan-gram.l"
1198  return PERCENT_NAME_PREFIX;  return PERCENT_NAME_PREFIX;
1199          YY_BREAK          YY_BREAK
1200  case 16:  case 16:
1201  YY_RULE_SETUP  YY_RULE_SETUP
1202  #line 137 "scan-gram.l"  #line 145 "scan-gram.l"
1203  return PERCENT_NO_LINES;  return PERCENT_NO_LINES;
1204          YY_BREAK          YY_BREAK
1205  case 17:  case 17:
1206  YY_RULE_SETUP  YY_RULE_SETUP
1207  #line 138 "scan-gram.l"  #line 146 "scan-gram.l"
1208  return PERCENT_NONASSOC;  return PERCENT_NONASSOC;
1209          YY_BREAK          YY_BREAK
1210  case 18:  case 18:
1211  YY_RULE_SETUP  YY_RULE_SETUP
1212  #line 139 "scan-gram.l"  #line 147 "scan-gram.l"
1213  return PERCENT_NTERM;  return PERCENT_NTERM;
1214          YY_BREAK          YY_BREAK
1215  case 19:  case 19:
1216  YY_RULE_SETUP  YY_RULE_SETUP
1217  #line 140 "scan-gram.l"  #line 148 "scan-gram.l"
1218  return PERCENT_OUTPUT;  return PERCENT_OUTPUT;
1219          YY_BREAK          YY_BREAK
1220  case 20:  case 20:
1221  YY_RULE_SETUP  YY_RULE_SETUP
1222  #line 141 "scan-gram.l"  #line 149 "scan-gram.l"
1223  return PERCENT_PREC;  { rule_length--; return PERCENT_PREC; }
1224          YY_BREAK          YY_BREAK
1225  case 21:  case 21:
1226  YY_RULE_SETUP  YY_RULE_SETUP
1227  #line 142 "scan-gram.l"  #line 150 "scan-gram.l"
1228  return PERCENT_PRINTER;  return PERCENT_PRINTER;
1229          YY_BREAK          YY_BREAK
1230  case 22:  case 22:
1231  YY_RULE_SETUP  YY_RULE_SETUP
1232  #line 143 "scan-gram.l"  #line 151 "scan-gram.l"
1233  return PERCENT_PURE_PARSER;  return PERCENT_PURE_PARSER;
1234          YY_BREAK          YY_BREAK
1235  case 23:  case 23:
1236  YY_RULE_SETUP  YY_RULE_SETUP
1237  #line 144 "scan-gram.l"  #line 152 "scan-gram.l"
1238  return PERCENT_RIGHT;  return PERCENT_RIGHT;
1239          YY_BREAK          YY_BREAK
1240  case 24:  case 24:
1241  YY_RULE_SETUP  YY_RULE_SETUP
1242  #line 145 "scan-gram.l"  #line 153 "scan-gram.l"
1243  return PERCENT_SKELETON;  return PERCENT_SKELETON;
1244          YY_BREAK          YY_BREAK
1245  case 25:  case 25:
1246  YY_RULE_SETUP  YY_RULE_SETUP
1247  #line 146 "scan-gram.l"  #line 154 "scan-gram.l"
1248  return PERCENT_START;  return PERCENT_START;
1249          YY_BREAK          YY_BREAK
1250  case 26:  case 26:
1251  YY_RULE_SETUP  YY_RULE_SETUP
1252  #line 147 "scan-gram.l"  #line 155 "scan-gram.l"
1253  return PERCENT_TOKEN;  return PERCENT_TOKEN;
1254          YY_BREAK          YY_BREAK
1255  case 27:  case 27:
1256  YY_RULE_SETUP  YY_RULE_SETUP
1257  #line 148 "scan-gram.l"  #line 156 "scan-gram.l"
1258  return PERCENT_TOKEN;  return PERCENT_TOKEN;
1259          YY_BREAK          YY_BREAK
1260  case 28:  case 28:
1261  YY_RULE_SETUP  YY_RULE_SETUP
1262  #line 149 "scan-gram.l"  #line 157 "scan-gram.l"
1263  return PERCENT_TOKEN_TABLE;  return PERCENT_TOKEN_TABLE;
1264          YY_BREAK          YY_BREAK
1265  case 29:  case 29:
1266  YY_RULE_SETUP  YY_RULE_SETUP
1267  #line 150 "scan-gram.l"  #line 158 "scan-gram.l"
1268  return PERCENT_TYPE;  return PERCENT_TYPE;
1269          YY_BREAK          YY_BREAK
1270  case 30:  case 30:
1271  YY_RULE_SETUP  YY_RULE_SETUP
1272  #line 151 "scan-gram.l"  #line 159 "scan-gram.l"
1273  return PERCENT_UNION;  return PERCENT_UNION;
1274          YY_BREAK          YY_BREAK
1275  case 31:  case 31:
1276  YY_RULE_SETUP  YY_RULE_SETUP
1277  #line 152 "scan-gram.l"  #line 160 "scan-gram.l"
1278  return PERCENT_VERBOSE;  return PERCENT_VERBOSE;
1279          YY_BREAK          YY_BREAK
1280  case 32:  case 32:
1281  YY_RULE_SETUP  YY_RULE_SETUP
1282  #line 153 "scan-gram.l"  #line 161 "scan-gram.l"
1283  return PERCENT_YACC;  return PERCENT_YACC;
1284          YY_BREAK          YY_BREAK
1285  case 33:  case 33:
1286  YY_RULE_SETUP  YY_RULE_SETUP
1287  #line 155 "scan-gram.l"  #line 163 "scan-gram.l"
1288  return EQUAL;  return EQUAL;
1289          YY_BREAK          YY_BREAK
1290  case 34:  case 34:
1291  YY_RULE_SETUP  YY_RULE_SETUP
1292  #line 156 "scan-gram.l"  #line 164 "scan-gram.l"
1293  return COLON;  { rule_length = 0; return COLON; }
1294          YY_BREAK          YY_BREAK
1295  case 35:  case 35:
1296  YY_RULE_SETUP  YY_RULE_SETUP
1297  #line 157 "scan-gram.l"  #line 165 "scan-gram.l"
1298  return PIPE;  { rule_length = 0; return PIPE; }
1299          YY_BREAK          YY_BREAK
1300  case 36:  case 36:
1301  YY_RULE_SETUP  YY_RULE_SETUP
1302  #line 158 "scan-gram.l"  #line 166 "scan-gram.l"
1303  return SEMICOLON;  return SEMICOLON;
1304          YY_BREAK          YY_BREAK
1305  case 37:  case 37:
1306  YY_RULE_SETUP  YY_RULE_SETUP
1307  #line 160 "scan-gram.l"  #line 168 "scan-gram.l"
1308  YY_LINES; YY_STEP;  YY_LINES; YY_STEP;
1309          YY_BREAK          YY_BREAK
1310  case 38:  case 38:
1311  YY_RULE_SETUP  YY_RULE_SETUP
1312  #line 161 "scan-gram.l"  #line 169 "scan-gram.l"
1313  YY_STEP;  YY_STEP;
1314          YY_BREAK          YY_BREAK
1315  case 39:  case 39:
1316  YY_RULE_SETUP  YY_RULE_SETUP
1317  #line 162 "scan-gram.l"  #line 170 "scan-gram.l"
1318  {  {
1319      yylval->symbol = symbol_get (yytext, *yylloc);      yylval->symbol = symbol_get (yytext, *yylloc);
1320        rule_length++;
1321      return ID;      return ID;
1322    }    }
1323          YY_BREAK          YY_BREAK
1324  case 40:  case 40:
1325  YY_RULE_SETUP  YY_RULE_SETUP
1326  #line 167 "scan-gram.l"  #line 176 "scan-gram.l"
1327  yylval->integer = strtol (yytext, 0, 10); return INT;  yylval->integer = strtol (yytext, 0, 10); return INT;
1328          YY_BREAK          YY_BREAK
1329  /* Characters.  We don't check there is only one.  */  /* Characters.  We don't check there is only one.  */
1330  case 41:  case 41:
1331  YY_RULE_SETUP  YY_RULE_SETUP
1332  #line 170 "scan-gram.l"  #line 179 "scan-gram.l"
1333  YY_OBS_GROW; yy_push_state (SC_ESCAPED_CHARACTER);  YY_OBS_GROW; yy_push_state (SC_ESCAPED_CHARACTER);
1334          YY_BREAK          YY_BREAK
1335  /* Strings. */  /* Strings. */
1336  case 42:  case 42:
1337  YY_RULE_SETUP  YY_RULE_SETUP
1338  #line 173 "scan-gram.l"  #line 182 "scan-gram.l"
1339  YY_OBS_GROW; yy_push_state (SC_ESCAPED_STRING);  YY_OBS_GROW; yy_push_state (SC_ESCAPED_STRING);
1340          YY_BREAK          YY_BREAK
1341  /* Comments. */  /* Comments. */
1342  case 43:  case 43:
1343  YY_RULE_SETUP  YY_RULE_SETUP
1344  #line 176 "scan-gram.l"  #line 185 "scan-gram.l"
1345  yy_push_state (SC_COMMENT);  yy_push_state (SC_COMMENT);
1346          YY_BREAK          YY_BREAK
1347  case 44:  case 44:
1348  YY_RULE_SETUP  YY_RULE_SETUP
1349  #line 177 "scan-gram.l"  #line 186 "scan-gram.l"
1350  YY_STEP;  YY_STEP;
1351          YY_BREAK          YY_BREAK
1352  /* Prologue. */  /* Prologue. */
1353  case 45:  case 45:
1354  YY_RULE_SETUP  YY_RULE_SETUP
1355  #line 180 "scan-gram.l"  #line 189 "scan-gram.l"
1356  yy_push_state (SC_PROLOGUE);  yy_push_state (SC_PROLOGUE);
1357          YY_BREAK          YY_BREAK
1358  /* Code in between braces.  */  /* Code in between braces.  */
1359  case 46:  case 46:
1360  YY_RULE_SETUP  YY_RULE_SETUP
1361  #line 183 "scan-gram.l"  #line 192 "scan-gram.l"
1362  YY_OBS_GROW; ++braces_level; yy_push_state (SC_BRACED_CODE);  YY_OBS_GROW; ++braces_level; yy_push_state (SC_BRACED_CODE);
1363          YY_BREAK          YY_BREAK
1364  /* A type. */  /* A type. */
1365  case 47:  case 47:
1366  YY_RULE_SETUP  YY_RULE_SETUP
1367  #line 186 "scan-gram.l"  #line 195 "scan-gram.l"
1368  {  {
1369      obstack_grow (&string_obstack, yytext + 1, yyleng - 2);      obstack_grow (&string_obstack, yytext + 1, yyleng - 2);
1370      YY_OBS_FINISH;      YY_OBS_FINISH;
# Line 1365  YY_RULE_SETUP Line 1374  YY_RULE_SETUP
1374          YY_BREAK          YY_BREAK
1375  case 48:  case 48:
1376  YY_RULE_SETUP  YY_RULE_SETUP
1377  #line 194 "scan-gram.l"  #line 203 "scan-gram.l"
1378  {  {
1379      if (++percent_percent_count == 2)      if (++percent_percent_count == 2)
1380        yy_push_state (SC_EPILOGUE);        yy_push_state (SC_EPILOGUE);
# Line 1374  YY_RULE_SETUP Line 1383  YY_RULE_SETUP
1383          YY_BREAK          YY_BREAK
1384  case 49:  case 49:
1385  YY_RULE_SETUP  YY_RULE_SETUP
1386  #line 200 "scan-gram.l"  #line 209 "scan-gram.l"
1387  {  {
1388      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1389      fprintf (stderr, _(": invalid character: `%c'\n"), *yytext);      fprintf (stderr, _(": invalid character: `%c'\n"), *yytext);
# Line 1391  YY_RULE_SETUP Line 1400  YY_RULE_SETUP
1400    
1401  case 50:  case 50:
1402  YY_RULE_SETUP  YY_RULE_SETUP
1403  #line 216 "scan-gram.l"  #line 225 "scan-gram.l"
1404  if (YY_START != SC_COMMENT) obstack_sgrow (&string_obstack, "@<:@");  if (YY_START != SC_COMMENT) obstack_sgrow (&string_obstack, "@<:@");
1405          YY_BREAK          YY_BREAK
1406  case 51:  case 51:
1407  YY_RULE_SETUP  YY_RULE_SETUP
1408  #line 217 "scan-gram.l"  #line 226 "scan-gram.l"
1409  if (YY_START != SC_COMMENT) obstack_sgrow (&string_obstack, "@:>@");  if (YY_START != SC_COMMENT) obstack_sgrow (&string_obstack, "@:>@");
1410          YY_BREAK          YY_BREAK
1411    
# Line 1407  if (YY_START != SC_COMMENT) obstack_sgro Line 1416  if (YY_START != SC_COMMENT) obstack_sgro
1416    
1417  case 52:  case 52:
1418  YY_RULE_SETUP  YY_RULE_SETUP
1419  #line 228 "scan-gram.l"  #line 237 "scan-gram.l"
1420  { /* End of the comment. */  { /* End of the comment. */
1421      if (yy_top_state () == INITIAL)      if (yy_top_state () == INITIAL)
1422        {        {
# Line 1422  YY_RULE_SETUP Line 1431  YY_RULE_SETUP
1431          YY_BREAK          YY_BREAK
1432  case 53:  case 53:
1433  YY_RULE_SETUP  YY_RULE_SETUP
1434  #line 240 "scan-gram.l"  #line 249 "scan-gram.l"
1435  if (yy_top_state () != INITIAL) YY_OBS_GROW;  if (yy_top_state () != INITIAL) YY_OBS_GROW;
1436          YY_BREAK          YY_BREAK
1437  case 54:  case 54:
1438  YY_RULE_SETUP  YY_RULE_SETUP
1439  #line 241 "scan-gram.l"  #line 250 "scan-gram.l"
1440  if (yy_top_state () != INITIAL) YY_OBS_GROW; YY_LINES;  if (yy_top_state () != INITIAL) YY_OBS_GROW; YY_LINES;
1441          YY_BREAK          YY_BREAK
1442  case 55:  case 55:
1443  YY_RULE_SETUP  YY_RULE_SETUP
1444  #line 242 "scan-gram.l"  #line 251 "scan-gram.l"
1445  /* Stray `*'. */if (yy_top_state () != INITIAL) YY_OBS_GROW;  /* Stray `*'. */if (yy_top_state () != INITIAL) YY_OBS_GROW;
1446          YY_BREAK          YY_BREAK
1447  case YY_STATE_EOF(SC_COMMENT):  case YY_STATE_EOF(SC_COMMENT):
1448  #line 244 "scan-gram.l"  #line 253 "scan-gram.l"
1449  {  {
1450      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1451      fprintf (stderr, _(": unexpected end of file in a comment\n"));      fprintf (stderr, _(": unexpected end of file in a comment\n"));
# Line 1452  case YY_STATE_EOF(SC_COMMENT): Line 1461  case YY_STATE_EOF(SC_COMMENT):
1461    
1462  case 56:  case 56:
1463  YY_RULE_SETUP  YY_RULE_SETUP
1464  #line 259 "scan-gram.l"  #line 268 "scan-gram.l"
1465  {  {
1466      assert (yy_top_state () == INITIAL);      assert (yy_top_state () == INITIAL);
1467      YY_OBS_GROW;      YY_OBS_GROW;
1468      YY_OBS_FINISH;      YY_OBS_FINISH;
1469      yylval->string = last_string;      yylval->string = last_string;
1470      yy_pop_state ();      yy_pop_state ();
1471        rule_length++;
1472      return STRING;      return STRING;
1473    }    }
1474          YY_BREAK          YY_BREAK
1475  case 57:  case 57:
1476  YY_RULE_SETUP  YY_RULE_SETUP
1477  #line 268 "scan-gram.l"  #line 278 "scan-gram.l"
1478  YY_OBS_GROW;  YY_OBS_GROW;
1479          YY_BREAK          YY_BREAK
1480  case 58:  case 58:
1481  YY_RULE_SETUP  YY_RULE_SETUP
1482  #line 270 "scan-gram.l"  #line 280 "scan-gram.l"
1483  obstack_1grow (&string_obstack, '\n'); YY_LINES;  obstack_1grow (&string_obstack, '\n'); YY_LINES;
1484          YY_BREAK          YY_BREAK
1485  case YY_STATE_EOF(SC_ESCAPED_STRING):  case YY_STATE_EOF(SC_ESCAPED_STRING):
1486  #line 272 "scan-gram.l"  #line 282 "scan-gram.l"
1487  {  {
1488      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1489      fprintf (stderr, _(": unexpected end of file in a string\n"));      fprintf (stderr, _(": unexpected end of file in a string\n"));
# Line 1493  case YY_STATE_EOF(SC_ESCAPED_STRING): Line 1503  case YY_STATE_EOF(SC_ESCAPED_STRING):
1503    
1504  case 59:  case 59:
1505  YY_RULE_SETUP  YY_RULE_SETUP
1506  #line 290 "scan-gram.l"  #line 300 "scan-gram.l"
1507  {  {
1508      YY_OBS_GROW;      YY_OBS_GROW;
1509      assert (yy_top_state () == INITIAL);      assert (yy_top_state () == INITIAL);
# Line 1505  YY_RULE_SETUP Line 1515  YY_RULE_SETUP
1515                                      (unsigned char) last_string[1], *yylloc);                                      (unsigned char) last_string[1], *yylloc);
1516        YY_OBS_FREE;        YY_OBS_FREE;
1517        yy_pop_state ();        yy_pop_state ();
1518          rule_length++;
1519        return ID;        return ID;
1520      }      }
1521    }    }
1522          YY_BREAK          YY_BREAK
1523  case 60:  case 60:
1524  YY_RULE_SETUP  YY_RULE_SETUP
1525  #line 305 "scan-gram.l"  #line 316 "scan-gram.l"
1526  YY_OBS_GROW;  YY_OBS_GROW;
1527          YY_BREAK          YY_BREAK
1528  case 61:  case 61:
1529  YY_RULE_SETUP  YY_RULE_SETUP
1530  #line 307 "scan-gram.l"  #line 318 "scan-gram.l"
1531  obstack_1grow (&string_obstack, '\n'); YY_LINES;  obstack_1grow (&string_obstack, '\n'); YY_LINES;
1532          YY_BREAK          YY_BREAK
1533  case YY_STATE_EOF(SC_ESCAPED_CHARACTER):  case YY_STATE_EOF(SC_ESCAPED_CHARACTER):
1534  #line 309 "scan-gram.l"  #line 320 "scan-gram.l"
1535  {  {
1536      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1537      fprintf (stderr, _(": unexpected end of file in a character\n"));      fprintf (stderr, _(": unexpected end of file in a character\n"));
# Line 1539  case YY_STATE_EOF(SC_ESCAPED_CHARACTER): Line 1550  case YY_STATE_EOF(SC_ESCAPED_CHARACTER):
1550    
1551  case 62:  case 62:
1552  YY_RULE_SETUP  YY_RULE_SETUP
1553  #line 327 "scan-gram.l"  #line 338 "scan-gram.l"
1554  {  {
1555      long c = strtol (yytext + 1, 0, 8);      long c = strtol (yytext + 1, 0, 8);
1556      if (c > 255)      if (c > 255)
# Line 1554  YY_RULE_SETUP Line 1565  YY_RULE_SETUP
1565          YY_BREAK          YY_BREAK
1566  case 63:  case 63:
1567  YY_RULE_SETUP  YY_RULE_SETUP
1568  #line 339 "scan-gram.l"  #line 350 "scan-gram.l"
1569  {  {
1570      obstack_1grow (&string_obstack, strtol (yytext + 2, 0, 16));      obstack_1grow (&string_obstack, strtol (yytext + 2, 0, 16));
1571    }    }
1572          YY_BREAK          YY_BREAK
1573  case 64:  case 64:
1574  YY_RULE_SETUP  YY_RULE_SETUP
1575  #line 343 "scan-gram.l"  #line 354 "scan-gram.l"
1576  obstack_1grow (&string_obstack, '\a');  obstack_1grow (&string_obstack, '\a');
1577          YY_BREAK          YY_BREAK
1578  case 65:  case 65:
1579  YY_RULE_SETUP  YY_RULE_SETUP
1580  #line 344 "scan-gram.l"  #line 355 "scan-gram.l"
1581  obstack_1grow (&string_obstack, '\b');  obstack_1grow (&string_obstack, '\b');
1582          YY_BREAK          YY_BREAK
1583  case 66:  case 66:
1584  YY_RULE_SETUP  YY_RULE_SETUP
1585  #line 345 "scan-gram.l"  #line 356 "scan-gram.l"
1586  obstack_1grow (&string_obstack, '\f');  obstack_1grow (&string_obstack, '\f');
1587          YY_BREAK          YY_BREAK
1588  case 67:  case 67:
1589  YY_RULE_SETUP  YY_RULE_SETUP
1590  #line 346 "scan-gram.l"  #line 357 "scan-gram.l"
1591  obstack_1grow (&string_obstack, '\n');  obstack_1grow (&string_obstack, '\n');
1592          YY_BREAK          YY_BREAK
1593  case 68:  case 68:
1594  YY_RULE_SETUP  YY_RULE_SETUP
1595  #line 347 "scan-gram.l"  #line 358 "scan-gram.l"
1596  obstack_1grow (&string_obstack, '\r');  obstack_1grow (&string_obstack, '\r');
1597          YY_BREAK          YY_BREAK
1598  case 69:  case 69:
1599  YY_RULE_SETUP  YY_RULE_SETUP
1600  #line 348 "scan-gram.l"  #line 359 "scan-gram.l"
1601  obstack_1grow (&string_obstack, '\t');  obstack_1grow (&string_obstack, '\t');
1602          YY_BREAK          YY_BREAK
1603  case 70:  case 70:
1604  YY_RULE_SETUP  YY_RULE_SETUP
1605  #line 349 "scan-gram.l"  #line 360 "scan-gram.l"
1606  obstack_1grow (&string_obstack, '\v');  obstack_1grow (&string_obstack, '\v');
1607          YY_BREAK          YY_BREAK
1608  case 71:  case 71:
1609  YY_RULE_SETUP  YY_RULE_SETUP
1610  #line 350 "scan-gram.l"  #line 361 "scan-gram.l"
1611  obstack_1grow (&string_obstack, yytext[1]);  obstack_1grow (&string_obstack, yytext[1]);
1612          YY_BREAK          YY_BREAK
1613  case 72:  case 72:
1614  YY_RULE_SETUP  YY_RULE_SETUP
1615  #line 351 "scan-gram.l"  #line 362 "scan-gram.l"
1616  {  {
1617      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1618      fprintf (stderr, _(": unrecognized escape: %s\n"), quote (yytext));      fprintf (stderr, _(": unrecognized escape: %s\n"), quote (yytext));
# Line 1611  YY_RULE_SETUP Line 1622  YY_RULE_SETUP
1622  /* FLex wants this rule, in case of a `\<<EOF>>'. */  /* FLex wants this rule, in case of a `\<<EOF>>'. */
1623  case 73:  case 73:
1624  YY_RULE_SETUP  YY_RULE_SETUP
1625  #line 357 "scan-gram.l"  #line 368 "scan-gram.l"
1626  YY_OBS_GROW;  YY_OBS_GROW;
1627          YY_BREAK          YY_BREAK
1628    
# Line 1623  YY_OBS_GROW; Line 1634  YY_OBS_GROW;
1634    
1635  case 74:  case 74:
1636  YY_RULE_SETUP  YY_RULE_SETUP
1637  #line 368 "scan-gram.l"  #line 379 "scan-gram.l"
1638  {  {
1639      YY_OBS_GROW;      YY_OBS_GROW;
1640      assert (yy_top_state () != INITIAL);      assert (yy_top_state () != INITIAL);
# Line 1632  YY_RULE_SETUP Line 1643  YY_RULE_SETUP
1643          YY_BREAK          YY_BREAK
1644  case 75:  case 75:
1645  YY_RULE_SETUP  YY_RULE_SETUP
1646  #line 374 "scan-gram.l"  #line 385 "scan-gram.l"
1647  YY_OBS_GROW;  YY_OBS_GROW;
1648          YY_BREAK          YY_BREAK
1649  case 76:  case 76:
1650  YY_RULE_SETUP  YY_RULE_SETUP
1651  #line 375 "scan-gram.l"  #line 386 "scan-gram.l"
1652  YY_OBS_GROW;  YY_OBS_GROW;
1653          YY_BREAK          YY_BREAK
1654  /* FLex wants this rule, in case of a `\<<EOF>>'. */  /* FLex wants this rule, in case of a `\<<EOF>>'. */
1655  case 77:  case 77:
1656  YY_RULE_SETUP  YY_RULE_SETUP
1657  #line 377 "scan-gram.l"  #line 388 "scan-gram.l"
1658  YY_OBS_GROW;  YY_OBS_GROW;
1659          YY_BREAK          YY_BREAK
1660  case 78:  case 78:
1661  YY_RULE_SETUP  YY_RULE_SETUP
1662  #line 379 "scan-gram.l"  #line 390 "scan-gram.l"
1663  YY_OBS_GROW; YY_LINES;  YY_OBS_GROW; YY_LINES;
1664          YY_BREAK          YY_BREAK
1665  case YY_STATE_EOF(SC_CHARACTER):  case YY_STATE_EOF(SC_CHARACTER):
1666  #line 381 "scan-gram.l"  #line 392 "scan-gram.l"
1667  {  {
1668      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1669      fprintf (stderr, _(": unexpected end of file in a character\n"));      fprintf (stderr, _(": unexpected end of file in a character\n"));
# Line 1669  case YY_STATE_EOF(SC_CHARACTER): Line 1680  case YY_STATE_EOF(SC_CHARACTER):
1680    
1681  case 79:  case 79:
1682  YY_RULE_SETUP  YY_RULE_SETUP
1683  #line 397 "scan-gram.l"  #line 408 "scan-gram.l"
1684  {  {
1685      assert (yy_top_state () != INITIAL);      assert (yy_top_state () != INITIAL);
1686      YY_OBS_GROW;      YY_OBS_GROW;
# Line 1678  YY_RULE_SETUP Line 1689  YY_RULE_SETUP
1689          YY_BREAK          YY_BREAK
1690  case 80:  case 80:
1691  YY_RULE_SETUP  YY_RULE_SETUP
1692  #line 403 "scan-gram.l"  #line 414 "scan-gram.l"
1693  YY_OBS_GROW;  YY_OBS_GROW;
1694          YY_BREAK          YY_BREAK
1695  case 81:  case 81:
1696  YY_RULE_SETUP  YY_RULE_SETUP
1697  #line 404 "scan-gram.l"  #line 415 "scan-gram.l"
1698  YY_OBS_GROW;  YY_OBS_GROW;
1699          YY_BREAK          YY_BREAK
1700  /* FLex wants this rule, in case of a `\<<EOF>>'. */  /* FLex wants this rule, in case of a `\<<EOF>>'. */
1701  case 82:  case 82:
1702  YY_RULE_SETUP  YY_RULE_SETUP
1703  #line 406 "scan-gram.l"  #line 417 "scan-gram.l"
1704  YY_OBS_GROW;  YY_OBS_GROW;
1705          YY_BREAK          YY_BREAK
1706  case 83:  case 83:
1707  YY_RULE_SETUP  YY_RULE_SETUP
1708  #line 408 "scan-gram.l"  #line 419 "scan-gram.l"
1709  YY_OBS_GROW; YY_LINES;  YY_OBS_GROW; YY_LINES;
1710          YY_BREAK          YY_BREAK
1711  case YY_STATE_EOF(SC_STRING):  case YY_STATE_EOF(SC_STRING):
1712  #line 410 "scan-gram.l"  #line 421 "scan-gram.l"
1713  {  {
1714      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1715      fprintf (stderr, _(": unexpected end of file in a string\n"));      fprintf (stderr, _(": unexpected end of file in a string\n"));
# Line 1715  case YY_STATE_EOF(SC_STRING): Line 1726  case YY_STATE_EOF(SC_STRING):
1726  /* Characters.  We don't check there is only one.  */  /* Characters.  We don't check there is only one.  */
1727  case 84:  case 84:
1728  YY_RULE_SETUP  YY_RULE_SETUP
1729  #line 426 "scan-gram.l"  #line 437 "scan-gram.l"
1730  YY_OBS_GROW; yy_push_state (SC_CHARACTER);  YY_OBS_GROW; yy_push_state (SC_CHARACTER);
1731          YY_BREAK          YY_BREAK
1732  /* Strings. */  /* Strings. */
1733  case 85:  case 85:
1734  YY_RULE_SETUP  YY_RULE_SETUP
1735  #line 429 "scan-gram.l"  #line 440 "scan-gram.l"
1736  YY_OBS_GROW; yy_push_state (SC_STRING);  YY_OBS_GROW; yy_push_state (SC_STRING);
1737          YY_BREAK          YY_BREAK
1738  /* Comments. */  /* Comments. */
1739  case 86:  case 86:
1740  YY_RULE_SETUP  YY_RULE_SETUP
1741  #line 432 "scan-gram.l"  #line 443 "scan-gram.l"
1742  YY_OBS_GROW; yy_push_state (SC_COMMENT);  YY_OBS_GROW; yy_push_state (SC_COMMENT);
1743          YY_BREAK          YY_BREAK
1744  case 87:  case 87:
1745  YY_RULE_SETUP  YY_RULE_SETUP
1746  #line 433 "scan-gram.l"  #line 444 "scan-gram.l"
1747  YY_OBS_GROW;  YY_OBS_GROW;
1748          YY_BREAK          YY_BREAK
1749  /* Not comments. */  /* Not comments. */
1750  case 88:  case 88:
1751  YY_RULE_SETUP  YY_RULE_SETUP
1752  #line 436 "scan-gram.l"  #line 447 "scan-gram.l"
1753  YY_OBS_GROW;  YY_OBS_GROW;
1754          YY_BREAK          YY_BREAK
1755    
# Line 1750  YY_OBS_GROW; Line 1761  YY_OBS_GROW;
1761    
1762  case 89:  case 89:
1763  YY_RULE_SETUP  YY_RULE_SETUP
1764  #line 447 "scan-gram.l"  #line 458 "scan-gram.l"
1765  {  {
1766      YY_OBS_GROW;      YY_OBS_GROW;
1767      if (--braces_level == 0)      if (--braces_level == 0)
# Line 1758  YY_RULE_SETUP Line 1769  YY_RULE_SETUP
1769          yy_pop_state ();          yy_pop_state ();
1770          YY_OBS_FINISH;          YY_OBS_FINISH;
1771          yylval->string = last_string;          yylval->string = last_string;
1772            rule_length++;
1773          return BRACED_CODE;          return BRACED_CODE;
1774        }        }
1775    }    }
1776          YY_BREAK          YY_BREAK
1777  case 90:  case 90:
1778  YY_RULE_SETUP  YY_RULE_SETUP
1779  #line 458 "scan-gram.l"  #line 470 "scan-gram.l"
1780  YY_OBS_GROW; braces_level++;  YY_OBS_GROW; braces_level++;
1781          YY_BREAK          YY_BREAK
1782  case 91:  case 91:
1783  YY_RULE_SETUP  YY_RULE_SETUP
1784  #line 460 "scan-gram.l"  #line 472 "scan-gram.l"
1785  { handle_dollar (current_braced_code,  { handle_dollar (current_braced_code,
1786                                                     yytext, *yylloc); }                                                     yytext, *yylloc); }
1787          YY_BREAK          YY_BREAK
1788  case 92:  case 92:
1789  YY_RULE_SETUP  YY_RULE_SETUP
1790  #line 462 "scan-gram.l"  #line 474 "scan-gram.l"
1791  { handle_at (current_braced_code,  { handle_at (current_braced_code,
1792                                                 yytext, *yylloc); }                                                 yytext, *yylloc); }
1793          YY_BREAK          YY_BREAK
1794  case 93:  case 93:
1795  YY_RULE_SETUP  YY_RULE_SETUP
1796  #line 465 "scan-gram.l"  #line 477 "scan-gram.l"
1797  YY_OBS_GROW;  YY_OBS_GROW;
1798          YY_BREAK          YY_BREAK
1799  case 94:  case 94:
1800  YY_RULE_SETUP  YY_RULE_SETUP
1801  #line 466 "scan-gram.l"  #line 478 "scan-gram.l"
1802  YY_OBS_GROW; YY_LINES;  YY_OBS_GROW; YY_LINES;
1803          YY_BREAK          YY_BREAK
1804  /* A lose $, or /, or etc. */  /* A lose $, or /, or etc. */
1805  case 95:  case 95:
1806  YY_RULE_SETUP  YY_RULE_SETUP
1807  #line 469 "scan-gram.l"  #line 481 "scan-gram.l"
1808  YY_OBS_GROW;  YY_OBS_GROW;
1809          YY_BREAK          YY_BREAK
1810  case YY_STATE_EOF(SC_BRACED_CODE):  case YY_STATE_EOF(SC_BRACED_CODE):
1811  #line 471 "scan-gram.l"  #line 483 "scan-gram.l"
1812  {  {
1813      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1814      fprintf (stderr, _(": unexpected end of file in a braced code\n"));      fprintf (stderr, _(": unexpected end of file in a braced code\n"));
# Line 1814  case YY_STATE_EOF(SC_BRACED_CODE): Line 1826  case YY_STATE_EOF(SC_BRACED_CODE):
1826    
1827  case 96:  case 96:
1828  YY_RULE_SETUP  YY_RULE_SETUP
1829  #line 489 "scan-gram.l"  #line 501 "scan-gram.l"
1830  {  {
1831      yy_pop_state ();      yy_pop_state ();
1832      YY_OBS_FINISH;      YY_OBS_FINISH;
# Line 1824  YY_RULE_SETUP Line 1836  YY_RULE_SETUP
1836          YY_BREAK          YY_BREAK
1837  case 97:  case 97:
1838  YY_RULE_SETUP  YY_RULE_SETUP
1839  #line 496 "scan-gram.l"  #line 508 "scan-gram.l"
1840  YY_OBS_GROW;  YY_OBS_GROW;
1841          YY_BREAK          YY_BREAK
1842  case 98:  case 98:
1843  YY_RULE_SETUP  YY_RULE_SETUP
1844  #line 497 "scan-gram.l"  #line 509 "scan-gram.l"
1845  YY_OBS_GROW;  YY_OBS_GROW;
1846          YY_BREAK          YY_BREAK
1847  case 99:  case 99:
1848  YY_RULE_SETUP  YY_RULE_SETUP
1849  #line 498 "scan-gram.l"  #line 510 "scan-gram.l"
1850  YY_OBS_GROW; YY_LINES;  YY_OBS_GROW; YY_LINES;
1851          YY_BREAK          YY_BREAK
1852  case YY_STATE_EOF(SC_PROLOGUE):  case YY_STATE_EOF(SC_PROLOGUE):
1853  #line 500 "scan-gram.l"  #line 512 "scan-gram.l"
1854  {  {
1855      LOCATION_PRINT (stderr, *yylloc);      LOCATION_PRINT (stderr, *yylloc);
1856      fprintf (stderr, _(": unexpected end of file in a prologue\n"));      fprintf (stderr, _(": unexpected end of file in a prologue\n"));
# Line 1857  case YY_STATE_EOF(SC_PROLOGUE): Line 1869  case YY_STATE_EOF(SC_PROLOGUE):
1869    
1870  case 100:  case 100:
1871  YY_RULE_SETUP  YY_RULE_SETUP
1872  #line 518 "scan-gram.l"  #line 530 "scan-gram.l"
1873  YY_OBS_GROW;  YY_OBS_GROW;
1874          YY_BREAK          YY_BREAK
1875  case YY_STATE_EOF(SC_EPILOGUE):  case YY_STATE_EOF(SC_EPILOGUE):
1876  #line 520 "scan-gram.l"  #line 532 "scan-gram.l"
1877  {  {
1878      yy_pop_state ();      yy_pop_state ();
1879      YY_OBS_FINISH;      YY_OBS_FINISH;
# Line 1872  case YY_STATE_EOF(SC_EPILOGUE): Line 1884  case YY_STATE_EOF(SC_EPILOGUE):
1884    
1885  case 101:  case 101:
1886  YY_RULE_SETUP  YY_RULE_SETUP
1887  #line 529 "scan-gram.l"  #line 541 "scan-gram.l"
1888  YY_FATAL_ERROR( "flex scanner jammed" );  YY_FATAL_ERROR( "flex scanner jammed" );
1889          YY_BREAK          YY_BREAK
1890  #line 1879 "scan-gram.c"  #line 1891 "scan-gram.c"
1891  case YY_STATE_EOF(INITIAL):  case YY_STATE_EOF(INITIAL):
1892          yyterminate();          yyterminate();
1893    
# Line 2765  int main() Line 2777  int main()
2777          return 0;          return 0;
2778          }          }
2779  #endif  #endif
2780  #line 529 "scan-gram.l"  #line 541 "scan-gram.l"
2781    
2782    
2783  /*------------------------------------------------------------------.  /*------------------------------------------------------------------.
# Line 2806  handle_action_dollar (char *text, locati Line 2818  handle_action_dollar (char *text, locati
2818      }      }
2819    else if (('0' <= *cp && *cp <= '9') || *cp == '-')    else if (('0' <= *cp && *cp <= '9') || *cp == '-')
2820      {      {
       /* RULE_LENGTH is the number of values in the current rule so  
          far, which says where to find `$0' with respect to the top of  
          the stack.  It is not the same as the rule->length in the  
          case of mid rule actions.  */  
       int rule_length = symbol_list_length (current_rule->next);  
2821        int n = strtol (cp, &cp, 10);        int n = strtol (cp, &cp, 10);
2822    
2823        if (n > rule_length)        if (n > rule_length)
# Line 2893  handle_action_at (char *text, location_t Line 2900  handle_action_at (char *text, location_t
2900      }      }
2901    else if (('0' <= *cp && *cp <= '9') || *cp == '-')    else if (('0' <= *cp && *cp <= '9') || *cp == '-')
2902      {      {
       /* RULE_LENGTH is the number of values in the current rule so  
          far, which says where to find `$0' with respect to the top of  
          the stack.  It is not the same as the rule->length in the  
          case of mid rule actions.  */  
       int rule_length = symbol_list_length (current_rule->next);  
2903        int n = strtol (cp, &cp, 10);        int n = strtol (cp, &cp, 10);
2904    
2905        if (n > rule_length)        if (n > rule_length)

Legend:
Removed from v.1.31  
changed lines
  Added in v.1.32

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26