*** empty log message ***
[deliverable/binutils-gdb.git] / ld / ldlex.l
CommitLineData
252b5132
RH
1%{
2
968ec2b9 3/* Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3db64b00
AM
4 2000, 2001, 2002, 2003, 2004, 2005, 2007
5 Free Software Foundation, Inc.
252b5132 6
3ec57632 7 This file is part of GLD, the Gnu Linker.
252b5132 8
3ec57632
NC
9 GLD is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
12 any later version.
252b5132 13
3ec57632
NC
14 GLD is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
252b5132 18
3ec57632
NC
19 You should have received a copy of the GNU General Public License
20 along with GLD; see the file COPYING. If not, write to the Free
75be928b
NC
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
252b5132
RH
23
24/*
25This was written by steve chamberlain
26 sac@cygnus.com
27*/
28
252b5132 29#include "sysdep.h"
3db64b00 30#include "bfd.h"
3882b010 31#include "safe-ctype.h"
e3e942e9 32#include "bfdlink.h"
252b5132 33#include "ld.h"
252b5132
RH
34#include "ldmisc.h"
35#include "ldexp.h"
36#include "ldlang.h"
df2a7313 37#include <ldgram.h>
252b5132
RH
38#include "ldfile.h"
39#include "ldlex.h"
40#include "ldmain.h"
d1b2b2dc 41#include "libiberty.h"
252b5132
RH
42
43/* The type of top-level parser input.
44 yylex and yyparse (indirectly) both check this. */
45input_type parser_input;
46
47/* Line number in the current input file.
48 (FIXME Actually, it doesn't appear to get reset for each file?) */
49unsigned int lineno = 1;
50
51/* The string we are currently lexing, or NULL if we are reading a
52 file. */
53const char *lex_string = NULL;
54
55/* Support for flex reading from more than one input file (stream).
56 `include_stack' is flex's input state for each open file;
57 `file_name_stack' is the file names. `lineno_stack' is the current
58 line numbers.
59
60 If `include_stack_ptr' is 0, we haven't started reading anything yet.
61 Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */
62
63#undef YY_INPUT
1579bae1 64#define YY_INPUT(buf,result,max_size) yy_input (buf, &result, max_size)
252b5132 65
297ba367
NC
66#define YY_NO_UNPUT
67
252b5132
RH
68#define MAX_INCLUDE_DEPTH 10
69static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
70static const char *file_name_stack[MAX_INCLUDE_DEPTH];
71static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
72static unsigned int include_stack_ptr = 0;
73static int vers_node_nesting = 0;
74
1579bae1
AM
75static void yy_input (char *, int *, int);
76static void comment (void);
77static void lex_warn_invalid (char *where, char *what);
252b5132 78
1579bae1 79/* STATES
252b5132
RH
80 EXPRESSION definitely in an expression
81 SCRIPT definitely in a script
82 BOTH either EXPRESSION or SCRIPT
83 DEFSYMEXP in an argument to -defsym
84 MRI in an MRI script
85 VERS_START starting a Sun style mapfile
86 VERS_SCRIPT a Sun style mapfile
87 VERS_NODE a node within a Sun style mapfile
88*/
89#define RTOKEN(x) { yylval.token = x; return x; }
90
91/* Some versions of flex want this. */
92#ifndef yywrap
1579bae1 93int yywrap (void) { return 1; }
252b5132
RH
94#endif
95%}
96
97%a 4000
98%o 5000
99
100CMDFILENAMECHAR [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
101CMDFILENAMECHAR1 [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
102FILENAMECHAR1 [_a-zA-Z\/\.\\\$\_\~]
103SYMBOLCHARN [_a-zA-Z\/\.\\\$\_\~0-9]
104FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
105WILDCHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~\?\*]
1579bae1 106WHITE [ \t\n\r]+
252b5132
RH
107
108NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
109
110V_TAG [.$_a-zA-Z][._a-zA-Z0-9]*
5e35cbc2 111V_IDENTIFIER [*?.$_a-zA-Z\[\]\-\!\^\\]([*?.$_a-zA-Z0-9\[\]\-\!\^\\]|::)*
252b5132
RH
112
113%s SCRIPT
114%s EXPRESSION
115%s BOTH
116%s DEFSYMEXP
117%s MRI
118%s VERS_START
119%s VERS_SCRIPT
120%s VERS_NODE
121%%
122
123 if (parser_input != input_selected)
124 {
125 /* The first token of the input determines the initial parser state. */
126 input_type t = parser_input;
127 parser_input = input_selected;
128 switch (t)
129 {
130 case input_script: return INPUT_SCRIPT; break;
131 case input_mri_script: return INPUT_MRI_SCRIPT; break;
132 case input_version_script: return INPUT_VERSION_SCRIPT; break;
55255dae 133 case input_dynamic_list: return INPUT_DYNAMIC_LIST; break;
252b5132
RH
134 case input_defsym: return INPUT_DEFSYM; break;
135 default: abort ();
136 }
137 }
138
1579bae1 139<BOTH,SCRIPT,EXPRESSION,VERS_START,VERS_NODE,VERS_SCRIPT>"/*" { comment (); }
252b5132
RH
140
141
142<DEFSYMEXP>"-" { RTOKEN('-');}
143<DEFSYMEXP>"+" { RTOKEN('+');}
1579bae1 144<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = xstrdup (yytext); return NAME; }
252b5132
RH
145<DEFSYMEXP>"=" { RTOKEN('='); }
146
147<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
1579bae1
AM
148 yylval.integer = bfd_scan_vma (yytext + 1, 0, 16);
149 yylval.bigint.str = NULL;
252b5132
RH
150 return INT;
151 }
152
153<MRI,EXPRESSION>([0-9A-Fa-f])+(H|h|X|x|B|b|O|o|D|d) {
154 int ibase ;
1579bae1
AM
155 switch (yytext[yyleng - 1]) {
156 case 'X':
252b5132
RH
157 case 'x':
158 case 'H':
159 case 'h':
160 ibase = 16;
161 break;
162 case 'O':
163 case 'o':
164 ibase = 8;
165 break;
166 case 'B':
167 case 'b':
168 ibase = 2;
169 break;
170 default:
171 ibase = 10;
172 }
173 yylval.integer = bfd_scan_vma (yytext, 0,
174 ibase);
1579bae1 175 yylval.bigint.str = NULL;
252b5132
RH
176 return INT;
177 }
2c382fb6 178<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>((("$"|0[xX])([0-9A-Fa-f])+)|(([0-9])+))(M|K|m|k)? {
252b5132 179 char *s = yytext;
2c382fb6 180 int ibase = 0;
252b5132
RH
181
182 if (*s == '$')
2c382fb6
AM
183 {
184 ++s;
185 ibase = 16;
186 }
187 yylval.integer = bfd_scan_vma (s, 0, ibase);
1579bae1
AM
188 yylval.bigint.str = NULL;
189 if (yytext[yyleng - 1] == 'M'
190 || yytext[yyleng - 1] == 'm')
2c382fb6
AM
191 {
192 yylval.integer *= 1024 * 1024;
193 }
1579bae1
AM
194 else if (yytext[yyleng - 1] == 'K'
195 || yytext[yyleng - 1]=='k')
2c382fb6
AM
196 {
197 yylval.integer *= 1024;
198 }
199 else if (yytext[0] == '0'
200 && (yytext[1] == 'x'
201 || yytext[1] == 'X'))
202 {
203 yylval.bigint.str = xstrdup (yytext + 2);
204 }
252b5132
RH
205 return INT;
206 }
207<BOTH,SCRIPT,EXPRESSION,MRI>"]" { RTOKEN(']');}
208<BOTH,SCRIPT,EXPRESSION,MRI>"[" { RTOKEN('[');}
209<BOTH,SCRIPT,EXPRESSION,MRI>"<<=" { RTOKEN(LSHIFTEQ);}
210<BOTH,SCRIPT,EXPRESSION,MRI>">>=" { RTOKEN(RSHIFTEQ);}
211<BOTH,SCRIPT,EXPRESSION,MRI>"||" { RTOKEN(OROR);}
212<BOTH,SCRIPT,EXPRESSION,MRI>"==" { RTOKEN(EQ);}
213<BOTH,SCRIPT,EXPRESSION,MRI>"!=" { RTOKEN(NE);}
214<BOTH,SCRIPT,EXPRESSION,MRI>">=" { RTOKEN(GE);}
215<BOTH,SCRIPT,EXPRESSION,MRI>"<=" { RTOKEN(LE);}
216<BOTH,SCRIPT,EXPRESSION,MRI>"<<" { RTOKEN(LSHIFT);}
217<BOTH,SCRIPT,EXPRESSION,MRI>">>" { RTOKEN(RSHIFT);}
218<BOTH,SCRIPT,EXPRESSION,MRI>"+=" { RTOKEN(PLUSEQ);}
219<BOTH,SCRIPT,EXPRESSION,MRI>"-=" { RTOKEN(MINUSEQ);}
220<BOTH,SCRIPT,EXPRESSION,MRI>"*=" { RTOKEN(MULTEQ);}
221<BOTH,SCRIPT,EXPRESSION,MRI>"/=" { RTOKEN(DIVEQ);}
222<BOTH,SCRIPT,EXPRESSION,MRI>"&=" { RTOKEN(ANDEQ);}
223<BOTH,SCRIPT,EXPRESSION,MRI>"|=" { RTOKEN(OREQ);}
224<BOTH,SCRIPT,EXPRESSION,MRI>"&&" { RTOKEN(ANDAND);}
225<BOTH,SCRIPT,EXPRESSION,MRI>">" { RTOKEN('>');}
226<BOTH,SCRIPT,EXPRESSION,MRI>"," { RTOKEN(',');}
227<BOTH,SCRIPT,EXPRESSION,MRI>"&" { RTOKEN('&');}
228<BOTH,SCRIPT,EXPRESSION,MRI>"|" { RTOKEN('|');}
229<BOTH,SCRIPT,EXPRESSION,MRI>"~" { RTOKEN('~');}
230<BOTH,SCRIPT,EXPRESSION,MRI>"!" { RTOKEN('!');}
231<BOTH,SCRIPT,EXPRESSION,MRI>"?" { RTOKEN('?');}
232<BOTH,SCRIPT,EXPRESSION,MRI>"*" { RTOKEN('*');}
233<BOTH,SCRIPT,EXPRESSION,MRI>"+" { RTOKEN('+');}
234<BOTH,SCRIPT,EXPRESSION,MRI>"-" { RTOKEN('-');}
235<BOTH,SCRIPT,EXPRESSION,MRI>"/" { RTOKEN('/');}
236<BOTH,SCRIPT,EXPRESSION,MRI>"%" { RTOKEN('%');}
237<BOTH,SCRIPT,EXPRESSION,MRI>"<" { RTOKEN('<');}
3ec57632
NC
238<BOTH,SCRIPT,EXPRESSION,MRI>"=" { RTOKEN('=');}
239<BOTH,SCRIPT,EXPRESSION,MRI>"}" { RTOKEN('}') ; }
240<BOTH,SCRIPT,EXPRESSION,MRI>"{" { RTOKEN('{'); }
241<BOTH,SCRIPT,EXPRESSION,MRI>")" { RTOKEN(')');}
242<BOTH,SCRIPT,EXPRESSION,MRI>"(" { RTOKEN('(');}
252b5132
RH
243<BOTH,SCRIPT,EXPRESSION,MRI>":" { RTOKEN(':'); }
244<BOTH,SCRIPT,EXPRESSION,MRI>";" { RTOKEN(';');}
3ec57632
NC
245<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
246<BOTH,SCRIPT,EXPRESSION>"ORIGIN" { RTOKEN(ORIGIN);}
247<BOTH,SCRIPT>"VERSION" { RTOKEN(VERSIONK);}
252b5132
RH
248<EXPRESSION,BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
249<EXPRESSION,BOTH,SCRIPT>"BIND" { RTOKEN(BIND);}
3ec57632
NC
250<BOTH,SCRIPT,EXPRESSION>"LENGTH" { RTOKEN(LENGTH);}
251<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
2d20f7bf 252<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_ALIGN" { RTOKEN(DATA_SEGMENT_ALIGN);}
8c37241b 253<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_RELRO_END" { RTOKEN(DATA_SEGMENT_RELRO_END);}
2d20f7bf 254<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_END" { RTOKEN(DATA_SEGMENT_END);}
3ec57632
NC
255<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
256<EXPRESSION,BOTH,SCRIPT>"LOADADDR" { RTOKEN(LOADADDR);}
252b5132
RH
257<EXPRESSION,BOTH>"MAX" { RTOKEN(MAX_K); }
258<EXPRESSION,BOTH>"MIN" { RTOKEN(MIN_K); }
259<EXPRESSION,BOTH>"ASSERT" { RTOKEN(ASSERT_K); }
260<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
261<BOTH,SCRIPT,MRI>"EXTERN" { RTOKEN(EXTERN);}
3ec57632 262<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
252b5132
RH
263<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
264<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
ba916c8a 265<EXPRESSION,BOTH,SCRIPT>"SEGMENT_START" { RTOKEN(SEGMENT_START);}
252b5132 266<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
3ec57632
NC
267<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
268<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
252b5132 269<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
3ec57632 270<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
252b5132
RH
271<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
272<EXPRESSION,BOTH,SCRIPT>"GROUP" { RTOKEN(GROUP);}
b717d30e 273<EXPRESSION,BOTH,SCRIPT>"AS_NEEDED" { RTOKEN(AS_NEEDED);}
3ec57632 274<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
252b5132
RH
275<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
276<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
3ec57632 277<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
4818e05f 278<BOTH,SCRIPT>"INHIBIT_COMMON_ALLOCATION" { RTOKEN(INHIBIT_COMMON_ALLOCATION);}
3ec57632 279<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
252b5132 280<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
3ec57632 281<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
252b5132
RH
282<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
283<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
284<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
3ec57632 285<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
252b5132
RH
286<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
287<BOTH,SCRIPT>"QUAD" { RTOKEN( QUAD);}
288<BOTH,SCRIPT>"SQUAD" { RTOKEN( SQUAD);}
289<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
290<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
291<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
3ec57632 292<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
252b5132
RH
293<EXPRESSION,BOTH,SCRIPT>"NOCROSSREFS" { RTOKEN(NOCROSSREFS);}
294<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY); }
bcaa7b3e
L
295<BOTH,SCRIPT>"SORT_BY_NAME" { RTOKEN(SORT_BY_NAME); }
296<BOTH,SCRIPT>"SORT_BY_ALIGNMENT" { RTOKEN(SORT_BY_ALIGNMENT); }
297<BOTH,SCRIPT>"SORT" { RTOKEN(SORT_BY_NAME); }
252b5132
RH
298<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
299<EXPRESSION,BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
300<EXPRESSION,BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
301<EXPRESSION,BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
302<EXPRESSION,BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
0841712e
JJ
303<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RO" { RTOKEN(ONLY_IF_RO); }
304<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RW" { RTOKEN(ONLY_IF_RW); }
0cf7d72c 305<EXPRESSION,BOTH,SCRIPT>"SPECIAL" { RTOKEN(SPECIAL); }
252b5132
RH
306<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
307<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
308<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
309<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
310<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
311<BOTH,SCRIPT>"PHDRS" { RTOKEN (PHDRS); }
3ec57632
NC
312<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
313<EXPRESSION,BOTH,SCRIPT>"SUBALIGN" { RTOKEN(SUBALIGN);}
314<EXPRESSION,BOTH,SCRIPT>"PROVIDE" { RTOKEN(PROVIDE); }
7af8e998 315<EXPRESSION,BOTH,SCRIPT>"PROVIDE_HIDDEN" { RTOKEN(PROVIDE_HIDDEN); }
252b5132 316<EXPRESSION,BOTH,SCRIPT>"KEEP" { RTOKEN(KEEP); }
3ec57632 317<EXPRESSION,BOTH,SCRIPT>"EXCLUDE_FILE" { RTOKEN(EXCLUDE_FILE); }
24718e3b 318<EXPRESSION,BOTH,SCRIPT>"CONSTANT" { RTOKEN(CONSTANT);}
252b5132
RH
319<MRI>"#".*\n? { ++ lineno; }
320<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
321<MRI>"*".* { /* Mri comment line */ }
322<MRI>";".* { /* Mri comment line */ }
323<MRI>"END" { RTOKEN(ENDWORD); }
3ec57632
NC
324<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
325<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
252b5132
RH
326<MRI>"CHIP" { RTOKEN(CHIP); }
327<MRI>"BASE" { RTOKEN(BASE); }
3ec57632
NC
328<MRI>"ALIAS" { RTOKEN(ALIAS); }
329<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
252b5132
RH
330<MRI>"LOAD" { RTOKEN(LOAD); }
331<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
332<MRI>"ORDER" { RTOKEN(ORDER); }
333<MRI>"NAME" { RTOKEN(NAMEWORD); }
334<MRI>"FORMAT" { RTOKEN(FORMAT); }
335<MRI>"CASE" { RTOKEN(CASE); }
336<MRI>"START" { RTOKEN(START); }
337<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
338<MRI>"SECT" { RTOKEN(SECT); }
339<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
340<MRI>"end" { RTOKEN(ENDWORD); }
3ec57632
NC
341<MRI>"alignmod" { RTOKEN(ALIGNMOD);}
342<MRI>"align" { RTOKEN(ALIGN_K);}
252b5132
RH
343<MRI>"chip" { RTOKEN(CHIP); }
344<MRI>"base" { RTOKEN(BASE); }
3ec57632
NC
345<MRI>"alias" { RTOKEN(ALIAS); }
346<MRI>"truncate" { RTOKEN(TRUNCATE); }
252b5132
RH
347<MRI>"load" { RTOKEN(LOAD); }
348<MRI>"public" { RTOKEN(PUBLIC); }
349<MRI>"order" { RTOKEN(ORDER); }
350<MRI>"name" { RTOKEN(NAMEWORD); }
351<MRI>"format" { RTOKEN(FORMAT); }
352<MRI>"case" { RTOKEN(CASE); }
353<MRI>"extern" { RTOKEN(EXTERN); }
354<MRI>"start" { RTOKEN(START); }
355<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
356<MRI>"sect" { RTOKEN(SECT); }
357<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
358
359<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
360/* Filename without commas, needed to parse mri stuff */
1579bae1 361 yylval.name = xstrdup (yytext);
252b5132
RH
362 return NAME;
363 }
364
365
366<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
1579bae1 367 yylval.name = xstrdup (yytext);
252b5132
RH
368 return NAME;
369 }
370<BOTH,EXPRESSION>"-l"{FILENAMECHAR}+ {
d1b2b2dc 371 yylval.name = xstrdup (yytext + 2);
252b5132
RH
372 return LNAME;
373 }
374<SCRIPT>{WILDCHAR}* {
375 /* Annoyingly, this pattern can match comments, and we have
376 longest match issues to consider. So if the first two
377 characters are a comment opening, put the input back and
378 try again. */
379 if (yytext[0] == '/' && yytext[1] == '*')
380 {
1579bae1 381 yyless (2);
252b5132
RH
382 comment ();
383 }
384 else
385 {
1579bae1 386 yylval.name = xstrdup (yytext);
252b5132
RH
387 return NAME;
388 }
389 }
390
391<EXPRESSION,BOTH,SCRIPT,VERS_NODE>"\""[^\"]*"\"" {
392 /* No matter the state, quotes
393 give what's inside */
1579bae1
AM
394 yylval.name = xstrdup (yytext + 1);
395 yylval.name[yyleng - 2] = 0;
252b5132
RH
396 return NAME;
397 }
398<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
399<MRI,BOTH,SCRIPT,EXPRESSION>[ \t\r]+ { }
400
401<VERS_NODE,VERS_SCRIPT>[:,;] { return *yytext; }
402
403<VERS_NODE>global { RTOKEN(GLOBAL); }
404
405<VERS_NODE>local { RTOKEN(LOCAL); }
406
407<VERS_NODE>extern { RTOKEN(EXTERN); }
408
d1b2b2dc 409<VERS_NODE>{V_IDENTIFIER} { yylval.name = xstrdup (yytext);
252b5132
RH
410 return VERS_IDENTIFIER; }
411
d1b2b2dc 412<VERS_SCRIPT>{V_TAG} { yylval.name = xstrdup (yytext);
252b5132
RH
413 return VERS_TAG; }
414
415<VERS_START>"{" { BEGIN(VERS_SCRIPT); return *yytext; }
416
1579bae1 417<VERS_SCRIPT>"{" { BEGIN(VERS_NODE);
252b5132
RH
418 vers_node_nesting = 0;
419 return *yytext;
420 }
421<VERS_SCRIPT>"}" { return *yytext; }
422<VERS_NODE>"{" { vers_node_nesting++; return *yytext; }
423<VERS_NODE>"}" { if (--vers_node_nesting < 0)
424 BEGIN(VERS_SCRIPT);
425 return *yytext;
426 }
427
428<VERS_START,VERS_NODE,VERS_SCRIPT>[\n] { lineno++; }
429
430<VERS_START,VERS_NODE,VERS_SCRIPT>#.* { /* Eat up comments */ }
431
432<VERS_START,VERS_NODE,VERS_SCRIPT>[ \t\r]+ { /* Eat up whitespace */ }
433
434<<EOF>> {
435 include_stack_ptr--;
1579bae1
AM
436
437 if (include_stack_ptr == 0)
252b5132 438 {
1579bae1 439 yyterminate ();
252b5132 440 }
1579bae1 441 else
252b5132 442 {
1579bae1 443 yy_switch_to_buffer (include_stack[include_stack_ptr]);
252b5132 444 }
b47c4208 445
252b5132 446 ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
b47c4208 447 lineno = lineno_stack[include_stack_ptr];
252b5132
RH
448
449 return END;
450}
451
1579bae1
AM
452<SCRIPT,MRI,VERS_START,VERS_SCRIPT,VERS_NODE>. lex_warn_invalid (" in script", yytext);
453<EXPRESSION,DEFSYMEXP,BOTH>. lex_warn_invalid (" in expression", yytext);
454
252b5132
RH
455%%
456\f
457
458/* Switch flex to reading script file NAME, open on FILE,
459 saving the current input info on the include stack. */
460
461void
1579bae1 462lex_push_file (FILE *file, const char *name)
252b5132 463{
1579bae1 464 if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
252b5132 465 {
1579bae1 466 einfo ("%F:includes nested too deeply\n");
252b5132
RH
467 }
468 file_name_stack[include_stack_ptr] = name;
b47c4208 469 lineno_stack[include_stack_ptr] = lineno;
252b5132
RH
470 include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
471
472 include_stack_ptr++;
b47c4208 473 lineno = 1;
252b5132 474 yyin = file;
1579bae1 475 yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE));
252b5132
RH
476}
477
478/* Return a newly created flex input buffer containing STRING,
479 which is SIZE bytes long. */
480
1579bae1
AM
481static YY_BUFFER_STATE
482yy_create_string_buffer (const char *string, size_t size)
252b5132
RH
483{
484 YY_BUFFER_STATE b;
485
486 /* Calls to m-alloc get turned by sed into xm-alloc. */
1579bae1 487 b = malloc (sizeof (struct yy_buffer_state));
252b5132
RH
488 b->yy_input_file = 0;
489 b->yy_buf_size = size;
490
491 /* yy_ch_buf has to be 2 characters longer than the size given because
492 we need to put in 2 end-of-buffer characters. */
1579bae1 493 b->yy_ch_buf = malloc ((unsigned) (b->yy_buf_size + 3));
252b5132
RH
494
495 b->yy_ch_buf[0] = '\n';
496 strcpy (b->yy_ch_buf+1, string);
497 b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
498 b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
499 b->yy_n_chars = size+1;
500 b->yy_buf_pos = &b->yy_ch_buf[1];
501
dca7760f
AM
502 b->yy_is_our_buffer = 1;
503 b->yy_is_interactive = 0;
504 b->yy_at_bol = 1;
505 b->yy_fill_buffer = 0;
506
252b5132
RH
507 /* flex 2.4.7 changed the interface. FIXME: We should not be using
508 a flex internal interface in the first place! */
509#ifdef YY_BUFFER_NEW
510 b->yy_buffer_status = YY_BUFFER_NEW;
511#else
512 b->yy_eof_status = EOF_NOT_SEEN;
513#endif
514
515 return b;
516}
517
518/* Switch flex to reading from STRING, saving the current input info
519 on the include stack. */
520
521void
1579bae1 522lex_redirect (const char *string)
252b5132
RH
523{
524 YY_BUFFER_STATE tmp;
525
526 yy_init = 0;
1579bae1 527 if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
252b5132
RH
528 {
529 einfo("%F: macros nested too deeply\n");
530 }
531 file_name_stack[include_stack_ptr] = "redirect";
b47c4208 532 lineno_stack[include_stack_ptr] = lineno;
252b5132
RH
533 include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
534 include_stack_ptr++;
b47c4208 535 lineno = 1;
252b5132
RH
536 tmp = yy_create_string_buffer (string, strlen (string));
537 yy_switch_to_buffer (tmp);
252b5132
RH
538}
539\f
540/* Functions to switch to a different flex start condition,
541 saving the current start condition on `state_stack'. */
542
543static int state_stack[MAX_INCLUDE_DEPTH * 2];
544static int *state_stack_p = state_stack;
545
546void
1579bae1 547ldlex_script (void)
252b5132
RH
548{
549 *(state_stack_p)++ = yy_start;
550 BEGIN (SCRIPT);
551}
552
553void
1579bae1 554ldlex_mri_script (void)
252b5132
RH
555{
556 *(state_stack_p)++ = yy_start;
557 BEGIN (MRI);
558}
559
560void
1579bae1 561ldlex_version_script (void)
252b5132
RH
562{
563 *(state_stack_p)++ = yy_start;
564 BEGIN (VERS_START);
565}
566
567void
1579bae1 568ldlex_version_file (void)
252b5132
RH
569{
570 *(state_stack_p)++ = yy_start;
571 BEGIN (VERS_SCRIPT);
572}
573
574void
1579bae1 575ldlex_defsym (void)
252b5132
RH
576{
577 *(state_stack_p)++ = yy_start;
578 BEGIN (DEFSYMEXP);
579}
1579bae1 580
252b5132 581void
1579bae1 582ldlex_expression (void)
252b5132
RH
583{
584 *(state_stack_p)++ = yy_start;
585 BEGIN (EXPRESSION);
586}
587
588void
1579bae1 589ldlex_both (void)
252b5132
RH
590{
591 *(state_stack_p)++ = yy_start;
592 BEGIN (BOTH);
593}
594
595void
1579bae1 596ldlex_popstate (void)
252b5132
RH
597{
598 yy_start = *(--state_stack_p);
599}
600\f
601
602/* Place up to MAX_SIZE characters in BUF and return in *RESULT
603 either the number of characters read, or 0 to indicate EOF. */
604
605static void
1579bae1 606yy_input (char *buf, int *result, int max_size)
252b5132 607{
1579bae1 608 *result = 0;
731e28d8 609 if (YY_CURRENT_BUFFER->yy_input_file)
252b5132
RH
610 {
611 if (yyin)
612 {
1579bae1
AM
613 *result = fread (buf, 1, max_size, yyin);
614 if (*result < max_size && ferror (yyin))
252b5132
RH
615 einfo ("%F%P: read in flex scanner failed\n");
616 }
617 }
618}
619
620/* Eat the rest of a C-style comment. */
621
622static void
1579bae1 623comment (void)
252b5132
RH
624{
625 int c;
626
627 while (1)
628 {
629 c = input();
1579bae1 630 while (c != '*' && c != EOF)
252b5132
RH
631 {
632 if (c == '\n')
633 lineno++;
634 c = input();
635 }
636
637 if (c == '*')
638 {
639 c = input();
640 while (c == '*')
641 c = input();
642 if (c == '/')
643 break; /* found the end */
644 }
645
646 if (c == '\n')
647 lineno++;
648
649 if (c == EOF)
650 {
651 einfo( "%F%P: EOF in comment\n");
652 break;
653 }
654 }
655}
656
657/* Warn the user about a garbage character WHAT in the input
658 in context WHERE. */
659
660static void
1579bae1 661lex_warn_invalid (char *where, char *what)
252b5132
RH
662{
663 char buf[5];
664
665 /* If we have found an input file whose format we do not recognize,
666 and we are therefore treating it as a linker script, and we find
667 an invalid character, then most likely this is a real object file
668 of some different format. Treat it as such. */
669 if (ldfile_assumed_script)
670 {
671 bfd_set_error (bfd_error_file_not_recognized);
672 einfo ("%F%s: file not recognized: %E\n", ldfile_input_filename);
673 }
674
3882b010 675 if (! ISPRINT (*what))
252b5132
RH
676 {
677 sprintf (buf, "\\%03o", (unsigned int) *what);
678 what = buf;
679 }
680
681 einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where);
682}
This page took 0.354291 seconds and 4 git commands to generate.