b4_args is more general than only C++.

[bison.git] / src / scan-skel.l

diff --git a/src/scan-skel.l b/src/scan-skel.l
index aab570c604c12355f2f3dd7e135fbe9e5621a12b..b315951cacb85e936dcd40ab3e1801b8e880c9a9 100644 (file)
--- a/src/scan-skel.l
+++ b/src/scan-skel.l
@@ -1,24 +1,22 @@
 /* Scan Bison Skeletons.                                       -*- C -*-
 
 /* Scan Bison Skeletons.                                       -*- C -*-
 

-   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software

    Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
    Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 

-   Bison is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.

 
 

-   Bison is distributed in the hope that it will be useful, but
-   WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.

 
    You should have received a copy of the GNU General Public License
 
    You should have received a copy of the GNU General Public License

-   along with Bison; see the file COPYING.  If not, write to the Free
-   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 %option nodefault noyywrap nounput never-interactive debug
 %option prefix="skel_" outfile="lex.yy.c"
 
 %option nodefault noyywrap nounput never-interactive debug
 %option prefix="skel_" outfile="lex.yy.c"


@@ -30,16 +28,16 @@
 #define skel_wrap() 1
 
 #define FLEX_PREFIX(Id) skel_ ## Id
 #define skel_wrap() 1
 
 #define FLEX_PREFIX(Id) skel_ ## Id

-#include "flex-scanner.h"
+#include <src/flex-scanner.h>

 
 #include <dirname.h>
 #include <error.h>
 #include <quotearg.h>
 
 
 #include <dirname.h>
 #include <error.h>
 #include <quotearg.h>
 

-#include "complain.h"
-#include "getargs.h"
-#include "files.h"
-#include "scan-skel.h"
+#include <src/complain.h>
+#include <src/getargs.h>
+#include <src/files.h>
+#include <src/scan-skel.h>

 
 #define YY_DECL static int skel_lex (void)
 YY_DECL;
 
 #define YY_DECL static int skel_lex (void)
 YY_DECL;


@@ -47,23 +45,14 @@ YY_DECL;
 #define QPUTS(String) \
    fputs (quotearg_style (c_quoting_style, String), yyout)
 
 #define QPUTS(String) \
    fputs (quotearg_style (c_quoting_style, String), yyout)
 

-static void at_directive_perform (char **outnamep, int *out_linenop);
-static void fail_for_at_directive_too_many_args (void);
-static void fail_for_at_directive_too_few_args (void);
+static void at_directive_perform (int at_directive_argc,
+                                  char *at_directive_argv[],
+                                  char **outnamep, int *out_linenop);
+static void fail_for_at_directive_too_many_args (char const *at_directive_name);
+static void fail_for_at_directive_too_few_args (char const *at_directive_name);

 static void fail_for_invalid_at (char const *at);
 static void fail_for_invalid_at (char const *at);

-
-/* In SC_AT_DIRECTIVE_ARG context, the name of the directive.  */
-static char *at_directive_name = NULL;
-
-/* Currently, only the @warn, @complain, @fatal, @warn_at, @complain_at, and
-   @fatal_at directives take multiple arguments, and the last three already
-   can't take more than 7.  */
-#define AT_DIRECTIVE_ARGC_MAX 7
-static int at_directive_argc = 0;
-static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];

 %}
 
 %}
 

-%x SC_AT_GETTEXT_ARG

 %x SC_AT_DIRECTIVE_ARGS
 %x SC_AT_DIRECTIVE_SKIP_WS
 
 %x SC_AT_DIRECTIVE_ARGS
 %x SC_AT_DIRECTIVE_SKIP_WS
 


@@ -72,26 +61,35 @@ static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
 %{
   int out_lineno IF_LINT (= 0);
   char *outname = NULL;
 %{
   int out_lineno IF_LINT (= 0);
   char *outname = NULL;

+
+  /* Currently, only the @warn, @complain, @fatal, @warn_at, @complain_at, and
+     @fatal_at directives take multiple arguments, and the last three already
+     can't take more than 7.  at_directive_argv[0] is the directive name.  */
+  #define AT_DIRECTIVE_ARGC_MAX 8
+  int at_directive_argc = 0;
+  char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];

 %}
 
 %}
 

