%{
-/* Copyright (C) 1991 Free Software Foundation, Inc.
+
+/* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
This file is part of GLD, the Gnu Linker.
GLD is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
any later version.
GLD is distributed in the hope that it will be useful,
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/*
- * $Id$
-
- *
+This was written by steve chamberlain
*/
-
-/*SUPPRESS 529*/
-/*SUPPRESS 26*/
-/*SUPPRESS 29*/
-#define LEXDEBUG 0
-#include "sysdep.h"
+#include <ansidecl.h>
+#include <stdio.h>
+/* start-sanitize-mpw */
+#ifdef MPW
+/* Prevent enum redefinition problems. */
+#define TRUE_FALSE_ALREADY_DEFINED
+#endif /* MPW */
+/* end-sanitize-mpw */
#include "bfd.h"
-
-#include <ctype.h>
-#include "ldlex.h"
-
+#include "sysdep.h"
#include "ld.h"
-#include "ldexp.h"
-#include "ldgram.tab.h"
+#include "ldgram.h"
#include "ldmisc.h"
+#include "ldexp.h"
+#include "ldlang.h"
+#include "ldfile.h"
+#include "ldlex.h"
+#include "ldmain.h"
-#undef input
-#undef unput
-#define input lex_input
-#define unput lex_unput
-int debug;
+/* The type of top-level parser input.
+ yylex and yyparse (indirectly) both check this. */
+input_type parser_input;
-extern boolean ldgram_in_expression;
-extern boolean ldgram_in_defsym;
-extern boolean ldgram_in_script;
-static char *command_line;
+/* Radix to use for bfd_scan_vma -- 0 (default to base 10) or 16. */
+int hex_mode;
-extern int fgetc();
-extern int yyparse();
+/* Line number in the current input file.
+ (FIXME Actually, it doesn't appear to get reset for each file?) */
+unsigned int lineno = 1;
-typedef struct {
- char *name;
-int value;
-} keyword_type;
-#define RTOKEN(x) { yylval.token = x; return x; }
-keyword_type keywords[] =
-{
-"MEMORY",MEMORY,
-"ORIGIN",ORIGIN,
-"BLOCK",BLOCK,
-"LENGTH",LENGTH,
-"ALIGN",ALIGN_K,
-"SUBSECTION_ALIGN",SUBSECTION_ALIGN,
-"ADDR",ADDR,
-"ENTRY",ENTRY,
-"SCRIPT", SCRIPT,
-"ENDSCRIPT", ENDSCRIPT,
-"NEXT",NEXT,
-"MAP",MAP,
-"SIZEOF",SIZEOF,
-"TARGET",TARGET_K,
-"SEARCH_DIR",SEARCH_DIR,
-"OUTPUT",OUTPUT,
-"INPUT",INPUT,
-"DEFINED",DEFINED,
-"CREATE_OBJECT_SYMBOLS",CREATE_OBJECT_SYMBOLS,
-"FORCE_COMMON_ALLOCATION",FORCE_COMMON_ALLOCATION,
-"SECTIONS",SECTIONS,
-"FILL",FILL,
-"STARTUP",STARTUP,
-"OUTPUT_FORMAT",OUTPUT_FORMAT,
-"HLL",HLL,
-"SYSLIB",SYSLIB,
-"FLOAT",FLOAT,
-"LONG", LONG,
-"SHORT", SHORT,
-"BYTE", BYTE,
-"NOFLOAT",NOFLOAT,
-"o",ORIGIN,
-"org",ORIGIN,
-"l", LENGTH,
-"len", LENGTH,
-0,0};
-unsigned int lineno;
-extern boolean hex_mode;
-FILE *ldlex_input_stack;
-static unsigned int have_pushback;
-#define NPUSHBACK 10
-int pushback[NPUSHBACK];
-int thischar;
-extern char *ldfile_input_filename;
-int donehash = 0;
-int
-lex_input()
-{
- if (have_pushback > 0)
- {
- have_pushback --;
- return thischar = pushback[have_pushback];
- }
- if (ldlex_input_stack) {
- thischar = fgetc(ldlex_input_stack);
-
- if (thischar == EOF) {
- fclose(ldlex_input_stack);
- ldlex_input_stack = (FILE *)NULL;
- ldfile_input_filename = (char *)NULL;
- /* First char after script eof is a @ so that we can tell the grammer
- that we've eft */
- thischar = '@';
+/* Support for flex reading from more than one input file (stream).
+ `include_stack' is flex's input state for each open file;
+ `file_name_stack' is the file names.
- }
- }
- else if (command_line && *command_line) {
- thischar = *(command_line++);
- }
- else {
- thischar = 0;
- }
- if(thischar == '\t') thischar = ' ';
- if (thischar == '\n') { thischar = ' '; lineno++; }
- return thischar ;
-}
+ If `include_stack_ptr' is 0, we haven't started reading anything yet.
+ Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */
-void
-lex_unput(c)
-int c;
-{
- if (have_pushback > NPUSHBACK) {
- info("%F%P Too many pushbacks\n");
- }
+#undef YY_INPUT
+#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
- pushback[have_pushback] = c;
- have_pushback ++;
-}
+#define MAX_INCLUDE_DEPTH 10
+static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
+static char *file_name_stack[MAX_INCLUDE_DEPTH];
+static unsigned int include_stack_ptr = 0;
+static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string,
+ size_t size));
+static void yy_input PARAMS ((char *, int *result, int max_size));
- int
-yywrap()
- { return 1; }
-/*VARARGS*/
+static void comment PARAMS ((void));
+static void lex_warn_invalid PARAMS ((char *where, char *what));
-void
-allprint(x)
-int x;
-{
-fprintf(yyout,"%d",x);
-}
+/* STATES
+ EXPRESSION definitely in an expression
+ SCRIPT definitely in a script
+ BOTH either EXPRESSION or SCRIPT
+ DEFSYMEXP in an argument to -defsym
+ MRI in an MRI script
+*/
+#define RTOKEN(x) { yylval.token = x; return x; }
-void
-sprint(x)
-char *x;
-{
-fprintf(yyout,"%s",x);
-}
+/* Some versions of flex want this. */
+#ifndef yywrap
+int yywrap () { return 1; }
+#endif
+%}
-int thischar;
+%a 4000
+%o 5000
-void parse_line(arg)
-char *arg;
-{
- command_line = arg;
- have_pushback = 0;
- yyparse();
-}
+CMDFILENAMECHAR [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
+CMDFILENAMECHAR1 [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
+FILENAMECHAR1 [_a-zA-Z\/\.\\\$\_\~]
+SYMBOLCHARN [_a-zA-Z\/\.\\0-9]
+FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
+FILENAME {FILENAMECHAR}+
+WHITE [ \t\n\r]+
+NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
-void
-parse_args(ac, av)
-int ac;
-char **av;
-{
- char *p;
- int i;
- size_t size = 0;
- char *dst;
- debug = 1;
- for (i= 1; i < ac; i++) {
- size += strlen(av[i]) + 2;
- }
- dst = p = (char *)ldmalloc(size + 2);
-/* Put a space arount each option */
+%s SCRIPT
+%s EXPRESSION
+%s BOTH
+%s DEFSYMEXP
+%s MRI
+%%
+ if (parser_input != input_selected)
+ {
+ /* The first token of the input determines the initial parser state. */
+ input_type t = parser_input;
+ parser_input = input_selected;
+ switch (t)
+ {
+ case input_script: return INPUT_SCRIPT; break;
+ case input_mri_script: return INPUT_MRI_SCRIPT; break;
+ case input_defsym: return INPUT_DEFSYM; break;
+ default: abort ();
+ }
+ }
- for (i =1; i < ac; i++) {
+<BOTH,SCRIPT,EXPRESSION>"/*" { comment(); }
+
+
+<DEFSYMEXP>"-" { RTOKEN('-');}
+<DEFSYMEXP>"+" { RTOKEN('+');}
+<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = buystring(yytext); return NAME; }
+<DEFSYMEXP>"=" { RTOKEN('='); }
+
+<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
+ yylval.integer = bfd_scan_vma (yytext+1, 0,16);
+ return INT;
+ }
+
+<MRI,EXPRESSION>([0-9A-Fa-f])+(H|X|B|O|D) {
+ int ibase ;
+ switch (yytext[yyleng-1]) {
+ case 'X':
+ case 'H':
+ ibase = 16;
+ break;
+ case 'O':
+ ibase = 8;
+ break;
+ case 'B':
+ ibase = 2;
+ break;
+ default:
+ ibase = 10;
+ }
+ yylval.integer = bfd_scan_vma (yytext+1, 0,
+ ibase);
+ return INT;
+ }
+<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M|K|m|k)? {
+ yylval.integer = bfd_scan_vma (yytext, 0,
+ hex_mode);
+ if (yytext[yyleng-1]=='M'
+ || yytext[yyleng-1] == 'm') {
+ yylval.integer *= 1024*1024;
+ }
+ if (yytext[yyleng-1]=='K'
+ || yytext[yyleng-1]=='k') {
+ yylval.integer *= 1024;
+ }
+ return INT;
+ }
+<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
+<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
+<BOTH,SCRIPT,EXPRESSION>"<<=" { RTOKEN(LSHIFTEQ);}
+<BOTH,SCRIPT,EXPRESSION>">>=" { RTOKEN(RSHIFTEQ);}
+<BOTH,SCRIPT,EXPRESSION>"||" { RTOKEN(OROR);}
+<BOTH,SCRIPT,EXPRESSION>"==" { RTOKEN(EQ);}
+<BOTH,SCRIPT,EXPRESSION>"!=" { RTOKEN(NE);}
+<BOTH,SCRIPT,EXPRESSION>">=" { RTOKEN(GE);}
+<BOTH,SCRIPT,EXPRESSION>"<=" { RTOKEN(LE);}
+<BOTH,SCRIPT,EXPRESSION>"<<" { RTOKEN(LSHIFT);}
+<BOTH,SCRIPT,EXPRESSION>">>" { RTOKEN(RSHIFT);}
+<BOTH,SCRIPT,EXPRESSION>"+=" { RTOKEN(PLUSEQ);}
+<BOTH,SCRIPT,EXPRESSION>"-=" { RTOKEN(MINUSEQ);}
+<BOTH,SCRIPT,EXPRESSION>"*=" { RTOKEN(MULTEQ);}
+<BOTH,SCRIPT,EXPRESSION>"/=" { RTOKEN(DIVEQ);}
+<BOTH,SCRIPT,EXPRESSION>"&=" { RTOKEN(ANDEQ);}
+<BOTH,SCRIPT,EXPRESSION>"|=" { RTOKEN(OREQ);}
+<BOTH,SCRIPT,EXPRESSION>"&&" { RTOKEN(ANDAND);}
+<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
+<MRI,BOTH,SCRIPT,EXPRESSION>"," { RTOKEN(',');}
+<BOTH,SCRIPT,EXPRESSION>"&" { RTOKEN('&');}
+<BOTH,SCRIPT,EXPRESSION>"|" { RTOKEN('|');}
+<BOTH,SCRIPT,EXPRESSION>"~" { RTOKEN('~');}
+<BOTH,SCRIPT,EXPRESSION>"!" { RTOKEN('!');}
+<BOTH,SCRIPT,EXPRESSION>"?" { RTOKEN('?');}
+<BOTH,SCRIPT,EXPRESSION>"*" { RTOKEN('*');}
+<BOTH,SCRIPT,EXPRESSION>"+" { RTOKEN('+');}
+<BOTH,SCRIPT,EXPRESSION>"-" { RTOKEN('-');}
+<BOTH,SCRIPT,EXPRESSION>"/" { RTOKEN('/');}
+<BOTH,SCRIPT,EXPRESSION>"%" { RTOKEN('%');}
+<BOTH,SCRIPT,EXPRESSION>"<" { RTOKEN('<');}
+<MRI,BOTH,SCRIPT,EXPRESSION>"=" { RTOKEN('=');}
+<BOTH,SCRIPT,EXPRESSION>"}" { RTOKEN('}') ; }
+<BOTH,SCRIPT,EXPRESSION>"{" { RTOKEN('{'); }
+<BOTH,SCRIPT,EXPRESSION>")" { RTOKEN(')');}
+<BOTH,SCRIPT,EXPRESSION>"(" { RTOKEN('(');}
+<BOTH,SCRIPT,EXPRESSION>":" { RTOKEN(':'); }
+<BOTH,SCRIPT,EXPRESSION>";" { RTOKEN(';');}
+<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
+<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
+<BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
+<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
+<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
+<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
+<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
+<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
+<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
+<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
+<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
+<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
+<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
+<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
+<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
+<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
+<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
+<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
+<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
+<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
+<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
+<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
+<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
+<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
+<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
+<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
+<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
+<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
+<BOTH,SCRIPT>"QUAD" { RTOKEN( QUAD);}
+<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
+<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
+<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
+<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
+<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
+<BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
+<BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
+<BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
+<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
+<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
+<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
+<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
+<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
+<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
+<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
+<BOTH,SCRIPT>"PROVIDE" { RTOKEN(PROVIDE); }
+<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
+<MRI>"\r" { ++ lineno; RTOKEN(NEWLINE); }
+<MRI>"*".* { /* Mri comment line */ }
+<MRI>"END" { RTOKEN(ENDWORD); }
+<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
+<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
+
+<MRI>"CHIP" { RTOKEN(CHIP); }
+<MRI>"BASE" { RTOKEN(BASE); }
+<MRI>"ALIAS" { RTOKEN(ALIAS); }
+<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
+<MRI>"LOAD" { RTOKEN(LOAD); }
+<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
+<MRI>"ORDER" { RTOKEN(ORDER); }
+<MRI>"NAME" { RTOKEN(NAMEWORD); }
+<MRI>"FORMAT" { RTOKEN(FORMAT); }
+<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
+<MRI>"SECT" { RTOKEN(SECT); }
+<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
+<MRI>"end" { RTOKEN(ENDWORD); }
+<MRI>"chip" { RTOKEN(CHIP); }
+<MRI>"load" { RTOKEN(LOAD); }
+<MRI>"order" { RTOKEN(ORDER); }
+<MRI>"name" { RTOKEN(NAMEWORD); }
+<MRI>"format" { RTOKEN(FORMAT); }
+<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
+<MRI>"sect" { RTOKEN(SECT); }
+<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
+
+<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
+/* Filename without commas, needed to parse mri stuff */
+ yylval.name = buystring(yytext);
+ return NAME;
+ }
+
+
+<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
+ yylval.name = buystring(yytext);
+ return NAME;
+ }
+<SCRIPT>{FILENAMECHAR}* { yylval.name = buystring(yytext);
+ return NAME;
+ }
+
+<EXPRESSION,BOTH,SCRIPT>"\""[^\"]*"\"" {
+ /* No matter the state, quotes
+ give what's inside */
+ yylval.name = buystring(yytext+1);
+ yylval.name[yyleng-2] = 0;
+ return NAME;
+ }
+<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
+<BOTH,SCRIPT,EXPRESSION>"\r" { lineno++;}
+<MRI,BOTH,SCRIPT,EXPRESSION>[ \t]
+
+<<EOF>> {
+ include_stack_ptr--;
+
+ if (include_stack_ptr == 0)
+ {
+ yyterminate();
+ }
+ else
+ {
+ yy_switch_to_buffer(include_stack[include_stack_ptr]);
- unsigned int s = strlen(av[i]);
- *dst++ = ' ';
- memcpy(dst, av[i], s);
- dst[s] = ' ';
- dst += s + 1;
}
- *dst = 0;
- parse_line(p);
+ BEGIN(SCRIPT);
+ ldfile_input_filename = file_name_stack[include_stack_ptr-1];
- free(p);
+ return END;
+}
+<SCRIPT,MRI>. lex_warn_invalid(" in script", yytext);
+<EXPRESSION,DEFSYMEXP,BOTH>. lex_warn_invalid(" in expression", yytext);
+
+%%
+\f
-}
+/* Switch flex to reading script file NAME, open on FILE,
+ saving the current input info on the include stack. */
-long number(text, base)
-char *text;
-int base;
+void
+lex_push_file (file, name)
+ FILE *file;
+ char *name;
{
- unsigned long l = 0;
- char *p;
- for (p = text; *p != 0; p++) {
- if (*p == 'K') {
- l =l * 1024;
- }
- else if(*p== 'M') {
- l =l * 1024 * 1024;
+ if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
+ {
+ einfo("%F:includes nested too deeply\n");
}
- else {
- l =l * base;
- if (isdigit(*p)) {
- l += *p - '0';
- }
- else if (islower(*p)) {
- l += *p - 'a' + 10;
- }
- else {
- l += *p - 'A' + 10;
- }
- }
- }
- return l;
-}
-%}
+ file_name_stack[include_stack_ptr] = name;
+ include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
-%a 4000
-%o 5000
-FILENAMECHAR [a-zA-Z0-9\/\.\-\_\+\=]
-FILENAME {FILENAMECHAR}+
+ include_stack_ptr++;
+ yyin = file;
+ yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
+ BEGIN (SCRIPT);
+}
+/* Return a newly created flex input buffer containing STRING,
+ which is SIZE bytes long. */
-WHITE [ \t]+
+static YY_BUFFER_STATE
+yy_create_string_buffer (string, size)
+ CONST char *string;
+ size_t size;
+{
+ YY_BUFFER_STATE b;
+
+ /* Calls to m-alloc get turned by sed into xm-alloc. */
+ b = (YY_BUFFER_STATE) malloc (sizeof (struct yy_buffer_state));
+ b->yy_input_file = 0;
+ b->yy_buf_size = size;
+
+ /* yy_ch_buf has to be 2 characters longer than the size given because
+ we need to put in 2 end-of-buffer characters. */
+ b->yy_ch_buf = (YY_CHAR *) malloc ((unsigned) (b->yy_buf_size + 3));
+
+ b->yy_ch_buf[0] = '\n';
+ strcpy (b->yy_ch_buf+1, string);
+ b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
+ b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
+ b->yy_n_chars = size+1;
+ b->yy_buf_pos = &b->yy_ch_buf[1];
+ b->yy_eof_status = EOF_NOT_SEEN;
+
+ return b;
+}
-%%
+/* Switch flex to reading from STRING, saving the current input info
+ on the include stack. */
-"@" { return ENDSCRIPT; }
-"\ -defsym\ " { return OPTION_defsym; }
-"\ -noinhibit_exec\ " { return OPTION_noinhibit_exec; }
-"\ -format\ " { return OPTION_format; }
-"\ -n\ " { return OPTION_n; }
-"\ -r\ " { return OPTION_r; }
-"\ -Ur\ " { return OPTION_Ur; }
-"\ -o\ " { return OPTION_o; }
-"\ -g\ " { return OPTION_g; }
-"\ -e\ " { return OPTION_e; }
-"\ -b\ " { return OPTION_b; }
-"\ -dc\ " { return OPTION_dc; }
-"\ -dp\ " { return OPTION_dp; }
-"\ -d\ " { return OPTION_d; }
-"\ -v\ " { return OPTION_v; }
-"\ -M\ " { return OPTION_M; }
-"\ -t\ " { return OPTION_t; }
-"\ -X\ " { return OPTION_X; }
-"\ -x\ " { return OPTION_x; }
-"\ -c\ " { return OPTION_c; }
-"\ -R\ " { return OPTION_R; }
-"\ -u\ " { return OPTION_u; }
-"\ -s\ " { return OPTION_s; }
-"\ -S\ " { return OPTION_S; }
-"\ -l"{FILENAME} {
- yylval.name = buystring(yytext+3);
- return OPTION_l;
- }
+void
+lex_redirect (string)
+ CONST char *string;
+{
+ YY_BUFFER_STATE tmp;
-"\ -L"{FILENAME} {
- yylval.name = buystring(yytext+3);
- return OPTION_L;
- }
-"\ -Ttext\ " {
- yylval.name = ".text";
- return OPTION_Texp;
- }
-"\ -Tdata\ " {
- yylval.name = ".data";
- return OPTION_Texp;
- }
-"\ -Tbss\ " {
- yylval.name = ".bss";
- return OPTION_Texp;
- }
-
-"\ -T"{FILENAME} {
- yylval.name = buystring(yytext+3);
- return OPTION_Tfile;
- }
-"\ -T\ " {
- return OPTION_T;
- }
-
-"\ -F"{FILENAME} {
- return OPTION_F;
- }
-"\ -F\ " {
- return OPTION_F;
- }
-
-"\ -A"{FILENAME} {
- yylval.name = buystring(yytext+3);
- return OPTION_Aarch;
- }
-" " { }
-"<<=" { RTOKEN(LSHIFTEQ);}
-">>=" { RTOKEN(RSHIFTEQ);}
-"||" { RTOKEN(OROR);}
-"==" { RTOKEN(EQ);}
-"!=" { RTOKEN(NE);}
-">=" { RTOKEN(GE);}
-"<=" { RTOKEN(LE);}
-"<<" { RTOKEN(LSHIFT);}
-">>" { RTOKEN(RSHIFT);}
-"+=" { RTOKEN(PLUSEQ);}
-"-=" { RTOKEN(MINUSEQ);}
-"*=" { RTOKEN(MULTEQ);}
-"/=" { RTOKEN(DIVEQ);}
-"&=" { RTOKEN(ANDEQ);}
-"|=" { RTOKEN(OREQ);}
-"&&" { RTOKEN(ANDAND);}
-">" { RTOKEN('>');}
-"," { RTOKEN(',');}
-"&" { RTOKEN('&');}
-"|" { RTOKEN('|');}
-"~" { RTOKEN('~');}
-"!" { RTOKEN('!');}
-"?" { RTOKEN('?');}
-"*" { RTOKEN('*');}
-"%" { RTOKEN('%');}
-"<" { RTOKEN('<');}
-">" { RTOKEN('>');}
-"}" { RTOKEN('}') ; }
-"{" { RTOKEN('{'); }
-")" { RTOKEN(')');}
-"(" { RTOKEN('(');}
-"]" { RTOKEN(']');}
-"[" { RTOKEN('[');}
-":" { RTOKEN(':'); }
-";" { RTOKEN('\;');}
-"-" { RTOKEN('-');}
-
-
-
-"/*" {
- while (1) {
- int ch;
- ch = input();
- while (ch != '*') {
- ch = input();
+ yy_init = 0;
+ if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
+ {
+ einfo("%F: macros nested too deeply\n");
}
+ file_name_stack[include_stack_ptr] = "redirect";
+ include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
+ include_stack_ptr++;
+ tmp = yy_create_string_buffer (string, strlen (string));
+ yy_switch_to_buffer (tmp);
+ BEGIN (SCRIPT);
+}
+\f
+/* Functions to switch to a different flex start condition,
+ saving the current start condition on `state_stack'. */
+static int state_stack[MAX_INCLUDE_DEPTH * 2];
+static int *state_stack_p = state_stack;
+void
+ldlex_script ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN (SCRIPT);
+}
- if (input() == '/') {
- break;
- }
- unput(yytext[yyleng-1]);
- }
+void
+ldlex_mri_script ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN (MRI);
}
-"\""[^\"]*"\"" {
+void
+ldlex_defsym ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN (DEFSYMEXP);
+}
+
+void
+ldlex_expression ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN (EXPRESSION);
+}
- yylval.name = buystring(yytext+1);
- yylval.name[yyleng-2] = 0; /* Fry final quote */
- return NAME;
+void
+ldlex_both ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN (BOTH);
}
-"\#"{WHITE}*{FILENAMECHAR}+ {
- char *p = yytext+1;
- while(*p ==' ' || *p == '\t') p++;
- yylval.name = buystring(p);
- return NAME;
+void
+ldlex_popstate ()
+{
+ yy_start = *(--state_stack_p);
}
-{FILENAMECHAR} {
-
- boolean loop = false;
- /*
- Tokenize a name, this is really pain, since a name can be a
- filename or a symbol name. filenames have slashes and stuff whist
- in an expression those things are seperate tokens. We hack this by
- setting ldlang_in_script when we are expecting a symbol, so that
- [/+-] get taken to be seperate tokens. An extra gotcha is
- expressions after defsyms, we only allow +s and -s in a defsym
- expression, so -defsym foo=bar+9 /file.o is parsed ok.
-
- The more I think about this the more I hate it. I've got a problem
- now with the = sign, what should I do ? imagine:
- __start=.;
- You'd think that was pretty unambiguous wouldn't you. Well it's
- not since __start=. is (at the moment) a perfectly valid
- filename. And in some cases we don't know what's going on. I'm
- going to have to hack this. If we see a '/' before the = sign then
- we say we've got an = in a filename, otherwise it's an operator.
- (later)
- That's it, I've had enough. From now on, an =s on a command line
- will be taken to be part of a file name unless its in a defsym,
- and an = in a file will be taken to be an operator.
- */
- int ch;
- keyword_type *k;
-
- if ((hex_mode && isxdigit(yytext[0]))
- ||
- (isdigit(yytext[0]) && (ldgram_in_expression == true || ldgram_in_script == true))) {
- char *start = yytext;
- unsigned int base = 10;
- if (hex_mode == true) base = 16;
- if (yytext[0] == '0') {
- base = 8;
- }
- ch = input();
- while (isxdigit(ch)
- || ch == 'x'
- || ch == 'X'
- || ch == 'M'
- )
+\f
+
+/* Place up to MAX_SIZE characters in BUF and return in *RESULT
+ either the number of characters read, or 0 to indicate EOF. */
+
+static void
+yy_input (buf, result, max_size)
+ char *buf;
+ int *result;
+ int max_size;
+{
+ *result = 0;
+ if (yy_current_buffer->yy_input_file)
+ {
+ if (yyin)
{
- if (ch == 'x' || ch == 'X') {
- base = 16;
- start = yytext + yyleng;
- }
- else {
- yytext[yyleng++] = ch;
- }
- ch = input();
+ *result = read (fileno (yyin), (char *) buf, max_size);
+ if (*result < 0)
+ einfo ("%F%P: read in flex scanner failed");
}
- yytext[yyleng] = 0;
- unput(ch);
- yylval.integer = number(start, base);
- return INT;
- }
-
- if (ldfile_input_filename) {
- /* We're inside a file */
- if (yytext[0]== '=') {
- RTOKEN('=');
}
- }
+}
-
+/* Eat the rest of a C-style comment. */
- /* Otherwise we only notice special things if were in an
- expression */
-
- if (ldgram_in_expression) {
- if (yytext[0] != '/' || ldgram_in_defsym == false) {
- switch (yytext[0]) {
- case '/': RTOKEN('/');
- case '=': RTOKEN('=');
- case '+': RTOKEN('+');
- case '-': RTOKEN('-');
- }
+static void
+comment ()
+{
+ int c;
+
+ while (1)
+ {
+ c = input();
+ while (c != '*' && c != EOF)
+ {
+ if (c == '\n' || c == '\r')
+ lineno++;
+ c = input();
}
- }
- ch = input();
- while (true)
- {
- if (isalpha(ch) || isdigit(ch) || ch == '.' || ch == '_' ) {
- yytext[yyleng++] = ch;
- }
- else if (ch == '=' && ldgram_in_script) {
- /* An = within a script is always taken to be an operator */
- break;
- }
- else if (ch == '+' || ch == '-' || ch == '/' || ch == '=') {
- if (ldgram_in_expression) break;
- yytext[yyleng++] = ch;
- }
- else
- break;
- ch = input();
- }
-
- yytext[yyleng] = 0;
- unput(ch);
- /* Filenames of just =signs are tokens */
- if (yyleng == 1 && yytext[0] == '=') {
- RTOKEN('=');
- }
- for(k = keywords; k ->name != (char *)NULL; k++) {
+ if (c == '*')
+ {
+ c = input();
+ while (c == '*')
+ c = input();
+ if (c == '/')
+ break; /* found the end */
+ }
+
+ if (c == '\n' || c == '\r')
+ lineno++;
- if (strcmp(k->name, yytext)==0) {
- yylval.token = k->value;
- return k->value;
+ if (c == EOF)
+ {
+ einfo( "%F%P: EOF in comment\n");
+ break;
}
}
- yylval.name = buystring(yytext);
- return NAME;
}
+/* Warn the user about a garbage character WHAT in the input
+ in context WHERE. */
-
-
-
-%%
+static void
+lex_warn_invalid (where, what)
+ char *where, *what;
+{
+ fprintf(stderr,
+ "%s: ignoring invalid character `%s'%s\n",
+ program_name, what, where);
+}
projects / binutils.git / blobdiff