[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];
char *file_name_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);}
<EXPRESSION,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);}
<EXPRESSION,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);}
<BOTH,SCRIPT>"INCLUDE"			{ RTOKEN(INCLUDE);}
<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>> {
  extern char *ldfile_input_filename;
  include_stack_ptr--;
    
  if (include_stack_ptr == 0) 
  {
    yyterminate();
  }
  else 
  {
    yy_switch_to_buffer(include_stack[include_stack_ptr]);

  }
  if (include_stack_ptr==1) 
  {
    BEGIN(COMMAND);
  }
  else 
  {
    ldfile_input_filename = file_name_stack[include_stack_ptr-1];
  }

  return END;
}
    
%%

void
DEFUN(lex_push_file,(file,name),
     FILE *file AND
     char *name)
{
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  {
    einfo("%F:includes nested too deeply");
  }
  file_name_stack[include_stack_ptr] = name;
  include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;

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