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
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 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 excess
  25    spaces, turns single-quoted characters into a decimal constant, and turns
  26    # <number> <filename> <garbage> into a .line <number>\n.file <filename>
  27    pair.  This needs better error-handling.  */
  28
  29 #include "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 .line, put out digits
 355           5: parsing a string, then go to old-state
 356           6: putting out \ escape in a "d string.
 357           7: After putting out a .appfile, put out string.
 358           8: After putting out a .appfile string, flush until newline.
 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                   UNGET (ch);
 514                   if (scrub_m68k_mri)
 515                     out_string = "\n\tappfile ";
 516                   else
 517                     out_string = "\n\t.appfile ";
 518                   old_state = 7;
 519                   state = -1;
 520                   PUT (*out_string++);
 521                 }
 522               else
 523                 {
 524                   while (ch != EOF && ch != '\n')
 525                     ch = GET ();
 526                   state = 0;
 527                   PUT (ch);
 528                 }
 529             }
 530           continue;
 531
 532         case 5:
 533           /* We are going to copy everything up to a quote character,
 534              with special handling for a backslash.  We try to
 535              optimize the copying in the simple case without using the
 536              GET and PUT macros.  */
 537           {
 538             char *s;
 539             int len;
 540
 541             for (s = from; s < fromend; s++)
 542               {
 543                 ch = *s;
 544                 if (ch == '\\'
 545                     || ch == quotechar
 546                     || ch == '\n')
 547                   break;
 548               }
 549             len = s - from;
 550             if (len > toend - to)
 551               len = toend - to;
 552             if (len > 0)
 553               {
 554                 memcpy (to, from, len);
 555                 to += len;
 556                 from += len;
 557               }
 558           }
 559
 560           ch = GET ();
 561           if (ch == EOF)
 562             {
 563               as_warn (_("end of file in string; '%c' inserted"), quotechar);
 564               state = old_state;
 565               UNGET ('\n');
 566               PUT (quotechar);
 567             }
 568           else if (ch == quotechar)
 569             {
 570               state = old_state;
 571               PUT (ch);
 572             }
 573 #ifndef NO_STRING_ESCAPES
 574           else if (ch == '\\')
 575             {
 576               state = 6;
 577               PUT (ch);
 578             }
 579 #endif
 580           else if (scrub_m68k_mri && ch == '\n')
 581             {
 582               /* Just quietly terminate the string.  This permits lines like
 583                    bne  label   loop if we haven't reach end yet.  */
 584               state = old_state;
 585               UNGET (ch);
 586               PUT ('\'');
 587             }
 588           else
 589             {
 590               PUT (ch);
 591             }
 592           continue;
 593
 594         case 6:
 595           state = 5;
 596           ch = GET ();
 597           switch (ch)
 598             {
 599               /* Handle strings broken across lines, by turning '\n' into
 600                  '\\' and 'n'.  */
 601             case '\n':
 602               UNGET ('n');
 603               add_newlines++;
 604               PUT ('\\');
 605               continue;
 606
 607             case EOF:
 608               as_warn (_("end of file in string; '%c' inserted"), quotechar);
 609               PUT (quotechar);
 610               continue;
 611
 612             case '"':
 613             case '\\':
 614             case 'b':
 615             case 'f':
 616             case 'n':
 617             case 'r':
 618             case 't':
 619             case 'v':
 620             case 'x':
 621             case 'X':
 622             case '0':
 623             case '1':
 624             case '2':
 625             case '3':
 626             case '4':
 627             case '5':
 628             case '6':
 629             case '7':
 630               break;
 631
 632             default:
 633 #ifdef ONLY_STANDARD_ESCAPES
 634               as_warn (_("unknown escape '\\%c' in string; ignored"), ch);
 635 #endif
 636               break;
 637             }
 638           PUT (ch);
 639           continue;
 640
 641         case 7:
 642           ch = GET ();
 643           quotechar = ch;
 644           state = 5;
 645           old_state = 8;
 646           PUT (ch);
 647           continue;
 648
 649         case 8:
 650           do
 651             ch = GET ();
 652           while (ch != '\n' && ch != EOF);
 653           if (ch == EOF)
 654             goto fromeof;
 655           state = 0;
 656           PUT (ch);
 657           continue;
 658
 659 #ifdef DOUBLEBAR_PARALLEL
 660         case 13:
 661           ch = GET ();
 662           if (ch != '|')
 663             abort ();
 664
 665           /* Reset back to state 1 and pretend that we are parsing a
 666              line from just after the first white space.  */
 667           state = 1;
 668           PUT ('|');
 669           continue;
 670 #endif
 671 #ifdef TC_Z80
 672         case 16:
 673           /* We have seen an 'a' at the start of a symbol, look for an 'f'.  */
 674           ch = GET ();
 675           if (ch == 'f' || ch == 'F')
 676             {
 677               state = 17;
 678               PUT (ch);
 679             }
 680           else
 681             {
 682               state = 9;
 683               break;
 684             }
 685         case 17:
 686           /* We have seen "af" at the start of a symbol,
 687              a ' here is a part of that symbol.  */
 688           ch = GET ();
 689           state = 9;
 690           if (ch == '\'')
 691             /* Change to avoid warning about unclosed string.  */
 692             PUT ('`');
 693           else
 694             UNGET (ch);
 695           break;
 696 #endif
 697         }
 698
 699       /* OK, we are somewhere in states 0 through 4 or 9 through 11.  */
 700
 701       /* flushchar: */
 702       ch = GET ();
 703
 704 #ifdef TC_IA64
 705       if (ch == '(' && (state == 0 || state == 1))
 706         {
 707           state += 14;
 708           PUT (ch);
 709           continue;
 710         }
 711       else if (state == 14 || state == 15)
 712         {
 713           if (ch == ')')
 714             {
 715               state -= 14;
 716               PUT (ch);
 717               ch = GET ();
 718             }
 719           else
 720             {
 721               PUT (ch);
 722               continue;
 723             }
 724         }
 725 #endif
 726
 727     recycle:
 728
 729 #if defined TC_ARM && defined OBJ_ELF
 730       /* We need to watch out for .symver directives.  See the comment later
 731          in this function.  */
 732       if (symver_state == NULL)
 733         {
 734           if ((state == 0 || state == 1) && ch == symver_pseudo[0])
 735             symver_state = symver_pseudo + 1;
 736         }
 737       else
 738         {
 739           /* We advance to the next state if we find the right
 740              character.  */
 741           if (ch != '\0' && (*symver_state == ch))
 742             ++symver_state;
 743           else if (*symver_state != '\0')
 744             /* We did not get the expected character, or we didn't
 745                get a valid terminating character after seeing the
 746                entire pseudo-op, so we must go back to the beginning.  */
 747             symver_state = NULL;
 748           else
 749             {
 750               /* We've read the entire pseudo-op.  If this is the end
 751                  of the line, go back to the beginning.  */
 752               if (IS_NEWLINE (ch))
 753                 symver_state = NULL;
 754             }
 755         }
 756 #endif /* TC_ARM && OBJ_ELF */
 757
 758 #ifdef TC_M68K
 759       /* We want to have pseudo-ops which control whether we are in
 760          MRI mode or not.  Unfortunately, since m68k MRI mode affects
 761          the scrubber, that means that we need a special purpose
 762          recognizer here.  */
 763       if (mri_state == NULL)
 764         {
 765           if ((state == 0 || state == 1)
 766               && ch == mri_pseudo[0])
 767             mri_state = mri_pseudo + 1;
 768         }
 769       else
 770         {
 771           /* We advance to the next state if we find the right
 772              character, or if we need a space character and we get any
 773              whitespace character, or if we need a '0' and we get a
 774              '1' (this is so that we only need one state to handle
 775              ``.mri 0'' and ``.mri 1'').  */
 776           if (ch != '\0'
 777               && (*mri_state == ch
 778                   || (*mri_state == ' '
 779                       && lex[ch] == LEX_IS_WHITESPACE)
 780                   || (*mri_state == '0'
 781                       && ch == '1')))
 782             {
 783               mri_last_ch = ch;
 784               ++mri_state;
 785             }
 786           else if (*mri_state != '\0'
 787                    || (lex[ch] != LEX_IS_WHITESPACE
 788                        && lex[ch] != LEX_IS_NEWLINE))
 789             {
 790               /* We did not get the expected character, or we didn't
 791                  get a valid terminating character after seeing the
 792                  entire pseudo-op, so we must go back to the
 793                  beginning.  */
 794               mri_state = NULL;
 795             }
 796           else
 797             {
 798               /* We've read the entire pseudo-op.  mips_last_ch is
 799                  either '0' or '1' indicating whether to enter or
 800                  leave MRI mode.  */
 801               do_scrub_begin (mri_last_ch == '1');
 802               mri_state = NULL;
 803
 804               /* We continue handling the character as usual.  The
 805                  main gas reader must also handle the .mri pseudo-op
 806                  to control expression parsing and the like.  */
 807             }
 808         }
 809 #endif
 810
 811       if (ch == EOF)
 812         {
 813           if (state != 0)
 814             {
 815               as_warn (_("end of file not at end of a line; newline inserted"));
 816               state = 0;
 817               PUT ('\n');
 818             }
 819           goto fromeof;
 820         }
 821
 822       switch (lex[ch])
 823         {
 824         case LEX_IS_WHITESPACE:
 825           do
 826             {
 827               ch = GET ();
 828             }
 829           while (ch != EOF && IS_WHITESPACE (ch));
 830           if (ch == EOF)
 831             goto fromeof;
 832
 833           if (state == 0)
 834             {
 835               /* Preserve a single whitespace character at the
 836                  beginning of a line.  */
 837               state = 1;
 838               UNGET (ch);
 839               PUT (' ');
 840               break;
 841             }
 842
 843 #ifdef KEEP_WHITE_AROUND_COLON
 844           if (lex[ch] == LEX_IS_COLON)
 845             {
 846               /* Only keep this white if there's no white *after* the
 847                  colon.  */
 848               ch2 = GET ();
 849               UNGET (ch2);
 850               if (!IS_WHITESPACE (ch2))
 851                 {
 852                   state = 9;
 853                   UNGET (ch);
 854                   PUT (' ');
 855                   break;
 856                 }
 857             }
 858 #endif
 859           if (IS_COMMENT (ch)
 860               || ch == '/'
 861               || IS_LINE_SEPARATOR (ch)
 862               || IS_PARALLEL_SEPARATOR (ch))
 863             {
 864               if (scrub_m68k_mri)
 865                 {
 866                   /* In MRI mode, we keep these spaces.  */
 867                   UNGET (ch);
 868                   PUT (' ');
 869                   break;
 870                 }
 871               goto recycle;
 872             }
 873
 874           /* If we're in state 2 or 11, we've seen a non-white
 875              character followed by whitespace.  If the next character
 876              is ':', this is whitespace after a label name which we
 877              normally must ignore.  In MRI mode, though, spaces are
 878              not permitted between the label and the colon.  */
 879           if ((state == 2 || state == 11)
 880               && lex[ch] == LEX_IS_COLON
 881               && ! scrub_m68k_mri)
 882             {
 883               state = 1;
 884               PUT (ch);
 885               break;
 886             }
 887
 888           switch (state)
 889             {
 890             case 1:
 891               /* We can arrive here if we leave a leading whitespace
 892                  character at the beginning of a line.  */
 893               goto recycle;
 894             case 2:
 895               state = 3;
 896               if (to + 1 < toend)
 897                 {
 898                   /* Optimize common case by skipping UNGET/GET.  */
 899                   PUT (' ');    /* Sp after opco */
 900                   goto recycle;
 901                 }
 902               UNGET (ch);
 903               PUT (' ');
 904               break;
 905             case 3:
 906               if (scrub_m68k_mri)
 907                 {
 908                   /* In MRI mode, we keep these spaces.  */
 909                   UNGET (ch);
 910                   PUT (' ');
 911                   break;
 912                 }
 913               goto recycle;     /* Sp in operands */
 914             case 9:
 915             case 10:
 916               if (scrub_m68k_mri)
 917                 {
 918                   /* In MRI mode, we keep these spaces.  */
 919                   state = 3;
 920                   UNGET (ch);
 921                   PUT (' ');
 922                   break;
 923                 }
 924               state = 10;       /* Sp after symbol char */
 925               goto recycle;
 926             case 11:
 927               if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
 928                 state = 1;
 929               else
 930                 {
 931                   /* We know that ch is not ':', since we tested that
 932                      case above.  Therefore this is not a label, so it
 933                      must be the opcode, and we've just seen the
 934                      whitespace after it.  */
 935                   state = 3;
 936                 }
 937               UNGET (ch);
 938               PUT (' ');        /* Sp after label definition.  */
 939               break;
 940             default:
 941               BAD_CASE (state);
 942             }
 943           break;
 944
 945         case LEX_IS_TWOCHAR_COMMENT_1ST:
 946           ch2 = GET ();
 947           if (ch2 == '*')
 948             {
 949               for (;;)
 950                 {
 951                   do
 952                     {
 953                       ch2 = GET ();
 954                       if (ch2 != EOF && IS_NEWLINE (ch2))
 955                         add_newlines++;
 956                     }
 957                   while (ch2 != EOF && ch2 != '*');
 958
 959                   while (ch2 == '*')
 960                     ch2 = GET ();
 961
 962                   if (ch2 == EOF || ch2 == '/')
 963                     break;
 964
 965                   /* This UNGET will ensure that we count newlines
 966                      correctly.  */
 967                   UNGET (ch2);
 968                 }
 969
 970               if (ch2 == EOF)
 971                 as_warn (_("end of file in multiline comment"));
 972
 973               ch = ' ';
 974               goto recycle;
 975             }
 976 #ifdef DOUBLESLASH_LINE_COMMENTS
 977           else if (ch2 == '/')
 978             {
 979               do
 980                 {
 981                   ch = GET ();
 982                 }
 983               while (ch != EOF && !IS_NEWLINE (ch));
 984               if (ch == EOF)
 985                 as_warn ("end of file in comment; newline inserted");
 986               state = 0;
 987               PUT ('\n');
 988               break;
 989             }
 990 #endif
 991           else
 992             {
 993               if (ch2 != EOF)
 994                 UNGET (ch2);
 995               if (state == 9 || state == 10)
 996                 state = 3;
 997               PUT (ch);
 998             }
 999           break;
1000
1001         case LEX_IS_STRINGQUOTE:
1002           quotechar = ch;
1003           if (state == 10)
1004             {
1005               /* Preserve the whitespace in foo "bar".  */
1006               UNGET (ch);
1007               state = 3;
1008               PUT (' ');
1009
1010               /* PUT didn't jump out.  We could just break, but we
1011                  know what will happen, so optimize a bit.  */
1012               ch = GET ();
1013               old_state = 3;
1014             }
1015           else if (state == 9)
1016             old_state = 3;
1017           else
1018             old_state = state;
1019           state = 5;
1020           PUT (ch);
1021           break;
1022
1023 #ifndef IEEE_STYLE
1024         case LEX_IS_ONECHAR_QUOTE:
1025           if (state == 10)
1026             {
1027               /* Preserve the whitespace in foo 'b'.  */
1028               UNGET (ch);
1029               state = 3;
1030               PUT (' ');
1031               break;
1032             }
1033           ch = GET ();
1034           if (ch == EOF)
1035             {
1036               as_warn (_("end of file after a one-character quote; \\0 inserted"));
1037               ch = 0;
1038             }
1039           if (ch == '\\')
1040             {
1041               ch = GET ();
1042               if (ch == EOF)
1043                 {
1044                   as_warn (_("end of file in escape character"));
1045                   ch = '\\';
1046                 }
1047               else
1048                 ch = process_escape (ch);
1049             }
1050           sprintf (out_buf, "%d", (int) (unsigned char) ch);
1051
1052           /* None of these 'x constants for us.  We want 'x'.  */
1053           if ((ch = GET ()) != '\'')
1054             {
1055 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
1056               as_warn (_("missing close quote; (assumed)"));
1057 #else
1058               if (ch != EOF)
1059                 UNGET (ch);
1060 #endif
1061             }
1062           if (strlen (out_buf) == 1)
1063             {
1064               PUT (out_buf[0]);
1065               break;
1066             }
1067           if (state == 9)
1068             old_state = 3;
1069           else
1070             old_state = state;
1071           state = -1;
1072           out_string = out_buf;
1073           PUT (*out_string++);
1074           break;
1075 #endif
1076
1077         case LEX_IS_COLON:
1078 #ifdef KEEP_WHITE_AROUND_COLON
1079           state = 9;
1080 #else
1081           if (state == 9 || state == 10)
1082             state = 3;
1083           else if (state != 3)
1084             state = 1;
1085 #endif
1086           PUT (ch);
1087           break;
1088
1089         case LEX_IS_NEWLINE:
1090           /* Roll out a bunch of newlines from inside comments, etc.  */
1091           if (add_newlines)
1092             {
1093               --add_newlines;
1094               UNGET (ch);
1095             }
1096           /* Fall through.  */
1097
1098         case LEX_IS_LINE_SEPARATOR:
1099           state = 0;
1100           PUT (ch);
1101           break;
1102
1103         case LEX_IS_PARALLEL_SEPARATOR:
1104           state = 1;
1105           PUT (ch);
1106           break;
1107
1108 #ifdef TC_V850
1109         case LEX_IS_DOUBLEDASH_1ST:
1110           ch2 = GET ();
1111           if (ch2 != '-')
1112             {
1113               UNGET (ch2);
1114               goto de_fault;
1115             }
1116           /* Read and skip to end of line.  */
1117           do
1118             {
1119               ch = GET ();
1120             }
1121           while (ch != EOF && ch != '\n');
1122
1123           if (ch == EOF)
1124             as_warn (_("end of file in comment; newline inserted"));
1125
1126           state = 0;
1127           PUT ('\n');
1128           break;
1129 #endif
1130 #ifdef DOUBLEBAR_PARALLEL
1131         case LEX_IS_DOUBLEBAR_1ST:
1132           ch2 = GET ();
1133           UNGET (ch2);
1134           if (ch2 != '|')
1135             goto de_fault;
1136
1137           /* Handle '||' in two states as invoking PUT twice might
1138              result in the first one jumping out of this loop.  We'd
1139              then lose track of the state and one '|' char.  */
1140           state = 13;
1141           PUT ('|');
1142           break;
1143 #endif
1144         case LEX_IS_LINE_COMMENT_START:
1145           /* FIXME-someday: The two character comment stuff was badly
1146              thought out.  On i386, we want '/' as line comment start
1147              AND we want C style comments.  hence this hack.  The
1148              whole lexical process should be reworked.  xoxorich.  */
1149           if (ch == '/')
1150             {
1151               ch2 = GET ();
1152               if (ch2 == '*')
1153                 {
1154                   old_state = 3;
1155                   state = -2;
1156                   break;
1157                 }
1158               else
1159                 {
1160                   UNGET (ch2);
1161                 }
1162             }
1163
1164           if (state == 0 || state == 1) /* Only comment at start of line.  */
1165             {
1166               int startch;
1167
1168               startch = ch;
1169
1170               do
1171                 {
1172                   ch = GET ();
1173                 }
1174               while (ch != EOF && IS_WHITESPACE (ch));
1175
1176               if (ch == EOF)
1177                 {
1178                   as_warn (_("end of file in comment; newline inserted"));
1179                   PUT ('\n');
1180                   break;
1181                 }
1182
1183               if (ch < '0' || ch > '9' || state != 0 || startch != '#')
1184                 {
1185                   /* Not a cpp line.  */
1186                   while (ch != EOF && !IS_NEWLINE (ch))
1187                     ch = GET ();
1188                   if (ch == EOF)
1189                     as_warn (_("end of file in comment; newline inserted"));
1190                   state = 0;
1191                   PUT ('\n');
1192                   break;
1193                 }
1194               /* Looks like `# 123 "filename"' from cpp.  */
1195               UNGET (ch);
1196               old_state = 4;
1197               state = -1;
1198               if (scrub_m68k_mri)
1199                 out_string = "\tappline ";
1200               else
1201                 out_string = "\t.appline ";
1202               PUT (*out_string++);
1203               break;
1204             }
1205
1206 #ifdef TC_D10V
1207           /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true.
1208              Trap is the only short insn that has a first operand that is
1209              neither register nor label.
1210              We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 .
1211              We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is
1212              already LEX_IS_LINE_COMMENT_START.  However, it is the
1213              only character in line_comment_chars for d10v, hence we
1214              can recognize it as such.  */
1215           /* An alternative approach would be to reset the state to 1 when
1216              we see '||', '<'- or '->', but that seems to be overkill.  */
1217           if (state == 10)
1218             PUT (' ');
1219 #endif
1220           /* We have a line comment character which is not at the
1221              start of a line.  If this is also a normal comment
1222              character, fall through.  Otherwise treat it as a default
1223              character.  */
1224           if (strchr (tc_comment_chars, ch) == NULL
1225               && (! scrub_m68k_mri
1226                   || (ch != '!' && ch != '*')))
1227             goto de_fault;
1228           if (scrub_m68k_mri
1229               && (ch == '!' || ch == '*' || ch == '#')
1230               && state != 1
1231               && state != 10)
1232             goto de_fault;
1233           /* Fall through.  */
1234         case LEX_IS_COMMENT_START:
1235 #if defined TC_ARM && defined OBJ_ELF
1236           /* On the ARM, `@' is the comment character.
1237              Unfortunately this is also a special character in ELF .symver
1238              directives (and .type, though we deal with those another way).
1239              So we check if this line is such a directive, and treat
1240              the character as default if so.  This is a hack.  */
1241           if ((symver_state != NULL) && (*symver_state == 0))
1242             goto de_fault;
1243 #endif
1244 #ifdef WARN_COMMENTS
1245           if (!found_comment)
1246             as_where (&found_comment_file, &found_comment);
1247 #endif
1248           do
1249             {
1250               ch = GET ();
1251             }
1252           while (ch != EOF && !IS_NEWLINE (ch));
1253           if (ch == EOF)
1254             as_warn (_("end of file in comment; newline inserted"));
1255           state = 0;
1256           PUT ('\n');
1257           break;
1258
1259         case LEX_IS_SYMBOL_COMPONENT:
1260           if (state == 10)
1261             {
1262               /* This is a symbol character following another symbol
1263                  character, with whitespace in between.  We skipped
1264                  the whitespace earlier, so output it now.  */
1265               UNGET (ch);
1266               state = 3;
1267               PUT (' ');
1268               break;
1269             }
1270
1271 #ifdef TC_Z80
1272           /* "af'" is a symbol containing '\''.  */
1273           if (state == 3 && (ch == 'a' || ch == 'A'))
1274             {
1275               state = 16;
1276               PUT (ch);
1277               ch = GET ();
1278               if (ch == 'f' || ch == 'F')
1279                 {
1280                   state = 17;
1281                   PUT (ch);
1282                   break;
1283                 }
1284               else
1285                 {
1286                   state = 9;
1287                   if (!IS_SYMBOL_COMPONENT (ch))
1288                     {
1289                       UNGET (ch);
1290                       break;
1291                     }
1292                 }
1293             }
1294 #endif
1295           if (state == 3)
1296             state = 9;
1297
1298           /* This is a common case.  Quickly copy CH and all the
1299              following symbol component or normal characters.  */
1300           if (to + 1 < toend
1301               && mri_state == NULL
1302 #if defined TC_ARM && defined OBJ_ELF
1303               && symver_state == NULL
1304 #endif
1305               )
1306             {
1307               char *s;
1308               int len;
1309
1310               for (s = from; s < fromend; s++)
1311                 {
1312                   int type;
1313
1314                   ch2 = *(unsigned char *) s;
1315                   type = lex[ch2];
1316                   if (type != 0
1317                       && type != LEX_IS_SYMBOL_COMPONENT)
1318                     break;
1319                 }
1320
1321               if (s > from)
1322                 /* Handle the last character normally, for
1323                    simplicity.  */
1324                 --s;
1325
1326               len = s - from;
1327
1328               if (len > (toend - to) - 1)
1329                 len = (toend - to) - 1;
1330
1331               if (len > 0)
1332                 {
1333                   PUT (ch);
1334                   memcpy (to, from, len);
1335                   to += len;
1336                   from += len;
1337                   if (to >= toend)
1338                     goto tofull;
1339                   ch = GET ();
1340                 }
1341             }
1342
1343           /* Fall through.  */
1344         default:
1345         de_fault:
1346           /* Some relatively `normal' character.  */
1347           if (state == 0)
1348             {
1349               state = 11;       /* Now seeing label definition.  */
1350             }
1351           else if (state == 1)
1352             {
1353               state = 2;        /* Ditto.  */
1354             }
1355           else if (state == 9)
1356             {
1357               if (!IS_SYMBOL_COMPONENT (ch))
1358                 state = 3;
1359             }
1360           else if (state == 10)
1361             {
1362               if (ch == '\\')
1363                 {
1364                   /* Special handling for backslash: a backslash may
1365                      be the beginning of a formal parameter (of a
1366                      macro) following another symbol character, with
1367                      whitespace in between.  If that is the case, we
1368                      output a space before the parameter.  Strictly
1369                      speaking, correct handling depends upon what the
1370                      macro parameter expands into; if the parameter
1371                      expands into something which does not start with
1372                      an operand character, then we don't want to keep
1373                      the space.  We don't have enough information to
1374                      make the right choice, so here we are making the
1375                      choice which is more likely to be correct.  */
1376                   PUT (' ');
1377                 }
1378
1379               state = 3;
1380             }
1381           PUT (ch);
1382           break;
1383         }
1384     }
1385
1386   /*NOTREACHED*/
1387
1388  fromeof:
1389   /* We have reached the end of the input.  */
1390   return to - tostart;
1391
1392  tofull:
1393   /* The output buffer is full.  Save any input we have not yet
1394      processed.  */
1395   if (fromend > from)
1396     {
1397       saved_input = from;
1398       saved_input_len = fromend - from;
1399     }
1400   else
1401     saved_input = NULL;
1402
1403   return to - tostart;
1404 }
1405