[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]+ 

%x COMMAND
%x SCRIPT
%x EXPRESSION
%x COMMENT
%x BOTH
%x DEFSYMEXP
%x 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>"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); }
<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
9d1fe8a4 SC	77	%x COMMAND
	78	%x SCRIPT
	79	%x EXPRESSION
	80	%x COMMENT
	81	%x BOTH
0d3e45ea	82	%x DEFSYMEXP
3d2b83ea	83	%x MRI
9d1fe8a4 SC	84	%%
9d1fe8a4 SC	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
	175	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|X\|B\|O\|D)
	176	{
	177	int base ;
	178	switch (yytext[yyleng-1]) {
	179	case 'X':
	180	case 'H':
	181	base = 16;
	182	break;
	183	case 'O':
	184	base = 8;
	185	break;
	186	case 'B':
	187	base = 2;
	188	break;
	189	default:
	190	base = 10;
	191	}
dc4726c2	192	yylval.integer = strtoul(yytext+1, 0, base);
3d2b83ea SC	193	return INT;
3d2b83ea SC	194	}
ee0c4cf7	195	<DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M\|K\|m\|k)? {
dc4726c2	196	yylval.integer = strtoul(yytext,0,hex_mode);
9d1fe8a4 SC	197	if (yytext[yyleng-1]=='M'
	198	\|\| yytext[yyleng-1] == 'm') {
	199	yylval.integer = 10241024;
	200	}
	201	if (yytext[yyleng-1]=='K'
	202	\|\| yytext[yyleng-1]=='k') {
	203	yylval.integer *= 1024;
	204	}
	205	return INT;
	206	}
	207	<BOTH,SCRIPT,EXPRESSION>"]" { RTOKEN(']');}
	208	<BOTH,SCRIPT,EXPRESSION>"[" { RTOKEN('[');}
	209	<BOTH,SCRIPT,EXPRESSION>"<<=" { RTOKEN(LSHIFTEQ);}
	210	<BOTH,SCRIPT,EXPRESSION>">>=" { RTOKEN(RSHIFTEQ);}
	211	<BOTH,SCRIPT,EXPRESSION>"\|\|" { RTOKEN(OROR);}
	212	<BOTH,SCRIPT,EXPRESSION>"==" { RTOKEN(EQ);}
	213	<BOTH,SCRIPT,EXPRESSION>"!=" { RTOKEN(NE);}
	214	<BOTH,SCRIPT,EXPRESSION>">=" { RTOKEN(GE);}
	215	<BOTH,SCRIPT,EXPRESSION>"<=" { RTOKEN(LE);}
	216	<BOTH,SCRIPT,EXPRESSION>"<<" { RTOKEN(LSHIFT);}
	217	<BOTH,SCRIPT,EXPRESSION>">>" { RTOKEN(RSHIFT);}
	218	<BOTH,SCRIPT,EXPRESSION>"+=" { RTOKEN(PLUSEQ);}
	219	<BOTH,SCRIPT,EXPRESSION>"-=" { RTOKEN(MINUSEQ);}
	220	<BOTH,SCRIPT,EXPRESSION>"*=" { RTOKEN(MULTEQ);}
	221	<BOTH,SCRIPT,EXPRESSION>"/=" { RTOKEN(DIVEQ);}
	222	<BOTH,SCRIPT,EXPRESSION>"&=" { RTOKEN(ANDEQ);}
	223	<BOTH,SCRIPT,EXPRESSION>"\|=" { RTOKEN(OREQ);}
	224	<BOTH,SCRIPT,EXPRESSION>"&&" { RTOKEN(ANDAND);}
	225	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	226	<MRI,BOTH,SCRIPT,EXPRESSION>"," { RTOKEN(',');}
9d1fe8a4 SC	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('<');}
	238	<BOTH,SCRIPT,EXPRESSION>">" { RTOKEN('>');}
3d2b83ea	239	<MRI,BOTH,SCRIPT,EXPRESSION>"=" { RTOKEN('=');}
9d1fe8a4 SC	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,EXPRESSION>"/" { RTOKEN('/');}
	250	<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
	251	<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
	252	<BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
	253	<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
	254	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	255	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
	256	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	257	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	258	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	259	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	260	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	261	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	262	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	263	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	264	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	265	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
	266	<BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
	267	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	268	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	269	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	270	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	271	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	272	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	273	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	274	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	275	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	276	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	277	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
	278	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	279	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	280	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	281	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
	282	<BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
	283	<BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	284	<BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	285	<BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	286	<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
	287	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	288	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	289	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	290	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
