* app.c (do_scrub_chars): In MRI mode, silently end quoted strings

	at newline characters.  In MRI mode, always keep spaces in the
	operands field.  In MRI mode, treat a line comment character as a
	regular comment character following a space.
	* cond.c (ignore_input): Use strncasecmp rather than strncmp when
	looking for special pseudo-ops.
	* read.c (cons_worker): In MRI mode, the expressions stop at the
	first unquoted space.
	(equals): Likewise.

4 files changed, 897 insertions, 516 deletions

diff --git a/gas/ChangeLog b/gas/ChangeLog
index ece9f6e..74c1b9a 100644
--- a/gas/ChangeLog
+++ b/gas/ChangeLog
@@ -1,3 +1,28 @@
+Wed Sep  6 21:13:06 1995  Ian Lance Taylor  <ian@cygnus.com>
+
+	* app.c (do_scrub_chars): In MRI mode, silently end quoted strings
+	at newline characters.  In MRI mode, always keep spaces in the
+	operands field.  In MRI mode, treat a line comment character as a
+	regular comment character following a space.
+	* cond.c (ignore_input): Use strncasecmp rather than strncmp when
+	looking for special pseudo-ops.
+	* read.c (cons_worker): In MRI mode, the expressions stop at the
+	first unquoted space.
+	(equals): Likewise.
+
+start-sanitize-sh3e
+Wed Sep  6 15:03:53 1995  Jim Wilson  <wilson@chestnut.cygnus.com>
+
+	* config/tc-sh.c (get_operands): Read third arg if it exists.
+	Otherwise, clear it.
+	(get_specific, case F_FR0): Add.
+
+end-sanitize-sh3e
+Wed Sep  6 15:03:53 1995  Jim Wilson  <wilson@chestnut.cygnus.com>
+
+	* config/tc-sh.c (get_specific): Delete arg_to_test.
+	(md_assemble): Increase operand array from 2 to 3.
+
 Tue Sep  5 16:47:36 1995  Stan Shebs  <shebs@andros.cygnus.com>
 
 	* config/tc-mips.c: Remove CYGNUS LOCAL comments.
diff --git a/gas/app.c b/gas/app.c
index 09492b4..7b7ea15 100644
--- a/gas/app.c
+++ b/gas/app.c
@@ -84,6 +84,9 @@ do_scrub_begin ()
 #endif
     }
 
+  /* Note: if any other character can be LEX_IS_STRINGQUOTE, the loop
+     in state 5 of do_scrub_chars must be changed.  */
+
   /* 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)
@@ -129,43 +132,14 @@ do_scrub_begin ()
     }
 }				/* do_scrub_begin() */
 
-FILE *scrub_file;
-
-int 
-scrub_from_file ()
-{
-  return getc (scrub_file);
-}
-
-void 
-scrub_to_file (ch)
-     int ch;
-{
-  ungetc (ch, scrub_file);
-}				/* scrub_to_file() */
-
-char *scrub_string;
-char *scrub_last_string;
-
-int 
-scrub_from_string ()
-{
-  return scrub_string == scrub_last_string ? EOF : *scrub_string++;
-}				/* scrub_from_string() */
-
-void 
-scrub_to_string (ch)
-     int ch;
-{
-  *--scrub_string = ch;
-}				/* scrub_to_string() */
-
 /* Saved state of the scrubber */
 static int state;
 static int old_state;
 static char *out_string;
 static char out_buf[20];
-static int add_newlines = 0;
+static int add_newlines;
+static char *saved_input;
+static int saved_input_len;
 
 /* 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
@@ -179,9 +153,8 @@ struct app_save
     char *out_string;
     char out_buf[sizeof (out_buf)];
     int add_newlines;
-    char *scrub_string;
-    char *scrub_last_string;
-    FILE *scrub_file;
+    char *saved_input;
+    int saved_input_len;
   };
 
 char *
@@ -195,11 +168,14 @@ app_push ()
   saved->out_string = out_string;
   memcpy (saved->out_buf, out_buf, sizeof (out_buf));
   saved->add_newlines = add_newlines;
-  saved->scrub_string = scrub_string;
-  saved->scrub_last_string = scrub_last_string;
-  saved->scrub_file = scrub_file;
+  saved->saved_input = saved_input;
+  saved->saved_input_len = saved_input_len;
 
   /* do_scrub_begin() is not useful, just wastes time. */
+
+  state = 0;
+  saved_input = NULL;
+
   return (char *) saved;
 }
 
@@ -215,9 +191,8 @@ app_pop (arg)
   out_string = saved->out_string;
   memcpy (out_buf, saved->out_buf, sizeof (out_buf));
   add_newlines = saved->add_newlines;
-  scrub_string = saved->scrub_string;
-  scrub_last_string = saved->scrub_last_string;
-  scrub_file = saved->scrub_file;
+  saved_input = saved->saved_input;
+  saved_input_len = saved->saved_input_len;
 
   free (arg);
 }				/* app_pop() */
@@ -248,11 +223,32 @@ process_escape (ch)
       return ch;
     }
 }
-int 
-do_scrub_next_char (get, unget)
-     int (*get) ();
-     void (*unget) ();
+
+/* This function is called to process input characters.  The GET
+   parameter is used to retrieve more input characters.  GET should
+   set its parameter to point to a buffer, and return the length of
+   the buffer; it should return 0 at end of file.  The scrubbed output
+   characters are put into the buffer starting at TOSTART; the TOSTART
+   buffer is TOLEN bytes in length.  The function returns the number
+   of scrubbed characters put into TOSTART.  This will be TOLEN unless
+   end of file was seen.  This function is arranged as a state
+   machine, and saves its state so that it may return at any point.
+   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;
 {
+  char *to = tostart;
+  char *toend = tostart + tolen;
+  char *from;
+  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)
 	  2: After first non-white (opcode) on line (keep 1white)
@@ -279,502 +275,730 @@ do_scrub_next_char (get, unget)
      correctly on the PA (and any other target where colons are optional).
      Jeff Law, law@cs.utah.edu.  */
 
