src/scan-code.l

   1 /* Bison Action Scanner                             -*- C -*-
   2
   3    Copyright (C) 2006 Free Software Foundation, Inc.
   4
   5    This file is part of Bison, the GNU Compiler Compiler.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20    02110-1301  USA
  21 */
  22
  23 %option debug nodefault nounput noyywrap never-interactive
  24 %option prefix="code_" outfile="lex.yy.c"
  25
  26 %{
  27 /* Work around a bug in flex 2.5.31.  See Debian bug 333231
  28    <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>.  */
  29 #undef code_wrap
  30 #define code_wrap() 1
  31
  32 #define FLEX_PREFIX(Id) code_ ## Id
  33 #include "flex-scanner.h"
  34
  35 #include "complain.h"
  36 #include "reader.h"
  37 #include "getargs.h"
  38 #include <get-errno.h>
  39 #include <quote.h>
  40
  41 #include "scan-code.h"
  42
  43 /* The current calling start condition: SC_RULE_ACTION or
  44    SC_SYMBOL_ACTION. */
  45 # define YY_DECL char *code_lex (int sc_context, symbol_list *rule)
  46 YY_DECL;
  47
  48 #define YY_USER_ACTION  location_compute (loc, &loc->end, yytext, yyleng);
  49
  50 static void handle_action_dollar (symbol_list *rule, char *cp,
  51                                   location dollar_loc);
  52 static void handle_action_at (symbol_list *rule, char *cp, location at_loc);
  53 static location the_location;
  54 static location *loc = &the_location;
  55
  56 /* True if an untyped $$ or $n was seen.  */
  57 static bool untyped_var_seen;
  58 %}
  59  /* C and C++ comments in code. */
  60 %x SC_COMMENT SC_LINE_COMMENT
  61  /* Strings and characters in code. */
  62 %x SC_STRING SC_CHARACTER
  63  /* Whether in a rule or symbol action.  Specifies the translation
  64     of $ and @.  */
  65 %x SC_RULE_ACTION SC_SYMBOL_ACTION
  66
  67
  68 /* POSIX says that a tag must be both an id and a C union member, but
  69    historically almost any character is allowed in a tag.  We disallow
  70    NUL and newline, as this simplifies our implementation.  */
  71 tag      [^\0\n>]+
  72
  73 /* Zero or more instances of backslash-newline.  Following GCC, allow
  74    white space between the backslash and the newline.  */
  75 splice   (\\[ \f\t\v]*\n)*
  76
  77 %%
  78
  79 %{
  80   /* Nesting level of the current code in braces.  */
  81   int braces_level = 0;
  82
  83   /* This scanner is special: it is invoked only once, henceforth
  84      is expected to return only once.  This initialization is
  85      therefore done once per action to translate. */
  86   aver (sc_context == SC_SYMBOL_ACTION
  87         || sc_context == SC_RULE_ACTION
  88         || sc_context == INITIAL);
  89   BEGIN sc_context;
  90 %}
  91
  92   /*------------------------------------------------------------.
  93   | Scanning a C comment.  The initial `/ *' is already eaten.  |
  94   `------------------------------------------------------------*/
  95
  96 <SC_COMMENT>
  97 {
  98   "*"{splice}"/"  STRING_GROW; BEGIN sc_context;
  99 }
 100
 101
 102   /*--------------------------------------------------------------.
 103   | Scanning a line comment.  The initial `//' is already eaten.  |
 104   `--------------------------------------------------------------*/
 105
 106 <SC_LINE_COMMENT>
 107 {
 108   "\n"           STRING_GROW; BEGIN sc_context;
 109   {splice}       STRING_GROW;
 110 }
 111
 112
 113   /*--------------------------------------------.
 114   | Scanning user-code characters and strings.  |
 115   `--------------------------------------------*/
 116
 117 <SC_CHARACTER,SC_STRING>
 118 {
 119   {splice}|\\{splice}.  STRING_GROW;
 120 }
 121
 122 <SC_CHARACTER>
 123 {
 124   "'"           STRING_GROW; BEGIN sc_context;
 125 }
 126
 127 <SC_STRING>
 128 {
 129   "\""          STRING_GROW; BEGIN sc_context;
 130 }
 131
 132
 133 <SC_RULE_ACTION,SC_SYMBOL_ACTION>{
 134   "'" {
 135     STRING_GROW;
 136     BEGIN SC_CHARACTER;
 137   }
 138   "\"" {
 139     STRING_GROW;
 140     BEGIN SC_STRING;
 141   }
 142   "/"{splice}"*" {
 143     STRING_GROW;
 144     BEGIN SC_COMMENT;
 145   }
 146   "/"{splice}"/" {
 147     STRING_GROW;
 148     BEGIN SC_LINE_COMMENT;
 149   }
 150 }
 151
 152 <SC_RULE_ACTION>
 153 {
 154   "$"("<"{tag}">")?(-?[0-9]+|"$")   handle_action_dollar (rule, yytext, *loc);
 155   "@"(-?[0-9]+|"$")                 handle_action_at (rule, yytext, *loc);
 156
 157   "$"  {
 158     warn_at (*loc, _("stray `$'"));
 159     obstack_sgrow (&obstack_for_string, "$][");
 160   }
 161   "@"  {
 162     warn_at (*loc, _("stray `@'"));
 163     obstack_sgrow (&obstack_for_string, "@@");
 164   }
 165
 166   "{"  STRING_GROW; ++braces_level;
 167   "}"  {
 168     bool outer_brace = --braces_level < 0;
 169
 170     /* As an undocumented Bison extension, append `;' before the last
 171        brace in braced code, so that the user code can omit trailing
 172        `;'.  But do not append `;' if emulating Yacc, since Yacc does
 173        not append one.
 174
 175        FIXME: Bison should warn if a semicolon seems to be necessary
 176        here, and should omit the semicolon if it seems unnecessary
 177        (e.g., after ';', '{', or '}', each followed by comments or
 178        white space).  Such a warning shouldn't depend on --yacc; it
 179        should depend on a new --pedantic option, which would cause
 180        Bison to warn if it detects an extension to POSIX.  --pedantic
 181        should also diagnose other Bison extensions like %yacc.
 182        Perhaps there should also be a GCC-style --pedantic-errors
 183        option, so that such warnings are diagnosed as errors.  */
 184     if (outer_brace && ! yacc_flag)
 185       obstack_1grow (&obstack_for_string, ';');
 186
 187     STRING_GROW;
 188   }
 189 }
 190
 191 <SC_SYMBOL_ACTION>
 192 {
 193   "$$"   obstack_sgrow (&obstack_for_string, "]b4_dollar_dollar[");
 194   "@$"   obstack_sgrow (&obstack_for_string, "]b4_at_dollar[");
 195 }
 196
 197
 198   /*-----------------------------------------.
 199   | Escape M4 quoting characters in C code.  |
 200   `-----------------------------------------*/
 201
 202 <*>
 203 {
 204   \$    obstack_sgrow (&obstack_for_string, "$][");
 205   \@    obstack_sgrow (&obstack_for_string, "@@");
 206   \[    obstack_sgrow (&obstack_for_string, "@{");
 207   \]    obstack_sgrow (&obstack_for_string, "@}");
 208 }
 209
 210   /*-----------------------------------------------------.
 211   | By default, grow the string obstack with the input.  |
 212   `-----------------------------------------------------*/
 213
 214 <*>.|\n STRING_GROW;
 215
 216  /* End of processing. */
 217 <*><<EOF>>       {
 218                    obstack_1grow (&obstack_for_string, '\0');
 219                    return obstack_finish (&obstack_for_string);
 220                  }
 221
 222 %%
 223
 224 /* Keeps track of the maximum number of semantic values to the left of
 225    a handle (those referenced by $0, $-1, etc.) are required by the
 226    semantic actions of this grammar. */
 227 int max_left_semantic_context = 0;
 228
 229
 230 /*------------------------------------------------------------------.
 231 | TEXT is pointing to a wannabee semantic value (i.e., a `$').      |
 232 |                                                                   |
 233 | Possible inputs: $[<TYPENAME>]($|integer)                         |
 234 |                                                                   |
 235 | Output to OBSTACK_FOR_STRING a reference to this semantic value.  |
 236 `------------------------------------------------------------------*/
 237
 238 static void
 239 handle_action_dollar (symbol_list *rule, char *text, location dollar_loc)
 240 {
 241   const char *type_name = NULL;
 242   char *cp = text + 1;
 243   symbol_list *effective_rule;
 244   int effective_rule_length;
 245
 246   if (rule->midrule_parent_rule)
 247     {
 248       effective_rule = rule->midrule_parent_rule;
 249       effective_rule_length = rule->midrule_parent_rhs_index - 1;
 250     }
 251   else
 252     {
 253       effective_rule = rule;
 254       effective_rule_length = symbol_list_length (rule->next);
 255     }
 256
 257   /* Get the type name if explicit. */
 258   if (*cp == '<')
 259     {
 260       type_name = ++cp;
 261       while (*cp != '>')
 262         ++cp;
 263       *cp = '\0';
 264       ++cp;
 265       if (untyped_var_seen)
 266         complain_at (dollar_loc, _("explicit type given in untyped grammar"));
 267       tag_seen = true;
 268     }
 269
 270   if (*cp == '$')
 271     {
 272       if (!type_name)
 273         type_name = symbol_list_n_type_name_get (rule, dollar_loc, 0);
 274
 275       if (!type_name)
 276         {
 277           if (union_seen | tag_seen)
 278             {
 279               if (rule->midrule_parent_rule)
 280                 complain_at (dollar_loc,
 281                              _("$$ for the midrule at $%d of `%s'"
 282                                " has no declared type"),
 283                              rule->midrule_parent_rhs_index,
 284                              effective_rule->content.sym->tag);
 285               else
 286                 complain_at (dollar_loc, _("$$ of `%s' has no declared type"),
 287                              rule->content.sym->tag);
 288             }
 289           else
 290             untyped_var_seen = true;
 291           type_name = "";
 292         }
 293
 294       obstack_fgrow1 (&obstack_for_string,
 295                       "]b4_lhs_value([%s])[", type_name);
 296       rule->used = true;
 297     }
 298   else
 299     {
 300       long int num = strtol (cp, NULL, 10);
 301
 302       if (1 - INT_MAX + effective_rule_length <= num
 303           && num <= effective_rule_length)
 304         {
 305           int n = num;
 306           if (max_left_semantic_context < 1 - n)
 307             max_left_semantic_context = 1 - n;
 308           if (!type_name && 0 < n)
 309             type_name =
 310               symbol_list_n_type_name_get (effective_rule, dollar_loc, n);
 311           if (!type_name)
 312             {
 313               if (union_seen | tag_seen)
 314                 complain_at (dollar_loc, _("$%d of `%s' has no declared type"),
 315                              n, effective_rule->content.sym->tag);
 316               else
 317                 untyped_var_seen = true;
 318               type_name = "";
 319             }
 320
 321           obstack_fgrow3 (&obstack_for_string,
 322                           "]b4_rhs_value(%d, %d, [%s])[",
 323                           effective_rule_length, n, type_name);
 324           symbol_list_n_used_set (effective_rule, n, true);
 325         }
 326       else
 327         complain_at (dollar_loc, _("integer out of range: %s"), quote (text));
 328     }
 329 }
 330
 331
 332 /*------------------------------------------------------.
 333 | TEXT is a location token (i.e., a `@...').  Output to |
 334 | OBSTACK_FOR_STRING a reference to this location.      |
 335 `------------------------------------------------------*/
 336
 337 static void
 338 handle_action_at (symbol_list *rule, char *text, location at_loc)
 339 {
 340   char *cp = text + 1;
 341   int effective_rule_length =
 342     (rule->midrule_parent_rule
 343      ? rule->midrule_parent_rhs_index - 1
 344      : symbol_list_length (rule->next));
 345
 346   locations_flag = true;
 347
 348   if (*cp == '$')
 349     obstack_sgrow (&obstack_for_string, "]b4_lhs_location[");
 350   else
 351     {
 352       long int num = strtol (cp, NULL, 10);
 353
 354       if (1 - INT_MAX + effective_rule_length <= num
 355           && num <= effective_rule_length)
 356         {
 357           int n = num;
 358           obstack_fgrow2 (&obstack_for_string, "]b4_rhs_location(%d, %d)[",
 359                           effective_rule_length, n);
 360         }
 361       else
 362         complain_at (at_loc, _("integer out of range: %s"), quote (text));
 363     }
 364 }
 365
 366
 367 /*-------------------------.
 368 | Initialize the scanner.  |
 369 `-------------------------*/
 370
 371 /* Translate the dollars and ats in \a a, whose location is \a l.  The
 372    translation is for \a rule, in the context \a sc_context
 373    (SC_RULE_ACTION, SC_SYMBOL_ACTION, INITIAL).  */
 374
 375 static char const *
 376 translate_action (int sc_context, symbol_list *rule, char const *a, location l)
 377 {
 378   char *res;
 379   static bool initialized = false;
 380   if (!initialized)
 381     {
 382       obstack_init (&obstack_for_string);
 383       yy_flex_debug = 0;
 384       initialized = true;
 385     }
 386
 387   loc->start = loc->end = l.start;
 388   yy_switch_to_buffer (yy_scan_string (a));
 389   res = code_lex (sc_context, rule);
 390   yy_delete_buffer (YY_CURRENT_BUFFER);
 391
 392   return res;
 393 }
 394
 395 char const *
 396 translate_rule_action (symbol_list *rule)
 397 {
 398   return translate_action (SC_RULE_ACTION, rule, rule->action,
 399                            rule->action_location);
 400 }
 401
 402 char const *
 403 translate_symbol_action (char const *a, location l)
 404 {
 405   return translate_action (SC_SYMBOL_ACTION, NULL, a, l);
 406 }
 407
 408 char const *
 409 translate_code (char const *a, location l)
 410 {
 411   return translate_action (INITIAL, NULL, a, l);
 412 }
 413
 414 /*-----------------------------------------------.
 415 | Free all the memory allocated to the scanner.  |
 416 `-----------------------------------------------*/
 417
 418 void
 419 code_scanner_free (void)
 420 {
 421   obstack_free (&obstack_for_string, 0);
 422   /* Reclaim Flex's buffers.  */
 423   yylex_destroy ();
 424 }