[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>"-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;
			       }
<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
DEFUN(lex_push_file,(file,name),
     FILE *file AND
     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 
DEFUN(yy_create_string_buffer,(string,  size),
      CONST char *string AND
      int size )
{
  YY_BUFFER_STATE b;

  b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  b->yy_input_file = 0;
  
  if ( ! b )
   YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

  b->yy_buf_size = size;

  /* yy_ch_buf has to be 2 characters longer than the size given because
   * we need to put in 2 end-of-buffer characters.
   */
  b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );

  if ( ! b->yy_ch_buf )
   YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );


  b->yy_ch_buf[0] = '\n';
  strcpy(b->yy_ch_buf+1,  string);
  b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
  b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
    b->yy_n_chars = size+1;
  b->yy_buf_pos = &b->yy_ch_buf[1];

  b->yy_eof_status = EOF_NOT_SEEN;

  return ( b );
}


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

  int len = strlen(string);
  yy_init = 0  ;  
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  {
    einfo("%F: macros nested too deeply");
  }
  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
DEFUN_VOID(ldlex_script)
{
  *(state_stack_p)++ = yy_start;

  BEGIN(SCRIPT);
}


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

void
DEFUN_VOID(ldlex_defsym)
{
  *(state_stack_p)++ = yy_start;
  BEGIN(DEFSYMEXP);
}
	   
void
DEFUN_VOID(ldlex_expression)
{
  *(state_stack_p)++ = yy_start;
  BEGIN(EXPRESSION);

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

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

yy_input(buf, result, max_size)
char *buf;
int *result;
int max_size;
{
  *result = 0; 
  if (yy_current_buffer->yy_input_file)
  {
    if (yyin)
     if ( (*result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) 
      YY_FATAL_ERROR( "read() in flex scanner failed" );
  }
}

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