* GNUmakefile: Update git-version-gen invocation so make dist

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

diff --git a/src/scan-skel.l b/src/scan-skel.l
index bd9ff841bc505d73e822c7131dae57bbcbf3d47a..6ef53511a674507ec2d42ca179f887e7e3d43bbb 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 Free Software
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007 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"


@@ -47,46 +45,52 @@ 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 fail_for_at_directive_too_many_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;
-
-/* Currently, only the @warn, @complain, and @fatal directives take multiple
-   arguments, and they already can't take more than 5.  */
-#define AT_DIRECTIVE_ARGC_MAX 5
-static int at_directive_argc = 0;
-static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];

 %}
 
 %}
 

-%x SC_AT_DIRECTIVE_ARG
+%x SC_AT_DIRECTIVE_ARGS

 %x SC_AT_DIRECTIVE_SKIP_WS
 
 %%
 
 %{
 %x SC_AT_DIRECTIVE_SKIP_WS
 
 %%
 
 %{

-  int lineno IF_LINT (= 0);
+  int out_lineno IF_LINT (= 0);

   char *outname = NULL;
   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", lineno + 1);
+"@oline@"  fprintf (yyout, "%d", out_lineno + 1);

 "@ofile@"  QPUTS (outname);
 "@dir_prefix@" QPUTS (dir_prefix);
 
 @[a-z_]+"(" {
   yytext[yyleng-1] = '\0';
 "@ofile@"  QPUTS (outname);
 "@dir_prefix@" QPUTS (dir_prefix);
 
 @[a-z_]+"(" {
   yytext[yyleng-1] = '\0';

-  at_directive_name = xstrdup (yytext);
-  BEGIN SC_AT_DIRECTIVE_ARG;
+  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. */
 }
 
   /* This pattern must not match more than the previous @ patterns. */

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

 [^@\n]+           ECHO;
 
 <INITIAL><<EOF>> {
 [^@\n]+           ECHO;
 
 <INITIAL><<EOF>> {


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

-<SC_AT_DIRECTIVE_ARG>{
-  [^@\n]+ { STRING_GROW; }
-  \n      { ++lineno; STRING_GROW; }
+<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. */
 
   "@@" { 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. */

+  @\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++] =


@@ -121,70 +125,10 @@ static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
       BEGIN SC_AT_DIRECTIVE_SKIP_WS;
     else
       {
       BEGIN SC_AT_DIRECTIVE_SKIP_WS;
     else
       {

-        if (0 == strcmp (at_directive_name, "@basename"))
-          {
-            if (at_directive_argc > 1)
-              fail_for_at_directive_too_many_args ();
-            fputs (last_component (at_directive_argv[0]), yyout);
-          }
-        else if (0 == strcmp (at_directive_name, "@warn")
-                 || 0 == strcmp (at_directive_name, "@complain")
-                 || 0 == strcmp (at_directive_name, "@fatal"))
-          {
-            void (*func)(char const *, ...);
-            switch (at_directive_name[1])
-              {
-                case 'w': func = warn; break;
-                case 'c': func = complain; break;
-                case 'f': func = fatal; break;
-                default: aver (false); func = NULL; break;
-              }
-            switch (at_directive_argc)
-              {
-                case 1:
-                  func (_(at_directive_argv[0]));
-                  break;
-                case 2:
-                  func (_(at_directive_argv[0]), at_directive_argv[1]);
-                  break;
-                case 3:
-                  func (_(at_directive_argv[0]), at_directive_argv[1],
-                        at_directive_argv[2]);
-                  break;
-                case 4:
-                  func (_(at_directive_argv[0]), at_directive_argv[1],
-                        at_directive_argv[2], at_directive_argv[3]);
-                  break;
-                case 5:
-                  func (_(at_directive_argv[0]), at_directive_argv[1],
-                        at_directive_argv[2], at_directive_argv[3],
-                        at_directive_argv[4]);
-                  break;
-                default:
-                  fail_for_at_directive_too_many_args ();
-                  break;
-              }
-          }
-        else if (0 == strcmp (at_directive_name, "@output"))
-          {
-            if (at_directive_argc > 1)
-              fail_for_at_directive_too_many_args ();
-            if (outname)
-              {
-                free (outname);
-                xfclose (yyout);
-              }
-            outname = xstrdup (at_directive_argv[0]);
-            output_file_name_check (outname);
-            yyout = xfopen (outname, "w");
-            lineno = 1;
-          }
-        else
-          fail_for_invalid_at (at_directive_name);
-        
+        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);

         BEGIN INITIAL;
       }
   }
         BEGIN INITIAL;
       }
   }


@@ -193,14 +137,13 @@ static char *at_directive_argv[AT_DIRECTIVE_ARGC_MAX];
 }
 
 <SC_AT_DIRECTIVE_SKIP_WS>{
 }
 
 <SC_AT_DIRECTIVE_SKIP_WS>{

-  [ \t\r]
-  \n { ++lineno; }
-  . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARG; }
+  [ \t\r\n]
+  . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }

 }
 
 }
 

