[deliverable/binutils-gdb.git] / ld / ldlex.l

%{
/* Copyright (C) 1991 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 2, or (at your option)
any later version.

GLD is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GLD; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*
This was written by steve chamberlain
                    sac@cygnus.com
*/


typedef int bfd_vma;
#include <ansidecl.h>
#include "ldgram.h"

int ldgram_in_defsym;
int ldgram_had_equals;
int ldgram_in_script;

int hex_mode;
extern int fgetc();
extern int yyparse();


char *buystring();

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 ;
#define MAX_INCLUDE_DEPTH 10
YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
unsigned int include_stack_ptr = 0;


/* STATES 
	COMMAND	 	on command line
	COMMENT		in a C comment
	EXPRESSION	definiatelyt in an expression
	SCRIPT		definately in a script
	SOMEWHERE	either EXPRESSION or SCRIPT
        MRI             in an MRI script
*/
#define RTOKEN(x)  {  yylval.token = x; return x; }
%}

%a 4000
%o 5000
FILENAMECHAR1	[_a-zA-Z\/\.\\]
FILENAMECHAR	[_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\]
FILENAME	{FILENAMECHAR}+
WHITE		[ \t\n]+ 

%x COMMAND
%x SCRIPT
%x EXPRESSION
%x COMMENT
%x BOTH
%x MRI
%%
  
<COMMAND>"-defsym" 		{ return OPTION_defsym; }
<COMMAND>"-noinhibit_exec" 	{ return OPTION_noinhibit_exec; }
<COMMAND>"-noinhibit-exec"	{ return OPTION_noinhibit_exec; }
<COMMAND>"-sort_common"		{ return OPTION_sort_common;}
<COMMAND>"-sort-common"		{ return OPTION_sort_common;}
<COMMAND>"-format"		{ return OPTION_format; }
<COMMAND>"-n"			{ return OPTION_n; }
<COMMAND>"-N"			{ return OPTION_N; }
<COMMAND>"-r"			{ return OPTION_r; }
<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>"-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>"-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>"-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_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"{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>"-A"{FILENAME} 	{
		                	yylval.name = buystring(yytext+2);
				 	return OPTION_Aarch;
			       	}

<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
  				yylval.integer = strtol(yytext+1, 0,16);	
				return INT;
			}

<MRI,EXPRESSION>([0-9A-Fa-f])+(H|X|B|O|D)
				 {
				   int base ;
				   switch (yytext[yyleng-1]) {
				    case 'X': 
				    case 'H':
				     base = 16;
				     break;
				    case 'O':
				     base = 8;
				     break;
				    case 'B':
				     base = 2;
				     break;
				    default:
				     base = 10;
				   }
				   yylval.integer = strtol(yytext+1, 0, base);	
				   return INT;
				 }
<MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M|K|m|k)? {
				  yylval.integer = strtol(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);}
<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>"LONG"			{ RTOKEN( LONG);}
<BOTH,SCRIPT>"SHORT"			{ RTOKEN( SHORT);}
<BOTH,SCRIPT>"BYTE"			{ RTOKEN( BYTE);}
<BOTH,SCRIPT>"NOFLOAT"		{ RTOKEN(NOFLOAT);}
<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);}
<MRI>"\n"	                { ++ lineno;  RTOKEN(NEWLINE); }
<MRI>^"*".*			{ /* Mri comment line */ }
<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); }
<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); }
<MRI>"absolute"			{ RTOKEN(ABSOLUTE); }

<MRI,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]

"/*"				{ old = INITIAL; BEGIN(COMMENT); }
<COMMAND>"/*"			{ old = COMMAND; BEGIN(COMMENT); }
<BOTH>"/*"			{ old =BOTH; BEGIN(COMMENT); }
<SCRIPT>"/*"			{ old = EXPRESSION; BEGIN(COMMENT); }
<EXPRESSION>"/*"		{ old = SCRIPT; BEGIN(COMMENT); }
"/*"				{ old = INITIAL; BEGIN(COMMENT); }
<COMMENT>[^*\\n]*
<COMMENT>"*"+[^*/\\n]*
<COMMENT>\\n             	{ ++lineno;}
<COMMENT>"*"+"/" 		{ BEGIN(old); }


<<EOF>> {
    include_stack_ptr--;
    
    if (include_stack_ptr == 0) 
    {
      yyterminate();
    }
    else 
    {
      yy_switch_to_buffer(include_stack[include_stack_ptr]);
    }
	BEGIN(COMMAND);
	return END;
  }
    

