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