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

%{

/* Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   2000, 2001, 2002, 2003, 2004, 2005  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
                    sac@cygnus.com
*/


#include <stdio.h>

#include "bfd.h"
#include "sysdep.h"
#include "safe-ctype.h"
#include "bfdlink.h"
#include "ld.h"
#include "ldmisc.h"
#include "ldexp.h"
#include "ldlang.h"
#include <ldgram.h>
#include "ldfile.h"
#include "ldlex.h"
#include "ldmain.h"
#include "libiberty.h"

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

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

#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 int vers_node_nesting = 0;

static void yy_input (char *, int *, int);
static void comment (void);
static void lex_warn_invalid (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
	VERS_START	starting a Sun style mapfile
	VERS_SCRIPT	a Sun style mapfile
	VERS_NODE	a node within a Sun style mapfile
*/
#define RTOKEN(x)  {  yylval.token = x; return x; }

/* Some versions of flex want this.  */
#ifndef yywrap
int yywrap (void) { 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\/\.\-\_\+\$\:\[\]\\\~]

V_TAG [.$_a-zA-Z][._a-zA-Z0-9]*
V_IDENTIFIER [*?.$_a-zA-Z\[\]\-\!\^\\]([*?.$_a-zA-Z0-9\[\]\-\!\^\\]|::)*

%s SCRIPT
%s EXPRESSION
%s BOTH
%s DEFSYMEXP
%s MRI
%s VERS_START
%s VERS_SCRIPT
%s VERS_NODE
%%

  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_version_script: return INPUT_VERSION_SCRIPT; break;
	case input_defsym: return INPUT_DEFSYM; break;
	default: abort ();
	}
    }

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


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

<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
  				yylval.integer = bfd_scan_vma (yytext + 1, 0, 16);
				yylval.bigint.str = NULL;
				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);
				   yylval.bigint.str = NULL;
				   return INT;
				 }
<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>((("$"|0[xX])([0-9A-Fa-f])+)|(([0-9])+))(M|K|m|k)? {
				  char *s = yytext;
				  int ibase = 0;

				  if (*s == '$')
				    {
				      ++s;
				      ibase = 16;
				    }
				  yylval.integer = bfd_scan_vma (s, 0, ibase);
				  yylval.bigint.str = NULL;
				  if (yytext[yyleng - 1] == 'M'
				      || yytext[yyleng - 1] == 'm')
				    {
				      yylval.integer *= 1024 * 1024;
				    }
				  else if (yytext[yyleng - 1] == 'K'
				      || yytext[yyleng - 1]=='k')
				    {
				      yylval.integer *= 1024;
				    }
				  else if (yytext[0] == '0'
					   && (yytext[1] == 'x'
					       || yytext[1] == 'X'))
				    {
				      yylval.bigint.str = xstrdup (yytext + 2);
				    }
				  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,EXPRESSION>"ORIGIN"	{ RTOKEN(ORIGIN);}
<BOTH,SCRIPT>"VERSION"			{ RTOKEN(VERSIONK);}
<EXPRESSION,BOTH,SCRIPT>"BLOCK"		{ RTOKEN(BLOCK);}
<EXPRESSION,BOTH,SCRIPT>"BIND"		{ RTOKEN(BIND);}
<BOTH,SCRIPT,EXPRESSION>"LENGTH"	{ RTOKEN(LENGTH);}
<EXPRESSION,BOTH,SCRIPT>"ALIGN"		{ RTOKEN(ALIGN_K);}
<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_ALIGN"	{ RTOKEN(DATA_SEGMENT_ALIGN);}
<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_RELRO_END"	{ RTOKEN(DATA_SEGMENT_RELRO_END);}
<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_END"	{ RTOKEN(DATA_SEGMENT_END);}
<EXPRESSION,BOTH,SCRIPT>"ADDR"		{ RTOKEN(ADDR);}
<EXPRESSION,BOTH,SCRIPT>"LOADADDR"	{ RTOKEN(LOADADDR);}
<EXPRESSION,BOTH>"MAX"			{ RTOKEN(MAX_K); }
<EXPRESSION,BOTH>"MIN"			{ RTOKEN(MIN_K); }
<EXPRESSION,BOTH>"ASSERT"		{ RTOKEN(ASSERT_K); }
<BOTH,SCRIPT>"ENTRY"			{ RTOKEN(ENTRY);}
<BOTH,SCRIPT,MRI>"EXTERN"		{ RTOKEN(EXTERN);}
<EXPRESSION,BOTH,SCRIPT>"NEXT"		{ RTOKEN(NEXT);}
<EXPRESSION,BOTH,SCRIPT>"sizeof_headers"	{ RTOKEN(SIZEOF_HEADERS);}
<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS"	{ RTOKEN(SIZEOF_HEADERS);}
<EXPRESSION,BOTH,SCRIPT>"SEGMENT_START" { RTOKEN(SEGMENT_START);}
<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>"AS_NEEDED"	{ RTOKEN(AS_NEEDED);}
<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>"INHIBIT_COMMON_ALLOCATION" { RTOKEN(INHIBIT_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>"SQUAD"			{ RTOKEN( SQUAD);}
<BOTH,SCRIPT>"LONG"			{ RTOKEN( LONG);}
<BOTH,SCRIPT>"SHORT"			{ RTOKEN( SHORT);}
<BOTH,SCRIPT>"BYTE"			{ RTOKEN( BYTE);}
<BOTH,SCRIPT>"NOFLOAT"			{ RTOKEN(NOFLOAT);}
<EXPRESSION,BOTH,SCRIPT>"NOCROSSREFS"	{ RTOKEN(NOCROSSREFS);}
<BOTH,SCRIPT>"OVERLAY"			{ RTOKEN(OVERLAY); }
<BOTH,SCRIPT>"SORT_BY_NAME"		{ RTOKEN(SORT_BY_NAME); }
<BOTH,SCRIPT>"SORT_BY_ALIGNMENT"	{ RTOKEN(SORT_BY_ALIGNMENT); }
<BOTH,SCRIPT>"SORT"			{ RTOKEN(SORT_BY_NAME); }
<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);}
<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RO"	{ RTOKEN(ONLY_IF_RO); }
<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RW"	{ RTOKEN(ONLY_IF_RW); }
<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>"SUBALIGN"	{ RTOKEN(SUBALIGN);}
<EXPRESSION,BOTH,SCRIPT>"PROVIDE"	{ RTOKEN(PROVIDE); }
<EXPRESSION,BOTH,SCRIPT>"KEEP"		{ RTOKEN(KEEP); }
<EXPRESSION,BOTH,SCRIPT>"EXCLUDE_FILE"  { RTOKEN(EXCLUDE_FILE); }
<MRI>"#".*\n?			{ ++ lineno; }
<MRI>"\n"	                { ++ 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>"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 = xstrdup (yytext);
				  return NAME;
				}


<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}*	{
				 yylval.name = xstrdup (yytext);
				  return NAME;
				}
