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

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

%s COMMAND
%s SCRIPT
%s EXPRESSION
%s COMMENT
%s BOTH
%s DEFSYMEXP
%s MRI
%%

<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>"-A"{FILENAME} 	{
		                	yylval.name = buystring(yytext+2);
				 	return OPTION_Aarch;
			       	}

<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;
				 }
<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);}
<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);}
<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);}
<MRI>"\n"	                { ++ lineno;  RTOKEN(NEWLINE); }
<MRI>"*".*			{ /* Mri comment line */ }
<MRI>"END"                      { RTOKEN(ENDWORD); }
<MRI>"CHIP"                     { RTOKEN(CHIP); }
<MRI>"BASE"                     { RTOKEN(BASE); }
<MRI>"ALIAS"                     { RTOKEN(ALIAS); }
<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); }
<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); }
<MRI>"absolute"			{ RTOKEN(ABSOLUTE); }

<COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}*	{
				 yylval.name = buystring(yytext); 
				  return NAME;
				}


<MRI,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]

"/*"				{ old = INITIAL; BEGIN(COMMENT); }
<COMMAND>"/*"			{ old = COMMAND; BEGIN(COMMENT); }
<BOTH>"/*"			{ old =BOTH; BEGIN(COMMENT); }
<SCRIPT>"/*"			{ old = EXPRESSION; BEGIN(COMMENT); }
<EXPRESSION>"/*"		{ old = SCRIPT; BEGIN(COMMENT); }
"/*"				{ old = INITIAL; BEGIN(COMMENT); }
<COMMENT>[^*\\n]*
<COMMENT>"*"+[^*/\\n]*
<COMMENT>\\n             	{ ++lineno;}
<COMMENT>"*"+"/" 		{ BEGIN(old); }
<<EOF>> {
    include_stack_ptr--;
    
    if (include_stack_ptr == 0) 
    {
      yyterminate();
    }
    else 
    {
      yy_switch_to_buffer(include_stack[include_stack_ptr]);
    }
	BEGIN(COMMAND);
	return END;
  }
    
%%

void
DEFUN(lex_push_file,(file),
     FILE *file)
{
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  {
    einfo("%F:includes nested too deeply");
  }
  include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
  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");
  }
  include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;

  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" );
  }
}
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
9d1fe8a4 SC	46	#undef YY_INPUT
	47	#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
	48	#undef YY_FATAL_ERROR
	49	#define YY_FATAL_ERROR ;
	50	#define MAX_INCLUDE_DEPTH 10
	51	YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
	52	unsigned int include_stack_ptr = 0;
2fa0b342	53
2fa0b342	54
3d2b83ea	55	/* STATES
9d1fe8a4 SC	56	COMMAND on command line
	57	COMMENT in a C comment
	58	EXPRESSION definiatelyt in an expression
	59	SCRIPT definately in a script
	60	SOMEWHERE either EXPRESSION or SCRIPT
3d2b83ea	61	MRI in an MRI script
9d1fe8a4	62	*/
2fa0b342	63	#define RTOKEN(x) { yylval.token = x; return x; }
9d1fe8a4	64	%}
2fa0b342	65
9d1fe8a4 SC	66	%a 4000
9d1fe8a4 SC	67	%o 5000
ee0c4cf7 SC	68
	69	CMDFILENAMECHAR [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-]
	70	CMDFILENAMECHAR1 [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>]
9d1fe8a4	71	FILENAMECHAR1 [_a-zA-Z\/\.\\]
0d3e45ea SC	72	SYMBOLCHARN [_a-zA-Z\/\.\\0-9]
0d3e45ea SC	73	FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\]
9d1fe8a4 SC	74	FILENAME {FILENAMECHAR}+
9d1fe8a4 SC	75	WHITE [ \t\n]+
2fa0b342	76
91e25b4f PB	77	%s COMMAND
	78	%s SCRIPT
	79	%s EXPRESSION
	80	%s COMMENT
	81	%s BOTH
	82	%s DEFSYMEXP
	83	%s MRI
9d1fe8a4	84	%%
91e25b4f	85
0d3e45ea SC	86	<DEFSYMEXP>"-" { RTOKEN('-');}
	87	<DEFSYMEXP>"+" { RTOKEN('+');}
	88	<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = buystring(yytext); return NAME; }
	89	<DEFSYMEXP>[ \t] { RTOKEN(DEFSYMEND); }
	90	<DEFSYMEXP>"=" { RTOKEN('='); }
	91	<COMMAND>"-defsym"{WHITE}* { return OPTION_defsym; }
