[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;
int ldgram_had_equals;
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>"-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_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;
				}
<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");
  }
  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");
  }
  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");
      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 SC	31	int ldgram_in_defsym;
	32	int ldgram_had_equals;
	33	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;}
9d1fe8a4 SC	110	<COMMAND>"-n" { return OPTION_n; }
	111	<COMMAND>"-N" { return OPTION_N; }
	112	<COMMAND>"-r" { return OPTION_r; }
	113	<COMMAND>"-relax" { return OPTION_relax; }
	114	<COMMAND>"-i" { return OPTION_r; }
	115	<COMMAND>"-Ur" { return OPTION_Ur; }
	116	<COMMAND>"-o" { return OPTION_o; }
	117	<COMMAND>"-g" { return OPTION_g; }
	118	<COMMAND>"-e" { return OPTION_e; }
	119	<COMMAND>"-b" { return OPTION_b; }
	120	<COMMAND>"-dc" { return OPTION_dc; }
	121	<COMMAND>"-dp" { return OPTION_dp; }
	122	<COMMAND>"-d" { return OPTION_d; }
	123	<COMMAND>"-v" { return OPTION_v; }
	124	<COMMAND>"-V" { return OPTION_V; }
8ddef552 DM	125	<COMMAND>"-m" { return OPTION_m; }
8ddef552 DM	126	<COMMAND>"-m"{FILENAME} { return OPTION_memul; }
9d1fe8a4 SC	127	<COMMAND>"-M" { return OPTION_M; }
	128	<COMMAND>"-Map" { return OPTION_Map;}
	129	<COMMAND>"-t" { return OPTION_t; }
	130	<COMMAND>"-X" { return OPTION_X; }
	131	<COMMAND>"-x" { return OPTION_x; }
	132	<COMMAND>"-c" { return OPTION_c; }
	133	<COMMAND>"-R" { return OPTION_R; }
	134	<COMMAND>"-u" { return OPTION_u; }
	135	<COMMAND>"-s" { return OPTION_s; }
	136	<COMMAND>"-S" { return OPTION_S; }
	137	<COMMAND>"-Bstat" { return OPTION_Bstatic; }
	138	<COMMAND>"-B"{FILENAME} { /* Ignored */ }
	139	<COMMAND>"-l"{FILENAME} {
	140	yylval.name = buystring(yytext+2);
	141	return OPTION_l;
	142	}
	143
	144	<COMMAND>"-L"{FILENAME} {
	145	yylval.name = buystring(yytext+2);
	146	return OPTION_L;
	147	}
	148	<COMMAND>"-Ttext" {
	149	yylval.name = ".text";
	150	return OPTION_Texp;
	151	}
	152	<COMMAND>"-Tdata" {
	153	yylval.name = ".data";
	154	return OPTION_Texp;
	155	}
	156	<COMMAND>"-Tbss" {
	157	yylval.name = ".bss";
	158	return OPTION_Texp;
	159	}
	160	<COMMAND>"-O"{FILENAME} {
	161	yylval.name = buystring(yytext+2);
	162	return OPTION_Texp;
	163	}
	164
	165	<COMMAND>"-T"{FILENAME} {
	166	yylval.name = buystring(yytext+2);
	167	return OPTION_Tfile;
	168	}
	169	<COMMAND>"-T" {
	170	return OPTION_T;
	171	}
	172
	173	<COMMAND>"-F"{FILENAME} {
	174	return OPTION_F;
	175	}
	176	<COMMAND>"-F" {
	177	return OPTION_F;
	178	}
	179
85e38cfa SC	180	<COMMAND>"-y"{FILENAME} {
	181	yylval.name = buystring(yytext+2);
	182	return OPTION_y;
	183	}
	184
9d1fe8a4 SC	185	<COMMAND>"-A"{FILENAME} {
	186	yylval.name = buystring(yytext+2);
	187	return OPTION_Aarch;
	188	}
3d2b83ea	189
85e38cfa SC	190	<COMMAND>"-retain-symbols-file" { return OPTION_RETAIN_SYMBOLS_FILE; }
85e38cfa SC	191
8ddef552 DM	192	<COMMAND>"-EB" {
	193	return OPTION_EB;
	194	}
	195	<COMMAND>"-EL" {
	196	return OPTION_EL;
	197	}
	198	<COMMAND>"-G" {
	199	return OPTION_G;
	200	}
	201	<COMMAND>"-G"([0-9])+ {
	202	yylval.integer = atoi (yytext + 2);
	203	return OPTION_Gval;
	204	}
3d2b83ea	205	<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
85e38cfa	206	yylval.integer = strtoul(yytext+1, 0,16);
3d2b83ea SC	207	return INT;
	208	}
	209
