x

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

diff --git a/ld/ldlex.l b/ld/ldlex.l
index 7955ac70831afd9ce07aed3b5f2332e0f7d398f1..e8214942f70baa48aa2611a8214800bf0c31116a 100644 (file)
--- a/ld/ldlex.l
+++ b/ld/ldlex.l
@@ -1,6 +1,6 @@
 %{
 
 %{
 

-/* Copyright (C) 1991, 1993 Free Software Foundation, Inc.
+/* Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.

 
 This file is part of GLD, the Gnu Linker.
 
 
 This file is part of GLD, the Gnu Linker.
 


@@ -16,7 +16,7 @@ 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
 
 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.  */
+the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

 
 /*
 This was written by steve chamberlain
 
 /*
 This was written by steve chamberlain


@@ -26,12 +26,13 @@ This was written by steve chamberlain
 
 #include <ansidecl.h>
 #include <stdio.h>
 
 #include <ansidecl.h>
 #include <stdio.h>

-/* start-sanitize-mpw */
+#include <ctype.h>
+

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


@@ -41,37 +42,63 @@ This was written by steve chamberlain
 #include "ldlang.h"
 #include "ldfile.h"
 #include "ldlex.h"
 #include "ldlang.h"
 #include "ldfile.h"
 #include "ldlex.h"

+#include "ldmain.h"

 
 

-int ldgram_in_defsym;
+/* 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;
 
 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;
 unsigned int lineno = 1;

-int old;
+
+/* 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)
 
 #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
 #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 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,
 
 static YY_BUFFER_STATE yy_create_string_buffer PARAMS ((const char *string,

-                                                       int size));
+                                                       size_t size));

 static void yy_input PARAMS ((char *, int *result, int max_size));
 static void yy_input PARAMS ((char *, int *result, int max_size));

+

 static void comment PARAMS ((void));
 static void comment PARAMS ((void));

+static void lex_warn_invalid PARAMS ((char *where, char *what));

 
 /* STATES 
 
 /* STATES 

-       COMMAND         on command line
-       COMMENT         in a C comment
-       EXPRESSION      definiatelyt in an expression
-       SCRIPT          definately in a script
-       SOMEWHERE       either EXPRESSION or SCRIPT
+       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
         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; }
 */
 #define RTOKEN(x)  {  yylval.token = x; return x; }

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

 %}
 
 %a 4000
 %}
 
 %a 4000


@@ -80,189 +107,75 @@ static void comment PARAMS ((void));
 CMDFILENAMECHAR   [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
 CMDFILENAMECHAR1  [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
 FILENAMECHAR1  [_a-zA-Z\/\.\\\$\_\~]
 CMDFILENAMECHAR   [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
 CMDFILENAMECHAR1  [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
 FILENAMECHAR1  [_a-zA-Z\/\.\\\$\_\~]

-SYMBOLCHARN     [_a-zA-Z\/\.\\0-9]
+SYMBOLCHARN     [_a-zA-Z\/\.\\\$\_\~0-9]

 FILENAMECHAR   [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
 FILENAMECHAR   [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]

-FILENAME       {FILENAMECHAR}+
-WHITE          [ \t\n]+ 
+WILDCHAR       [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~\?\*]
+WHITE          [ \t\n\r]+ 

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

+V_TAG [.$_a-zA-Z][._a-zA-Z0-9]*
+V_IDENTIFIER [*?$_a-zA-Z][*?_a-zA-Z0-9]*

 
 

-%s COMMAND

 %s SCRIPT
 %s EXPRESSION
 %s SCRIPT
 %s EXPRESSION

-%s COMMENT

 %s BOTH
 %s DEFSYMEXP
 %s MRI
 %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,COMMAND>"/*"   { comment(); }
+<BOTH,SCRIPT,EXPRESSION>"/*"   { comment(); }

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

-<DEFSYMEXP>[ \t]                { RTOKEN(DEFSYMEND); }

 <DEFSYMEXP>"="                  { RTOKEN('='); }
 <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])+ {
                                yylval.integer = bfd_scan_vma (yytext+1, 0,16);
                                return INT;
                        }
 

-<MRI,EXPRESSION>([0-9A-Fa-f])+(H|X|B|O|D) {
+<MRI,EXPRESSION>([0-9A-Fa-f])+(H|h|X|x|B|b|O|o|D|d) {

                                   int ibase ;
                                   switch (yytext[yyleng-1]) {
                                    case 'X': 
                                   int ibase ;
                                   switch (yytext[yyleng-1]) {
                                    case 'X': 

+                                   case 'x':

                                    case 'H':
                                    case 'H':

+                                   case 'h':

                                     ibase = 16;
                                     break;
                                    case 'O':
                                     ibase = 16;
                                     break;
                                    case 'O':

+                                   case 'o':

                                     ibase = 8;
                                     break;
                                    case 'B':
                                     ibase = 8;
                                     break;
                                    case 'B':

+                                   case 'b':

                                     ibase = 2;
                                     break;
                                    default:
                                     ibase = 10;
                                   }
                                     ibase = 2;
                                     break;
                                    default:
                                     ibase = 10;
                                   }

-                                  yylval.integer = bfd_scan_vma (yytext+1, 0,
+                                  yylval.integer = bfd_scan_vma (yytext, 0,

                                                                  ibase);
                                   return INT;
                                 }
                                                                  ibase);
                                   return INT;
                                 }


@@ -279,55 +192,55 @@ NOCFILENAMECHAR   [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
                                    }           
                                  return INT;
                                }
                                    }           
                                  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,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);}
 <BOTH,SCRIPT>"MEMORY"          { RTOKEN(MEMORY);}
 <BOTH,SCRIPT>"ORIGIN"          { RTOKEN(ORIGIN);}

