[binutils.git] / ld / ldlex.l

%{

/* Copyright (C) 1991, 92, 93, 94, 95, 1996 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/*
This was written by steve chamberlain
                    [email protected]
*/


#include <ansidecl.h>
#include <stdio.h>
#include <ctype.h>

#ifdef MPW
/* Prevent enum redefinition problems. */
#define TRUE_FALSE_ALREADY_DEFINED
#endif /* 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"

/* The type of top-level parser input.
   yylex and yyparse (indirectly) both check this.  */
input_type parser_input;

/* Radix to use for bfd_scan_vma -- 0 (default to base 10) or 16.  */
int hex_mode;

/* Line number in the current input file.
   (FIXME Actually, it doesn't appear to get reset for each file?)  */
unsigned int lineno = 1;

/* The string we are currently lexing, or NULL if we are reading a
   file.  */
const char *lex_string = NULL;

/* Support for flex reading from more than one input file (stream).
   `include_stack' is flex's input state for each open file;
   `file_name_stack' is the file names.  `lineno_stack' is the current
   line numbers.

   If `include_stack_ptr' is 0, we haven't started reading anything yet.
   Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid.  */

#undef YY_INPUT
#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)

#define MAX_INCLUDE_DEPTH 10
static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
static const char *file_name_stack[MAX_INCLUDE_DEPTH];
static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
static unsigned int include_stack_ptr = 0;

static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string,
							size_t 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 
	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; }

/* Some versions of flex want this.  */
#ifndef yywrap
int yywrap () { return 1; }
#endif
%}

%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\/\.\-\_\+\=\$\:\[\]\\\,\~]
WILDCHAR	[_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~\?\*]
WHITE		[ \t\n\r]+ 

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


%s SCRIPT
%s EXPRESSION
%s BOTH
%s DEFSYMEXP
%s MRI
%%

  if (parser_input != input_selected)
    {
      /* The first token of the input determines the initial parser state.  */
      input_type t = parser_input;
      parser_input = input_selected;
      switch (t)
	{
	case input_script: return INPUT_SCRIPT; break;
	case input_mri_script: return INPUT_MRI_SCRIPT; break;
	case input_defsym: return INPUT_DEFSYM; break;
	default: abort ();
	}
    }

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


<DEFSYMEXP>"-"                  { RTOKEN('-');}
<DEFSYMEXP>"+"                  { RTOKEN('+');}
<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}*   { yylval.name = buystring(yytext); return NAME; }
<DEFSYMEXP>"="                  { RTOKEN('='); }

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

