scan-gram.c

bison 2.0 主要可以用来做语法分析用的

case 30:
YY_RULE_SETUP
#line 208 "scan-gram.l"
return PERCENT_OUTPUT;
	YY_BREAK
case 31:
YY_RULE_SETUP
#line 209 "scan-gram.l"
token_type = PERCENT_PARSE_PARAM; BEGIN SC_PRE_CODE;
	YY_BREAK
case 32:
YY_RULE_SETUP
#line 210 "scan-gram.l"
rule_length--; return PERCENT_PREC;
	YY_BREAK
case 33:
YY_RULE_SETUP
#line 211 "scan-gram.l"
token_type = PERCENT_PRINTER; BEGIN SC_PRE_CODE;
	YY_BREAK
case 34:
YY_RULE_SETUP
#line 212 "scan-gram.l"
return PERCENT_PURE_PARSER;
	YY_BREAK
case 35:
YY_RULE_SETUP
#line 213 "scan-gram.l"
return PERCENT_RIGHT;
	YY_BREAK
case 36:
YY_RULE_SETUP
#line 214 "scan-gram.l"
return PERCENT_SKELETON;
	YY_BREAK
case 37:
YY_RULE_SETUP
#line 215 "scan-gram.l"
return PERCENT_START;
	YY_BREAK
case 38:
YY_RULE_SETUP
#line 216 "scan-gram.l"
return PERCENT_TOKEN;
	YY_BREAK
case 39:
YY_RULE_SETUP
#line 217 "scan-gram.l"
return PERCENT_TOKEN;
	YY_BREAK
case 40:
YY_RULE_SETUP
#line 218 "scan-gram.l"
return PERCENT_TOKEN_TABLE;
	YY_BREAK
case 41:
YY_RULE_SETUP
#line 219 "scan-gram.l"
return PERCENT_TYPE;
	YY_BREAK
case 42:
YY_RULE_SETUP
#line 220 "scan-gram.l"
token_type = PERCENT_UNION; BEGIN SC_PRE_CODE;
	YY_BREAK
case 43:
YY_RULE_SETUP
#line 221 "scan-gram.l"
return PERCENT_VERBOSE;
	YY_BREAK
case 44:
YY_RULE_SETUP
#line 222 "scan-gram.l"
return PERCENT_YACC;
	YY_BREAK
case 45:
YY_RULE_SETUP
#line 224 "scan-gram.l"
{
    complain_at (*loc, _("invalid directive: %s"), quote (yytext));
  }
	YY_BREAK
case 46:
YY_RULE_SETUP
#line 228 "scan-gram.l"
return EQUAL;
	YY_BREAK
case 47:
YY_RULE_SETUP
#line 229 "scan-gram.l"
rule_length = 0; return PIPE;
	YY_BREAK
case 48:
YY_RULE_SETUP
#line 230 "scan-gram.l"
return SEMICOLON;
	YY_BREAK
case 49:
YY_RULE_SETUP
#line 232 "scan-gram.l"
{
    val->symbol = symbol_get (yytext, *loc);
    id_loc = *loc;
    rule_length++;
    BEGIN SC_AFTER_IDENTIFIER;
  }
	YY_BREAK
case 50:
YY_RULE_SETUP
#line 239 "scan-gram.l"
{
    val->integer = scan_integer (yytext, 10, *loc);
    return INT;
  }
	YY_BREAK
case 51:
YY_RULE_SETUP
#line 243 "scan-gram.l"
{
    val->integer = scan_integer (yytext, 16, *loc);
    return INT;
  }
	YY_BREAK
/* Characters.  We don't check there is only one.  */
case 52:
YY_RULE_SETUP
#line 249 "scan-gram.l"
STRING_GROW; token_start = loc->start; BEGIN SC_ESCAPED_CHARACTER;
	YY_BREAK
/* Strings. */
case 53:
YY_RULE_SETUP
#line 252 "scan-gram.l"
STRING_GROW; token_start = loc->start; BEGIN SC_ESCAPED_STRING;
	YY_BREAK
/* Prologue. */
case 54:
YY_RULE_SETUP
#line 255 "scan-gram.l"
code_start = loc->start; BEGIN SC_PROLOGUE;
	YY_BREAK
