src/scan-gram.l

   1 /* Bison Grammar Scanner                             -*- C -*-
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3
   4    This file is part of Bison, the GNU Compiler Compiler.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307  USA
  20 */
  21
  22 %option debug nodefault noyywrap nounput never-interactive stack
  23 %option prefix="gram_" outfile="lex.yy.c"
  24
  25 %{
  26 #include "system.h"
  27 #include "complain.h"
  28 #include "quote.h"
  29 #include "getargs.h"
  30 #include "gram.h"
  31 #include "reader.h"
  32
  33 /* Each time we match a string, move the end cursor to its end. */
  34 #define YY_USER_INIT                            \
  35 do {                                            \
  36   LOCATION_RESET (*yylloc);                     \
  37    /* This is only to avoid GCC warnings. */    \
  38   if (yycontrol) {;};                           \
  39 } while (0)
  40
  41 #define YY_USER_ACTION  LOCATION_COLUMNS (*yylloc, yyleng)
  42 #define YY_LINES        LOCATION_LINES (*yylloc, yyleng); lineno += yyleng;
  43 #define YY_STEP         LOCATION_STEP (*yylloc)
  44
  45
  46 /* STRING_OBSTACK -- Used to store all the characters that we need to
  47    keep (to construct ID, STRINGS etc.).  Use the following macros to
  48    use it.
  49
  50    Use YY_OBS_GROW to append what has just been matched, and
  51    YY_OBS_FINISH to end the string (it puts the ending 0).
  52    YY_OBS_FINISH also stores this string in LAST_STRING, which can be
  53    used, and which is used by YY_OBS_FREE to free the last string.  */
  54
  55 static struct obstack string_obstack;
  56 char *last_string;
  57
  58 #define YY_OBS_GROW   \
  59   obstack_grow (&string_obstack, yytext, yyleng)
  60
  61 #define YY_OBS_FINISH                                   \
  62   do {                                                  \
  63     obstack_1grow (&string_obstack, '\0');              \
  64     last_string = obstack_finish (&string_obstack);     \
  65   } while (0)
  66
  67 #define YY_OBS_FREE                                             \
  68   do {                                                          \
  69     obstack_free (&string_obstack, last_string);                \
  70   } while (0)
  71
  72 void
  73 scanner_last_string_free (void)
  74 {
  75   YY_OBS_FREE;
  76 }
  77
  78
  79 static int braces_level = 0;
  80 static int percent_percent_count = 0;
  81
  82 static void handle_dollar PARAMS ((braced_code_t code_kind,
  83                                    char *cp, location_t location));
  84 static void handle_at PARAMS ((braced_code_t code_kind,
  85                                char *cp, location_t location));
  86
  87 %}
  88 %x SC_COMMENT
  89 %x SC_STRING SC_CHARACTER
  90 %x SC_ESCAPED_STRING SC_ESCAPED_CHARACTER
  91 %x SC_BRACED_CODE SC_PROLOGUE SC_EPILOGUE
  92
  93 id       [.a-zA-Z][.a-zA-Z_0-9]*
  94 int      [0-9]+
  95 eols     (\n|\r|\n\r|\r\n)+
  96 blanks   [ \t\f]+
  97
  98 %%
  99 %{
 100   /* At each yylex invocation, mark the current position as the
 101      start of the next token.  */
 102 #define TR_POS 0
 103 #if TR_POS
 104   fprintf (stderr, "FOO1: %p: ", yylloc);
 105   LOCATION_PRINT (stderr, *yylloc);
 106   fprintf (stderr, "\n");
 107 #endif
 108   YY_STEP;
 109 #if TR_POS
 110   fprintf (stderr, "BAR1: ");
 111   LOCATION_PRINT (stderr, *yylloc);
 112   fprintf (stderr, "\n");
 113 #endif
 114 %}
 115
 116
 117   /*----------------------------.
 118   | Scanning Bison directives.  |
 119   `----------------------------*/
 120 <INITIAL>
 121 {
 122   "%binary"               return PERCENT_NONASSOC;
 123   "%debug"                return PERCENT_DEBUG;
 124   "%define"               return PERCENT_DEFINE;
 125   "%defines"              return PERCENT_DEFINES;
 126   "%destructor"           return PERCENT_DESTRUCTOR;
 127   "%error"[-_]"verbose"   return PERCENT_ERROR_VERBOSE;
 128   "%expect"               return PERCENT_EXPECT;
 129   "%file-prefix"          return PERCENT_FILE_PREFIX;
 130   "%fixed"[-_]"output"[-_]"files"   return PERCENT_YACC;
 131   "%left"                 return PERCENT_LEFT;
 132   "%locations"            return PERCENT_LOCATIONS;
 133   "%name"[-_]"prefix"     return PERCENT_NAME_PREFIX;
 134   "%no"[-_]"lines"        return PERCENT_NO_LINES;
 135   "%nonassoc"             return PERCENT_NONASSOC;
 136   "%nterm"                return PERCENT_NTERM;
 137   "%output"               return PERCENT_OUTPUT;
 138   "%prec"                 return PERCENT_PREC;
 139   "%pure"[-_]"parser"     return PERCENT_PURE_PARSER;
 140   "%right"                return PERCENT_RIGHT;
 141   "%skeleton"             return PERCENT_SKELETON;
 142   "%start"                return PERCENT_START;
 143   "%term"                 return PERCENT_TOKEN;
 144   "%token"                return PERCENT_TOKEN;
 145   "%token"[-_]"table"     return PERCENT_TOKEN_TABLE;
 146   "%type"                 return PERCENT_TYPE;
 147   "%union"                return PERCENT_UNION;
 148   "%verbose"              return PERCENT_VERBOSE;
 149   "%yacc"                 return PERCENT_YACC;
 150
 151   "="                     return EQUAL;
 152   ":"                     return COLON;
 153   "|"                     return PIPE;
 154   ";"                     return SEMICOLON;
 155
 156   {eols}      YY_LINES; YY_STEP;
 157   {blanks}    YY_STEP;
 158   {id}        {
 159     yylval->symbol = getsym (yytext, *yylloc);
 160     return ID;
 161   }
 162
 163   {int}       yylval->integer = strtol (yytext, 0, 10); return INT;
 164
 165   /* Characters.  We don't check there is only one.  */
 166   \'          YY_OBS_GROW; yy_push_state (SC_ESCAPED_CHARACTER);
 167
 168   /* Strings. */
 169   \"          YY_OBS_GROW; yy_push_state (SC_ESCAPED_STRING);
 170
 171   /* Comments. */
 172   "/*"        yy_push_state (SC_COMMENT);
 173   "//".*      YY_STEP;
 174
 175   /* Prologue. */
 176   "%{"        yy_push_state (SC_PROLOGUE);
 177
 178   /* Code in between braces.  */
 179   "{"         YY_OBS_GROW; ++braces_level; yy_push_state (SC_BRACED_CODE);
 180
 181   /* A type. */
 182   "<"[^>]+">" {
 183     obstack_grow (&string_obstack, yytext + 1, yyleng - 2);
 184     YY_OBS_FINISH;
 185     yylval->string = last_string;
 186     return TYPE;
 187   }
 188
 189
 190   "%%"   {
 191     if (++percent_percent_count == 2)
 192       yy_push_state (SC_EPILOGUE);
 193     return PERCENT_PERCENT;
 194   }
 195
 196   .           {
 197     LOCATION_PRINT (stderr, *yylloc);
 198     fprintf (stderr, ": invalid character: `%c'\n", *yytext);
 199     YY_STEP;
 200   }
 201 }
 202
 203
 204   /*------------------------------------------------------------.
 205   | Whatever the start condition (but those which correspond to |
 206   | entity `swallowed' by Bison: SC_ESCAPED_STRING and          |
 207   | SC_ESCAPED_CHARACTER), no M4 character must escape as is.   |
 208   `------------------------------------------------------------*/
 209
 210 <SC_COMMENT,SC_STRING,SC_CHARACTER,SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>
 211 {
 212   \[          if (YY_START != SC_COMMENT) obstack_sgrow (&string_obstack, "@<:@");
 213   \]          if (YY_START != SC_COMMENT) obstack_sgrow (&string_obstack, "@:>@");
 214 }
 215
 216
 217
 218   /*-----------------------------------------------------------.
 219   | Scanning a C comment. The initial `/ *' is already eaten.  |
 220   `-----------------------------------------------------------*/
 221
 222 <SC_COMMENT>
 223 {
 224   "*/" { /* End of the comment. */
 225     if (yy_top_state () == INITIAL)
 226       {
 227         YY_STEP;
 228       }
 229     else
 230       {
 231         YY_OBS_GROW;
 232       }
 233     yy_pop_state ();
 234   }
 235
 236   [^\[\]*\n\r]+         if (yy_top_state () != INITIAL) YY_OBS_GROW;
 237   {eols}        if (yy_top_state () != INITIAL) YY_OBS_GROW; YY_LINES;
 238   .             /* Stray `*'. */if (yy_top_state () != INITIAL) YY_OBS_GROW;
 239
 240   <<EOF>> {
 241     LOCATION_PRINT (stderr, *yylloc);
 242     fprintf (stderr, ": unexpected end of file in a comment\n");
 243     yy_pop_state ();
 244   }
 245 }
 246
 247
 248   /*----------------------------------------------------------------.
 249   | Scanning a C string, including its escapes.  The initial `"' is |
 250   | already eaten.                                                  |
 251   `----------------------------------------------------------------*/
 252
 253 <SC_ESCAPED_STRING>
 254 {
 255   \" {
 256     assert (yy_top_state () == INITIAL);
 257     YY_OBS_GROW;
 258     YY_OBS_FINISH;
 259     yylval->string = last_string;
 260     yy_pop_state ();
 261     return STRING;
 262   }
 263
 264   [^\"\n\r\\]+      YY_OBS_GROW;
 265
 266   {eols}    obstack_1grow (&string_obstack, '\n'); YY_LINES;
 267
 268   <<EOF>> {
 269     LOCATION_PRINT (stderr, *yylloc);
 270     fprintf (stderr, ": unexpected end of file in a string\n");
 271     assert (yy_top_state () == INITIAL);
 272     YY_OBS_FINISH;
 273     yylval->string = last_string;
 274     yy_pop_state ();
 275     return STRING;
 276   }
 277 }
 278
 279   /*---------------------------------------------------------------.
 280   | Scanning a C character, decoding its escapes.  The initial "'" |
 281   | is already eaten.                                              |
 282   `---------------------------------------------------------------*/
 283
 284 <SC_ESCAPED_CHARACTER>
 285 {
 286   \' {
 287     YY_OBS_GROW;
 288     assert (yy_top_state () == INITIAL);
 289     {
 290       YY_OBS_FINISH;
 291       yylval->symbol = getsym (last_string, *yylloc);
 292       symbol_class_set (yylval->symbol, token_sym);
 293       symbol_user_token_number_set (yylval->symbol, last_string[1]);
 294       YY_OBS_FREE;
 295       yy_pop_state ();
 296       return ID;
 297     }
 298   }
 299
 300   [^\'\n\r\\]      YY_OBS_GROW;
 301
 302   {eols}    obstack_1grow (&string_obstack, '\n'); YY_LINES;
 303
 304   <<EOF>> {
 305     LOCATION_PRINT (stderr, *yylloc);
 306     fprintf (stderr, ": unexpected end of file in a character\n");
 307     assert (yy_top_state () == INITIAL);
 308     YY_OBS_FINISH;
 309     yylval->string = last_string;
 310     yy_pop_state ();
 311     return CHARACTER;
 312   }
 313 }
 314
 315
 316   /*----------------------------.
 317   | Decode escaped characters.  |
 318   `----------------------------*/
 319
 320 <SC_ESCAPED_STRING,SC_ESCAPED_CHARACTER>
 321 {
 322   \\[0-7]{3}            {
 323     long c = strtol (yytext + 1, 0, 8);
 324     if (c > 255)
 325       {
 326         LOCATION_PRINT (stderr, *yylloc);
 327         fprintf (stderr, ": invalid escape: %s\n", quote (yytext));
 328         YY_STEP;
 329       }
 330     else
 331       obstack_1grow (&string_obstack, c);
 332   }
 333
 334   \\x[0-9a-fA-F]{2}     {
 335     obstack_1grow (&string_obstack, strtol (yytext + 2, 0, 16));
 336   }
 337
 338   \\a   obstack_1grow (&string_obstack, '\a');
 339   \\b   obstack_1grow (&string_obstack, '\b');
 340   \\f   obstack_1grow (&string_obstack, '\f');
 341   \\n   obstack_1grow (&string_obstack, '\n');
 342   \\r   obstack_1grow (&string_obstack, '\r');
 343   \\t   obstack_1grow (&string_obstack, '\t');
 344   \\v   obstack_1grow (&string_obstack, '\v');
 345   \\[\\""]   obstack_1grow (&string_obstack, yytext[1]);
 346   \\(.|\n)      {
 347     LOCATION_PRINT (stderr, *yylloc);
 348     fprintf (stderr, ": unrecognized escape: %s\n", quote (yytext));
 349     YY_OBS_GROW;
 350   }
 351   /* FLex wants this rule, in case of a `\<<EOF>>'. */
 352   \\                   YY_OBS_GROW;
 353 }
 354
 355
 356   /*----------------------------------------------------------.
 357   | Scanning a C character without decoding its escapes.  The |
 358   | initial "'" is already eaten.                             |
 359   `----------------------------------------------------------*/
 360
 361 <SC_CHARACTER>
 362 {
 363   \' {
 364     YY_OBS_GROW;
 365     assert (yy_top_state () != INITIAL);
 366     yy_pop_state ();
 367   }
 368
 369   [^\[\]\'\n\r\\]+     YY_OBS_GROW;
 370   \\(.|\n)             YY_OBS_GROW;
 371   /* FLex wants this rule, in case of a `\<<EOF>>'. */
 372   \\                   YY_OBS_GROW;
 373
 374   {eols}               YY_OBS_GROW; YY_LINES;
 375
 376   <<EOF>> {
 377     LOCATION_PRINT (stderr, *yylloc);
 378     fprintf (stderr, ": unexpected end of file in a character\n");
 379     assert (yy_top_state () != INITIAL);
 380     yy_pop_state ();
 381   }
 382 }
 383
 384
 385   /*----------------------------------------------------------------.
 386   | Scanning a C string, without decoding its escapes.  The initial |
 387   | `"' is already eaten.                                           |
 388   `----------------------------------------------------------------*/
 389
 390 <SC_STRING>
 391 {
 392   \" {
 393     assert (yy_top_state () != INITIAL);
 394     YY_OBS_GROW;
 395     yy_pop_state ();
 396   }
 397
 398   [^\[\]\"\n\r\\]+      YY_OBS_GROW;
 399   \\(.|\n)              YY_OBS_GROW;
 400   /* FLex wants this rule, in case of a `\<<EOF>>'. */
 401   \\                   YY_OBS_GROW;
 402
 403   {eols}                YY_OBS_GROW; YY_LINES;
 404
 405   <<EOF>> {
 406     LOCATION_PRINT (stderr, *yylloc);
 407     fprintf (stderr, ": unexpected end of file in a string\n");
 408     assert (yy_top_state () != INITIAL);
 409     yy_pop_state ();
 410   }
 411 }
 412
 413
 414   /*---------------------------------------------------.
 415   | Strings, comments etc. can be found in user code.  |
 416   `---------------------------------------------------*/
 417
 418 <SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>
 419 {
 420   /* Characters.  We don't check there is only one.  */
 421   \'          YY_OBS_GROW; yy_push_state (SC_CHARACTER);
 422
 423   /* Strings. */
 424   \"          YY_OBS_GROW; yy_push_state (SC_STRING);
 425
 426   /* Comments. */
 427   "/*"        YY_OBS_GROW; yy_push_state (SC_COMMENT);
 428   "//".*      YY_OBS_GROW;
 429
 430   /* Not comments. */
 431   "/"         YY_OBS_GROW;
 432 }
 433
 434
 435   /*---------------------------------------------------------------.
 436   | Scanning some code in braces (%union and actions). The initial |
 437   | "{" is already eaten.                                          |
 438   `---------------------------------------------------------------*/
 439
 440 <SC_BRACED_CODE>
 441 {
 442   "}" {
 443     YY_OBS_GROW;
 444     if (--braces_level == 0)
 445       {
 446         yy_pop_state ();
 447         YY_OBS_FINISH;
 448         yylval->string = last_string;
 449         return BRACED_CODE;
 450       }
 451   }
 452
 453   "{"           YY_OBS_GROW; braces_level++;
 454
 455   "$"("<"[^>]+">")?(-?[0-9]+|"$") { handle_dollar (current_braced_code,
 456                                                    yytext, *yylloc); }
 457   "@"(-?[0-9]+|"$")               { handle_at (current_braced_code,
 458                                                yytext, *yylloc); }
 459
 460   [^$@\[\]/\'\"\{\}\n\r]+ YY_OBS_GROW;
 461   {eols}        YY_OBS_GROW; YY_LINES;
 462
 463   /* A lose $, or /, or etc. */
 464   .             YY_OBS_GROW;
 465
 466   <<EOF>> {
 467     LOCATION_PRINT (stderr, *yylloc);
 468     fprintf (stderr, ": unexpected end of file in a braced code\n");
 469     yy_pop_state ();
 470     YY_OBS_FINISH;
 471     yylval->string = last_string;
 472     return BRACED_CODE;
 473   }
 474
 475 }
 476
 477
 478   /*--------------------------------------------------------------.
 479   | Scanning some prologue: from "%{" (already scanned) to "%}".  |
 480   `--------------------------------------------------------------*/
 481
 482 <SC_PROLOGUE>
 483 {
 484   "%}" {
 485     yy_pop_state ();
 486     YY_OBS_FINISH;
 487     yylval->string = last_string;
 488     return PROLOGUE;
 489   }
 490
 491   [^%\[\]/\'\"\n\r]+ YY_OBS_GROW;
 492   "%"                YY_OBS_GROW;
 493   {eols}             YY_OBS_GROW; YY_LINES;
 494
 495   <<EOF>> {
 496     LOCATION_PRINT (stderr, *yylloc);
 497     fprintf (stderr, ": unexpected end of file in a prologue\n");
 498     yy_pop_state ();
 499     YY_OBS_FINISH;
 500     yylval->string = last_string;
 501     return PROLOGUE;
 502   }
 503 }
 504
 505
 506   /*---------------------------------------------------------------.
 507   | Scanning the epilogue (everything after the second "%%", which |
 508   | has already been eaten.                                        |
 509   `---------------------------------------------------------------*/
 510
 511 <SC_EPILOGUE>
 512 {
 513   ([^\[\]]|{eols})+  YY_OBS_GROW;
 514
 515   <<EOF>> {
 516     yy_pop_state ();
 517     YY_OBS_FINISH;
 518     yylval->string = last_string;
 519     return EPILOGUE;
 520   }
 521 }
 522
 523
 524 %%
 525
 526 /*------------------------------------------------------------------.
 527 | CP is pointing to a wannabee semantic value (i.e., a `$').        |
 528 |                                                                   |
 529 | Possible inputs: $[<TYPENAME>]($|integer)                         |
 530 |                                                                   |
 531 | Output to the STRING_OBSTACK a reference to this semantic value.  |
 532 `------------------------------------------------------------------*/
 533
 534 static inline void
 535 handle_action_dollar (char *cp, location_t location)
 536 {
 537   const char *type_name = NULL;
 538
 539   ++cp;
 540
 541   /* Get the type name if explicit. */
 542   if (*cp == '<')
 543     {
 544       type_name = ++cp;
 545       while (*cp != '>')
 546         ++cp;
 547       *cp = '\0';
 548       ++cp;
 549     }
 550
 551   if (*cp == '$')
 552     {
 553       if (!type_name)
 554         type_name = symbol_list_n_type_name_get (current_rule, location, 0);
 555       if (!type_name && typed)
 556         complain_at (location, _("$$ of `%s' has no declared type"),
 557                      symbol_tag_get (current_rule->sym));
 558       if (!type_name)
 559         type_name = "";
 560       obstack_fgrow1 (&string_obstack,
 561                       "]b4_lhs_value([%s])[", type_name);
 562     }
 563   else if (isdigit (*cp) || *cp == '-')
 564     {
 565       /* RULE_LENGTH is the number of values in the current rule so
 566          far, which says where to find `$0' with respect to the top of
 567          the stack.  It is not the same as the rule->length in the
 568          case of mid rule actions.  */
 569       int rule_length = symbol_list_length (current_rule->next);
 570       int n = strtol (cp, &cp, 10);
 571
 572       if (n > rule_length)
 573         complain_at (location, _("invalid value: %s%d"), "$", n);
 574       else
 575         {
 576           if (!type_name && n > 0)
 577             type_name = symbol_list_n_type_name_get (current_rule, location,
 578                                                      n);
 579           if (!type_name && typed)
 580             complain_at (location, _("$%d of `%s' has no declared type"),
 581                       n, symbol_tag_get (current_rule->sym));
 582           if (!type_name)
 583             type_name = "";
 584           obstack_fgrow3 (&string_obstack,
 585                           "]b4_rhs_value([%d], [%d], [%s])[",
 586                           rule_length, n, type_name);
 587         }
 588     }
 589   else
 590     {
 591       char buf[] = "$c";
 592       buf[1] = *cp;
 593       complain_at (location, _("%s is invalid"), quote (buf));
 594     }
 595 }
 596
 597
 598 /*---------------------------------------.
 599 | CP is pointing to $$ in a destructor.  |
 600 `---------------------------------------*/
 601
 602 static inline void
 603 handle_destructor_dollar (char *cp, location_t location)
 604 {
 605   ++cp;
 606   if (*cp == '$')
 607     {
 608       obstack_sgrow (&string_obstack, "]b4_dollar_dollar[");
 609     }
 610   else
 611     {
 612       char buf[] = "$c";
 613       buf[1] = *cp;
 614       complain_at (location, _("%s is invalid"), quote (buf));
 615     }
 616 }
 617
 618
 619 /*-----------------------------------------------------------------.
 620 | Dispatch onto handle_action_dollar, or handle_destructor_dollar, |
 621 | depending upon CODE_KIND.                                        |
 622 `-----------------------------------------------------------------*/
 623
 624 static void
 625 handle_dollar (braced_code_t braced_code_kind,
 626                char *text, location_t location)
 627 {
 628   switch (braced_code_kind)
 629     {
 630     case action_braced_code:
 631       handle_action_dollar (text, location);
 632       break;
 633
 634     case destructor_braced_code:
 635       handle_destructor_dollar (text, location);
 636       break;
 637     }
 638 }
 639
 640
 641 /*------------------------------------------------------.
 642 | TEXT is a location token (i.e., a `@...').  Output to |
 643 | STRING_OBSTACK a reference to this location.          |
 644 `------------------------------------------------------*/
 645
 646 static inline void
 647 handle_action_at (char *text, location_t location)
 648 {
 649   locations_flag = 1;
 650   ++text;
 651
 652   if (*text == '$')
 653     {
 654       obstack_sgrow (&string_obstack, "]b4_lhs_location[");
 655     }
 656   else if (isdigit (*text) || *text == '-')
 657     {
 658       /* RULE_LENGTH is the number of values in the current rule so
 659          far, which says where to find `$0' with respect to the top of
 660          the stack.  It is not the same as the rule->length in the
 661          case of mid rule actions.  */
 662       int rule_length = symbol_list_length (current_rule->next);
 663       int n = strtol (text, &text, 10);
 664
 665       if (n > rule_length)
 666         complain_at (location, _("invalid value: %s%d"), "@", n);
 667       else
 668         obstack_fgrow2 (&string_obstack, "]b4_rhs_location([%d], [%d])[",
 669                         rule_length, n);
 670     }
 671   else
 672     {
 673       char buf[] = "@c";
 674       buf[1] = *text;
 675       complain_at (location, _("%s is invalid"), quote (buf));
 676     }
 677 }
 678
 679
 680 /*--------------------------------------------.
 681 | TEXT is expexted tp be @$ in a destructor.  |
 682 `--------------------------------------------*/
 683
 684 static inline void
 685 handle_destructor_at (char *text, location_t location)
 686 {
 687   ++text;
 688   if (*text == '$')
 689     {
 690       obstack_sgrow (&string_obstack, "]b4_at_dollar[");
 691     }
 692   else
 693     {
 694       char buf[] = "$c";
 695       buf[1] = *text;
 696       complain_at (location, _("%s is invalid"), quote (buf));
 697     }
 698 }
 699
 700
 701 /*-------------------------------------------------------------------.
 702 | Dispatch onto handle_action_at, or handle_destructor_at, depending |
 703 | upon CODE_KIND.                                                    |
 704 `-------------------------------------------------------------------*/
 705
 706 static void
 707 handle_at (braced_code_t braced_code_kind,
 708            char *text, location_t location)
 709 {
 710   switch (braced_code_kind)
 711     {
 712     case action_braced_code:
 713       handle_action_at (text, location);
 714       break;
 715
 716     case destructor_braced_code:
 717       handle_destructor_at (text, location);
 718       break;
 719     }
 720 }
 721
 722
 723 /*-------------------------.
 724 | Initialize the scanner.  |
 725 `-------------------------*/
 726
 727 void
 728 scanner_initialize (void)
 729 {
 730   obstack_init (&string_obstack);
 731 }
 732
 733
 734 /*-----------------------------------------------.
 735 | Free all the memory allocated to the scanner.  |
 736 `-----------------------------------------------*/
 737
 738 void
 739 scanner_free (void)
 740 {
 741   obstack_free (&string_obstack, 0);
 742 }