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