-<BOTH,SCRIPT>"BLOCK"                   { RTOKEN(BLOCK);}
+<BOTH,SCRIPT>"VERSION"         { RTOKEN(VERSION);}
+<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);}
 <BOTH,SCRIPT>"LENGTH"          { RTOKEN(LENGTH);}
 <EXPRESSION,BOTH,SCRIPT>"ALIGN"                        { RTOKEN(ALIGN_K);}
 <EXPRESSION,BOTH,SCRIPT>"ADDR"                 { RTOKEN(ADDR);}

+<EXPRESSION,BOTH,SCRIPT>"LOADADDR"             { RTOKEN(LOADADDR);}
+<EXPRESSION,BOTH>"MAX"                 { RTOKEN(MAX); }
+<EXPRESSION,BOTH>"MIN"                 { RTOKEN(MIN); }

 <BOTH,SCRIPT>"ENTRY"                   { RTOKEN(ENTRY);}
 <EXPRESSION,BOTH,SCRIPT>"NEXT"                 { RTOKEN(NEXT);}
 <EXPRESSION,BOTH,SCRIPT>"sizeof_headers"       { RTOKEN(SIZEOF_HEADERS);}
 <BOTH,SCRIPT>"ENTRY"                   { RTOKEN(ENTRY);}
 <EXPRESSION,BOTH,SCRIPT>"NEXT"                 { RTOKEN(NEXT);}
 <EXPRESSION,BOTH,SCRIPT>"sizeof_headers"       { RTOKEN(SIZEOF_HEADERS);}


@@ -338,6 +251,7 @@ NOCFILENAMECHAR     [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
 <BOTH,SCRIPT>"SEARCH_DIR"              { RTOKEN(SEARCH_DIR);}
 <BOTH,SCRIPT>"OUTPUT"          { RTOKEN(OUTPUT);}
 <BOTH,SCRIPT>"INPUT"                   { RTOKEN(INPUT);}
 <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);}
 <EXPRESSION,BOTH,SCRIPT>"DEFINED"              { RTOKEN(DEFINED);}
 <BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS"   { RTOKEN(CREATE_OBJECT_SYMBOLS);}
 <BOTH,SCRIPT>"CONSTRUCTORS"            { RTOKEN( CONSTRUCTORS);}


@@ -351,27 +265,34 @@ NOCFILENAMECHAR   [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
 <BOTH,SCRIPT>"SYSLIB"          { RTOKEN(SYSLIB);}
 <BOTH,SCRIPT>"FLOAT"                   { RTOKEN(FLOAT);}
 <BOTH,SCRIPT>"QUAD"                    { RTOKEN( QUAD);}
 <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);}
 <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);}
+<EXPRESSION,BOTH,SCRIPT>"NOCROSSREFS"  { RTOKEN(NOCROSSREFS);}
+<BOTH,SCRIPT>"OVERLAY"                 { RTOKEN(OVERLAY); }
+<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>"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>"AT"                   { RTOKEN(AT);}

+<EXPRESSION,BOTH,SCRIPT>"PROVIDE"              { RTOKEN(PROVIDE); }
+<MRI>"#".*\n?\r?               { ++ lineno; }

 <MRI>"\n"                      { ++ lineno;  RTOKEN(NEWLINE); }
 <MRI>"\n"                      { ++ lineno;  RTOKEN(NEWLINE); }

+<MRI>"\r"                      { ++ lineno;  RTOKEN(NEWLINE); }

 <MRI>"*".*                     { /* Mri comment line */ }
 <MRI>"*".*                     { /* Mri comment line */ }

