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