<BOTH,EXPRESSION>"-l"{FILENAMECHAR}+ {
				  yylval.name = xstrdup (yytext + 2);
				  return LNAME;
				}
<SCRIPT>{WILDCHAR}* {
		/* Annoyingly, this pattern can match comments, and we have
		   longest match issues to consider.  So if the first two
		   characters are a comment opening, put the input back and
		   try again.  */
		if (yytext[0] == '/' && yytext[1] == '*')
		  {
		    yyless (2);
		    comment ();
		  }
		else
		  {
		    yylval.name = xstrdup (yytext);
		    return NAME;
		  }
	}

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

<VERS_NODE,VERS_SCRIPT>[:,;]	{ return *yytext; }

<VERS_NODE>global		{ RTOKEN(GLOBAL); }

<VERS_NODE>local		{ RTOKEN(LOCAL); }

<VERS_NODE>extern		{ RTOKEN(EXTERN); }

<VERS_NODE>{V_IDENTIFIER}	{ yylval.name = xstrdup (yytext);
				  return VERS_IDENTIFIER; }

<VERS_SCRIPT>{V_TAG}		{ yylval.name = xstrdup (yytext);
				  return VERS_TAG; }

<VERS_START>"{"			{ BEGIN(VERS_SCRIPT); return *yytext; }

<VERS_SCRIPT>"{"		{ BEGIN(VERS_NODE);
				  vers_node_nesting = 0;
				  return *yytext;
				}
<VERS_SCRIPT>"}"		{ return *yytext; }
<VERS_NODE>"{"			{ vers_node_nesting++; return *yytext; }
<VERS_NODE>"}"			{ if (--vers_node_nesting < 0)
				    BEGIN(VERS_SCRIPT);
				  return *yytext;
				}

<VERS_START,VERS_NODE,VERS_SCRIPT>[\n]		{ lineno++; }

<VERS_START,VERS_NODE,VERS_SCRIPT>#.*		{ /* Eat up comments */ }

<VERS_START,VERS_NODE,VERS_SCRIPT>[ \t\r]+   	{ /* Eat up whitespace */ }

<<EOF>> {
  include_stack_ptr--;

  if (include_stack_ptr == 0)
  {
    yyterminate ();
  }
  else
  {
    yy_switch_to_buffer (include_stack[include_stack_ptr]);
  }

  ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
  lineno = lineno_stack[include_stack_ptr];

  return END;
}

