contrib/binutils-2.20/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
   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_IA64
 388          14: After seeing a `(' at state 0, looking for a `)' as
 389              predicate.
 390          15: After seeing a `(' at state 1, looking for a `)' as
 391              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           continue;
 671 #endif
 672 #ifdef TC_Z80
 673         case 16:
 674           /* We have seen an 'a' at the start of a symbol, look for an 'f'.  */
 675           ch = GET ();
 676           if (ch == 'f' || ch == 'F')
 677             {
 678               state = 17;
 679               PUT (ch);
 680             }
 681           else
 682             {
 683               state = 9;
 684               break;
 685             }
 686         case 17:
 687           /* We have seen "af" at the start of a symbol,
 688              a ' here is a part of that symbol.  */
 689           ch = GET ();
 690           state = 9;
 691           if (ch == '\'')
 692             /* Change to avoid warning about unclosed string.  */
 693             PUT ('`');
 694           else if (ch != EOF)
 695             UNGET (ch);
 696           break;
 697 #endif
 698         }
 699
 700       /* OK, we are somewhere in states 0 through 4 or 9 through 11.  */
 701
 702       /* flushchar: */
 703       ch = GET ();
 704
 705 #ifdef TC_IA64
 706       if (ch == '(' && (state == 0 || state == 1))
 707         {
 708           state += 14;
 709           PUT (ch);
 710           continue;
 711         }
 712       else if (state == 14 || state == 15)
 713         {
 714           if (ch == ')')
 715             {
 716               state -= 14;
 717               PUT (ch);
 718               ch = GET ();
 719             }
 720           else
 721             {
 722               PUT (ch);
 723               continue;
 724             }
 725         }
 726 #endif
 727
 728     recycle:
 729
 730 #if defined TC_ARM && defined OBJ_ELF
 731       /* We need to watch out for .symver directives.  See the comment later
 732          in this function.  */
 733       if (symver_state == NULL)
 734         {
 735           if ((state == 0 || state == 1) && ch == symver_pseudo[0])
 736             symver_state = symver_pseudo + 1;
 737         }
 738       else
 739         {
 740           /* We advance to the next state if we find the right
 741              character.  */
 742           if (ch != '\0' && (*symver_state == ch))
 743             ++symver_state;
 744           else if (*symver_state != '\0')
 745             /* We did not get the expected character, or we didn't
 746                get a valid terminating character after seeing the
 747                entire pseudo-op, so we must go back to the beginning.  */
 748             symver_state = NULL;
 749           else
 750             {
 751               /* We've read the entire pseudo-op.  If this is the end
 752                  of the line, go back to the beginning.  */
 753               if (IS_NEWLINE (ch))
 754                 symver_state = NULL;
 755             }
 756         }
 757 #endif /* TC_ARM && OBJ_ELF */
 758
 759 #ifdef TC_M68K
 760       /* We want to have pseudo-ops which control whether we are in
 761          MRI mode or not.  Unfortunately, since m68k MRI mode affects
 762          the scrubber, that means that we need a special purpose
 763          recognizer here.  */
 764       if (mri_state == NULL)
 765         {
 766           if ((state == 0 || state == 1)
 767               && ch == mri_pseudo[0])
 768             mri_state = mri_pseudo + 1;
 769         }
 770       else
 771         {
 772           /* We advance to the next state if we find the right
 773              character, or if we need a space character and we get any
 774              whitespace character, or if we need a '0' and we get a
 775              '1' (this is so that we only need one state to handle
 776              ``.mri 0'' and ``.mri 1'').  */
 777           if (ch != '\0'
 778               && (*mri_state == ch
 779                   || (*mri_state == ' '
 780                       && lex[ch] == LEX_IS_WHITESPACE)
 781                   || (*mri_state == '0'
 782                       && ch == '1')))
 783             {
 784               mri_last_ch = ch;
 785               ++mri_state;
 786             }
 787           else if (*mri_state != '\0'
 788                    || (lex[ch] != LEX_IS_WHITESPACE
 789                        && lex[ch] != LEX_IS_NEWLINE))
 790             {
 791               /* We did not get the expected character, or we didn't
 792                  get a valid terminating character after seeing the
 793                  entire pseudo-op, so we must go back to the
 794                  beginning.  */
 795               mri_state = NULL;
 796             }
 797           else
 798             {
 799               /* We've read the entire pseudo-op.  mips_last_ch is
 800                  either '0' or '1' indicating whether to enter or
 801                  leave MRI mode.  */
 802               do_scrub_begin (mri_last_ch == '1');
 803               mri_state = NULL;
 804
 805               /* We continue handling the character as usual.  The
 806                  main gas reader must also handle the .mri pseudo-op
 807                  to control expression parsing and the like.  */
 808             }
 809         }
 810 #endif
 811
 812       if (ch == EOF)
 813         {
 814           if (state != 0)
 815             {
 816               as_warn (_("end of file not at end of a line; newline inserted"));
 817               state = 0;
 818               PUT ('\n');
 819             }
 820           goto fromeof;
 821         }
 822
 823       switch (lex[ch])
 824         {
 825         case LEX_IS_WHITESPACE:
 826           do
 827             {
 828               ch = GET ();
 829             }
 830           while (ch != EOF && IS_WHITESPACE (ch));
 831           if (ch == EOF)
 832             goto fromeof;
 833
 834           if (state == 0)
 835             {
 836               /* Preserve a single whitespace character at the
 837                  beginning of a line.  */
 838               state = 1;
 839               UNGET (ch);
 840               PUT (' ');
 841               break;
 842             }
 843
 844 #ifdef KEEP_WHITE_AROUND_COLON
 845           if (lex[ch] == LEX_IS_COLON)
 846             {
 847               /* Only keep this white if there's no white *after* the
 848                  colon.  */
 849               ch2 = GET ();
 850               if (ch2 != EOF)
 851                 UNGET (ch2);
 852               if (!IS_WHITESPACE (ch2))
 853                 {
 854                   state = 9;
 855                   UNGET (ch);
 856                   PUT (' ');
 857                   break;
 858                 }
 859             }
 860 #endif
 861           if (IS_COMMENT (ch)
 862               || ch == '/'
 863               || IS_LINE_SEPARATOR (ch)
 864               || IS_PARALLEL_SEPARATOR (ch))
 865             {
 866               if (scrub_m68k_mri)
 867                 {
 868                   /* In MRI mode, we keep these spaces.  */
 869                   UNGET (ch);
 870                   PUT (' ');
 871                   break;
 872                 }
 873               goto recycle;
 874             }
 875
 876           /* If we're in state 2 or 11, we've seen a non-white
 877              character followed by whitespace.  If the next character
 878              is ':', this is whitespace after a label name which we
 879              normally must ignore.  In MRI mode, though, spaces are
 880              not permitted between the label and the colon.  */
 881           if ((state == 2 || state == 11)
 882               && lex[ch] == LEX_IS_COLON
 883               && ! scrub_m68k_mri)
 884             {
 885               state = 1;
 886               PUT (ch);
 887               break;
 888             }
 889
 890           switch (state)
 891             {
 892             case 1:
 893               /* We can arrive here if we leave a leading whitespace
 894                  character at the beginning of a line.  */
 895               goto recycle;
 896             case 2:
 897               state = 3;
 898               if (to + 1 < toend)
 899                 {
 900                   /* Optimize common case by skipping UNGET/GET.  */
 901                   PUT (' ');    /* Sp after opco */
 902                   goto recycle;
 903                 }
 904               UNGET (ch);
 905               PUT (' ');
 906               break;
 907             case 3:
 908               if (scrub_m68k_mri)
 909                 {
 910                   /* In MRI mode, we keep these spaces.  */
 911                   UNGET (ch);
 912                   PUT (' ');
 913                   break;
 914                 }
 915               goto recycle;     /* Sp in operands */
 916             case 9:
 917             case 10:
 918               if (scrub_m68k_mri)
 919                 {
 920                   /* In MRI mode, we keep these spaces.  */
 921                   state = 3;
 922                   UNGET (ch);
 923                   PUT (' ');
 924                   break;
 925                 }
 926               state = 10;       /* Sp after symbol char */
 927               goto recycle;
 928             case 11:
 929               if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
 930                 state = 1;
 931               else
 932                 {
 933                   /* We know that ch is not ':', since we tested that
 934                      case above.  Therefore this is not a label, so it
 935                      must be the opcode, and we've just seen the
 936                      whitespace after it.  */
 937                   state = 3;
 938                 }
 939               UNGET (ch);
 940               PUT (' ');        /* Sp after label definition.  */
 941               break;
 942             default:
 943               BAD_CASE (state);
 944             }
 945           break;
 946
 947         case LEX_IS_TWOCHAR_COMMENT_1ST:
 948           ch2 = GET ();
 949           if (ch2 == '*')
 950             {
 951               for (;;)
 952                 {
 953                   do
 954                     {
 955                       ch2 = GET ();
 956                       if (ch2 != EOF && IS_NEWLINE (ch2))
 957                         add_newlines++;
 958                     }
 959                   while (ch2 != EOF && ch2 != '*');
 960
 961                   while (ch2 == '*')
 962                     ch2 = GET ();
 963
 964                   if (ch2 == EOF || ch2 == '/')
 965                     break;
 966
 967                   /* This UNGET will ensure that we count newlines
 968                      correctly.  */
 969                   UNGET (ch2);
 970                 }
 971
 972               if (ch2 == EOF)
 973                 as_warn (_("end of file in multiline comment"));
 974
 975               ch = ' ';
 976               goto recycle;
 977             }
 978 #ifdef DOUBLESLASH_LINE_COMMENTS
 979           else if (ch2 == '/')
 980             {
 981               do
 982                 {
 983                   ch = GET ();
 984                 }
 985               while (ch != EOF && !IS_NEWLINE (ch));
 986               if (ch == EOF)
 987                 as_warn ("end of file in comment; newline inserted");
 988               state = 0;
 989               PUT ('\n');
 990               break;
 991             }
 992 #endif
 993           else
 994             {
 995               if (ch2 != EOF)
 996                 UNGET (ch2);
 997               if (state == 9 || state == 10)
 998                 state = 3;
 999               PUT (ch);
1000             }
1001           break;
1002
1003         case LEX_IS_STRINGQUOTE:
1004           quotechar = ch;
1005           if (state == 10)
1006             {
1007               /* Preserve the whitespace in foo "bar".  */
1008               UNGET (ch);
1009               state = 3;
1010               PUT (' ');
1011
1012               /* PUT didn't jump out.  We could just break, but we
1013                  know what will happen, so optimize a bit.  */
1014               ch = GET ();
1015               old_state = 3;
1016             }
1017           else if (state == 9)
1018             old_state = 3;
1019           else
1020             old_state = state;
1021           state = 5;
1022           PUT (ch);
1023           break;
1024
1025 #ifndef IEEE_STYLE
1026         case LEX_IS_ONECHAR_QUOTE:
1027 #ifdef H_TICK_HEX
1028           if (state == 9 && enable_h_tick_hex)
1029             {
1030               char c;
1031
1032               c = GET ();
1033               as_warn ("'%c found after symbol", c);
1034               UNGET (c);
1035             }
1036 #endif
1037           if (state == 10)
1038             {
1039               /* Preserve the whitespace in foo 'b'.  */
1040               UNGET (ch);
1041               state = 3;
1042               PUT (' ');
1043               break;
1044             }
1045           ch = GET ();
1046           if (ch == EOF)
1047             {
1048               as_warn (_("end of file after a one-character quote; \\0 inserted"));
1049               ch = 0;
1050             }
1051           if (ch == '\\')
1052             {
1053               ch = GET ();
1054               if (ch == EOF)
1055                 {
1056                   as_warn (_("end of file in escape character"));
1057                   ch = '\\';
1058                 }
1059               else
1060                 ch = process_escape (ch);
1061             }
1062           sprintf (out_buf, "%d", (int) (unsigned char) ch);
1063
1064           /* None of these 'x constants for us.  We want 'x'.  */
1065           if ((ch = GET ()) != '\'')
1066             {
1067 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
1068               as_warn (_("missing close quote; (assumed)"));
1069 #else
1070               if (ch != EOF)
1071                 UNGET (ch);
1072 #endif
1073             }
1074           if (strlen (out_buf) == 1)
1075             {
1076               PUT (out_buf[0]);
1077               break;
1078             }
1079           if (state == 9)
1080             old_state = 3;
1081           else
1082             old_state = state;
1083           state = -1;
1084           out_string = out_buf;
1085           PUT (*out_string++);
1086           break;
1087 #endif
1088
1089         case LEX_IS_COLON:
1090 #ifdef KEEP_WHITE_AROUND_COLON
1091           state = 9;
1092 #else
1093           if (state == 9 || state == 10)
1094             state = 3;
1095           else if (state != 3)
1096             state = 1;
1097 #endif
1098           PUT (ch);
1099           break;
1100
1101         case LEX_IS_NEWLINE:
1102           /* Roll out a bunch of newlines from inside comments, etc.  */
1103           if (add_newlines)
1104             {
1105               --add_newlines;
1106               UNGET (ch);
1107             }
1108           /* Fall through.  */
1109
1110         case LEX_IS_LINE_SEPARATOR:
1111           state = 0;
1112           PUT (ch);
1113           break;
1114
1115         case LEX_IS_PARALLEL_SEPARATOR:
1116           state = 1;
1117           PUT (ch);
1118           break;
1119
1120 #ifdef TC_V850
1121         case LEX_IS_DOUBLEDASH_1ST:
1122           ch2 = GET ();
1123           if (ch2 != '-')
1124             {
1125               if (ch2 != EOF)
1126                 UNGET (ch2);
1127               goto de_fault;
1128             }
1129           /* Read and skip to end of line.  */
1130           do
1131             {
1132               ch = GET ();
1133             }
1134           while (ch != EOF && ch != '\n');
1135
1136           if (ch == EOF)
1137             as_warn (_("end of file in comment; newline inserted"));
1138
1139           state = 0;
1140           PUT ('\n');
1141           break;
1142 #endif
1143 #ifdef DOUBLEBAR_PARALLEL
1144         case LEX_IS_DOUBLEBAR_1ST:
1145           ch2 = GET ();
1146           if (ch2 != EOF)
1147             UNGET (ch2);
1148           if (ch2 != '|')
1149             goto de_fault;
1150
1151           /* Handle '||' in two states as invoking PUT twice might
1152              result in the first one jumping out of this loop.  We'd
1153              then lose track of the state and one '|' char.  */
1154           state = 13;
1155           PUT ('|');
1156           break;
1157 #endif
1158         case LEX_IS_LINE_COMMENT_START:
1159           /* FIXME-someday: The two character comment stuff was badly
1160              thought out.  On i386, we want '/' as line comment start
1161              AND we want C style comments.  hence this hack.  The
1162              whole lexical process should be reworked.  xoxorich.  */
1163           if (ch == '/')
1164             {
1165               ch2 = GET ();
1166               if (ch2 == '*')
1167                 {
1168                   old_state = 3;
1169                   state = -2;
1170                   break;
1171                 }
1172               else
1173                 {
1174                   UNGET (ch2);
1175                 }
1176             }
1177
1178           if (state == 0 || state == 1) /* Only comment at start of line.  */
1179             {
1180               int startch;
1181
1182               startch = ch;
1183
1184               do
1185                 {
1186                   ch = GET ();
1187                 }
1188               while (ch != EOF && IS_WHITESPACE (ch));
1189
1190               if (ch == EOF)
1191                 {
1192                   as_warn (_("end of file in comment; newline inserted"));
1193                   PUT ('\n');
1194                   break;
1195                 }
1196
1197               if (ch < '0' || ch > '9' || state != 0 || startch != '#')
1198                 {
1199                   /* Not a cpp line.  */
1200                   while (ch != EOF && !IS_NEWLINE (ch))
1201                     ch = GET ();
1202                   if (ch == EOF)
1203                     as_warn (_("end of file in comment; newline inserted"));
1204                   state = 0;
1205                   PUT ('\n');
1206                   break;
1207                 }
1208               /* Looks like `# 123 "filename"' from cpp.  */
1209               UNGET (ch);
1210               old_state = 4;
1211               state = -1;
1212               if (scrub_m68k_mri)
1213                 out_string = "\tlinefile ";
1214               else
1215                 out_string = "\t.linefile ";
1216               PUT (*out_string++);
1217               break;
1218             }
1219
1220 #ifdef TC_D10V
1221           /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true.
1222              Trap is the only short insn that has a first operand that is
1223              neither register nor label.
1224              We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 .
1225              We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is
1226              already LEX_IS_LINE_COMMENT_START.  However, it is the
1227              only character in line_comment_chars for d10v, hence we
1228              can recognize it as such.  */
1229           /* An alternative approach would be to reset the state to 1 when
1230              we see '||', '<'- or '->', but that seems to be overkill.  */
1231           if (state == 10)
1232             PUT (' ');
1233 #endif
1234           /* We have a line comment character which is not at the
1235              start of a line.  If this is also a normal comment
1236              character, fall through.  Otherwise treat it as a default
1237              character.  */
1238           if (strchr (tc_comment_chars, ch) == NULL
1239               && (! scrub_m68k_mri
1240                   || (ch != '!' && ch != '*')))
1241             goto de_fault;
1242           if (scrub_m68k_mri
1243               && (ch == '!' || ch == '*' || ch == '#')
1244               && state != 1
1245               && state != 10)
1246             goto de_fault;
1247           /* Fall through.  */
1248         case LEX_IS_COMMENT_START:
1249 #if defined TC_ARM && defined OBJ_ELF
1250           /* On the ARM, `@' is the comment character.
1251              Unfortunately this is also a special character in ELF .symver
1252              directives (and .type, though we deal with those another way).
1253              So we check if this line is such a directive, and treat
1254              the character as default if so.  This is a hack.  */
1255           if ((symver_state != NULL) && (*symver_state == 0))
1256             goto de_fault;
1257 #endif
1258
1259 #ifdef TC_ARM
1260           /* For the ARM, care is needed not to damage occurrences of \@
1261              by stripping the @ onwards.  Yuck.  */
1262           if (to > tostart && *(to - 1) == '\\')
1263             /* Do not treat the @ as a start-of-comment.  */
1264             goto de_fault;
1265 #endif
1266
1267 #ifdef WARN_COMMENTS
1268           if (!found_comment)
1269             as_where (&found_comment_file, &found_comment);
1270 #endif
1271           do
1272             {
1273               ch = GET ();
1274             }
1275           while (ch != EOF && !IS_NEWLINE (ch));
1276           if (ch == EOF)
1277             as_warn (_("end of file in comment; newline inserted"));
1278           state = 0;
1279           PUT ('\n');
1280           break;
1281
1282 #ifdef H_TICK_HEX
1283         case LEX_IS_H:
1284           /* Look for strings like H'[0-9A-Fa-f] and if found, replace
1285              the H' with 0x to make them gas-style hex characters.  */
1286           if (enable_h_tick_hex)
1287             {
1288               char quot;
1289
1290               quot = GET ();
1291               if (quot == '\'')
1292                 {
1293                   UNGET ('x');
1294                   ch = '0';
1295                 }
1296               else
1297                 UNGET (quot);
1298             }
1299           /* FALL THROUGH */
1300 #endif
1301
1302         case LEX_IS_SYMBOL_COMPONENT:
1303           if (state == 10)
1304             {
1305               /* This is a symbol character following another symbol
1306                  character, with whitespace in between.  We skipped
1307                  the whitespace earlier, so output it now.  */
1308               UNGET (ch);
1309               state = 3;
1310               PUT (' ');
1311               break;
1312             }
1313
1314 #ifdef TC_Z80
1315           /* "af'" is a symbol containing '\''.  */
1316           if (state == 3 && (ch == 'a' || ch == 'A'))
1317             {
1318               state = 16;
1319               PUT (ch);
1320               ch = GET ();
1321               if (ch == 'f' || ch == 'F')
1322                 {
1323                   state = 17;
1324                   PUT (ch);
1325                   break;
1326                 }
1327               else
1328                 {
1329                   state = 9;
1330                   if (!IS_SYMBOL_COMPONENT (ch))
1331                     {
1332                       if (ch != EOF)
1333                         UNGET (ch);
1334                       break;
1335                     }
1336                 }
1337             }
1338 #endif
1339           if (state == 3)
1340             state = 9;
1341
1342           /* This is a common case.  Quickly copy CH and all the
1343              following symbol component or normal characters.  */
1344           if (to + 1 < toend
1345               && mri_state == NULL
1346 #if defined TC_ARM && defined OBJ_ELF
1347               && symver_state == NULL
1348 #endif
1349               )
1350             {
1351               char *s;
1352               int len;
1353
1354               for (s = from; s < fromend; s++)
1355                 {
1356                   int type;
1357
1358                   ch2 = *(unsigned char *) s;
1359                   type = lex[ch2];
1360                   if (type != 0
1361                       && type != LEX_IS_SYMBOL_COMPONENT)
1362                     break;
1363                 }
1364
1365               if (s > from)
1366                 /* Handle the last character normally, for
1367                    simplicity.  */
1368                 --s;
1369
1370               len = s - from;
1371
1372               if (len > (toend - to) - 1)
1373                 len = (toend - to) - 1;
1374
1375               if (len > 0)
1376                 {
1377                   PUT (ch);
1378                   memcpy (to, from, len);
1379                   to += len;
1380                   from += len;
1381                   if (to >= toend)
1382                     goto tofull;
1383                   ch = GET ();
1384                 }
1385             }
1386
1387           /* Fall through.  */
1388         default:
1389         de_fault:
1390           /* Some relatively `normal' character.  */
1391           if (state == 0)
1392             {
1393               state = 11;       /* Now seeing label definition.  */
1394             }
1395           else if (state == 1)
1396             {
1397               state = 2;        /* Ditto.  */
1398             }
1399           else if (state == 9)
1400             {
1401               if (!IS_SYMBOL_COMPONENT (ch))
1402                 state = 3;
1403             }
1404           else if (state == 10)
1405             {
1406               if (ch == '\\')
1407                 {
1408                   /* Special handling for backslash: a backslash may
1409                      be the beginning of a formal parameter (of a
1410                      macro) following another symbol character, with
1411                      whitespace in between.  If that is the case, we
1412                      output a space before the parameter.  Strictly
1413                      speaking, correct handling depends upon what the
1414                      macro parameter expands into; if the parameter
1415                      expands into something which does not start with
1416                      an operand character, then we don't want to keep
1417                      the space.  We don't have enough information to
1418                      make the right choice, so here we are making the
1419                      choice which is more likely to be correct.  */
1420                   if (to + 1 >= toend)
1421                     {
1422                       /* If we're near the end of the buffer, save the
1423                          character for the next time round.  Otherwise
1424                          we'll lose our state.  */
1425                       UNGET (ch);
1426                       goto tofull;
1427                     }
1428                   *to++ = ' ';
1429                 }
1430
1431               state = 3;
1432             }
1433           PUT (ch);
1434           break;
1435         }
1436     }
1437
1438   /*NOTREACHED*/
1439
1440  fromeof:
1441   /* We have reached the end of the input.  */
1442   return to - tostart;
1443
1444  tofull:
1445   /* The output buffer is full.  Save any input we have not yet
1446      processed.  */
1447   if (fromend > from)
1448     {
1449       saved_input = from;
1450       saved_input_len = fromend - from;
1451     }
1452   else
1453     saved_input = NULL;
1454
1455   return to - tostart;
1456 }