-  /* This is purely an optimization hack, and relies on gcc's inlining
-     capability.  */
-#if defined (__GNUC__) && defined (__OPTIMIZE__)
-#define GET()	(get == scrub_from_file ? scrub_from_file () : (*get) ())
-#else
-#define GET()	((*get) ())
-#endif
-
-  register int ch, ch2 = 0;
-  int not_cpp_line = 0;
-
-  switch (state)
+  /* 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++)))
+
+  /* This macro pushes a character back on the input stream.  */
+
+#define UNGET(uch) (*--from = (uch))
+
+  /* This macro puts a character into the output buffer.  If this
+     character fills the output buffer, this macro jumps to the label
+     TOFULL.  We use this rather ugly approach because we need to
+     handle two different termination conditions: EOF on the input
+     stream, and a full output buffer.  It would be simpler if we
+     always read in the entire input stream before processing it, but
+     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;			\
+    }					\
+  while (0)
+
+  if (saved_input != NULL)
     {
-    case -1:
-      ch = *out_string++;
-      if (*out_string == 0)
-	{
-	  state = old_state;
-	  old_state = 3;
-	}
-      return ch;
+      from = saved_input;
+      fromend = from + saved_input_len;
+    }
+  else
+    {
+      fromlen = (*get) (&from);
+      if (fromlen == 0)
+	return 0;
+      fromend = from + fromlen;
+    }
 
-    case -2:
-      for (;;)
+  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.  */
+      switch (state)
 	{
-	  do
+	case -1:
+	  ch = *out_string++;
+	  if (*out_string == '\0')
 	    {
-	      ch = GET ();
+	      state = old_state;
+	      old_state = 3;
 	    }
-	  while (ch != EOF && ch != '\n' && ch != '*');
-	  if (ch == '\n' || ch == EOF)
-	    return ch;
+	  PUT (ch);
+	  continue;
 
-	  /* At this point, ch must be a '*' */
-	  while ((ch = GET ()) == '*')
+	case -2:
+	  for (;;)
 	    {
-	      ;
-	    }
-	  if (ch == EOF || ch == '/')
-	    break;
-	  (*unget) (ch);
-	}
-      state = old_state;
-      return ' ';
+	      do
+		{
+		  ch = GET ();
 
-    case 4:
-      ch = GET ();
-      if (ch == EOF || (ch >= '0' && ch <= '9'))
-	return ch;
-      else
-	{
-	  while (ch != EOF && IS_WHITESPACE (ch))
-	    ch = GET ();
-	  if (ch == '"')
-	    {
-	      (*unget) (ch);
-	      out_string = "\n\t.appfile ";
-	      old_state = 7;
-	      state = -1;
-	      return *out_string++;
+		  if (ch == EOF)
+		    {
+		      as_warn ("end of file in comment");
+		      goto fromeof;
+		    }
+
+		  if (ch == '\n')
+		    PUT ('\n');
+		}
+	      while (ch != '*');
+
+	      while ((ch = GET ()) == '*')
+		;
+
+	      if (ch == EOF)
+		{
+		  as_warn ("end of file in comment");
+		  goto fromeof;
+		}
+
+	      if (ch == '/')
+		break;
+
+	      UNGET (ch);
 	    }
+
+	  state = old_state;
+	  PUT (' ');
+	  continue;
+
+	case 4:
+	  ch = GET ();
+	  if (ch == EOF)
+	    goto fromeof;
+	  else if (ch >= '0' && ch <= '9')
+	    PUT (ch);
 	  else
 	    {
-	      while (ch != EOF && ch != '\n')
+	      while (ch != EOF && IS_WHITESPACE (ch))
 		ch = GET ();
-	      state = 0;
-	      return ch;
+	      if (ch == '"')
+		{
+		  UNGET (ch);
+		  out_string = "\n\t.appfile ";
+		  old_state = 7;
+		  state = -1;
+		  PUT (*out_string++);
+		}
+	      else
+		{
+		  while (ch != EOF && ch != '\n')
+		    ch = GET ();
+		  state = 0;
+		  PUT (ch);
+		}
 	    }
-	}
+	  continue;
 
-    case 5:
-      ch = GET ();
-      if (lex[ch] == LEX_IS_STRINGQUOTE)
-	{
-	  state = old_state;
-	  return ch;
-	}
+	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.  */
+	  {
+	    char *s;
+	    int len;
+
+	    for (s = from; s < fromend; s++)
+	      {
+		ch = *s;
+		/* This condition must be changed if the type of any
+                   other character can be LEX_IS_STRINGQUOTE.  */
+		if (ch == '\\'
+		    || ch == '"'
+		    || ch == '\''
+		    || ch == '\n')
+		  break;
+	      }
+	    len = s - from;
+	    if (len > toend - to)
+	      len = toend - to;
+	    if (len > 0)
+	      {
+		memcpy (to, from, len);
+		to += len;
+		from += len;
+	      }
+	  }
+
+	  ch = GET ();
+	  if (ch == EOF)
+	    {
+	      as_warn ("end of file in string: inserted '\"'");
+	      state = old_state;
+	      UNGET ('\n');
+	      PUT ('"');
+	    }
+	  else if (lex[ch] == LEX_IS_STRINGQUOTE)
+	    {
+	      state = old_state;
+	      PUT (ch);
+	    }
 #ifndef NO_STRING_ESCAPES
-      else if (ch == '\\')
-	{
-	  state = 6;
-	  return ch;
-	}
+	  else if (ch == '\\')
+	    {
+	      state = 6;
+	      PUT (ch);
+	    }
 #endif
-      else if (ch == EOF)
-	{
-	  as_warn ("End of file in string: inserted '\"'");
-	  state = old_state;
-	  (*unget) ('\n');
-	  return '"';
-	}
-      else
-	{
-	  return ch;
-	}
+	  else if (flag_mri && ch == '\n')
+	    {
+	      /* Just quietly terminate the string.  This permits lines like
+		   bne	label	loop if we haven't reach end yet
+		 */
+	      state = old_state;
+	      UNGET (ch);
+	      PUT ('\'');
+	    }
+	  else
+	    {
+	      PUT (ch);
+	    }
+	  continue;
 
