Merge remote-tracking branch 'origin/maint'

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

diff --git a/src/scan-skel.l b/src/scan-skel.l
index e15294a1e219292be2114417857233c99cb1db8c..b79e58323e0cc2a95fc1232c6437ed2a56099151 100644 (file)
--- a/src/scan-skel.l
+++ b/src/scan-skel.l
@@ -72,12 +72,11 @@ static void fail_for_invalid_at (char const *at);
 "@@" fputc ('@', yyout);
 "@{" fputc ('[', yyout);
 "@}" fputc (']', yyout);
 "@@" fputc ('@', yyout);
 "@{" fputc ('[', yyout);
 "@}" fputc (']', yyout);

-"@`" /* Empty.  Used by b4_cat in ../data/bison.m4.  */
-@\n  /* Likewise.  */
+"@`" continue;  /* Used by b4_cat in ../data/bison.m4.  */
+@\n  continue;

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

-"@dir_prefix@" QPUTS (dir_prefix);

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


@@ -92,7 +91,7 @@ static void fail_for_invalid_at (char const *at);
 \n         out_lineno++; ECHO;
 [^@\n]+    ECHO;
 
 \n         out_lineno++; ECHO;
 [^@\n]+    ECHO;
 

-<INITIAL><<EOF>> {
+<<EOF>> {

   if (outname)
     {
       free (outname);
   if (outname)
     {
       free (outname);


@@ -101,15 +100,15 @@ static void fail_for_invalid_at (char const *at);
   return EOF;
 }
 
   return EOF;
 }
 

-<SC_AT_DIRECTIVE_ARGS>{
-  [^@]+ { STRING_GROW; }
+<SC_AT_DIRECTIVE_ARGS>
+{
+  [^@]+  STRING_GROW;

 
 

-  "@@" { obstack_1grow (&obstack_for_string, '@'); }
-  "@{" { obstack_1grow (&obstack_for_string, '['); }
-  "@}" { obstack_1grow (&obstack_for_string, ']'); }
-  "@`" /* Empty.  Useful for starting an argument
-          that begins with whitespace. */
-  @\n  /* Empty.  */
+  "@@"   obstack_1grow (&obstack_for_string, '@');
+  "@{"   obstack_1grow (&obstack_for_string, '[');
+  "@}"   obstack_1grow (&obstack_for_string, ']');
+  "@`"   continue; /* For starting an argument that begins with whitespace. */
+  @\n    continue;

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


@@ -132,17 +131,20 @@ static void fail_for_invalid_at (char const *at);
       }
   }
 
       }
   }
 

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

 }
 
 }
 

-<SC_AT_DIRECTIVE_SKIP_WS>{
-  [ \t\r\n]
+<SC_AT_DIRECTIVE_SKIP_WS>
+{
+  [ \t\r\n]    continue;

   . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }
 }
 
   . { yyless (0); BEGIN SC_AT_DIRECTIVE_ARGS; }
 }
 

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

   }
 }
 
   }
 }
 


@@ -189,34 +191,36 @@ at_directive_perform (int at_directive_argc,
            || STREQ (at_directive_argv[0], "@complain")
            || STREQ (at_directive_argv[0], "@fatal"))
     {
            || STREQ (at_directive_argv[0], "@complain")
            || STREQ (at_directive_argv[0], "@fatal"))
     {

-      void (*func)(char const *, ...);
+      warnings complaint_flag;

       switch (at_directive_argv[0][1])
         {
       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;
+        case 'w': complaint_flag = Wother; break;
+        case 'c': complaint_flag = complaint; break;
+        case 'f': complaint_flag = fatal; break;
+        default: aver (false); break;

         }
       switch (at_directive_argc)
         {
           case 2:
         }
       switch (at_directive_argc)
         {
           case 2:

-            func (_(at_directive_argv[1]));
+            complain (complaint_flag, "%s", _(at_directive_argv[1]));

             break;
           case 3:
             break;
           case 3:

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

             break;
           case 4:
             break;
           case 4:

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

             break;
           case 5:
             break;
           case 5:

-            func (_(at_directive_argv[1]), at_directive_argv[2],
-                  at_directive_argv[3], at_directive_argv[4]);
+            complain (complaint_flag, _(at_directive_argv[1]),
+                      at_directive_argv[2], at_directive_argv[3],
+                      at_directive_argv[4]);

             break;
           case 6:
             break;
           case 6:

-            func (_(at_directive_argv[1]), at_directive_argv[2],
-                  at_directive_argv[3], at_directive_argv[4],
-                  at_directive_argv[5]);
+            complain (complaint_flag, _(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;
           default:
             fail_for_at_directive_too_many_args (at_directive_argv[0]);


@@ -227,39 +231,41 @@ at_directive_perform (int at_directive_argc,
            || STREQ (at_directive_argv[0], "@complain_at")
            || STREQ (at_directive_argv[0], "@fatal_at"))
     {
            || STREQ (at_directive_argv[0], "@complain_at")
            || STREQ (at_directive_argv[0], "@fatal_at"))
     {

-      void (*func)(location, char const *, ...);
+      warnings complaint_flag;

       location loc;
       if (at_directive_argc < 4)
         fail_for_at_directive_too_few_args (at_directive_argv[0]);
       switch (at_directive_argv[0][1])
         {
       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;
+        case 'w': complaint_flag = Wother; break;
+        case 'c': complaint_flag = complaint; break;
+        case 'f': complaint_flag = fatal; 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:
         }
       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]));
+            complain_at (loc, complaint_flag, "%s", _(at_directive_argv[3]));

             break;
           case 5:
             break;
           case 5:

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

             break;
           case 6:
             break;
           case 6:

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

             break;
           case 7:
             break;
           case 7:

-            func (loc, _(at_directive_argv[3]), at_directive_argv[4],
-                  at_directive_argv[5], at_directive_argv[6]);
+            complain_at (loc, complaint_flag, _(at_directive_argv[3]),
+                      at_directive_argv[4], at_directive_argv[5],
+                      at_directive_argv[6]);

             break;
           case 8:
             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]);
+            complain_at (loc, complaint_flag, _(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;
           default:
             fail_for_at_directive_too_many_args (at_directive_argv[0]);


@@ -287,19 +293,19 @@ at_directive_perform (int at_directive_argc,
 static void
 fail_for_at_directive_too_few_args (char const *at_directive_name)
 {
 static void
 fail_for_at_directive_too_few_args (char const *at_directive_name)
 {

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

          at_directive_name);
 }
 
 static void
 fail_for_at_directive_too_many_args (char const *at_directive_name)
 {
          at_directive_name);
 }
 
 static 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);
+  complain (fatal, _("too many arguments for %s directive in skeleton"),
+            at_directive_name);

 }
 
 static void
 fail_for_invalid_at (char const *at)
 {
 }
 
 static void
 fail_for_invalid_at (char const *at)
 {

-  fatal ("invalid @ in skeleton: %s", at);
+  complain (fatal, "invalid @ in skeleton: %s", at);

 }
 }