<MRI,EXPRESSION>([0-9A-Fa-f])+(H|h|X|x|B|b|O|o|D|d) {
				   int ibase ;
				   switch (yytext[yyleng-1]) {
				    case 'X': 
				    case 'x':
				    case 'H':
				    case 'h':
				     ibase = 16;
				     break;
				    case 'O':
				    case 'o':
				     ibase = 8;
				     break;
				    case 'B':
				    case 'b':
				     ibase = 2;
				     break;
				    default:
				     ibase = 10;
				   }
				   yylval.integer = bfd_scan_vma (yytext, 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,MRI>"]"		{ RTOKEN(']');}
<BOTH,SCRIPT,EXPRESSION,MRI>"["		{ RTOKEN('[');}
<BOTH,SCRIPT,EXPRESSION,MRI>"<<="	{ RTOKEN(LSHIFTEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>">>="	{ RTOKEN(RSHIFTEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"||"	{ RTOKEN(OROR);}
<BOTH,SCRIPT,EXPRESSION,MRI>"=="	{ RTOKEN(EQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"!="	{ RTOKEN(NE);}
<BOTH,SCRIPT,EXPRESSION,MRI>">="	{ RTOKEN(GE);}
<BOTH,SCRIPT,EXPRESSION,MRI>"<="	{ RTOKEN(LE);}
<BOTH,SCRIPT,EXPRESSION,MRI>"<<"	{ RTOKEN(LSHIFT);}
<BOTH,SCRIPT,EXPRESSION,MRI>">>"	{ RTOKEN(RSHIFT);}
<BOTH,SCRIPT,EXPRESSION,MRI>"+="	{ RTOKEN(PLUSEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"-="	{ RTOKEN(MINUSEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"*="	{ RTOKEN(MULTEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"/="	{ RTOKEN(DIVEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"&="	{ RTOKEN(ANDEQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"|="	{ RTOKEN(OREQ);}
<BOTH,SCRIPT,EXPRESSION,MRI>"&&"	{ RTOKEN(ANDAND);}
<BOTH,SCRIPT,EXPRESSION,MRI>">"		{ RTOKEN('>');}
<BOTH,SCRIPT,EXPRESSION,MRI>","		{ RTOKEN(',');}
<BOTH,SCRIPT,EXPRESSION,MRI>"&"		{ RTOKEN('&');}
<BOTH,SCRIPT,EXPRESSION,MRI>"|"		{ RTOKEN('|');}
<BOTH,SCRIPT,EXPRESSION,MRI>"~"		{ RTOKEN('~');}
<BOTH,SCRIPT,EXPRESSION,MRI>"!"		{ RTOKEN('!');}
<BOTH,SCRIPT,EXPRESSION,MRI>"?"		{ RTOKEN('?');}
<BOTH,SCRIPT,EXPRESSION,MRI>"*"		{ RTOKEN('*');}
<BOTH,SCRIPT,EXPRESSION,MRI>"+"		{ RTOKEN('+');}
<BOTH,SCRIPT,EXPRESSION,MRI>"-"		{ RTOKEN('-');}
<BOTH,SCRIPT,EXPRESSION,MRI>"/"		{ RTOKEN('/');}
<BOTH,SCRIPT,EXPRESSION,MRI>"%"		{ RTOKEN('%');}
<BOTH,SCRIPT,EXPRESSION,MRI>"<"		{ RTOKEN('<');}
<BOTH,SCRIPT,EXPRESSION,MRI>"="          { RTOKEN('=');}
<BOTH,SCRIPT,EXPRESSION,MRI>"}"			{ RTOKEN('}') ; }
<BOTH,SCRIPT,EXPRESSION,MRI>"{"			{ RTOKEN('{'); }
<BOTH,SCRIPT,EXPRESSION,MRI>")"			{ RTOKEN(')');}
<BOTH,SCRIPT,EXPRESSION,MRI>"("			{ RTOKEN('(');}
<BOTH,SCRIPT,EXPRESSION,MRI>":"		{ RTOKEN(':'); }
<BOTH,SCRIPT,EXPRESSION,MRI>";"		{ RTOKEN(';');}
<BOTH,SCRIPT>"MEMORY"		{ RTOKEN(MEMORY);}
<BOTH,SCRIPT>"ORIGIN"		{ RTOKEN(ORIGIN);}
<EXPRESSION,BOTH,SCRIPT>"BLOCK"		{ RTOKEN(BLOCK);}
<EXPRESSION,BOTH,SCRIPT>"BIND"		{ RTOKEN(BIND);}
<BOTH,SCRIPT>"LENGTH"		{ RTOKEN(LENGTH);}
<EXPRESSION,BOTH,SCRIPT>"ALIGN"			{ RTOKEN(ALIGN_K);}
<EXPRESSION,BOTH,SCRIPT>"ADDR"			{ RTOKEN(ADDR);}
<EXPRESSION,BOTH,SCRIPT>"LOADADDR"		{ RTOKEN(LOADADDR);}
<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>"GROUP"		{ RTOKEN(GROUP);}
<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);}
<BOTH,SCRIPT>"NOCROSSREFS"		{ RTOKEN(NOCROSSREFS);}
<EXPRESSION,BOTH,SCRIPT>"NOLOAD"	{ RTOKEN(NOLOAD);}
<EXPRESSION,BOTH,SCRIPT>"DSECT"		{ RTOKEN(DSECT);}
<EXPRESSION,BOTH,SCRIPT>"COPY"		{ RTOKEN(COPY);}
<EXPRESSION,BOTH,SCRIPT>"INFO"		{ RTOKEN(INFO);}
<EXPRESSION,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);}
<BOTH,SCRIPT>"PHDRS"			{ RTOKEN (PHDRS); }
<EXPRESSION,BOTH,SCRIPT>"AT"			{ RTOKEN(AT);}
<EXPRESSION,BOTH,SCRIPT>"PROVIDE"		{ RTOKEN(PROVIDE); }
<MRI>"#".*\n?\r?		{ ++ lineno; }
<MRI>"\n"	                { ++ lineno;  RTOKEN(NEWLINE); }
<MRI>"\r"	                { ++ lineno;  RTOKEN(NEWLINE); }
<MRI>"*".*			{ /* Mri comment line */ }
<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>"CASE"                     { RTOKEN(CASE); }
<MRI>"EXTERN"                   { RTOKEN(EXTERN); }
<MRI>"START"                    { RTOKEN(START); }
<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>"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>"case"                     { RTOKEN(CASE); }
<MRI>"extern"                   { RTOKEN(EXTERN); }
<MRI>"start"                    { RTOKEN(START); }
<MRI>"list".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
<MRI>"sect"			{ RTOKEN(SECT); }
<EXPRESSION,BOTH,SCRIPT,MRI>"absolute"			{ RTOKEN(ABSOLUTE); }

<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;
				}
<BOTH,EXPRESSION>"-l"{FILENAMECHAR}+ {
				  yylval.name = buystring (yytext + 2);
				  return LNAME;
				}
<SCRIPT>{WILDCHAR}* { yylval.name = buystring(yytext); return NAME; }

<EXPRESSION,BOTH,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++;}
<BOTH,SCRIPT,EXPRESSION>"\r"		{ lineno++;}
<MRI,BOTH,SCRIPT,EXPRESSION>[ \t]

<<EOF>> {
  include_stack_ptr--;
    
  if (include_stack_ptr == 0) 
  {
    yyterminate();
  }
  else 
  {
    yy_switch_to_buffer(include_stack[include_stack_ptr]);

  }
  BEGIN(SCRIPT);
  ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
  lineno = lineno_stack[include_stack_ptr - 1];

  return END;
}

<SCRIPT,MRI>.		lex_warn_invalid(" in script", yytext);
<EXPRESSION,DEFSYMEXP,BOTH>.	lex_warn_invalid(" in expression", yytext);
    
%%
\f

/* Switch flex to reading script file NAME, open on FILE,
   saving the current input info on the include stack.  */

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

/* Return a newly created flex input buffer containing STRING,
   which is SIZE bytes long.  */

static YY_BUFFER_STATE 
yy_create_string_buffer (string, size)
     CONST char *string;
     size_t size;
{
  YY_BUFFER_STATE b;

  /* Calls to m-alloc get turned by sed into xm-alloc.  */
  b = (YY_BUFFER_STATE) malloc (sizeof (struct yy_buffer_state));
  b->yy_input_file = 0;
  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 = (char *) malloc ((unsigned) (b->yy_buf_size + 3));

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

  /* flex 2.4.7 changed the interface.  FIXME: We should not be using
     a flex internal interface in the first place!  */
#ifdef YY_BUFFER_NEW
  b->yy_buffer_status = YY_BUFFER_NEW;
#else
  b->yy_eof_status = EOF_NOT_SEEN;
#endif

  return b;
}

/* Switch flex to reading from STRING, saving the current input info
   on the include stack.  */

void
lex_redirect (string)
     CONST char *string;
{
  YY_BUFFER_STATE tmp;

  yy_init = 0;
  if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
    {
      einfo("%F: macros nested too deeply\n");
    }
  file_name_stack[include_stack_ptr] = "redirect";
  lineno_stack[include_stack_ptr] = 0;
  include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
  include_stack_ptr++;
  tmp = yy_create_string_buffer (string, strlen (string));
  yy_switch_to_buffer (tmp);
  BEGIN (SCRIPT);
}
\f
/* Functions to switch to a different flex start condition,
   saving the current start condition on `state_stack'.  */

static int state_stack[MAX_INCLUDE_DEPTH * 2];
static 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_popstate ()
{
  yy_start = *(--state_stack_p);
}
\f

/* Place up to MAX_SIZE characters in BUF and return in *RESULT
   either the number of characters read, or 0 to indicate EOF.  */

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)
	{
	  *result = read (fileno (yyin), (char *) buf, max_size);
	  if (*result < 0) 
	    einfo ("%F%P: read in flex scanner failed");
	}
    }
}

/* Eat the rest of a C-style comment.  */

static void
comment ()
{
  int c;

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

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

    if (c == '\n' || c == '\r')
      lineno++;

    if (c == EOF)
    {
      einfo( "%F%P: EOF in comment\n");
      break;
    }
  }
}

/* Warn the user about a garbage character WHAT in the input
   in context WHERE.  */

static void
lex_warn_invalid (where, what)
     char *where, *what;
{
  char buf[5];

  /* If we have found an input file whose format we do not recognize,
     and we are therefore treating it as a linker script, and we find
     an invalid character, then most likely this is a real object file
     of some different format.  Treat it as such.  */
  if (ldfile_assumed_script)
    {
      bfd_set_error (bfd_error_file_not_recognized);
      einfo ("%F%s: file not recognized: %E\n", ldfile_input_filename);
    }

  if (! isprint ((unsigned char) *what))
    {
      sprintf (buf, "\\%03o", (unsigned int) *what);
      what = buf;
    }

  einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where);
}
Commit	Line	Data
2fa0b342	1	%{
0d3e45ea	2
86bc0974	3	/* Copyright (C) 1991, 92, 93, 94, 95, 1996 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
86bc0974	19	the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
2fa0b342 DHW	20
2fa0b342 DHW	21	/*
9d1fe8a4 SC	22	This was written by steve chamberlain
9d1fe8a4 SC	23	[email protected]
2fa0b342 DHW	24	*/
	25
	26
9d1fe8a4	27	#include <ansidecl.h>
fcf276c4	28	#include <stdio.h>
86bc0974 ILT	29	#include <ctype.h>
86bc0974 ILT	30
b5b2c886 SS	31	#ifdef MPW
	32	/* Prevent enum redefinition problems. */
	33	#define TRUE_FALSE_ALREADY_DEFINED
	34	#endif /* MPW */
86bc0974	35
a02945df	36	#include "bfd.h"
c477527c	37	#include "sysdep.h"
fcf276c4	38	#include "ld.h"
9d1fe8a4	39	#include "ldgram.h"
fcf276c4 ILT	40	#include "ldmisc.h"
	41	#include "ldexp.h"
	42	#include "ldlang.h"
	43	#include "ldfile.h"
9f629407	44	#include "ldlex.h"
fb55f9b8	45	#include "ldmain.h"
2fa0b342	46
d4e5e3c3 DM	47	/* The type of top-level parser input.
	48	yylex and yyparse (indirectly) both check this. */
	49	input_type parser_input;
2fa0b342	50
d4e5e3c3	51	/* Radix to use for bfd_scan_vma -- 0 (default to base 10) or 16. */
9d1fe8a4	52	int hex_mode;
2e2bf962	53
d4e5e3c3 DM	54	/* Line number in the current input file.
d4e5e3c3 DM	55	(FIXME Actually, it doesn't appear to get reset for each file?) */
dc4726c2	56	unsigned int lineno = 1;
d4e5e3c3	57
86bc0974 ILT	58	/* The string we are currently lexing, or NULL if we are reading a
	59	file. */
	60	const char *lex_string = NULL;
	61
d4e5e3c3 DM	62	/* Support for flex reading from more than one input file (stream).
d4e5e3c3 DM	63	`include_stack' is flex's input state for each open file;
86bc0974 ILT	64	`file_name_stack' is the file names. `lineno_stack' is the current
86bc0974 ILT	65	line numbers.
d4e5e3c3 DM	66
	67	If `include_stack_ptr' is 0, we haven't started reading anything yet.
	68	Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */
1d45ccb3	69
9d1fe8a4 SC	70	#undef YY_INPUT
9d1fe8a4 SC	71	#define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
d4e5e3c3	72
9d1fe8a4	73	#define MAX_INCLUDE_DEPTH 10
d4e5e3c3	74	static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
86bc0974 ILT	75	static const char *file_name_stack[MAX_INCLUDE_DEPTH];
86bc0974 ILT	76	static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
d4e5e3c3	77	static unsigned int include_stack_ptr = 0;
2fa0b342	78
fcf276c4	79	static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string,
d4e5e3c3	80	size_t size));
fcf276c4	81	static void yy_input PARAMS ((char , int result, int max_size));
d4e5e3c3	82
fcf276c4	83	static void comment PARAMS ((void));
fb55f9b8	84	static void lex_warn_invalid PARAMS ((char where, char what));
2fa0b342	85
3d2b83ea	86	/* STATES
fb55f9b8 DM	87	EXPRESSION definitely in an expression
	88	SCRIPT definitely in a script
	89	BOTH either EXPRESSION or SCRIPT
	90	DEFSYMEXP in an argument to -defsym
3d2b83ea	91	MRI in an MRI script
9d1fe8a4	92	*/
2fa0b342	93	#define RTOKEN(x) { yylval.token = x; return x; }
d4e5e3c3 DM	94
	95	/* Some versions of flex want this. */
	96	#ifndef yywrap
	97	int yywrap () { return 1; }
	98	#endif
9d1fe8a4	99	%}
2fa0b342	100
9d1fe8a4 SC	101	%a 4000
9d1fe8a4 SC	102	%o 5000
ee0c4cf7	103
6bf2e3a7 SC	104	CMDFILENAMECHAR [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
	105	CMDFILENAMECHAR1 [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
	106	FILENAMECHAR1 [_a-zA-Z\/\.\\\$\_\~]
0d3e45ea	107	SYMBOLCHARN [_a-zA-Z\/\.\\0-9]
6bf2e3a7	108	FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
86bc0974	109	WILDCHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~\?\*]
31ddb156	110	WHITE [ \t\n\r]+
2fa0b342	111
85e38cfa SC	112	NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
	113
	114
91e25b4f PB	115	%s SCRIPT
91e25b4f PB	116	%s EXPRESSION
91e25b4f PB	117	%s BOTH
	118	%s DEFSYMEXP
	119	%s MRI
9d1fe8a4	120	%%
91e25b4f	121
d4e5e3c3 DM	122	if (parser_input != input_selected)
	123	{
	124	/* The first token of the input determines the initial parser state. */
	125	input_type t = parser_input;
	126	parser_input = input_selected;
31ddb156 ILT	127	switch (t)
	128	{
	129	case input_script: return INPUT_SCRIPT; break;
	130	case input_mri_script: return INPUT_MRI_SCRIPT; break;
	131	case input_defsym: return INPUT_DEFSYM; break;
	132	default: abort ();
	133	}
d4e5e3c3	134	}
6bf2e3a7	135
d4e5e3c3	136	<BOTH,SCRIPT,EXPRESSION>"/*" { comment(); }
6bf2e3a7 SC	137
6bf2e3a7 SC	138
0d3e45ea SC	139	<DEFSYMEXP>"-" { RTOKEN('-');}
	140	<DEFSYMEXP>"+" { RTOKEN('+');}
	141	<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = buystring(yytext); return NAME; }
0d3e45ea	142	<DEFSYMEXP>"=" { RTOKEN('='); }
2a28d8b0	143
3d2b83ea	144	<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
f651733a	145	yylval.integer = bfd_scan_vma (yytext+1, 0,16);
3d2b83ea SC	146	return INT;
	147	}
	148
86bc0974	149	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|h\|X\|x\|B\|b\|O\|o\|D\|d) {
9f629407	150	int ibase ;
3d2b83ea SC	151	switch (yytext[yyleng-1]) {
3d2b83ea SC	152	case 'X':
86bc0974	153	case 'x':
3d2b83ea	154	case 'H':
86bc0974	155	case 'h':
9f629407	156	ibase = 16;
3d2b83ea SC	157	break;
3d2b83ea SC	158	case 'O':
86bc0974	159	case 'o':
9f629407	160	ibase = 8;
3d2b83ea SC	161	break;
3d2b83ea SC	162	case 'B':
86bc0974	163	case 'b':
9f629407	164	ibase = 2;
3d2b83ea SC	165	break;
3d2b83ea SC	166	default:
9f629407	167	ibase = 10;
3d2b83ea	168	}
86bc0974	169	yylval.integer = bfd_scan_vma (yytext, 0,
9f629407	170	ibase);
3d2b83ea SC	171	return INT;
3d2b83ea SC	172	}
9fce28ed	173	<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M\|K\|m\|k)? {
f651733a ILT	174	yylval.integer = bfd_scan_vma (yytext, 0,
f651733a ILT	175	hex_mode);
9d1fe8a4 SC	176	if (yytext[yyleng-1]=='M'
	177	\|\| yytext[yyleng-1] == 'm') {
	178	yylval.integer = 10241024;
	179	}
	180	if (yytext[yyleng-1]=='K'
	181	\|\| yytext[yyleng-1]=='k') {
	182	yylval.integer *= 1024;
	183	}
	184	return INT;
	185	}
86bc0974 ILT	186	<BOTH,SCRIPT,EXPRESSION,MRI>"]" { RTOKEN(']');}
	187	<BOTH,SCRIPT,EXPRESSION,MRI>"[" { RTOKEN('[');}
	188	<BOTH,SCRIPT,EXPRESSION,MRI>"<<=" { RTOKEN(LSHIFTEQ);}
	189	<BOTH,SCRIPT,EXPRESSION,MRI>">>=" { RTOKEN(RSHIFTEQ);}
	190	<BOTH,SCRIPT,EXPRESSION,MRI>"\|\|" { RTOKEN(OROR);}
	191	<BOTH,SCRIPT,EXPRESSION,MRI>"==" { RTOKEN(EQ);}
	192	<BOTH,SCRIPT,EXPRESSION,MRI>"!=" { RTOKEN(NE);}
	193	<BOTH,SCRIPT,EXPRESSION,MRI>">=" { RTOKEN(GE);}
	194	<BOTH,SCRIPT,EXPRESSION,MRI>"<=" { RTOKEN(LE);}
	195	<BOTH,SCRIPT,EXPRESSION,MRI>"<<" { RTOKEN(LSHIFT);}
	196	<BOTH,SCRIPT,EXPRESSION,MRI>">>" { RTOKEN(RSHIFT);}
	197	<BOTH,SCRIPT,EXPRESSION,MRI>"+=" { RTOKEN(PLUSEQ);}
	198	<BOTH,SCRIPT,EXPRESSION,MRI>"-=" { RTOKEN(MINUSEQ);}
	199	<BOTH,SCRIPT,EXPRESSION,MRI>"*=" { RTOKEN(MULTEQ);}
	200	<BOTH,SCRIPT,EXPRESSION,MRI>"/=" { RTOKEN(DIVEQ);}
	201	<BOTH,SCRIPT,EXPRESSION,MRI>"&=" { RTOKEN(ANDEQ);}
	202	<BOTH,SCRIPT,EXPRESSION,MRI>"\|=" { RTOKEN(OREQ);}
	203	<BOTH,SCRIPT,EXPRESSION,MRI>"&&" { RTOKEN(ANDAND);}
	204	<BOTH,SCRIPT,EXPRESSION,MRI>">" { RTOKEN('>');}
	205	<BOTH,SCRIPT,EXPRESSION,MRI>"," { RTOKEN(',');}
	206	<BOTH,SCRIPT,EXPRESSION,MRI>"&" { RTOKEN('&');}
	207	<BOTH,SCRIPT,EXPRESSION,MRI>"\|" { RTOKEN('\|');}
	208	<BOTH,SCRIPT,EXPRESSION,MRI>"~" { RTOKEN('~');}
	209	<BOTH,SCRIPT,EXPRESSION,MRI>"!" { RTOKEN('!');}
	210	<BOTH,SCRIPT,EXPRESSION,MRI>"?" { RTOKEN('?');}
	211	<BOTH,SCRIPT,EXPRESSION,MRI>"" { RTOKEN('');}
	212	<BOTH,SCRIPT,EXPRESSION,MRI>"+" { RTOKEN('+');}
	213	<BOTH,SCRIPT,EXPRESSION,MRI>"-" { RTOKEN('-');}
	214	<BOTH,SCRIPT,EXPRESSION,MRI>"/" { RTOKEN('/');}
	215	<BOTH,SCRIPT,EXPRESSION,MRI>"%" { RTOKEN('%');}
	216	<BOTH,SCRIPT,EXPRESSION,MRI>"<" { RTOKEN('<');}
	217	<BOTH,SCRIPT,EXPRESSION,MRI>"=" { RTOKEN('=');}
	218	<BOTH,SCRIPT,EXPRESSION,MRI>"}" { RTOKEN('}') ; }
	219	<BOTH,SCRIPT,EXPRESSION,MRI>"{" { RTOKEN('{'); }
	220	<BOTH,SCRIPT,EXPRESSION,MRI>")" { RTOKEN(')');}
	221	<BOTH,SCRIPT,EXPRESSION,MRI>"(" { RTOKEN('(');}
	222	<BOTH,SCRIPT,EXPRESSION,MRI>":" { RTOKEN(':'); }
	223	<BOTH,SCRIPT,EXPRESSION,MRI>";" { RTOKEN(';');}
9d1fe8a4 SC	224	<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
9d1fe8a4 SC	225	<BOTH,SCRIPT>"ORIGIN" { RTOKEN(ORIGIN);}
86bc0974 ILT	226	<EXPRESSION,BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
86bc0974 ILT	227	<EXPRESSION,BOTH,SCRIPT>"BIND" { RTOKEN(BIND);}
9d1fe8a4 SC	228	<BOTH,SCRIPT>"LENGTH" { RTOKEN(LENGTH);}
	229	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	230	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
5735ac9e	231	<EXPRESSION,BOTH,SCRIPT>"LOADADDR" { RTOKEN(LOADADDR);}
9d1fe8a4 SC	232	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	233	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	234	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	235	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	236	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	237	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	238	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	239	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	240	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	241	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
86bc0974	242	<EXPRESSION,BOTH,SCRIPT>"GROUP" { RTOKEN(GROUP);}
dadd414a	243	<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
9d1fe8a4 SC	244	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	245	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	246	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	247	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	248	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	249	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	250	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	251	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	252	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	253	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	254	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
c477527c	255	<BOTH,SCRIPT>"QUAD" { RTOKEN( QUAD);}
9d1fe8a4 SC	256	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	257	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	258	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	259	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
582dd77f	260	<BOTH,SCRIPT>"NOCROSSREFS" { RTOKEN(NOCROSSREFS);}
86bc0974 ILT	261	<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
	262	<EXPRESSION,BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	263	<EXPRESSION,BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	264	<EXPRESSION,BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	265	<EXPRESSION,BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
9d1fe8a4 SC	266	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	267	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	268	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	269	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
dadd414a	270	<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
86bc0974	271	<BOTH,SCRIPT>"PHDRS" { RTOKEN (PHDRS); }
9fce28ed	272	<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
86bc0974 ILT	273	<EXPRESSION,BOTH,SCRIPT>"PROVIDE" { RTOKEN(PROVIDE); }
86bc0974 ILT	274	<MRI>"#".*\n?\r? { ++ lineno; }
2e38b71d	275	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
31ddb156	276	<MRI>"\r" { ++ lineno; RTOKEN(NEWLINE); }
91e25b4f	277	<MRI>"". { /* Mri comment line */ }
86bc0974	278	<MRI>";".* { /* Mri comment line */ }
2e38b71d	279	<MRI>"END" { RTOKEN(ENDWORD); }
85e38cfa SC	280	<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
85e38cfa SC	281	<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
3d2b83ea	282	<MRI>"CHIP" { RTOKEN(CHIP); }
91e25b4f PB	283	<MRI>"BASE" { RTOKEN(BASE); }
91e25b4f PB	284	<MRI>"ALIAS" { RTOKEN(ALIAS); }
85e38cfa	285	<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
3d2b83ea	286	<MRI>"LOAD" { RTOKEN(LOAD); }
91e25b4f	287	<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
2e38b71d SC	288	<MRI>"ORDER" { RTOKEN(ORDER); }
	289	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	290	<MRI>"FORMAT" { RTOKEN(FORMAT); }
86bc0974 ILT	291	<MRI>"CASE" { RTOKEN(CASE); }
	292	<MRI>"EXTERN" { RTOKEN(EXTERN); }
	293	<MRI>"START" { RTOKEN(START); }
2e38b71d	294	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
3d2b83ea	295	<MRI>"SECT" { RTOKEN(SECT); }
6bf2e3a7	296	<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
1bd1fa2d	297	<MRI>"end" { RTOKEN(ENDWORD); }
86bc0974 ILT	298	<MRI>"alignmod" { RTOKEN(ALIGNMOD);}
86bc0974 ILT	299	<MRI>"align" { RTOKEN(ALIGN_K);}
1bd1fa2d	300	<MRI>"chip" { RTOKEN(CHIP); }
86bc0974 ILT	301	<MRI>"base" { RTOKEN(BASE); }
	302	<MRI>"alias" { RTOKEN(ALIAS); }
	303	<MRI>"truncate" { RTOKEN(TRUNCATE); }
1bd1fa2d	304	<MRI>"load" { RTOKEN(LOAD); }
86bc0974	305	<MRI>"public" { RTOKEN(PUBLIC); }
1bd1fa2d SC	306	<MRI>"order" { RTOKEN(ORDER); }
	307	<MRI>"name" { RTOKEN(NAMEWORD); }
	308	<MRI>"format" { RTOKEN(FORMAT); }
86bc0974 ILT	309	<MRI>"case" { RTOKEN(CASE); }
	310	<MRI>"extern" { RTOKEN(EXTERN); }
	311	<MRI>"start" { RTOKEN(START); }
1bd1fa2d SC	312	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
1bd1fa2d SC	313	<MRI>"sect" { RTOKEN(SECT); }
6bf2e3a7	314	<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
3d2b83ea	315
85e38cfa SC	316	<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
	317	/* Filename without commas, needed to parse mri stuff */
	318	yylval.name = buystring(yytext);
	319	return NAME;
	320	}
	321
	322
	323	<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
9d1fe8a4 SC	324	yylval.name = buystring(yytext);
	325	return NAME;
	326	}