-    case 6:
-      state = 5;
-      ch = GET ();
-      switch (ch)
-	{
-	  /* Handle strings broken across lines, by turning '\n' into
-	     '\\' and 'n'.  */
-	case '\n':
-	  (*unget) ('n');
-	  add_newlines++;
-	  return '\\';
-
-	case '"':
-	case '\\':
-	case 'b':
-	case 'f':
-	case 'n':
-	case 'r':
-	case 't':
-	case 'v':
-	case 'x':
-	case 'X':
-	case '0':
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	  break;
+	case 6:
+	  state = 5;
+	  ch = GET ();
+	  switch (ch)
+	    {
+	      /* Handle strings broken across lines, by turning '\n' into
+		 '\\' and 'n'.  */
+	    case '\n':
+	      UNGET ('n');
+	      add_newlines++;
+	      PUT ('\\');
+	      continue;
+
+	    case '"':
+	    case '\\':
+	    case 'b':
+	    case 'f':
+	    case 'n':
+	    case 'r':
+	    case 't':
+	    case 'v':
+	    case 'x':
+	    case 'X':
+	    case '0':
+	    case '1':
+	    case '2':
+	    case '3':
+	    case '4':
+	    case '5':
+	    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:
-	  /* Accept \x as x for any x */
-	  break;
+	    default:
+	      as_warn ("Unknown escape '\\%c' in string: Ignored", ch);
+	      break;
+#else  /* ONLY_STANDARD_ESCAPES */
+	    default:
+	      /* Accept \x as x for any x */
+	      break;
 #endif /* ONLY_STANDARD_ESCAPES */
 
-	case EOF:
-	  as_warn ("End of file in string: '\"' inserted");
-	  return '"';
-	}
-      return ch;
-
-    case 7:
-      ch = GET ();
-      state = 5;
-      old_state = 8;
-      return ch;
-
-    case 8:
-      do
-	ch = GET ();
-      while (ch != '\n');
-      state = 0;
-      return ch;
-    }
+	    case EOF:
+	      as_warn ("End of file in string: '\"' inserted");
+	      PUT ('"');
+	      continue;
+	    }
+	  PUT (ch);
+	  continue;
 
-  /* OK, we are somewhere in states 0 through 4 or 9 through 11 */
+	case 7:
+	  ch = GET ();
+	  state = 5;
+	  old_state = 8;
+	  if (ch == EOF)
+	    goto fromeof;
+	  PUT (ch);
+	  continue;
 
-  /* flushchar: */
-  ch = GET ();
-recycle:
-  if (ch == EOF)
-    {
-      if (state != 0)
-	{
-	  as_warn ("End of file not at end of a line: Newline inserted.");
+	case 8:
+	  do
+	    ch = GET ();
+	  while (ch != '\n' && ch != EOF);
+	  if (ch == EOF)
+	    goto fromeof;
 	  state = 0;
-	  return '\n';
+	  PUT (ch);
+	  continue;
 	}
-      return ch;
-    }
 
