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