%{
-/* 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"
+
+int ldgram_in_defsym;
+
+int hex_mode;
+
+unsigned int lineno = 1;
+int old;
+
+#undef YY_INPUT
+#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
+#undef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(s)
+#define MAX_INCLUDE_DEPTH 10
+YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
+char *file_name_stack[MAX_INCLUDE_DEPTH];
+unsigned int include_stack_ptr = 0;
+
+static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string,
+ int size));
+static void yy_input PARAMS ((char *, int *result, int max_size));
+static void comment PARAMS ((void));
+static void lex_warn_invalid PARAMS ((char *where, char *what));
+
+/* STATES
+ COMMAND on command line
+ 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; }
+%}
-#undef input
-#undef unput
-#define input lex_input
-#define unput lex_unput
-int debug;
+%a 4000
+%o 5000
+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]+
-static boolean ldgram_in_defsym;
-static boolean ldgram_had_equals;
-extern boolean ldgram_in_script;
-static char *command_line;
+NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
-extern int fgetc();
-extern int yyparse();
-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,
-"sizeof_headers",SIZEOF_HEADERS,
-"SIZEOF_HEADERS",SIZEOF_HEADERS,
-"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,
-"OUTPUT_ARCH", OUTPUT_ARCH,
-"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 left */
- thischar = '@';
+%s COMMAND
+%s SCRIPT
+%s EXPRESSION
+%s BOTH
+%s DEFSYMEXP
+%s MRI
+%%
- }
+
+<BOTH,SCRIPT,EXPRESSION,COMMAND>"/*" { comment(); }
+
+
+<DEFSYMEXP>"-" { RTOKEN('-');}
+<DEFSYMEXP>"+" { RTOKEN('+');}
+<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = buystring(yytext); return NAME; }
+<DEFSYMEXP>[ \t] { RTOKEN(DEFSYMEND); }
+<DEFSYMEXP>"=" { RTOKEN('='); }
+<COMMAND>"--help" { return OPTION_help; }
+<COMMAND>"--version" { return OPTION_version; }
+<COMMAND>"-defsym"{WHITE}* { return OPTION_defsym; }
+<COMMAND>"-format" { return OPTION_format; }
+<COMMAND>"-noinhibit-exec" { return OPTION_noinhibit_exec; }
+<COMMAND>"-noinhibit_exec" { return OPTION_noinhibit_exec; }
+<COMMAND>"-oformat" { return OPTION_oformat; }
+<COMMAND>"-sort-common" { return OPTION_sort_common;}
+<COMMAND>"-sort_common" { return OPTION_sort_common;}
+<COMMAND>"-warn-common" { return OPTION_warn_common;}
+<COMMAND>"-n" { return OPTION_n; }
+<COMMAND>"-N" { return OPTION_N; }
+<COMMAND>"-r" { return OPTION_r; }
+<COMMAND>"-stats" { return OPTION_stats; }
+<COMMAND>"-no-keep-memory" { return OPTION_no_keep_memory; }
+<COMMAND>"-relax" { return OPTION_relax; }
+<COMMAND>"-i" { return OPTION_r; }
+<COMMAND>"-Ur" { return OPTION_Ur; }
+<COMMAND>"-o" { return OPTION_o; }
+<COMMAND>"-g" { return OPTION_g; }
+<COMMAND>"-e" { return OPTION_e; }
+<COMMAND>"-e"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_esymbol;
+ }
+<COMMAND>"-b" { return OPTION_b; }
+<COMMAND>"-dc" { return OPTION_dc; }
+<COMMAND>"-dp" { return OPTION_dp; }
+<COMMAND>"-d" { return OPTION_d; }
+<COMMAND>"-v" { return OPTION_v; }
+<COMMAND>"-V" { return OPTION_V; }
+<COMMAND>"-m" { return OPTION_m; }
+<COMMAND>"-m"{FILENAME} { return OPTION_memul; }
+<COMMAND>"-M" { return OPTION_M; }
+<COMMAND>"-Map" { return OPTION_Map;}
+<COMMAND>"-t" { return OPTION_t; }
+<COMMAND>"-X" { return OPTION_X; }
+<COMMAND>"-x" { return OPTION_x; }
+<COMMAND>"-c" { return OPTION_c; }
+<COMMAND>"-R" { return OPTION_R; }
+<COMMAND>"-u" { return OPTION_u; }
+<COMMAND>"-u"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_usymbol;
+ }
+<COMMAND>"-s" { return OPTION_s; }
+<COMMAND>"-S" { return OPTION_S; }
+<COMMAND>"-Bstat" { return OPTION_Bstatic; }
+<COMMAND>"-B"{FILENAME} { /* Ignored */ }
+<COMMAND>"-l"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_l;
+ }
+
+<COMMAND>"-L"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_Lfile;
+ }
+<COMMAND>"-L" { return OPTION_L; }
+<COMMAND>"-Ttext" {
+ yylval.name = ".text";
+ return OPTION_Texp;
+ }
+<COMMAND>"-Tdata" {
+ yylval.name = ".data";
+ return OPTION_Texp;
+ }
+<COMMAND>"-Tbss" {
+ yylval.name = ".bss";
+ return OPTION_Texp;
+ }
+<COMMAND>"-O"([0-9])+ {
+ yylval.integer = atoi (yytext + 2);
+ return OPTION_Oval;
+ }
+<COMMAND>"-O"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_Texp;
+ }
+
+<COMMAND>"-T"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_Tfile;
+ }
+<COMMAND>"-T" {
+ return OPTION_T;
+ }
+
+<COMMAND>"-F"{FILENAME} {
+ return OPTION_F;
+ }
+<COMMAND>"-F" {
+ return OPTION_F;
+ }
+
+<COMMAND>"-y" {
+ return OPTION_y;
+ }
+
+<COMMAND>"-y"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_ysymbol;
+ }
+
+<COMMAND>"-A"{FILENAME} {
+ yylval.name = buystring(yytext+2);
+ return OPTION_Aarch;
+ }
+
+<COMMAND>"-retain-symbols-file" { return OPTION_RETAIN_SYMBOLS_FILE; }
+
+<COMMAND>"-EB" {
+ return OPTION_EB;
+ }
+<COMMAND>"-EL" {
+ return OPTION_EL;
+ }
+<COMMAND>"-G" {
+ return OPTION_G;
+ }
+<COMMAND>"-G"([0-9])+ {
+ yylval.integer = atoi (yytext + 2);
+ return OPTION_Gval;
+ }
+
+<COMMAND>"-Qy" { return OPTION_Qy; }
+<COMMAND>"-dn" { return OPTION_dn; }
+<COMMAND>"-Y" { return OPTION_Y; }
+<COMMAND>"-YP,"{FILENAME} {
+ yylval.name = buystring (yytext+4);
+ return OPTION_YP;
+ }
+<COMMAND>"-non_shared" { return OPTION_non_shared; }
+<COMMAND>"-call_shared" { return OPTION_call_shared; }
+
+<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('<');}
+<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>"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);}
+<MRI>"\n" { ++ 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); }
+
+<COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}* {
+ yylval.name = buystring(yytext);
+ return NAME;
+ }
+
+
+<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,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext);
+ return NAME;
+ }
+
+<EXPRESSION,BOTH,COMMAND,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++;}
+<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
+
+<<EOF>> {
+ include_stack_ptr--;
+
+ if (include_stack_ptr == 0)
+ {
+ yyterminate();
}
- else if (command_line && *command_line) {
- thischar = *(command_line++);
+ else
+ {
+ yy_switch_to_buffer(include_stack[include_stack_ptr]);
+
}
- else {
- thischar = 0;
+ if (include_stack_ptr==1)
+ {
+ BEGIN(COMMAND);
}
- if(thischar == '\t') thischar = ' ';
- if (thischar == '\n') { thischar = ' '; lineno++; }
- return thischar ;
-}
-
-void
-lex_unput(c)
-int c;
-{
- if (have_pushback > NPUSHBACK) {
- info("%F%P Too many pushbacks\n");
+ else
+ {
+ BEGIN(SCRIPT);
+ ldfile_input_filename = file_name_stack[include_stack_ptr-1];
}
- pushback[have_pushback] = c;
- have_pushback ++;
+ return END;
}
-
- int
-yywrap()
- { return 1; }
-/*VARARGS*/
-
-void
-allprint(x)
-int x;
-{
-fprintf(yyout,"%d",x);
-}
+<COMMAND>. lex_warn_invalid(" on command line", yytext);
+<SCRIPT,MRI>. lex_warn_invalid(" in script", yytext);
+<EXPRESSION,DEFSYMEXP,BOTH>. lex_warn_invalid(" in expression", yytext);
+
+%%
void
-sprint(x)
-char *x;
+lex_push_file (file, name)
+ FILE *file;
+ char *name;
{
-fprintf(yyout,"%s",x);
-}
+ if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
+ {
+ einfo("%F:includes nested too deeply\n");
+ }
+ file_name_stack[include_stack_ptr] = name;
+ include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
-int thischar;
+ include_stack_ptr++;
+ yyin = file;
+ yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
-void parse_line(arg)
-char *arg;
-{
- command_line = arg;
- have_pushback = 0;
- yyparse();
+ BEGIN(SCRIPT);
}
-
-
-void
-parse_args(ac, av)
-int ac;
-char **av;
+static YY_BUFFER_STATE
+yy_create_string_buffer (string, size)
+ CONST char *string;
+ int size;
{
- 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 */
+ YY_BUFFER_STATE b;
+ b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
+ b->yy_input_file = 0;
+
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
- for (i =1; i < ac; i++) {
+ b->yy_buf_size = size;
- unsigned int s = strlen(av[i]);
- *dst++ = ' ';
- memcpy(dst, av[i], s);
- dst[s] = ' ';
- dst += s + 1;
- }
- *dst = 0;
- parse_line(p);
+ /* 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) );
- free(p);
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
-}
+ 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];
-static long
-DEFUN(number,(default_if_zero,base),
- int default_if_zero AND
- int base)
-{
- unsigned long l = 0;
- int ch = yytext[0];
- if (ch == 0) {
- base = default_if_zero;
- }
- while (1) {
- switch (ch) {
- case 'x':
- base = 16;
- break;
- case 'k':
- case 'K':
- l =l * 1024;
- break;
- case 'm':
- case 'M':
- l =l * 1024 * 1024;
- break;
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
- l = l * base + ch - '0';
- break;
- case 'a': case 'b': case 'c' : case 'd' : case 'e': case 'f':
- l =l *base + ch - 'a' + 10;
- break;
- case 'A': case 'B': case 'C' : case 'D' : case 'E': case 'F':
- l =l *base + ch - 'A' + 10;
- break;
- default:
- unput(ch);
- yylval.integer = l;
- return INT;
- }
-ch = input();
- }
-}
-%}
-
-%a 4000
-%o 5000
-FILENAMECHAR [a-zA-Z0-9\/\.\-\_\+\=]
-FILENAME {FILENAMECHAR}+
-WHITE [ \t]+
+ b->yy_eof_status = EOF_NOT_SEEN;
-%%
+ return ( b );
+}
-"@" { return '}'; }
-"\ -defsym\ " { ldgram_in_defsym = true; return OPTION_defsym; }
-"\ -noinhibit_exec\ " { return OPTION_noinhibit_exec; }
-"\ -format\ " { return OPTION_format; }
-"\ -n\ " { return OPTION_n; }
-"\ -r\ " { return OPTION_r; }
-"\ -i\ " { 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; }
-"\ -B{FILENAME}\ " { /* Ignored */ }
-"\ -l"{FILENAME} {
- yylval.name = buystring(yytext+3);
- return OPTION_l;
- }
-
-"\ -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;
- }
-
-" " {
- if (ldgram_had_equals == true) {
- ldgram_in_defsym = false;
- ldgram_had_equals = false;
- }
- }
-"<<=" { 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();
- }
+void
+lex_redirect (string)
+ CONST char *string;
+{
+ YY_BUFFER_STATE tmp;
- if (input() == '/') {
- break;
- }
- unput(yytext[yyleng-1]);
+ int len = strlen(string);
+ 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, len);
+
+ yy_switch_to_buffer(tmp);
+ BEGIN(COMMAND);
+ yyout = stdout;
}
-"\""[^\"]*"\"" {
+int state_stack[20];
+int *state_stack_p = state_stack;
+
+void
+ldlex_script ()
+{
+ *(state_stack_p)++ = yy_start;
- yylval.name = buystring(yytext+1);
- yylval.name[yyleng-2] = 0; /* Fry final quote */
- return NAME;
+ BEGIN(SCRIPT);
}
-{FILENAMECHAR} {
- boolean loop = false;
- int ch;
- keyword_type *k;
+void
+ldlex_mri_script ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN(MRI);
+}
- /* If we're in hex mode (only after a -T) then all we can see are numbers
- hex digit we see will be a number. */
+void
+ldlex_defsym ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN(DEFSYMEXP);
+}
+
+void
+ldlex_expression ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN(EXPRESSION);
- if (hex_mode) {
- return number(16, 16);
- }
+}
+void
+ldlex_both ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN(BOTH);
+}
+void
+ldlex_command ()
+{
+ *(state_stack_p)++ = yy_start;
+ BEGIN(COMMAND);
+}
- /* If we're in a defsym then all things starting with a digit are in
- hex */
+void
+ldlex_popstate ()
+{
+ yy_start = *(--state_stack_p);
+}
- if (isdigit(yytext[0]) && ldgram_in_defsym) {
- return number(16,16);
+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 ( (*result = read( fileno(yyin), (char *) buf, max_size )) < 0 )
+ YY_FATAL_ERROR( "read() in flex scanner failed" );
}
+}
+static void
+comment ()
+{
+ int c;
+ while (1)
+ {
+ c = input();
+ while (c !='*' && c != EOF)
+ {
+ if (c == '\n') lineno++;
+ c = input();
+ }
- /* Otherwise if we're in a script we will parse the numbers
- normally */
-
- if (ldgram_in_script == true && isdigit(yytext[0])) {
- return number(8,10);
- }
- /* Anywhere not in a script or defsym, an opertor is part of a
- filename, except / and, which is an operator when on its own */
- if (ldgram_in_script == true|| ldgram_in_defsym == true) {
-
- switch (yytext[0]) {
- case '*': RTOKEN('*');
-
- case '=': {
- ldgram_had_equals = true;
- RTOKEN('=');
- }
- break;
- case '/': {
- if (ldgram_in_defsym) RTOKEN('/');
- }
- break;
- case '+': RTOKEN('+');
- case '-': RTOKEN('-');
- case '!': RTOKEN('!');
- case '~': RTOKEN('~');
- }
+ if (c == '*')
+ {
+ c = input();
+ while ( c == '*')
+ c = input();
+ if ( c == '/' )
+ break; /* found the end */
}
-
-/* Otherwise this must be a file or a symbol name, and it will continue to be a
- filename until we get to something strange. In scripts operator looking
- things are taken to be operators, except /, which will be left
- */
- ch = input();
- while (true)
- {
- if (ldgram_in_defsym == true) {
- switch (ch) {
- case '*':
- case '=':
- case '+':
- case '/':
- case '-':
- case '!':
- case '~':
- goto quit;
- }
-
- }
- if(ldgram_in_script == true) {
- switch (ch) {
- case '*':
- case '=':
- case '+':
- case '-':
- case '!':
- case '~':
- goto quit;
- }
- }
-
- if (isalpha(ch) || isdigit(ch) || ch == '.' || ch == '_' ||
- ch == '/' || ch == '.' || ch == '+' || ch == '-' || ch =='=') {
- yytext[yyleng++] = ch;
- }
- else
- break;
- ch = input();
- }
- quit:;
- yytext[yyleng] = 0;
- unput(ch);
-
- for(k = keywords; k ->name != (char *)NULL; k++) {
- 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;
}
-
-
-
-
-%%
+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