style: use %code for local function declarations in our parser

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

diff --git a/src/scan-gram.l b/src/scan-gram.l
index 7a6d7bfe78546ad6ae0796cd7a9607122d763641..cf8b220d3a329479a700a8f912cf96b684882685 100644 (file)
--- a/src/scan-gram.l
+++ b/src/scan-gram.l
@@ -1,7 +1,6 @@
 /* Bison Grammar Scanner                             -*- C -*-
 
 /* Bison Grammar Scanner                             -*- C -*-
 

-   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
-   Free Software Foundation, Inc.
+   Copyright (C) 2002-2013 Free Software Foundation, Inc.

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


@@ -18,7 +17,7 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 

-%option debug nodefault noinput nounput noyywrap never-interactive
+%option debug nodefault noinput noyywrap never-interactive

 %option prefix="gram_" outfile="lex.yy.c"
 
 %{
 %option prefix="gram_" outfile="lex.yy.c"
 
 %{


@@ -32,11 +31,13 @@
 
 #include <src/complain.h>
 #include <src/files.h>
 
 #include <src/complain.h>
 #include <src/files.h>

+#include <src/getargs.h>

 #include <src/gram.h>
 #include <quotearg.h>
 #include <src/reader.h>
 #include <src/uniqstr.h>
 
 #include <src/gram.h>
 #include <quotearg.h>
 #include <src/reader.h>
 #include <src/uniqstr.h>
 

+#include <c-ctype.h>

 #include <mbswidth.h>
 #include <quote.h>
 
 #include <mbswidth.h>
 #include <quote.h>
 


@@ -44,8 +45,8 @@
 
 #define YY_DECL GRAM_LEX_DECL
 
 
 #define YY_DECL GRAM_LEX_DECL
 

-#define YY_USER_INIT                                   \
-   code_start = scanner_cursor = loc->start;           \
+#define YY_USER_INIT                                    \
+   code_start = scanner_cursor = loc->start;            \

 
 /* Location of scanner cursor.  */
 static boundary scanner_cursor;
 
 /* Location of scanner cursor.  */
 static boundary scanner_cursor;


@@ -55,18 +56,33 @@ static boundary scanner_cursor;
 static size_t no_cr_read (FILE *, char *, size_t);
 #define YY_INPUT(buf, result, size) ((result) = no_cr_read (yyin, buf, size))
 
 static size_t no_cr_read (FILE *, char *, size_t);
 #define YY_INPUT(buf, result, size) ((result) = no_cr_read (yyin, buf, size))
 