%%

void
DEFUN(lex_push_file,(file),
     FILE *file)
{
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  {
    einfo("%F:includes nested too deeply");
  }
  include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
  yyin = file;
  yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));

  BEGIN(SCRIPT);
}

YY_BUFFER_STATE 
DEFUN(yy_create_string_buffer,(string,  size),
      CONST char *string AND
      int size )
{
  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()" );

  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) );

  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];

  b->yy_eof_status = EOF_NOT_SEEN;

  return ( b );
}


void
DEFUN(lex_redirect,( string),
    CONST  char *string)
{
  YY_BUFFER_STATE tmp;

  int len = strlen(string);
yy_init = 0  ;  
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  {
    einfo("%F: macros nested too deeply");
  }
  include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;

  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
DEFUN_VOID(ldlex_script)
{
*(state_stack_p)++ = yy_start;

BEGIN(SCRIPT);
}


void
DEFUN_VOID(ldlex_mri_script)
{
  *(state_stack_p)++ = yy_start;
  BEGIN(MRI);
}
	   
void
DEFUN_VOID(ldlex_expression)
{
*(state_stack_p)++ = yy_start;
BEGIN(EXPRESSION);

}
void
DEFUN_VOID(ldlex_both)
{
*(state_stack_p)++ = yy_start;
BEGIN(BOTH);
}
void
DEFUN_VOID(ldlex_command)
{
*(state_stack_p)++ = yy_start;
BEGIN(COMMAND);
}

void
DEFUN_VOID(ldlex_popstate)
{
yy_start = *(--state_stack_p);
}

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" );
  }
}
Commit	Line	Data
2fa0b342 DHW	1	%{
	2	/* Copyright (C) 1991 Free Software Foundation, Inc.
	3
	4	This file is part of GLD, the Gnu Linker.
	5
	6	GLD is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
2e2bf962	8	the Free Software Foundation; either version 2, or (at your option)
2fa0b342 DHW	9	any later version.
	10
	11	GLD is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GLD; see the file COPYING. If not, write to
	18	the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	/*
9d1fe8a4 SC	21	This was written by steve chamberlain
9d1fe8a4 SC	22	sac@cygnus.com
2fa0b342 DHW	23	*/
	24
	25
9d1fe8a4 SC	26	typedef int bfd_vma;
	27	#include <ansidecl.h>
	28	#include "ldgram.h"
2fa0b342	29
9d1fe8a4 SC	30	int ldgram_in_defsym;
	31	int ldgram_had_equals;
	32	int ldgram_in_script;
2fa0b342	33
9d1fe8a4 SC	34	int hex_mode;
	35	extern int fgetc();
	36	extern int yyparse();
2fa0b342	37
2fa0b342	38
2e2bf962	39
9d1fe8a4	40	char *buystring();
7ca04d28	41
9d1fe8a4 SC	42	int lineno = 1;
9d1fe8a4 SC	43	int old;
1d45ccb3	44
9d1fe8a4 SC	45	#undef YY_INPUT
	46	#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
	47	#undef YY_FATAL_ERROR
	48	#define YY_FATAL_ERROR ;
	49	#define MAX_INCLUDE_DEPTH 10
	50	YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
	51	unsigned int include_stack_ptr = 0;
2fa0b342	52
2fa0b342	53
3d2b83ea	54	/* STATES
9d1fe8a4 SC	55	COMMAND on command line
	56	COMMENT in a C comment
	57	EXPRESSION definiatelyt in an expression
	58	SCRIPT definately in a script
	59	SOMEWHERE either EXPRESSION or SCRIPT
3d2b83ea	60	MRI in an MRI script
9d1fe8a4	61	*/
2fa0b342	62	#define RTOKEN(x) { yylval.token = x; return x; }
9d1fe8a4	63	%}
2fa0b342	64
9d1fe8a4 SC	65	%a 4000
	66	%o 5000
	67	FILENAMECHAR1 [_a-zA-Z\/\.\\]
2e38b71d	68	FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\]
9d1fe8a4 SC	69	FILENAME {FILENAMECHAR}+
9d1fe8a4 SC	70	WHITE [ \t\n]+
2fa0b342	71
9d1fe8a4 SC	72	%x COMMAND
	73	%x SCRIPT
	74	%x EXPRESSION
	75	%x COMMENT
	76	%x BOTH