-  switch (lex[ch])
-    {
-    case LEX_IS_WHITESPACE:
-      do
-	/* Preserve a single whitespace character at the beginning of
-	   a line.  */
-	if (state == 0)
-	  {
-	    state = 1;
-	    return ch;
-	  }
-	else
-	  ch = GET ();
-      while (ch != EOF && IS_WHITESPACE (ch));
-      if (ch == EOF)
-	return ch;
+      /* OK, we are somewhere in states 0 through 4 or 9 through 11 */
 
-      if (IS_COMMENT (ch)
-	  || (state == 0 && IS_LINE_COMMENT (ch))
-	  || ch == '/'
-	  || IS_LINE_SEPARATOR (ch))
+      /* flushchar: */
+      ch = GET ();
+    recycle:
+      if (ch == EOF)
 	{
-	  /* cpp never outputs a leading space before the #, so try to
-	     avoid being confused.  */
-	  not_cpp_line = 1;
-	  goto recycle;
+	  if (state != 0)
+	    {
+	      as_warn ("end of file not at end of a line; newline inserted");
+	      state = 0;
+	      PUT ('\n');
+	    }
+	  goto fromeof;
 	}
 
-      /* If we're in state 2 or 11, we've seen a non-white character
-	 followed by whitespace.  If the next character is ':', this
-	 is whitespace after a label name which we normally must
-	 ignore.  In MRI mode, though, spaces are not permitted
-	 between the label and the colon.  */
-      if ((state == 2 || state == 11)
-	  && lex[ch] == LEX_IS_COLON
-	  && ! flag_mri)
+      switch (lex[ch])
 	{
-	  state = 1;
-	  return ch;
-	}
+	case LEX_IS_WHITESPACE:
+	  if (state == 0)
+	    {
+	      /* Preserve a single whitespace character at the
+		 beginning of a line.  */
+	      state = 1;
+	      PUT (ch);
+	      break;
+	    }
+	  do
+	    {
+	      ch = GET ();
+	    }
+	  while (ch != EOF && IS_WHITESPACE (ch));
+	  if (ch == EOF)
+	    goto fromeof;
 
-      switch (state)
-	{
-	case 0:
-	  state++;
-	  goto recycle;		/* Punted leading sp */
-	case 1:
-	  /* We can arrive here if we leave a leading whitespace character
-	     at the beginning of a line.  */
-	  goto recycle;
-	case 2:
-	  state = 3;
-	  (*unget) (ch);
-	  return ' ';		/* Sp after opco */
-	case 3:
-	  goto recycle;		/* Sp in operands */
-	case 9:
-	case 10:
-	  state = 10;		/* Sp after symbol char */
-	  goto recycle;
-	case 11:
-	  state = 1;
-	  (*unget) (ch);
-	  return ' ';		/* Sp after label definition.  */
-	default:
-	  BAD_CASE (state);
-	}
-      break;
+	  if (IS_COMMENT (ch)
+	      || (state == 0 && IS_LINE_COMMENT (ch))
+	      || ch == '/'
+	      || IS_LINE_SEPARATOR (ch))
+	    {
+	      /* cpp never outputs a leading space before the #, so
+		 try to avoid being confused.  */
+	      not_cpp_line = 1;
+	      goto recycle;
+	    }
 
-    case LEX_IS_TWOCHAR_COMMENT_1ST:
-      ch2 = GET ();
-      if (ch2 != EOF && lex[ch2] == LEX_IS_TWOCHAR_COMMENT_2ND)
-	{
-	  for (;;)
+	  /* If we're in state 2 or 11, we've seen a non-white
+	     character followed by whitespace.  If the next character
+	     is ':', this is whitespace after a label name which we
+	     normally must ignore.  In MRI mode, though, spaces are
+	     not permitted between the label and the colon.  */
+	  if ((state == 2 || state == 11)
+	      && lex[ch] == LEX_IS_COLON
+	      && ! flag_mri)
 	    {
-	      do
+	      state = 1;
+	      PUT (ch);
+	      break;
+	    }
+
+	  switch (state)
+	    {
+	    case 0:
+	      state++;
+	      goto recycle;	/* Punted leading sp */
+	    case 1:
+	      /* We can arrive here if we leave a leading whitespace
+		 character at the beginning of a line.  */
+	      goto recycle;
+	    case 2:
+	      state = 3;
+	      if (to + 1 < toend)
 		{
-		  ch2 = GET ();
-		  if (ch2 != EOF && IS_NEWLINE (ch2))
-		    add_newlines++;
+		  /* Optimize common case by skipping UNGET/GET.  */
+		  PUT (' ');	/* Sp after opco */
+		  goto recycle;
 		}
-	      while (ch2 != EOF &&
-		     (lex[ch2] != LEX_IS_TWOCHAR_COMMENT_2ND));
+	      UNGET (ch);
+	      PUT (' ');
+	      break;
+	    case 3:
+	      if (flag_mri)
+		{
+		  /* In MRI mode, we keep these spaces.  */
+		  UNGET (ch);
+		  PUT (' ');
+		  break;
+		}
+	      goto recycle;	/* Sp in operands */
+	    case 9:
+	    case 10:
+	      if (flag_mri)
+		{
+		  /* In MRI mode, we keep these spaces.  */
+		  state = 3;
+		  UNGET (ch);
+		  PUT (' ');
+		  break;
+		}
+	      state = 10;	/* Sp after symbol char */
+	      goto recycle;
+	    case 11:
+	      state = 1;
+	      UNGET (ch);
+	      PUT (' ');	/* Sp after label definition.  */
+	      break;
+	    default:
+	      BAD_CASE (state);
+	    }
+	  break;
 
-	      while (ch2 != EOF &&
-		     (lex[ch2] == LEX_IS_TWOCHAR_COMMENT_2ND))
+	case LEX_IS_TWOCHAR_COMMENT_1ST:
+	  ch2 = GET ();
+	  if (ch2 != EOF && lex[ch2] == LEX_IS_TWOCHAR_COMMENT_2ND)
+	    {
+	      for (;;)
 		{
-		  ch2 = GET ();
+		  do
+		    {
+		      ch2 = GET ();
+		      if (ch2 != EOF && IS_NEWLINE (ch2))
+			add_newlines++;
+		    }
+		  while (ch2 != EOF &&
+			 (lex[ch2] != LEX_IS_TWOCHAR_COMMENT_2ND));
+
+		  while (ch2 != EOF &&
+			 (lex[ch2] == LEX_IS_TWOCHAR_COMMENT_2ND))
+		    {
+		      ch2 = GET ();
+		    }
+
+		  if (ch2 == EOF
+		      || lex[ch2] == LEX_IS_TWOCHAR_COMMENT_1ST)
+		    break;
+		  UNGET (ch);
 		}
+	      if (ch2 == EOF)
+		as_warn ("end of file in multiline comment");
 
-	      if (ch2 == EOF
-		  || lex[ch2] == LEX_IS_TWOCHAR_COMMENT_1ST)
-		break;
-	      (*unget) (ch);
+	      ch = ' ';
+	      goto recycle;
 	    }
-	  if (ch2 == EOF)
-	    as_warn ("End of file in multiline comment");
+	  else
+	    {
+	      if (ch2 != EOF)
+		UNGET (ch2);
+	      if (state == 9 || state == 10)
+		state = 3;
+	      PUT (ch);
+	    }
+	  break;
 
-	  ch = ' ';
-	  goto recycle;
-	}
-      else
-	{
-	  if (ch2 != EOF)
-	    (*unget) (ch2);
-	  if (state == 9 || state == 10)
-	    state = 3;
-	  return ch;
-	}
-      break;
+	case LEX_IS_STRINGQUOTE:
+	  if (state == 10)
+	    {
+	      /* Preserve the whitespace in foo "bar" */
+	      UNGET (ch);
+	      state = 3;
+	      PUT (' ');
+
+	      /* PUT didn't jump out.  We could just break, but we
+                 know what will happen, so optimize a bit.  */
+	      ch = GET ();
+	      old_state = 3;
+	    }
+	  else if (state == 9)
+	    old_state = 3;
+	  else
+	    old_state = state;
+	  state = 5;
+	  PUT (ch);
+	  break;
 
-    case LEX_IS_STRINGQUOTE:
-      if (state == 10)
-	{
-	  /* Preserve the whitespace in foo "bar" */
-	  (*unget) (ch);
-	  state = 3;
-	  return ' ';
-	}
-      else if (state == 9)
-	old_state = 3;
-      else
-	old_state = state;
-      state = 5;
-      return ch;
 #ifndef IEEE_STYLE
-    case LEX_IS_ONECHAR_QUOTE:
-      if (state == 10)
-	{
-	  /* Preserve the whitespace in foo 'b' */
-	  (*unget) (ch);
-	  state = 3;
-	  return ' ';
-	}
-      ch = GET ();
-      if (ch == EOF)
-	{
-	  as_warn ("End-of-file after a one-character quote; \\000 inserted");
-	  ch = 0;
-	}
-      if (ch == '\\')
-	{
+	case LEX_IS_ONECHAR_QUOTE:
+	  if (state == 10)
+	    {
+	      /* Preserve the whitespace in foo 'b' */
+	      UNGET (ch);
+	      state = 3;
+	      PUT (' ');
+	      break;
+	    }
 	  ch = GET ();
-	  ch = process_escape (ch);
-	}
-      sprintf (out_buf, "%d", (int) (unsigned char) ch);
-
+	  if (ch == EOF)
+	    {
+	      as_warn ("end of file after a one-character quote; \\0 inserted");
+	      ch = 0;
+	    }
+	  if (ch == '\\')
+	    {
+	      ch = GET ();
+	      if (ch == EOF)
+		{
+		  as_warn ("end of file in escape character");
+		  ch = '\\';
+		}
+	      else
+		ch = process_escape (ch);
+	    }
+	  sprintf (out_buf, "%d", (int) (unsigned char) ch);
 
-      /* None of these 'x constants for us.  We want 'x'.  */
-      if ((ch = GET ()) != '\'')
-	{
+	  /* None of these 'x constants for us.  We want 'x'.  */
+	  if ((ch = GET ()) != '\'')
+	    {
 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
-	  as_warn ("Missing close quote: (assumed)");
+	      as_warn ("Missing close quote: (assumed)");
 #else
-	  (*unget) (ch);
+	      if (ch != EOF)
+		UNGET (ch);
 #endif
-	}
-      if (strlen (out_buf) == 1)
-	{
-	  return out_buf[0];
-	}
-      if (state == 9)
-	old_state = 3;
-      else
-	old_state = state;
-      state = -1;
-      out_string = out_buf;
-      return *out_string++;
+	    }
+	  if (strlen (out_buf) == 1)
+	    {
+	      PUT (out_buf[0]);
+	      break;
+	    }
+	  if (state == 9)
+	    old_state = 3;
+	  else
+	    old_state = state;
+	  state = -1;
+	  out_string = out_buf;
+	  PUT (*out_string++);
+	  break;
 #endif
-    case LEX_IS_COLON:
-      if (state == 9 || state == 10)
-	state = 3;
-      else if (state != 3)
-	state = 1;
-      return ch;
 
-    case LEX_IS_NEWLINE:
-      /* Roll out a bunch of newlines from inside comments, etc.  */
-      if (add_newlines)
-	{
-	  --add_newlines;
-	  (*unget) (ch);
-	}
-      /* fall thru into... */
+	case LEX_IS_COLON:
+	  if (state == 9 || state == 10)
+	    state = 3;
+	  else if (state != 3)
+	    state = 1;
+	  PUT (ch);
+	  break;
 
-    case LEX_IS_LINE_SEPARATOR:
-      state = 0;
-      return ch;
+	case LEX_IS_NEWLINE:
+	  /* Roll out a bunch of newlines from inside comments, etc.  */
+	  if (add_newlines)
+	    {
+	      --add_newlines;
+	      UNGET (ch);
+	    }
+	  /* fall thru into... */
 
-    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 == '/')
-	    {
-	      ch2 = GET ();
-	      if (ch2 == '*')
+	case LEX_IS_LINE_SEPARATOR:
+	  state = 0;
+	  PUT (ch);
+	  break;
+
+	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 == '/')
+		{
+		  ch2 = GET ();
+		  if (ch2 == '*')
+		    {
+		      state = -2;
+		      break;
+		    }
+		  else
+		    {
+		      UNGET (ch2);
+		    }
+		} /* bad hack */
+
+	      if (ch != '#')
+		not_cpp_line = 1;
+
+	      do
 		{
-		  state = -2;
-		  return (do_scrub_next_char (get, unget));
+		  ch = GET ();
 		}
