projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* elf32-mips.c (mips_elf_gprel32_reloc): Reject
[deliverable/binutils-gdb.git] / gas / app.c
diff --git a/gas/app.c b/gas/app.c
index c338653fa46b3b610dfda22113ea3f1e3f08a544..1dbc49a8cd894f79667966a7ce47314874d6e914 100644 (file)
--- a/gas/app.c
+++ b/gas/app.c
@@ -1,5 +1,6 @@
 /* This is the Assembler Pre-Processor
 /* This is the Assembler Pre-Processor
-   Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 1996
+   Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+   1999, 2000, 2002, 2003
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
    Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
@@ -15,17 +16,18 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with GAS; see the file COPYING.  If not, write to
-   the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   along with GAS; see the file COPYING.  If not, write to the Free
+   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
 
 
-/* Modified by Allen Wirfs-Brock, Instantiations Inc 2/90 */
+/* Modified by Allen Wirfs-Brock, Instantiations Inc 2/90.  */
 /* App, the assembler pre-processor.  This pre-processor strips out excess
    spaces, turns single-quoted characters into a decimal constant, and turns
    # <number> <filename> <garbage> into a .line <number>\n.file <filename>
    pair.  This needs better error-handling.  */
 
 #include <stdio.h>
 /* App, the assembler pre-processor.  This pre-processor strips out excess
    spaces, turns single-quoted characters into a decimal constant, and turns
    # <number> <filename> <garbage> into a .line <number>\n.file <filename>
    pair.  This needs better error-handling.  */
 
 #include <stdio.h>
-#include "as.h"                        /* For BAD_CASE() only */
+#include "as.h"                        /* For BAD_CASE() only.  */
 
 #if (__STDC__ != 1)
 #ifndef const
 
 #if (__STDC__ != 1)
 #ifndef const
@@ -33,6 +35,26 @@
 #endif
 #endif
 
 #endif
 #endif
 
+#ifdef TC_M68K
+/* Whether we are scrubbing in m68k MRI mode.  This is different from
+   flag_m68k_mri, because the two flags will be affected by the .mri
+   pseudo-op at different times.  */
+static int scrub_m68k_mri;
+
+/* The pseudo-op which switches in and out of MRI mode.  See the
+   comment in do_scrub_chars.  */
+static const char mri_pseudo[] = ".mri 0";
+#else
+#define scrub_m68k_mri 0
+#endif
+
+#if defined TC_ARM && defined OBJ_ELF
+/* The pseudo-op for which we need to special-case `@' characters.
+   See the comment in do_scrub_chars.  */
+static const char   symver_pseudo[] = ".symver";
+static const char * symver_state;
+#endif
+
 static char lex[256];
 static const char symbol_chars[] =
 "$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 static char lex[256];
 static const char symbol_chars[] =
 "$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
@@ -43,40 +65,56 @@ static const char symbol_chars[] =
 #define LEX_IS_COMMENT_START           4
 #define LEX_IS_LINE_COMMENT_START      5
 #define        LEX_IS_TWOCHAR_COMMENT_1ST      6
 #define LEX_IS_COMMENT_START           4
 #define LEX_IS_LINE_COMMENT_START      5
 #define        LEX_IS_TWOCHAR_COMMENT_1ST      6
-#define        LEX_IS_TWOCHAR_COMMENT_2ND      7
 #define        LEX_IS_STRINGQUOTE              8
 #define        LEX_IS_COLON                    9
 #define        LEX_IS_NEWLINE                  10
 #define        LEX_IS_ONECHAR_QUOTE            11
 #define        LEX_IS_STRINGQUOTE              8
 #define        LEX_IS_COLON                    9
 #define        LEX_IS_NEWLINE                  10
 #define        LEX_IS_ONECHAR_QUOTE            11
+#ifdef TC_V850
+#define LEX_IS_DOUBLEDASH_1ST          12
+#endif
+#ifdef TC_M32R
+#define DOUBLEBAR_PARALLEL
+#endif
+#ifdef DOUBLEBAR_PARALLEL
+#define LEX_IS_DOUBLEBAR_1ST           13
+#endif
+#define LEX_IS_PARALLEL_SEPARATOR      14
 #define IS_SYMBOL_COMPONENT(c)         (lex[c] == LEX_IS_SYMBOL_COMPONENT)
 #define IS_WHITESPACE(c)               (lex[c] == LEX_IS_WHITESPACE)
 #define IS_LINE_SEPARATOR(c)           (lex[c] == LEX_IS_LINE_SEPARATOR)
 #define IS_SYMBOL_COMPONENT(c)         (lex[c] == LEX_IS_SYMBOL_COMPONENT)
 #define IS_WHITESPACE(c)               (lex[c] == LEX_IS_WHITESPACE)
 #define IS_LINE_SEPARATOR(c)           (lex[c] == LEX_IS_LINE_SEPARATOR)
+#define IS_PARALLEL_SEPARATOR(c)       (lex[c] == LEX_IS_PARALLEL_SEPARATOR)
 #define IS_COMMENT(c)                  (lex[c] == LEX_IS_COMMENT_START)
 #define IS_LINE_COMMENT(c)             (lex[c] == LEX_IS_LINE_COMMENT_START)
 #define        IS_NEWLINE(c)                   (lex[c] == LEX_IS_NEWLINE)
 
 #define IS_COMMENT(c)                  (lex[c] == LEX_IS_COMMENT_START)
 #define IS_LINE_COMMENT(c)             (lex[c] == LEX_IS_LINE_COMMENT_START)
 #define        IS_NEWLINE(c)                   (lex[c] == LEX_IS_NEWLINE)
 