3d2b83ea	77	%x MRI
9d1fe8a4 SC	78	%%
	79
	80	<COMMAND>"-defsym" { return OPTION_defsym; }
	81	<COMMAND>"-noinhibit_exec" { return OPTION_noinhibit_exec; }
	82	<COMMAND>"-noinhibit-exec" { return OPTION_noinhibit_exec; }
	83	<COMMAND>"-sort_common" { return OPTION_sort_common;}
	84	<COMMAND>"-sort-common" { return OPTION_sort_common;}
	85	<COMMAND>"-format" { return OPTION_format; }
	86	<COMMAND>"-n" { return OPTION_n; }
	87	<COMMAND>"-N" { return OPTION_N; }
	88	<COMMAND>"-r" { return OPTION_r; }
	89	<COMMAND>"-relax" { return OPTION_relax; }
	90	<COMMAND>"-i" { return OPTION_r; }
	91	<COMMAND>"-Ur" { return OPTION_Ur; }
	92	<COMMAND>"-o" { return OPTION_o; }
	93	<COMMAND>"-g" { return OPTION_g; }
	94	<COMMAND>"-e" { return OPTION_e; }
	95	<COMMAND>"-b" { return OPTION_b; }
	96	<COMMAND>"-dc" { return OPTION_dc; }
	97	<COMMAND>"-dp" { return OPTION_dp; }
	98	<COMMAND>"-d" { return OPTION_d; }
	99	<COMMAND>"-v" { return OPTION_v; }
	100	<COMMAND>"-V" { return OPTION_V; }
	101	<COMMAND>"-M" { return OPTION_M; }
	102	<COMMAND>"-Map" { return OPTION_Map;}
	103	<COMMAND>"-t" { return OPTION_t; }
	104	<COMMAND>"-X" { return OPTION_X; }
	105	<COMMAND>"-x" { return OPTION_x; }
	106	<COMMAND>"-c" { return OPTION_c; }
	107	<COMMAND>"-R" { return OPTION_R; }
	108	<COMMAND>"-u" { return OPTION_u; }
	109	<COMMAND>"-s" { return OPTION_s; }
	110	<COMMAND>"-S" { return OPTION_S; }
	111	<COMMAND>"-Bstat" { return OPTION_Bstatic; }
	112	<COMMAND>"-B"{FILENAME} { /* Ignored */ }
	113	<COMMAND>"-l"{FILENAME} {
	114	yylval.name = buystring(yytext+2);
	115	return OPTION_l;
	116	}
	117
	118	<COMMAND>"-L"{FILENAME} {
	119	yylval.name = buystring(yytext+2);
	120	return OPTION_L;
	121	}
	122	<COMMAND>"-Ttext" {
	123	yylval.name = ".text";
	124	return OPTION_Texp;
	125	}
	126	<COMMAND>"-Tdata" {
	127	yylval.name = ".data";
	128	return OPTION_Texp;
	129	}
	130	<COMMAND>"-Tbss" {
	131	yylval.name = ".bss";
	132	return OPTION_Texp;
	133	}
	134	<COMMAND>"-O"{FILENAME} {
	135	yylval.name = buystring(yytext+2);
	136	return OPTION_Texp;
	137	}
	138
	139	<COMMAND>"-T"{FILENAME} {
	140	yylval.name = buystring(yytext+2);
	141	return OPTION_Tfile;
142	}
143	<COMMAND>"-T" {
144	return OPTION_T;
145	}
146
147	<COMMAND>"-F"{FILENAME} {
148	return OPTION_F;
149	}
150	<COMMAND>"-F" {
151	return OPTION_F;
152	}
153
154	<COMMAND>"-A"{FILENAME} {
155	yylval.name = buystring(yytext+2);
156	return OPTION_Aarch;
157	}
3d2b83ea SC	158
	159	<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
	160	yylval.integer = strtol(yytext+1, 0,16);
	161	return INT;
	162	}
	163
	164	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|X\|B\|O\|D)
	165	{
	166	int base ;
	167	switch (yytext[yyleng-1]) {
	168	case 'X':
	169	case 'H':
	170	base = 16;
	171	break;
	172	case 'O':
	173	base = 8;
	174	break;
	175	case 'B':
	176	base = 2;
	177	break;
	178	default:
	179	base = 10;
	180	}
	181	yylval.integer = strtol(yytext+1, 0, base);
	182	return INT;
	183	}
	184	<MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M\|K\|m\|k)? {
9d1fe8a4 SC	185	yylval.integer = strtol(yytext,0,hex_mode);
	186	if (yytext[yyleng-1]=='M'
	187	\|\| yytext[yyleng-1] == 'm') {
	188	yylval.integer = 10241024;
	189	}
	190	if (yytext[yyleng-1]=='K'
	191	\|\| yytext[yyleng-1]=='k') {
	192	yylval.integer *= 1024;
	193	}
	194	return INT;
	195	}
	196	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	197	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	198	<BOTH,SCRIPT,EXPRESSION>"<<=" { RTOKEN(LSHIFTEQ);}
	199	<BOTH,SCRIPT,EXPRESSION>">>=" { RTOKEN(RSHIFTEQ);}
	200	<BOTH,SCRIPT,EXPRESSION>"\|\|" { RTOKEN(OROR);}
	201	<BOTH,SCRIPT,EXPRESSION>"==" { RTOKEN(EQ);}
	202	<BOTH,SCRIPT,EXPRESSION>"!=" { RTOKEN(NE);}
	203	<BOTH,SCRIPT,EXPRESSION>">=" { RTOKEN(GE);}
	204	<BOTH,SCRIPT,EXPRESSION>"<=" { RTOKEN(LE);}
	205	<BOTH,SCRIPT,EXPRESSION>"<<" { RTOKEN(LSHIFT);}
	206	<BOTH,SCRIPT,EXPRESSION>">>" { RTOKEN(RSHIFT);}
	207	<BOTH,SCRIPT,EXPRESSION>"+=" { RTOKEN(PLUSEQ);}
	208	<BOTH,SCRIPT,EXPRESSION>"-=" { RTOKEN(MINUSEQ);}
	209	<BOTH,SCRIPT,EXPRESSION>"*=" { RTOKEN(MULTEQ);}
	210	<BOTH,SCRIPT,EXPRESSION>"/=" { RTOKEN(DIVEQ);}
	211	<BOTH,SCRIPT,EXPRESSION>"&=" { RTOKEN(ANDEQ);}
	212	<BOTH,SCRIPT,EXPRESSION>"\|=" { RTOKEN(OREQ);}
	213	<BOTH,SCRIPT,EXPRESSION>"&&" { RTOKEN(ANDAND);}
	214	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	215	<MRI,BOTH,SCRIPT,EXPRESSION>"," { RTOKEN(',');}
