contrib/binutils-2.14/gas/app.c

   1 /* This is the Assembler Pre-Processor
   2    Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2002, 2003
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 /* Modified by Allen Wirfs-Brock, Instantiations Inc 2/90.  */
  24 /* App, the assembler pre-processor.  This pre-processor strips out excess
  25    spaces, turns single-quoted characters into a decimal constant, and turns
  26    # <number> <filename> <garbage> into a .line <number>\n.file <filename>
  27    pair.  This needs better error-handling.  */
  28
  29 #include <stdio.h>
  30 #include "as.h"                 /* For BAD_CASE() only.  */
  31
  32 #if (__STDC__ != 1)
  33 #ifndef const
  34 #define const  /* empty */
  35 #endif
  36 #endif
  37
  38 #ifdef TC_M68K
  39 /* Whether we are scrubbing in m68k MRI mode.  This is different from
  40    flag_m68k_mri, because the two flags will be affected by the .mri
  41    pseudo-op at different times.  */
  42 static int scrub_m68k_mri;
  43
  44 /* The pseudo-op which switches in and out of MRI mode.  See the
  45    comment in do_scrub_chars.  */
  46 static const char mri_pseudo[] = ".mri 0";
  47 #else
  48 #define scrub_m68k_mri 0
  49 #endif
  50
  51 #if defined TC_ARM && defined OBJ_ELF
  52 /* The pseudo-op for which we need to special-case `@' characters.
  53    See the comment in do_scrub_chars.  */
  54 static const char   symver_pseudo[] = ".symver";
  55 static const char * symver_state;
  56 #endif
  57
  58 static char lex[256];
  59 static const char symbol_chars[] =
  60 "$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
  61
  62 #define LEX_IS_SYMBOL_COMPONENT         1
  63 #define LEX_IS_WHITESPACE               2
  64 #define LEX_IS_LINE_SEPARATOR           3
  65 #define LEX_IS_COMMENT_START            4
  66 #define LEX_IS_LINE_COMMENT_START       5
  67 #define LEX_IS_TWOCHAR_COMMENT_1ST      6
  68 #define LEX_IS_STRINGQUOTE              8
  69 #define LEX_IS_COLON                    9
  70 #define LEX_IS_NEWLINE                  10
  71 #define LEX_IS_ONECHAR_QUOTE            11
  72 #ifdef TC_V850
  73 #define LEX_IS_DOUBLEDASH_1ST           12
  74 #endif
  75 #ifdef TC_M32R
  76 #define DOUBLEBAR_PARALLEL
  77 #endif
  78 #ifdef DOUBLEBAR_PARALLEL
  79 #define LEX_IS_DOUBLEBAR_1ST            13
  80 #endif
  81 #define LEX_IS_PARALLEL_SEPARATOR       14
  82 #define IS_SYMBOL_COMPONENT(c)          (lex[c] == LEX_IS_SYMBOL_COMPONENT)
  83 #define IS_WHITESPACE(c)                (lex[c] == LEX_IS_WHITESPACE)
  84 #define IS_LINE_SEPARATOR(c)            (lex[c] == LEX_IS_LINE_SEPARATOR)
  85 #define IS_PARALLEL_SEPARATOR(c)        (lex[c] == LEX_IS_PARALLEL_SEPARATOR)
  86 #define IS_COMMENT(c)                   (lex[c] == LEX_IS_COMMENT_START)
  87 #define IS_LINE_COMMENT(c)              (lex[c] == LEX_IS_LINE_COMMENT_START)
  88 #define IS_NEWLINE(c)                   (lex[c] == LEX_IS_NEWLINE)
  89
  90 static int process_escape PARAMS ((int));
  91
  92 /* FIXME-soon: The entire lexer/parser thingy should be
  93    built statically at compile time rather than dynamically
  94    each and every time the assembler is run.  xoxorich.  */
  95
  96 void
  97 do_scrub_begin (m68k_mri)
  98      int m68k_mri ATTRIBUTE_UNUSED;
  99 {
 100   const char *p;
 101   int c;
 102
 103   lex[' '] = LEX_IS_WHITESPACE;
 104   lex['\t'] = LEX_IS_WHITESPACE;
 105   lex['\r'] = LEX_IS_WHITESPACE;
 106   lex['\n'] = LEX_IS_NEWLINE;
 107   lex[':'] = LEX_IS_COLON;
 108
 109 #ifdef TC_M68K
 110   scrub_m68k_mri = m68k_mri;
 111
 112   if (! m68k_mri)
 113 #endif
 114     {
 115       lex['"'] = LEX_IS_STRINGQUOTE;
 116
 117 #if ! defined (TC_HPPA) && ! defined (TC_I370)
 118       /* I370 uses single-quotes to delimit integer, float constants.  */
 119       lex['\''] = LEX_IS_ONECHAR_QUOTE;
 120 #endif
 121
 122 #ifdef SINGLE_QUOTE_STRINGS
 123       lex['\''] = LEX_IS_STRINGQUOTE;
 124 #endif
 125     }
 126
 127   /* Note: if any other character can be LEX_IS_STRINGQUOTE, the loop
 128      in state 5 of do_scrub_chars must be changed.  */
 129
 130   /* Note that these override the previous defaults, e.g. if ';' is a
 131      comment char, then it isn't a line separator.  */
 132   for (p = symbol_chars; *p; ++p)
 133     lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT;
 134
 135   for (c = 128; c < 256; ++c)
 136     lex[c] = LEX_IS_SYMBOL_COMPONENT;
 137
 138 #ifdef tc_symbol_chars
 139   /* This macro permits the processor to specify all characters which
 140      may appears in an operand.  This will prevent the scrubber from
 141      discarding meaningful whitespace in certain cases.  The i386
 142      backend uses this to support prefixes, which can confuse the
 143      scrubber as to whether it is parsing operands or opcodes.  */
 144   for (p = tc_symbol_chars; *p; ++p)
 145     lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT;
 146 #endif
 147
 148   /* The m68k backend wants to be able to change comment_chars.  */
 149 #ifndef tc_comment_chars
 150 #define tc_comment_chars comment_chars
 151 #endif
 152   for (p = tc_comment_chars; *p; p++)
 153     lex[(unsigned char) *p] = LEX_IS_COMMENT_START;
 154
 155   for (p = line_comment_chars; *p; p++)
 156     lex[(unsigned char) *p] = LEX_IS_LINE_COMMENT_START;
 157
 158   for (p = line_separator_chars; *p; p++)
 159     lex[(unsigned char) *p] = LEX_IS_LINE_SEPARATOR;
 160
 161 #ifdef tc_parallel_separator_chars
 162   /* This macro permits the processor to specify all characters which
 163      separate parallel insns on the same line.  */
 164   for (p = tc_parallel_separator_chars; *p; p++)
 165     lex[(unsigned char) *p] = LEX_IS_PARALLEL_SEPARATOR;
 166 #endif
 167
 168   /* Only allow slash-star comments if slash is not in use.
 169      FIXME: This isn't right.  We should always permit them.  */
 170   if (lex['/'] == 0)
 171     lex['/'] = LEX_IS_TWOCHAR_COMMENT_1ST;
 172
 173 #ifdef TC_M68K
 174   if (m68k_mri)
 175     {
 176       lex['\''] = LEX_IS_STRINGQUOTE;
 177       lex[';'] = LEX_IS_COMMENT_START;
 178       lex['*'] = LEX_IS_LINE_COMMENT_START;
 179       /* The MRI documentation says '!' is LEX_IS_COMMENT_START, but
 180          then it can't be used in an expression.  */
 181       lex['!'] = LEX_IS_LINE_COMMENT_START;
 182     }
 183 #endif
 184
 185 #ifdef TC_V850
 186   lex['-'] = LEX_IS_DOUBLEDASH_1ST;
 187 #endif
 188 #ifdef DOUBLEBAR_PARALLEL
 189   lex['|'] = LEX_IS_DOUBLEBAR_1ST;
 190 #endif
 191 #ifdef TC_D30V
 192   /* Must do this is we want VLIW instruction with "->" or "<-".  */
 193   lex['-'] = LEX_IS_SYMBOL_COMPONENT;
 194 #endif
 195 }
 196
 197 /* Saved state of the scrubber.  */
 198 static int state;
 199 static int old_state;
 200 static char *out_string;
 201 static char out_buf[20];
 202 static int add_newlines;
 203 static char *saved_input;
 204 static int saved_input_len;
 205 static char input_buffer[32 * 1024];
 206 static const char *mri_state;
 207 static char mri_last_ch;
 208
 209 /* Data structure for saving the state of app across #include's.  Note that
 210    app is called asynchronously to the parsing of the .include's, so our
 211    state at the time .include is interpreted is completely unrelated.
 212    That's why we have to save it all.  */
 213
 214 struct app_save
 215 {
 216   int          state;
 217   int          old_state;
 218   char *       out_string;
 219   char         out_buf[sizeof (out_buf)];
 220   int          add_newlines;
 221   char *       saved_input;
 222   int          saved_input_len;
 223 #ifdef TC_M68K
 224   int          scrub_m68k_mri;
 225 #endif
 226   const char * mri_state;
 227   char         mri_last_ch;
 228 #if defined TC_ARM && defined OBJ_ELF
 229   const char * symver_state;
 230 #endif
 231 };
 232
 233 char *
 234 app_push ()
 235 {
 236   register struct app_save *saved;
 237
 238   saved = (struct app_save *) xmalloc (sizeof (*saved));
 239   saved->state = state;
 240   saved->old_state = old_state;
 241   saved->out_string = out_string;
 242   memcpy (saved->out_buf, out_buf, sizeof (out_buf));
 243   saved->add_newlines = add_newlines;
 244   if (saved_input == NULL)
 245     saved->saved_input = NULL;
 246   else
 247     {
 248       saved->saved_input = xmalloc (saved_input_len);
 249       memcpy (saved->saved_input, saved_input, saved_input_len);
 250       saved->saved_input_len = saved_input_len;
 251     }
 252 #ifdef TC_M68K
 253   saved->scrub_m68k_mri = scrub_m68k_mri;
 254 #endif
 255   saved->mri_state = mri_state;
 256   saved->mri_last_ch = mri_last_ch;
 257 #if defined TC_ARM && defined OBJ_ELF
 258   saved->symver_state = symver_state;
 259 #endif
 260
 261   /* do_scrub_begin() is not useful, just wastes time.  */
 262
 263   state = 0;
 264   saved_input = NULL;
 265
 266   return (char *) saved;
 267 }
 268
 269 void
 270 app_pop (arg)
 271      char *arg;
 272 {
 273   register struct app_save *saved = (struct app_save *) arg;
 274
 275   /* There is no do_scrub_end ().  */
 276   state = saved->state;
 277   old_state = saved->old_state;
 278   out_string = saved->out_string;
 279   memcpy (out_buf, saved->out_buf, sizeof (out_buf));
 280   add_newlines = saved->add_newlines;
 281   if (saved->saved_input == NULL)
 282     saved_input = NULL;
 283   else
 284     {
 285       assert (saved->saved_input_len <= (int) (sizeof input_buffer));
 286       memcpy (input_buffer, saved->saved_input, saved->saved_input_len);
 287       saved_input = input_buffer;
 288       saved_input_len = saved->saved_input_len;
 289       free (saved->saved_input);
 290     }
 291 #ifdef TC_M68K
 292   scrub_m68k_mri = saved->scrub_m68k_mri;
 293 #endif
 294   mri_state = saved->mri_state;
 295   mri_last_ch = saved->mri_last_ch;
 296 #if defined TC_ARM && defined OBJ_ELF
 297   symver_state = saved->symver_state;
 298 #endif
 299
 300   free (arg);
 301 }
 302
 303 /* @@ This assumes that \n &c are the same on host and target.  This is not
 304    necessarily true.  */
 305
 306 static int
 307 process_escape (ch)
 308      int ch;
 309 {
 310   switch (ch)
 311     {
 312     case 'b':
 313       return '\b';
 314     case 'f':
 315       return '\f';
 316     case 'n':
 317       return '\n';
 318     case 'r':
 319       return '\r';
 320     case 't':
 321       return '\t';
 322     case '\'':
 323       return '\'';
 324     case '"':
 325       return '\"';
 326     default:
 327       return ch;
 328     }
 329 }
 330
 331 /* This function is called to process input characters.  The GET
 332    parameter is used to retrieve more input characters.  GET should
 333    set its parameter to point to a buffer, and return the length of
 334    the buffer; it should return 0 at end of file.  The scrubbed output
 335    characters are put into the buffer starting at TOSTART; the TOSTART
 336    buffer is TOLEN bytes in length.  The function returns the number
 337    of scrubbed characters put into TOSTART.  This will be TOLEN unless
 338    end of file was seen.  This function is arranged as a state
 339    machine, and saves its state so that it may return at any point.
 340    This is the way the old code used to work.  */
 341
 342 int
 343 do_scrub_chars (get, tostart, tolen)
 344      int (*get) PARAMS ((char *, int));
 345      char *tostart;
 346      int tolen;
 347 {
 348   char *to = tostart;
 349   char *toend = tostart + tolen;
 350   char *from;
 351   char *fromend;
 352   int fromlen;
 353   register int ch, ch2 = 0;
 354
 355   /*State 0: beginning of normal line
 356           1: After first whitespace on line (flush more white)
 357           2: After first non-white (opcode) on line (keep 1white)
 358           3: after second white on line (into operands) (flush white)
 359           4: after putting out a .line, put out digits
 360           5: parsing a string, then go to old-state
 361           6: putting out \ escape in a "d string.
 362           7: After putting out a .appfile, put out string.
 363           8: After putting out a .appfile string, flush until newline.
 364           9: After seeing symbol char in state 3 (keep 1white after symchar)
 365          10: After seeing whitespace in state 9 (keep white before symchar)
 366          11: After seeing a symbol character in state 0 (eg a label definition)
 367          -1: output string in out_string and go to the state in old_state
 368          -2: flush text until a '*' '/' is seen, then go to state old_state
 369 #ifdef TC_V850
 370          12: After seeing a dash, looking for a second dash as a start
 371              of comment.
 372 #endif
 373 #ifdef DOUBLEBAR_PARALLEL
 374          13: After seeing a vertical bar, looking for a second
 375              vertical bar as a parallel expression separator.
 376 #endif
 377           */
 378
 379   /* I added states 9 and 10 because the MIPS ECOFF assembler uses
 380      constructs like ``.loc 1 20''.  This was turning into ``.loc
 381      120''.  States 9 and 10 ensure that a space is never dropped in
 382      between characters which could appear in an identifier.  Ian
 383      Taylor, ian@cygnus.com.
 384
 385      I added state 11 so that something like "Lfoo add %r25,%r26,%r27" works
 386      correctly on the PA (and any other target where colons are optional).
 387      Jeff Law, law@cs.utah.edu.
 388
 389      I added state 13 so that something like "cmp r1, r2 || trap #1" does not
 390      get squashed into "cmp r1,r2||trap#1", with the all important space
 391      between the 'trap' and the '#1' being eliminated.  nickc@cygnus.com  */
 392
 393   /* This macro gets the next input character.  */
 394
 395 #define GET()                                                   \
 396   (from < fromend                                               \
 397    ? * (unsigned char *) (from++)                               \
 398    : (saved_input = NULL,                                       \
 399       fromlen = (*get) (input_buffer, sizeof input_buffer),     \
 400       from = input_buffer,                                      \
 401       fromend = from + fromlen,                                 \
 402       (fromlen == 0                                             \
 403        ? EOF                                                    \
 404        : * (unsigned char *) (from++))))
 405
 406   /* This macro pushes a character back on the input stream.  */
 407
 408 #define UNGET(uch) (*--from = (uch))
 409
 410   /* This macro puts a character into the output buffer.  If this
 411      character fills the output buffer, this macro jumps to the label
 412      TOFULL.  We use this rather ugly approach because we need to
 413      handle two different termination conditions: EOF on the input
 414      stream, and a full output buffer.  It would be simpler if we
 415      always read in the entire input stream before processing it, but
 416      I don't want to make such a significant change to the assembler's
 417      memory usage.  */
 418
 419 #define PUT(pch)                                \
 420   do                                            \
 421     {                                           \
 422       *to++ = (pch);                            \
 423       if (to >= toend)                          \
 424         goto tofull;                            \
 425     }                                           \
 426   while (0)
 427
 428   if (saved_input != NULL)
 429     {
 430       from = saved_input;
 431       fromend = from + saved_input_len;
 432     }
 433   else
 434     {
 435       fromlen = (*get) (input_buffer, sizeof input_buffer);
 436       if (fromlen == 0)
 437         return 0;
 438       from = input_buffer;
 439       fromend = from + fromlen;
 440     }
 441
 442   while (1)
 443     {
 444       /* The cases in this switch end with continue, in order to
 445          branch back to the top of this while loop and generate the
 446          next output character in the appropriate state.  */
 447       switch (state)
 448         {
 449         case -1:
 450           ch = *out_string++;
 451           if (*out_string == '\0')
 452             {
 453               state = old_state;
 454               old_state = 3;
 455             }
 456           PUT (ch);
 457           continue;
 458
 459         case -2:
 460           for (;;)
 461             {
 462               do
 463                 {
 464                   ch = GET ();
 465
 466                   if (ch == EOF)
 467                     {
 468                       as_warn (_("end of file in comment"));
 469                       goto fromeof;
 470                     }
 471
 472                   if (ch == '\n')
 473                     PUT ('\n');
 474                 }
 475               while (ch != '*');
 476
 477               while ((ch = GET ()) == '*')
 478                 ;
 479
 480               if (ch == EOF)
 481                 {
 482                   as_warn (_("end of file in comment"));
 483                   goto fromeof;
 484                 }
 485
 486               if (ch == '/')
 487                 break;
 488
 489               UNGET (ch);
 490             }
 491
 492           state = old_state;
 493           UNGET (' ');
 494           continue;
 495
 496         case 4:
 497           ch = GET ();
 498           if (ch == EOF)
 499             goto fromeof;
 500           else if (ch >= '0' && ch <= '9')
 501             PUT (ch);
 502           else
 503             {
 504               while (ch != EOF && IS_WHITESPACE (ch))
 505                 ch = GET ();
 506               if (ch == '"')
 507                 {
 508                   UNGET (ch);
 509                   if (scrub_m68k_mri)
 510                     out_string = "\n\tappfile ";
 511                   else
 512                     out_string = "\n\t.appfile ";
 513                   old_state = 7;
 514                   state = -1;
 515                   PUT (*out_string++);
 516                 }
 517               else
 518                 {
 519                   while (ch != EOF && ch != '\n')
 520                     ch = GET ();
 521                   state = 0;
 522                   PUT (ch);
 523                 }
 524             }
 525           continue;
 526
 527         case 5:
 528           /* We are going to copy everything up to a quote character,
 529              with special handling for a backslash.  We try to
 530              optimize the copying in the simple case without using the
 531              GET and PUT macros.  */
 532           {
 533             char *s;
 534             int len;
 535
 536             for (s = from; s < fromend; s++)
 537               {
 538                 ch = *s;
 539                 /* This condition must be changed if the type of any
 540                    other character can be LEX_IS_STRINGQUOTE.  */
 541                 if (ch == '\\'
 542                     || ch == '"'
 543                     || ch == '\''
 544                     || ch == '\n')
 545                   break;
 546               }
 547             len = s - from;
 548             if (len > toend - to)
 549               len = toend - to;
 550             if (len > 0)
 551               {
 552                 memcpy (to, from, len);
 553                 to += len;
 554                 from += len;
 555               }
 556           }
 557
 558           ch = GET ();
 559           if (ch == EOF)
 560             {
 561               as_warn (_("end of file in string; inserted '\"'"));
 562               state = old_state;
 563               UNGET ('\n');
 564               PUT ('"');
 565             }
 566           else if (lex[ch] == LEX_IS_STRINGQUOTE)
 567             {
 568               state = old_state;
 569               PUT (ch);
 570             }
 571 #ifndef NO_STRING_ESCAPES
 572           else if (ch == '\\')
 573             {
 574               state = 6;
 575               PUT (ch);
 576             }
 577 #endif
 578           else if (scrub_m68k_mri && ch == '\n')
 579             {
 580               /* Just quietly terminate the string.  This permits lines like
 581                    bne  label   loop if we haven't reach end yet.  */
 582               state = old_state;
 583               UNGET (ch);
 584               PUT ('\'');
 585             }
 586           else
 587             {
 588               PUT (ch);
 589             }
 590           continue;
 591
 592         case 6:
 593           state = 5;
 594           ch = GET ();
 595           switch (ch)
 596             {
 597               /* Handle strings broken across lines, by turning '\n' into
 598                  '\\' and 'n'.  */
 599             case '\n':
 600               UNGET ('n');
 601               add_newlines++;
 602               PUT ('\\');
 603               continue;
 604
 605             case EOF:
 606               as_warn (_("end of file in string; '\"' inserted"));
 607               PUT ('"');
 608               continue;
 609
 610             case '"':
 611             case '\\':
 612             case 'b':
 613             case 'f':
 614             case 'n':
 615             case 'r':
 616             case 't':
 617             case 'v':
 618             case 'x':
 619             case 'X':
 620             case '0':
 621             case '1':
 622             case '2':
 623             case '3':
 624             case '4':
 625             case '5':
 626             case '6':
 627             case '7':
 628               break;
 629
 630             default:
 631 #ifdef ONLY_STANDARD_ESCAPES
 632               as_warn (_("unknown escape '\\%c' in string; ignored"), ch);
 633 #endif
 634               break;
 635             }
 636           PUT (ch);
 637           continue;
 638
 639         case 7:
 640           ch = GET ();
 641           state = 5;
 642           old_state = 8;
 643           if (ch == EOF)
 644             goto fromeof;
 645           PUT (ch);
 646           continue;
 647
 648         case 8:
 649           do
 650             ch = GET ();
 651           while (ch != '\n' && ch != EOF);
 652           if (ch == EOF)
 653             goto fromeof;
 654           state = 0;
 655           PUT (ch);
 656           continue;
 657
 658 #ifdef DOUBLEBAR_PARALLEL
 659         case 13:
 660           ch = GET ();
 661           if (ch != '|')
 662             abort ();
 663
 664           /* Reset back to state 1 and pretend that we are parsing a
 665              line from just after the first white space.  */
 666           state = 1;
 667           PUT ('|');
 668           continue;
 669 #endif
 670         }
 671
 672       /* OK, we are somewhere in states 0 through 4 or 9 through 11.  */
 673
 674       /* flushchar: */
 675       ch = GET ();
 676
 677     recycle:
 678
 679 #if defined TC_ARM && defined OBJ_ELF
 680       /* We need to watch out for .symver directives.  See the comment later
 681          in this function.  */
 682       if (symver_state == NULL)
 683         {
 684           if ((state == 0 || state == 1) && ch == symver_pseudo[0])
 685             symver_state = symver_pseudo + 1;
 686         }
 687       else
 688         {
 689           /* We advance to the next state if we find the right
 690              character.  */
 691           if (ch != '\0' && (*symver_state == ch))
 692             ++symver_state;
 693           else if (*symver_state != '\0')
 694             /* We did not get the expected character, or we didn't
 695                get a valid terminating character after seeing the
 696                entire pseudo-op, so we must go back to the beginning.  */
 697             symver_state = NULL;
 698           else
 699             {
 700               /* We've read the entire pseudo-op.  If this is the end
 701                  of the line, go back to the beginning.  */
 702               if (IS_NEWLINE (ch))
 703                 symver_state = NULL;
 704             }
 705         }
 706 #endif /* TC_ARM && OBJ_ELF */
 707
 708 #ifdef TC_M68K
 709       /* We want to have pseudo-ops which control whether we are in
 710          MRI mode or not.  Unfortunately, since m68k MRI mode affects
 711          the scrubber, that means that we need a special purpose
 712          recognizer here.  */
 713       if (mri_state == NULL)
 714         {
 715           if ((state == 0 || state == 1)
 716               && ch == mri_pseudo[0])
 717             mri_state = mri_pseudo + 1;
 718         }
 719       else
 720         {
 721           /* We advance to the next state if we find the right
 722              character, or if we need a space character and we get any
 723              whitespace character, or if we need a '0' and we get a
 724              '1' (this is so that we only need one state to handle
 725              ``.mri 0'' and ``.mri 1'').  */
 726           if (ch != '\0'
 727               && (*mri_state == ch
 728                   || (*mri_state == ' '
 729                       && lex[ch] == LEX_IS_WHITESPACE)
 730                   || (*mri_state == '0'
 731                       && ch == '1')))
 732             {
 733               mri_last_ch = ch;
 734               ++mri_state;
 735             }
 736           else if (*mri_state != '\0'
 737                    || (lex[ch] != LEX_IS_WHITESPACE
 738                        && lex[ch] != LEX_IS_NEWLINE))
 739             {
 740               /* We did not get the expected character, or we didn't
 741                  get a valid terminating character after seeing the
 742                  entire pseudo-op, so we must go back to the
 743                  beginning.  */
 744               mri_state = NULL;
 745             }
 746           else
 747             {
 748               /* We've read the entire pseudo-op.  mips_last_ch is
 749                  either '0' or '1' indicating whether to enter or
 750                  leave MRI mode.  */
 751               do_scrub_begin (mri_last_ch == '1');
 752               mri_state = NULL;
 753
 754               /* We continue handling the character as usual.  The
 755                  main gas reader must also handle the .mri pseudo-op
 756                  to control expression parsing and the like.  */
 757             }
 758         }
 759 #endif
 760
 761       if (ch == EOF)
 762         {
 763           if (state != 0)
 764             {
 765               as_warn (_("end of file not at end of a line; newline inserted"));
 766               state = 0;
 767               PUT ('\n');
 768             }
 769           goto fromeof;
 770         }
 771
 772       switch (lex[ch])
 773         {
 774         case LEX_IS_WHITESPACE:
 775           do
 776             {
 777               ch = GET ();
 778             }
 779           while (ch != EOF && IS_WHITESPACE (ch));
 780           if (ch == EOF)
 781             goto fromeof;
 782
 783           if (state == 0)
 784             {
 785               /* Preserve a single whitespace character at the
 786                  beginning of a line.  */
 787               state = 1;
 788               UNGET (ch);
 789               PUT (' ');
 790               break;
 791             }
 792
 793 #ifdef KEEP_WHITE_AROUND_COLON
 794           if (lex[ch] == LEX_IS_COLON)
 795             {
 796               /* Only keep this white if there's no white *after* the
 797                  colon.  */
 798               ch2 = GET ();
 799               UNGET (ch2);
 800               if (!IS_WHITESPACE (ch2))
 801                 {
 802                   state = 9;
 803                   UNGET (ch);
 804                   PUT (' ');
 805                   break;
 806                 }
 807             }
 808 #endif
 809           if (IS_COMMENT (ch)
 810               || ch == '/'
 811               || IS_LINE_SEPARATOR (ch)
 812               || IS_PARALLEL_SEPARATOR (ch))
 813             {
 814               if (scrub_m68k_mri)
 815                 {
 816                   /* In MRI mode, we keep these spaces.  */
 817                   UNGET (ch);
 818                   PUT (' ');
 819                   break;
 820                 }
 821               goto recycle;
 822             }
 823
 824           /* If we're in state 2 or 11, we've seen a non-white
 825              character followed by whitespace.  If the next character
 826              is ':', this is whitespace after a label name which we
 827              normally must ignore.  In MRI mode, though, spaces are
 828              not permitted between the label and the colon.  */
 829           if ((state == 2 || state == 11)
 830               && lex[ch] == LEX_IS_COLON
 831               && ! scrub_m68k_mri)
 832             {
 833               state = 1;
 834               PUT (ch);
 835               break;
 836             }
 837
 838           switch (state)
 839             {
 840             case 0:
 841               state++;
 842               goto recycle;     /* Punted leading sp */
 843             case 1:
 844               /* We can arrive here if we leave a leading whitespace
 845                  character at the beginning of a line.  */
 846               goto recycle;
 847             case 2:
 848               state = 3;
 849               if (to + 1 < toend)
 850                 {
 851                   /* Optimize common case by skipping UNGET/GET.  */
 852                   PUT (' ');    /* Sp after opco */
 853                   goto recycle;
 854                 }
 855               UNGET (ch);
 856               PUT (' ');
 857               break;
 858             case 3:
 859               if (scrub_m68k_mri)
 860                 {
 861                   /* In MRI mode, we keep these spaces.  */
 862                   UNGET (ch);
 863                   PUT (' ');
 864                   break;
 865                 }
 866               goto recycle;     /* Sp in operands */
 867             case 9:
 868             case 10:
 869               if (scrub_m68k_mri)
 870                 {
 871                   /* In MRI mode, we keep these spaces.  */
 872                   state = 3;
 873                   UNGET (ch);
 874                   PUT (' ');
 875                   break;
 876                 }
 877               state = 10;       /* Sp after symbol char */
 878               goto recycle;
 879             case 11:
 880               if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
 881                 state = 1;
 882               else
 883                 {
 884                   /* We know that ch is not ':', since we tested that
 885                      case above.  Therefore this is not a label, so it
 886                      must be the opcode, and we've just seen the
 887                      whitespace after it.  */
 888                   state = 3;
 889                 }
 890               UNGET (ch);
 891               PUT (' ');        /* Sp after label definition.  */
 892               break;
 893             default:
 894               BAD_CASE (state);
 895             }
 896           break;
 897
 898         case LEX_IS_TWOCHAR_COMMENT_1ST:
 899           ch2 = GET ();
 900           if (ch2 == '*')
 901             {
 902               for (;;)
 903                 {
 904                   do
 905                     {
 906                       ch2 = GET ();
 907                       if (ch2 != EOF && IS_NEWLINE (ch2))
 908                         add_newlines++;
 909                     }
 910                   while (ch2 != EOF && ch2 != '*');
 911
 912                   while (ch2 == '*')
 913                     ch2 = GET ();
 914
 915                   if (ch2 == EOF || ch2 == '/')
 916                     break;
 917
 918                   /* This UNGET will ensure that we count newlines
 919                      correctly.  */
 920                   UNGET (ch2);
 921                 }
 922
 923               if (ch2 == EOF)
 924                 as_warn (_("end of file in multiline comment"));
 925
 926               ch = ' ';
 927               goto recycle;
 928             }
 929 #ifdef DOUBLESLASH_LINE_COMMENTS
 930           else if (ch2 == '/')
 931             {
 932               do
 933                 {
 934                   ch = GET ();
 935                 }
 936               while (ch != EOF && !IS_NEWLINE (ch));
 937               if (ch == EOF)
 938                 as_warn ("end of file in comment; newline inserted");
 939               state = 0;
 940               PUT ('\n');
 941               break;
 942             }
 943 #endif
 944           else
 945             {
 946               if (ch2 != EOF)
 947                 UNGET (ch2);
 948               if (state == 9 || state == 10)
 949                 state = 3;
 950               PUT (ch);
 951             }
 952           break;
 953
 954         case LEX_IS_STRINGQUOTE:
 955           if (state == 10)
 956             {
 957               /* Preserve the whitespace in foo "bar".  */
 958               UNGET (ch);
 959               state = 3;
 960               PUT (' ');
 961
 962               /* PUT didn't jump out.  We could just break, but we
 963                  know what will happen, so optimize a bit.  */
 964               ch = GET ();
 965               old_state = 3;
 966             }
 967           else if (state == 9)
 968             old_state = 3;
 969           else
 970             old_state = state;
 971           state = 5;
 972           PUT (ch);
 973           break;
 974
 975 #ifndef IEEE_STYLE
 976         case LEX_IS_ONECHAR_QUOTE:
 977           if (state == 10)
 978             {
 979               /* Preserve the whitespace in foo 'b'.  */
 980               UNGET (ch);
 981               state = 3;
 982               PUT (' ');
 983               break;
 984             }
 985           ch = GET ();
 986           if (ch == EOF)
 987             {
 988               as_warn (_("end of file after a one-character quote; \\0 inserted"));
 989               ch = 0;
 990             }
 991           if (ch == '\\')
 992             {
 993               ch = GET ();
 994               if (ch == EOF)
 995                 {
 996                   as_warn (_("end of file in escape character"));
 997                   ch = '\\';
 998                 }
 999               else
1000                 ch = process_escape (ch);
1001             }
1002           sprintf (out_buf, "%d", (int) (unsigned char) ch);
1003
1004           /* None of these 'x constants for us.  We want 'x'.  */
1005           if ((ch = GET ()) != '\'')
1006             {
1007 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
1008               as_warn (_("missing close quote; (assumed)"));
1009 #else
1010               if (ch != EOF)
1011                 UNGET (ch);
1012 #endif
1013             }
1014           if (strlen (out_buf) == 1)
1015             {
1016               PUT (out_buf[0]);
1017               break;
1018             }
1019           if (state == 9)
1020             old_state = 3;
1021           else
1022             old_state = state;
1023           state = -1;
1024           out_string = out_buf;
1025           PUT (*out_string++);
1026           break;
1027 #endif
1028
1029         case LEX_IS_COLON:
1030 #ifdef KEEP_WHITE_AROUND_COLON
1031           state = 9;
1032 #else
1033           if (state == 9 || state == 10)
1034             state = 3;
1035           else if (state != 3)
1036             state = 1;
1037 #endif
1038           PUT (ch);
1039           break;
1040
1041         case LEX_IS_NEWLINE:
1042           /* Roll out a bunch of newlines from inside comments, etc.  */
1043           if (add_newlines)
1044             {
1045               --add_newlines;
1046               UNGET (ch);
1047             }
1048           /* Fall through.  */
1049
1050         case LEX_IS_LINE_SEPARATOR:
1051           state = 0;
1052           PUT (ch);
1053           break;
1054
1055         case LEX_IS_PARALLEL_SEPARATOR:
1056           state = 1;
1057           PUT (ch);
1058           break;
1059
1060 #ifdef TC_V850
1061         case LEX_IS_DOUBLEDASH_1ST:
1062           ch2 = GET ();
1063           if (ch2 != '-')
1064             {
1065               UNGET (ch2);
1066               goto de_fault;
1067             }
1068           /* Read and skip to end of line.  */
1069           do
1070             {
1071               ch = GET ();
1072             }
1073           while (ch != EOF && ch != '\n');
1074
1075           if (ch == EOF)
1076             as_warn (_("end of file in comment; newline inserted"));
1077
1078           state = 0;
1079           PUT ('\n');
1080           break;
1081 #endif
1082 #ifdef DOUBLEBAR_PARALLEL
1083         case LEX_IS_DOUBLEBAR_1ST:
1084           ch2 = GET ();
1085           UNGET (ch2);
1086           if (ch2 != '|')
1087             goto de_fault;
1088
1089           /* Handle '||' in two states as invoking PUT twice might
1090              result in the first one jumping out of this loop.  We'd
1091              then lose track of the state and one '|' char.  */
1092           state = 13;
1093           PUT ('|');
1094           break;
1095 #endif
1096         case LEX_IS_LINE_COMMENT_START:
1097           /* FIXME-someday: The two character comment stuff was badly
1098              thought out.  On i386, we want '/' as line comment start
1099              AND we want C style comments.  hence this hack.  The
1100              whole lexical process should be reworked.  xoxorich.  */
1101           if (ch == '/')
1102             {
1103               ch2 = GET ();
1104               if (ch2 == '*')
1105                 {
1106                   old_state = 3;
1107                   state = -2;
1108                   break;
1109                 }
1110               else
1111                 {
1112                   UNGET (ch2);
1113                 }
1114             }
1115
1116           if (state == 0 || state == 1) /* Only comment at start of line.  */
1117             {
1118               int startch;
1119
1120               startch = ch;
1121
1122               do
1123                 {
1124                   ch = GET ();
1125                 }
1126               while (ch != EOF && IS_WHITESPACE (ch));
1127
1128               if (ch == EOF)
1129                 {
1130                   as_warn (_("end of file in comment; newline inserted"));
1131                   PUT ('\n');
1132                   break;
1133                 }
1134
1135               if (ch < '0' || ch > '9' || state != 0 || startch != '#')
1136                 {
1137                   /* Not a cpp line.  */
1138                   while (ch != EOF && !IS_NEWLINE (ch))
1139                     ch = GET ();
1140                   if (ch == EOF)
1141                     as_warn (_("end of file in comment; newline inserted"));
1142                   state = 0;
1143                   PUT ('\n');
1144                   break;
1145                 }
1146               /* Looks like `# 123 "filename"' from cpp.  */
1147               UNGET (ch);
1148               old_state = 4;
1149               state = -1;
1150               if (scrub_m68k_mri)
1151                 out_string = "\tappline ";
1152               else
1153                 out_string = "\t.appline ";
1154               PUT (*out_string++);
1155               break;
1156             }
1157
1158 #ifdef TC_D10V
1159           /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true.
1160              Trap is the only short insn that has a first operand that is
1161              neither register nor label.
1162              We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 .
1163              We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is
1164              already LEX_IS_LINE_COMMENT_START.  However, it is the
1165              only character in line_comment_chars for d10v, hence we
1166              can recognize it as such.  */
1167           /* An alternative approach would be to reset the state to 1 when
1168              we see '||', '<'- or '->', but that seems to be overkill.  */
1169           if (state == 10)
1170             PUT (' ');
1171 #endif
1172           /* We have a line comment character which is not at the
1173              start of a line.  If this is also a normal comment
1174              character, fall through.  Otherwise treat it as a default
1175              character.  */
1176           if (strchr (tc_comment_chars, ch) == NULL
1177               && (! scrub_m68k_mri
1178                   || (ch != '!' && ch != '*')))
1179             goto de_fault;
1180           if (scrub_m68k_mri
1181               && (ch == '!' || ch == '*' || ch == '#')
1182               && state != 1
1183               && state != 10)
1184             goto de_fault;
1185           /* Fall through.  */
1186         case LEX_IS_COMMENT_START:
1187 #if defined TC_ARM && defined OBJ_ELF
1188           /* On the ARM, `@' is the comment character.
1189              Unfortunately this is also a special character in ELF .symver
1190              directives (and .type, though we deal with those another way).
1191              So we check if this line is such a directive, and treat
1192              the character as default if so.  This is a hack.  */
1193           if ((symver_state != NULL) && (*symver_state == 0))
1194             goto de_fault;
1195 #endif
1196 #ifdef WARN_COMMENTS
1197           if (!found_comment)
1198             as_where (&found_comment_file, &found_comment);
1199 #endif
1200           do
1201             {
1202               ch = GET ();
1203             }
1204           while (ch != EOF && !IS_NEWLINE (ch));
1205           if (ch == EOF)
1206             as_warn (_("end of file in comment; newline inserted"));
1207           state = 0;
1208           PUT ('\n');
1209           break;
1210
1211         case LEX_IS_SYMBOL_COMPONENT:
1212           if (state == 10)
1213             {
1214               /* This is a symbol character following another symbol
1215                  character, with whitespace in between.  We skipped
1216                  the whitespace earlier, so output it now.  */
1217               UNGET (ch);
1218               state = 3;
1219               PUT (' ');
1220               break;
1221             }
1222
1223           if (state == 3)
1224             state = 9;
1225
1226           /* This is a common case.  Quickly copy CH and all the
1227              following symbol component or normal characters.  */
1228           if (to + 1 < toend
1229               && mri_state == NULL
1230 #if defined TC_ARM && defined OBJ_ELF
1231               && symver_state == NULL
1232 #endif
1233               )
1234             {
1235               char *s;
1236               int len;
1237
1238               for (s = from; s < fromend; s++)
1239                 {
1240                   int type;
1241
1242                   ch2 = *(unsigned char *) s;
1243                   type = lex[ch2];
1244                   if (type != 0
1245                       && type != LEX_IS_SYMBOL_COMPONENT)
1246                     break;
1247                 }
1248
1249               if (s > from)
1250                 /* Handle the last character normally, for
1251                    simplicity.  */
1252                 --s;
1253
1254               len = s - from;
1255
1256               if (len > (toend - to) - 1)
1257                 len = (toend - to) - 1;
1258
1259               if (len > 0)
1260                 {
1261                   PUT (ch);
1262                   if (len > 8)
1263                     {
1264                       memcpy (to, from, len);
1265                       to += len;
1266                       from += len;
1267                     }
1268                   else
1269                     {
1270                       switch (len)
1271                         {
1272                         case 8: *to++ = *from++;
1273                         case 7: *to++ = *from++;
1274                         case 6: *to++ = *from++;
1275                         case 5: *to++ = *from++;
1276                         case 4: *to++ = *from++;
1277                         case 3: *to++ = *from++;
1278                         case 2: *to++ = *from++;
1279                         case 1: *to++ = *from++;
1280                         }
1281                     }
1282                   ch = GET ();
1283                 }
1284             }
1285
1286           /* Fall through.  */
1287         default:
1288         de_fault:
1289           /* Some relatively `normal' character.  */
1290           if (state == 0)
1291             {
1292               state = 11;       /* Now seeing label definition.  */
1293             }
1294           else if (state == 1)
1295             {
1296               state = 2;        /* Ditto.  */
1297             }
1298           else if (state == 9)
1299             {
1300               if (lex[ch] != LEX_IS_SYMBOL_COMPONENT)
1301                 state = 3;
1302             }
1303           else if (state == 10)
1304             {
1305               if (ch == '\\')
1306                 {
1307                   /* Special handling for backslash: a backslash may
1308                      be the beginning of a formal parameter (of a
1309                      macro) following another symbol character, with
1310                      whitespace in between.  If that is the case, we
1311                      output a space before the parameter.  Strictly
1312                      speaking, correct handling depends upon what the
1313                      macro parameter expands into; if the parameter
1314                      expands into something which does not start with
1315                      an operand character, then we don't want to keep
1316                      the space.  We don't have enough information to
1317                      make the right choice, so here we are making the
1318                      choice which is more likely to be correct.  */
1319                   PUT (' ');
1320                 }
1321
1322               state = 3;
1323             }
1324           PUT (ch);
1325           break;
1326         }
1327     }
1328
1329   /*NOTREACHED*/
1330
1331  fromeof:
1332   /* We have reached the end of the input.  */
1333   return to - tostart;
1334
1335  tofull:
1336   /* The output buffer is full.  Save any input we have not yet
1337      processed.  */
1338   if (fromend > from)
1339     {
1340       saved_input = from;
1341       saved_input_len = fromend - from;
1342     }
1343   else
1344     saved_input = NULL;
1345
1346   return to - tostart;
1347 }
1348