-	      else
+	      while (ch != EOF && IS_WHITESPACE (ch));
+	      if (ch == EOF)
 		{
-		  (*unget) (ch2);
+		  as_warn ("end of file in comment; newline inserted");
+		  PUT ('\n');
+		  break;
 		}
-	    }			/* bad hack */
-
-	  if (ch != '#')
-	    not_cpp_line = 1;
+	      if (ch < '0' || ch > '9' || not_cpp_line)
+		{
+		  /* Non-numerics:  Eat whole comment line */
+		  while (ch != EOF && !IS_NEWLINE (ch))
+		    ch = GET ();
+		  if (ch == EOF)
+		    as_warn ("EOF in Comment: Newline inserted");
+		  state = 0;
+		  PUT ('\n');
+		  break;
+		}
+	      /* Numerics begin comment.  Perhaps CPP `# 123 "filename"' */
+	      UNGET (ch);
+	      old_state = 4;
+	      state = -1;
+	      out_string = "\t.appline ";
+	      PUT (*out_string++);
+	      break;
+	    }
 
+	  /* 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_mri
+		  || (ch != '!' && ch != '*')))
+	    goto de_fault;
+	  if (flag_mri
+	      && (ch == '!' || ch == '*')
+	      && state != 1
+	      && state != 10)
+	    goto de_fault;
+	  /* Fall through.  */
+	case LEX_IS_COMMENT_START:
 	  do
-	    ch = GET ();
-	  while (ch != EOF && IS_WHITESPACE (ch));
-	  if (ch == EOF)
 	    {
-	      as_warn ("EOF in comment:  Newline inserted");
-	      return '\n';
+	      ch = GET ();
 	    }
