ld/ldlex.l

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