-"@@"      fputc ('@', yyout);
-"@{"      fputc ('[', yyout);
-"@}"      fputc (']', yyout);
+"@@" fputc ('@', yyout);
+"@{" fputc ('[', yyout);
+"@}" fputc (']', yyout);
+"@`" /* Emtpy.  Used by b4_cat in ../data/bison.m4.  */
+@\n  /* Likewise.  */

 
 "@oline@"  fprintf (yyout, "%d", out_lineno + 1);
 "@ofile@"  QPUTS (outname);
 "@dir_prefix@" QPUTS (dir_prefix);
 
 
 "@oline@"  fprintf (yyout, "%d", out_lineno + 1);
 "@ofile@"  QPUTS (outname);
 "@dir_prefix@" QPUTS (dir_prefix);
 

-"@gettext<" BEGIN SC_AT_GETTEXT_ARG;
-

 @[a-z_]+"(" {
   yytext[yyleng-1] = '\0';
 @[a-z_]+"(" {
   yytext[yyleng-1] = '\0';

-  at_directive_name = xstrdup (yytext);
+  obstack_grow (&obstack_for_string, yytext, yyleng);
+  at_directive_argv[at_directive_argc++] =
+    obstack_finish (&obstack_for_string);

   BEGIN SC_AT_DIRECTIVE_ARGS;
 }
 
   /* This pattern must not match more than the previous @ patterns. */
   BEGIN SC_AT_DIRECTIVE_ARGS;
 }
 
   /* This pattern must not match more than the previous @ patterns. */

-@[^<@{}(\n]* fail_for_invalid_at (yytext);
+@[^@{}`(\n]* fail_for_invalid_at (yytext);

 \n        out_lineno++; ECHO;
 [^@\n]+           ECHO;
 
 \n        out_lineno++; ECHO;
 [^@\n]+           ECHO;
 


@@ -104,51 +102,19 @@ static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
   return EOF;
 }
 
   return EOF;
 }
 

-<SC_AT_GETTEXT_ARG>{
-  "@>" {
-    char *arg;
-    obstack_1grow (&obstack_for_string, '\0');
-    arg = obstack_finish (&obstack_for_string);
-    if (!at_directive_name)
-      {
-        fprintf (yyout, "%s", _(arg));
-        obstack_free (&obstack_for_string, arg);
-        BEGIN INITIAL;
-      }
-    else
-      {
-        char const *translated = _(arg);
-        size_t parent_size = strlen (at_directive_argv[at_directive_argc]);
-        size_t translated_size = strlen (translated);
-        char *copy = xmalloc (parent_size + translated_size + 1);
-        strcpy (copy, at_directive_argv[at_directive_argc]);
-        strcpy (copy + parent_size, translated);
-        obstack_free (&obstack_for_string,
-                      at_directive_argv[at_directive_argc]);
-        obstack_grow (&obstack_for_string, copy,
-                      parent_size + translated_size);
-        free (copy);
-        BEGIN SC_AT_DIRECTIVE_ARGS;
-      }
-  }
-}
-

 <SC_AT_DIRECTIVE_ARGS>{
 <SC_AT_DIRECTIVE_ARGS>{

+  [^@]+ { STRING_GROW; }
+
+  "@@" { obstack_1grow (&obstack_for_string, '@'); }
+  "@{" { obstack_1grow (&obstack_for_string, '['); }
+  "@}" { obstack_1grow (&obstack_for_string, ']'); }

   "@`" /* Emtpy.  Useful for starting an argument
           that begins with whitespace. */
   "@`" /* Emtpy.  Useful for starting an argument
           that begins with whitespace. */

-
-  "@gettext<" {
-    if (at_directive_argc >= AT_DIRECTIVE_ARGC_MAX)
-      fail_for_at_directive_too_many_args ();
-    obstack_1grow (&obstack_for_string, '\0');
-    at_directive_argv[at_directive_argc] =
-      obstack_finish (&obstack_for_string);
-    BEGIN SC_AT_GETTEXT_ARG;
-  }
+  @\n  /* Empty.  */

 
   @[,)] {
     if (at_directive_argc >= AT_DIRECTIVE_ARGC_MAX)
 
   @[,)] {
     if (at_directive_argc >= AT_DIRECTIVE_ARGC_MAX)

-      fail_for_at_directive_too_many_args ();
+      fail_for_at_directive_too_many_args (at_directive_argv[0]);

 
     obstack_1grow (&obstack_for_string, '\0');
     at_directive_argv[at_directive_argc++] =
 
     obstack_1grow (&obstack_for_string, '\0');
     at_directive_argv[at_directive_argc++] =


@@ -159,21 +125,14 @@ static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
       BEGIN SC_AT_DIRECTIVE_SKIP_WS;
     else
       {
       BEGIN SC_AT_DIRECTIVE_SKIP_WS;
     else
       {

-        at_directive_perform (&outname, &out_lineno);
+        at_directive_perform (at_directive_argc, at_directive_argv,
+                              &outname, &out_lineno);

         obstack_free (&obstack_for_string, at_directive_argv[0]);
         at_directive_argc = 0;
         obstack_free (&obstack_for_string, at_directive_argv[0]);
         at_directive_argc = 0;

-        free (at_directive_name);
-        at_directive_name = NULL;

         BEGIN INITIAL;
       }
   }
         BEGIN INITIAL;
       }
   }