9d1fe8a4 SC	216	<BOTH,SCRIPT,EXPRESSION>"&" { RTOKEN('&');}
	217	<BOTH,SCRIPT,EXPRESSION>"\|" { RTOKEN('\|');}
	218	<BOTH,SCRIPT,EXPRESSION>"~" { RTOKEN('~');}
	219	<BOTH,SCRIPT,EXPRESSION>"!" { RTOKEN('!');}
	220	<BOTH,SCRIPT,EXPRESSION>"?" { RTOKEN('?');}
	221	<BOTH,SCRIPT,EXPRESSION>"" { RTOKEN('');}
	222	<BOTH,SCRIPT,EXPRESSION>"+" { RTOKEN('+');}
	223	<BOTH,SCRIPT,EXPRESSION>"-" { RTOKEN('-');}
	224	<BOTH,SCRIPT,EXPRESSION>"/" { RTOKEN('/');}
	225	<BOTH,SCRIPT,EXPRESSION>"%" { RTOKEN('%');}
	226	<BOTH,SCRIPT,EXPRESSION>"<" { RTOKEN('<');}
	227	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	228	<MRI,BOTH,SCRIPT,EXPRESSION>"=" { RTOKEN('=');}
9d1fe8a4 SC	229	<BOTH,SCRIPT,EXPRESSION>"}" { RTOKEN('}') ; }
	230	<BOTH,SCRIPT,EXPRESSION>"{" { RTOKEN('{'); }
	231	<BOTH,SCRIPT,EXPRESSION>")" { RTOKEN(')');}
	232	<BOTH,SCRIPT,EXPRESSION>"(" { RTOKEN('(');}
	233	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	234	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	235	<BOTH,SCRIPT,EXPRESSION>":" { RTOKEN(':'); }
	236	<BOTH,SCRIPT,EXPRESSION>";" { RTOKEN(';');}
	237	<BOTH,SCRIPT,EXPRESSION>"-" { RTOKEN('-');}
	238	<BOTH,SCRIPT,EXPRESSION>"/" { RTOKEN('/');}
	239	<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
	240	<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
	241	<BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
	242	<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
	243	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	244	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
	245	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	246	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	247	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	248	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	249	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	250	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	251	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	252	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	253	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	254	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
	255	<BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
	256	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	257	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	258	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	259	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	260	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	261	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	262	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	263	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	264	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	265	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	266	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
	267	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	268	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	269	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	270	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
	271	<BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
	272	<BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	273	<BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	274	<BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	275	<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
	276	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	277	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	278	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	279	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