91e25b4f	210	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|X\|B\|O\|D) {
3d2b83ea SC	211	int base ;
	212	switch (yytext[yyleng-1]) {
	213	case 'X':
	214	case 'H':
	215	base = 16;
	216	break;
	217	case 'O':
	218	base = 8;
	219	break;
	220	case 'B':
	221	base = 2;
	222	break;
	223	default:
	224	base = 10;
	225	}
dc4726c2	226	yylval.integer = strtoul(yytext+1, 0, base);
3d2b83ea SC	227	return INT;
3d2b83ea SC	228	}
9fce28ed	229	<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M\|K\|m\|k)? {
dc4726c2	230	yylval.integer = strtoul(yytext,0,hex_mode);
9d1fe8a4 SC	231	if (yytext[yyleng-1]=='M'
	232	\|\| yytext[yyleng-1] == 'm') {
	233	yylval.integer = 10241024;
	234	}
	235	if (yytext[yyleng-1]=='K'
	236	\|\| yytext[yyleng-1]=='k') {
	237	yylval.integer *= 1024;
	238	}
	239	return INT;
	240	}
	241	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	242	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	243	<BOTH,SCRIPT,EXPRESSION>"<<=" { RTOKEN(LSHIFTEQ);}
	244	<BOTH,SCRIPT,EXPRESSION>">>=" { RTOKEN(RSHIFTEQ);}
	245	<BOTH,SCRIPT,EXPRESSION>"\|\|" { RTOKEN(OROR);}
	246	<BOTH,SCRIPT,EXPRESSION>"==" { RTOKEN(EQ);}
	247	<BOTH,SCRIPT,EXPRESSION>"!=" { RTOKEN(NE);}
	248	<BOTH,SCRIPT,EXPRESSION>">=" { RTOKEN(GE);}
	249	<BOTH,SCRIPT,EXPRESSION>"<=" { RTOKEN(LE);}
	250	<BOTH,SCRIPT,EXPRESSION>"<<" { RTOKEN(LSHIFT);}
	251	<BOTH,SCRIPT,EXPRESSION>">>" { RTOKEN(RSHIFT);}
	252	<BOTH,SCRIPT,EXPRESSION>"+=" { RTOKEN(PLUSEQ);}
	253	<BOTH,SCRIPT,EXPRESSION>"-=" { RTOKEN(MINUSEQ);}
	254	<BOTH,SCRIPT,EXPRESSION>"*=" { RTOKEN(MULTEQ);}
	255	<BOTH,SCRIPT,EXPRESSION>"/=" { RTOKEN(DIVEQ);}
	256	<BOTH,SCRIPT,EXPRESSION>"&=" { RTOKEN(ANDEQ);}
	257	<BOTH,SCRIPT,EXPRESSION>"\|=" { RTOKEN(OREQ);}
	258	<BOTH,SCRIPT,EXPRESSION>"&&" { RTOKEN(ANDAND);}
	259	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	260	<MRI,BOTH,SCRIPT,EXPRESSION>"," { RTOKEN(',');}
9d1fe8a4 SC	261	<BOTH,SCRIPT,EXPRESSION>"&" { RTOKEN('&');}
	262	<BOTH,SCRIPT,EXPRESSION>"\|" { RTOKEN('\|');}
	263	<BOTH,SCRIPT,EXPRESSION>"~" { RTOKEN('~');}
	264	<BOTH,SCRIPT,EXPRESSION>"!" { RTOKEN('!');}
	265	<BOTH,SCRIPT,EXPRESSION>"?" { RTOKEN('?');}
	266	<BOTH,SCRIPT,EXPRESSION>"" { RTOKEN('');}
	267	<BOTH,SCRIPT,EXPRESSION>"+" { RTOKEN('+');}
	268	<BOTH,SCRIPT,EXPRESSION>"-" { RTOKEN('-');}
	269	<BOTH,SCRIPT,EXPRESSION>"/" { RTOKEN('/');}
	270	<BOTH,SCRIPT,EXPRESSION>"%" { RTOKEN('%');}
	271	<BOTH,SCRIPT,EXPRESSION>"<" { RTOKEN('<');}
	272	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	273	<MRI,BOTH,SCRIPT,EXPRESSION>"=" { RTOKEN('=');}
9d1fe8a4 SC	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('/');}
	284	<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
	285	<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
	286	<BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
	287	<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
	288	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	289	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
	290	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	291	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	292	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	293	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	294	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	295	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	296	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	297	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	298	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	299	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
dadd414a	300	<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
9d1fe8a4 SC	301	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	302	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	303	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	304	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	305	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	306	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	307	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	308	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	309	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	310	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	311	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
	312	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	313	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	314	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	315	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
dadd414a	316	<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
9d1fe8a4 SC	317	<BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	318	<BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	319	<BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	320	<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
	321	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	322	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	323	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	324	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
