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