2e38b71d	280	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
3d2b83ea	281	<MRI>^"". { /* Mri comment line */ }
2e38b71d	282	<MRI>"END" { RTOKEN(ENDWORD); }
3d2b83ea SC	283	<MRI>"CHIP" { RTOKEN(CHIP); }
3d2b83ea SC	284	<MRI>"LOAD" { RTOKEN(LOAD); }
2e38b71d SC	285	<MRI>"ORDER" { RTOKEN(ORDER); }
	286	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	287	<MRI>"FORMAT" { RTOKEN(FORMAT); }
	288	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
3d2b83ea SC	289	<MRI>"SECT" { RTOKEN(SECT); }
3d2b83ea SC	290	<MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
1bd1fa2d SC	291	<MRI>"end" { RTOKEN(ENDWORD); }
	292	<MRI>"chip" { RTOKEN(CHIP); }
	293	<MRI>"load" { RTOKEN(LOAD); }
	294	<MRI>"order" { RTOKEN(ORDER); }
	295	<MRI>"name" { RTOKEN(NAMEWORD); }
	296	<MRI>"format" { RTOKEN(FORMAT); }
	297	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	298	<MRI>"sect" { RTOKEN(SECT); }
	299	<MRI>"absolute" { RTOKEN(ABSOLUTE); }
3d2b83ea SC	300
3d2b83ea SC	301	<MRI,BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
9d1fe8a4 SC	302	yylval.name = buystring(yytext);
	303	return NAME;
	304	}
	305	<SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext);
	306	return NAME;
	307	}
	308
	309	<EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
	310	/* No matter the state, quotes
	311	give what's inside */
	312	yylval.name = buystring(yytext+1);
	313	yylval.name[yyleng-2] = 0;
	314	return NAME;
	315	}
	316	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
3d2b83ea	317	<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
9d1fe8a4 SC	318
	319	"/*" { old = INITIAL; BEGIN(COMMENT); }
	320	<COMMAND>"/*" { old = COMMAND; BEGIN(COMMENT); }
	321	<BOTH>"/*" { old =BOTH; BEGIN(COMMENT); }
	322	<SCRIPT>"/*" { old = EXPRESSION; BEGIN(COMMENT); }
	323	<EXPRESSION>"/*" { old = SCRIPT; BEGIN(COMMENT); }
	324	"/*" { old = INITIAL; BEGIN(COMMENT); }
	325	<COMMENT>[^\\n]
	326	<COMMENT>""+[^/\\n]*
	327	<COMMENT>\\n { ++lineno;}
	328	<COMMENT>"*"+"/" { BEGIN(old); }
	329
3d2b83ea	330
9d1fe8a4 SC	331	<<EOF>> {
	332	include_stack_ptr--;
	333
	334	if (include_stack_ptr == 0)
	335	{
	336	yyterminate();
	337	}
	338	else
	339	{
	340	yy_switch_to_buffer(include_stack[include_stack_ptr]);
	341	}
	342	BEGIN(COMMAND);
	343	return END;
2fa0b342	344	}
9d1fe8a4	345
2fa0b342	346
2fa0b342 DHW	347
2fa0b342 DHW	348
2fa0b342	349
2fa0b342	350
2fa0b342 DHW	351
2fa0b342 DHW	352
9d1fe8a4	353	%%
2fa0b342 DHW	354
2fa0b342 DHW	355	void
9d1fe8a4 SC	356	DEFUN(lex_push_file,(file),
9d1fe8a4 SC	357	FILE *file)
2fa0b342	358	{
9d1fe8a4 SC	359	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	360	{
	361	einfo("%F:includes nested too deeply");
2fa0b342	362	}
9d1fe8a4 SC	363	include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
	364	yyin = file;
	365	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
2fa0b342	366
9d1fe8a4	367	BEGIN(SCRIPT);
2fa0b342 DHW	368	}
2fa0b342 DHW	369
9d1fe8a4 SC	370	YY_BUFFER_STATE
	371	DEFUN(yy_create_string_buffer,(string, size),
	372	CONST char *string AND
	373	int size )
