src/scan-skel.l

   1 /* Scan Bison Skeletons.                                       -*- C -*-
   2
   3    Copyright (C) 2001-2007, 2009-2011 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 %option nodefault noyywrap noinput nounput never-interactive debug
  21 %option prefix="skel_" outfile="lex.yy.c"
  22
  23 %{
  24 /* Work around a bug in flex 2.5.31.  See Debian bug 333231
  25    <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=333231>.  */
  26 #undef skel_wrap
  27 #define skel_wrap() 1
  28
  29 #define FLEX_PREFIX(Id) skel_ ## Id
  30 #include "flex-scanner.h"
  31
  32 #include <dirname.h>
  33 #include <error.h>
  34 #include <quotearg.h>
  35
  36 #include "complain.h"
  37 #include "getargs.h"
  38 #include "files.h"
  39 #include "scan-skel.h"
  40
  41 #define YY_DECL static int skel_lex (void)
  42 YY_DECL;
  43
  44 #define QPUTS(String) \
  45    fputs (quotearg_style (c_quoting_style, String), yyout)
  46
  47 static void at_directive_perform (int at_directive_argc,
  48                                   char *at_directive_argv[],
  49                                   char **outnamep, int *out_linenop);
  50 static void fail_for_at_directive_too_many_args (char const *at_directive_name);
  51 static void fail_for_at_directive_too_few_args (char const *at_directive_name);
  52 static void fail_for_invalid_at (char const *at);
  53 %}
  54
  55 %x SC_AT_DIRECTIVE_ARGS
  56 %x SC_AT_DIRECTIVE_SKIP_WS
  57
  58 %%
  59
  60 %{
  61   int out_lineno IF_LINT (= 0);
  62   char *outname = NULL;
  63
  64   /* Currently, only the @warn, @complain, @fatal, @warn_at, @complain_at, and
  65      @fatal_at directives take multiple arguments, and the last three already
  66      can't take more than 7.  at_directive_argv[0] is the directive name.  */
  67   #define AT_DIRECTIVE_ARGC_MAX 8
  68   int at_directive_argc = 0;
  69   char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
  70 %}
  71
  72 "@@" fputc ('@', yyout);
  73 "@{" fputc ('[', yyout);
  74 "@}" fputc (']', yyout);
  75 "@`" /* Emtpy.  Used by b4_cat in ../data/bison.m4.  */
  76 @\n  /* Likewise.  */
  77
  78 "@oline@"  fprintf (yyout, "%d", out_lineno + 1);
  79 "@ofile@"  QPUTS (outname);
  80 "@dir_prefix@" QPUTS (dir_prefix);
  81
  82 @[a-z_]+"(" {
  83   yytext[yyleng-1] = '\0';
  84   obstack_grow (&obstack_for_string, yytext, yyleng);
  85   at_directive_argv[at_directive_argc++] =
  86     obstack_finish (&obstack_for_string);
  87   BEGIN SC_AT_DIRECTIVE_ARGS;
  88 }
  89
  90   /* This pattern must not match more than the previous @ patterns. */
  91 @[^@{}`(\n]* fail_for_invalid_at (yytext);
  92 \n         out_lineno++; ECHO;
  93 [^@\n]+    ECHO;
  94
  95 <INITIAL><<EOF>> {
  96   if (outname)
  97     {
  98       free (outname);
  99       xfclose (yyout);
 100     }
 101   return EOF;
 102 }
 103
 104 <SC_AT_DIRECTIVE_ARGS>{
 105   [^@]+ { STRING_GROW; }
 106
 107   "@@" { obstack_1grow (&obstack_for_string, '@'); }
 108   "@{" { obstack_1grow (&obstack_for_string, '['); }
 109   "@}" { obstack_1grow (&obstack_for_string, ']'); }
 110   "@`" /* Empty.  Useful for starting an argument
 111           that begins with whitespace. */
 112   @\n  /* Empty.  */
 113
 114   @[,)] {
 115     if (at_directive_argc >= AT_DIRECTIVE_ARGC_MAX)
 116       fail_for_at_directive_too_many_args (at_directive_argv[0]);
 117
 118     obstack_1grow (&obstack_for_string, '\0');
 119     at_directive_argv[at_directive_argc++] =
 120       obstack_finish (&obstack_for_string);
 121
 122     /* Like M4, skip whitespace after a comma.  */
 123     if (yytext[1] == ',')
 124       BEGIN SC_AT_DIRECTIVE_SKIP_WS;
 125     else
 126       {
 127         at_directive_perform (at_directive_argc, at_directive_argv,
 128                               &outname, &out_lineno);
 129         obstack_free (&obstack_for_string, at_directive_argv[0]);
 130         at_directive_argc = 0;
 131         BEGIN INITIAL;
 132       }
 133   }
 134
 135   @.? { fail_for_invalid_at (yytext); }
 136 }
 137
 138 <SC_AT_DIRECTIVE_SKIP_WS>{
 139   [ \t\r\n]
 140   . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }
 141 }
 142
 143 <SC_AT_DIRECTIVE_ARGS,SC_AT_DIRECTIVE_SKIP_WS>{
 144   <<EOF>> {
 145     fatal (_("unclosed %s directive in skeleton"), at_directive_argv[0]);
 146   }
 147 }
 148
 149 %%
 150
 151 /*------------------------.
 152 | Scan a Bison skeleton.  |
 153 `------------------------*/
 154
 155 void
 156 scan_skel (FILE *in)
 157 {
 158   static bool initialized = false;
 159   if (!initialized)
 160     {
 161       initialized = true;
 162       obstack_init (&obstack_for_string);
 163     }
 164   skel_in = in;
 165   skel__flex_debug = trace_flag & trace_skeleton;
 166   skel_lex ();
 167 }
 168
 169 void
 170 skel_scanner_free (void)
 171 {
 172   obstack_free (&obstack_for_string, 0);
 173   /* Reclaim Flex's buffers.  */
 174   yylex_destroy ();
 175 }
 176
 177 static void
 178 at_directive_perform (int at_directive_argc,
 179                       char *at_directive_argv[],
 180                       char **outnamep, int *out_linenop)
 181 {
 182   if (0 == strcmp (at_directive_argv[0], "@basename"))
 183     {
 184       if (at_directive_argc > 2)
 185         fail_for_at_directive_too_many_args (at_directive_argv[0]);
 186       fputs (last_component (at_directive_argv[1]), yyout);
 187     }
 188   else if (0 == strcmp (at_directive_argv[0], "@warn")
 189            || 0 == strcmp (at_directive_argv[0], "@complain")
 190            || 0 == strcmp (at_directive_argv[0], "@fatal"))
 191     {
 192       void (*func)(char const *, ...);
 193       switch (at_directive_argv[0][1])
 194         {
 195           case 'w': func = warn; break;
 196           case 'c': func = complain; break;
 197           case 'f': func = fatal; break;
 198           default: aver (false); break;
 199         }
 200       switch (at_directive_argc)
 201         {
 202           case 2:
 203             func (_(at_directive_argv[1]));
 204             break;
 205           case 3:
 206             func (_(at_directive_argv[1]), at_directive_argv[2]);
 207             break;
 208           case 4:
 209             func (_(at_directive_argv[1]), at_directive_argv[2],
 210                   at_directive_argv[3]);
 211             break;
 212           case 5:
 213             func (_(at_directive_argv[1]), at_directive_argv[2],
 214                   at_directive_argv[3], at_directive_argv[4]);
 215             break;
 216           case 6:
 217             func (_(at_directive_argv[1]), at_directive_argv[2],
 218                   at_directive_argv[3], at_directive_argv[4],
 219                   at_directive_argv[5]);
 220             break;
 221           default:
 222             fail_for_at_directive_too_many_args (at_directive_argv[0]);
 223             break;
 224         }
 225     }
 226   else if (0 == strcmp (at_directive_argv[0], "@warn_at")
 227            || 0 == strcmp (at_directive_argv[0], "@complain_at")
 228            || 0 == strcmp (at_directive_argv[0], "@fatal_at"))
 229     {
 230       void (*func)(location, char const *, ...);
 231       location loc;
 232       if (at_directive_argc < 4)
 233         fail_for_at_directive_too_few_args (at_directive_argv[0]);
 234       switch (at_directive_argv[0][1])
 235         {
 236           case 'w': func = warn_at; break;
 237           case 'c': func = complain_at; break;
 238           case 'f': func = fatal_at; break;
 239           default: aver (false); break;
 240         }
 241       boundary_set_from_string (&loc.start, at_directive_argv[1]);
 242       boundary_set_from_string (&loc.end, at_directive_argv[2]);
 243       switch (at_directive_argc)
 244         {
 245           case 4:
 246             func (loc, _(at_directive_argv[3]));
 247             break;
 248           case 5:
 249             func (loc, _(at_directive_argv[3]), at_directive_argv[4]);
 250             break;
 251           case 6:
 252             func (loc, _(at_directive_argv[3]), at_directive_argv[4],
 253                   at_directive_argv[5]);
 254             break;
 255           case 7:
 256             func (loc, _(at_directive_argv[3]), at_directive_argv[4],
 257                   at_directive_argv[5], at_directive_argv[6]);
 258             break;
 259           case 8:
 260             func (loc, _(at_directive_argv[3]), at_directive_argv[4],
 261                   at_directive_argv[5], at_directive_argv[6],
 262                   at_directive_argv[7]);
 263             break;
 264           default:
 265             fail_for_at_directive_too_many_args (at_directive_argv[0]);
 266             break;
 267         }
 268     }
 269   else if (0 == strcmp (at_directive_argv[0], "@output"))
 270     {
 271       if (at_directive_argc > 2)
 272         fail_for_at_directive_too_many_args (at_directive_argv[0]);
 273       if (*outnamep)
 274         {
 275           free (*outnamep);
 276           xfclose (yyout);
 277         }
 278       *outnamep = xstrdup (at_directive_argv[1]);
 279       output_file_name_check (outnamep);
 280       yyout = xfopen (*outnamep, "w");
 281       *out_linenop = 1;
 282     }
 283   else
 284     fail_for_invalid_at (at_directive_argv[0]);
 285 }
 286
 287 static void
 288 fail_for_at_directive_too_few_args (char const *at_directive_name)
 289 {
 290   fatal (_("too few arguments for %s directive in skeleton"),
 291          at_directive_name);
 292 }
 293
 294 static void
 295 fail_for_at_directive_too_many_args (char const *at_directive_name)
 296 {
 297   fatal (_("too many arguments for %s directive in skeleton"),
 298          at_directive_name);
 299 }
 300
 301 static void
 302 fail_for_invalid_at (char const *at)
 303 {
 304   fatal ("invalid @ in skeleton: %s", at);
 305 }