2e38b71d	291	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
3d2b83ea	292	<MRI>^"". { /* Mri comment line */ }
2e38b71d	293	<MRI>"END" { RTOKEN(ENDWORD); }
3d2b83ea SC	294	<MRI>"CHIP" { RTOKEN(CHIP); }
3d2b83ea SC	295	<MRI>"LOAD" { RTOKEN(LOAD); }
2e38b71d SC	296	<MRI>"ORDER" { RTOKEN(ORDER); }
	297	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	298	<MRI>"FORMAT" { RTOKEN(FORMAT); }
	299	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
3d2b83ea SC	300	<MRI>"SECT" { RTOKEN(SECT); }
3d2b83ea SC	301	<MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
1bd1fa2d SC	302	<MRI>"end" { RTOKEN(ENDWORD); }
	303	<MRI>"chip" { RTOKEN(CHIP); }
	304	<MRI>"load" { RTOKEN(LOAD); }
	305	<MRI>"order" { RTOKEN(ORDER); }
	306	<MRI>"name" { RTOKEN(NAMEWORD); }
	307	<MRI>"format" { RTOKEN(FORMAT); }
	308	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	309	<MRI>"sect" { RTOKEN(SECT); }
	310	<MRI>"absolute" { RTOKEN(ABSOLUTE); }
3d2b83ea	311
ee0c4cf7 SC	312	<COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}* {
	313	yylval.name = buystring(yytext);
	314	return NAME;
	315	}
	316
	317
3d2b83ea	318	<MRI,BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
9d1fe8a4 SC	319	yylval.name = buystring(yytext);
	320	return NAME;
	321	}
	322	<SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext);
	323	return NAME;
	324	}
	325
	326	<EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
	327	/* No matter the state, quotes
	328	give what's inside */
	329	yylval.name = buystring(yytext+1);
	330	yylval.name[yyleng-2] = 0;
	331	return NAME;
	332	}
	333	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
3d2b83ea	334	<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
9d1fe8a4 SC	335
	336	"/*" { old = INITIAL; BEGIN(COMMENT); }
	337	<COMMAND>"/*" { old = COMMAND; BEGIN(COMMENT); }
	338	<BOTH>"/*" { old =BOTH; BEGIN(COMMENT); }
	339	<SCRIPT>"/*" { old = EXPRESSION; BEGIN(COMMENT); }
	340	<EXPRESSION>"/*" { old = SCRIPT; BEGIN(COMMENT); }
	341	"/*" { old = INITIAL; BEGIN(COMMENT); }
	342	<COMMENT>[^\\n]
	343	<COMMENT>""+[^/\\n]*
	344	<COMMENT>\\n { ++lineno;}
	345	<COMMENT>"*"+"/" { BEGIN(old); }
	346
3d2b83ea	347
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
2fa0b342	363
2fa0b342 DHW	364
2fa0b342 DHW	365
2fa0b342	366
2fa0b342	367
2fa0b342 DHW	368
2fa0b342 DHW	369
9d1fe8a4	370	%%
2fa0b342 DHW	371
2fa0b342 DHW	372	void
9d1fe8a4 SC	373	DEFUN(lex_push_file,(file),
9d1fe8a4 SC	374	FILE *file)
2fa0b342	375	{
9d1fe8a4 SC	376	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	377	{
	378	einfo("%F:includes nested too deeply");
2fa0b342	379	}
9d1fe8a4 SC	380	include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
	381	yyin = file;
	382	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
2fa0b342	383
9d1fe8a4	384	BEGIN(SCRIPT);
2fa0b342 DHW	385	}
2fa0b342 DHW	386
9d1fe8a4 SC	387	YY_BUFFER_STATE
	388	DEFUN(yy_create_string_buffer,(string, size),
	389	CONST char *string AND
	390	int size )