dadd414a	325	<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
9fce28ed	326	<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
2e38b71d	327	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
91e25b4f	328	<MRI>"". { /* Mri comment line */ }
2e38b71d	329	<MRI>"END" { RTOKEN(ENDWORD); }
85e38cfa SC	330	<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
	331	<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
	332
3d2b83ea	333	<MRI>"CHIP" { RTOKEN(CHIP); }
91e25b4f PB	334	<MRI>"BASE" { RTOKEN(BASE); }
91e25b4f PB	335	<MRI>"ALIAS" { RTOKEN(ALIAS); }
85e38cfa	336	<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
3d2b83ea	337	<MRI>"LOAD" { RTOKEN(LOAD); }
91e25b4f	338	<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
2e38b71d SC	339	<MRI>"ORDER" { RTOKEN(ORDER); }
	340	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	341	<MRI>"FORMAT" { RTOKEN(FORMAT); }
	342	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
3d2b83ea	343	<MRI>"SECT" { RTOKEN(SECT); }
6bf2e3a7	344	<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
1bd1fa2d SC	345	<MRI>"end" { RTOKEN(ENDWORD); }
	346	<MRI>"chip" { RTOKEN(CHIP); }
	347	<MRI>"load" { RTOKEN(LOAD); }
	348	<MRI>"order" { RTOKEN(ORDER); }
	349	<MRI>"name" { RTOKEN(NAMEWORD); }
	350	<MRI>"format" { RTOKEN(FORMAT); }
	351	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	352	<MRI>"sect" { RTOKEN(SECT); }
6bf2e3a7	353	<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
3d2b83ea	354
ee0c4cf7 SC	355	<COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}* {
	356	yylval.name = buystring(yytext);
	357	return NAME;
	358	}
	359
	360
85e38cfa SC	361	<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
	362	/* Filename without commas, needed to parse mri stuff */
	363	yylval.name = buystring(yytext);
	364	return NAME;
	365	}
	366
	367
	368	<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
9d1fe8a4 SC	369	yylval.name = buystring(yytext);
	370	return NAME;
	371	}
	372	<SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext);
	373	return NAME;
	374	}
	375
	376	<EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
	377	/* No matter the state, quotes
	378	give what's inside */
	379	yylval.name = buystring(yytext+1);
	380	yylval.name[yyleng-2] = 0;
	381	return NAME;
	382	}
	383	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
3d2b83ea	384	<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
9d1fe8a4	385
9d1fe8a4	386	<<EOF>> {
dadd414a SC	387	extern char *ldfile_input_filename;
dadd414a SC	388	include_stack_ptr--;
9d1fe8a4	389
dadd414a SC	390	if (include_stack_ptr == 0)
	391	{
	392	yyterminate();
	393	}
	394	else
	395	{
	396	yy_switch_to_buffer(include_stack[include_stack_ptr]);
	397
	398	}
	399	if (include_stack_ptr==1)
	400	{
	401	BEGIN(COMMAND);
	402	}
	403	else
	404	{
9fce28ed	405	BEGIN(SCRIPT);
dadd414a	406	ldfile_input_filename = file_name_stack[include_stack_ptr-1];
2fa0b342	407	}
dadd414a SC	408
	409	return END;
	410	}
9d1fe8a4	411
9d1fe8a4	412	%%
2fa0b342 DHW	413
2fa0b342 DHW	414	void
8ddef552 DM	415	lex_push_file (file, name)
	416	FILE *file;
	417	char *name;
2fa0b342	418	{
9d1fe8a4 SC	419	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	420	{
	421	einfo("%F:includes nested too deeply");
2fa0b342	422	}
dadd414a SC	423	file_name_stack[include_stack_ptr] = name;
	424	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	425
	426	include_stack_ptr++;
9d1fe8a4 SC	427	yyin = file;
9d1fe8a4 SC	428	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
2fa0b342	429
9d1fe8a4	430	BEGIN(SCRIPT);
2fa0b342 DHW	431	}
2fa0b342 DHW	432
9d1fe8a4	433	YY_BUFFER_STATE
8ddef552 DM	434	yy_create_string_buffer (string, size)
	435	CONST char *string;
	436	int size;
2fa0b342	437	{
9d1fe8a4	438	YY_BUFFER_STATE b;
2fa0b342	439
9d1fe8a4 SC	440	b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
	441	b->yy_input_file = 0;
	442
	443	if ( ! b )
	444	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342	445
9d1fe8a4	446	b->yy_buf_size = size;
2fa0b342	447
9d1fe8a4 SC	448	/* yy_ch_buf has to be 2 characters longer than the size given because
	449	* we need to put in 2 end-of-buffer characters.
	450	*/
	451	b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );
2fa0b342	452
9d1fe8a4 SC	453	if ( ! b->yy_ch_buf )
9d1fe8a4 SC	454	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342 DHW	455
2fa0b342 DHW	456
9d1fe8a4 SC	457	b->yy_ch_buf[0] = '\n';
	458	strcpy(b->yy_ch_buf+1, string);
	459	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
	460	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
	461	b->yy_n_chars = size+1;
	462	b->yy_buf_pos = &b->yy_ch_buf[1];
2fa0b342	463
9d1fe8a4	464	b->yy_eof_status = EOF_NOT_SEEN;
2fa0b342	465
9d1fe8a4	466	return ( b );
2fa0b342	467	}
2fa0b342	468
2fa0b342	469
1418c83b	470
9d1fe8a4	471	void
8ddef552 DM	472	lex_redirect (string)
8ddef552 DM	473	CONST char *string;
9d1fe8a4 SC	474	{
9d1fe8a4 SC	475	YY_BUFFER_STATE tmp;
1d45ccb3	476
9d1fe8a4	477	int len = strlen(string);
dadd414a	478	yy_init = 0 ;
9d1fe8a4 SC	479	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	480	{
	481	einfo("%F: macros nested too deeply");
1418c83b	482	}
dadd414a SC	483	file_name_stack[include_stack_ptr] = "redirect";
	484	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	485	include_stack_ptr++;
9d1fe8a4 SC	486	tmp = yy_create_string_buffer(string, len);
	487
	488	yy_switch_to_buffer(tmp);
	489	BEGIN(COMMAND);
dadd414a	490	yyout = stdout;
9d1fe8a4	491	}
1d45ccb3	492
9d1fe8a4 SC	493	int state_stack[20];
9d1fe8a4 SC	494	int *state_stack_p = state_stack;
1d45ccb3	495
9d1fe8a4	496	void
8ddef552	497	ldlex_script ()
9d1fe8a4	498	{
dadd414a	499	*(state_stack_p)++ = yy_start;
1d45ccb3	500
dadd414a	501	BEGIN(SCRIPT);
9d1fe8a4	502	}
1418c83b	503
2fa0b342	504
3d2b83ea	505	void
8ddef552	506	ldlex_mri_script ()
3d2b83ea	507	{
dadd414a SC	508	*(state_stack_p)++ = yy_start;
dadd414a SC	509	BEGIN(MRI);
0d3e45ea SC	510	}
	511
	512	void
8ddef552	513	ldlex_defsym ()
0d3e45ea	514	{
dadd414a SC	515	*(state_stack_p)++ = yy_start;
dadd414a SC	516	BEGIN(DEFSYMEXP);
3d2b83ea SC	517	}
3d2b83ea SC	518
9d1fe8a4	519	void
8ddef552	520	ldlex_expression ()
9d1fe8a4	521	{
dadd414a SC	522	*(state_stack_p)++ = yy_start;
dadd414a SC	523	BEGIN(EXPRESSION);
1d45ccb3	524
9d1fe8a4 SC	525	}
9d1fe8a4 SC	526	void
8ddef552	527	ldlex_both ()
9d1fe8a4	528	{
dadd414a SC	529	*(state_stack_p)++ = yy_start;
dadd414a SC	530	BEGIN(BOTH);
9d1fe8a4 SC	531	}
9d1fe8a4 SC	532	void
8ddef552	533	ldlex_command ()
9d1fe8a4	534	{
dadd414a SC	535	*(state_stack_p)++ = yy_start;
dadd414a SC	536	BEGIN(COMMAND);
2fa0b342 DHW	537	}
2fa0b342 DHW	538
9d1fe8a4	539	void
8ddef552	540	ldlex_popstate ()
9d1fe8a4	541	{
dadd414a	542	yy_start = *(--state_stack_p);
9d1fe8a4	543	}
2fa0b342	544
9d1fe8a4 SC	545	yy_input(buf, result, max_size)
	546	char *buf;
	547	int *result;
	548	int max_size;
	549	{
	550	*result = 0;
	551	if (yy_current_buffer->yy_input_file)
	552	{
	553	if (yyin)
	554	if ( (result = read( fileno(yyin), (char ) buf, max_size )) < 0 )
	555	YY_FATAL_ERROR( "read() in flex scanner failed" );
	556	}
	557	}
6bf2e3a7	558
85e38cfa SC	559	static
	560	comment()
	561	{
	562	int c;
	563	while (1)
	564	{
	565	c = input();
	566	while (c !='*' && c != EOF)
	567	{
	568	if (c == '\n') lineno++;
	569	c = input();
	570	}
	571
	572
	573	if (c == '*')
	574	{
	575	c = input();
	576	while ( c == '*')
	577	c = input();
	578	if ( c == '/' )
	579	break; /* found the end */
	580	}
	581
	582	if ( c == EOF )
	583	{
	584	einfo( "%F%P :EOF in comment");
	585	break;
	586	}
	587	}
	588	}