[deliverable/binutils-gdb.git] / ld / ldlex.l

%{

/* Copyright (C) 1991 Free Software Foundation, Inc.

This file is part of GLD, the Gnu Linker.

GLD is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GLD is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GLD; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/*
This was written by steve chamberlain
                    sac@cygnus.com
*/


typedef int bfd_vma;
#include <ansidecl.h>
#include "ldgram.h"

int ldgram_in_defsym;
int ldgram_had_equals;
int ldgram_in_script;

int hex_mode;
extern int fgetc();
extern int yyparse();


char *buystring();

unsigned int lineno = 1;
int old;

static comment();

#undef YY_INPUT
#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
#undef YY_FATAL_ERROR
#define YY_FATAL_ERROR ;
#define MAX_INCLUDE_DEPTH 10
YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
unsigned int include_stack_ptr = 0;


/* STATES 
	COMMAND	 	on command line
	COMMENT		in a C comment
	EXPRESSION	definiatelyt in an expression
	SCRIPT		definately in a script
	SOMEWHERE	either EXPRESSION or SCRIPT
        MRI             in an MRI script
*/
#define RTOKEN(x)  {  yylval.token = x; return x; }
%}

%a 4000
%o 5000

CMDFILENAMECHAR   [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
CMDFILENAMECHAR1  [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
FILENAMECHAR1	[_a-zA-Z\/\.\\\$\_\~]
SYMBOLCHARN     [_a-zA-Z\/\.\\0-9]
FILENAMECHAR	[_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
FILENAME	{FILENAMECHAR}+
WHITE		[ \t\n]+ 

NOCFILENAMECHAR	[_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]


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


<BOTH,SCRIPT,EXPRESSION,COMMAND>"/*"	{ comment(); }


<DEFSYMEXP>"-"                  { RTOKEN('-');}
<DEFSYMEXP>"+"                  { RTOKEN('+');}
<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}*   { yylval.name = buystring(yytext); return NAME; }
<DEFSYMEXP>[ \t]                { RTOKEN(DEFSYMEND); }
<DEFSYMEXP>"="                  { RTOKEN('='); }
<COMMAND>"-defsym"{WHITE}*	{ return OPTION_defsym; }
<COMMAND>"-noinhibit_exec" 	{ return OPTION_noinhibit_exec; }
<COMMAND>"-noinhibit-exec"	{ return OPTION_noinhibit_exec; }
<COMMAND>"-sort_common"		{ return OPTION_sort_common;}
<COMMAND>"-sort-common"		{ return OPTION_sort_common;}
<COMMAND>"-format"		{ return OPTION_format; }
<COMMAND>"-n"			{ return OPTION_n; }
<COMMAND>"-N"			{ return OPTION_N; }
<COMMAND>"-r"			{ return OPTION_r; }
<COMMAND>"-relax"		{ return OPTION_relax; }
<COMMAND>"-i"			{ return OPTION_r; }
<COMMAND>"-Ur"			{ return OPTION_Ur; }
<COMMAND>"-o"			{ return OPTION_o; }
<COMMAND>"-g"			{ return OPTION_g; }
<COMMAND>"-e"			{ return OPTION_e; }
<COMMAND>"-b"			{ return OPTION_b; }
<COMMAND>"-dc"			{ return OPTION_dc; }
<COMMAND>"-dp"			{ return OPTION_dp; }
<COMMAND>"-d"			{ return OPTION_d; }
<COMMAND>"-v"			{ return OPTION_v; }
<COMMAND>"-V"			{ return OPTION_V; }
<COMMAND>"-M"			{ return OPTION_M; }
<COMMAND>"-Map"	             	{ return OPTION_Map;}
<COMMAND>"-t"			{ return OPTION_t; }
<COMMAND>"-X"			{ return OPTION_X; }
<COMMAND>"-x"			{ return OPTION_x; }
<COMMAND>"-c"			{ return OPTION_c; }
<COMMAND>"-R"			{ return OPTION_R; }
<COMMAND>"-u"			{ return OPTION_u; }
<COMMAND>"-s"	           	{ return OPTION_s; }
<COMMAND>"-S"	           	{ return OPTION_S; }
<COMMAND>"-Bstat"	 	{ return OPTION_Bstatic; }
<COMMAND>"-B"{FILENAME}	   	{ /* Ignored */ }
<COMMAND>"-l"{FILENAME} 	{
 					yylval.name = buystring(yytext+2);
				  	return OPTION_l; 
				}

<COMMAND>"-L"{FILENAME} 	{ 
					yylval.name = buystring(yytext+2);
					return OPTION_L; 
				}
<COMMAND>"-Ttext" 	        {
				 yylval.name = ".text";
				 return OPTION_Texp;
				}
<COMMAND>"-Tdata"  		{
				 yylval.name = ".data";
				 return OPTION_Texp;
			       }
<COMMAND>"-Tbss"		{
				 yylval.name = ".bss";
				 return OPTION_Texp;
			       }
<COMMAND>"-O"{FILENAME} 	{
				yylval.name = buystring(yytext+2);
				return OPTION_Texp;
				}

<COMMAND>"-T"{FILENAME}  	{
				 yylval.name = buystring(yytext+2);
				 return OPTION_Tfile;
			       }
<COMMAND>"-T"          		{
				 return OPTION_T;
			       }

<COMMAND>"-F"{FILENAME}  	{
				 return OPTION_F;
			       }
<COMMAND>"-F"          		{
				 return OPTION_F;
			       }

<COMMAND>"-y"{FILENAME}         {
					yylval.name = buystring(yytext+2);
					return OPTION_y;
				}
				
<COMMAND>"-A"{FILENAME} 	{
		                	yylval.name = buystring(yytext+2);
				 	return OPTION_Aarch;
			       	}

<COMMAND>"-retain-symbols-file"	{ return OPTION_RETAIN_SYMBOLS_FILE; }

<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>"ALIGNMOD"		{ RTOKEN(ALIGNMOD);}
<MRI>"ALIGN"		{ RTOKEN(ALIGN_K);}

<MRI>"CHIP"                     { RTOKEN(CHIP); }
<MRI>"BASE"                     { RTOKEN(BASE); }
<MRI>"ALIAS"                     { RTOKEN(ALIAS); }
<MRI>"TRUNCATE"                     { RTOKEN(TRUNCATE); }
<MRI>"LOAD"                     { RTOKEN(LOAD); }
<MRI>"PUBLIC"                   { RTOKEN(PUBLIC); }
<MRI>"ORDER"                    { RTOKEN(ORDER); }
<MRI>"NAME"                     { RTOKEN(NAMEWORD); }
<MRI>"FORMAT"                   { RTOKEN(FORMAT); }
<MRI>"LIST".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
<MRI>"SECT"			{ RTOKEN(SECT); }
<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE"			{ RTOKEN(ABSOLUTE); }
<MRI>"end"                      { RTOKEN(ENDWORD); }
<MRI>"chip"                     { RTOKEN(CHIP); }
<MRI>"load"                     { RTOKEN(LOAD); }
<MRI>"order"                    { RTOKEN(ORDER); }
<MRI>"name"                     { RTOKEN(NAMEWORD); }
<MRI>"format"                   { RTOKEN(FORMAT); }
<MRI>"list".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
<MRI>"sect"			{ RTOKEN(SECT); }
<EXPRESSION,BOTH,SCRIPT,MRI>"absolute"			{ RTOKEN(ABSOLUTE); }

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


<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}*	{
/* Filename without commas, needed to parse mri stuff */
				 yylval.name = buystring(yytext); 
				  return NAME;
				}


<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}*	{
				 yylval.name = buystring(yytext); 
				  return NAME;
				}
<SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext); 
				  return NAME;
				}

<EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
					/* No matter the state, quotes
					   give what's inside */
					yylval.name = buystring(yytext+1);
					yylval.name[yyleng-2] = 0;
					return NAME;
				}
<BOTH,SCRIPT,EXPRESSION>"\n"		{ lineno++;}
<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]

<<EOF>> {
    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" );
  }
}

static
comment()
{
  int c;
  while (1)
  {
    c = input();
    while (c !='*' && c != EOF) 
    {
      if (c == '\n') lineno++;
      c = input();
    }


    if (c == '*')
    {
      c = input();
      while ( c == '*')
       c = input();
      if ( c == '/' )
       break;			/* found the end */
    }

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