-}

 
 

-<SC_AT_GETTEXT_ARG,SC_AT_DIRECTIVE_ARGS>{
-  [^@]+ { STRING_GROW; }
-  "@@" { obstack_1grow (&obstack_for_string, '@'); }
-  "@{" { obstack_1grow (&obstack_for_string, '['); }
-  "@}" { obstack_1grow (&obstack_for_string, ']'); }

   @.? { fail_for_invalid_at (yytext); }
 }
 
   @.? { fail_for_invalid_at (yytext); }
 }
 


@@ -182,10 +141,9 @@ static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
   . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }
 }
 
   . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }
 }
 

-<SC_AT_GETTEXT_ARG,SC_AT_DIRECTIVE_ARGS,SC_AT_DIRECTIVE_SKIP_WS>{
+<SC_AT_DIRECTIVE_ARGS,SC_AT_DIRECTIVE_SKIP_WS>{

   <<EOF>> {
   <<EOF>> {

-    fatal (_("unclosed %s directive in skeleton"),
-           at_directive_name ? at_directive_name : "@gettext");
+    fatal (_("unclosed %s directive in skeleton"), at_directive_argv[0]);

   }
 }
 
   }
 }
 


@@ -207,133 +165,135 @@ scan_skel (FILE *in)
   skel_in = in;
   skel__flex_debug = trace_flag & trace_skeleton;
   skel_lex ();
   skel_in = in;
   skel__flex_debug = trace_flag & trace_skeleton;
   skel_lex ();

-  /* Reclaim Flex's buffers.  */
-  yylex_destroy ();

 }
 
 void
 skel_scanner_free (void)
 {
   obstack_free (&obstack_for_string, 0);
 }
 
 void
 skel_scanner_free (void)
 {
   obstack_free (&obstack_for_string, 0);

+  /* Reclaim Flex's buffers.  */
+  yylex_destroy ();

 }
 
 static
 }
 
 static