9d1fe8a4 SC	92	<COMMAND>"-noinhibit_exec" { return OPTION_noinhibit_exec; }
	93	<COMMAND>"-noinhibit-exec" { return OPTION_noinhibit_exec; }
	94	<COMMAND>"-sort_common" { return OPTION_sort_common;}
	95	<COMMAND>"-sort-common" { return OPTION_sort_common;}
	96	<COMMAND>"-format" { return OPTION_format; }
	97	<COMMAND>"-n" { return OPTION_n; }
	98	<COMMAND>"-N" { return OPTION_N; }
	99	<COMMAND>"-r" { return OPTION_r; }
	100	<COMMAND>"-relax" { return OPTION_relax; }
	101	<COMMAND>"-i" { return OPTION_r; }
	102	<COMMAND>"-Ur" { return OPTION_Ur; }
	103	<COMMAND>"-o" { return OPTION_o; }
	104	<COMMAND>"-g" { return OPTION_g; }
	105	<COMMAND>"-e" { return OPTION_e; }
	106	<COMMAND>"-b" { return OPTION_b; }
	107	<COMMAND>"-dc" { return OPTION_dc; }
	108	<COMMAND>"-dp" { return OPTION_dp; }
	109	<COMMAND>"-d" { return OPTION_d; }
	110	<COMMAND>"-v" { return OPTION_v; }
	111	<COMMAND>"-V" { return OPTION_V; }
	112	<COMMAND>"-M" { return OPTION_M; }
	113	<COMMAND>"-Map" { return OPTION_Map;}
	114	<COMMAND>"-t" { return OPTION_t; }
	115	<COMMAND>"-X" { return OPTION_X; }
	116	<COMMAND>"-x" { return OPTION_x; }
	117	<COMMAND>"-c" { return OPTION_c; }
	118	<COMMAND>"-R" { return OPTION_R; }
	119	<COMMAND>"-u" { return OPTION_u; }
	120	<COMMAND>"-s" { return OPTION_s; }
	121	<COMMAND>"-S" { return OPTION_S; }
	122	<COMMAND>"-Bstat" { return OPTION_Bstatic; }
	123	<COMMAND>"-B"{FILENAME} { /* Ignored */ }
	124	<COMMAND>"-l"{FILENAME} {
	125	yylval.name = buystring(yytext+2);
	126	return OPTION_l;
	127	}
	128
	129	<COMMAND>"-L"{FILENAME} {
	130	yylval.name = buystring(yytext+2);
	131	return OPTION_L;
	132	}
	133	<COMMAND>"-Ttext" {
	134	yylval.name = ".text";
	135	return OPTION_Texp;
	136	}
	137	<COMMAND>"-Tdata" {
	138	yylval.name = ".data";
	139	return OPTION_Texp;
	140	}
	141	<COMMAND>"-Tbss" {
	142	yylval.name = ".bss";
	143	return OPTION_Texp;
	144	}
	145	<COMMAND>"-O"{FILENAME} {
	146	yylval.name = buystring(yytext+2);
	147	return OPTION_Texp;
	148	}
	149
	150	<COMMAND>"-T"{FILENAME} {
	151	yylval.name = buystring(yytext+2);
	152	return OPTION_Tfile;
	153	}
	154	<COMMAND>"-T" {
	155	return OPTION_T;
156	}
157
158	<COMMAND>"-F"{FILENAME} {
159	return OPTION_F;
160	}
161	<COMMAND>"-F" {
162	return OPTION_F;
163	}
164
165	<COMMAND>"-A"{FILENAME} {
166	yylval.name = buystring(yytext+2);
167	return OPTION_Aarch;
168	}
3d2b83ea SC	169
3d2b83ea SC	170	<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
dc4726c2	171	yylval.integer = strtoul(yytext+1, 0,16);
3d2b83ea SC	172	return INT;
	173	}
	174