2fa0b342	374	{
9d1fe8a4	375	YY_BUFFER_STATE b;
2fa0b342	376
9d1fe8a4 SC	377	b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
	378	b->yy_input_file = 0;
	379
	380	if ( ! b )
	381	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342	382
9d1fe8a4	383	b->yy_buf_size = size;
2fa0b342	384
9d1fe8a4 SC	385	/* yy_ch_buf has to be 2 characters longer than the size given because
	386	* we need to put in 2 end-of-buffer characters.
	387	*/
	388	b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );
2fa0b342	389
9d1fe8a4 SC	390	if ( ! b->yy_ch_buf )
9d1fe8a4 SC	391	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342 DHW	392
2fa0b342 DHW	393
9d1fe8a4 SC	394	b->yy_ch_buf[0] = '\n';
	395	strcpy(b->yy_ch_buf+1, string);
	396	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
	397	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
	398	b->yy_n_chars = size+1;
	399	b->yy_buf_pos = &b->yy_ch_buf[1];
2fa0b342	400
9d1fe8a4	401	b->yy_eof_status = EOF_NOT_SEEN;
2fa0b342	402
9d1fe8a4	403	return ( b );
2fa0b342	404	}
2fa0b342	405
2fa0b342	406
1418c83b	407
9d1fe8a4 SC	408	void
	409	DEFUN(lex_redirect,( string),
	410	CONST char *string)
	411	{
	412	YY_BUFFER_STATE tmp;
1d45ccb3	413
9d1fe8a4 SC	414	int len = strlen(string);
	415	yy_init = 0 ;
	416	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	417	{
	418	einfo("%F: macros nested too deeply");
1418c83b	419	}
9d1fe8a4	420	include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
1418c83b	421
9d1fe8a4 SC	422	tmp = yy_create_string_buffer(string, len);
	423
	424	yy_switch_to_buffer(tmp);
	425	BEGIN(COMMAND);
	426	yyout = stdout;
	427	}
1d45ccb3	428
9d1fe8a4 SC	429	int state_stack[20];
9d1fe8a4 SC	430	int *state_stack_p = state_stack;
1d45ccb3	431
9d1fe8a4 SC	432	void
	433	DEFUN_VOID(ldlex_script)
	434	{
	435	*(state_stack_p)++ = yy_start;
1d45ccb3	436
9d1fe8a4 SC	437	BEGIN(SCRIPT);
9d1fe8a4 SC	438	}
1418c83b	439
2fa0b342	440
3d2b83ea SC	441	void
	442	DEFUN_VOID(ldlex_mri_script)
	443	{
	444	*(state_stack_p)++ = yy_start;
	445	BEGIN(MRI);
	446	}
	447
9d1fe8a4 SC	448	void
	449	DEFUN_VOID(ldlex_expression)
	450	{
	451	*(state_stack_p)++ = yy_start;
	452	BEGIN(EXPRESSION);
1d45ccb3	453
9d1fe8a4 SC	454	}
	455	void
	456	DEFUN_VOID(ldlex_both)
	457	{
	458	*(state_stack_p)++ = yy_start;
	459	BEGIN(BOTH);
	460	}
	461	void
	462	DEFUN_VOID(ldlex_command)
	463	{
	464	*(state_stack_p)++ = yy_start;
	465	BEGIN(COMMAND);
2fa0b342 DHW	466	}
2fa0b342 DHW	467
9d1fe8a4 SC	468	void
	469	DEFUN_VOID(ldlex_popstate)
	470	{
	471	yy_start = *(--state_stack_p);
	472	}
2fa0b342	473
9d1fe8a4 SC	474	yy_input(buf, result, max_size)
	475	char *buf;
	476	int *result;
	477	int max_size;
	478	{
	479	*result = 0;
	480	if (yy_current_buffer->yy_input_file)
	481	{
	482	if (yyin)
	483	if ( (result = read( fileno(yyin), (char ) buf, max_size )) < 0 )
	484	YY_FATAL_ERROR( "read() in flex scanner failed" );
	485	}
	486	}
2fa0b342	487