+<MRI>";".*                     { /* Mri comment line */ }

 <MRI>"END"                      { RTOKEN(ENDWORD); }
 <MRI>"ALIGNMOD"                { RTOKEN(ALIGNMOD);}
 <MRI>"ALIGN"           { RTOKEN(ALIGN_K);}
 <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>"CHIP"                     { RTOKEN(CHIP); }
 <MRI>"BASE"                     { RTOKEN(BASE); }
 <MRI>"ALIAS"                     { RTOKEN(ALIAS); }


@@ -381,25 +302,31 @@ NOCFILENAMECHAR   [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
 <MRI>"ORDER"                    { RTOKEN(ORDER); }
 <MRI>"NAME"                     { RTOKEN(NAMEWORD); }
 <MRI>"FORMAT"                   { RTOKEN(FORMAT); }
 <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>"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>"chip"                     { RTOKEN(CHIP); }

+<MRI>"base"                     { RTOKEN(BASE); }
+<MRI>"alias"                     { RTOKEN(ALIAS); }
+<MRI>"truncate"                     { RTOKEN(TRUNCATE); }

 <MRI>"load"                     { RTOKEN(LOAD); }
 <MRI>"load"                     { RTOKEN(LOAD); }

+<MRI>"public"                   { RTOKEN(PUBLIC); }

 <MRI>"order"                    { RTOKEN(ORDER); }
 <MRI>"name"                     { RTOKEN(NAMEWORD); }
 <MRI>"format"                   { RTOKEN(FORMAT); }
 <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>"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); 
 <MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
 /* Filename without commas, needed to parse mri stuff */
                                 yylval.name = buystring(yytext); 


@@ -411,11 +338,13 @@ NOCFILENAMECHAR   [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
                                 yylval.name = buystring(yytext); 
                                  return NAME;
                                }
                                 yylval.name = buystring(yytext); 
                                  return NAME;
                                }

-<SCRIPT,COMMAND>{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,COMMAND,SCRIPT>"\""[^\"]*"\"" {
+<EXPRESSION,BOTH,SCRIPT>"\""[^\"]*"\"" {

                                        /* No matter the state, quotes
                                           give what's inside */
                                        yylval.name = buystring(yytext+1);
                                        /* No matter the state, quotes
                                           give what's inside */
                                        yylval.name = buystring(yytext+1);


@@ -423,7 +352,31 @@ NOCFILENAMECHAR    [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
                                        return NAME;
                                }
 <BOTH,SCRIPT,EXPRESSION>"\n"           { lineno++;}
                                        return NAME;
                                }
 <BOTH,SCRIPT,EXPRESSION>"\n"           { lineno++;}

-<MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
+<BOTH,SCRIPT,EXPRESSION>"\r"           { lineno++;}
+<MRI,BOTH,SCRIPT,EXPRESSION>[ \t]
+
+<VERS_NODE,VERS_SCRIPT>[:,;]   { return *yytext; }
+
+<VERS_NODE>global              { RTOKEN(GLOBAL); }
+
+<VERS_NODE>local               { RTOKEN(LOCAL); }
+
+<VERS_NODE>{V_IDENTIFIER}      { yylval.name = buystring (yytext);
+                                 return VERS_IDENTIFIER; }
+
+<VERS_SCRIPT>{V_TAG}           { yylval.name = buystring (yytext);
+                                 return VERS_TAG; }
+
+<VERS_START>"{"                        { BEGIN(VERS_SCRIPT); return *yytext; }
+
+<VERS_SCRIPT>"{"               { BEGIN(VERS_NODE); return *yytext; }
+<VERS_SCRIPT,VERS_NODE>"}"     { BEGIN(VERS_SCRIPT); return *yytext; }
+
+<VERS_START,VERS_NODE,VERS_SCRIPT>[\n\r]       { lineno++; }
+
+<VERS_START,VERS_NODE,VERS_SCRIPT>#.*          { /* Eat up comments */ }
+
+<VERS_START,VERS_NODE,VERS_SCRIPT>[ \t]+       { /* Eat up whitespace */ }

 
 <<EOF>> {
   include_stack_ptr--;
 
 <<EOF>> {
   include_stack_ptr--;


@@ -437,144 +390,154 @@ NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
     yy_switch_to_buffer(include_stack[include_stack_ptr]);
 
   }
     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];
-  }
+  BEGIN(SCRIPT);
+  ldfile_input_filename = file_name_stack[include_stack_ptr - 1];
+  lineno = lineno_stack[include_stack_ptr - 1];

 
   return END;
 }
 
   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, name)
      FILE *file;
 
 void
 lex_push_file (file, name)
      FILE *file;

-     char *name;
+     const char *name;

 {
   if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
 {
   if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 

-  {
-    einfo("%F:includes nested too deeply\n");
-  }
+    {
+      einfo("%F:includes nested too deeply\n");
+    }

   file_name_stack[include_stack_ptr] = name;
   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));
   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);