91e25b4f	175	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|X\|B\|O\|D) {
3d2b83ea SC	176	int base ;
	177	switch (yytext[yyleng-1]) {
	178	case 'X':
	179	case 'H':
	180	base = 16;
	181	break;
	182	case 'O':
	183	base = 8;
	184	break;
	185	case 'B':
	186	base = 2;
	187	break;
	188	default:
	189	base = 10;
	190	}
dc4726c2	191	yylval.integer = strtoul(yytext+1, 0, base);
3d2b83ea SC	192	return INT;
3d2b83ea SC	193	}
ee0c4cf7	194	<DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M\|K\|m\|k)? {
dc4726c2	195	yylval.integer = strtoul(yytext,0,hex_mode);
9d1fe8a4 SC	196	if (yytext[yyleng-1]=='M'
	197	\|\| yytext[yyleng-1] == 'm') {
	198	yylval.integer = 10241024;
	199	}
	200	if (yytext[yyleng-1]=='K'
	201	\|\| yytext[yyleng-1]=='k') {
	202	yylval.integer *= 1024;
	203	}
	204	return INT;
	205	}
	206	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	207	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	208	<BOTH,SCRIPT,EXPRESSION>"<<=" { RTOKEN(LSHIFTEQ);}
	209	<BOTH,SCRIPT,EXPRESSION>">>=" { RTOKEN(RSHIFTEQ);}
	210	<BOTH,SCRIPT,EXPRESSION>"\|\|" { RTOKEN(OROR);}
	211	<BOTH,SCRIPT,EXPRESSION>"==" { RTOKEN(EQ);}
	212	<BOTH,SCRIPT,EXPRESSION>"!=" { RTOKEN(NE);}
	213	<BOTH,SCRIPT,EXPRESSION>">=" { RTOKEN(GE);}
	214	<BOTH,SCRIPT,EXPRESSION>"<=" { RTOKEN(LE);}
	215	<BOTH,SCRIPT,EXPRESSION>"<<" { RTOKEN(LSHIFT);}
	216	<BOTH,SCRIPT,EXPRESSION>">>" { RTOKEN(RSHIFT);}
	217	<BOTH,SCRIPT,EXPRESSION>"+=" { RTOKEN(PLUSEQ);}
	218	<BOTH,SCRIPT,EXPRESSION>"-=" { RTOKEN(MINUSEQ);}
	219	<BOTH,SCRIPT,EXPRESSION>"*=" { RTOKEN(MULTEQ);}
	220	<BOTH,SCRIPT,EXPRESSION>"/=" { RTOKEN(DIVEQ);}
	221	<BOTH,SCRIPT,EXPRESSION>"&=" { RTOKEN(ANDEQ);}
	222	<BOTH,SCRIPT,EXPRESSION>"\|=" { RTOKEN(OREQ);}
	223	<BOTH,SCRIPT,EXPRESSION>"&&" { RTOKEN(ANDAND);}
	224	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	225	<MRI,BOTH,SCRIPT,EXPRESSION>"," { RTOKEN(',');}
9d1fe8a4 SC	226	<BOTH,SCRIPT,EXPRESSION>"&" { RTOKEN('&');}
	227	<BOTH,SCRIPT,EXPRESSION>"\|" { RTOKEN('\|');}
	228	<BOTH,SCRIPT,EXPRESSION>"~" { RTOKEN('~');}
	229	<BOTH,SCRIPT,EXPRESSION>"!" { RTOKEN('!');}
	230	<BOTH,SCRIPT,EXPRESSION>"?" { RTOKEN('?');}
	231	<BOTH,SCRIPT,EXPRESSION>"" { RTOKEN('');}
	232	<BOTH,SCRIPT,EXPRESSION>"+" { RTOKEN('+');}
	233	<BOTH,SCRIPT,EXPRESSION>"-" { RTOKEN('-');}
	234	<BOTH,SCRIPT,EXPRESSION>"/" { RTOKEN('/');}
	235	<BOTH,SCRIPT,EXPRESSION>"%" { RTOKEN('%');}
	236	<BOTH,SCRIPT,EXPRESSION>"<" { RTOKEN('<');}
	237	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	238	<MRI,BOTH,SCRIPT,EXPRESSION>"=" { RTOKEN('=');}
9d1fe8a4 SC	239	<BOTH,SCRIPT,EXPRESSION>"}" { RTOKEN('}') ; }
	240	<BOTH,SCRIPT,EXPRESSION>"{" { RTOKEN('{'); }
	241	<BOTH,SCRIPT,EXPRESSION>")" { RTOKEN(')');}
	242	<BOTH,SCRIPT,EXPRESSION>"(" { RTOKEN('(');}
	243	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	244	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	245	<BOTH,SCRIPT,EXPRESSION>":" { RTOKEN(':'); }
	246	<BOTH,SCRIPT,EXPRESSION>";" { RTOKEN(';');}
	247	<BOTH,SCRIPT,EXPRESSION>"-" { RTOKEN('-');}
	248	<BOTH,SCRIPT,EXPRESSION>"/" { RTOKEN('/');}
	249	<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
	250	<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
	251	<BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
	252	<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
	253	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	254	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
	255	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	256	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	257	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	258	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	259	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	260	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	261	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	262	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	263	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	264	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
	265	<BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
	266	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	267	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	268	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	269	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	270	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	271	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	272	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	273	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	274	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	275	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	276	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
	277	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	278	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	279	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	280	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
	281	<BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
	282	<BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	283	<BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	284	<BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	285	<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
	286	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	287	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	288	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	289	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
