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

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
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 = strtol(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 = strtol(yytext+1, 0, base);	
				   return INT;
				 }
<MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M|K|m|k)? {
				  yylval.integer = strtol(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); }

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