[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
*/


#include <ansidecl.h>
#include "bfd.h"
#include "ldgram.h"

int ldgram_in_defsym;
extern int ldgram_had_equals;
extern int ldgram_in_script;

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


char *buystring();

unsigned int lineno = 1;
int old;

static comment();

#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];
char *file_name_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

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

NOCFILENAMECHAR	[_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]


%s COMMAND
%s SCRIPT
%s EXPRESSION
%s COMMENT
%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>"-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>"-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>"-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"{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"{FILENAME}         {
					yylval.name = buystring(yytext+2);
					return OPTION_y;
				}
				
<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 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 = bfd_scan_vma (yytext+1, 0,
								  base);
				   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>"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>> {
  extern char *ldfile_input_filename;
  include_stack_ptr--;
    
  if (include_stack_ptr == 0) 
  {
    yyterminate();
  }
  else 
  {
    yy_switch_to_buffer(include_stack[include_stack_ptr]);

  }
  if (include_stack_ptr==1) 
  {
    BEGIN(COMMAND);
  }
  else 
  {
    BEGIN(SCRIPT);
    ldfile_input_filename = file_name_stack[include_stack_ptr-1];
  }

  return END;
}
    
%%

void
lex_push_file (file, name)
     FILE *file;
     char *name;
{
  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;

  include_stack_ptr++;
  yyin = file;
  yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));

  BEGIN(SCRIPT);
}

YY_BUFFER_STATE 
yy_create_string_buffer (string,  size)
     CONST char *string;
     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
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\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;

  BEGIN(SCRIPT);
}


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

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

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

static
comment()
{
  int c;
  while (1)
  {
    c = input();
    while (c !='*' && c != EOF) 
    {
      if (c == '\n') lineno++;
      c = input();
    }


    if (c == '*')
    {
      c = input();
      while ( c == '*')
       c = input();
      if ( c == '/' )
       break;			/* found the end */
    }

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