src/scan-skel.l

   1 /* Scan Bison Skeletons.                                       -*- C -*-
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
   4    Foundation, Inc.
   5
   6    This file is part of Bison, the GNU Compiler Compiler.
   7
   8    Bison is free software; you can redistribute it and/or modify it
   9    under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    Bison is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Bison; see the file COPYING.  If not, write to the Free
  20    Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 %option nodefault noyywrap nounput never-interactive debug
  24 %option prefix="skel_" 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 skel_wrap
  30 #define skel_wrap() 1
  31
  32 #define FLEX_PREFIX(Id) skel_ ## Id
  33 #include "flex-scanner.h"
  34
  35 #include <dirname.h>
  36 #include <error.h>
  37 #include <quotearg.h>
  38
  39 #include "complain.h"
  40 #include "getargs.h"
  41 #include "files.h"
  42 #include "scan-skel.h"
  43
  44 #define YY_DECL static int skel_lex (void)
  45 YY_DECL;
  46
  47 #define QPUTS(String) \
  48    fputs (quotearg_style (c_quoting_style, String), yyout)
  49
  50 static void at_directive_perform (char **outnamep, int *out_linenop);
  51 static void fail_for_at_directive_too_many_args (void);
  52 static void fail_for_at_directive_too_few_args (void);
  53 static void fail_for_invalid_at (char const *at);
  54
  55 /* In SC_AT_DIRECTIVE_ARG context, the name of the directive.  */
  56 static char *at_directive_name = NULL;
  57
  58 /* Currently, only the @warn, @complain, @fatal, @warn_at, @complain_at, and
  59    @fatal_at directives take multiple arguments, and the last three already
  60    can't take more than 7.  */
  61 #define AT_DIRECTIVE_ARGC_MAX 7
  62 static int at_directive_argc = 0;
  63 static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
  64 %}
  65
  66 %x SC_AT_GETTEXT_ARG
  67 %x SC_AT_DIRECTIVE_ARGS
  68 %x SC_AT_DIRECTIVE_SKIP_WS
  69
  70 %%
  71
  72 %{
  73   int out_lineno IF_LINT (= 0);
  74   char *outname = NULL;
  75 %}
  76
  77 "@@"       fputc ('@', yyout);
  78 "@{"       fputc ('[', yyout);
  79 "@}"       fputc (']', yyout);
  80
  81 "@oline@"  fprintf (yyout, "%d", out_lineno + 1);
  82 "@ofile@"  QPUTS (outname);
  83 "@dir_prefix@" QPUTS (dir_prefix);
  84
  85 "@gettext<" BEGIN SC_AT_GETTEXT_ARG;
  86
  87 @[a-z_]+"(" {
  88   yytext[yyleng-1] = '\0';
  89   at_directive_name = xstrdup (yytext);
  90   BEGIN SC_AT_DIRECTIVE_ARGS;
  91 }
  92
  93   /* This pattern must not match more than the previous @ patterns. */
  94 @[^<@{}(\n]* fail_for_invalid_at (yytext);
  95 \n         out_lineno++; ECHO;
  96 [^@\n]+    ECHO;
  97
  98 <INITIAL><<EOF>> {
  99   if (outname)
 100     {
 101       free (outname);
 102       xfclose (yyout);
 103     }
 104   return EOF;
 105 }
 106
 107 <SC_AT_GETTEXT_ARG>{
 108   "@>" {
 109     char *arg;
 110     obstack_1grow (&obstack_for_string, '\0');
 111     arg = obstack_finish (&obstack_for_string);
 112     if (!at_directive_name)
 113       {
 114         fprintf (yyout, "%s", _(arg));
 115         obstack_free (&obstack_for_string, arg);
 116         BEGIN INITIAL;
 117       }
 118     else
 119       {
 120         char const *translated = _(arg);
 121         size_t parent_size = strlen (at_directive_argv[at_directive_argc]);
 122         size_t translated_size = strlen (translated);
 123         char *copy = xmalloc (parent_size + translated_size + 1);
 124         strcpy (copy, at_directive_argv[at_directive_argc]);
 125         strcpy (copy + parent_size, translated);
 126         obstack_free (&obstack_for_string,
 127                       at_directive_argv[at_directive_argc]);
 128         obstack_grow (&obstack_for_string, copy,
 129                       parent_size + translated_size);
 130         free (copy);
 131         BEGIN SC_AT_DIRECTIVE_ARGS;
 132       }
 133   }
 134 }
 135
 136 <SC_AT_DIRECTIVE_ARGS>{
 137   "@`" /* Emtpy.  Useful for starting an argument
 138           that begins with whitespace. */
 139
 140   "@gettext<" {
 141     if (at_directive_argc >= AT_DIRECTIVE_ARGC_MAX)
 142       fail_for_at_directive_too_many_args ();
 143     obstack_1grow (&obstack_for_string, '\0');
 144     at_directive_argv[at_directive_argc] =
 145       obstack_finish (&obstack_for_string);
 146     BEGIN SC_AT_GETTEXT_ARG;
 147   }
 148
 149   @[,)] {
 150     if (at_directive_argc >= AT_DIRECTIVE_ARGC_MAX)
 151       fail_for_at_directive_too_many_args ();
 152
 153     obstack_1grow (&obstack_for_string, '\0');
 154     at_directive_argv[at_directive_argc++] =
 155       obstack_finish (&obstack_for_string);
 156
 157     /* Like M4, skip whitespace after a comma.  */
 158     if (yytext[1] == ',')
 159       BEGIN SC_AT_DIRECTIVE_SKIP_WS;
 160     else
 161       {
 162         at_directive_perform (&outname, &out_lineno);
 163         obstack_free (&obstack_for_string, at_directive_argv[0]);
 164         at_directive_argc = 0;
 165         free (at_directive_name);
 166         at_directive_name = NULL;
 167         BEGIN INITIAL;
 168       }
 169   }
 170 }
 171
 172 <SC_AT_GETTEXT_ARG,SC_AT_DIRECTIVE_ARGS>{
 173   [^@]+ { STRING_GROW; }
 174   "@@" { obstack_1grow (&obstack_for_string, '@'); }
 175   "@{" { obstack_1grow (&obstack_for_string, '['); }
 176   "@}" { obstack_1grow (&obstack_for_string, ']'); }
 177   @.? { fail_for_invalid_at (yytext); }
 178 }
 179
 180 <SC_AT_DIRECTIVE_SKIP_WS>{
 181   [ \t\r\n]
 182   . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }
 183 }
 184
 185 <SC_AT_GETTEXT_ARG,SC_AT_DIRECTIVE_ARGS,SC_AT_DIRECTIVE_SKIP_WS>{
 186   <<EOF>> {
 187     fatal (_("unclosed %s directive in skeleton"),
 188            at_directive_name ? at_directive_name : "@gettext");
 189   }
 190 }
 191
 192 %%
 193
 194 /*------------------------.
 195 | Scan a Bison skeleton.  |
 196 `------------------------*/
 197
 198 void
 199 scan_skel (FILE *in)
 200 {
 201   static bool initialized = false;
 202   if (!initialized)
 203     {
 204       initialized = true;
 205       obstack_init (&obstack_for_string);
 206     }
 207   skel_in = in;
 208   skel__flex_debug = trace_flag & trace_skeleton;
 209   skel_lex ();
 210   /* Reclaim Flex's buffers.  */
 211   yylex_destroy ();
 212 }
 213
 214 void
 215 skel_scanner_free (void)
 216 {
 217   obstack_free (&obstack_for_string, 0);
 218 }
 219
 220 static
 221 void at_directive_perform (char **outnamep, int *out_linenop)
 222 {
 223   if (0 == strcmp (at_directive_name, "@basename"))
 224     {
 225       if (at_directive_argc > 1)
 226         fail_for_at_directive_too_many_args ();
 227       fputs (last_component (at_directive_argv[0]), yyout);
 228     }
 229   else if (0 == strcmp (at_directive_name, "@warn")
 230            || 0 == strcmp (at_directive_name, "@complain")
 231            || 0 == strcmp (at_directive_name, "@fatal"))
 232     {
 233       void (*func)(char const *, ...);
 234       switch (at_directive_name[1])
 235         {
 236           case 'w': func = warn; break;
 237           case 'c': func = complain; break;
 238           case 'f': func = fatal; break;
 239           default: aver (false); func = NULL; break;
 240         }
 241       switch (at_directive_argc)
 242         {
 243           case 1:
 244             func (at_directive_argv[0]);
 245             break;
 246           case 2:
 247             func (at_directive_argv[0], at_directive_argv[1]);
 248             break;
 249           case 3:
 250             func (at_directive_argv[0], at_directive_argv[1],
 251                   at_directive_argv[2]);
 252             break;
 253           case 4:
 254             func (at_directive_argv[0], at_directive_argv[1],
 255                   at_directive_argv[2], at_directive_argv[3]);
 256             break;
 257           case 5:
 258             func (at_directive_argv[0], at_directive_argv[1],
 259                   at_directive_argv[2], at_directive_argv[3],
 260                   at_directive_argv[4]);
 261             break;
 262           default:
 263             fail_for_at_directive_too_many_args ();
 264             break;
 265         }
 266     }
 267   else if (0 == strcmp (at_directive_name, "@warn_at")
 268            || 0 == strcmp (at_directive_name, "@complain_at")
 269            || 0 == strcmp (at_directive_name, "@fatal_at"))
 270     {
 271       void (*func)(location, char const *, ...);
 272       location loc;
 273       if (at_directive_argc < 3)
 274         fail_for_at_directive_too_few_args ();
 275       switch (at_directive_name[1])
 276         {
 277           case 'w': func = warn_at; break;
 278           case 'c': func = complain_at; break;
 279           case 'f': func = fatal_at; break;
 280           default: aver (false); func = NULL; break;
 281         }
 282       boundary_set_from_string (&loc.start, at_directive_argv[0]);
 283       boundary_set_from_string (&loc.end, at_directive_argv[1]);
 284       switch (at_directive_argc)
 285         {
 286           case 3:
 287             func (loc, at_directive_argv[2]);
 288             break;
 289           case 4:
 290             func (loc, at_directive_argv[2], at_directive_argv[3]);
 291             break;
 292           case 5:
 293             func (loc, at_directive_argv[2], at_directive_argv[3],
 294                   at_directive_argv[4]);
 295             break;
 296           case 6:
 297             func (loc, at_directive_argv[2], at_directive_argv[3],
 298                   at_directive_argv[4], at_directive_argv[5]);
 299             break;
 300           case 7:
 301             func (loc, at_directive_argv[2], at_directive_argv[3],
 302                   at_directive_argv[4], at_directive_argv[5],
 303                   at_directive_argv[6]);
 304             break;
 305           default:
 306             fail_for_at_directive_too_many_args ();
 307             break;
 308         }
 309     }
 310   else if (0 == strcmp (at_directive_name, "@output"))
 311     {
 312       if (at_directive_argc > 1)
 313         fail_for_at_directive_too_many_args ();
 314       if (*outnamep)
 315         {
 316           free (*outnamep);
 317           xfclose (yyout);
 318         }
 319       *outnamep = xstrdup (at_directive_argv[0]);
 320       output_file_name_check (*outnamep);
 321       yyout = xfopen (*outnamep, "w");
 322       *out_linenop = 1;
 323     }
 324   else
 325     fail_for_invalid_at (at_directive_name);
 326 }
 327
 328 static void
 329 fail_for_at_directive_too_few_args (void)
 330 {
 331   fatal (_("too few arguments for %s directive in skeleton"),
 332          at_directive_name);
 333 }
 334
 335 static void
 336 fail_for_at_directive_too_many_args (void)
 337 {
 338   fatal (_("too many arguments for %s directive in skeleton"),
 339          at_directive_name);
 340 }
 341
 342 static void
 343 fail_for_invalid_at (char const *at)
 344 {
 345   fatal ("invalid @ in skeleton: %s", at);
 346 }