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