2fa0b342	391	{
9d1fe8a4	392	YY_BUFFER_STATE b;
2fa0b342	393
9d1fe8a4 SC	394	b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
	395	b->yy_input_file = 0;
	396
	397	if ( ! b )
	398	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342	399
9d1fe8a4	400	b->yy_buf_size = size;
2fa0b342	401
9d1fe8a4 SC	402	/* yy_ch_buf has to be 2 characters longer than the size given because
	403	* we need to put in 2 end-of-buffer characters.
	404	*/
	405	b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );
2fa0b342	406
9d1fe8a4 SC	407	if ( ! b->yy_ch_buf )
9d1fe8a4 SC	408	YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2fa0b342 DHW	409
2fa0b342 DHW	410
9d1fe8a4 SC	411	b->yy_ch_buf[0] = '\n';
	412	strcpy(b->yy_ch_buf+1, string);
	413	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
	414	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
	415	b->yy_n_chars = size+1;
	416	b->yy_buf_pos = &b->yy_ch_buf[1];
2fa0b342	417
9d1fe8a4	418	b->yy_eof_status = EOF_NOT_SEEN;
2fa0b342	419
9d1fe8a4	420	return ( b );
2fa0b342	421	}
2fa0b342	422
2fa0b342	423
1418c83b	424
9d1fe8a4 SC	425	void
	426	DEFUN(lex_redirect,( string),
	427	CONST char *string)
	428	{
	429	YY_BUFFER_STATE tmp;
1d45ccb3	430
9d1fe8a4 SC	431	int len = strlen(string);
	432	yy_init = 0 ;
	433	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	434	{
	435	einfo("%F: macros nested too deeply");
1418c83b	436	}
9d1fe8a4	437	include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER;
1418c83b	438
9d1fe8a4 SC	439	tmp = yy_create_string_buffer(string, len);
	440
	441	yy_switch_to_buffer(tmp);
	442	BEGIN(COMMAND);
	443	yyout = stdout;
	444	}
1d45ccb3	445
9d1fe8a4 SC	446	int state_stack[20];
9d1fe8a4 SC	447	int *state_stack_p = state_stack;
1d45ccb3	448
9d1fe8a4 SC	449	void
	450	DEFUN_VOID(ldlex_script)
	451	{
	452	*(state_stack_p)++ = yy_start;
1d45ccb3	453
9d1fe8a4 SC	454	BEGIN(SCRIPT);
9d1fe8a4 SC	455	}
1418c83b	456
2fa0b342	457
3d2b83ea SC	458	void
	459	DEFUN_VOID(ldlex_mri_script)
	460	{
0d3e45ea SC	461	*(state_stack_p)++ = yy_start;
	462	BEGIN(MRI);
	463	}
	464
	465	void
	466	DEFUN_VOID(ldlex_defsym)
	467	{
	468	*(state_stack_p)++ = yy_start;
	469	BEGIN(DEFSYMEXP);
3d2b83ea SC	470	}
3d2b83ea SC	471
9d1fe8a4 SC	472	void
	473	DEFUN_VOID(ldlex_expression)
	474	{
	475	*(state_stack_p)++ = yy_start;
	476	BEGIN(EXPRESSION);
1d45ccb3	477
9d1fe8a4 SC	478	}
	479	void
	480	DEFUN_VOID(ldlex_both)
	481	{
	482	*(state_stack_p)++ = yy_start;
	483	BEGIN(BOTH);
	484	}
	485	void
	486	DEFUN_VOID(ldlex_command)
	487	{
	488	*(state_stack_p)++ = yy_start;
	489	BEGIN(COMMAND);
2fa0b342 DHW	490	}
2fa0b342 DHW	491
9d1fe8a4 SC	492	void
	493	DEFUN_VOID(ldlex_popstate)
	494	{
	495	yy_start = *(--state_stack_p);
	496	}
2fa0b342	497
9d1fe8a4 SC	498	yy_input(buf, result, max_size)
	499	char *buf;
	500	int *result;
	501	int max_size;
	502	{
	503	*result = 0;
	504	if (yy_current_buffer->yy_input_file)
	505	{
	506	if (yyin)
	507	if ( (result = read( fileno(yyin), (char ) buf, max_size )) < 0 )
	508	YY_FATAL_ERROR( "read() in flex scanner failed" );
	509	}
	510	}
2fa0b342	511