-	  if (ch < '0' || ch > '9' || not_cpp_line)
+	  while (ch != EOF && !IS_NEWLINE (ch));
+	  if (ch == EOF)
+	    as_warn ("end of file in comment; newline inserted");
+	  state = 0;
+	  PUT ('\n');
+	  break;
+
+	case LEX_IS_SYMBOL_COMPONENT:
+	  if (state == 10)
 	    {
-	      /* Non-numerics:  Eat whole comment line */
-	      while (ch != EOF && !IS_NEWLINE (ch))
-		ch = GET ();
-	      if (ch == EOF)
-		as_warn ("EOF in Comment: Newline inserted");
-	      state = 0;
-	      return '\n';
+	      /* This is a symbol character following another symbol
+		 character, with whitespace in between.  We skipped
+		 the whitespace earlier, so output it now.  */
+	      UNGET (ch);
+	      state = 3;
+	      PUT (' ');
+	      break;
 	    }
-	  /* Numerics begin comment.  Perhaps CPP `# 123 "filename"' */
-	  (*unget) (ch);
-	  old_state = 4;
-	  state = -1;
-	  out_string = "\t.appline ";
-	  return *out_string++;
-	}
 
-      /* 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 ((flag_mri && (ch == '!' || ch == '*'))
-	  || strchr (comment_chars, ch) == NULL)
-	goto de_fault;
-      /* Fall through.  */
-    case LEX_IS_COMMENT_START:
-      do
-	ch = GET ();
-      while (ch != EOF && !IS_NEWLINE (ch));
-      if (ch == EOF)
-	as_warn ("EOF in comment:  Newline inserted");
-      state = 0;
-      return '\n';
+	  if (state == 3)
+	    state = 9;
 
-    case LEX_IS_SYMBOL_COMPONENT:
-      if (state == 10)
-	{
-	  /* This is a symbol character following another symbol
-	     character, with whitespace in between.  We skipped the
-	     whitespace earlier, so output it now.  */
-	  (*unget) (ch);
-	  state = 3;
-	  return ' ';
-	}
-      if (state == 3)
-	state = 9;
-      /* Fall through.  */
-    default:
-    de_fault:
-      /* Some relatively `normal' character.  */
-      if (state == 0)
-	{
-	  state = 11;		/* Now seeing label definition */
-	  return ch;
-	}
-      else if (state == 1)
-	{
-	  state = 2;		/* Ditto */
-	  return ch;
-	}
-      else if (state == 9)
-	{
-	  if (lex[ch] != LEX_IS_SYMBOL_COMPONENT)
-	    state = 3;
-	  return ch;
-	}
-      else if (state == 10)
-	{
-	  state = 3;
-	  return ch;
-	}
-      else
-	{
-	  return ch;		/* Opcode or operands already */
-	}
-    }
-  return -1;
+	  /* This is a common case.  Quickly copy CH and all the
+             following symbol component or normal characters.  */
+	  if (to + 1 < toend)
+	    {
+	      char *s;
+	      int len;
 
-#undef GET
-}
+	      for (s = from; s < fromend; s++)
+		{
+		  int type;
 
-#ifdef TEST
+		  ch2 = *s;
+		  type = lex[ch2];
+		  if (type != 0
+		      && type != LEX_IS_SYMBOL_COMPONENT)
+		    break;
+		}
+	      if (s > from)
+		{
+		  /* Handle the last character normally, for
+                     simplicity.  */
+		  --s;
+		}
+	      len = s - from;
+	      if (len > (toend - to) - 1)
+		len = (toend - to) - 1;
+	      if (len > 0)
+		{
+		  PUT (ch);
+		  if (len > 8)
+		    {
+		      memcpy (to, from, len);
+		      to += len;
+		      from += len;
+		    }
+		  else
+		    {
+		      switch (len)
+			{
+			case 8: *to++ = *from++;
+			case 7: *to++ = *from++;
+			case 6: *to++ = *from++;
+			case 5: *to++ = *from++;
+			case 4: *to++ = *from++;
+			case 3: *to++ = *from++;
+			case 2: *to++ = *from++;
+			case 1: *to++ = *from++;
+			}
+		    } 
+		  ch = GET ();
+		}
+	    }
 
-const char comment_chars[] = "|";
-const char line_comment_chars[] = "#";
+	  /* Fall through.  */
+	default:
+	de_fault:
+	  /* Some relatively `normal' character.  */
+	  if (state == 0)
+	    {
+	      state = 11;	/* Now seeing label definition */
+	    }
+	  else if (state == 1)
+	    {
+	      state = 2;	/* Ditto */
+	    }
+	  else if (state == 9)
+	    {
+	      if (lex[ch] != LEX_IS_SYMBOL_COMPONENT)
+		state = 3;
+	    }
+	  else if (state == 10)
+	    {
+	      state = 3;
+	    }
+	  PUT (ch);
+	  break;
+	}
+    }
 
-main ()
-{
-  int ch;
+  /*NOTREACHED*/
 
-  app_begin ();
-  while ((ch = do_scrub_next_char (stdin)) != EOF)
-    putc (ch, stdout);
-}
+ fromeof:
+  /* We have reached the end of the input.  */
+  return to - tostart;
 
-as_warn (str)
-     char *str;
-{
-  fputs (str, stderr);
-  putc ('\n', stderr);
+ tofull:
+  /* The output buffer is full.  Save any input we have not yet
+     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_len = fromend - from;
+    }
+  else
+    {
+      if (saved_input != NULL)
+	{
+	  free (saved_input);
+	  saved_input = NULL;
+	}
+    }
+  return to - tostart;
 }
 
-#endif
-
 /* end of app.c */
diff --git a/gas/cond.c b/gas/cond.c
index def9db9..b32f3f5 100644
--- a/gas/cond.c
+++ b/gas/cond.c
@@ -61,19 +61,23 @@ s_ifdef (arg)
     {
       as_bad ("invalid identifier for \".ifdef\"");
       obstack_1grow (&cond_obstack, 0);
+      ignore_rest_of_line ();
     }
   else
     {
-      get_symbol_end ();
-      ++input_line_pointer;
+      char c;
+
+      c = get_symbol_end ();
       symbolP = symbol_find (name);
+      *input_line_pointer = c;
 
       initialize_cframe (&cframe);
       cframe.ignoring = cframe.dead_tree || !((symbolP != 0) ^ arg);
-      current_cframe = (struct conditional_frame *) obstack_copy (&cond_obstack, &cframe, sizeof (cframe));
+      current_cframe = ((struct conditional_frame *)
+			obstack_copy (&cond_obstack, &cframe,
+				      sizeof (cframe)));
+      demand_empty_rest_of_line ();
     }				/* if a valid identifyer name */
-
-  return;
 }				/* s_ifdef() */
 
 void 
