1 %option nounput noyywrap
5 /* Copyright (C) 1991-2022 Free Software Foundation, Inc.
6 Written by Steve Chamberlain of Cygnus Support.
8 This file is part of the GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
26 #include "safe-ctype.h"
37 #include "libiberty.h"
39 /* The type of top-level parser input.
40 yylex and yyparse (indirectly) both check this. */
41 input_type parser_input;
43 /* Line number in the current input file. */
46 /* The string we are currently lexing, or NULL if we are reading a
48 const char *lex_string = NULL;
50 /* Support for flex reading from more than one input file (stream).
51 `include_stack' is flex's input state for each open file;
52 `file_name_stack' is the file names. `lineno_stack' is the current
55 If `include_stack_ptr' is 0, we haven't started reading anything yet.
56 Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */
59 #define YY_INPUT(buf,result,max_size) result = yy_input (buf, max_size)
65 #define MAX_INCLUDE_DEPTH 10
66 static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
67 static const char *file_name_stack[MAX_INCLUDE_DEPTH];
68 static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
69 static unsigned int sysrooted_stack[MAX_INCLUDE_DEPTH];
70 static unsigned int include_stack_ptr = 0;
71 static int vers_node_nesting = 0;
73 static int yy_input (char *, int);
74 static void comment (void);
75 static void lex_warn_invalid (char *where, char *what);
78 EXPRESSION in an expression
80 INPUTLIST in a script, a filename-list
82 WILD inside the braces of an output section or overlay,
83 for input section wildcards
84 VERS_START starting a Sun style mapfile
85 VERS_SCRIPT a Sun style mapfile
86 VERS_NODE a node within a Sun style mapfile
88 #define RTOKEN(x) { yylval.token = x; return x; }
95 WILDCHAR [_a-zA-Z0-9\/\.\\\$\~\-\+\:\[\]\,\=\?\*\^\!]
96 FILENAMECHAR [_a-zA-Z0-9\/\.\\\$\~\-\+\:\[\]\,\=]
97 NOCFILENAMECHAR [_a-zA-Z0-9\/\.\\\$\~\-\+\:\[\]]
98 SYMBOLNAMECHAR [_a-zA-Z0-9\/\.\\\$\~]
99 FILENAMECHAR1 [_a-zA-Z\/\.\\\$\~]
100 SYMBOLNAMECHAR1 [_a-zA-Z\.\\\$]
103 V_TAG [.$_a-zA-Z][._a-zA-Z0-9]*
104 V_IDENTIFIER [*?.$_a-zA-Z\[\]\-\!\^\\]([*?.$_a-zA-Z0-9\[\]\-\!\^\\]|::)*
116 if (parser_input != input_selected)
118 /* The first token of the input determines the initial parser state. */
119 input_type t = parser_input;
120 parser_input = input_selected;
123 case input_script: return INPUT_SCRIPT; break;
124 case input_mri_script: return INPUT_MRI_SCRIPT; break;
125 case input_version_script: return INPUT_VERSION_SCRIPT; break;
126 case input_dynamic_list: return INPUT_DYNAMIC_LIST; break;
127 case input_defsym: return INPUT_DEFSYM; break;
132 <SCRIPT,EXPRESSION,VERS_START,VERS_NODE,VERS_SCRIPT,INPUTLIST>"/*" {
135 <MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
136 yylval.integer = bfd_scan_vma (yytext + 1, 0, 16);
137 yylval.bigint.str = NULL;
141 <MRI,EXPRESSION>([0-9A-Fa-f])+(H|h|X|x|B|b|O|o|D|d) {
143 switch (yytext[yyleng - 1]) {
161 yylval.integer = bfd_scan_vma (yytext, 0,
163 yylval.bigint.str = NULL;
166 <SCRIPT,MRI,EXPRESSION>((("$"|0[xX])([0-9A-Fa-f])+)|(([0-9])+))(M|K|m|k)? {
175 yylval.integer = bfd_scan_vma (s, 0, ibase);
176 yylval.bigint.str = NULL;
177 if (yytext[yyleng - 1] == 'M'
178 || yytext[yyleng - 1] == 'm')
180 yylval.integer *= 1024 * 1024;
182 else if (yytext[yyleng - 1] == 'K'
183 || yytext[yyleng - 1]=='k')
185 yylval.integer *= 1024;
187 else if (yytext[0] == '0'
189 || yytext[1] == 'X'))
191 yylval.bigint.str = xstrdup (yytext + 2);
196 /* Some tokens that only appear in expressions must be enabled for
197 states other than EXPRESSION, since parser lookahead means they
198 must be recognised before the parser switches the lexer out of
199 SCRIPT or WILD state into EXPRESSION state.
201 This sort of thing happens for example with NAME in ldgram.y
202 "section" rule, which is immediately followed by ldlex_expression.
203 However, if you follow the grammar from "sec_or_group_p1" you see
204 "assignment" appearing in "statement_anywhere". Now,
205 "assignment" also has NAME as its first token, just like
206 "section". So the parser can't know whether it is in the
207 "section" or the "assignment" rule until it has scanned the next
208 token to find an assignment operator. Thus the next token after
209 NAME in the "section" rule may be lexed before the lexer is
210 switched to EXPRESSION state, and there are quite a number of
211 optional components. The first token in all those components
212 must be able to be lexed in SCRIPT state, as well as the
213 assignment operators. In fact, due to "opt_exp_with_type",
214 anything that can appear on the left hand side of "exp" might
215 need to be lexed in SCRIPT state.
217 MRI mode tends to cover everything in MRI scripts.
219 <MRI,WILD>"]" { RTOKEN(']'); }
220 <MRI,WILD>"[" { RTOKEN('['); }
221 <SCRIPT,EXPRESSION,MRI,WILD>"<<=" { RTOKEN(LSHIFTEQ); }
222 <SCRIPT,EXPRESSION,MRI,WILD>">>=" { RTOKEN(RSHIFTEQ); }
223 <EXPRESSION,MRI>"||" { RTOKEN(OROR); }
224 <EXPRESSION,MRI>"==" { RTOKEN(EQ); }
225 <EXPRESSION,MRI>"!=" { RTOKEN(NE); }
226 <EXPRESSION,MRI>">=" { RTOKEN(GE); }
227 <EXPRESSION,MRI>"<=" { RTOKEN(LE); }
228 <EXPRESSION,MRI>"<<" { RTOKEN(LSHIFT); }
229 <EXPRESSION,MRI>">>" { RTOKEN(RSHIFT); }
230 <SCRIPT,EXPRESSION,MRI,WILD>"+=" { RTOKEN(PLUSEQ); }
231 <SCRIPT,EXPRESSION,MRI,WILD>"-=" { RTOKEN(MINUSEQ); }
232 <SCRIPT,EXPRESSION,MRI,WILD>"*=" { RTOKEN(MULTEQ); }
233 <SCRIPT,EXPRESSION,MRI,WILD>"/=" { RTOKEN(DIVEQ); }
234 <SCRIPT,EXPRESSION,MRI,WILD>"&=" { RTOKEN(ANDEQ); }
235 <SCRIPT,EXPRESSION,MRI,WILD>"|=" { RTOKEN(OREQ); }
236 <EXPRESSION,MRI>"&&" { RTOKEN(ANDAND); }
237 <SCRIPT,EXPRESSION,MRI>">" { RTOKEN('>'); }
238 <SCRIPT,EXPRESSION,MRI,INPUTLIST>"," { RTOKEN(','); }
239 <EXPRESSION,MRI,WILD>"&" { RTOKEN('&'); }
240 <EXPRESSION,MRI>"|" { RTOKEN('|'); }
241 <SCRIPT,EXPRESSION,MRI>"~" { RTOKEN('~'); }
242 <SCRIPT,EXPRESSION,MRI>"!" { RTOKEN('!'); }
243 <EXPRESSION,MRI>"?" { RTOKEN('?'); }
244 <EXPRESSION,MRI>"*" { RTOKEN('*'); }
245 <SCRIPT,EXPRESSION,MRI>"+" { RTOKEN('+'); }
246 <SCRIPT,EXPRESSION,MRI>"-" { RTOKEN('-'); }
247 <EXPRESSION,MRI>"/" { RTOKEN('/'); }
248 <EXPRESSION,MRI>"%" { RTOKEN('%'); }
249 <EXPRESSION,MRI>"<" { RTOKEN('<'); }
250 <SCRIPT,EXPRESSION,MRI,WILD>"=" { RTOKEN('='); }
251 <SCRIPT,EXPRESSION,MRI,WILD>"}" { RTOKEN('}'); }
252 <SCRIPT,EXPRESSION,MRI,WILD>"{" { RTOKEN('{'); }
253 <SCRIPT,EXPRESSION,MRI,WILD,INPUTLIST>")" { RTOKEN(')'); }
254 <SCRIPT,EXPRESSION,MRI,WILD,INPUTLIST>"(" { RTOKEN('('); }
255 <SCRIPT,EXPRESSION,MRI>":" { RTOKEN(':'); }
256 <SCRIPT,EXPRESSION,MRI,WILD>";" { RTOKEN(';'); }
257 <SCRIPT>"MEMORY" { RTOKEN(MEMORY); }
258 <SCRIPT>"REGION_ALIAS" { RTOKEN(REGION_ALIAS); }
259 <SCRIPT>"LD_FEATURE" { RTOKEN(LD_FEATURE); }
260 <SCRIPT,EXPRESSION>"ORIGIN" { RTOKEN(ORIGIN); }
261 <SCRIPT>"VERSION" { RTOKEN(VERSIONK); }
262 <SCRIPT,EXPRESSION>"BLOCK" { RTOKEN(BLOCK); }
263 <SCRIPT,EXPRESSION>"BIND" { RTOKEN(BIND); }
264 <SCRIPT,EXPRESSION>"LENGTH" { RTOKEN(LENGTH); }
265 <SCRIPT,EXPRESSION>"ALIGN" { RTOKEN(ALIGN_K); }
266 <SCRIPT,EXPRESSION>"DATA_SEGMENT_ALIGN" { RTOKEN(DATA_SEGMENT_ALIGN); }
267 <SCRIPT,EXPRESSION>"DATA_SEGMENT_RELRO_END" { RTOKEN(DATA_SEGMENT_RELRO_END); }
268 <SCRIPT,EXPRESSION>"DATA_SEGMENT_END" { RTOKEN(DATA_SEGMENT_END); }
269 <SCRIPT,EXPRESSION>"ADDR" { RTOKEN(ADDR); }
270 <SCRIPT,EXPRESSION>"LOADADDR" { RTOKEN(LOADADDR); }
271 <SCRIPT,EXPRESSION>"ALIGNOF" { RTOKEN(ALIGNOF); }
272 <SCRIPT,EXPRESSION>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
273 <SCRIPT,EXPRESSION>"MAX" { RTOKEN(MAX_K); }
274 <SCRIPT,EXPRESSION>"MIN" { RTOKEN(MIN_K); }
275 <SCRIPT,EXPRESSION>"LOG2CEIL" { RTOKEN(LOG2CEIL); }
276 <SCRIPT,EXPRESSION,WILD>"ASSERT" { RTOKEN(ASSERT_K); }
277 <SCRIPT>"ENTRY" { RTOKEN(ENTRY); }
278 <SCRIPT,MRI>"EXTERN" { RTOKEN(EXTERN); }
279 <SCRIPT,EXPRESSION>"NEXT" { RTOKEN(NEXT); }
280 <SCRIPT,EXPRESSION>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS); }
281 <SCRIPT,EXPRESSION>"SEGMENT_START" { RTOKEN(SEGMENT_START); }
282 <SCRIPT>"MAP" { RTOKEN(MAP); }
283 <SCRIPT,EXPRESSION>"SIZEOF" { RTOKEN(SIZEOF); }
284 <SCRIPT>"TARGET" { RTOKEN(TARGET_K); }
285 <SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR); }
286 <SCRIPT>"OUTPUT" { RTOKEN(OUTPUT); }
287 <SCRIPT>"INPUT" { RTOKEN(INPUT); }
288 <SCRIPT>"GROUP" { RTOKEN(GROUP); }
289 <INPUTLIST>"AS_NEEDED" { RTOKEN(AS_NEEDED); }
290 <SCRIPT,EXPRESSION>"DEFINED" { RTOKEN(DEFINED); }
291 <WILD>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS); }
292 <WILD>"CONSTRUCTORS" { RTOKEN(CONSTRUCTORS); }
293 <SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION); }
294 <SCRIPT>"FORCE_GROUP_ALLOCATION" { RTOKEN(FORCE_GROUP_ALLOCATION); }
295 <SCRIPT>"INHIBIT_COMMON_ALLOCATION" { RTOKEN(INHIBIT_COMMON_ALLOCATION); }
296 <SCRIPT>"SECTIONS" { RTOKEN(SECTIONS); }
297 <SCRIPT>"INSERT" { RTOKEN(INSERT_K); }
298 <SCRIPT>"AFTER" { RTOKEN(AFTER); }
299 <SCRIPT>"BEFORE" { RTOKEN(BEFORE); }
300 <WILD>"FILL" { RTOKEN(FILL); }
301 <SCRIPT>"STARTUP" { RTOKEN(STARTUP); }
302 <SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT); }
303 <SCRIPT>"OUTPUT_ARCH" { RTOKEN(OUTPUT_ARCH); }
304 <SCRIPT>"HLL" { RTOKEN(HLL); }
305 <SCRIPT>"SYSLIB" { RTOKEN(SYSLIB); }
306 <SCRIPT>"FLOAT" { RTOKEN(FLOAT); }
307 <WILD>"QUAD" { RTOKEN(QUAD); }
308 <WILD>"SQUAD" { RTOKEN(SQUAD); }
309 <WILD>"LONG" { RTOKEN(LONG); }
310 <WILD>"SHORT" { RTOKEN(SHORT); }
311 <WILD>"BYTE" { RTOKEN(BYTE); }
312 <SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT); }
313 <SCRIPT,EXPRESSION>"NOCROSSREFS" { RTOKEN(NOCROSSREFS); }
314 <SCRIPT,EXPRESSION>"NOCROSSREFS_TO" { RTOKEN(NOCROSSREFS_TO); }
315 <SCRIPT,EXPRESSION>"OVERLAY" { RTOKEN(OVERLAY); }
316 <WILD>"SORT_BY_NAME" { RTOKEN(SORT_BY_NAME); }
317 <WILD>"SORT_BY_ALIGNMENT" { RTOKEN(SORT_BY_ALIGNMENT); }
318 <WILD>"SORT" { RTOKEN(SORT_BY_NAME); }
319 <WILD>"SORT_BY_INIT_PRIORITY" { RTOKEN(SORT_BY_INIT_PRIORITY); }
320 <WILD>"SORT_NONE" { RTOKEN(SORT_NONE); }
321 <EXPRESSION>"NOLOAD" { RTOKEN(NOLOAD); }
322 <EXPRESSION>"READONLY" { RTOKEN(READONLY); }
323 <EXPRESSION>"DSECT" { RTOKEN(DSECT); }
324 <EXPRESSION>"COPY" { RTOKEN(COPY); }
325 <EXPRESSION>"INFO" { RTOKEN(INFO); }
326 <EXPRESSION>"TYPE" { RTOKEN(TYPE); }
327 <SCRIPT,EXPRESSION>"ONLY_IF_RO" { RTOKEN(ONLY_IF_RO); }
328 <SCRIPT,EXPRESSION>"ONLY_IF_RW" { RTOKEN(ONLY_IF_RW); }
329 <SCRIPT,EXPRESSION>"SPECIAL" { RTOKEN(SPECIAL); }
330 <SCRIPT>"o" { RTOKEN(ORIGIN); }
331 <SCRIPT>"org" { RTOKEN(ORIGIN); }
332 <SCRIPT>"l" { RTOKEN(LENGTH); }
333 <SCRIPT>"len" { RTOKEN(LENGTH); }
334 <WILD>"INPUT_SECTION_FLAGS" { RTOKEN(INPUT_SECTION_FLAGS); }
335 <SCRIPT,EXPRESSION,WILD,MRI>"INCLUDE" { RTOKEN(INCLUDE);}
336 <SCRIPT>"PHDRS" { RTOKEN(PHDRS); }
337 <SCRIPT,EXPRESSION,WILD>"AT" { RTOKEN(AT);}
338 <SCRIPT,EXPRESSION>"ALIGN_WITH_INPUT" { RTOKEN(ALIGN_WITH_INPUT);}
339 <SCRIPT,EXPRESSION>"SUBALIGN" { RTOKEN(SUBALIGN);}
340 <SCRIPT,EXPRESSION,WILD>"HIDDEN" { RTOKEN(HIDDEN); }
341 <SCRIPT,EXPRESSION,WILD>"PROVIDE" { RTOKEN(PROVIDE); }
342 <SCRIPT,EXPRESSION,WILD>"PROVIDE_HIDDEN" { RTOKEN(PROVIDE_HIDDEN); }
343 <WILD>"KEEP" { RTOKEN(KEEP); }
344 <WILD>"EXCLUDE_FILE" { RTOKEN(EXCLUDE_FILE); }
345 <SCRIPT,EXPRESSION>"CONSTANT" { RTOKEN(CONSTANT);}
347 <MRI>"#".*\n? { ++ lineno; }
348 <MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
349 <MRI>"*".* { /* Mri comment line */ }
350 <MRI>";".* { /* Mri comment line */ }
351 <MRI>"END" { RTOKEN(ENDWORD); }
352 <MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
353 <MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
354 <MRI>"ALIGN" { RTOKEN(ALIGN_K);}
355 <MRI>"CHIP" { RTOKEN(CHIP); }
356 <MRI>"BASE" { RTOKEN(BASE); }
357 <MRI>"ALIAS" { RTOKEN(ALIAS); }
358 <MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
359 <MRI>"LOAD" { RTOKEN(LOAD); }
360 <MRI>"PUBLIC" { RTOKEN(PUBLIC); }
361 <MRI>"ORDER" { RTOKEN(ORDER); }
362 <MRI>"NAME" { RTOKEN(NAMEWORD); }
363 <MRI>"FORMAT" { RTOKEN(FORMAT); }
364 <MRI>"CASE" { RTOKEN(CASE); }
365 <MRI>"START" { RTOKEN(START); }
366 <MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
367 <MRI>"SECT" { RTOKEN(SECT); }
368 <MRI>"end" { RTOKEN(ENDWORD); }
369 <MRI>"absolute" { RTOKEN(ABSOLUTE); }
370 <MRI>"alignmod" { RTOKEN(ALIGNMOD);}
371 <MRI>"align" { RTOKEN(ALIGN_K);}
372 <MRI>"chip" { RTOKEN(CHIP); }
373 <MRI>"base" { RTOKEN(BASE); }
374 <MRI>"alias" { RTOKEN(ALIAS); }
375 <MRI>"truncate" { RTOKEN(TRUNCATE); }
376 <MRI>"load" { RTOKEN(LOAD); }
377 <MRI>"public" { RTOKEN(PUBLIC); }
378 <MRI>"order" { RTOKEN(ORDER); }
379 <MRI>"name" { RTOKEN(NAMEWORD); }
380 <MRI>"format" { RTOKEN(FORMAT); }
381 <MRI>"case" { RTOKEN(CASE); }
382 <MRI>"extern" { RTOKEN(EXTERN); }
383 <MRI>"start" { RTOKEN(START); }
384 <MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
385 <MRI>"sect" { RTOKEN(SECT); }
387 <MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
388 /* Filename without commas, needed to parse mri stuff */
389 yylval.name = xstrdup (yytext);
394 <SCRIPT,INPUTLIST>{FILENAMECHAR1}{FILENAMECHAR}* {
395 yylval.name = xstrdup (yytext);
398 <INPUTLIST>"="{FILENAMECHAR1}{FILENAMECHAR}* {
399 /* Filename to be prefixed by --sysroot or when non-sysrooted, nothing. */
400 yylval.name = xstrdup (yytext);
403 <INPUTLIST>"-l"{FILENAMECHAR}+ {
404 yylval.name = xstrdup (yytext + 2);
407 <EXPRESSION>{SYMBOLNAMECHAR1}{SYMBOLNAMECHAR}* {
408 yylval.name = xstrdup (yytext);
411 /* The following rule is to prevent a fill expression on the output
412 section before /DISCARD/ interpreting the '/' as a divide. */
413 <EXPRESSION>"/DISCARD/" {
414 yylval.name = xstrdup (yytext);
418 /* Annoyingly, this pattern can match comments, and we have
419 longest match issues to consider. So if the first two
420 characters are a comment opening, put the input back and
422 if (yytext[0] == '/' && yytext[1] == '*')
429 yylval.name = xstrdup (yytext);
434 <SCRIPT,EXPRESSION,WILD,VERS_NODE,INPUTLIST>"\""[^\"]*"\"" {
435 /* No matter the state, quotes give what's inside. */
436 yylval.name = xmemdup (yytext + 1, yyleng - 2, yyleng - 1);
440 <SCRIPT,EXPRESSION,WILD,VERS_START,VERS_NODE,VERS_SCRIPT,INPUTLIST>"\n" {
442 <MRI,SCRIPT,EXPRESSION,WILD,VERS_START,VERS_NODE,VERS_SCRIPT,INPUTLIST>[ \t\r]+ {
443 /* Eat up whitespace */ }
444 <SCRIPT,EXPRESSION,WILD,VERS_START,VERS_NODE,VERS_SCRIPT>#.* {
445 /* Eat up comments */ }
447 <VERS_NODE,VERS_SCRIPT>[:,;] { return *yytext; }
449 <VERS_NODE>global { RTOKEN(GLOBAL); }
451 <VERS_NODE>local { RTOKEN(LOCAL); }
453 <VERS_NODE>extern { RTOKEN(EXTERN); }
455 <VERS_NODE>{V_IDENTIFIER} { yylval.name = xstrdup (yytext);
456 return VERS_IDENTIFIER; }
458 <VERS_SCRIPT>{V_TAG} { yylval.name = xstrdup (yytext);
461 <VERS_START>"{" { BEGIN(VERS_SCRIPT); return *yytext; }
463 <VERS_SCRIPT>"{" { BEGIN(VERS_NODE);
464 vers_node_nesting = 0;
467 <VERS_SCRIPT>"}" { return *yytext; }
468 <VERS_NODE>"{" { vers_node_nesting++; return *yytext; }
469 <VERS_NODE>"}" { if (--vers_node_nesting < 0)
476 if (include_stack_ptr == 0)
482 yy_switch_to_buffer (include_stack[include_stack_ptr]);
484 lineno = lineno_stack[include_stack_ptr];
485 input_flags.sysrooted = sysrooted_stack[include_stack_ptr];
490 <SCRIPT,WILD,MRI,VERS_START,VERS_SCRIPT,VERS_NODE>. lex_warn_invalid (" in script", yytext);
491 <EXPRESSION>. lex_warn_invalid (" in expression", yytext);
496 /* Switch flex to reading script file NAME, open on FILE,
497 saving the current input info on the include stack. */
500 lex_push_file (FILE *file, const char *name, unsigned int sysrooted)
502 if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
504 einfo (_("%F:includes nested too deeply\n"));
506 file_name_stack[include_stack_ptr] = name;
507 lineno_stack[include_stack_ptr] = lineno;
508 sysrooted_stack[include_stack_ptr] = input_flags.sysrooted;
509 include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
513 input_flags.sysrooted = sysrooted;
515 yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE));
518 /* Return a newly created flex input buffer containing STRING,
519 which is SIZE bytes long. */
521 static YY_BUFFER_STATE
522 yy_create_string_buffer (const char *string, size_t size)
526 b = xmalloc (sizeof (struct yy_buffer_state));
527 b->yy_input_file = 0;
528 b->yy_buf_size = size;
530 /* yy_ch_buf has to be 2 characters longer than the size given because
531 we need to put in 2 end-of-buffer characters. */
532 b->yy_ch_buf = xmalloc ((size_t) b->yy_buf_size + 3);
534 b->yy_ch_buf[0] = '\n';
535 strcpy (b->yy_ch_buf+1, string);
536 b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
537 b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
538 b->yy_n_chars = size+1;
539 b->yy_buf_pos = &b->yy_ch_buf[1];
541 b->yy_is_our_buffer = 1;
542 b->yy_is_interactive = 0;
544 b->yy_fill_buffer = 0;
546 /* flex 2.4.7 changed the interface. FIXME: We should not be using
547 a flex internal interface in the first place! */
549 b->yy_buffer_status = YY_BUFFER_NEW;
551 b->yy_eof_status = EOF_NOT_SEEN;
557 /* Switch flex to reading from STRING, saving the current input info
558 on the include stack. */
561 lex_redirect (const char *string, const char *fake_filename, unsigned int count)
566 if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
568 einfo (_("%F: macros nested too deeply\n"));
570 file_name_stack[include_stack_ptr] = fake_filename;
571 lineno_stack[include_stack_ptr] = lineno;
572 include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
575 tmp = yy_create_string_buffer (string, strlen (string));
576 yy_switch_to_buffer (tmp);
579 /* Functions to switch to a different flex start condition,
580 saving the current start condition on `state_stack'. */
582 static int state_stack[MAX_INCLUDE_DEPTH * 2];
583 static int *state_stack_p = state_stack;
588 *(state_stack_p)++ = yy_start;
593 ldlex_inputlist (void)
595 *(state_stack_p)++ = yy_start;
600 ldlex_mri_script (void)
602 *(state_stack_p)++ = yy_start;
607 ldlex_version_script (void)
609 *(state_stack_p)++ = yy_start;
614 ldlex_version_file (void)
616 *(state_stack_p)++ = yy_start;
621 ldlex_expression (void)
623 *(state_stack_p)++ = yy_start;
630 *(state_stack_p)++ = yy_start;
635 ldlex_popstate (void)
637 yy_start = *(--state_stack_p);
640 /* In cases where the parser needs to look ahead and the context
641 changes from expression to script or vice-versa, throw away a
642 NAME. What constitutes a NAME depends on context. */
650 /* Return the current file name, or the previous file if no file is
654 ldlex_filename (void)
656 return file_name_stack[include_stack_ptr - (include_stack_ptr != 0)];
660 /* Place up to MAX_SIZE characters in BUF and return
661 either the number of characters read, or 0 to indicate EOF. */
664 yy_input (char *buf, int max_size)
667 if (YY_CURRENT_BUFFER->yy_input_file)
671 result = fread (buf, 1, max_size, yyin);
672 if (result < max_size && ferror (yyin))
673 einfo (_("%F%P: read in flex scanner failed\n"));
679 /* Eat the rest of a C-style comment. */
689 while (c != '*' && c != 0)
702 break; /* found the end */
710 einfo (_("%F%P: EOF in comment\n"));
716 /* Warn the user about a garbage character WHAT in the input
720 lex_warn_invalid (char *where, char *what)
724 /* If we have found an input file whose format we do not recognize,
725 and we are therefore treating it as a linker script, and we find
726 an invalid character, then most likely this is a real object file
727 of some different format. Treat it as such. */
728 if (ldfile_assumed_script)
730 bfd_set_error (bfd_error_file_not_recognized);
731 einfo (_("%F%s: file not recognized: %E\n"), ldlex_filename ());
734 if (! ISPRINT (*what))
736 sprintf (buf, "\\%03o", *(unsigned char *) what);
740 einfo (_("%P:%pS: ignoring invalid character `%s'%s\n"), NULL, what, where);