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

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


#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
%%


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