-#define RETURN_PERCENT_FLAG(Value)              \
+#define RETURN_PERCENT_PARAM(Value)                     \
+  RETURN_VALUE(PERCENT_PARAM, param, param_ ## Value)
+
+#define RETURN_PERCENT_FLAG(Value)                              \
+  RETURN_VALUE(PERCENT_FLAG, uniqstr, uniqstr_new (Value))
+
+#define RETURN_VALUE(Token, Field, Value)       \

   do {                                          \
   do {                                          \

-    val->uniqstr = uniqstr_new (Value);         \
-    return PERCENT_FLAG;                        \
+    val->Field = Value;                         \
+    return Token;                               \

   } while (0)
 
 #define ROLLBACK_CURRENT_TOKEN                                  \
   do {                                                          \
   } while (0)
 
 #define ROLLBACK_CURRENT_TOKEN                                  \
   do {                                                          \

-    scanner_cursor.column -= mbsnwidth (yytext, yyleng, 0);    \
+    scanner_cursor.column -= mbsnwidth (yytext, yyleng, 0);     \

     yyless (0);                                                 \
   } while (0)
 
     yyless (0);                                                 \
   } while (0)
 

+#define DEPRECATED(Msg)                                         \
+  do {                                                          \
+    size_t i;                                                   \
+    deprecated_directive (loc, yytext, Msg);                    \
+    scanner_cursor.column -= mbsnwidth (Msg, strlen (Msg), 0);  \
+    for (i = strlen (Msg); i != 0; --i)                         \
+      unput (Msg[i - 1]);                                       \
+  } while (0)
+

 /* A string representing the most recently saved token.  */
 static char *last_string;
 
 /* A string representing the most recently saved token.  */
 static char *last_string;
 


@@ -94,16 +110,22 @@ static void unexpected_newline (boundary, char const *);
  /* Strings and characters in directives/rules. */
 %x SC_ESCAPED_STRING SC_ESCAPED_CHARACTER
  /* A identifier was just read in directives/rules.  Special state
  /* Strings and characters in directives/rules. */
 %x SC_ESCAPED_STRING SC_ESCAPED_CHARACTER
  /* A identifier was just read in directives/rules.  Special state

-    to capture the sequence `identifier :'. */
+    to capture the sequence 'identifier :'. */

 %x SC_AFTER_IDENTIFIER
 %x SC_AFTER_IDENTIFIER

- /* A complex tag, with nested angles brackets. */
+
+ /* POSIX says that a tag must be both an id and a C union member, but
+    historically almost any character is allowed in a tag.  We
+    disallow NUL, as this simplifies our implementation.  We match
+    angle brackets in nested pairs: several languages use them for
+    generics/template types.  */

 %x SC_TAG
 
 %x SC_TAG
 

- /* Three types of user code:
-    - prologue (code between `%{' `%}' in the first section, before %%);
+ /* Four types of user code:
+    - prologue (code between '%{' '%}' in the first section, before %%);

     - actions, printers, union, etc, (between braced in the middle section);
     - actions, printers, union, etc, (between braced in the middle section);

-    - epilogue (everything after the second %%). */
-%x SC_PROLOGUE SC_BRACED_CODE SC_EPILOGUE
+    - epilogue (everything after the second %%).
+    - predicate (code between '%?{' and '{' in middle section); */
+%x SC_PROLOGUE SC_BRACED_CODE SC_EPILOGUE SC_PREDICATE

  /* C and C++ comments in code. */
 %x SC_COMMENT SC_LINE_COMMENT
  /* Strings and characters in code. */
  /* C and C++ comments in code. */
 %x SC_COMMENT SC_LINE_COMMENT
  /* Strings and characters in code. */


@@ -111,33 +133,30 @@ static void unexpected_newline (boundary, char const *);
  /* Bracketed identifiers support. */
 %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID
 
  /* Bracketed identifiers support. */
 %x SC_BRACKETED_ID SC_RETURN_BRACKETED_ID
 

-letter   [-.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]
-id       {letter}({letter}|[0-9])*
-directive %{id}
-int      [0-9]+
-
-/* POSIX says that a tag must be both an id and a C union member, but
-   historically almost any character is allowed in a tag.  We disallow
-   NUL, as this simplifies our implementation.  We disallow angle
-   bracket to match them in nested pairs: several languages use them
-   for generics/template types.  */
-tag     [^\0<>]+
+letter    [.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]
+notletter [^.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]{-}[%\{]
+id        {letter}({letter}|[-0-9])*
+int       [0-9]+

 
 /* Zero or more instances of backslash-newline.  Following GCC, allow
    white space between the backslash and the newline.  */
 
 /* Zero or more instances of backslash-newline.  Following GCC, allow
    white space between the backslash and the newline.  */

-splice  (\\[ \f\t\v]*\n)*
+splice   (\\[ \f\t\v]*\n)*
+
+/* An equal sign, with optional leading whitespaces. This is used in some
+   deprecated constructs. */
+eqopt    ([[:space:]]*=)?

 
 %%
 %{
   /* Nesting level.  Either for nested braces, or nested angle brackets
      (but not mixed).  */
 
 %%
 %{
   /* Nesting level.  Either for nested braces, or nested angle brackets
      (but not mixed).  */

-  int nesting IF_LINT (= 0);
+  int nesting PACIFY_CC (= 0);

 
   /* Parent context state, when applicable.  */
 
   /* Parent context state, when applicable.  */

-  int context_state IF_LINT (= 0);
+  int context_state PACIFY_CC (= 0);

 
   /* Location of most recent identifier, when applicable.  */
 
   /* Location of most recent identifier, when applicable.  */

-  location id_loc IF_LINT (= empty_location);
+  location id_loc PACIFY_CC (= empty_location);

 
   /* Where containing code started, when applicable.  Its initial
      value is relevant only when yylex is invoked in the SC_EPILOGUE
 
   /* Where containing code started, when applicable.  Its initial
      value is relevant only when yylex is invoked in the SC_EPILOGUE


@@ -146,7 +165,7 @@ splice       (\\[ \f\t\v]*\n)*
 
   /* Where containing comment or string or character literal started,
      when applicable.  */
 
   /* Where containing comment or string or character literal started,
      when applicable.  */

-  boundary token_start IF_LINT (= scanner_cursor);
+  boundary token_start PACIFY_CC (= scanner_cursor);

 %}
 
 
 %}
 
 


@@ -157,9 +176,11 @@ splice      (\\[ \f\t\v]*\n)*
 <INITIAL,SC_AFTER_IDENTIFIER,SC_BRACKETED_ID,SC_RETURN_BRACKETED_ID>
 {
   /* Comments and white space.  */
 <INITIAL,SC_AFTER_IDENTIFIER,SC_BRACKETED_ID,SC_RETURN_BRACKETED_ID>
 {
   /* Comments and white space.  */

-  ","         warn_at (*loc, _("stray `,' treated as white space"));
+  "," {
+     complain (loc, Wother, _("stray ',' treated as white space"));
+  }

   [ \f\n\t\v]  |
   [ \f\n\t\v]  |

-  "//".*       ;
+  "//".*       continue;

   "/*" {
     token_start = loc->start;
     context_state = YY_START;
   "/*" {
     token_start = loc->start;
     context_state = YY_START;


@@ -168,7 +189,7 @@ splice       (\\[ \f\t\v]*\n)*
 
   /* #line directives are not documented, and may be withdrawn or
      modified in future versions of Bison.  */
 
   /* #line directives are not documented, and may be withdrawn or
      modified in future versions of Bison.  */

-  ^"#line "{int}" \"".*"\"\n" {
+  ^"#line "{int}(" \"".*"\"")?"\n" {

     handle_syncline (yytext + sizeof "#line " - 1, *loc);
   }
 }
     handle_syncline (yytext + sizeof "#line " - 1, *loc);
   }
 }


@@ -179,7 +200,7 @@ splice       (\\[ \f\t\v]*\n)*
   `----------------------------*/
 
   /* For directives that are also command line options, the regex must be
   `----------------------------*/
 
   /* For directives that are also command line options, the regex must be

-       "%..."
+        "%..."

      after "[-_]"s are removed, and the directive must match the --long
      option name, with a single string argument.  Otherwise, add exceptions
      to ../build-aux/cross-options.pl.  */
      after "[-_]"s are removed, and the directive must match the --long
      option name, with a single string argument.  Otherwise, add exceptions
      to ../build-aux/cross-options.pl.  */


@@ -189,49 +210,64 @@ splice     (\\[ \f\t\v]*\n)*
   "%binary"                         return PERCENT_NONASSOC;
   "%code"                           return PERCENT_CODE;
   "%debug"                          RETURN_PERCENT_FLAG("parse.trace");
   "%binary"                         return PERCENT_NONASSOC;
   "%code"                           return PERCENT_CODE;
   "%debug"                          RETURN_PERCENT_FLAG("parse.trace");

-  "%default"[-_]"prec"              return PERCENT_DEFAULT_PREC;
+  "%default-prec"                   return PERCENT_DEFAULT_PREC;

   "%define"                         return PERCENT_DEFINE;
   "%defines"                        return PERCENT_DEFINES;
   "%destructor"                     return PERCENT_DESTRUCTOR;
   "%dprec"                          return PERCENT_DPREC;
   "%define"                         return PERCENT_DEFINE;
   "%defines"                        return PERCENT_DEFINES;
   "%destructor"                     return PERCENT_DESTRUCTOR;
   "%dprec"                          return PERCENT_DPREC;

-  "%error"[-_]"verbose"             return PERCENT_ERROR_VERBOSE;
+  "%empty"                          return PERCENT_EMPTY;
+  "%error-verbose"                  return PERCENT_ERROR_VERBOSE;

   "%expect"                         return PERCENT_EXPECT;
   "%expect"                         return PERCENT_EXPECT;

-  "%expect"[-_]"rr"                 return PERCENT_EXPECT_RR;
+  "%expect-rr"                      return PERCENT_EXPECT_RR;

   "%file-prefix"                    return PERCENT_FILE_PREFIX;
   "%file-prefix"                    return PERCENT_FILE_PREFIX;

-  "%fixed"[-_]"output"[-_]"files"   return PERCENT_YACC;
+  "%fixed-output-files"             return PERCENT_YACC;

   "%initial-action"                 return PERCENT_INITIAL_ACTION;
   "%glr-parser"                     return PERCENT_GLR_PARSER;
   "%language"                       return PERCENT_LANGUAGE;
   "%left"                           return PERCENT_LEFT;
   "%initial-action"                 return PERCENT_INITIAL_ACTION;
   "%glr-parser"                     return PERCENT_GLR_PARSER;
   "%language"                       return PERCENT_LANGUAGE;
   "%left"                           return PERCENT_LEFT;

-  "%lex-param"                      return PERCENT_LEX_PARAM;
+  "%lex-param"                      RETURN_PERCENT_PARAM(lex);

   "%locations"                      RETURN_PERCENT_FLAG("locations");
   "%merge"                          return PERCENT_MERGE;
   "%locations"                      RETURN_PERCENT_FLAG("locations");
   "%merge"                          return PERCENT_MERGE;

-  "%name"[-_]"prefix"               return PERCENT_NAME_PREFIX;
-  "%no"[-_]"default"[-_]"prec"      return PERCENT_NO_DEFAULT_PREC;
-  "%no"[-_]"lines"                  return PERCENT_NO_LINES;
+  "%name-prefix"                    return PERCENT_NAME_PREFIX;
+  "%no-default-prec"                return PERCENT_NO_DEFAULT_PREC;
+  "%no-lines"                       return PERCENT_NO_LINES;

   "%nonassoc"                       return PERCENT_NONASSOC;
   "%nondeterministic-parser"        return PERCENT_NONDETERMINISTIC_PARSER;
   "%nterm"                          return PERCENT_NTERM;
   "%output"                         return PERCENT_OUTPUT;
   "%nonassoc"                       return PERCENT_NONASSOC;
   "%nondeterministic-parser"        return PERCENT_NONDETERMINISTIC_PARSER;
   "%nterm"                          return PERCENT_NTERM;
   "%output"                         return PERCENT_OUTPUT;

-  "%parse-param"                    return PERCENT_PARSE_PARAM;
+  "%param"                          RETURN_PERCENT_PARAM(both);
+  "%parse-param"                    RETURN_PERCENT_PARAM(parse);

   "%prec"                           return PERCENT_PREC;
   "%precedence"                     return PERCENT_PRECEDENCE;
   "%printer"                        return PERCENT_PRINTER;
   "%prec"                           return PERCENT_PREC;
   "%precedence"                     return PERCENT_PRECEDENCE;
   "%printer"                        return PERCENT_PRINTER;

-  "%pure"[-_]"parser"               RETURN_PERCENT_FLAG("api.pure");
+  "%pure-parser"                    RETURN_PERCENT_FLAG("api.pure");

   "%require"                        return PERCENT_REQUIRE;
   "%right"                          return PERCENT_RIGHT;
   "%skeleton"                       return PERCENT_SKELETON;
   "%start"                          return PERCENT_START;
   "%term"                           return PERCENT_TOKEN;
   "%token"                          return PERCENT_TOKEN;
   "%require"                        return PERCENT_REQUIRE;
   "%right"                          return PERCENT_RIGHT;
   "%skeleton"                       return PERCENT_SKELETON;
   "%start"                          return PERCENT_START;
   "%term"                           return PERCENT_TOKEN;
   "%token"                          return PERCENT_TOKEN;

-  "%token"[-_]"table"               return PERCENT_TOKEN_TABLE;
+  "%token-table"                    return PERCENT_TOKEN_TABLE;

   "%type"                           return PERCENT_TYPE;
   "%union"                          return PERCENT_UNION;
   "%verbose"                        return PERCENT_VERBOSE;
   "%yacc"                           return PERCENT_YACC;
 
   "%type"                           return PERCENT_TYPE;
   "%union"                          return PERCENT_UNION;
   "%verbose"                        return PERCENT_VERBOSE;
   "%yacc"                           return PERCENT_YACC;
 

-  {directive} {
-    complain_at (*loc, _("invalid directive: %s"), quote (yytext));
+  /* deprecated */
+  "%default"[-_]"prec"              DEPRECATED("%default-prec");
+  "%error"[-_]"verbose"             DEPRECATED("%define parse.error verbose");
+  "%expect"[-_]"rr"                 DEPRECATED("%expect-rr");
+  "%file-prefix"{eqopt}             DEPRECATED("%file-prefix");
+  "%fixed"[-_]"output"[-_]"files"   DEPRECATED("%fixed-output-files");
+  "%name"[-_]"prefix"{eqopt}        DEPRECATED("%name-prefix");
+  "%no"[-_]"default"[-_]"prec"      DEPRECATED("%no-default-prec");
+  "%no"[-_]"lines"                  DEPRECATED("%no-lines");
+  "%output"{eqopt}                  DEPRECATED("%output");
+  "%pure"[-_]"parser"               DEPRECATED("%pure-parser");
+  "%token"[-_]"table"               DEPRECATED("%token-table");
+
+  "%"{id}|"%"{notletter}([[:graph:]])+ {
+    complain (loc, complaint, _("invalid directive: %s"), quote (yytext));

   }
 
   "="                     return EQUAL;
   }
 
   "="                     return EQUAL;


@@ -257,14 +293,14 @@ splice     (\\[ \f\t\v]*\n)*
   /* Identifiers may not start with a digit.  Yet, don't silently
      accept "1FOO" as "1 FOO".  */
   {int}{id} {
   /* Identifiers may not start with a digit.  Yet, don't silently
      accept "1FOO" as "1 FOO".  */
   {int}{id} {

-    complain_at (*loc, _("invalid identifier: %s"), quote (yytext));
+    complain (loc, complaint, _("invalid identifier: %s"), quote (yytext));

   }
 
   /* Characters.  */
   }
 
   /* Characters.  */

-  "'"        token_start = loc->start; BEGIN SC_ESCAPED_CHARACTER;
+  "'"         token_start = loc->start; BEGIN SC_ESCAPED_CHARACTER;

 
   /* Strings. */
 
   /* Strings. */

-  "\""       token_start = loc->start; BEGIN SC_ESCAPED_STRING;
+  "\""        token_start = loc->start; BEGIN SC_ESCAPED_STRING;

 
   /* Prologue. */
   "%{"        code_start = loc->start; BEGIN SC_PROLOGUE;
 
   /* Prologue. */
   "%{"        code_start = loc->start; BEGIN SC_PROLOGUE;


@@ -277,16 +313,16 @@ splice     (\\[ \f\t\v]*\n)*
     BEGIN SC_BRACED_CODE;
   }
 
     BEGIN SC_BRACED_CODE;
   }
 

+  /* Semantic predicate. */
+  "%?"[ \f\n\t\v]*"{" {
+    nesting = 0;
+    code_start = loc->start;
+    BEGIN SC_PREDICATE;
+  }
+

   /* A type. */
   "<*>"       return TAG_ANY;
   "<>"        return TAG_NONE;
   /* A type. */
   "<*>"       return TAG_ANY;
   "<>"        return TAG_NONE;

-  "<"{tag}">" {
-    obstack_grow (&obstack_for_string, yytext + 1, yyleng - 2);
-    STRING_FINISH;
-    val->uniqstr = uniqstr_new (last_string);
-    STRING_FREE;
-    return TAG;
-  }

   "<"         {
     nesting = 0;
     token_start = loc->start;
   "<"         {
     nesting = 0;
     token_start = loc->start;


@@ -307,8 +343,10 @@ splice      (\\[ \f\t\v]*\n)*
     BEGIN SC_BRACKETED_ID;
   }
 
     BEGIN SC_BRACKETED_ID;
   }
 

-  . {
-    complain_at (*loc, _("invalid character: %s"), quote (yytext));
+  [^\[%A-Za-z0-9_<>{}\"\'*;|=/, \f\n\t\v]+|. {
+    complain (loc, complaint, "%s: %s",
+              ngettext ("invalid character", "invalid characters", yyleng),
+              quote_mem (yytext, yyleng));

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


@@ -325,7 +363,7 @@ splice       (\\[ \f\t\v]*\n)*
 
 <SC_ESCAPED_CHARACTER,SC_ESCAPED_STRING,SC_TAG>
 {
 
 <SC_ESCAPED_CHARACTER,SC_ESCAPED_STRING,SC_TAG>
 {

-  \0       complain_at (*loc, _("invalid null character"));
+  \0        complain (loc, complaint, _("invalid null character"));

 }
 
 
 }
 
 


@@ -338,16 +376,16 @@ splice     (\\[ \f\t\v]*\n)*
   "[" {
     if (bracketed_id_str)
       {
   "[" {
     if (bracketed_id_str)
       {

-       ROLLBACK_CURRENT_TOKEN;
-       BEGIN SC_RETURN_BRACKETED_ID;
-       *loc = id_loc;
-       return ID;
+        ROLLBACK_CURRENT_TOKEN;
+        BEGIN SC_RETURN_BRACKETED_ID;
+        *loc = id_loc;
+        return ID;

       }
     else
       {
       }
     else
       {

-       bracketed_id_start = loc->start;
-       bracketed_id_context_state = YY_START;
-       BEGIN SC_BRACKETED_ID;
+        bracketed_id_start = loc->start;
+        bracketed_id_context_state = YY_START;
+        BEGIN SC_BRACKETED_ID;

       }
   }
   ":" {
       }
   }
   ":" {


@@ -377,34 +415,39 @@ splice     (\\[ \f\t\v]*\n)*
   {id} {
     if (bracketed_id_str)
       {
   {id} {
     if (bracketed_id_str)
       {

-       complain_at (*loc, _("unexpected identifier in bracketed name: %s"),
-                    quote (yytext));
+        complain (loc, complaint,
+                  _("unexpected identifier in bracketed name: %s"),
+                  quote (yytext));

       }
     else
       {
       }
     else
       {

-       bracketed_id_str = uniqstr_new (yytext);
-       bracketed_id_loc = *loc;
+        bracketed_id_str = uniqstr_new (yytext);
+        bracketed_id_loc = *loc;

       }
   }
   "]" {
     BEGIN bracketed_id_context_state;
     if (bracketed_id_str)
       {
       }
   }
   "]" {
     BEGIN bracketed_id_context_state;
     if (bracketed_id_str)
       {

-       if (INITIAL == bracketed_id_context_state)
-         {
-           val->uniqstr = bracketed_id_str;
-           bracketed_id_str = 0;
-           *loc = bracketed_id_loc;
-           return BRACKETED_ID;
-         }
+        if (INITIAL == bracketed_id_context_state)
+          {
+            val->uniqstr = bracketed_id_str;
+            bracketed_id_str = 0;
+            *loc = bracketed_id_loc;
+            return BRACKETED_ID;
+          }

       }
     else
       }
     else

-      complain_at (*loc, _("an identifier expected"));
+      complain (loc, complaint, _("an identifier expected"));

   }
   }

-  . {
-    complain_at (*loc, _("invalid character in bracketed name: %s"),
-                quote (yytext));
+
+  [^\].A-Za-z0-9_/ \f\n\t\v]+|. {
+    complain (loc, complaint, "%s: %s",
+              ngettext ("invalid character in bracketed name",
+                        "invalid characters in bracketed name", yyleng),
+              quote_mem (yytext, yyleng));

   }
   }

+

   <<EOF>> {
     BEGIN bracketed_id_context_state;
     unexpected_eof (bracketed_id_start, "]");
   <<EOF>> {
     BEGIN bracketed_id_context_state;
     unexpected_eof (bracketed_id_start, "]");


@@ -425,37 +468,37 @@ splice     (\\[ \f\t\v]*\n)*
 
 
   /*---------------------------------------------------------------.
 
 
   /*---------------------------------------------------------------.

-  | Scanning a Yacc comment.  The initial `/ *' is already eaten.  |
+  | Scanning a Yacc comment.  The initial '/ *' is already eaten.  |

   `---------------------------------------------------------------*/
 
 <SC_YACC_COMMENT>
 {
   "*/"     BEGIN context_state;
   `---------------------------------------------------------------*/
 
 <SC_YACC_COMMENT>
 {
   "*/"     BEGIN context_state;

-  .|\n    ;
+  .|\n     continue;

   <<EOF>>  unexpected_eof (token_start, "*/"); BEGIN context_state;
 }
 
 
   /*------------------------------------------------------------.
   <<EOF>>  unexpected_eof (token_start, "*/"); BEGIN context_state;
 }
 
 
   /*------------------------------------------------------------.

-  | Scanning a C comment.  The initial `/ *' is already eaten.  |
+  | Scanning a C comment.  The initial '/ *' is already eaten.  |

   `------------------------------------------------------------*/
 
 <SC_COMMENT>
 {
   "*"{splice}"/"  STRING_GROW; BEGIN context_state;
   `------------------------------------------------------------*/
 
 <SC_COMMENT>
 {
   "*"{splice}"/"  STRING_GROW; BEGIN context_state;

-  <<EOF>>        unexpected_eof (token_start, "*/"); BEGIN context_state;
+  <<EOF>>         unexpected_eof (token_start, "*/"); BEGIN context_state;

 }
 
 
   /*--------------------------------------------------------------.
 }
 
 
   /*--------------------------------------------------------------.

-  | Scanning a line comment.  The initial `//' is already eaten.  |
+  | Scanning a line comment.  The initial '//' is already eaten.  |

   `--------------------------------------------------------------*/
 
 <SC_LINE_COMMENT>
 {
   `--------------------------------------------------------------*/
 
 <SC_LINE_COMMENT>
 {

-  "\n"          STRING_GROW; BEGIN context_state;
-  {splice}      STRING_GROW;
-  <<EOF>>       BEGIN context_state;
+  "\n"           STRING_GROW; BEGIN context_state;
+  {splice}       STRING_GROW;
+  <<EOF>>        BEGIN context_state;

 }
 
 
 }
 
 


@@ -466,79 +509,52 @@ splice     (\\[ \f\t\v]*\n)*
 
 <SC_ESCAPED_STRING>
 {
 
 <SC_ESCAPED_STRING>
 {

-  "\""|"\n" {
-    if (yytext[0] == '\n')
-      unexpected_newline (token_start, "\"");
-    STRING_FINISH;
-    loc->start = token_start;
-    val->chars = last_string;
-    BEGIN INITIAL;
-    return STRING;
-  }
-  <<EOF>> {
-    unexpected_eof (token_start, "\"");
+  "\"" {

     STRING_FINISH;
     loc->start = token_start;
     val->chars = last_string;
     BEGIN INITIAL;
     return STRING;
   }
     STRING_FINISH;
     loc->start = token_start;
     val->chars = last_string;
     BEGIN INITIAL;
     return STRING;
   }

+  <<EOF>>   unexpected_eof (token_start, "\"");
+  "\n"      unexpected_newline (token_start, "\"");

 }
 
   /*----------------------------------------------------------.
   | Scanning a Bison character literal, decoding its escapes. |
 }
 
   /*----------------------------------------------------------.
   | Scanning a Bison character literal, decoding its escapes. |

-  | The initial quote is already eaten.                              |
+  | The initial quote is already eaten.                       |

   `----------------------------------------------------------*/
 
 <SC_ESCAPED_CHARACTER>
 {
   `----------------------------------------------------------*/
 
 <SC_ESCAPED_CHARACTER>
 {

-  "'"|"\n" {
-    STRING_FINISH;
-    loc->start = token_start;
-    val->character = last_string[0];
-    {
-      /* FIXME: Eventually, make these errors.  */
-      if (last_string[0] == '\0')
-        {
-          warn_at (*loc, _("empty character literal"));
-          /* '\0' seems dangerous even if we are about to complain.  */
-          val->character = '\'';
-        }
-      else if (last_string[1] != '\0')
-        warn_at (*loc, _("extra characters in character literal"));
-    }
-    if (yytext[0] == '\n')
-      unexpected_newline (token_start, "'");
-    STRING_FREE;
-    BEGIN INITIAL;
-    return CHAR;
-  }
-  <<EOF>> {
+  "'" {

     STRING_FINISH;
     loc->start = token_start;
     val->character = last_string[0];
     STRING_FINISH;
     loc->start = token_start;
     val->character = last_string[0];

+
+    /* FIXME: Eventually, make these errors.  */
+    if (last_string[0] == '\0')

     {
     {

-      /* FIXME: Eventually, make these errors.  */
-      if (last_string[0] == '\0')
-        {
-          warn_at (*loc, _("empty character literal"));
-          /* '\0' seems dangerous even if we are about to complain.  */
-          val->character = '\'';
-        }
-      else if (last_string[1] != '\0')
-        warn_at (*loc, _("extra characters in character literal"));
+      complain (loc, Wother, _("empty character literal"));
+      /* '\0' seems dangerous even if we are about to complain.  */
+      val->character = '\'';

     }
     }

-    unexpected_eof (token_start, "'");
+    else if (last_string[1] != '\0')
+      complain (loc, Wother,
+                _("extra characters in character literal"));

     STRING_FREE;
     BEGIN INITIAL;
     return CHAR;
   }
     STRING_FREE;
     BEGIN INITIAL;
     return CHAR;
   }

+  "\n"      unexpected_newline (token_start, "'");
+  <<EOF>>   unexpected_eof (token_start, "'");

 }
 
 }
 

-  /*-----------------------------------------------------------.
-  | Scanning a Bison nested tag.  The initial angle bracket is |
-  | already eaten.                                             |
-  `-----------------------------------------------------------*/
+
+
+  /*--------------------------------------------------------------.
+  | Scanning a tag.  The initial angle bracket is already eaten.  |
+  `--------------------------------------------------------------*/

 
 <SC_TAG>
 {
 
 <SC_TAG>
 {


@@ -556,18 +572,10 @@ splice     (\\[ \f\t\v]*\n)*
     STRING_GROW;
   }
 
     STRING_GROW;
   }
 

-  [^<>]+ STRING_GROW;
+  ([^<>]|->)+ STRING_GROW;

   "<"+   STRING_GROW; nesting += yyleng;
 
   "<"+   STRING_GROW; nesting += yyleng;
 

-  <<EOF>> {
-    unexpected_eof (token_start, ">");
-    STRING_FINISH;
-    loc->start = token_start;
-    val->uniqstr = uniqstr_new (last_string);
-    STRING_FREE;
-    BEGIN INITIAL;
-    return TAG;
-  }
+  <<EOF>>   unexpected_eof (token_start, ">");

 }
 
   /*----------------------------.
 }
 
   /*----------------------------.


@@ -578,10 +586,9 @@ splice      (\\[ \f\t\v]*\n)*
 {
   \\[0-7]{1,3} {
     unsigned long int c = strtoul (yytext + 1, NULL, 8);
 {
   \\[0-7]{1,3} {
     unsigned long int c = strtoul (yytext + 1, NULL, 8);

-    if (UCHAR_MAX < c)
-      complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
-    else if (! c)
-      complain_at (*loc, _("invalid null character: %s"), quote (yytext));
+    if (!c || UCHAR_MAX < c)
+      complain (loc, complaint, _("invalid number after \\-escape: %s"),
+                   yytext+1);

     else
       obstack_1grow (&obstack_for_string, c);
   }
     else
       obstack_1grow (&obstack_for_string, c);
   }


@@ -589,37 +596,41 @@ splice     (\\[ \f\t\v]*\n)*
   \\x[0-9abcdefABCDEF]+ {
     verify (UCHAR_MAX < ULONG_MAX);
     unsigned long int c = strtoul (yytext + 2, NULL, 16);
   \\x[0-9abcdefABCDEF]+ {
     verify (UCHAR_MAX < ULONG_MAX);
     unsigned long int c = strtoul (yytext + 2, NULL, 16);

-    if (UCHAR_MAX < c)
-      complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
-    else if (! c)
-      complain_at (*loc, _("invalid null character: %s"), quote (yytext));
+    if (!c || UCHAR_MAX < c)
+      complain (loc, complaint, _("invalid number after \\-escape: %s"),
+                   yytext+1);

     else
       obstack_1grow (&obstack_for_string, c);
   }
 
     else
       obstack_1grow (&obstack_for_string, c);
   }
 

-  \\a  obstack_1grow (&obstack_for_string, '\a');
-  \\b  obstack_1grow (&obstack_for_string, '\b');
-  \\f  obstack_1grow (&obstack_for_string, '\f');
-  \\n  obstack_1grow (&obstack_for_string, '\n');
-  \\r  obstack_1grow (&obstack_for_string, '\r');
-  \\t  obstack_1grow (&obstack_for_string, '\t');
-  \\v  obstack_1grow (&obstack_for_string, '\v');
+  \\a   obstack_1grow (&obstack_for_string, '\a');
+  \\b   obstack_1grow (&obstack_for_string, '\b');
+  \\f   obstack_1grow (&obstack_for_string, '\f');
+  \\n   obstack_1grow (&obstack_for_string, '\n');
+  \\r   obstack_1grow (&obstack_for_string, '\r');
+  \\t   obstack_1grow (&obstack_for_string, '\t');
+  \\v   obstack_1grow (&obstack_for_string, '\v');

 
   /* \\[\"\'?\\] would be shorter, but it confuses xgettext.  */
   \\("\""|"'"|"?"|"\\")  obstack_1grow (&obstack_for_string, yytext[1]);
 
   \\(u|U[0-9abcdefABCDEF]{4})[0-9abcdefABCDEF]{4} {
     int c = convert_ucn_to_byte (yytext);
 
   /* \\[\"\'?\\] would be shorter, but it confuses xgettext.  */
   \\("\""|"'"|"?"|"\\")  obstack_1grow (&obstack_for_string, yytext[1]);
 
   \\(u|U[0-9abcdefABCDEF]{4})[0-9abcdefABCDEF]{4} {
     int c = convert_ucn_to_byte (yytext);

-    if (c < 0)
-      complain_at (*loc, _("invalid escape sequence: %s"), quote (yytext));
-    else if (! c)
-      complain_at (*loc, _("invalid null character: %s"), quote (yytext));
+    if (c <= 0)
+      complain (loc, complaint, _("invalid number after \\-escape: %s"),
+                   yytext+1);

     else
       obstack_1grow (&obstack_for_string, c);
   }
     else
       obstack_1grow (&obstack_for_string, c);
   }

-  \\(.|\n)     {
-    complain_at (*loc, _("unrecognized escape sequence: %s"), quote (yytext));
-    STRING_GROW;
+  \\(.|\n)      {
+    char const *p = yytext + 1;
+    /* Quote only if escaping won't make the character visible.  */
+    if (c_isspace ((unsigned char) *p) && c_isprint ((unsigned char) *p))
+      p = quote (p);
+    else
+      p = quotearg_style_mem (escape_quoting_style, p, 1);
+    complain (loc, complaint, _("invalid character after \\-escape: %s"),
+                 p);

   }
 }
 
   }
 }
 


@@ -629,21 +640,21 @@ splice     (\\[ \f\t\v]*\n)*
 
 <SC_CHARACTER,SC_STRING>
 {
 
 <SC_CHARACTER,SC_STRING>
 {

-  {splice}|\\{splice}[^\n\[\]] STRING_GROW;
+  {splice}|\\{splice}[^\n\[\]]  STRING_GROW;

 }
 
 <SC_CHARACTER>
 {
 }
 
 <SC_CHARACTER>
 {

-  "'"          STRING_GROW; BEGIN context_state;
-  \n           unexpected_newline (token_start, "'"); BEGIN context_state;
-  <<EOF>>      unexpected_eof (token_start, "'"); BEGIN context_state;
+  "'"           STRING_GROW; BEGIN context_state;
+  \n            unexpected_newline (token_start, "'");
+  <<EOF>>       unexpected_eof (token_start, "'");

 }
 
 <SC_STRING>
 {
 }
 
 <SC_STRING>
 {

-  "\""         STRING_GROW; BEGIN context_state;
-  \n           unexpected_newline (token_start, "\""); BEGIN context_state;
-  <<EOF>>      unexpected_eof (token_start, "\""); BEGIN context_state;
+  "\""          STRING_GROW; BEGIN context_state;
+  \n            unexpected_newline (token_start, "\"");
+  <<EOF>>       unexpected_eof (token_start, "\"");

 }
 
 
 }
 
 


@@ -651,7 +662,7 @@ splice       (\\[ \f\t\v]*\n)*
   | Strings, comments etc. can be found in user code.  |
   `---------------------------------------------------*/
 
   | Strings, comments etc. can be found in user code.  |
   `---------------------------------------------------*/
 

-<SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>
+<SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE,SC_PREDICATE>

 {
   "'" {
     STRING_GROW;
 {
   "'" {
     STRING_GROW;


@@ -681,43 +692,56 @@ splice     (\\[ \f\t\v]*\n)*
 
 
   /*-----------------------------------------------------------.
 
 
   /*-----------------------------------------------------------.

-  | Scanning some code in braces (actions). The initial "{" is |
-  | already eaten.                                             |
+  | Scanning some code in braces (actions, predicates). The    |
+  | initial "{" is already eaten.                              |

   `-----------------------------------------------------------*/
 
   `-----------------------------------------------------------*/
 

-<SC_BRACED_CODE>
+<SC_BRACED_CODE,SC_PREDICATE>

 {
   "{"|"<"{splice}"%"  STRING_GROW; nesting++;
   "%"{splice}">"      STRING_GROW; nesting--;
 {
   "{"|"<"{splice}"%"  STRING_GROW; nesting++;
   "%"{splice}">"      STRING_GROW; nesting--;

+
+  /* Tokenize '<<%' correctly (as '<<' '%') rather than incorrrectly
+     (as '<' '<%').  */
+  "<"{splice}"<"  STRING_GROW;
+
+  <<EOF>>   unexpected_eof (code_start, "}");
+}
+
+<SC_BRACED_CODE>
+{

   "}" {
     obstack_1grow (&obstack_for_string, '}');
 
     --nesting;
     if (nesting < 0)
       {
   "}" {
     obstack_1grow (&obstack_for_string, '}');
 
     --nesting;
     if (nesting < 0)
       {

-       STRING_FINISH;
-       loc->start = code_start;
-       val->code = last_string;
-       BEGIN INITIAL;
-       return BRACED_CODE;
+        STRING_FINISH;
+        loc->start = code_start;
+        val->code = last_string;
+        BEGIN INITIAL;
+        return BRACED_CODE;

       }
   }
       }
   }

+}

 
 

-  /* Tokenize `<<%' correctly (as `<<' `%') rather than incorrrectly
-     (as `<' `<%').  */
-  "<"{splice}"<"  STRING_GROW;
-
-  <<EOF>> {
-    unexpected_eof (code_start, "}");
-    STRING_FINISH;
-    loc->start = code_start;
-    val->code = last_string;
-    BEGIN INITIAL;
-    return BRACED_CODE;
+<SC_PREDICATE>
+{
+  "}" {
+    --nesting;
+    if (nesting < 0)
+      {
+        STRING_FINISH;
+        loc->start = code_start;
+        val->code = last_string;
+        BEGIN INITIAL;
+        return BRACED_PREDICATE;
+      }
+    else
+      obstack_1grow (&obstack_for_string, '}');

   }
 }
 
   }
 }
 

-

   /*--------------------------------------------------------------.
   | Scanning some prologue: from "%{" (already scanned) to "%}".  |
   `--------------------------------------------------------------*/
   /*--------------------------------------------------------------.
   | Scanning some prologue: from "%{" (already scanned) to "%}".  |
   `--------------------------------------------------------------*/


@@ -732,14 +756,7 @@ splice      (\\[ \f\t\v]*\n)*
     return PROLOGUE;
   }
 
     return PROLOGUE;
   }
 

-  <<EOF>> {
-    unexpected_eof (code_start, "%}");
-    STRING_FINISH;
-    loc->start = code_start;
-    val->chars = last_string;
-    BEGIN INITIAL;
-    return PROLOGUE;
-  }
+  <<EOF>>   unexpected_eof (code_start, "%}");

 }
 
 
 }
 
 


@@ -764,8 +781,8 @@ splice       (\\[ \f\t\v]*\n)*
   | By default, grow the string obstack with the input.  |
   `-----------------------------------------------------*/
 
   | By default, grow the string obstack with the input.  |
   `-----------------------------------------------------*/
 

-<SC_COMMENT,SC_LINE_COMMENT,SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE,SC_STRING,SC_CHARACTER,SC_ESCAPED_STRING,SC_ESCAPED_CHARACTER>.     |
-<SC_COMMENT,SC_LINE_COMMENT,SC_BRACED_CODE,SC_PROLOGUE,SC_EPILOGUE>\n  STRING_GROW;
+<SC_COMMENT,SC_LINE_COMMENT,SC_BRACED_CODE,SC_PREDICATE,SC_PROLOGUE,SC_EPILOGUE,SC_STRING,SC_CHARACTER,SC_ESCAPED_STRING,SC_ESCAPED_CHARACTER>. |
+  <SC_COMMENT,SC_LINE_COMMENT,SC_BRACED_CODE,SC_PREDICATE,SC_PROLOGUE,SC_EPILOGUE>\n    STRING_GROW;

 
 %%
 
 
 %%
 


@@ -781,35 +798,35 @@ no_cr_read (FILE *fp, char *buf, size_t size)
     {
       char *w = memchr (buf, '\r', bytes_read);
       if (w)
     {
       char *w = memchr (buf, '\r', bytes_read);
       if (w)

-       {
-         char const *r = ++w;
-         char const *lim = buf + bytes_read;
-
-         for (;;)
-           {
-             /* Found an '\r'.  Treat it like '\n', but ignore any
-                '\n' that immediately follows.  */
-             w[-1] = '\n';
-             if (r == lim)
-               {
-                 int ch = getc (fp);
-                 if (ch != '\n' && ungetc (ch, fp) != ch)
-                   break;
-               }
-             else if (*r == '\n')
-               r++;
-
-             /* Copy until the next '\r'.  */
-             do
-               {
-                 if (r == lim)
-                   return w - buf;
-               }
-             while ((*w++ = *r++) != '\r');
-           }
-
-         return w - buf;
-       }
+        {
+          char const *r = ++w;
+          char const *lim = buf + bytes_read;
+
+          for (;;)
+            {
+              /* Found an '\r'.  Treat it like '\n', but ignore any
+                 '\n' that immediately follows.  */
+              w[-1] = '\n';
+              if (r == lim)
+                {
+                  int ch = getc (fp);
+                  if (ch != '\n' && ungetc (ch, fp) != ch)
+                    break;
+                }
+              else if (*r == '\n')
+                r++;
+
+              /* Copy until the next '\r'.  */
+              do
+                {
+                  if (r == lim)
+                    return w - buf;
+                }
+              while ((*w++ = *r++) != '\r');
+            }
+
+          return w - buf;
+        }

     }
 
   return bytes_read;
     }
 
   return bytes_read;


@@ -829,7 +846,8 @@ scan_integer (char const *number, int base, location loc)
 
   if (INT_MAX < num)
     {
 
   if (INT_MAX < num)
     {

-      complain_at (loc, _("integer out of range: %s"), quote (number));
+      complain (&loc, complaint, _("integer out of range: %s"),
+                   quote (number));

       num = INT_MAX;
     }
 
       num = INT_MAX;
     }
 


@@ -840,7 +858,7 @@ scan_integer (char const *number, int base, location loc)
 /*------------------------------------------------------------------.
 | Convert universal character name UCN to a single-byte character,  |
 | and return that character.  Return -1 if UCN does not correspond  |
 /*------------------------------------------------------------------.
 | Convert universal character name UCN to a single-byte character,  |
 | and return that character.  Return -1 if UCN does not correspond  |

-| to a single-byte character.                                      |
+| to a single-byte character.                                       |

 `------------------------------------------------------------------*/
 
 static int
 `------------------------------------------------------------------*/
 
 static int


@@ -868,22 +886,22 @@ convert_ucn_to_byte (char const *ucn)
        about.  */
     static signed char const table[] =
       {
        about.  */
     static signed char const table[] =
       {

-       '\0',   -1,   -1,   -1,   -1,   -1,   -1, '\a',
-       '\b', '\t', '\n', '\v', '\f', '\r',   -1,   -1,
-         -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-         -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-        ' ',  '!',  '"',  '#',  '$',  '%',  '&', '\'',
-        '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
-        '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
-        '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
-        '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
-        'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
-        'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
-        'X',  'Y',  'Z',  '[', '\\',  ']',  '^',  '_',
-        '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
-        'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
-        'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
-        'x',  'y',  'z',  '{',  '|',  '}',  '~'
+        '\0',   -1,   -1,   -1,   -1,   -1,   -1, '\a',
+        '\b', '\t', '\n', '\v', '\f', '\r',   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+         ' ',  '!',  '"',  '#',  '$',  '%',  '&', '\'',
+         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
+         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
+         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
+         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
+         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
+         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
+         'X',  'Y',  'Z',  '[', '\\',  ']',  '^',  '_',
+         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
+         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
+         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
+         'x',  'y',  'z',  '{',  '|',  '}',  '~'

       };
 
     code = code < sizeof table ? table[code] : -1;
       };
 
     code = code < sizeof table ? table[code] : -1;


@@ -894,31 +912,35 @@ convert_ucn_to_byte (char const *ucn)
 }
 
 
 }
 
 

-/*----------------------------------------------------------------.
-| Handle `#line INT "FILE"'.  ARGS has already skipped `#line '.  |
-`----------------------------------------------------------------*/
+/*---------------------------------------------------------------------.
+| Handle '#line INT( "FILE")?\n'.  ARGS has already skipped '#line '.  |
+`---------------------------------------------------------------------*/

 
 static void
 handle_syncline (char *args, location loc)
 {
 
 static void
 handle_syncline (char *args, location loc)
 {

-  char *after_num;
-  unsigned long int lineno = strtoul (args, &after_num, 10);
-  char *file = strchr (after_num, '"') + 1;
-  *strchr (file, '"') = '\0';
+  char *file;
+  unsigned long int lineno = strtoul (args, &file, 10);

   if (INT_MAX <= lineno)
     {
   if (INT_MAX <= lineno)
     {

-      warn_at (loc, _("line number overflow"));
+      complain (&loc, Wother, _("line number overflow"));

       lineno = INT_MAX;
     }
       lineno = INT_MAX;
     }

-  current_file = uniqstr_new (file);
+
+  file = strchr (file, '"');
+  if (file)
+    {
+      *strchr (file + 1, '"') = '\0';
+      current_file = uniqstr_new (file + 1);
+    }

   boundary_set (&scanner_cursor, current_file, lineno, 1);
 }
 
 
 /*----------------------------------------------------------------.
 | For a token or comment starting at START, report message MSGID, |
   boundary_set (&scanner_cursor, current_file, lineno, 1);
 }
 
 
 /*----------------------------------------------------------------.
 | For a token or comment starting at START, report message MSGID, |

-| which should say that an end marker was found before           |
-| the expected TOKEN_END.                                        |
+| which should say that an end marker was found before the        |
+| expected TOKEN_END. Then, pretend that TOKEN_END was found.     |

 `----------------------------------------------------------------*/
 
 static void
 `----------------------------------------------------------------*/
 
 static void


@@ -927,19 +949,33 @@ unexpected_end (boundary start, char const *msgid, char const *token_end)
   location loc;
   loc.start = start;
   loc.end = scanner_cursor;
   location loc;
   loc.start = start;
   loc.end = scanner_cursor;

-  complain_at (loc, _(msgid), token_end);
+  size_t i = strlen (token_end);
+
+/* Adjust scanner cursor so that any later message does not count
+     the characters about to be inserted.  */
+  scanner_cursor.column -= i;
+
+  while (i != 0)
+    unput (token_end[--i]);
+
+  token_end = quote (token_end);
+  /* Instead of '\'', display "'".  */
+  if (STREQ (token_end, "'\\''"))
+    token_end = "\"'\"";
+  complain (&loc, complaint, _(msgid), token_end);

 }
 
 
 /*------------------------------------------------------------------------.
 | Report an unexpected EOF in a token or comment starting at START.       |
 | An end of file was encountered and the expected TOKEN_END was missing.  |
 }
 
 
 /*------------------------------------------------------------------------.
 | Report an unexpected EOF in a token or comment starting at START.       |
 | An end of file was encountered and the expected TOKEN_END was missing.  |

+| After reporting the problem, pretend that TOKEN_END was found.          |

 `------------------------------------------------------------------------*/
 
 static void
 unexpected_eof (boundary start, char const *token_end)
 {
 `------------------------------------------------------------------------*/
 
 static void
 unexpected_eof (boundary start, char const *token_end)
 {

-  unexpected_end (start, N_("missing `%s' at end of file"), token_end);
+  unexpected_end (start, N_("missing %s at end of file"), token_end);

 }
 
 
 }
 
 


@@ -950,7 +986,7 @@ unexpected_eof (boundary start, char const *token_end)
 static void
 unexpected_newline (boundary start, char const *token_end)
 {
 static void
 unexpected_newline (boundary start, char const *token_end)
 {

-  unexpected_end (start, N_("missing `%s' at end of line"), token_end);
+  unexpected_end (start, N_("missing %s at end of line"), token_end);

 }
 
 
 }