86bc0974 ILT	327	<BOTH,EXPRESSION>"-l"{FILENAMECHAR}+ {
	328	yylval.name = buystring (yytext + 2);
	329	return LNAME;
9d1fe8a4	330	}
86bc0974	331	<SCRIPT>{WILDCHAR}* { yylval.name = buystring(yytext); return NAME; }
9d1fe8a4	332
d4e5e3c3	333	<EXPRESSION,BOTH,SCRIPT>"\""[^\"]*"\"" {
9d1fe8a4 SC	334	/* No matter the state, quotes
	335	give what's inside */
	336	yylval.name = buystring(yytext+1);
	337	yylval.name[yyleng-2] = 0;
	338	return NAME;
	339	}
	340	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
31ddb156	341	<BOTH,SCRIPT,EXPRESSION>"\r" { lineno++;}
d4e5e3c3	342	<MRI,BOTH,SCRIPT,EXPRESSION>[ \t]
9d1fe8a4	343
9d1fe8a4	344	<<EOF>> {
dadd414a	345	include_stack_ptr--;
9d1fe8a4	346
dadd414a SC	347	if (include_stack_ptr == 0)
	348	{
	349	yyterminate();
	350	}
	351	else
	352	{
	353	yy_switch_to_buffer(include_stack[include_stack_ptr]);
	354
	355	}
d4e5e3c3	356	BEGIN(SCRIPT);
86bc0974 ILT	357	ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
86bc0974 ILT	358	lineno = lineno_stack[include_stack_ptr - 1];
dadd414a SC	359
	360	return END;
	361	}
fb55f9b8	362
fb55f9b8 DM	363	<SCRIPT,MRI>. lex_warn_invalid(" in script", yytext);
fb55f9b8 DM	364	<EXPRESSION,DEFSYMEXP,BOTH>. lex_warn_invalid(" in expression", yytext);
9d1fe8a4	365
9d1fe8a4	366	%%
d4e5e3c3 DM	367	\f
	368
	369	/* Switch flex to reading script file NAME, open on FILE,
	370	saving the current input info on the include stack. */
2fa0b342 DHW	371
2fa0b342 DHW	372	void
8ddef552 DM	373	lex_push_file (file, name)
8ddef552 DM	374	FILE *file;
86bc0974	375	const char *name;
2fa0b342	376	{
9d1fe8a4	377	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
d4e5e3c3 DM	378	{
	379	einfo("%F:includes nested too deeply\n");
	380	}
dadd414a	381	file_name_stack[include_stack_ptr] = name;
86bc0974	382	lineno_stack[include_stack_ptr] = 1;
dadd414a SC	383	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	384
	385	include_stack_ptr++;
9d1fe8a4 SC	386	yyin = file;
9d1fe8a4 SC	387	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
d4e5e3c3	388	BEGIN (SCRIPT);
2fa0b342 DHW	389	}
2fa0b342 DHW	390
d4e5e3c3 DM	391	/* Return a newly created flex input buffer containing STRING,
	392	which is SIZE bytes long. */
	393
fcf276c4	394	static YY_BUFFER_STATE
d4e5e3c3	395	yy_create_string_buffer (string, size)
8ddef552	396	CONST char *string;
d4e5e3c3	397	size_t size;
2fa0b342	398	{
9d1fe8a4	399	YY_BUFFER_STATE b;
2fa0b342	400
d4e5e3c3 DM	401	/* Calls to m-alloc get turned by sed into xm-alloc. */
d4e5e3c3 DM	402	b = (YY_BUFFER_STATE) malloc (sizeof (struct yy_buffer_state));
9d1fe8a4	403	b->yy_input_file = 0;
9d1fe8a4	404	b->yy_buf_size = size;
2fa0b342	405
9d1fe8a4	406	/* yy_ch_buf has to be 2 characters longer than the size given because
d4e5e3c3	407	we need to put in 2 end-of-buffer characters. */
86bc0974	408	b->yy_ch_buf = (char *) malloc ((unsigned) (b->yy_buf_size + 3));
2fa0b342	409
9d1fe8a4	410	b->yy_ch_buf[0] = '\n';
d4e5e3c3	411	strcpy (b->yy_ch_buf+1, string);
9d1fe8a4 SC	412	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
9d1fe8a4 SC	413	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
d4e5e3c3	414	b->yy_n_chars = size+1;
9d1fe8a4	415	b->yy_buf_pos = &b->yy_ch_buf[1];
86bc0974 ILT	416
	417	/* flex 2.4.7 changed the interface. FIXME: We should not be using
	418	a flex internal interface in the first place! */
	419	#ifdef YY_BUFFER_NEW
	420	b->yy_buffer_status = YY_BUFFER_NEW;
	421	#else
9d1fe8a4	422	b->yy_eof_status = EOF_NOT_SEEN;
86bc0974	423	#endif
2fa0b342	424
d4e5e3c3	425	return b;
2fa0b342	426	}
2fa0b342	427
d4e5e3c3 DM	428	/* Switch flex to reading from STRING, saving the current input info
d4e5e3c3 DM	429	on the include stack. */
1418c83b	430
9d1fe8a4	431	void
8ddef552	432	lex_redirect (string)
d4e5e3c3	433	CONST char *string;
9d1fe8a4 SC	434	{
9d1fe8a4 SC	435	YY_BUFFER_STATE tmp;
1d45ccb3	436
d4e5e3c3	437	yy_init = 0;
9d1fe8a4	438	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
d4e5e3c3 DM	439	{
	440	einfo("%F: macros nested too deeply\n");
	441	}
dadd414a	442	file_name_stack[include_stack_ptr] = "redirect";
86bc0974	443	lineno_stack[include_stack_ptr] = 0;
dadd414a SC	444	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
dadd414a SC	445	include_stack_ptr++;
d4e5e3c3 DM	446	tmp = yy_create_string_buffer (string, strlen (string));
	447	yy_switch_to_buffer (tmp);
	448	BEGIN (SCRIPT);
9d1fe8a4	449	}
d4e5e3c3 DM	450	\f
	451	/* Functions to switch to a different flex start condition,
	452	saving the current start condition on `state_stack'. */
1d45ccb3	453
d4e5e3c3 DM	454	static int state_stack[MAX_INCLUDE_DEPTH * 2];
d4e5e3c3 DM	455	static int *state_stack_p = state_stack;
1d45ccb3	456
9d1fe8a4	457	void
8ddef552	458	ldlex_script ()
9d1fe8a4	459	{
dadd414a	460	*(state_stack_p)++ = yy_start;
d4e5e3c3	461	BEGIN (SCRIPT);
9d1fe8a4	462	}
1418c83b	463
3d2b83ea	464	void
8ddef552	465	ldlex_mri_script ()
3d2b83ea	466	{
dadd414a	467	*(state_stack_p)++ = yy_start;
d4e5e3c3	468	BEGIN (MRI);
0d3e45ea SC	469	}
	470
	471	void
8ddef552	472	ldlex_defsym ()
0d3e45ea	473	{
dadd414a	474	*(state_stack_p)++ = yy_start;
d4e5e3c3	475	BEGIN (DEFSYMEXP);
3d2b83ea SC	476	}
3d2b83ea SC	477
9d1fe8a4	478	void
8ddef552	479	ldlex_expression ()
9d1fe8a4	480	{
dadd414a	481	*(state_stack_p)++ = yy_start;
d4e5e3c3	482	BEGIN (EXPRESSION);
9d1fe8a4	483	}
d4e5e3c3	484
9d1fe8a4	485	void
8ddef552	486	ldlex_both ()
9d1fe8a4	487	{
dadd414a	488	*(state_stack_p)++ = yy_start;
d4e5e3c3	489	BEGIN (BOTH);
2fa0b342 DHW	490	}
2fa0b342 DHW	491
9d1fe8a4	492	void
8ddef552	493	ldlex_popstate ()
9d1fe8a4	494	{
dadd414a	495	yy_start = *(--state_stack_p);
9d1fe8a4	496	}
d4e5e3c3 DM	497	\f
	498
	499	/* Place up to MAX_SIZE characters in BUF and return in *RESULT
	500	either the number of characters read, or 0 to indicate EOF. */
2fa0b342	501
fcf276c4	502	static void
d4e5e3c3 DM	503	yy_input (buf, result, max_size)
	504	char *buf;
	505	int *result;
	506	int max_size;
9d1fe8a4 SC	507	{
	508	*result = 0;
	509	if (yy_current_buffer->yy_input_file)
d4e5e3c3 DM	510	{
	511	if (yyin)
	512	{
	513	result = read (fileno (yyin), (char ) buf, max_size);
	514	if (*result < 0)
	515	einfo ("%F%P: read in flex scanner failed");
	516	}
	517	}
9d1fe8a4	518	}
6bf2e3a7	519
d4e5e3c3 DM	520	/* Eat the rest of a C-style comment. */
d4e5e3c3 DM	521
fcf276c4 ILT	522	static void
fcf276c4 ILT	523	comment ()
85e38cfa SC	524	{
85e38cfa SC	525	int c;
d4e5e3c3	526
85e38cfa SC	527	while (1)
	528	{
	529	c = input();
d4e5e3c3	530	while (c != '*' && c != EOF)
85e38cfa	531	{
31ddb156	532	if (c == '\n' \|\| c == '\r')
d4e5e3c3	533	lineno++;
85e38cfa SC	534	c = input();
	535	}
	536
85e38cfa SC	537	if (c == '*')
	538	{
	539	c = input();
d4e5e3c3	540	while (c == '*')
85e38cfa	541	c = input();
d4e5e3c3	542	if (c == '/')
85e38cfa SC	543	break; /* found the end */
	544	}
	545
31ddb156	546	if (c == '\n' \|\| c == '\r')
d4e5e3c3 DM	547	lineno++;
	548
	549	if (c == EOF)
85e38cfa	550	{
d4e5e3c3	551	einfo( "%F%P: EOF in comment\n");
85e38cfa SC	552	break;
	553	}
	554	}
	555	}
fb55f9b8	556
d4e5e3c3 DM	557	/* Warn the user about a garbage character WHAT in the input
	558	in context WHERE. */
	559
fb55f9b8 DM	560	static void
	561	lex_warn_invalid (where, what)
	562	char where, what;
	563	{
86bc0974 ILT	564	char buf[5];
	565
	566	/* If we have found an input file whose format we do not recognize,
	567	and we are therefore treating it as a linker script, and we find
	568	an invalid character, then most likely this is a real object file
	569	of some different format. Treat it as such. */
	570	if (ldfile_assumed_script)
	571	{
	572	bfd_set_error (bfd_error_file_not_recognized);
	573	einfo ("%F%s: file not recognized: %E\n", ldfile_input_filename);
	574	}
	575
	576	if (! isprint ((unsigned char) *what))
	577	{
	578	sprintf (buf, "\\%03o", (unsigned int) *what);
	579	what = buf;
	580	}
	581
	582	einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where);
fb55f9b8	583	}