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