-static int process_escape PARAMS ((int));
+static int process_escape (int);
 
 /* FIXME-soon: The entire lexer/parser thingy should be
    built statically at compile time rather than dynamically
 
 /* FIXME-soon: The entire lexer/parser thingy should be
    built statically at compile time rather than dynamically
-   each and every time the assembler is run.  xoxorich. */
+   each and every time the assembler is run.  xoxorich.  */
 
 
-void 
-do_scrub_begin ()
+void
+do_scrub_begin (int m68k_mri ATTRIBUTE_UNUSED)
 {
   const char *p;
 {
   const char *p;
+  int c;
 
   lex[' '] = LEX_IS_WHITESPACE;
   lex['\t'] = LEX_IS_WHITESPACE;
 
   lex[' '] = LEX_IS_WHITESPACE;
   lex['\t'] = LEX_IS_WHITESPACE;
+  lex['\r'] = LEX_IS_WHITESPACE;
   lex['\n'] = LEX_IS_NEWLINE;
   lex['\n'] = LEX_IS_NEWLINE;
-  lex[';'] = LEX_IS_LINE_SEPARATOR;
   lex[':'] = LEX_IS_COLON;
 
   lex[':'] = LEX_IS_COLON;
 
-  if (! flag_m68k_mri)
+#ifdef TC_M68K
+  scrub_m68k_mri = m68k_mri;
+
+  if (! m68k_mri)
+#endif
     {
       lex['"'] = LEX_IS_STRINGQUOTE;
 
     {
       lex['"'] = LEX_IS_STRINGQUOTE;
 
-#ifndef TC_HPPA
+#if ! defined (TC_HPPA) && ! defined (TC_I370)
+      /* I370 uses single-quotes to delimit integer, float constants.  */
       lex['\''] = LEX_IS_ONECHAR_QUOTE;
 #endif
 
       lex['\''] = LEX_IS_ONECHAR_QUOTE;
 #endif
 
@@ -91,49 +129,71 @@ do_scrub_begin ()
   /* Note that these override the previous defaults, e.g. if ';' is a
      comment char, then it isn't a line separator.  */
   for (p = symbol_chars; *p; ++p)
   /* Note that these override the previous defaults, e.g. if ';' is a
      comment char, then it isn't a line separator.  */
   for (p = symbol_chars; *p; ++p)
-    {
-      lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT;
-    }                          /* declare symbol characters */
+    lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT;
+
+  for (c = 128; c < 256; ++c)
+    lex[c] = LEX_IS_SYMBOL_COMPONENT;
+
+#ifdef tc_symbol_chars
+  /* This macro permits the processor to specify all characters which
+     may appears in an operand.  This will prevent the scrubber from
+     discarding meaningful whitespace in certain cases.  The i386
+     backend uses this to support prefixes, which can confuse the
+     scrubber as to whether it is parsing operands or opcodes.  */
+  for (p = tc_symbol_chars; *p; ++p)
+    lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT;
+#endif
 
 
-  for (p = comment_chars; *p; p++)
-    {
-      lex[(unsigned char) *p] = LEX_IS_COMMENT_START;
-    }                          /* declare comment chars */
+  /* The m68k backend wants to be able to change comment_chars.  */
+#ifndef tc_comment_chars
+#define tc_comment_chars comment_chars
+#endif
+  for (p = tc_comment_chars; *p; p++)
+    lex[(unsigned char) *p] = LEX_IS_COMMENT_START;
 
   for (p = line_comment_chars; *p; p++)
 
   for (p = line_comment_chars; *p; p++)
-    {
-      lex[(unsigned char) *p] = LEX_IS_LINE_COMMENT_START;
-    }                          /* declare line comment chars */
+    lex[(unsigned char) *p] = LEX_IS_LINE_COMMENT_START;
 
   for (p = line_separator_chars; *p; p++)
 
   for (p = line_separator_chars; *p; p++)
-    {
-      lex[(unsigned char) *p] = LEX_IS_LINE_SEPARATOR;
-    }                          /* declare line separators */
+    lex[(unsigned char) *p] = LEX_IS_LINE_SEPARATOR;
+
+#ifdef tc_parallel_separator_chars
+  /* This macro permits the processor to specify all characters which
+     separate parallel insns on the same line.  */
+  for (p = tc_parallel_separator_chars; *p; p++)
+    lex[(unsigned char) *p] = LEX_IS_PARALLEL_SEPARATOR;
+#endif
 
 
-  /* Only allow slash-star comments if slash is not in use */
+  /* Only allow slash-star comments if slash is not in use.
+     FIXME: This isn't right.  We should always permit them.  */
   if (lex['/'] == 0)
   if (lex['/'] == 0)
-    {
-      lex['/'] = LEX_IS_TWOCHAR_COMMENT_1ST;
-    }
-  /* FIXME-soon.  This is a bad hack but otherwise, we can't do
-     c-style comments when '/' is a line comment char. xoxorich. */
-  if (lex['*'] == 0)
-    {
-      lex['*'] = LEX_IS_TWOCHAR_COMMENT_2ND;
-    }
+    lex['/'] = LEX_IS_TWOCHAR_COMMENT_1ST;
 
 
-  if (flag_m68k_mri)
+#ifdef TC_M68K
+  if (m68k_mri)
     {
       lex['\''] = LEX_IS_STRINGQUOTE;
       lex[';'] = LEX_IS_COMMENT_START;
       lex['*'] = LEX_IS_LINE_COMMENT_START;
       /* The MRI documentation says '!' is LEX_IS_COMMENT_START, but
     {
       lex['\''] = LEX_IS_STRINGQUOTE;
       lex[';'] = LEX_IS_COMMENT_START;
       lex['*'] = LEX_IS_LINE_COMMENT_START;
       /* The MRI documentation says '!' is LEX_IS_COMMENT_START, but
-         then it can't be used in an expression.  */
+        then it can't be used in an expression.  */
       lex['!'] = LEX_IS_LINE_COMMENT_START;
     }
       lex['!'] = LEX_IS_LINE_COMMENT_START;
     }
-}                              /* do_scrub_begin() */
+#endif
+
+#ifdef TC_V850
+  lex['-'] = LEX_IS_DOUBLEDASH_1ST;
+#endif
+#ifdef DOUBLEBAR_PARALLEL
+  lex['|'] = LEX_IS_DOUBLEBAR_1ST;
+#endif
+#ifdef TC_D30V
+  /* Must do this is we want VLIW instruction with "->" or "<-".  */
+  lex['-'] = LEX_IS_SYMBOL_COMPONENT;
+#endif
+}
 
 
-/* Saved state of the scrubber */
+/* Saved state of the scrubber.  */
 static int state;
 static int old_state;
 static char *out_string;
 static int state;
 static int old_state;
 static char *out_string;
@@ -141,6 +201,9 @@ static char out_buf[20];
 static int add_newlines;
 static char *saved_input;
 static int saved_input_len;
 static int add_newlines;
 static char *saved_input;
 static int saved_input_len;
+static char input_buffer[32 * 1024];
+static const char *mri_state;
+static char mri_last_ch;
 
 /* Data structure for saving the state of app across #include's.  Note that
    app is called asynchronously to the parsing of the .include's, so our
 
 /* Data structure for saving the state of app across #include's.  Note that
    app is called asynchronously to the parsing of the .include's, so our
@@ -148,18 +211,26 @@ static int saved_input_len;
    That's why we have to save it all.  */
 
 struct app_save
    That's why we have to save it all.  */
 
 struct app_save
-  {
-    int state;
-    int old_state;
-    char *out_string;
-    char out_buf[sizeof (out_buf)];
-    int add_newlines;
-    char *saved_input;
-    int saved_input_len;
-  };
+{
+  int          state;
+  int          old_state;
+  char *       out_string;
+  char         out_buf[sizeof (out_buf)];
+  int          add_newlines;
+  char *       saved_input;
+  int          saved_input_len;
+#ifdef TC_M68K
+  int          scrub_m68k_mri;
+#endif
+  const char * mri_state;
+  char         mri_last_ch;
+#if defined TC_ARM && defined OBJ_ELF
+  const char * symver_state;
+#endif
+};
 
 char *
 
 char *
-app_push ()
+app_push (void)
 {
   register struct app_save *saved;
 
 {
   register struct app_save *saved;
 
@@ -169,10 +240,24 @@ app_push ()
   saved->out_string = out_string;
   memcpy (saved->out_buf, out_buf, sizeof (out_buf));
   saved->add_newlines = add_newlines;
   saved->out_string = out_string;
   memcpy (saved->out_buf, out_buf, sizeof (out_buf));
   saved->add_newlines = add_newlines;
-  saved->saved_input = saved_input;
-  saved->saved_input_len = saved_input_len;
+  if (saved_input == NULL)
+    saved->saved_input = NULL;
+  else
+    {
+      saved->saved_input = xmalloc (saved_input_len);
+      memcpy (saved->saved_input, saved_input, saved_input_len);
+      saved->saved_input_len = saved_input_len;
+    }
+#ifdef TC_M68K
+  saved->scrub_m68k_mri = scrub_m68k_mri;
+#endif
+  saved->mri_state = mri_state;
+  saved->mri_last_ch = mri_last_ch;
+#if defined TC_ARM && defined OBJ_ELF
+  saved->symver_state = symver_state;
+#endif
 
 
-  /* do_scrub_begin() is not useful, just wastes time. */
+  /* do_scrub_begin() is not useful, just wastes time.  */
 
   state = 0;
   saved_input = NULL;
 
   state = 0;
   saved_input = NULL;
@@ -180,29 +265,44 @@ app_push ()
   return (char *) saved;
 }
 
   return (char *) saved;
 }
 
-void 
-app_pop (arg)
-     char *arg;
+void
+app_pop (char *arg)
 {
   register struct app_save *saved = (struct app_save *) arg;
 
 {
   register struct app_save *saved = (struct app_save *) arg;
 
-  /* There is no do_scrub_end (). */
+  /* There is no do_scrub_end ().  */
   state = saved->state;
   old_state = saved->old_state;
   out_string = saved->out_string;
   memcpy (out_buf, saved->out_buf, sizeof (out_buf));
   add_newlines = saved->add_newlines;
   state = saved->state;
   old_state = saved->old_state;
   out_string = saved->out_string;
   memcpy (out_buf, saved->out_buf, sizeof (out_buf));
   add_newlines = saved->add_newlines;
-  saved_input = saved->saved_input;
-  saved_input_len = saved->saved_input_len;
+  if (saved->saved_input == NULL)
+    saved_input = NULL;
+  else
+    {
+      assert (saved->saved_input_len <= (int) (sizeof input_buffer));
+      memcpy (input_buffer, saved->saved_input, saved->saved_input_len);
+      saved_input = input_buffer;
+      saved_input_len = saved->saved_input_len;
+      free (saved->saved_input);
+    }
+#ifdef TC_M68K
+  scrub_m68k_mri = saved->scrub_m68k_mri;
+#endif
+  mri_state = saved->mri_state;
+  mri_last_ch = saved->mri_last_ch;
+#if defined TC_ARM && defined OBJ_ELF
+  symver_state = saved->symver_state;
+#endif
 
   free (arg);
 
   free (arg);
-}                              /* app_pop() */
+}
 
 /* @@ This assumes that \n &c are the same on host and target.  This is not
    necessarily true.  */
 
 /* @@ This assumes that \n &c are the same on host and target.  This is not
    necessarily true.  */
-static int 
-process_escape (ch)
-     int ch;
+
+static int
+process_escape (int ch)
 {
   switch (ch)
     {
 {
   switch (ch)
     {
@@ -237,10 +337,7 @@ process_escape (ch)
    This is the way the old code used to work.  */
 
 int
    This is the way the old code used to work.  */
 
 int
-do_scrub_chars (get, tostart, tolen)
-     int (*get) PARAMS ((char **));
-     char *tostart;
-     int tolen;
+do_scrub_chars (int (*get) (char *, int), char *tostart, int tolen)
 {
   char *to = tostart;
   char *toend = tostart + tolen;
 {
   char *to = tostart;
   char *toend = tostart + tolen;
@@ -248,7 +345,6 @@ do_scrub_chars (get, tostart, tolen)
   char *fromend;
   int fromlen;
   register int ch, ch2 = 0;
   char *fromend;
   int fromlen;
   register int ch, ch2 = 0;
-  int not_cpp_line = 0;
 
   /*State 0: beginning of normal line
          1: After first whitespace on line (flush more white)
 
   /*State 0: beginning of normal line
          1: After first whitespace on line (flush more white)
@@ -264,33 +360,48 @@ do_scrub_chars (get, tostart, tolen)
         11: After seeing a symbol character in state 0 (eg a label definition)
         -1: output string in out_string and go to the state in old_state
         -2: flush text until a '*' '/' is seen, then go to state old_state
         11: After seeing a symbol character in state 0 (eg a label definition)
         -1: output string in out_string and go to the state in old_state
         -2: flush text until a '*' '/' is seen, then go to state old_state
+#ifdef TC_V850
+        12: After seeing a dash, looking for a second dash as a start
+            of comment.
+#endif
+#ifdef DOUBLEBAR_PARALLEL
+        13: After seeing a vertical bar, looking for a second
+            vertical bar as a parallel expression separator.
+#endif
+#ifdef TC_IA64
+        14: After seeing a `(' at state 0, looking for a `)' as
+            predicate.
+        15: After seeing a `(' at state 1, looking for a `)' as
+            predicate.
+#endif
          */
 
   /* I added states 9 and 10 because the MIPS ECOFF assembler uses
      constructs like ``.loc 1 20''.  This was turning into ``.loc
      120''.  States 9 and 10 ensure that a space is never dropped in
          */
 
   /* I added states 9 and 10 because the MIPS ECOFF assembler uses
      constructs like ``.loc 1 20''.  This was turning into ``.loc
      120''.  States 9 and 10 ensure that a space is never dropped in
-     between characters which could appear in a identifier.  Ian
+     between characters which could appear in an identifier.  Ian
      Taylor, ian@cygnus.com.
 
      I added state 11 so that something like "Lfoo add %r25,%r26,%r27" works
      correctly on the PA (and any other target where colons are optional).
      Taylor, ian@cygnus.com.
 
      I added state 11 so that something like "Lfoo add %r25,%r26,%r27" works
      correctly on the PA (and any other target where colons are optional).
-     Jeff Law, law@cs.utah.edu.  */
+     Jeff Law, law@cs.utah.edu.
+
+     I added state 13 so that something like "cmp r1, r2 || trap #1" does not
+     get squashed into "cmp r1,r2||trap#1", with the all important space
+     between the 'trap' and the '#1' being eliminated.  nickc@cygnus.com  */
 
   /* This macro gets the next input character.  */
 
 
   /* This macro gets the next input character.  */
 
-#define GET()                          \
-  (from < fromend                      \
-   ? *from++                           \
-   : ((saved_input != NULL             \
-       ? (free (saved_input),          \
-         saved_input = NULL,           \
-         0)                            \
-       : 0),                           \
-      fromlen = (*get) (&from),                \
-      fromend = from + fromlen,                \
-      (fromlen == 0                    \
-       ? EOF                           \
-       : *from++)))
+#define GET()                                                  \
+  (from < fromend                                              \
+   ? * (unsigned char *) (from++)                              \
+   : (saved_input = NULL,                                      \
+      fromlen = (*get) (input_buffer, sizeof input_buffer),    \
+      from = input_buffer,                                     \
+      fromend = from + fromlen,                                        \
+      (fromlen == 0                                            \
+       ? EOF                                                   \
+       : * (unsigned char *) (from++))))
 
   /* This macro pushes a character back on the input stream.  */
 
 
   /* This macro pushes a character back on the input stream.  */
 
@@ -305,13 +416,13 @@ do_scrub_chars (get, tostart, tolen)
      I don't want to make such a significant change to the assembler's
      memory usage.  */
 
      I don't want to make such a significant change to the assembler's
      memory usage.  */
 
-#define PUT(pch)                       \
-  do                                   \
-    {                                  \
-      *to++ = (pch);                   \
-      if (to >= toend)                 \
-        goto tofull;                   \
-    }                                  \
+#define PUT(pch)                               \
+  do                                           \
+    {                                          \
+      *to++ = (pch);                           \
+      if (to >= toend)                         \
+       goto tofull;                            \
+    }                                          \
   while (0)
 
   if (saved_input != NULL)
   while (0)
 
   if (saved_input != NULL)
@@ -321,17 +432,18 @@ do_scrub_chars (get, tostart, tolen)
     }
   else
     {
     }
   else
     {
-      fromlen = (*get) (&from);
+      fromlen = (*get) (input_buffer, sizeof input_buffer);
       if (fromlen == 0)
        return 0;
       if (fromlen == 0)
        return 0;
+      from = input_buffer;
       fromend = from + fromlen;
     }
 
   while (1)
     {
       /* The cases in this switch end with continue, in order to
       fromend = from + fromlen;
     }
 
   while (1)
     {
       /* The cases in this switch end with continue, in order to
-         branch back to the top of this while loop and generate the
-         next output character in the appropriate state.  */
+        branch back to the top of this while loop and generate the
+        next output character in the appropriate state.  */
       switch (state)
        {
        case -1:
       switch (state)
        {
        case -1:
@@ -353,7 +465,7 @@ do_scrub_chars (get, tostart, tolen)
 
                  if (ch == EOF)
                    {
 
                  if (ch == EOF)
                    {
-                     as_warn ("end of file in comment");
+                     as_warn (_("end of file in comment"));
                      goto fromeof;
                    }
 
                      goto fromeof;
                    }
 
@@ -367,7 +479,7 @@ do_scrub_chars (get, tostart, tolen)
 
              if (ch == EOF)
                {
 
              if (ch == EOF)
                {
-                 as_warn ("end of file in comment");
+                 as_warn (_("end of file in comment"));
                  goto fromeof;
                }
 
                  goto fromeof;
                }
 
@@ -378,7 +490,7 @@ do_scrub_chars (get, tostart, tolen)
            }
 
          state = old_state;
            }
 
          state = old_state;
-         PUT (' ');
+         UNGET (' ');
          continue;
 
        case 4:
          continue;
 
        case 4:
@@ -394,7 +506,7 @@ do_scrub_chars (get, tostart, tolen)
              if (ch == '"')
                {
                  UNGET (ch);
              if (ch == '"')
                {
                  UNGET (ch);
-                 if (flag_m68k_mri)
+                 if (scrub_m68k_mri)
                    out_string = "\n\tappfile ";
                  else
                    out_string = "\n\t.appfile ";
                    out_string = "\n\tappfile ";
                  else
                    out_string = "\n\t.appfile ";
@@ -414,9 +526,9 @@ do_scrub_chars (get, tostart, tolen)
 
        case 5:
          /* We are going to copy everything up to a quote character,
 
        case 5:
          /* We are going to copy everything up to a quote character,
-             with special handling for a backslash.  We try to
-             optimize the copying in the simple case without using the
-             GET and PUT macros.  */
+            with special handling for a backslash.  We try to
+            optimize the copying in the simple case without using the
+            GET and PUT macros.  */
          {
            char *s;
            int len;
          {
            char *s;
            int len;
@@ -425,7 +537,7 @@ do_scrub_chars (get, tostart, tolen)
              {
                ch = *s;
                /* This condition must be changed if the type of any
              {
                ch = *s;
                /* This condition must be changed if the type of any
-                   other character can be LEX_IS_STRINGQUOTE.  */
+                  other character can be LEX_IS_STRINGQUOTE.  */
                if (ch == '\\'
                    || ch == '"'
                    || ch == '\''
                if (ch == '\\'
                    || ch == '"'
                    || ch == '\''
@@ -446,7 +558,7 @@ do_scrub_chars (get, tostart, tolen)
          ch = GET ();
          if (ch == EOF)
            {
          ch = GET ();
          if (ch == EOF)
            {
-             as_warn ("end of file in string: inserted '\"'");
+             as_warn (_("end of file in string; inserted '\"'"));
              state = old_state;
              UNGET ('\n');
              PUT ('"');
              state = old_state;
              UNGET ('\n');
              PUT ('"');
@@ -463,11 +575,10 @@ do_scrub_chars (get, tostart, tolen)
              PUT (ch);
            }
 #endif
              PUT (ch);
            }
 #endif
-         else if (flag_m68k_mri && ch == '\n')
+         else if (scrub_m68k_mri && ch == '\n')
            {
              /* Just quietly terminate the string.  This permits lines like
            {
              /* Just quietly terminate the string.  This permits lines like
-                  bne  label   loop if we haven't reach end yet
-                */
+                  bne  label   loop if we haven't reach end yet.  */
              state = old_state;
              UNGET (ch);
              PUT ('\'');
              state = old_state;
              UNGET (ch);
              PUT ('\'');
@@ -491,6 +602,11 @@ do_scrub_chars (get, tostart, tolen)
              PUT ('\\');
              continue;
 
              PUT ('\\');
              continue;
 
+           case EOF:
+             as_warn (_("end of file in string; '\"' inserted"));
+             PUT ('"');
+             continue;
+
            case '"':
            case '\\':
            case 'b':
            case '"':
            case '\\':
            case 'b':
@@ -510,20 +626,12 @@ do_scrub_chars (get, tostart, tolen)
            case '6':
            case '7':
              break;
            case '6':
            case '7':
              break;
-#if defined(IGNORE_NONSTANDARD_ESCAPES) | defined(ONLY_STANDARD_ESCAPES)
-           default:
-             as_warn ("Unknown escape '\\%c' in string: Ignored", ch);
-             break;
-#else  /* ONLY_STANDARD_ESCAPES */
+
            default:
            default:
-             /* Accept \x as x for any x */
+#ifdef ONLY_STANDARD_ESCAPES
+             as_warn (_("unknown escape '\\%c' in string; ignored"), ch);
+#endif
              break;
              break;
-#endif /* ONLY_STANDARD_ESCAPES */
-
-           case EOF:
-             as_warn ("End of file in string: '\"' inserted");
-             PUT ('"');
-             continue;
            }
          PUT (ch);
          continue;
            }
          PUT (ch);
          continue;
@@ -546,18 +654,138 @@ do_scrub_chars (get, tostart, tolen)
          state = 0;
          PUT (ch);
          continue;
          state = 0;
          PUT (ch);
          continue;
+
+#ifdef DOUBLEBAR_PARALLEL
+       case 13:
+         ch = GET ();
+         if (ch != '|')
+           abort ();
+
+         /* Reset back to state 1 and pretend that we are parsing a
+            line from just after the first white space.  */
+         state = 1;
+         PUT ('|');
+         continue;
+#endif
        }
 
        }
 
-      /* OK, we are somewhere in states 0 through 4 or 9 through 11 */
+      /* OK, we are somewhere in states 0 through 4 or 9 through 11.  */
 
       /* flushchar: */
       ch = GET ();
 
       /* flushchar: */
       ch = GET ();
+
+#ifdef TC_IA64
+      if (ch == '(' && (state == 0 || state == 1))
+       {
+         state += 14;
+         PUT (ch);
+         continue;
+       }
+      else if (state == 14 || state == 15)
+       {
+         if (ch == ')')
+           {
+             state -= 14;
+             PUT (ch);
+             ch = GET ();
+           }
+         else
+           {
+             PUT (ch);
+             continue;
+           }
+       }
+#endif
+
     recycle:
     recycle:
+
+#if defined TC_ARM && defined OBJ_ELF
+      /* We need to watch out for .symver directives.  See the comment later
+        in this function.  */
+      if (symver_state == NULL)
+       {
+         if ((state == 0 || state == 1) && ch == symver_pseudo[0])
+           symver_state = symver_pseudo + 1;
+       }
+      else
+       {
+         /* We advance to the next state if we find the right
+            character.  */
+         if (ch != '\0' && (*symver_state == ch))
+           ++symver_state;
+         else if (*symver_state != '\0')
+           /* We did not get the expected character, or we didn't
+              get a valid terminating character after seeing the
+              entire pseudo-op, so we must go back to the beginning.  */
+           symver_state = NULL;
+         else
+           {
+             /* We've read the entire pseudo-op.  If this is the end
+                of the line, go back to the beginning.  */
+             if (IS_NEWLINE (ch))
+               symver_state = NULL;
+           }
+       }
+#endif /* TC_ARM && OBJ_ELF */
+
+#ifdef TC_M68K
+      /* We want to have pseudo-ops which control whether we are in
+        MRI mode or not.  Unfortunately, since m68k MRI mode affects
+        the scrubber, that means that we need a special purpose
+        recognizer here.  */
+      if (mri_state == NULL)
+       {
+         if ((state == 0 || state == 1)
+             && ch == mri_pseudo[0])
+           mri_state = mri_pseudo + 1;
+       }
+      else
+       {
+         /* We advance to the next state if we find the right
+            character, or if we need a space character and we get any
+            whitespace character, or if we need a '0' and we get a
+            '1' (this is so that we only need one state to handle
+            ``.mri 0'' and ``.mri 1'').  */
+         if (ch != '\0'
+             && (*mri_state == ch
+                 || (*mri_state == ' '
+                     && lex[ch] == LEX_IS_WHITESPACE)
+                 || (*mri_state == '0'
+                     && ch == '1')))
+           {
+             mri_last_ch = ch;
+             ++mri_state;
+           }
+         else if (*mri_state != '\0'
+                  || (lex[ch] != LEX_IS_WHITESPACE
+                      && lex[ch] != LEX_IS_NEWLINE))
+           {
+             /* We did not get the expected character, or we didn't
+                get a valid terminating character after seeing the
+                entire pseudo-op, so we must go back to the
+                beginning.  */
+             mri_state = NULL;
+           }
+         else
+           {
+             /* We've read the entire pseudo-op.  mips_last_ch is
+                either '0' or '1' indicating whether to enter or
+                leave MRI mode.  */
+             do_scrub_begin (mri_last_ch == '1');
+             mri_state = NULL;
+
+             /* We continue handling the character as usual.  The
+                main gas reader must also handle the .mri pseudo-op
+                to control expression parsing and the like.  */
+           }
+       }
+#endif
+
       if (ch == EOF)
        {
          if (state != 0)
            {
       if (ch == EOF)
        {
          if (state != 0)
            {
-             as_warn ("end of file not at end of a line; newline inserted");
+             as_warn (_("end of file not at end of a line; newline inserted"));
              state = 0;
              PUT ('\n');
            }
              state = 0;
              PUT ('\n');
            }
@@ -585,14 +813,28 @@ do_scrub_chars (get, tostart, tolen)
              break;
            }
 
              break;
            }
 
+#ifdef KEEP_WHITE_AROUND_COLON
+         if (lex[ch] == LEX_IS_COLON)
+           {
+             /* Only keep this white if there's no white *after* the
+                colon.  */
+             ch2 = GET ();
+             UNGET (ch2);
+             if (!IS_WHITESPACE (ch2))
+               {
+                 state = 9;
+                 UNGET (ch);
+                 PUT (' ');
+                 break;
+               }
+           }
+#endif
          if (IS_COMMENT (ch)
              || ch == '/'
          if (IS_COMMENT (ch)
              || ch == '/'
-             || IS_LINE_SEPARATOR (ch))
+             || IS_LINE_SEPARATOR (ch)
+             || IS_PARALLEL_SEPARATOR (ch))
            {
            {
-             /* cpp never outputs a leading space before the #, so
-                try to avoid being confused.  */
-             not_cpp_line = 1;
-             if (flag_m68k_mri)
+             if (scrub_m68k_mri)
                {
                  /* In MRI mode, we keep these spaces.  */
                  UNGET (ch);
                {
                  /* In MRI mode, we keep these spaces.  */
                  UNGET (ch);
@@ -609,7 +851,7 @@ do_scrub_chars (get, tostart, tolen)
             not permitted between the label and the colon.  */
          if ((state == 2 || state == 11)
              && lex[ch] == LEX_IS_COLON
             not permitted between the label and the colon.  */
          if ((state == 2 || state == 11)
              && lex[ch] == LEX_IS_COLON
-             && ! flag_m68k_mri)
+             && ! scrub_m68k_mri)
            {
              state = 1;
              PUT (ch);
            {
              state = 1;
              PUT (ch);
@@ -637,7 +879,7 @@ do_scrub_chars (get, tostart, tolen)
              PUT (' ');
              break;
            case 3:
              PUT (' ');
              break;
            case 3:
-             if (flag_m68k_mri)
+             if (scrub_m68k_mri)
                {
                  /* In MRI mode, we keep these spaces.  */
                  UNGET (ch);
                {
                  /* In MRI mode, we keep these spaces.  */
                  UNGET (ch);
@@ -647,7 +889,7 @@ do_scrub_chars (get, tostart, tolen)
              goto recycle;     /* Sp in operands */
            case 9:
            case 10:
              goto recycle;     /* Sp in operands */
            case 9:
            case 10:
-             if (flag_m68k_mri)
+             if (scrub_m68k_mri)
                {
                  /* In MRI mode, we keep these spaces.  */
                  state = 3;
                {
                  /* In MRI mode, we keep these spaces.  */
                  state = 3;
@@ -658,7 +900,16 @@ do_scrub_chars (get, tostart, tolen)
              state = 10;       /* Sp after symbol char */
              goto recycle;
            case 11:
              state = 10;       /* Sp after symbol char */
              goto recycle;
            case 11:
-             state = 1;
+             if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
+               state = 1;
+             else
+               {
+                 /* We know that ch is not ':', since we tested that
+                    case above.  Therefore this is not a label, so it
+                    must be the opcode, and we've just seen the
+                    whitespace after it.  */
+                 state = 3;
+               }
              UNGET (ch);
              PUT (' ');        /* Sp after label definition.  */
              break;
              UNGET (ch);
              PUT (' ');        /* Sp after label definition.  */
              break;
@@ -669,7 +920,7 @@ do_scrub_chars (get, tostart, tolen)
 
        case LEX_IS_TWOCHAR_COMMENT_1ST:
          ch2 = GET ();
 
        case LEX_IS_TWOCHAR_COMMENT_1ST:
          ch2 = GET ();
-         if (ch2 != EOF && lex[ch2] == LEX_IS_TWOCHAR_COMMENT_2ND)
+         if (ch2 == '*')
            {
              for (;;)
                {
            {
              for (;;)
                {
@@ -679,26 +930,40 @@ do_scrub_chars (get, tostart, tolen)
                      if (ch2 != EOF && IS_NEWLINE (ch2))
                        add_newlines++;
                    }
                      if (ch2 != EOF && IS_NEWLINE (ch2))
                        add_newlines++;
                    }
-                 while (ch2 != EOF &&
-                        (lex[ch2] != LEX_IS_TWOCHAR_COMMENT_2ND));
+                 while (ch2 != EOF && ch2 != '*');
 
 
-                 while (ch2 != EOF &&
-                        (lex[ch2] == LEX_IS_TWOCHAR_COMMENT_2ND))
-                   {
-                     ch2 = GET ();
-                   }
+                 while (ch2 == '*')
+                   ch2 = GET ();
 
 
-                 if (ch2 == EOF
-                     || lex[ch2] == LEX_IS_TWOCHAR_COMMENT_1ST)
+                 if (ch2 == EOF || ch2 == '/')
                    break;
                    break;
-                 UNGET (ch);
+
+                 /* This UNGET will ensure that we count newlines
+                    correctly.  */
+                 UNGET (ch2);
                }
                }
+
              if (ch2 == EOF)
              if (ch2 == EOF)
-               as_warn ("end of file in multiline comment");
+               as_warn (_("end of file in multiline comment"));
 
              ch = ' ';
              goto recycle;
            }
 
              ch = ' ';
              goto recycle;
            }
+#ifdef DOUBLESLASH_LINE_COMMENTS
+         else if (ch2 == '/')
+           {
+             do
+               {
+                 ch = GET ();
+               }
+             while (ch != EOF && !IS_NEWLINE (ch));
+             if (ch == EOF)
+               as_warn ("end of file in comment; newline inserted");
+             state = 0;
+             PUT ('\n');
+             break;
+           }
+#endif
          else
            {
              if (ch2 != EOF)
          else
            {
              if (ch2 != EOF)
@@ -712,13 +977,13 @@ do_scrub_chars (get, tostart, tolen)
        case LEX_IS_STRINGQUOTE:
          if (state == 10)
            {
        case LEX_IS_STRINGQUOTE:
          if (state == 10)
            {
-             /* Preserve the whitespace in foo "bar" */
+             /* Preserve the whitespace in foo "bar".  */
              UNGET (ch);
              state = 3;
              PUT (' ');
 
              /* PUT didn't jump out.  We could just break, but we
              UNGET (ch);
              state = 3;
              PUT (' ');
 
              /* PUT didn't jump out.  We could just break, but we
-                 know what will happen, so optimize a bit.  */
+                know what will happen, so optimize a bit.  */
              ch = GET ();
              old_state = 3;
            }
              ch = GET ();
              old_state = 3;
            }
@@ -734,7 +999,7 @@ do_scrub_chars (get, tostart, tolen)
        case LEX_IS_ONECHAR_QUOTE:
          if (state == 10)
            {
        case LEX_IS_ONECHAR_QUOTE:
          if (state == 10)
            {
-             /* Preserve the whitespace in foo 'b' */
+             /* Preserve the whitespace in foo 'b'.  */
              UNGET (ch);
              state = 3;
              PUT (' ');
              UNGET (ch);
              state = 3;
              PUT (' ');
@@ -743,7 +1008,7 @@ do_scrub_chars (get, tostart, tolen)
          ch = GET ();
          if (ch == EOF)
            {
          ch = GET ();
          if (ch == EOF)
            {
-             as_warn ("end of file after a one-character quote; \\0 inserted");
+             as_warn (_("end of file after a one-character quote; \\0 inserted"));
              ch = 0;
            }
          if (ch == '\\')
              ch = 0;
            }
          if (ch == '\\')
@@ -751,7 +1016,7 @@ do_scrub_chars (get, tostart, tolen)
              ch = GET ();
              if (ch == EOF)
                {
              ch = GET ();
              if (ch == EOF)
                {
-                 as_warn ("end of file in escape character");
+                 as_warn (_("end of file in escape character"));
                  ch = '\\';
                }
              else
                  ch = '\\';
                }
              else
@@ -763,7 +1028,7 @@ do_scrub_chars (get, tostart, tolen)
          if ((ch = GET ()) != '\'')
            {
 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
          if ((ch = GET ()) != '\'')
            {
 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
-             as_warn ("Missing close quote: (assumed)");
+             as_warn (_("missing close quote; (assumed)"));
 #else
              if (ch != EOF)
                UNGET (ch);
 #else
              if (ch != EOF)
                UNGET (ch);
@@ -785,10 +1050,14 @@ do_scrub_chars (get, tostart, tolen)
 #endif
 
        case LEX_IS_COLON:
 #endif
 
        case LEX_IS_COLON:
+#ifdef KEEP_WHITE_AROUND_COLON
+         state = 9;
+#else
          if (state == 9 || state == 10)
            state = 3;
          else if (state != 3)
            state = 1;
          if (state == 9 || state == 10)
            state = 3;
          else if (state != 3)
            state = 1;
+#endif
          PUT (ch);
          break;
 
          PUT (ch);
          break;
 
@@ -799,65 +1068,109 @@ do_scrub_chars (get, tostart, tolen)
              --add_newlines;
              UNGET (ch);
            }
              --add_newlines;
              UNGET (ch);
            }
-         /* fall thru into... */
+         /* Fall through.  */
 
        case LEX_IS_LINE_SEPARATOR:
          state = 0;
          PUT (ch);
          break;
 
 
        case LEX_IS_LINE_SEPARATOR:
          state = 0;
          PUT (ch);
          break;
 
+       case LEX_IS_PARALLEL_SEPARATOR:
+         state = 1;
+         PUT (ch);
+         break;
+
+#ifdef TC_V850
+       case LEX_IS_DOUBLEDASH_1ST:
+         ch2 = GET ();
+         if (ch2 != '-')
+           {
+             UNGET (ch2);
+             goto de_fault;
+           }
+         /* Read and skip to end of line.  */
+         do
+           {
+             ch = GET ();
+           }
+         while (ch != EOF && ch != '\n');
+
+         if (ch == EOF)
+           as_warn (_("end of file in comment; newline inserted"));
+
+         state = 0;
+         PUT ('\n');
+         break;
+#endif
+#ifdef DOUBLEBAR_PARALLEL
+       case LEX_IS_DOUBLEBAR_1ST:
+         ch2 = GET ();
+         UNGET (ch2);
+         if (ch2 != '|')
+           goto de_fault;
+
+         /* Handle '||' in two states as invoking PUT twice might
+            result in the first one jumping out of this loop.  We'd
+            then lose track of the state and one '|' char.  */
+         state = 13;
+         PUT ('|');
+         break;
+#endif
        case LEX_IS_LINE_COMMENT_START:
        case LEX_IS_LINE_COMMENT_START:
-         if (state == 0)       /* Only comment at start of line.  */
+         /* FIXME-someday: The two character comment stuff was badly
+            thought out.  On i386, we want '/' as line comment start
+            AND we want C style comments.  hence this hack.  The
+            whole lexical process should be reworked.  xoxorich.  */
+         if (ch == '/')
            {
            {
-             /* FIXME-someday: The two character comment stuff was
-                badly thought out.  On i386, we want '/' as line
-                comment start AND we want C style comments.  hence
-                this hack.  The whole lexical process should be
-                reworked.  xoxorich.  */
-             if (ch == '/')
+             ch2 = GET ();
+             if (ch2 == '*')
                {
                {
-                 ch2 = GET ();
-                 if (ch2 == '*')
-                   {
-                     state = -2;
-                     break;
-                   }
-                 else
-                   {
-                     UNGET (ch2);
-                   }
-               } /* bad hack */
+                 old_state = 3;
+                 state = -2;
+                 break;
+               }
+             else
+               {
+                 UNGET (ch2);
+               }
+           }
 
 
-             if (ch != '#')
-               not_cpp_line = 1;
+         if (state == 0 || state == 1) /* Only comment at start of line.  */
+           {
+             int startch;
+
+             startch = ch;
 
              do
                {
                  ch = GET ();
                }
              while (ch != EOF && IS_WHITESPACE (ch));
 
              do
                {
                  ch = GET ();
                }
              while (ch != EOF && IS_WHITESPACE (ch));
+
              if (ch == EOF)
                {
              if (ch == EOF)
                {
-                 as_warn ("end of file in comment; newline inserted");
+                 as_warn (_("end of file in comment; newline inserted"));
                  PUT ('\n');
                  break;
                }
                  PUT ('\n');
                  break;
                }
-             if (ch < '0' || ch > '9' || not_cpp_line)
+
+             if (ch < '0' || ch > '9' || state != 0 || startch != '#')
                {
                {
-                 /* Non-numerics:  Eat whole comment line */
+                 /* Not a cpp line.  */
                  while (ch != EOF && !IS_NEWLINE (ch))
                    ch = GET ();
                  if (ch == EOF)
                  while (ch != EOF && !IS_NEWLINE (ch))
                    ch = GET ();
                  if (ch == EOF)
-                   as_warn ("EOF in Comment: Newline inserted");
+                   as_warn (_("end of file in comment; newline inserted"));
                  state = 0;
                  PUT ('\n');
                  break;
                }
                  state = 0;
                  PUT ('\n');
                  break;
                }
-             /* Numerics begin comment.  Perhaps CPP `# 123 "filename"' */
+             /* Looks like `# 123 "filename"' from cpp.  */
              UNGET (ch);
              old_state = 4;
              state = -1;
              UNGET (ch);
              old_state = 4;
              state = -1;
-             if (flag_m68k_mri)
+             if (scrub_m68k_mri)
                out_string = "\tappline ";
              else
                out_string = "\t.appline ";
                out_string = "\tappline ";
              else
                out_string = "\t.appline ";
@@ -865,28 +1178,55 @@ do_scrub_chars (get, tostart, tolen)
              break;
            }
 
              break;
            }
 
+#ifdef TC_D10V
+         /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true.
+            Trap is the only short insn that has a first operand that is
+            neither register nor label.
+            We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 .
+            We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is
+            already LEX_IS_LINE_COMMENT_START.  However, it is the
+            only character in line_comment_chars for d10v, hence we
+            can recognize it as such.  */
+         /* An alternative approach would be to reset the state to 1 when
+            we see '||', '<'- or '->', but that seems to be overkill.  */
+         if (state == 10)
+           PUT (' ');
+#endif
          /* We have a line comment character which is not at the
             start of a line.  If this is also a normal comment
             character, fall through.  Otherwise treat it as a default
             character.  */
          /* We have a line comment character which is not at the
             start of a line.  If this is also a normal comment
             character, fall through.  Otherwise treat it as a default
             character.  */
-         if (strchr (comment_chars, ch) == NULL
-             && (! flag_m68k_mri
+         if (strchr (tc_comment_chars, ch) == NULL
+             && (! scrub_m68k_mri
                  || (ch != '!' && ch != '*')))
            goto de_fault;
                  || (ch != '!' && ch != '*')))
            goto de_fault;
-         if (flag_m68k_mri
+         if (scrub_m68k_mri
              && (ch == '!' || ch == '*' || ch == '#')
              && state != 1
              && state != 10)
            goto de_fault;
          /* Fall through.  */
        case LEX_IS_COMMENT_START:
              && (ch == '!' || ch == '*' || ch == '#')
              && state != 1
              && state != 10)
            goto de_fault;
          /* Fall through.  */
        case LEX_IS_COMMENT_START:
+#if defined TC_ARM && defined OBJ_ELF
+         /* On the ARM, `@' is the comment character.
+            Unfortunately this is also a special character in ELF .symver
+            directives (and .type, though we deal with those another way).
+            So we check if this line is such a directive, and treat
+            the character as default if so.  This is a hack.  */
+         if ((symver_state != NULL) && (*symver_state == 0))
+           goto de_fault;
+#endif
+#ifdef WARN_COMMENTS
+         if (!found_comment)
+           as_where (&found_comment_file, &found_comment);
+#endif
          do
            {
              ch = GET ();
            }
          while (ch != EOF && !IS_NEWLINE (ch));
          if (ch == EOF)
          do
            {
              ch = GET ();
            }
          while (ch != EOF && !IS_NEWLINE (ch));
          if (ch == EOF)
-           as_warn ("end of file in comment; newline inserted");
+           as_warn (_("end of file in comment; newline inserted"));
          state = 0;
          PUT ('\n');
          break;
          state = 0;
          PUT ('\n');
          break;
@@ -907,8 +1247,13 @@ do_scrub_chars (get, tostart, tolen)
            state = 9;
 
          /* This is a common case.  Quickly copy CH and all the
            state = 9;
 
          /* This is a common case.  Quickly copy CH and all the
-             following symbol component or normal characters.  */
-         if (to + 1 < toend)
+            following symbol component or normal characters.  */
+         if (to + 1 < toend
+             && mri_state == NULL
+#if defined TC_ARM && defined OBJ_ELF
+             && symver_state == NULL
+#endif
+             )
            {
              char *s;
              int len;
            {
              char *s;
              int len;
@@ -917,21 +1262,23 @@ do_scrub_chars (get, tostart, tolen)
                {
                  int type;
 
                {
                  int type;
 
-                 ch2 = *s;
+                 ch2 = *(unsigned char *) s;
                  type = lex[ch2];
                  if (type != 0
                      && type != LEX_IS_SYMBOL_COMPONENT)
                    break;
                }
                  type = lex[ch2];
                  if (type != 0
                      && type != LEX_IS_SYMBOL_COMPONENT)
                    break;
                }
+
              if (s > from)
              if (s > from)
-               {
-                 /* Handle the last character normally, for
-                     simplicity.  */
-                 --s;
-               }
+               /* Handle the last character normally, for
+                  simplicity.  */
+               --s;
+
              len = s - from;
              len = s - from;
+
              if (len > (toend - to) - 1)
                len = (toend - to) - 1;
              if (len > (toend - to) - 1)
                len = (toend - to) - 1;
+
              if (len > 0)
                {
                  PUT (ch);
              if (len > 0)
                {
                  PUT (ch);
@@ -954,7 +1301,7 @@ do_scrub_chars (get, tostart, tolen)
                        case 2: *to++ = *from++;
                        case 1: *to++ = *from++;
                        }
                        case 2: *to++ = *from++;
                        case 1: *to++ = *from++;
                        }
-                   } 
+                   }
                  ch = GET ();
                }
            }
                  ch = GET ();
                }
            }
@@ -965,19 +1312,36 @@ do_scrub_chars (get, tostart, tolen)
          /* Some relatively `normal' character.  */
          if (state == 0)
            {
          /* Some relatively `normal' character.  */
          if (state == 0)
            {
-             state = 11;       /* Now seeing label definition */
+             state = 11;       /* Now seeing label definition.  */
            }
          else if (state == 1)
            {
            }
          else if (state == 1)
            {
-             state = 2;        /* Ditto */
+             state = 2;        /* Ditto.  */
            }
          else if (state == 9)
            {
            }
          else if (state == 9)
            {
-             if (lex[ch] != LEX_IS_SYMBOL_COMPONENT)
+             if (!IS_SYMBOL_COMPONENT (ch))
                state = 3;
            }
          else if (state == 10)
            {
                state = 3;
            }
          else if (state == 10)
            {
+             if (ch == '\\')
+               {
+                 /* Special handling for backslash: a backslash may
+                    be the beginning of a formal parameter (of a
+                    macro) following another symbol character, with
+                    whitespace in between.  If that is the case, we
+                    output a space before the parameter.  Strictly
+                    speaking, correct handling depends upon what the
+                    macro parameter expands into; if the parameter
+                    expands into something which does not start with
+                    an operand character, then we don't want to keep
+                    the space.  We don't have enough information to
+                    make the right choice, so here we are making the
+                    choice which is more likely to be correct.  */
+                 PUT (' ');
+               }
+
              state = 3;
            }
          PUT (ch);
              state = 3;
            }
          PUT (ch);
@@ -996,24 +1360,12 @@ do_scrub_chars (get, tostart, tolen)
      processed.  */
   if (fromend > from)
     {
      processed.  */
   if (fromend > from)
     {
-      char *save;
-
-      save = (char *) xmalloc (fromend - from);
-      memcpy (save, from, fromend - from);
-      if (saved_input != NULL)
-       free (saved_input);
-      saved_input = save;
+      saved_input = from;
       saved_input_len = fromend - from;
     }
   else
       saved_input_len = fromend - from;
     }
   else
-    {
-      if (saved_input != NULL)
-       {
-         free (saved_input);
-         saved_input = NULL;
-       }
-    }
+    saved_input = NULL;
+
   return to - tostart;
 }
 
   return to - tostart;
 }
 
-/* end of app.c */
GDB Binutils - Deliverables
This page took 0.038235 seconds and 4 git commands to generate.