source: trunk/src/binutils/ld/ldlex.l@ 73

Last change on this file since 73 was 10, checked in by bird, 23 years ago

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