+  BEGIN (SCRIPT);

 }
 
 }
 

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

 static YY_BUFFER_STATE 
 static YY_BUFFER_STATE 

-yy_create_string_buffer (string,  size)
+yy_create_string_buffer (string, size)

      CONST char *string;
      CONST char *string;

-     int size;
+     size_t size;

 {
   YY_BUFFER_STATE b;
 
 {
   YY_BUFFER_STATE b;
 

-  b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
+  /* 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_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
   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()" );
-
+     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';
 
   b->yy_ch_buf[0] = '\n';

-  strcpy(b->yy_ch_buf+1,  string);
+  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_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_n_chars = size+1;

   b->yy_buf_pos = &b->yy_ch_buf[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;
   b->yy_eof_status = EOF_NOT_SEEN;

+#endif

 
 

-  return ( b );
+  return b;

 }
 
 }
 

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

 
 void
 lex_redirect (string)
 
 void
 lex_redirect (string)

-     CONST  char *string;
+     CONST char *string;

 {
   YY_BUFFER_STATE tmp;
 
 {
   YY_BUFFER_STATE tmp;
 

-  int len = strlen(string);
-  yy_init = 0  ;  
+  yy_init = 0;

   if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
   if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 

-  {
-    einfo("%F: macros nested too deeply\n");
-  }
+    {
+      einfo("%F: macros nested too deeply\n");
+    }

   file_name_stack[include_stack_ptr] = "redirect";
   file_name_stack[include_stack_ptr] = "redirect";

+  lineno_stack[include_stack_ptr] = 0;

   include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
   include_stack_ptr++;
   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;
+  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'.  */

 
 

-int state_stack[20];
-int *state_stack_p = 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;
 
 void
 ldlex_script ()
 {
   *(state_stack_p)++ = yy_start;

-
-  BEGIN(SCRIPT);
+  BEGIN (SCRIPT);

 }
 
 }
 

-

 void
 ldlex_mri_script ()
 {
   *(state_stack_p)++ = yy_start;
 void
 ldlex_mri_script ()
 {
   *(state_stack_p)++ = yy_start;

-  BEGIN(MRI);
+  BEGIN (MRI);

 }
 
 void
 }
 
 void

-ldlex_defsym ()
+ldlex_version_script ()

 {
   *(state_stack_p)++ = yy_start;
 {
   *(state_stack_p)++ = yy_start;

-  BEGIN(DEFSYMEXP);
+  BEGIN (VERS_START);

 }
 }

-          
+

 void
 void

-ldlex_expression ()
+ldlex_version_file ()

 {
   *(state_stack_p)++ = yy_start;
 {
   *(state_stack_p)++ = yy_start;

-  BEGIN(EXPRESSION);
+  BEGIN (VERS_SCRIPT);
+}

 
 

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

 }
 }

+          

 void
 void

-ldlex_both ()
+ldlex_expression ()

 {
   *(state_stack_p)++ = yy_start;
 {
   *(state_stack_p)++ = yy_start;

-  BEGIN(BOTH);
+  BEGIN (EXPRESSION);

 }
 }

+

 void
 void

-ldlex_command ()
+ldlex_both ()

 {
   *(state_stack_p)++ = yy_start;
 {
   *(state_stack_p)++ = yy_start;

-  BEGIN(COMMAND);
+  BEGIN (BOTH);

 }
 
 void
 }
 
 void


@@ -582,49 +545,90 @@ ldlex_popstate ()
 {
   yy_start = *(--state_stack_p);
 }
 {
   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
 
 static void

-yy_input(buf, result, max_size)
-char *buf;
-int *result;
-int max_size;
+yy_input (buf, result, max_size)
+     char *buf;
+     int *result;
+     int max_size;

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

 }
 
 }
 

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

 static void
 comment ()
 {
   int c;
 static void
 comment ()
 {
   int c;

+

   while (1)
   {
     c = input();
   while (1)
   {
     c = input();

-    while (c !='*' && c != EOF) 
+    while (c != '*' && c != EOF) 

     {
     {

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

       c = input();
     }
 
       c = input();
     }
 

-

     if (c == '*')
     {
       c = input();
     if (c == '*')
     {
       c = input();

-      while ( c == '*')
+      while (c == '*')

        c = input();
        c = input();

-      if ( c == '/' )
+      if (c == '/')

        break;                  /* found the end */
     }
 
        break;                  /* found the end */
     }
 

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

     {
     {

-      einfo( "%F%P :EOF in comment\n");
+      einfo( "%F%P: EOF in comment\n");

       break;
     }
   }
 }
       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);
+}