1 /* This is the Assembler Pre-Processor
2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2006, 2007
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* Modified by Allen Wirfs-Brock, Instantiations Inc 2/90. */
24 /* App, the assembler pre-processor. This pre-processor strips out
25 excess spaces, turns single-quoted characters into a decimal
26 constant, and turns the # in # <number> <filename> <garbage> into a
27 .linefile. This needs better error-handling. */
33 #define const /* empty */
38 /* Whether we are scrubbing in m68k MRI mode. This is different from
39 flag_m68k_mri, because the two flags will be affected by the .mri
40 pseudo-op at different times. */
41 static int scrub_m68k_mri;
43 /* The pseudo-op which switches in and out of MRI mode. See the
44 comment in do_scrub_chars. */
45 static const char mri_pseudo[] = ".mri 0";
47 #define scrub_m68k_mri 0
50 #if defined TC_ARM && defined OBJ_ELF
51 /* The pseudo-op for which we need to special-case `@' characters.
52 See the comment in do_scrub_chars. */
53 static const char symver_pseudo[] = ".symver";
54 static const char * symver_state;
58 static const char symbol_chars[] =
59 "$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
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
72 #define LEX_IS_DOUBLEDASH_1ST 12
75 #define DOUBLEBAR_PARALLEL
77 #ifdef DOUBLEBAR_PARALLEL
78 #define LEX_IS_DOUBLEBAR_1ST 13
80 #define LEX_IS_PARALLEL_SEPARATOR 14
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)
84 #define IS_PARALLEL_SEPARATOR(c) (lex[c] == LEX_IS_PARALLEL_SEPARATOR)
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)
89 static int process_escape (int);
91 /* FIXME-soon: The entire lexer/parser thingy should be
92 built statically at compile time rather than dynamically
93 each and every time the assembler is run. xoxorich. */
96 do_scrub_begin (int m68k_mri ATTRIBUTE_UNUSED)
101 lex[' '] = LEX_IS_WHITESPACE;
102 lex['\t'] = LEX_IS_WHITESPACE;
103 lex['\r'] = LEX_IS_WHITESPACE;
104 lex['\n'] = LEX_IS_NEWLINE;
105 lex[':'] = LEX_IS_COLON;
108 scrub_m68k_mri = m68k_mri;
113 lex['"'] = LEX_IS_STRINGQUOTE;
115 #if ! defined (TC_HPPA) && ! defined (TC_I370)
116 /* I370 uses single-quotes to delimit integer, float constants. */
117 lex['\''] = LEX_IS_ONECHAR_QUOTE;
120 #ifdef SINGLE_QUOTE_STRINGS
121 lex['\''] = LEX_IS_STRINGQUOTE;
125 /* Note: if any other character can be LEX_IS_STRINGQUOTE, the loop
126 in state 5 of do_scrub_chars must be changed. */
128 /* Note that these override the previous defaults, e.g. if ';' is a
129 comment char, then it isn't a line separator. */
130 for (p = symbol_chars; *p; ++p)
131 lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT;
133 for (c = 128; c < 256; ++c)
134 lex[c] = LEX_IS_SYMBOL_COMPONENT;
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;
146 /* The m68k backend wants to be able to change comment_chars. */
147 #ifndef tc_comment_chars
148 #define tc_comment_chars comment_chars
150 for (p = tc_comment_chars; *p; p++)
151 lex[(unsigned char) *p] = LEX_IS_COMMENT_START;
153 for (p = line_comment_chars; *p; p++)
154 lex[(unsigned char) *p] = LEX_IS_LINE_COMMENT_START;
156 for (p = line_separator_chars; *p; p++)
157 lex[(unsigned char) *p] = LEX_IS_LINE_SEPARATOR;
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++)
163 lex[(unsigned char) *p] = LEX_IS_PARALLEL_SEPARATOR;
166 /* Only allow slash-star comments if slash is not in use.
167 FIXME: This isn't right. We should always permit them. */
169 lex['/'] = LEX_IS_TWOCHAR_COMMENT_1ST;
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
178 then it can't be used in an expression. */
179 lex['!'] = LEX_IS_LINE_COMMENT_START;
184 lex['-'] = LEX_IS_DOUBLEDASH_1ST;
186 #ifdef DOUBLEBAR_PARALLEL
187 lex['|'] = LEX_IS_DOUBLEBAR_1ST;
190 /* Must do this is we want VLIW instruction with "->" or "<-". */
191 lex['-'] = LEX_IS_SYMBOL_COMPONENT;
195 /* Saved state of the scrubber. */
197 static int old_state;
198 static char *out_string;
199 static char out_buf[20];
200 static int add_newlines;
201 static char *saved_input;
202 static int saved_input_len;
203 static char input_buffer[32 * 1024];
204 static const char *mri_state;
205 static char mri_last_ch;
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. */
217 char out_buf[sizeof (out_buf)];
224 const char * mri_state;
226 #if defined TC_ARM && defined OBJ_ELF
227 const char * symver_state;
234 register struct app_save *saved;
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;
242 if (saved_input == NULL)
243 saved->saved_input = NULL;
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;
251 saved->scrub_m68k_mri = scrub_m68k_mri;
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;
259 /* do_scrub_begin() is not useful, just wastes time. */
264 return (char *) saved;
270 register struct app_save *saved = (struct app_save *) arg;
272 /* There is no do_scrub_end (). */
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;
278 if (saved->saved_input == NULL)
282 assert (saved->saved_input_len <= (int) (sizeof input_buffer));
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);
289 scrub_m68k_mri = saved->scrub_m68k_mri;
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;
300 /* @@ This assumes that \n &c are the same on host and target. This is not
304 process_escape (int ch)
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. */
339 do_scrub_chars (int (*get) (char *, int), char *tostart, int tolen)
342 char *toend = tostart + tolen;
346 register int ch, ch2 = 0;
347 /* Character that started the string we're working on. */
348 static char quotechar;
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 .linefile, put out digits
355 5: parsing a string, then go to old-state
356 6: putting out \ escape in a "d string.
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
365 12: After seeing a dash, looking for a second dash as a start
368 #ifdef DOUBLEBAR_PARALLEL
369 13: After seeing a vertical bar, looking for a second
370 vertical bar as a parallel expression separator.
373 14: After seeing a `(' at state 0, looking for a `)' as
375 15: After seeing a `(' at state 1, looking for a `)' as
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
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
387 between characters which could appear in an identifier. Ian
388 Taylor, ian@cygnus.com.
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.
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 */
398 /* This macro gets the next input character. */
402 ? * (unsigned char *) (from++) \
403 : (saved_input = NULL, \
404 fromlen = (*get) (input_buffer, sizeof input_buffer), \
405 from = input_buffer, \
406 fromend = from + fromlen, \
409 : * (unsigned char *) (from++))))
411 /* This macro pushes a character back on the input stream. */
413 #define UNGET(uch) (*--from = (uch))
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
433 if (saved_input != NULL)
436 fromend = from + saved_input_len;
440 fromlen = (*get) (input_buffer, sizeof input_buffer);
444 fromend = from + fromlen;
449 /* The cases in this switch end with continue, in order to
450 branch back to the top of this while loop and generate the
451 next output character in the appropriate state. */
456 if (*out_string == '\0')
473 as_warn (_("end of file in comment"));
482 while ((ch = GET ()) == '*')
487 as_warn (_("end of file in comment"));
505 else if (ch >= '0' && ch <= '9')
509 while (ch != EOF && IS_WHITESPACE (ch))
520 while (ch != EOF && ch != '\n')
529 /* We are going to copy everything up to a quote character,
530 with special handling for a backslash. We try to
531 optimize the copying in the simple case without using the
532 GET and PUT macros. */
537 for (s = from; s < fromend; s++)
546 if (len > toend - to)
550 memcpy (to, from, len);
561 /* This buffer is here specifically so
562 that the UNGET below will work. */
563 static char one_char_buf[1];
565 as_warn (_("end of file in string; '%c' inserted"), quotechar);
567 from = fromend = one_char_buf + 1;
572 else if (ch == quotechar)
577 #ifndef NO_STRING_ESCAPES
584 else if (scrub_m68k_mri && ch == '\n')
586 /* Just quietly terminate the string. This permits lines like
587 bne label loop if we haven't reach end yet. */
603 /* Handle strings broken across lines, by turning '\n' into
612 as_warn (_("end of file in string; '%c' inserted"), quotechar);
637 #ifdef ONLY_STANDARD_ESCAPES
638 as_warn (_("unknown escape '\\%c' in string; ignored"), ch);
645 #ifdef DOUBLEBAR_PARALLEL
651 /* Reset back to state 1 and pretend that we are parsing a
652 line from just after the first white space. */
659 /* We have seen an 'a' at the start of a symbol, look for an 'f'. */
661 if (ch == 'f' || ch == 'F')
672 /* We have seen "af" at the start of a symbol,
673 a ' here is a part of that symbol. */
677 /* Change to avoid warning about unclosed string. */
685 /* OK, we are somewhere in states 0 through 4 or 9 through 11. */
691 if (ch == '(' && (state == 0 || state == 1))
697 else if (state == 14 || state == 15)
715 #if defined TC_ARM && defined OBJ_ELF
716 /* We need to watch out for .symver directives. See the comment later
718 if (symver_state == NULL)
720 if ((state == 0 || state == 1) && ch == symver_pseudo[0])
721 symver_state = symver_pseudo + 1;
725 /* We advance to the next state if we find the right
727 if (ch != '\0' && (*symver_state == ch))
729 else if (*symver_state != '\0')
730 /* We did not get the expected character, or we didn't
731 get a valid terminating character after seeing the
732 entire pseudo-op, so we must go back to the beginning. */
736 /* We've read the entire pseudo-op. If this is the end
737 of the line, go back to the beginning. */
742 #endif /* TC_ARM && OBJ_ELF */
745 /* We want to have pseudo-ops which control whether we are in
746 MRI mode or not. Unfortunately, since m68k MRI mode affects
747 the scrubber, that means that we need a special purpose
749 if (mri_state == NULL)
751 if ((state == 0 || state == 1)
752 && ch == mri_pseudo[0])
753 mri_state = mri_pseudo + 1;
757 /* We advance to the next state if we find the right
758 character, or if we need a space character and we get any
759 whitespace character, or if we need a '0' and we get a
760 '1' (this is so that we only need one state to handle
761 ``.mri 0'' and ``.mri 1''). */
764 || (*mri_state == ' '
765 && lex[ch] == LEX_IS_WHITESPACE)
766 || (*mri_state == '0'
772 else if (*mri_state != '\0'
773 || (lex[ch] != LEX_IS_WHITESPACE
774 && lex[ch] != LEX_IS_NEWLINE))
776 /* We did not get the expected character, or we didn't
777 get a valid terminating character after seeing the
778 entire pseudo-op, so we must go back to the
784 /* We've read the entire pseudo-op. mips_last_ch is
785 either '0' or '1' indicating whether to enter or
787 do_scrub_begin (mri_last_ch == '1');
790 /* We continue handling the character as usual. The
791 main gas reader must also handle the .mri pseudo-op
792 to control expression parsing and the like. */
801 as_warn (_("end of file not at end of a line; newline inserted"));
810 case LEX_IS_WHITESPACE:
815 while (ch != EOF && IS_WHITESPACE (ch));
821 /* Preserve a single whitespace character at the
822 beginning of a line. */
829 #ifdef KEEP_WHITE_AROUND_COLON
830 if (lex[ch] == LEX_IS_COLON)
832 /* Only keep this white if there's no white *after* the
837 if (!IS_WHITESPACE (ch2))
848 || IS_LINE_SEPARATOR (ch)
849 || IS_PARALLEL_SEPARATOR (ch))
853 /* In MRI mode, we keep these spaces. */
861 /* If we're in state 2 or 11, we've seen a non-white
862 character followed by whitespace. If the next character
863 is ':', this is whitespace after a label name which we
864 normally must ignore. In MRI mode, though, spaces are
865 not permitted between the label and the colon. */
866 if ((state == 2 || state == 11)
867 && lex[ch] == LEX_IS_COLON
878 /* We can arrive here if we leave a leading whitespace
879 character at the beginning of a line. */
885 /* Optimize common case by skipping UNGET/GET. */
886 PUT (' '); /* Sp after opco */
895 /* In MRI mode, we keep these spaces. */
900 goto recycle; /* Sp in operands */
905 /* In MRI mode, we keep these spaces. */
911 state = 10; /* Sp after symbol char */
914 if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
918 /* We know that ch is not ':', since we tested that
919 case above. Therefore this is not a label, so it
920 must be the opcode, and we've just seen the
921 whitespace after it. */
925 PUT (' '); /* Sp after label definition. */
932 case LEX_IS_TWOCHAR_COMMENT_1ST:
941 if (ch2 != EOF && IS_NEWLINE (ch2))
944 while (ch2 != EOF && ch2 != '*');
949 if (ch2 == EOF || ch2 == '/')
952 /* This UNGET will ensure that we count newlines
958 as_warn (_("end of file in multiline comment"));
963 #ifdef DOUBLESLASH_LINE_COMMENTS
970 while (ch != EOF && !IS_NEWLINE (ch));
972 as_warn ("end of file in comment; newline inserted");
982 if (state == 9 || state == 10)
988 case LEX_IS_STRINGQUOTE:
992 /* Preserve the whitespace in foo "bar". */
997 /* PUT didn't jump out. We could just break, but we
998 know what will happen, so optimize a bit. */
1002 else if (state == 9)
1011 case LEX_IS_ONECHAR_QUOTE:
1014 /* Preserve the whitespace in foo 'b'. */
1023 as_warn (_("end of file after a one-character quote; \\0 inserted"));
1031 as_warn (_("end of file in escape character"));
1035 ch = process_escape (ch);
1037 sprintf (out_buf, "%d", (int) (unsigned char) ch);
1039 /* None of these 'x constants for us. We want 'x'. */
1040 if ((ch = GET ()) != '\'')
1042 #ifdef REQUIRE_CHAR_CLOSE_QUOTE
1043 as_warn (_("missing close quote; (assumed)"));
1049 if (strlen (out_buf) == 1)
1059 out_string = out_buf;
1060 PUT (*out_string++);
1065 #ifdef KEEP_WHITE_AROUND_COLON
1068 if (state == 9 || state == 10)
1070 else if (state != 3)
1076 case LEX_IS_NEWLINE:
1077 /* Roll out a bunch of newlines from inside comments, etc. */
1085 case LEX_IS_LINE_SEPARATOR:
1090 case LEX_IS_PARALLEL_SEPARATOR:
1096 case LEX_IS_DOUBLEDASH_1ST:
1104 /* Read and skip to end of line. */
1109 while (ch != EOF && ch != '\n');
1112 as_warn (_("end of file in comment; newline inserted"));
1118 #ifdef DOUBLEBAR_PARALLEL
1119 case LEX_IS_DOUBLEBAR_1ST:
1126 /* Handle '||' in two states as invoking PUT twice might
1127 result in the first one jumping out of this loop. We'd
1128 then lose track of the state and one '|' char. */
1133 case LEX_IS_LINE_COMMENT_START:
1134 /* FIXME-someday: The two character comment stuff was badly
1135 thought out. On i386, we want '/' as line comment start
1136 AND we want C style comments. hence this hack. The
1137 whole lexical process should be reworked. xoxorich. */
1153 if (state == 0 || state == 1) /* Only comment at start of line. */
1163 while (ch != EOF && IS_WHITESPACE (ch));
1167 as_warn (_("end of file in comment; newline inserted"));
1172 if (ch < '0' || ch > '9' || state != 0 || startch != '#')
1174 /* Not a cpp line. */
1175 while (ch != EOF && !IS_NEWLINE (ch))
1178 as_warn (_("end of file in comment; newline inserted"));
1183 /* Looks like `# 123 "filename"' from cpp. */
1188 out_string = "\tlinefile ";
1190 out_string = "\t.linefile ";
1191 PUT (*out_string++);
1196 /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true.
1197 Trap is the only short insn that has a first operand that is
1198 neither register nor label.
1199 We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 .
1200 We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is
1201 already LEX_IS_LINE_COMMENT_START. However, it is the
1202 only character in line_comment_chars for d10v, hence we
1203 can recognize it as such. */
1204 /* An alternative approach would be to reset the state to 1 when
1205 we see '||', '<'- or '->', but that seems to be overkill. */
1209 /* We have a line comment character which is not at the
1210 start of a line. If this is also a normal comment
1211 character, fall through. Otherwise treat it as a default
1213 if (strchr (tc_comment_chars, ch) == NULL
1214 && (! scrub_m68k_mri
1215 || (ch != '!' && ch != '*')))
1218 && (ch == '!' || ch == '*' || ch == '#')
1223 case LEX_IS_COMMENT_START:
1224 #if defined TC_ARM && defined OBJ_ELF
1225 /* On the ARM, `@' is the comment character.
1226 Unfortunately this is also a special character in ELF .symver
1227 directives (and .type, though we deal with those another way).
1228 So we check if this line is such a directive, and treat
1229 the character as default if so. This is a hack. */
1230 if ((symver_state != NULL) && (*symver_state == 0))
1235 /* For the ARM, care is needed not to damage occurrences of \@
1236 by stripping the @ onwards. Yuck. */
1237 if (to > tostart && *(to - 1) == '\\')
1238 /* Do not treat the @ as a start-of-comment. */
1242 #ifdef WARN_COMMENTS
1244 as_where (&found_comment_file, &found_comment);
1250 while (ch != EOF && !IS_NEWLINE (ch));
1252 as_warn (_("end of file in comment; newline inserted"));
1257 case LEX_IS_SYMBOL_COMPONENT:
1260 /* This is a symbol character following another symbol
1261 character, with whitespace in between. We skipped
1262 the whitespace earlier, so output it now. */
1270 /* "af'" is a symbol containing '\''. */
1271 if (state == 3 && (ch == 'a' || ch == 'A'))
1276 if (ch == 'f' || ch == 'F')
1285 if (!IS_SYMBOL_COMPONENT (ch))
1297 /* This is a common case. Quickly copy CH and all the
1298 following symbol component or normal characters. */
1300 && mri_state == NULL
1301 #if defined TC_ARM && defined OBJ_ELF
1302 && symver_state == NULL
1309 for (s = from; s < fromend; s++)
1313 ch2 = *(unsigned char *) s;
1316 && type != LEX_IS_SYMBOL_COMPONENT)
1321 /* Handle the last character normally, for
1327 if (len > (toend - to) - 1)
1328 len = (toend - to) - 1;
1333 memcpy (to, from, len);
1345 /* Some relatively `normal' character. */
1348 state = 11; /* Now seeing label definition. */
1350 else if (state == 1)
1352 state = 2; /* Ditto. */
1354 else if (state == 9)
1356 if (!IS_SYMBOL_COMPONENT (ch))
1359 else if (state == 10)
1363 /* Special handling for backslash: a backslash may
1364 be the beginning of a formal parameter (of a
1365 macro) following another symbol character, with
1366 whitespace in between. If that is the case, we
1367 output a space before the parameter. Strictly
1368 speaking, correct handling depends upon what the
1369 macro parameter expands into; if the parameter
1370 expands into something which does not start with
1371 an operand character, then we don't want to keep
1372 the space. We don't have enough information to
1373 make the right choice, so here we are making the
1374 choice which is more likely to be correct. */
1375 if (to + 1 >= toend)
1377 /* If we're near the end of the buffer, save the
1378 character for the next time round. Otherwise
1379 we'll lose our state. */
1396 /* We have reached the end of the input. */
1397 return to - tostart;
1400 /* The output buffer is full. Save any input we have not yet
1405 saved_input_len = fromend - from;
1410 return to - tostart;