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

%{

/* Copyright (C) 1991 Free Software Foundation, Inc.

This file is part of GLD, the Gnu Linker.

GLD is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

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

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

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


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

int ldgram_in_defsym;
int ldgram_had_equals;
int ldgram_in_script;

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


char *buystring();

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