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