gas/app.c

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