[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;
				}

<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
  				yylval.integer = strtoul(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 = strtoul(yytext+1, 0, base);	
				   return INT;
				 }
<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M|K|m|k)? {
				  yylval.integer = strtoul(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	}
	215
3d2b83ea	216	<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
85e38cfa	217	yylval.integer = strtoul(yytext+1, 0,16);
3d2b83ea SC	218	return INT;
	219	}
	220
91e25b4f	221	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|X\|B\|O\|D) {
3d2b83ea SC	222	int base ;
	223	switch (yytext[yyleng-1]) {
	224	case 'X':
	225	case 'H':
	226	base = 16;
	227	break;
	228	case 'O':
	229	base = 8;
	230	break;
	231	case 'B':
	232	base = 2;
	233	break;
	234	default:
	235	base = 10;
	236	}
dc4726c2	237	yylval.integer = strtoul(yytext+1, 0, base);
3d2b83ea SC	238	return INT;
3d2b83ea SC	239	}
9fce28ed	240	<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M\|K\|m\|k)? {
dc4726c2	241	yylval.integer = strtoul(yytext,0,hex_mode);
9d1fe8a4 SC	242	if (yytext[yyleng-1]=='M'
	243	\|\| yytext[yyleng-1] == 'm') {
	244	yylval.integer = 10241024;
	245	}
	246	if (yytext[yyleng-1]=='K'
	247	\|\| yytext[yyleng-1]=='k') {
	248	yylval.integer *= 1024;
	249	}
	250	return INT;
	251	}
	252	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	253	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	254	<BOTH,SCRIPT,EXPRESSION>"<<=" { RTOKEN(LSHIFTEQ);}
	255	<BOTH,SCRIPT,EXPRESSION>">>=" { RTOKEN(RSHIFTEQ);}
	256	<BOTH,SCRIPT,EXPRESSION>"\|\|" { RTOKEN(OROR);}
	257	<BOTH,SCRIPT,EXPRESSION>"==" { RTOKEN(EQ);}
	258	<BOTH,SCRIPT,EXPRESSION>"!=" { RTOKEN(NE);}
	259	<BOTH,SCRIPT,EXPRESSION>">=" { RTOKEN(GE);}
	260	<BOTH,SCRIPT,EXPRESSION>"<=" { RTOKEN(LE);}
	261	<BOTH,SCRIPT,EXPRESSION>"<<" { RTOKEN(LSHIFT);}
	262	<BOTH,SCRIPT,EXPRESSION>">>" { RTOKEN(RSHIFT);}
	263	<BOTH,SCRIPT,EXPRESSION>"+=" { RTOKEN(PLUSEQ);}
	264	<BOTH,SCRIPT,EXPRESSION>"-=" { RTOKEN(MINUSEQ);}
	265	<BOTH,SCRIPT,EXPRESSION>"*=" { RTOKEN(MULTEQ);}
	266	<BOTH,SCRIPT,EXPRESSION>"/=" { RTOKEN(DIVEQ);}
	267	<BOTH,SCRIPT,EXPRESSION>"&=" { RTOKEN(ANDEQ);}
	268	<BOTH,SCRIPT,EXPRESSION>"\|=" { RTOKEN(OREQ);}
	269	<BOTH,SCRIPT,EXPRESSION>"&&" { RTOKEN(ANDAND);}
	270	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	271	<MRI,BOTH,SCRIPT,EXPRESSION>"," { RTOKEN(',');}
9d1fe8a4 SC	272	<BOTH,SCRIPT,EXPRESSION>"&" { RTOKEN('&');}
	273	<BOTH,SCRIPT,EXPRESSION>"\|" { RTOKEN('\|');}
	274	<BOTH,SCRIPT,EXPRESSION>"~" { RTOKEN('~');}
	275	<BOTH,SCRIPT,EXPRESSION>"!" { RTOKEN('!');}
	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('>');}
3d2b83ea	284	<MRI,BOTH,SCRIPT,EXPRESSION>"=" { RTOKEN('=');}
9d1fe8a4 SC	285	<BOTH,SCRIPT,EXPRESSION>"}" { RTOKEN('}') ; }
	286	<BOTH,SCRIPT,EXPRESSION>"{" { RTOKEN('{'); }
	287	<BOTH,SCRIPT,EXPRESSION>")" { RTOKEN(')');}
	288	<BOTH,SCRIPT,EXPRESSION>"(" { RTOKEN('(');}
	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>"MEMORY" { RTOKEN(MEMORY);}
	296	<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
	297	<BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
	298	<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
	299	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	300	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
	301	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	302	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	303	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	304	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	305	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	306	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	307	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	308	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	309	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	310	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
dadd414a	311	<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
9d1fe8a4 SC	312	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	313	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	314	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	315	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	316	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	317	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	318	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	319	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	320	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	321	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	322	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
	323	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	324	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	325	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	326	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