-void at_directive_perform (char **outnamep, int *out_linenop)
+void at_directive_perform (int at_directive_argc,
+                           char *at_directive_argv[],
+                           char **outnamep, int *out_linenop)

 {
 {

-  if (0 == strcmp (at_directive_name, "@basename"))
+  if (0 == strcmp (at_directive_argv[0], "@basename"))

     {
     {

-      if (at_directive_argc > 1)
-        fail_for_at_directive_too_many_args ();
-      fputs (last_component (at_directive_argv[0]), yyout);
+      if (at_directive_argc > 2)
+        fail_for_at_directive_too_many_args (at_directive_argv[0]);
+      fputs (last_component (at_directive_argv[1]), yyout);

     }
     }

-  else if (0 == strcmp (at_directive_name, "@warn")
-           || 0 == strcmp (at_directive_name, "@complain")
-           || 0 == strcmp (at_directive_name, "@fatal"))
+  else if (0 == strcmp (at_directive_argv[0], "@warn")
+           || 0 == strcmp (at_directive_argv[0], "@complain")
+           || 0 == strcmp (at_directive_argv[0], "@fatal"))

     {
       void (*func)(char const *, ...);
     {
       void (*func)(char const *, ...);

-      switch (at_directive_name[1])
+      switch (at_directive_argv[0][1])

         {
           case 'w': func = warn; break;
           case 'c': func = complain; break;
           case 'f': func = fatal; break;
         {
           case 'w': func = warn; break;
           case 'c': func = complain; break;
           case 'f': func = fatal; break;

-          default: aver (false); func = NULL; break;
+          default: aver (false); break;

         }
       switch (at_directive_argc)
         {
         }
       switch (at_directive_argc)
         {

-          case 1:
-            func (at_directive_argv[0]);
-            break;

           case 2:
           case 2:

-            func (at_directive_argv[0], at_directive_argv[1]);
+            func (_(at_directive_argv[1]));

             break;
           case 3:
             break;
           case 3:

-            func (at_directive_argv[0], at_directive_argv[1],
-                  at_directive_argv[2]);
+            func (_(at_directive_argv[1]), at_directive_argv[2]);

             break;
           case 4:
             break;
           case 4:

-            func (at_directive_argv[0], at_directive_argv[1],
-                  at_directive_argv[2], at_directive_argv[3]);
+            func (_(at_directive_argv[1]), at_directive_argv[2],
+                  at_directive_argv[3]);

             break;
           case 5:
             break;
           case 5:

-            func (at_directive_argv[0], at_directive_argv[1],
-                  at_directive_argv[2], at_directive_argv[3],
-                  at_directive_argv[4]);
+            func (_(at_directive_argv[1]), at_directive_argv[2],
+                  at_directive_argv[3], at_directive_argv[4]);
+            break;
+          case 6:
+            func (_(at_directive_argv[1]), at_directive_argv[2],
+                  at_directive_argv[3], at_directive_argv[4],
+                  at_directive_argv[5]);

             break;
           default:
             break;
           default:

-            fail_for_at_directive_too_many_args ();
+            fail_for_at_directive_too_many_args (at_directive_argv[0]);

             break;
         }
     }
             break;
         }
     }

-  else if (0 == strcmp (at_directive_name, "@warn_at")
-           || 0 == strcmp (at_directive_name, "@complain_at")
-           || 0 == strcmp (at_directive_name, "@fatal_at"))
+  else if (0 == strcmp (at_directive_argv[0], "@warn_at")
+           || 0 == strcmp (at_directive_argv[0], "@complain_at")
+           || 0 == strcmp (at_directive_argv[0], "@fatal_at"))

     {
       void (*func)(location, char const *, ...);
       location loc;
     {
       void (*func)(location, char const *, ...);
       location loc;

-      if (at_directive_argc < 3)
-        fail_for_at_directive_too_few_args ();
-      switch (at_directive_name[1])
+      if (at_directive_argc < 4)
+        fail_for_at_directive_too_few_args (at_directive_argv[0]);
+      switch (at_directive_argv[0][1])

         {
           case 'w': func = warn_at; break;
           case 'c': func = complain_at; break;
           case 'f': func = fatal_at; break;
         {
           case 'w': func = warn_at; break;
           case 'c': func = complain_at; break;
           case 'f': func = fatal_at; break;

-          default: aver (false); func = NULL; break;
+          default: aver (false); break;

         }
         }

-      boundary_set_from_string (&loc.start, at_directive_argv[0]);
-      boundary_set_from_string (&loc.end, at_directive_argv[1]);
+      boundary_set_from_string (&loc.start, at_directive_argv[1]);
+      boundary_set_from_string (&loc.end, at_directive_argv[2]);

       switch (at_directive_argc)
         {
       switch (at_directive_argc)
         {

-          case 3:
-            func (loc, at_directive_argv[2]);
-            break;

           case 4:
           case 4:

-            func (loc, at_directive_argv[2], at_directive_argv[3]);
+            func (loc, _(at_directive_argv[3]));

             break;
           case 5:
             break;
           case 5:

-            func (loc, at_directive_argv[2], at_directive_argv[3],
-                  at_directive_argv[4]);
+            func (loc, _(at_directive_argv[3]), at_directive_argv[4]);

             break;
           case 6:
             break;
           case 6:

-            func (loc, at_directive_argv[2], at_directive_argv[3],
-                  at_directive_argv[4], at_directive_argv[5]);
+            func (loc, _(at_directive_argv[3]), at_directive_argv[4],
+                  at_directive_argv[5]);

             break;
           case 7:
             break;
           case 7:

-            func (loc, at_directive_argv[2], at_directive_argv[3],
-                  at_directive_argv[4], at_directive_argv[5],
-                  at_directive_argv[6]);
+            func (loc, _(at_directive_argv[3]), at_directive_argv[4],
+                  at_directive_argv[5], at_directive_argv[6]);
+            break;
+          case 8:
+            func (loc, _(at_directive_argv[3]), at_directive_argv[4],
+                  at_directive_argv[5], at_directive_argv[6],
+                  at_directive_argv[7]);

             break;
           default:
             break;
           default:

-            fail_for_at_directive_too_many_args ();
+            fail_for_at_directive_too_many_args (at_directive_argv[0]);

             break;
         }
     }
             break;
         }
     }

-  else if (0 == strcmp (at_directive_name, "@output"))
+  else if (0 == strcmp (at_directive_argv[0], "@output"))

     {
     {

-      if (at_directive_argc > 1)
-        fail_for_at_directive_too_many_args ();
+      if (at_directive_argc > 2)
+        fail_for_at_directive_too_many_args (at_directive_argv[0]);

       if (*outnamep)
         {
           free (*outnamep);
           xfclose (yyout);
         }
       if (*outnamep)
         {
           free (*outnamep);
           xfclose (yyout);
         }

-      *outnamep = xstrdup (at_directive_argv[0]);
+      *outnamep = xstrdup (at_directive_argv[1]);

       output_file_name_check (*outnamep);
       yyout = xfopen (*outnamep, "w");
       *out_linenop = 1;
     }
   else
       output_file_name_check (*outnamep);
       yyout = xfopen (*outnamep, "w");
       *out_linenop = 1;
     }
   else

-    fail_for_invalid_at (at_directive_name);
+    fail_for_invalid_at (at_directive_argv[0]);

 }
 
 static void
 }
 
 static void

-fail_for_at_directive_too_few_args (void)
+fail_for_at_directive_too_few_args (char const *at_directive_name)

 {
   fatal (_("too few arguments for %s directive in skeleton"),
          at_directive_name);
 }
 
 static void
 {
   fatal (_("too few arguments for %s directive in skeleton"),
          at_directive_name);
 }
 
 static void

-fail_for_at_directive_too_many_args (void)
+fail_for_at_directive_too_many_args (char const *at_directive_name)

 {
   fatal (_("too many arguments for %s directive in skeleton"),
          at_directive_name);
 {
   fatal (_("too many arguments for %s directive in skeleton"),
          at_directive_name);