@@ -85,10 +89,19 @@ s_if (arg)
   int t;
 
   SKIP_WHITESPACE ();		/* Leading whitespace is part of operand. */
-  expression (&operand);
 
-  if (operand.X_op != O_constant)
-    as_bad ("non-constant expression in \".if\" statement");
+  if (current_cframe != NULL && current_cframe->ignoring)
+    {
+      operand.X_add_number = 0;
+      while (! is_end_of_line[(unsigned char) *input_line_pointer])
+	++input_line_pointer;
+    }
+  else
+    {
+      expression (&operand);
+      if (operand.X_op != O_constant)
+	as_bad ("non-constant expression in \".if\" statement");
+    }
 
   switch ((operatorT) arg)
     {
@@ -108,7 +121,8 @@ s_if (arg)
   cframe.ignoring = cframe.dead_tree || ! t;
   current_cframe = ((struct conditional_frame *)
 		    obstack_copy (&cond_obstack, &cframe, sizeof (cframe)));
-  return;
+
+  demand_empty_rest_of_line ();
 }				/* s_if() */
 
 /* Get a string for the MRI IFC or IFNC pseudo-ops.  */
@@ -268,14 +282,16 @@ ignore_input ()
     }
 
   /* We cannot ignore certain pseudo ops.  */
-  if ((s[0] == 'i'
-       && (!strncmp (s, "if", 2)
-	   || !strncmp (s, "ifdef", 5)
-	   || !strncmp (s, "ifndef", 6)))
-      || (s[0] == 'e'
-	  && (!strncmp (s, "else", 4)
-	      || !strncmp (s, "endif", 5)
-	      || !strncmp (s, "endc", 4))))
+  if (((s[0] == 'i'
+	|| s[0] == 'I')
+       && (!strncasecmp (s, "if", 2)
+	   || !strncasecmp (s, "ifdef", 5)
+	   || !strncasecmp (s, "ifndef", 6)))
+      || ((s[0] == 'e'
+	   || s[0] == 'E')
+	  && (!strncasecmp (s, "else", 4)
+	      || !strncasecmp (s, "endif", 5)
+	      || !strncasecmp (s, "endc", 4))))
     return 0;
 
   return (current_cframe != NULL) && (current_cframe->ignoring);
diff --git a/gas/read.c b/gas/read.c
index 7efdaad..cb536d0 100644
--- a/gas/read.c
+++ b/gas/read.c
@@ -191,6 +191,7 @@ symbolS *mri_common_symbol;
    may be needed.  */
 static int mri_pending_align;
 
+static int scrub_from_string PARAMS ((char **));
 static void do_align PARAMS ((int, char *));
 static int hex_float PARAMS ((int, char *));
 static void do_org PARAMS ((segT, expressionS *, int));
@@ -330,6 +331,7 @@ static const pseudo_typeS potable[] =
 /* print */
   {"quad", cons, 8},
   {"rept", s_rept, 0},
+  {"rva", s_rva, 4},
   {"sbttl", listing_title, 1},	/* Subtitle of listing */
 /* scl */
 /* sect */
@@ -425,6 +427,24 @@ pobegin ()
     }
 
 
+/* This function is used when scrubbing the characters between #APP
+   and #NO_APP.  */
+
+static char *scrub_string;
+static char *scrub_string_end;
+
+static int
+scrub_from_string (from)
+     char **from;
+{
+  int size;
+
+  *from = scrub_string;
+  size = scrub_string_end - scrub_string;
+  scrub_string = scrub_string_end;
+  return size;
+}
+
 /*	read_a_source_file()
  *
  * We read the file, putting things into a web that
@@ -810,7 +830,6 @@ read_a_source_file (name)
 	      char *new_tmp;
 	      unsigned int new_length;
 	      char *tmp_buf = 0;
-	      extern char *scrub_string, *scrub_last_string;
 
 	      bump_line_counters ();
 	      s = input_line_pointer;
@@ -862,26 +881,30 @@ read_a_source_file (name)
 		{
 		  input_line_pointer = ends + 8;
 		}
-	      new_buf = xmalloc (100);
-	      new_length = 100;
-	      new_tmp = new_buf;
 
 	      scrub_string = s;
-	      scrub_last_string = ends;
+	      scrub_string_end = ends;
+
+	      new_length = ends - s;
+	      new_buf = (char *) xmalloc (new_length);
+	      new_tmp = new_buf;
 	      for (;;)
 		{
-		  int ch;
+		  int space;
+		  int size;
 
-		  ch = do_scrub_next_char (scrub_from_string, scrub_to_string);
-		  if (ch == EOF)
-		    break;
-		  *new_tmp++ = ch;
-		  if (new_tmp == new_buf + new_length)
+		  space = (new_buf + new_length) - new_tmp;
+		  size = do_scrub_chars (scrub_from_string, new_tmp, space);
+
+		  if (size < space)
 		    {
-		      new_buf = xrealloc (new_buf, new_length + 100);
-		      new_tmp = new_buf + new_length;
-		      new_length += 100;
+		      new_tmp += size;
+		      break;
 		    }
+
+		  new_buf = xrealloc (new_buf, new_length + 100);
+		  new_tmp = new_buf + new_length;
+		  new_length += 100;
 		}
 
 	      if (tmp_buf)
@@ -908,6 +931,7 @@ read_a_source_file (name)
 
       if (old_buffer)
 	{
+	  free (buffer);
 	  bump_line_counters ();
 	  if (old_input != 0)
 	    {
@@ -1224,11 +1248,11 @@ s_data (ignore)
 }
 
 /* Handle the .appfile pseudo-op.  This is automatically generated by
-   do_scrub_next_char when a preprocessor # line comment is seen with
-   a file name.  This default definition may be overridden by the
-   object or CPU specific pseudo-ops.  This function is also the
-   default definition for .file; the APPFILE argument is 1 for
-   .appfile, 0 for .file.  */
+   do_scrub_chars when a preprocessor # line comment is seen with a
+   file name.  This default definition may be overridden by the object
+   or CPU specific pseudo-ops.  This function is also the default
+   definition for .file; the APPFILE argument is 1 for .appfile, 0 for
+   .file.  */
 
 void 
 s_app_file (appfile)