dadd414a	327	<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
9d1fe8a4 SC	328	<BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	329	<BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	330	<BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	331	<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
	332	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	333	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	334	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	335	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
dadd414a	336	<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
9fce28ed	337	<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
2e38b71d	338	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
91e25b4f	339	<MRI>"". { /* Mri comment line */ }
2e38b71d	340	<MRI>"END" { RTOKEN(ENDWORD); }
85e38cfa SC	341	<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
	342	<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
	343
3d2b83ea	344	<MRI>"CHIP" { RTOKEN(CHIP); }
91e25b4f PB	345	<MRI>"BASE" { RTOKEN(BASE); }
91e25b4f PB	346	<MRI>"ALIAS" { RTOKEN(ALIAS); }
85e38cfa	347	<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
3d2b83ea	348	<MRI>"LOAD" { RTOKEN(LOAD); }
91e25b4f	349	<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
2e38b71d SC	350	<MRI>"ORDER" { RTOKEN(ORDER); }
	351	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	352	<MRI>"FORMAT" { RTOKEN(FORMAT); }
	353	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
3d2b83ea	354	<MRI>"SECT" { RTOKEN(SECT); }
6bf2e3a7	355	<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
1bd1fa2d SC	356	<MRI>"end" { RTOKEN(ENDWORD); }
	357	<MRI>"chip" { RTOKEN(CHIP); }
	358	<MRI>"load" { RTOKEN(LOAD); }
	359	<MRI>"order" { RTOKEN(ORDER); }
	360	<MRI>"name" { RTOKEN(NAMEWORD); }
	361	<MRI>"format" { RTOKEN(FORMAT); }
	362	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	363	<MRI>"sect" { RTOKEN(SECT); }
6bf2e3a7	364	<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
3d2b83ea	365
ee0c4cf7 SC	366	<COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}* {
	367	yylval.name = buystring(yytext);
	368	return NAME;
	369	}
	370
	371
85e38cfa SC	372	<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
	373	/* Filename without commas, needed to parse mri stuff */
	374	yylval.name = buystring(yytext);
	375	return NAME;
	376	}
	377
	378
	379	<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
9d1fe8a4 SC	380	yylval.name = buystring(yytext);
	381	return NAME;
	382	}
	383	<SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext);
	384	return NAME;
	385	}
	386
	387	<EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
	388	/* No matter the state, quotes
	389	give what's inside */
	390	yylval.name = buystring(yytext+1);
	391	yylval.name[yyleng-2] = 0;
	392	return NAME;
	393	}
	394	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
3d2b83ea	395	<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
9d1fe8a4	396
9d1fe8a4	397	<<EOF>> {
dadd414a SC	398	extern char *ldfile_input_filename;
dadd414a SC	399	include_stack_ptr--;
9d1fe8a4	400
dadd414a SC	401	if (include_stack_ptr == 0)
	402	{
	403	yyterminate();
	404	}
	405	else
	406	{
	407	yy_switch_to_buffer(include_stack[include_stack_ptr]);
	408
	409	}
	410	if (include_stack_ptr==1)
	411	{
	412	BEGIN(COMMAND);
	413	}
	414	else
	415	{
9fce28ed	416	BEGIN(SCRIPT);
dadd414a	417	ldfile_input_filename = file_name_stack[include_stack_ptr-1];
2fa0b342	418	}
dadd414a SC	419
	420	return END;
	421	}
9d1fe8a4	422
9d1fe8a4	423	%%
2fa0b342 DHW	424
2fa0b342 DHW	425	void
8ddef552 DM	426	lex_push_file (file, name)
	427	FILE *file;
	428	char *name;
2fa0b342	429	{
9d1fe8a4 SC	430	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
9d1fe8a4 SC	431	{
8bf66be8	432	einfo("%F:includes nested too deeply\n");
2fa0b342	433	}
dadd414a SC	434	file_name_stack[include_stack_ptr] = name;
	435	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	436
	437	include_stack_ptr++;
9d1fe8a4 SC	438	yyin = file;
9d1fe8a4 SC	439	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
2fa0b342	440
9d1fe8a4	441	BEGIN(SCRIPT);
2fa0b342 DHW	442	}
2fa0b342 DHW	443
9d1fe8a4	444	YY_BUFFER_STATE
8ddef552 DM	445	yy_create_string_buffer (string, size)
	446	CONST char *string;
	447	int size;
2fa0b342	448	{
9d1fe8a4	449	YY_BUFFER_STATE b;
2fa0b342	450
9d1fe8a4 SC	451	b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
	452	b->yy_input_file = 0;
	453
	454	if ( ! b )
	455	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342	456
9d1fe8a4	457	b->yy_buf_size = size;
2fa0b342	458
9d1fe8a4 SC	459	/* yy_ch_buf has to be 2 characters longer than the size given because
	460	* we need to put in 2 end-of-buffer characters.
	461	*/
	462	b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );
2fa0b342	463
9d1fe8a4 SC	464	if ( ! b->yy_ch_buf )
9d1fe8a4 SC	465	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342 DHW	466
2fa0b342 DHW	467
9d1fe8a4 SC	468	b->yy_ch_buf[0] = '\n';
	469	strcpy(b->yy_ch_buf+1, string);
	470	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
	471	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
	472	b->yy_n_chars = size+1;
	473	b->yy_buf_pos = &b->yy_ch_buf[1];
2fa0b342	474
9d1fe8a4	475	b->yy_eof_status = EOF_NOT_SEEN;
2fa0b342	476
9d1fe8a4	477	return ( b );
2fa0b342	478	}
2fa0b342	479
2fa0b342	480
1418c83b	481
9d1fe8a4	482	void
8ddef552 DM	483	lex_redirect (string)
8ddef552 DM	484	CONST char *string;
9d1fe8a4 SC	485	{
9d1fe8a4 SC	486	YY_BUFFER_STATE tmp;
1d45ccb3	487
9d1fe8a4	488	int len = strlen(string);
dadd414a	489	yy_init = 0 ;
9d1fe8a4 SC	490	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
9d1fe8a4 SC	491	{
8bf66be8	492	einfo("%F: macros nested too deeply\n");
1418c83b	493	}
dadd414a SC	494	file_name_stack[include_stack_ptr] = "redirect";
	495	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	496	include_stack_ptr++;
9d1fe8a4 SC	497	tmp = yy_create_string_buffer(string, len);
	498
	499	yy_switch_to_buffer(tmp);
	500	BEGIN(COMMAND);
dadd414a	501	yyout = stdout;
9d1fe8a4	502	}
1d45ccb3	503
9d1fe8a4 SC	504	int state_stack[20];
9d1fe8a4 SC	505	int *state_stack_p = state_stack;
1d45ccb3	506
9d1fe8a4	507	void
8ddef552	508	ldlex_script ()
9d1fe8a4	509	{
dadd414a	510	*(state_stack_p)++ = yy_start;
1d45ccb3	511
dadd414a	512	BEGIN(SCRIPT);
9d1fe8a4	513	}
1418c83b	514
2fa0b342	515
3d2b83ea	516	void
8ddef552	517	ldlex_mri_script ()
3d2b83ea	518	{
dadd414a SC	519	*(state_stack_p)++ = yy_start;
dadd414a SC	520	BEGIN(MRI);
0d3e45ea SC	521	}
	522
	523	void
8ddef552	524	ldlex_defsym ()
0d3e45ea	525	{
dadd414a SC	526	*(state_stack_p)++ = yy_start;
dadd414a SC	527	BEGIN(DEFSYMEXP);
3d2b83ea SC	528	}
3d2b83ea SC	529
9d1fe8a4	530	void
8ddef552	531	ldlex_expression ()
9d1fe8a4	532	{
dadd414a SC	533	*(state_stack_p)++ = yy_start;
dadd414a SC	534	BEGIN(EXPRESSION);
1d45ccb3	535
9d1fe8a4 SC	536	}
9d1fe8a4 SC	537	void
8ddef552	538	ldlex_both ()
9d1fe8a4	539	{
dadd414a SC	540	*(state_stack_p)++ = yy_start;
dadd414a SC	541	BEGIN(BOTH);
9d1fe8a4 SC	542	}
9d1fe8a4 SC	543	void
8ddef552	544	ldlex_command ()
9d1fe8a4	545	{
dadd414a SC	546	*(state_stack_p)++ = yy_start;
dadd414a SC	547	BEGIN(COMMAND);
2fa0b342 DHW	548	}
2fa0b342 DHW	549
9d1fe8a4	550	void
8ddef552	551	ldlex_popstate ()
9d1fe8a4	552	{
dadd414a	553	yy_start = *(--state_stack_p);
9d1fe8a4	554	}
2fa0b342	555
9d1fe8a4 SC	556	yy_input(buf, result, max_size)
	557	char *buf;
	558	int *result;
	559	int max_size;
	560	{
	561	*result = 0;
	562	if (yy_current_buffer->yy_input_file)
	563	{
	564	if (yyin)
	565	if ( (result = read( fileno(yyin), (char ) buf, max_size )) < 0 )
	566	YY_FATAL_ERROR( "read() in flex scanner failed" );
	567	}
	568	}
6bf2e3a7	569
85e38cfa SC	570	static
	571	comment()
	572	{
	573	int c;
	574	while (1)
	575	{
	576	c = input();
	577	while (c !='*' && c != EOF)
	578	{
	579	if (c == '\n') lineno++;
	580	c = input();
	581	}
	582
	583
	584	if (c == '*')
	585	{
	586	c = input();
	587	while ( c == '*')
	588	c = input();
	589	if ( c == '/' )
	590	break; /* found the end */
	591	}
	592
	593	if ( c == EOF )
	594	{
8bf66be8	595	einfo( "%F%P :EOF in comment\n");
85e38cfa SC	596	break;
	597	}
	598	}
	599	}