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

%{

/* Copyright (C) 1991, 1992, 1993, 1994 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>
/* start-sanitize-mpw */
#ifdef MPW
/* Prevent enum redefinition problems. */
#define TRUE_FALSE_ALREADY_DEFINED
#endif /* MPW */
/* end-sanitize-mpw */
#include "bfd.h"
#include "sysdep.h"
#include "ld.h"
#include "ldgram.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include "ldfile.h"
#include "ldlex.h"
#include "ldmain.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));
static void lex_warn_invalid PARAMS ((char *where, char *what));

/* STATES 
	COMMAND	 	on command line
	EXPRESSION	definitely in an expression
	SCRIPT		definitely in a script
	BOTH		either EXPRESSION or SCRIPT
	DEFSYMEXP	in an argument to -defsym
        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 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>"-stats"		{ return OPTION_stats; }
<COMMAND>"-no-keep-memory"	{ return OPTION_no_keep_memory; }
<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>"-e"{FILENAME}		{
 					yylval.name = buystring(yytext+2);
					return OPTION_esymbol;
				}
<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>"-u"{FILENAME}		{
 					yylval.name = buystring(yytext+2);
  					return OPTION_usymbol;
				}
<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"		       {
					return OPTION_y;
				}
				
<COMMAND>"-y"{FILENAME}         {
					yylval.name = buystring(yytext+2);
					return OPTION_ysymbol;
				}
				
<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>"QUAD"			{ RTOKEN( QUAD);}
<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;
}

<COMMAND>.		lex_warn_invalid(" on command line", yytext);
<SCRIPT,MRI>.		lex_warn_invalid(" in script", yytext);
<EXPRESSION,DEFSYMEXP,BOTH>.	lex_warn_invalid(" in expression", yytext);
    
%%

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

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