[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
*/


#include <ansidecl.h>
#include <stdio.h>
#include "bfd.h"
#include "ld.h"
#include "ldgram.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldfile.h"
#include "ldlex.h"

int ldgram_in_defsym;

int hex_mode;

unsigned int lineno = 1;
int old;

#undef YY_INPUT
#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
#undef YY_FATAL_ERROR
#define YY_FATAL_ERROR(s)
#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;

static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string,
							int size));
static void yy_input PARAMS ((char *, int *result, int max_size));
static void comment PARAMS ((void));

/* 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>"--help"		{ return OPTION_help; }
<COMMAND>"--version"		{ return OPTION_version; }
<COMMAND>"-defsym"{WHITE}*	{ return OPTION_defsym; }
<COMMAND>"-format"		{ return OPTION_format; }
<COMMAND>"-noinhibit-exec"	{ return OPTION_noinhibit_exec; }
<COMMAND>"-noinhibit_exec" 	{ return OPTION_noinhibit_exec; }
<COMMAND>"-oformat"		{ return OPTION_oformat; }
<COMMAND>"-sort-common"		{ return OPTION_sort_common;}
<COMMAND>"-sort_common"		{ return OPTION_sort_common;}
<COMMAND>"-warn-common"		{ return OPTION_warn_common;}
<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>"-m"{FILENAME}		{ return OPTION_memul; }
<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_Lfile;
				}
<COMMAND>"-L"			{ 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"([0-9])+		{
					yylval.integer = atoi (yytext + 2);
					return OPTION_Oval;
				}
<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; }

<COMMAND>"-EB"          	{
					return OPTION_EB;
				}
<COMMAND>"-EL"        		{
					return OPTION_EL;
				}
<COMMAND>"-G"			{
					return OPTION_G;
				}
<COMMAND>"-G"([0-9])+		{
					yylval.integer = atoi (yytext + 2);
					return OPTION_Gval;
				}

<COMMAND>"-Qy"			{	return OPTION_Qy; }
<COMMAND>"-dn"			{	return OPTION_dn; }
<COMMAND>"-Y"			{	return OPTION_Y;  }
<COMMAND>"-YP,"{FILENAME}	{
					yylval.name = buystring (yytext+4);
					return OPTION_YP;
				}
<COMMAND>"-non_shared"		{	return OPTION_non_shared; }
<COMMAND>"-call_shared"		{	return OPTION_call_shared; }

<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
  				yylval.integer = bfd_scan_vma (yytext+1, 0,16);
				return INT;
			}

<MRI,EXPRESSION>([0-9A-Fa-f])+(H|X|B|O|D) {
				   int ibase ;
				   switch (yytext[yyleng-1]) {
				    case 'X': 
				    case 'H':
				     ibase = 16;
				     break;
				    case 'O':
				     ibase = 8;
				     break;
				    case 'B':
				     ibase = 2;
				     break;
				    default:
				     ibase = 10;
				   }
				   yylval.integer = bfd_scan_vma (yytext+1, 0,
								  ibase);
				   return INT;
				 }
<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M|K|m|k)? {
				  yylval.integer = bfd_scan_vma (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);}
<EXPRESSION,BOTH,SCRIPT>"AT"			{ RTOKEN(AT);}
<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]);

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

  return END;
}
    
%%

void
lex_push_file (file, name)
     FILE *file;
     char *name;
{
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  {
    einfo("%F:includes nested too deeply\n");
  }
  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);
}

static YY_BUFFER_STATE 
yy_create_string_buffer (string,  size)
     CONST char *string;
     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
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\n");
  }
  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
ldlex_script ()
{
  *(state_stack_p)++ = yy_start;

  BEGIN(SCRIPT);
}


void
ldlex_mri_script ()
{
  *(state_stack_p)++ = yy_start;
  BEGIN(MRI);
}

void
ldlex_defsym ()
{
  *(state_stack_p)++ = yy_start;
  BEGIN(DEFSYMEXP);
}
	   
void
ldlex_expression ()
{
  *(state_stack_p)++ = yy_start;
  BEGIN(EXPRESSION);

}
void
ldlex_both ()
{
  *(state_stack_p)++ = yy_start;
  BEGIN(BOTH);
}
void
ldlex_command ()
{
  *(state_stack_p)++ = yy_start;
  BEGIN(COMMAND);
}

void
ldlex_popstate ()
{
  yy_start = *(--state_stack_p);
}

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