/* Code in between braces.  */
case 55:
YY_RULE_SETUP
#line 258 "scan-gram.l"
{
    STRING_GROW;
    token_type = BRACED_CODE;
    braces_level = 0;
    code_start = loc->start;
    BEGIN SC_BRACED_CODE;
  }
	YY_BREAK
/* A type. */
case 56:
YY_RULE_SETUP
#line 267 "scan-gram.l"
{
    obstack_grow (&obstack_for_string, yytext + 1, yyleng - 2);
    STRING_FINISH;
    val->uniqstr = uniqstr_new (last_string);
    STRING_FREE;
    return TYPE;
  }
	YY_BREAK
case 57:
YY_RULE_SETUP
#line 275 "scan-gram.l"
{
    static int percent_percent_count;
    if (++percent_percent_count == 2)
      BEGIN SC_EPILOGUE;
    return PERCENT_PERCENT;
  }
	YY_BREAK
case 58:
YY_RULE_SETUP
#line 282 "scan-gram.l"
{
    complain_at (*loc, _("invalid character: %s"), quote (yytext));
  }
	YY_BREAK
case YY_STATE_EOF(INITIAL):
#line 286 "scan-gram.l"
{
    loc->start = loc->end = scanner_cursor;
    yyterminate ();
  }
	YY_BREAK

/*-----------------------------------------------------------------.
  | Scanning after an identifier, checking whether a colon is next.  |
  `-----------------------------------------------------------------*/


case 59:
YY_RULE_SETUP
#line 299 "scan-gram.l"
{
    rule_length = 0;
    *loc = id_loc;
    BEGIN INITIAL;
    return ID_COLON;
  }
	YY_BREAK
case 60:
YY_RULE_SETUP
#line 305 "scan-gram.l"
{
    scanner_cursor.column -= mbsnwidth (yytext, yyleng, 0);
    yyless (0);
    *loc = id_loc;
    BEGIN INITIAL;
    return ID;
  }
	YY_BREAK
case YY_STATE_EOF(SC_AFTER_IDENTIFIER):
#line 312 "scan-gram.l"
{
    *loc = id_loc;
    BEGIN INITIAL;
    return ID;
  }
	YY_BREAK

/*---------------------------------------------------------------.
  | Scanning a Yacc comment.  The initial `/ *' is already eaten.  |
  `---------------------------------------------------------------*/


case 61:
YY_RULE_SETUP
#line 326 "scan-gram.l"
BEGIN context_state;
	YY_BREAK
case 62:
YY_RULE_SETUP
#line 327 "scan-gram.l"
;
	YY_BREAK
case YY_STATE_EOF(SC_YACC_COMMENT):
#line 328 "scan-gram.l"
unexpected_eof (token_start, "*/"); BEGIN context_state;
	YY_BREAK

/*------------------------------------------------------------.
  | Scanning a C comment.  The initial `/ *' is already eaten.  |
  `------------------------------------------------------------*/


case 63:
YY_RULE_SETUP
#line 338 "scan-gram.l"
STRING_GROW; BEGIN context_state;
	YY_BREAK
case YY_STATE_EOF(SC_COMMENT):
#line 339 "scan-gram.l"
unexpected_eof (token_start, "*/"); BEGIN context_state;
	YY_BREAK

/*--------------------------------------------------------------.
  | Scanning a line comment.  The initial `//' is already eaten.  |
  `--------------------------------------------------------------*/


case 64:
YY_RULE_SETUP
#line 349 "scan-gram.l"
STRING_GROW; BEGIN context_state;
	YY_BREAK
case 65:
YY_RULE_SETUP
#line 350 "scan-gram.l"
STRING_GROW;
	YY_BREAK
case YY_STATE_EOF(SC_LINE_COMMENT):
#line 351 "scan-gram.l"
BEGIN context_state;
	YY_BREAK

/*------------------------------------------------.
  | Scanning a Bison string, including its escapes. |
  | The initial quote is already eaten.             |
  `------------------------------------------------*/