@@ -1256,9 +1280,9 @@ s_app_file (appfile)
 }
 
 /* Handle the .appline pseudo-op.  This is automatically generated by
-   do_scrub_next_char when a preprocessor # line comment is seen.
-   This default definition may be overridden by the object or CPU
-   specific pseudo-ops.  */
+   do_scrub_chars when a preprocessor # line comment is seen.  This
+   default definition may be overridden by the object or CPU specific
+   pseudo-ops.  */
 
 void
 s_app_line (ignore)
@@ -2362,12 +2386,14 @@ parse_repeat_cons PARAMS ((expressionS *exp, unsigned int nbytes));
 /* worker to do .byte etc statements */
 /* clobbers input_line_pointer, checks */
 /* end-of-line. */
-void 
-cons (nbytes)
+static void 
+cons_worker (nbytes, rva)
      register int nbytes;	/* 1=.byte, 2=.word, 4=.long */
+     int rva;
 {
   int c;
   expressionS exp;
+  char *stop = NULL;
 
 #ifdef md_flush_pending_output
   md_flush_pending_output ();
@@ -2379,17 +2405,54 @@ cons (nbytes)
       return;
     }
 
+  /* In MRI mode, the operands end at the first unquoted space.  */
+  if (flag_mri)
+    {
+      char *s;
+      int inquote = 0;
+
+      for (s = input_line_pointer;
+	   ((! is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
+	    || inquote);
+	   s++)
+	{
+	  if (*s == '\'')
+	    inquote = ! inquote;
+	}
+      stop = s;
+    }
+
   c = 0;
   do
     {
+      if (rva) 
+	{
+	  /* If this is an .rva pseudoop then stick
+	     an extra reloc in for this word. */
+	  int reloc;
+	  char *p = frag_more (0);
+	  exp.X_op = O_absent;
+
+#ifdef BFD_ASSEMBLER
+	  reloc = BFD_RELOC_RVA;
+#elif defined(TC_RVA_RELOC)
+	  reloc = TC_RVA_RELOC;
+#else
+	  abort();
+#endif
+	  fix_new_exp (frag_now, p - frag_now->fr_literal,
+		       nbytes, &exp, 0, reloc);
+
+	}
       if (flag_mri)
 	parse_mri_cons (&exp, (unsigned int) nbytes);
       else
 	TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
-      emit_expr (&exp, (unsigned int) nbytes);
+       emit_expr (&exp, (unsigned int) nbytes);
       ++c;
     }
-  while (*input_line_pointer++ == ',');
+  while (*input_line_pointer++ == ','
+	 && (! flag_mri || input_line_pointer < stop));
 
   /* In MRI mode, after an odd number of bytes, we must align to an
      even word boundary, unless the next instruction is a dc.b, ds.b
@@ -2398,9 +2461,33 @@ cons (nbytes)
     mri_pending_align = 1;
 
   input_line_pointer--;		/* Put terminator back into stream. */
+
+  if (flag_mri)
+    {
+      input_line_pointer = stop;
+      while (! is_end_of_line[(unsigned char) *input_line_pointer])
+	++input_line_pointer;
+    }
+
   demand_empty_rest_of_line ();
 }
 
+
+void
+cons (size)
+     int size;
+{
+  cons_worker (size, 0);
+}
+
+void 
+s_rva (size)
+     int size;
+{
+  cons_worker (size, 1);
+}
+
+
 /* Put the contents of expression EXP into the object file using
    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
 
@@ -2625,8 +2712,8 @@ emit_expr (exp, nbytes)
       fix_new_exp (frag_now, p - frag_now->fr_literal, (int) nbytes, exp, 0,
 		   /* @@ Should look at CPU word size.  */
 		   nbytes == 2 ? BFD_RELOC_16
-		   : nbytes == 8 ? BFD_RELOC_64
-		   : BFD_RELOC_32);
+		      : nbytes == 8 ? BFD_RELOC_64
+		      : BFD_RELOC_32);
 #endif
 #else
 #ifdef TC_CONS_FIX_NEW
@@ -3435,6 +3522,8 @@ equals (sym_name)
      char *sym_name;
 {
   register symbolS *symbolP;	/* symbol we are working with */
+  char *stop;
+  int stopc;
 
   input_line_pointer++;
   if (*input_line_pointer == '=')
@@ -3443,6 +3532,25 @@ equals (sym_name)
   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
     input_line_pointer++;
 
+  /* In MRI mode, the operands end at the first unquoted space.  */
+  if (flag_mri)
+    {
+      char *s;
+      int inquote = 0;
+
+      for (s = input_line_pointer;
+	   ((! is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
+	    || inquote);
+	   s++)
+	{
+	  if (*s == '\'')
+	    inquote = ! inquote;
+	}
+      stop = s;
+      stopc = *stop;
+      *stop = '\0';
+    }
+
   if (sym_name[0] == '.' && sym_name[1] == '\0')
     {
       /* Turn '. = mumble' into a .org mumble */
@@ -3458,6 +3566,14 @@ equals (sym_name)
       symbolP = symbol_find_or_make (sym_name);
       pseudo_set (symbolP);
     }
+
+  if (flag_mri)
+    {
+      input_line_pointer = stop;
+      *stop = stopc;
+      while (! is_end_of_line[(unsigned char) *input_line_pointer])
+	++input_line_pointer;
+    }
 }				/* equals() */
 
 /* .include -- include a file at this point. */