<SCRIPT,MRI,VERS_START,VERS_SCRIPT,VERS_NODE>.	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 *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] = lineno;
  include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;

  include_stack_ptr++;
  lineno = 1;
  yyin = file;
  yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE));
}

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

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

  /* Calls to m-alloc get turned by sed into xm-alloc.  */
  b = 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 = 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];

  b->yy_is_our_buffer = 1;
  b->yy_is_interactive = 0;
  b->yy_at_bol = 1;
  b->yy_fill_buffer = 0;

  /* 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 (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] = lineno;
  include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
  include_stack_ptr++;
  lineno = 1;
  tmp = yy_create_string_buffer (string, strlen (string));
  yy_switch_to_buffer (tmp);
}
\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 (void)
{
  *(state_stack_p)++ = yy_start;
  BEGIN (SCRIPT);
}

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

void
ldlex_version_script (void)
{
  *(state_stack_p)++ = yy_start;
  BEGIN (VERS_START);
}

void
ldlex_version_file (void)
{
  *(state_stack_p)++ = yy_start;
  BEGIN (VERS_SCRIPT);
}

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

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

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

void
ldlex_popstate (void)
{
  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 (char *buf, int *result, int max_size)
{
  *result = 0;
  if (YY_CURRENT_BUFFER->yy_input_file)
    {
      if (yyin)
	{
	  *result = fread (buf, 1, max_size, yyin);
	  if (*result < max_size && ferror (yyin))
	    einfo ("%F%P: read in flex scanner failed\n");
	}
    }
}

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

static void
comment (void)
{
  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 == '\n')
      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 (char *where, char *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 (*what))
    {
      sprintf (buf, "\\%03o", (unsigned int) *what);
      what = buf;
    }

  einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where);
}
Commit	Line	Data
	1	%{
	2
	3	/* Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
	4	2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
	5
	6	This file is part of GLD, the Gnu Linker.
	7
	8	GLD is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
	13	GLD is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with GLD; see the file COPYING. If not, write to the Free
	20	Software Foundation, 59 Temple Place - Suite 330, Boston, MA
	21	02111-1307, USA. */
	22
	23	/*
	24	This was written by steve chamberlain
	25	sac@cygnus.com
	26	*/
	27
	28
	29	#include <stdio.h>
	30
	31	#include "bfd.h"
	32	#include "sysdep.h"
	33	#include "safe-ctype.h"
	34	#include "bfdlink.h"
	35	#include "ld.h"
	36	#include "ldmisc.h"
	37	#include "ldexp.h"
	38	#include "ldlang.h"
	39	#include <ldgram.h>
	40	#include "ldfile.h"
	41	#include "ldlex.h"
	42	#include "ldmain.h"
	43	#include "libiberty.h"
	44
	45	/* The type of top-level parser input.
	46	yylex and yyparse (indirectly) both check this. */
	47	input_type parser_input;
	48
	49	/* Line number in the current input file.
	50	(FIXME Actually, it doesn't appear to get reset for each file?) */
	51	unsigned int lineno = 1;
	52
	53	/* The string we are currently lexing, or NULL if we are reading a
	54	file. */
	55	const char *lex_string = NULL;
	56
	57	/* Support for flex reading from more than one input file (stream).
	58	`include_stack' is flex's input state for each open file;
	59	`file_name_stack' is the file names. `lineno_stack' is the current
	60	line numbers.
	61
	62	If `include_stack_ptr' is 0, we haven't started reading anything yet.
	63	Otherwise, stack elements 0 through `include_stack_ptr - 1' are valid. */
	64
	65	#undef YY_INPUT
	66	#define YY_INPUT(buf,result,max_size) yy_input (buf, &result, max_size)
	67
	68	#define YY_NO_UNPUT
	69
	70	#define MAX_INCLUDE_DEPTH 10
	71	static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
	72	static const char *file_name_stack[MAX_INCLUDE_DEPTH];
	73	static unsigned int lineno_stack[MAX_INCLUDE_DEPTH];
	74	static unsigned int include_stack_ptr = 0;
	75	static int vers_node_nesting = 0;
	76
	77	static void yy_input (char , int , int);
	78	static void comment (void);
	79	static void lex_warn_invalid (char where, char what);
	80
	81	/* STATES
	82	EXPRESSION definitely in an expression
	83	SCRIPT definitely in a script
	84	BOTH either EXPRESSION or SCRIPT
	85	DEFSYMEXP in an argument to -defsym
	86	MRI in an MRI script
	87	VERS_START starting a Sun style mapfile
	88	VERS_SCRIPT a Sun style mapfile
	89	VERS_NODE a node within a Sun style mapfile
	90	*/
	91	#define RTOKEN(x) { yylval.token = x; return x; }
	92
	93	/* Some versions of flex want this. */
	94	#ifndef yywrap
	95	int yywrap (void) { return 1; }
	96	#endif
	97	%}
	98
	99	%a 4000
	100	%o 5000
	101
	102	CMDFILENAMECHAR [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
	103	CMDFILENAMECHAR1 [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
	104	FILENAMECHAR1 [_a-zA-Z\/\.\\\$\_\~]
	105	SYMBOLCHARN [_a-zA-Z\/\.\\\$\_\~0-9]
	106	FILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
	107	WILDCHAR [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~\?\*]
	108	WHITE [ \t\n\r]+
	109
	110	NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
	111
	112	V_TAG [.$_a-zA-Z][._a-zA-Z0-9]*
	113	V_IDENTIFIER [?.$_a-zA-Z\[\]\-\!\^\\]([?.$_a-zA-Z0-9\[\]\-\!\^\\]\|::)*
	114
	115	%s SCRIPT
	116	%s EXPRESSION
	117	%s BOTH
	118	%s DEFSYMEXP
	119	%s MRI
	120	%s VERS_START
	121	%s VERS_SCRIPT
	122	%s VERS_NODE
	123	%%
	124
	125	if (parser_input != input_selected)
	126	{
	127	/* The first token of the input determines the initial parser state. */
	128	input_type t = parser_input;
	129	parser_input = input_selected;
	130	switch (t)
	131	{
	132	case input_script: return INPUT_SCRIPT; break;
	133	case input_mri_script: return INPUT_MRI_SCRIPT; break;
	134	case input_version_script: return INPUT_VERSION_SCRIPT; break;
	135	case input_defsym: return INPUT_DEFSYM; break;
	136	default: abort ();
	137	}
	138	}
	139
	140	<BOTH,SCRIPT,EXPRESSION,VERS_START,VERS_NODE,VERS_SCRIPT>"/*" { comment (); }
	141
	142
	143	<DEFSYMEXP>"-" { RTOKEN('-');}
	144	<DEFSYMEXP>"+" { RTOKEN('+');}
	145	<DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}* { yylval.name = xstrdup (yytext); return NAME; }
	146	<DEFSYMEXP>"=" { RTOKEN('='); }
	147
	148	<MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
	149	yylval.integer = bfd_scan_vma (yytext + 1, 0, 16);
	150	yylval.bigint.str = NULL;
	151	return INT;
	152	}
	153
	154	<MRI,EXPRESSION>([0-9A-Fa-f])+(H\|h\|X\|x\|B\|b\|O\|o\|D\|d) {
	155	int ibase ;
	156	switch (yytext[yyleng - 1]) {
	157	case 'X':
	158	case 'x':
	159	case 'H':
	160	case 'h':
	161	ibase = 16;
	162	break;
	163	case 'O':
	164	case 'o':
	165	ibase = 8;
	166	break;
	167	case 'B':
	168	case 'b':
	169	ibase = 2;
	170	break;
	171	default:
	172	ibase = 10;
	173	}
	174	yylval.integer = bfd_scan_vma (yytext, 0,
	175	ibase);
	176	yylval.bigint.str = NULL;
	177	return INT;
	178	}
	179	<SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>((("$"\|0[xX])([0-9A-Fa-f])+)\|(([0-9])+))(M\|K\|m\|k)? {
	180	char *s = yytext;
	181	int ibase = 0;
	182
	183	if (*s == '$')
	184	{
	185	++s;
	186	ibase = 16;
	187	}
	188	yylval.integer = bfd_scan_vma (s, 0, ibase);
	189	yylval.bigint.str = NULL;
	190	if (yytext[yyleng - 1] == 'M'
	191	\|\| yytext[yyleng - 1] == 'm')
	192	{
	193	yylval.integer = 1024 1024;
	194	}
	195	else if (yytext[yyleng - 1] == 'K'
	196	\|\| yytext[yyleng - 1]=='k')
	197	{
	198	yylval.integer *= 1024;
	199	}
	200	else if (yytext[0] == '0'
	201	&& (yytext[1] == 'x'
	202	\|\| yytext[1] == 'X'))
	203	{
	204	yylval.bigint.str = xstrdup (yytext + 2);
	205	}
	206	return INT;
	207	}
	208	<BOTH,SCRIPT,EXPRESSION,MRI>"]" { RTOKEN(']');}
	209	<BOTH,SCRIPT,EXPRESSION,MRI>"[" { RTOKEN('[');}
	210	<BOTH,SCRIPT,EXPRESSION,MRI>"<<=" { RTOKEN(LSHIFTEQ);}
	211	<BOTH,SCRIPT,EXPRESSION,MRI>">>=" { RTOKEN(RSHIFTEQ);}
	212	<BOTH,SCRIPT,EXPRESSION,MRI>"\|\|" { RTOKEN(OROR);}
	213	<BOTH,SCRIPT,EXPRESSION,MRI>"==" { RTOKEN(EQ);}
	214	<BOTH,SCRIPT,EXPRESSION,MRI>"!=" { RTOKEN(NE);}
	215	<BOTH,SCRIPT,EXPRESSION,MRI>">=" { RTOKEN(GE);}
	216	<BOTH,SCRIPT,EXPRESSION,MRI>"<=" { RTOKEN(LE);}
	217	<BOTH,SCRIPT,EXPRESSION,MRI>"<<" { RTOKEN(LSHIFT);}
	218	<BOTH,SCRIPT,EXPRESSION,MRI>">>" { RTOKEN(RSHIFT);}
	219	<BOTH,SCRIPT,EXPRESSION,MRI>"+=" { RTOKEN(PLUSEQ);}
	220	<BOTH,SCRIPT,EXPRESSION,MRI>"-=" { RTOKEN(MINUSEQ);}
	221	<BOTH,SCRIPT,EXPRESSION,MRI>"*=" { RTOKEN(MULTEQ);}
	222	<BOTH,SCRIPT,EXPRESSION,MRI>"/=" { RTOKEN(DIVEQ);}
	223	<BOTH,SCRIPT,EXPRESSION,MRI>"&=" { RTOKEN(ANDEQ);}
	224	<BOTH,SCRIPT,EXPRESSION,MRI>"\|=" { RTOKEN(OREQ);}
	225	<BOTH,SCRIPT,EXPRESSION,MRI>"&&" { RTOKEN(ANDAND);}
	226	<BOTH,SCRIPT,EXPRESSION,MRI>">" { RTOKEN('>');}
	227	<BOTH,SCRIPT,EXPRESSION,MRI>"," { RTOKEN(',');}
	228	<BOTH,SCRIPT,EXPRESSION,MRI>"&" { RTOKEN('&');}
	229	<BOTH,SCRIPT,EXPRESSION,MRI>"\|" { RTOKEN('\|');}
	230	<BOTH,SCRIPT,EXPRESSION,MRI>"~" { RTOKEN('~');}
	231	<BOTH,SCRIPT,EXPRESSION,MRI>"!" { RTOKEN('!');}
	232	<BOTH,SCRIPT,EXPRESSION,MRI>"?" { RTOKEN('?');}
	233	<BOTH,SCRIPT,EXPRESSION,MRI>"" { RTOKEN('');}
	234	<BOTH,SCRIPT,EXPRESSION,MRI>"+" { RTOKEN('+');}
	235	<BOTH,SCRIPT,EXPRESSION,MRI>"-" { RTOKEN('-');}
	236	<BOTH,SCRIPT,EXPRESSION,MRI>"/" { RTOKEN('/');}
	237	<BOTH,SCRIPT,EXPRESSION,MRI>"%" { RTOKEN('%');}
	238	<BOTH,SCRIPT,EXPRESSION,MRI>"<" { RTOKEN('<');}
	239	<BOTH,SCRIPT,EXPRESSION,MRI>"=" { RTOKEN('=');}
	240	<BOTH,SCRIPT,EXPRESSION,MRI>"}" { RTOKEN('}') ; }
	241	<BOTH,SCRIPT,EXPRESSION,MRI>"{" { RTOKEN('{'); }
	242	<BOTH,SCRIPT,EXPRESSION,MRI>")" { RTOKEN(')');}
	243	<BOTH,SCRIPT,EXPRESSION,MRI>"(" { RTOKEN('(');}
	244	<BOTH,SCRIPT,EXPRESSION,MRI>":" { RTOKEN(':'); }
	245	<BOTH,SCRIPT,EXPRESSION,MRI>";" { RTOKEN(';');}
	246	<BOTH,SCRIPT>"MEMORY" { RTOKEN(MEMORY);}
	247	<BOTH,SCRIPT,EXPRESSION>"ORIGIN" { RTOKEN(ORIGIN);}
	248	<BOTH,SCRIPT>"VERSION" { RTOKEN(VERSIONK);}
	249	<EXPRESSION,BOTH,SCRIPT>"BLOCK" { RTOKEN(BLOCK);}
	250	<EXPRESSION,BOTH,SCRIPT>"BIND" { RTOKEN(BIND);}
	251	<BOTH,SCRIPT,EXPRESSION>"LENGTH" { RTOKEN(LENGTH);}
	252	<EXPRESSION,BOTH,SCRIPT>"ALIGN" { RTOKEN(ALIGN_K);}
	253	<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_ALIGN" { RTOKEN(DATA_SEGMENT_ALIGN);}
	254	<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_RELRO_END" { RTOKEN(DATA_SEGMENT_RELRO_END);}
	255	<EXPRESSION,BOTH,SCRIPT>"DATA_SEGMENT_END" { RTOKEN(DATA_SEGMENT_END);}
	256	<EXPRESSION,BOTH,SCRIPT>"ADDR" { RTOKEN(ADDR);}
	257	<EXPRESSION,BOTH,SCRIPT>"LOADADDR" { RTOKEN(LOADADDR);}
	258	<EXPRESSION,BOTH>"MAX" { RTOKEN(MAX_K); }
	259	<EXPRESSION,BOTH>"MIN" { RTOKEN(MIN_K); }
	260	<EXPRESSION,BOTH>"ASSERT" { RTOKEN(ASSERT_K); }
	261	<BOTH,SCRIPT>"ENTRY" { RTOKEN(ENTRY);}
	262	<BOTH,SCRIPT,MRI>"EXTERN" { RTOKEN(EXTERN);}
	263	<EXPRESSION,BOTH,SCRIPT>"NEXT" { RTOKEN(NEXT);}
	264	<EXPRESSION,BOTH,SCRIPT>"sizeof_headers" { RTOKEN(SIZEOF_HEADERS);}
	265	<EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS" { RTOKEN(SIZEOF_HEADERS);}
	266	<EXPRESSION,BOTH,SCRIPT>"SEGMENT_START" { RTOKEN(SEGMENT_START);}
	267	<BOTH,SCRIPT>"MAP" { RTOKEN(MAP);}
	268	<EXPRESSION,BOTH,SCRIPT>"SIZEOF" { RTOKEN(SIZEOF);}
	269	<BOTH,SCRIPT>"TARGET" { RTOKEN(TARGET_K);}
	270	<BOTH,SCRIPT>"SEARCH_DIR" { RTOKEN(SEARCH_DIR);}
	271	<BOTH,SCRIPT>"OUTPUT" { RTOKEN(OUTPUT);}
	272	<BOTH,SCRIPT>"INPUT" { RTOKEN(INPUT);}
	273	<EXPRESSION,BOTH,SCRIPT>"GROUP" { RTOKEN(GROUP);}
	274	<EXPRESSION,BOTH,SCRIPT>"AS_NEEDED" { RTOKEN(AS_NEEDED);}
	275	<EXPRESSION,BOTH,SCRIPT>"DEFINED" { RTOKEN(DEFINED);}
	276	<BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS" { RTOKEN(CREATE_OBJECT_SYMBOLS);}
	277	<BOTH,SCRIPT>"CONSTRUCTORS" { RTOKEN( CONSTRUCTORS);}
	278	<BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
	279	<BOTH,SCRIPT>"INHIBIT_COMMON_ALLOCATION" { RTOKEN(INHIBIT_COMMON_ALLOCATION);}
	280	<BOTH,SCRIPT>"SECTIONS" { RTOKEN(SECTIONS);}
	281	<BOTH,SCRIPT>"FILL" { RTOKEN(FILL);}
	282	<BOTH,SCRIPT>"STARTUP" { RTOKEN(STARTUP);}
	283	<BOTH,SCRIPT>"OUTPUT_FORMAT" { RTOKEN(OUTPUT_FORMAT);}
	284	<BOTH,SCRIPT>"OUTPUT_ARCH" { RTOKEN( OUTPUT_ARCH);}
	285	<BOTH,SCRIPT>"HLL" { RTOKEN(HLL);}
	286	<BOTH,SCRIPT>"SYSLIB" { RTOKEN(SYSLIB);}
	287	<BOTH,SCRIPT>"FLOAT" { RTOKEN(FLOAT);}
	288	<BOTH,SCRIPT>"QUAD" { RTOKEN( QUAD);}
	289	<BOTH,SCRIPT>"SQUAD" { RTOKEN( SQUAD);}
	290	<BOTH,SCRIPT>"LONG" { RTOKEN( LONG);}
	291	<BOTH,SCRIPT>"SHORT" { RTOKEN( SHORT);}
	292	<BOTH,SCRIPT>"BYTE" { RTOKEN( BYTE);}
	293	<BOTH,SCRIPT>"NOFLOAT" { RTOKEN(NOFLOAT);}
	294	<EXPRESSION,BOTH,SCRIPT>"NOCROSSREFS" { RTOKEN(NOCROSSREFS);}
	295	<BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY); }
	296	<BOTH,SCRIPT>"SORT_BY_NAME" { RTOKEN(SORT_BY_NAME); }
	297	<BOTH,SCRIPT>"SORT_BY_ALIGNMENT" { RTOKEN(SORT_BY_ALIGNMENT); }
	298	<BOTH,SCRIPT>"SORT" { RTOKEN(SORT_BY_NAME); }
	299	<EXPRESSION,BOTH,SCRIPT>"NOLOAD" { RTOKEN(NOLOAD);}
	300	<EXPRESSION,BOTH,SCRIPT>"DSECT" { RTOKEN(DSECT);}
	301	<EXPRESSION,BOTH,SCRIPT>"COPY" { RTOKEN(COPY);}
	302	<EXPRESSION,BOTH,SCRIPT>"INFO" { RTOKEN(INFO);}
	303	<EXPRESSION,BOTH,SCRIPT>"OVERLAY" { RTOKEN(OVERLAY);}
	304	<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RO" { RTOKEN(ONLY_IF_RO); }
	305	<EXPRESSION,BOTH,SCRIPT>"ONLY_IF_RW" { RTOKEN(ONLY_IF_RW); }
	306	<BOTH,SCRIPT>"o" { RTOKEN(ORIGIN);}
	307	<BOTH,SCRIPT>"org" { RTOKEN(ORIGIN);}
	308	<BOTH,SCRIPT>"l" { RTOKEN( LENGTH);}
	309	<BOTH,SCRIPT>"len" { RTOKEN( LENGTH);}
	310	<BOTH,SCRIPT>"INCLUDE" { RTOKEN(INCLUDE);}
	311	<BOTH,SCRIPT>"PHDRS" { RTOKEN (PHDRS); }
	312	<EXPRESSION,BOTH,SCRIPT>"AT" { RTOKEN(AT);}
	313	<EXPRESSION,BOTH,SCRIPT>"SUBALIGN" { RTOKEN(SUBALIGN);}
	314	<EXPRESSION,BOTH,SCRIPT>"PROVIDE" { RTOKEN(PROVIDE); }
	315	<EXPRESSION,BOTH,SCRIPT>"KEEP" { RTOKEN(KEEP); }
	316	<EXPRESSION,BOTH,SCRIPT>"EXCLUDE_FILE" { RTOKEN(EXCLUDE_FILE); }
	317	<MRI>"#".*\n? { ++ lineno; }
	318	<MRI>"\n" { ++ lineno; RTOKEN(NEWLINE); }
	319	<MRI>"". { /* Mri comment line */ }
	320	<MRI>";".* { /* Mri comment line */ }
	321	<MRI>"END" { RTOKEN(ENDWORD); }
	322	<MRI>"ALIGNMOD" { RTOKEN(ALIGNMOD);}
	323	<MRI>"ALIGN" { RTOKEN(ALIGN_K);}
	324	<MRI>"CHIP" { RTOKEN(CHIP); }
	325	<MRI>"BASE" { RTOKEN(BASE); }
	326	<MRI>"ALIAS" { RTOKEN(ALIAS); }
	327	<MRI>"TRUNCATE" { RTOKEN(TRUNCATE); }
	328	<MRI>"LOAD" { RTOKEN(LOAD); }
	329	<MRI>"PUBLIC" { RTOKEN(PUBLIC); }
	330	<MRI>"ORDER" { RTOKEN(ORDER); }
	331	<MRI>"NAME" { RTOKEN(NAMEWORD); }
	332	<MRI>"FORMAT" { RTOKEN(FORMAT); }
	333	<MRI>"CASE" { RTOKEN(CASE); }
	334	<MRI>"START" { RTOKEN(START); }
	335	<MRI>"LIST".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	336	<MRI>"SECT" { RTOKEN(SECT); }
	337	<EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE" { RTOKEN(ABSOLUTE); }
	338	<MRI>"end" { RTOKEN(ENDWORD); }
	339	<MRI>"alignmod" { RTOKEN(ALIGNMOD);}
	340	<MRI>"align" { RTOKEN(ALIGN_K);}
	341	<MRI>"chip" { RTOKEN(CHIP); }
	342	<MRI>"base" { RTOKEN(BASE); }
	343	<MRI>"alias" { RTOKEN(ALIAS); }
	344	<MRI>"truncate" { RTOKEN(TRUNCATE); }
	345	<MRI>"load" { RTOKEN(LOAD); }
	346	<MRI>"public" { RTOKEN(PUBLIC); }
	347	<MRI>"order" { RTOKEN(ORDER); }
	348	<MRI>"name" { RTOKEN(NAMEWORD); }
	349	<MRI>"format" { RTOKEN(FORMAT); }
	350	<MRI>"case" { RTOKEN(CASE); }
	351	<MRI>"extern" { RTOKEN(EXTERN); }
	352	<MRI>"start" { RTOKEN(START); }
	353	<MRI>"list".* { RTOKEN(LIST); /* LIST and ignore to end of line */ }
	354	<MRI>"sect" { RTOKEN(SECT); }
	355	<EXPRESSION,BOTH,SCRIPT,MRI>"absolute" { RTOKEN(ABSOLUTE); }
	356
	357	<MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
	358	/* Filename without commas, needed to parse mri stuff */
	359	yylval.name = xstrdup (yytext);
	360	return NAME;
	361	}
	362
	363
	364	<BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}* {
	365	yylval.name = xstrdup (yytext);
	366	return NAME;
	367	}
	368	<BOTH,EXPRESSION>"-l"{FILENAMECHAR}+ {
	369	yylval.name = xstrdup (yytext + 2);
	370	return LNAME;
	371	}
	372	<SCRIPT>{WILDCHAR}* {
	373	/* Annoyingly, this pattern can match comments, and we have
	374	longest match issues to consider. So if the first two
	375	characters are a comment opening, put the input back and
	376	try again. */
	377	if (yytext[0] == '/' && yytext[1] == '*')
	378	{
	379	yyless (2);
	380	comment ();
	381	}
	382	else
	383	{
	384	yylval.name = xstrdup (yytext);
	385	return NAME;
	386	}
	387	}
	388
	389	<EXPRESSION,BOTH,SCRIPT,VERS_NODE>"\""[^\"]*"\"" {
	390	/* No matter the state, quotes
	391	give what's inside */
	392	yylval.name = xstrdup (yytext + 1);
	393	yylval.name[yyleng - 2] = 0;
	394	return NAME;
	395	}
	396	<BOTH,SCRIPT,EXPRESSION>"\n" { lineno++;}
	397	<MRI,BOTH,SCRIPT,EXPRESSION>[ \t\r]+ { }
	398
	399	<VERS_NODE,VERS_SCRIPT>[:,;] { return *yytext; }
	400
	401	<VERS_NODE>global { RTOKEN(GLOBAL); }
	402
	403	<VERS_NODE>local { RTOKEN(LOCAL); }
	404
	405	<VERS_NODE>extern { RTOKEN(EXTERN); }
	406
	407	<VERS_NODE>{V_IDENTIFIER} { yylval.name = xstrdup (yytext);
	408	return VERS_IDENTIFIER; }
	409
	410	<VERS_SCRIPT>{V_TAG} { yylval.name = xstrdup (yytext);
	411	return VERS_TAG; }
	412
	413	<VERS_START>"{" { BEGIN(VERS_SCRIPT); return *yytext; }
	414
	415	<VERS_SCRIPT>"{" { BEGIN(VERS_NODE);
	416	vers_node_nesting = 0;
	417	return *yytext;
	418	}
	419	<VERS_SCRIPT>"}" { return *yytext; }
	420	<VERS_NODE>"{" { vers_node_nesting++; return *yytext; }
	421	<VERS_NODE>"}" { if (--vers_node_nesting < 0)
	422	BEGIN(VERS_SCRIPT);
	423	return *yytext;
	424	}
	425
	426	<VERS_START,VERS_NODE,VERS_SCRIPT>[\n] { lineno++; }
	427
	428	<VERS_START,VERS_NODE,VERS_SCRIPT>#.* { /* Eat up comments */ }
	429
	430	<VERS_START,VERS_NODE,VERS_SCRIPT>[ \t\r]+ { /* Eat up whitespace */ }
	431
	432	<<EOF>> {
	433	include_stack_ptr--;
	434
	435	if (include_stack_ptr == 0)
	436	{
	437	yyterminate ();
	438	}
	439	else
	440	{
	441	yy_switch_to_buffer (include_stack[include_stack_ptr]);
	442	}
	443
	444	ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
	445	lineno = lineno_stack[include_stack_ptr];
	446
	447	return END;
	448	}
	449
	450	<SCRIPT,MRI,VERS_START,VERS_SCRIPT,VERS_NODE>. lex_warn_invalid (" in script", yytext);
	451	<EXPRESSION,DEFSYMEXP,BOTH>. lex_warn_invalid (" in expression", yytext);
	452
	453	%%
	454	\f
	455
	456	/* Switch flex to reading script file NAME, open on FILE,
	457	saving the current input info on the include stack. */
	458
	459	void
	460	lex_push_file (FILE file, const char name)
	461	{
	462	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	463	{
	464	einfo ("%F:includes nested too deeply\n");
	465	}
	466	file_name_stack[include_stack_ptr] = name;
	467	lineno_stack[include_stack_ptr] = lineno;
	468	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	469
	470	include_stack_ptr++;
	471	lineno = 1;
	472	yyin = file;
	473	yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE));
	474	}
	475
	476	/* Return a newly created flex input buffer containing STRING,
	477	which is SIZE bytes long. */
	478
	479	static YY_BUFFER_STATE
	480	yy_create_string_buffer (const char *string, size_t size)
	481	{
	482	YY_BUFFER_STATE b;
	483
	484	/* Calls to m-alloc get turned by sed into xm-alloc. */
	485	b = malloc (sizeof (struct yy_buffer_state));
	486	b->yy_input_file = 0;
	487	b->yy_buf_size = size;
	488
	489	/* yy_ch_buf has to be 2 characters longer than the size given because
	490	we need to put in 2 end-of-buffer characters. */
	491	b->yy_ch_buf = malloc ((unsigned) (b->yy_buf_size + 3));
	492
	493	b->yy_ch_buf[0] = '\n';
	494	strcpy (b->yy_ch_buf+1, string);
	495	b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
	496	b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
	497	b->yy_n_chars = size+1;
	498	b->yy_buf_pos = &b->yy_ch_buf[1];
	499
	500	b->yy_is_our_buffer = 1;
	501	b->yy_is_interactive = 0;
	502	b->yy_at_bol = 1;
	503	b->yy_fill_buffer = 0;
	504
	505	/* flex 2.4.7 changed the interface. FIXME: We should not be using
	506	a flex internal interface in the first place! */
	507	#ifdef YY_BUFFER_NEW
	508	b->yy_buffer_status = YY_BUFFER_NEW;
	509	#else
	510	b->yy_eof_status = EOF_NOT_SEEN;
	511	#endif
	512
	513	return b;
	514	}
	515
	516	/* Switch flex to reading from STRING, saving the current input info
	517	on the include stack. */
	518
	519	void
	520	lex_redirect (const char *string)
	521	{
	522	YY_BUFFER_STATE tmp;
	523
	524	yy_init = 0;
	525	if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
	526	{
	527	einfo("%F: macros nested too deeply\n");
	528	}
	529	file_name_stack[include_stack_ptr] = "redirect";
	530	lineno_stack[include_stack_ptr] = lineno;
	531	include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
	532	include_stack_ptr++;
	533	lineno = 1;
	534	tmp = yy_create_string_buffer (string, strlen (string));
	535	yy_switch_to_buffer (tmp);
	536	}
	537	\f
	538	/* Functions to switch to a different flex start condition,
	539	saving the current start condition on `state_stack'. */
	540
	541	static int state_stack[MAX_INCLUDE_DEPTH * 2];
	542	static int *state_stack_p = state_stack;
	543
	544	void
	545	ldlex_script (void)
	546	{
	547	*(state_stack_p)++ = yy_start;
	548	BEGIN (SCRIPT);
	549	}
	550
	551	void
	552	ldlex_mri_script (void)
	553	{
	554	*(state_stack_p)++ = yy_start;
	555	BEGIN (MRI);
	556	}
	557
	558	void
	559	ldlex_version_script (void)
	560	{
	561	*(state_stack_p)++ = yy_start;
	562	BEGIN (VERS_START);
	563	}
	564
	565	void
	566	ldlex_version_file (void)
	567	{
	568	*(state_stack_p)++ = yy_start;
	569	BEGIN (VERS_SCRIPT);
	570	}
	571
	572	void
	573	ldlex_defsym (void)
	574	{
	575	*(state_stack_p)++ = yy_start;
	576	BEGIN (DEFSYMEXP);
	577	}
	578
	579	void
	580	ldlex_expression (void)
	581	{
	582	*(state_stack_p)++ = yy_start;
	583	BEGIN (EXPRESSION);
	584	}
	585
	586	void
	587	ldlex_both (void)
	588	{
	589	*(state_stack_p)++ = yy_start;
	590	BEGIN (BOTH);
	591	}
	592
	593	void
	594	ldlex_popstate (void)
	595	{
	596	yy_start = *(--state_stack_p);
	597	}
	598	\f
	599
	600	/* Place up to MAX_SIZE characters in BUF and return in *RESULT
	601	either the number of characters read, or 0 to indicate EOF. */
	602
	603	static void
	604	yy_input (char buf, int result, int max_size)
	605	{
	606	*result = 0;
	607	if (YY_CURRENT_BUFFER->yy_input_file)
	608	{
	609	if (yyin)
	610	{
	611	*result = fread (buf, 1, max_size, yyin);
	612	if (*result < max_size && ferror (yyin))
	613	einfo ("%F%P: read in flex scanner failed\n");
	614	}
	615	}
	616	}
	617
	618	/* Eat the rest of a C-style comment. */
	619
	620	static void
	621	comment (void)
	622	{
	623	int c;
	624
	625	while (1)
	626	{
	627	c = input();
	628	while (c != '*' && c != EOF)
	629	{
	630	if (c == '\n')
	631	lineno++;
	632	c = input();
	633	}
	634
	635	if (c == '*')
	636	{
	637	c = input();
	638	while (c == '*')
	639	c = input();
	640	if (c == '/')
	641	break; /* found the end */
	642	}
	643
	644	if (c == '\n')
	645	lineno++;
	646
	647	if (c == EOF)
	648	{
	649	einfo( "%F%P: EOF in comment\n");
	650	break;
	651	}
	652	}
	653	}
	654
	655	/* Warn the user about a garbage character WHAT in the input
	656	in context WHERE. */
	657
	658	static void
	659	lex_warn_invalid (char where, char what)
	660	{
	661	char buf[5];
	662
	663	/* If we have found an input file whose format we do not recognize,
	664	and we are therefore treating it as a linker script, and we find
	665	an invalid character, then most likely this is a real object file
	666	of some different format. Treat it as such. */
	667	if (ldfile_assumed_script)
	668	{
	669	bfd_set_error (bfd_error_file_not_recognized);
	670	einfo ("%F%s: file not recognized: %E\n", ldfile_input_filename);
	671	}
	672
	673	if (! ISPRINT (*what))
	674	{
	675	sprintf (buf, "\\%03o", (unsigned int) *what);
	676	what = buf;
	677	}
	678
	679	einfo ("%P:%S: ignoring invalid character `%s'%s\n", what, where);
	680	}