case 66:
YY_RULE_SETUP
#line 362 "scan-gram.l"
{
    STRING_GROW;
    STRING_FINISH;
    loc->start = token_start;
    val->chars = last_string;
    rule_length++;
    BEGIN INITIAL;
    return STRING;
  }
	YY_BREAK
case 67:
YY_RULE_SETUP
#line 371 "scan-gram.l"
unexpected_newline (token_start, "\"");	BEGIN INITIAL;
	YY_BREAK
case YY_STATE_EOF(SC_ESCAPED_STRING):
#line 372 "scan-gram.l"
unexpected_eof (token_start, "\"");	BEGIN INITIAL;
	YY_BREAK

/*----------------------------------------------------------.
  | Scanning a Bison character literal, decoding its escapes. |
  | The initial quote is already eaten.			      |
  `----------------------------------------------------------*/


case 68:
YY_RULE_SETUP
#line 382 "scan-gram.l"
{
    unsigned char last_string_1;
    STRING_GROW;
    STRING_FINISH;
    loc->start = token_start;
    val->symbol = symbol_get (last_string, *loc);
    symbol_class_set (val->symbol, token_sym, *loc);
    last_string_1 = last_string[1];
    symbol_user_token_number_set (val->symbol, last_string_1, *loc);
    STRING_FREE;
    rule_length++;
    BEGIN INITIAL;
    return ID;
  }
	YY_BREAK
case 69:
YY_RULE_SETUP
#line 396 "scan-gram.l"
unexpected_newline (token_start, "'");	BEGIN INITIAL;
	YY_BREAK
case YY_STATE_EOF(SC_ESCAPED_CHARACTER):
#line 397 "scan-gram.l"
unexpected_eof (token_start, "'");	BEGIN INITIAL;
	YY_BREAK



case 70:
YY_RULE_SETUP
#line 402 "scan-gram.l"
complain_at (*loc, _("invalid null character"));
	YY_BREAK

/*----------------------------.
  | Decode escaped characters.  |
  `----------------------------*/


case 71:
YY_RULE_SETUP
#line 412 "scan-gram.l"
{
    unsigned long int c = strtoul (yytext + 1, 0, 8);
    if (UCHAR_MAX < c)
      complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
    else if (! c) 
      complain_at (*loc, _("invalid null character: %s"), quote (yytext));
    else
      obstack_1grow (&obstack_for_string, c);
  }
	YY_BREAK
case 72:
YY_RULE_SETUP
#line 422 "scan-gram.l"
{
    unsigned long int c;
    set_errno (0);
    c = strtoul (yytext + 2, 0, 16);
    if (UCHAR_MAX < c || get_errno ())
      complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
    else if (! c)
      complain_at (*loc, _("invalid null character: %s"), quote (yytext));
    else
      obstack_1grow (&obstack_for_string, c);
  }
	YY_BREAK
case 73:
YY_RULE_SETUP
#line 434 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\a');
	YY_BREAK
case 74:
YY_RULE_SETUP
#line 435 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\b');
	YY_BREAK
case 75:
YY_RULE_SETUP
#line 436 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\f');
	YY_BREAK
case 76:
YY_RULE_SETUP
#line 437 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\n');
	YY_BREAK
case 77:
YY_RULE_SETUP
#line 438 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\r');
	YY_BREAK
case 78:
YY_RULE_SETUP
#line 439 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\t');
	YY_BREAK
case 79:
YY_RULE_SETUP
#line 440 "scan-gram.l"
obstack_1grow (&obstack_for_string, '\v');
	YY_BREAK
/* \\[\"\'?\\] would be shorter, but it confuses xgettext.  */
case 80:
YY_RULE_SETUP
#line 443 "scan-gram.l"
obstack_1grow (&obstack_for_string, yytext[1]);
	YY_BREAK
case 81:
YY_RULE_SETUP
#line 445 "scan-gram.l"
{
    int c = convert_ucn_to_byte (yytext);
    if (c < 0)
      complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
    else if (! c)
      complain_at (*loc, _("invalid null character: %s"), quote (yytext));
    else
      obstack_1grow (&obstack_for_string, c);
  }
	YY_BREAK
case 82:
YY_RULE_SETUP