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