2e38b71d	290	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
91e25b4f	291	<MRI>"". { /* Mri comment line */ }
2e38b71d	292	<MRI>"END" { RTOKEN(ENDWORD); }
3d2b83ea	293	<MRI>"CHIP" { RTOKEN(CHIP); }
91e25b4f PB	294	<MRI>"BASE" { RTOKEN(BASE); }
91e25b4f PB	295	<MRI>"ALIAS" { RTOKEN(ALIAS); }
3d2b83ea	296	<MRI>"LOAD" { RTOKEN(LOAD); }
91e25b4f	297	<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
2e38b71d SC	298	<MRI>"ORDER" { RTOKEN(ORDER); }
	299	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	300	<MRI>"FORMAT" { RTOKEN(FORMAT); }
	301	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
3d2b83ea SC	302	<MRI>"SECT" { RTOKEN(SECT); }
3d2b83ea SC	303	<MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
1bd1fa2d SC	304	<MRI>"end" { RTOKEN(ENDWORD); }
	305	<MRI>"chip" { RTOKEN(CHIP); }
	306	<MRI>"load" { RTOKEN(LOAD); }
	307	<MRI>"order" { RTOKEN(ORDER); }
	308	<MRI>"name" { RTOKEN(NAMEWORD); }
	309	<MRI>"format" { RTOKEN(FORMAT); }
	310	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	311	<MRI>"sect" { RTOKEN(SECT); }
	312	<MRI>"absolute" { RTOKEN(ABSOLUTE); }
3d2b83ea	313
ee0c4cf7 SC	314	<COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}* {
	315	yylval.name = buystring(yytext);
	316	return NAME;
	317	}
	318
	319
3d2b83ea	320	<MRI,BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
9d1fe8a4 SC	321	yylval.name = buystring(yytext);
	322	return NAME;
	323	}
	324	<SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext);
	325	return NAME;
	326	}
	327
	328	<EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
	329	/* No matter the state, quotes
	330	give what's inside */
	331	yylval.name = buystring(yytext+1);
	332	yylval.name[yyleng-2] = 0;
	333	return NAME;
	334	}
	335	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
3d2b83ea	336	<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
9d1fe8a4 SC	337
	338	"/*" { old = INITIAL; BEGIN(COMMENT); }
	339	<COMMAND>"/*" { old = COMMAND; BEGIN(COMMENT); }
	340	<BOTH>"/*" { old =BOTH; BEGIN(COMMENT); }
	341	<SCRIPT>"/*" { old = EXPRESSION; BEGIN(COMMENT); }
	342	<EXPRESSION>"/*" { old = SCRIPT; BEGIN(COMMENT); }
	343	"/*" { old = INITIAL; BEGIN(COMMENT); }
	344	<COMMENT>[^\\n]
	345	<COMMENT>""+[^/\\n]*
	346	<COMMENT>\\n { ++lineno;}
	347	<COMMENT>"*"+"/" { BEGIN(old); }
9d1fe8a4 SC	348	<<EOF>> {
	349	include_stack_ptr--;
	350
	351	if (include_stack_ptr == 0)
	352	{
	353	yyterminate();
	354	}
	355	else
	356	{
	357	yy_switch_to_buffer(include_stack[include_stack_ptr]);
	358	}
	359	BEGIN(COMMAND);
	360	return END;
2fa0b342	361	}
9d1fe8a4	362
9d1fe8a4	363	%%
2fa0b342 DHW	364
2fa0b342 DHW	365	void
9d1fe8a4 SC	366	DEFUN(lex_push_file,(file),
9d1fe8a4 SC	367	FILE *file)
2fa0b342	368	{
9d1fe8a4 SC	369	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	370	{
	371	einfo("%F:includes nested too deeply");
2fa0b342	372	}
9d1fe8a4 SC	373	include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
	374	yyin = file;
	375	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
2fa0b342	376
9d1fe8a4	377	BEGIN(SCRIPT);
2fa0b342 DHW	378	}
2fa0b342 DHW	379
9d1fe8a4 SC	380	YY_BUFFER_STATE
	381	DEFUN(yy_create_string_buffer,(string, size),
	382	CONST char *string AND
	383	int size )
