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