-<SC_AT_DIRECTIVE_ARG,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);
+    fatal (_("unclosed %s directive in skeleton"), at_directive_argv[0]);

   }
 }
 
   }
 }
 


@@ -222,25 +165,142 @@ 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 ();

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

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

+static
+void at_directive_perform (int at_directive_argc,
+                           char *at_directive_argv[],
+                           char **outnamep, int *out_linenop)
+{
+  if (0 == strcmp (at_directive_argv[0], "@basename"))
+    {
+      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_argv[0], "@warn")
+           || 0 == strcmp (at_directive_argv[0], "@complain")
+           || 0 == strcmp (at_directive_argv[0], "@fatal"))
+    {
+      void (*func)(char const *, ...);
+      switch (at_directive_argv[0][1])
+        {
+          case 'w': func = warn; break;
+          case 'c': func = complain; break;
+          case 'f': func = fatal; break;
+          default: aver (false); break;
+        }
+      switch (at_directive_argc)
+        {
+          case 2:
+            func (_(at_directive_argv[1]));
+            break;
+          case 3:
+            func (_(at_directive_argv[1]), at_directive_argv[2]);
+            break;
+          case 4:
+            func (_(at_directive_argv[1]), at_directive_argv[2],
+                  at_directive_argv[3]);
+            break;
+          case 5:
+            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:
+            fail_for_at_directive_too_many_args (at_directive_argv[0]);
+            break;
+        }
+    }
+  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;
+      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;
+          default: aver (false); break;
+        }
+      boundary_set_from_string (&loc.start, at_directive_argv[1]);
+      boundary_set_from_string (&loc.end, at_directive_argv[2]);
+      switch (at_directive_argc)
+        {
+          case 4:
+            func (loc, _(at_directive_argv[3]));
+            break;
+          case 5:
+            func (loc, _(at_directive_argv[3]), at_directive_argv[4]);
+            break;
+          case 6:
+            func (loc, _(at_directive_argv[3]), at_directive_argv[4],
+                  at_directive_argv[5]);
+            break;
+          case 7:
+            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:
+            fail_for_at_directive_too_many_args (at_directive_argv[0]);
+            break;
+        }
+    }
+  else if (0 == strcmp (at_directive_argv[0], "@output"))
+    {
+      if (at_directive_argc > 2)
+        fail_for_at_directive_too_many_args (at_directive_argv[0]);
+      if (*outnamep)
+        {
+          free (*outnamep);
+          xfclose (yyout);
+        }
+      *outnamep = xstrdup (at_directive_argv[1]);
+      output_file_name_check (*outnamep);
+      yyout = xfopen (*outnamep, "w");
+      *out_linenop = 1;
+    }
+  else
+    fail_for_invalid_at (at_directive_argv[0]);
+}
+

 static void
 static void

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

 {
 {

-  fatal (_("too many arguments for %s directive in skeleton"),
+  fatal (_("too few arguments for %s directive in skeleton"),

          at_directive_name);
 }
 
 static void
          at_directive_name);
 }
 
 static void

-fail_for_invalid_at (char const *at)
+fail_for_at_directive_too_many_args (char const *at_directive_name)

 {
 {

-  fatal ("invalid @ in skeleton: %s", at);
+  fatal (_("too many arguments for %s directive in skeleton"),
+         at_directive_name);

 }
 
 }
 

-void
-skel_scanner_free (void)
+static void
+fail_for_invalid_at (char const *at)

 {
 {

-  obstack_free (&obstack_for_string, 0);
+  fatal ("invalid @ in skeleton: %s", at);

 }
 }