2fa0b342	384	{
9d1fe8a4	385	YY_BUFFER_STATE b;
2fa0b342	386
9d1fe8a4 SC	387	b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
	388	b->yy_input_file = 0;
	389
	390	if ( ! b )
	391	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342	392
9d1fe8a4	393	b->yy_buf_size = size;
2fa0b342	394
9d1fe8a4 SC	395	/* yy_ch_buf has to be 2 characters longer than the size given because
	396	* we need to put in 2 end-of-buffer characters.
	397	*/
	398	b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );
2fa0b342	399
9d1fe8a4 SC	400	if ( ! b->yy_ch_buf )
9d1fe8a4 SC	401	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342 DHW	402
2fa0b342 DHW	403
9d1fe8a4 SC	404	b->yy_ch_buf[0] = '\n';
	405	strcpy(b->yy_ch_buf+1, string);
	406	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
	407	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
	408	b->yy_n_chars = size+1;
	409	b->yy_buf_pos = &b->yy_ch_buf[1];
2fa0b342	410
9d1fe8a4	411	b->yy_eof_status = EOF_NOT_SEEN;
2fa0b342	412
9d1fe8a4	413	return ( b );
2fa0b342	414	}
2fa0b342	415
2fa0b342	416
1418c83b	417
9d1fe8a4 SC	418	void
	419	DEFUN(lex_redirect,( string),
	420	CONST char *string)
	421	{
	422	YY_BUFFER_STATE tmp;
1d45ccb3	423
9d1fe8a4 SC	424	int len = strlen(string);
	425	yy_init = 0 ;
	426	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	427	{
	428	einfo("%F: macros nested too deeply");
1418c83b	429	}
9d1fe8a4	430	include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
1418c83b	431
9d1fe8a4 SC	432	tmp = yy_create_string_buffer(string, len);
	433
	434	yy_switch_to_buffer(tmp);
	435	BEGIN(COMMAND);
	436	yyout = stdout;
	437	}
1d45ccb3	438
9d1fe8a4 SC	439	int state_stack[20];
9d1fe8a4 SC	440	int *state_stack_p = state_stack;
1d45ccb3	441
9d1fe8a4 SC	442	void
	443	DEFUN_VOID(ldlex_script)
	444	{
	445	*(state_stack_p)++ = yy_start;
1d45ccb3	446
9d1fe8a4 SC	447	BEGIN(SCRIPT);
9d1fe8a4 SC	448	}
1418c83b	449
2fa0b342	450
3d2b83ea SC	451	void
	452	DEFUN_VOID(ldlex_mri_script)
	453	{
0d3e45ea SC	454	*(state_stack_p)++ = yy_start;
	455	BEGIN(MRI);
	456	}
	457
	458	void
	459	DEFUN_VOID(ldlex_defsym)
	460	{
	461	*(state_stack_p)++ = yy_start;
	462	BEGIN(DEFSYMEXP);
3d2b83ea SC	463	}
3d2b83ea SC	464
9d1fe8a4 SC	465	void
	466	DEFUN_VOID(ldlex_expression)
	467	{
	468	*(state_stack_p)++ = yy_start;
	469	BEGIN(EXPRESSION);
1d45ccb3	470
9d1fe8a4 SC	471	}
	472	void
	473	DEFUN_VOID(ldlex_both)
	474	{
	475	*(state_stack_p)++ = yy_start;
	476	BEGIN(BOTH);
	477	}
	478	void
	479	DEFUN_VOID(ldlex_command)
	480	{
	481	*(state_stack_p)++ = yy_start;
	482	BEGIN(COMMAND);
2fa0b342 DHW	483	}
2fa0b342 DHW	484
9d1fe8a4 SC	485	void
	486	DEFUN_VOID(ldlex_popstate)
	487	{
	488	yy_start = *(--state_stack_p);
	489	}
2fa0b342	490
9d1fe8a4 SC	491	yy_input(buf, result, max_size)
	492	char *buf;
	493	int *result;
	494	int max_size;
	495	{
	496	*result = 0;
	497	if (yy_current_buffer->yy_input_file)
	498	{
	499	if (yyin)
	500	if ( (result = read( fileno(yyin), (char ) buf, max_size )) < 0 )
	501	YY_FATAL_ERROR( "read() in flex scanner failed" );
	502	}
	503	}