ld/ldlex.l

   1 %option nounput noyywrap
   2
   3 %{
   4
   5 /* Copyright (C) 1991-2022 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 <EXPRESSION,MRI>"&&"                    { RTOKEN(ANDAND); }
 237 <SCRIPT,EXPRESSION,MRI>">"              { RTOKEN('>'); }
 238 <SCRIPT,EXPRESSION,MRI,INPUTLIST>","    { RTOKEN(','); }
 239 <EXPRESSION,MRI,WILD>"&"                { RTOKEN('&'); }
 240 <EXPRESSION,MRI>"|"                     { RTOKEN('|'); }
 241 <SCRIPT,EXPRESSION,MRI>"~"              { RTOKEN('~'); }
 242 <SCRIPT,EXPRESSION,MRI>"!"              { RTOKEN('!'); }
 243 <EXPRESSION,MRI>"?"                     { RTOKEN('?'); }
 244 <EXPRESSION,MRI>"*"                     { RTOKEN('*'); }
 245 <SCRIPT,EXPRESSION,MRI>"+"              { RTOKEN('+'); }
 246 <SCRIPT,EXPRESSION,MRI>"-"              { RTOKEN('-'); }
 247 <EXPRESSION,MRI>"/"                     { RTOKEN('/'); }
 248 <EXPRESSION,MRI>"%"                     { RTOKEN('%'); }
 249 <EXPRESSION,MRI>"<"                     { RTOKEN('<'); }
 250 <SCRIPT,EXPRESSION,MRI,WILD>"="         { RTOKEN('='); }
 251 <SCRIPT,EXPRESSION,MRI,WILD>"}"         { RTOKEN('}'); }
 252 <SCRIPT,EXPRESSION,MRI,WILD>"{"         { RTOKEN('{'); }
 253 <SCRIPT,EXPRESSION,MRI,WILD,INPUTLIST>")" { RTOKEN(')'); }
 254 <SCRIPT,EXPRESSION,MRI,WILD,INPUTLIST>"(" { RTOKEN('('); }
 255 <SCRIPT,EXPRESSION,MRI>":"              { RTOKEN(':'); }
 256 <SCRIPT,EXPRESSION,MRI,WILD>";"         { RTOKEN(';'); }
 257 <SCRIPT>"MEMORY"                        { RTOKEN(MEMORY); }
 258 <SCRIPT>"REGION_ALIAS"                  { RTOKEN(REGION_ALIAS); }
 259 <SCRIPT>"LD_FEATURE"                    { RTOKEN(LD_FEATURE); }
 260 <SCRIPT,EXPRESSION>"ORIGIN"             { RTOKEN(ORIGIN); }
 261 <SCRIPT>"VERSION"                       { RTOKEN(VERSIONK); }
 262 <SCRIPT,EXPRESSION>"BLOCK"              { RTOKEN(BLOCK); }
 263 <SCRIPT,EXPRESSION>"BIND"               { RTOKEN(BIND); }
 264 <SCRIPT,EXPRESSION>"LENGTH"             { RTOKEN(LENGTH); }
 265 <SCRIPT,EXPRESSION>"ALIGN"              { RTOKEN(ALIGN_K); }
 266 <SCRIPT,EXPRESSION>"DATA_SEGMENT_ALIGN" { RTOKEN(DATA_SEGMENT_ALIGN); }
 267 <SCRIPT,EXPRESSION>"DATA_SEGMENT_RELRO_END" { RTOKEN(DATA_SEGMENT_RELRO_END); }
 268 <SCRIPT,EXPRESSION>"DATA_SEGMENT_END"   { RTOKEN(DATA_SEGMENT_END); }
 269 <SCRIPT,EXPRESSION>"ADDR"               { RTOKEN(ADDR); }
 270 <SCRIPT,EXPRESSION>"LOADADDR"           { RTOKEN(LOADADDR); }
 271 <SCRIPT,EXPRESSION>"ALIGNOF"            { RTOKEN(ALIGNOF); }
 272 <SCRIPT,EXPRESSION>"ABSOLUTE"           { RTOKEN(ABSOLUTE); }
 273 <SCRIPT,EXPRESSION>"MAX"                { RTOKEN(MAX_K); }
 274 <SCRIPT,EXPRESSION>"MIN"                { RTOKEN(MIN_K); }
 275 <SCRIPT,EXPRESSION>"LOG2CEIL"           { RTOKEN(LOG2CEIL); }
 276 <SCRIPT,EXPRESSION,WILD>"ASSERT"        { RTOKEN(ASSERT_K); }
 277 <SCRIPT>"ENTRY"                         { RTOKEN(ENTRY); }
 278 <SCRIPT,MRI>"EXTERN"                    { RTOKEN(EXTERN); }
 279 <SCRIPT,EXPRESSION>"NEXT"               { RTOKEN(NEXT); }
 280 <SCRIPT,EXPRESSION>"SIZEOF_HEADERS"     { RTOKEN(SIZEOF_HEADERS); }
 281 <SCRIPT,EXPRESSION>"SEGMENT_START"      { RTOKEN(SEGMENT_START); }
 282 <SCRIPT>"MAP"                           { RTOKEN(MAP); }
 283 <SCRIPT,EXPRESSION>"SIZEOF"             { RTOKEN(SIZEOF); }
 284 <SCRIPT>"TARGET"                        { RTOKEN(TARGET_K); }
 285 <SCRIPT>"SEARCH_DIR"                    { RTOKEN(SEARCH_DIR); }
 286 <SCRIPT>"OUTPUT"                        { RTOKEN(OUTPUT); }
 287 <SCRIPT>"INPUT"                         { RTOKEN(INPUT); }
 288 <SCRIPT>"GROUP"                         { RTOKEN(GROUP); }
 289 <INPUTLIST>"AS_NEEDED"                  { RTOKEN(AS_NEEDED); }
 290 <SCRIPT,EXPRESSION>"DEFINED"            { RTOKEN(DEFINED); }
 291 <WILD>"CREATE_OBJECT_SYMBOLS"           { RTOKEN(CREATE_OBJECT_SYMBOLS); }
 292 <WILD>"CONSTRUCTORS"                    { RTOKEN(CONSTRUCTORS); }
 293 <SCRIPT>"FORCE_COMMON_ALLOCATION"       { RTOKEN(FORCE_COMMON_ALLOCATION); }
 294 <SCRIPT>"FORCE_GROUP_ALLOCATION"        { RTOKEN(FORCE_GROUP_ALLOCATION); }
 295 <SCRIPT>"INHIBIT_COMMON_ALLOCATION"     { RTOKEN(INHIBIT_COMMON_ALLOCATION); }
 296 <SCRIPT>"SECTIONS"                      { RTOKEN(SECTIONS); }
 297 <SCRIPT>"INSERT"                        { RTOKEN(INSERT_K); }
 298 <SCRIPT>"AFTER"                         { RTOKEN(AFTER); }
 299 <SCRIPT>"BEFORE"                        { RTOKEN(BEFORE); }
 300 <WILD>"FILL"                            { RTOKEN(FILL); }
 301 <SCRIPT>"STARTUP"                       { RTOKEN(STARTUP); }
 302 <SCRIPT>"OUTPUT_FORMAT"                 { RTOKEN(OUTPUT_FORMAT); }
 303 <SCRIPT>"OUTPUT_ARCH"                   { RTOKEN(OUTPUT_ARCH); }
 304 <SCRIPT>"HLL"                           { RTOKEN(HLL); }
 305 <SCRIPT>"SYSLIB"                        { RTOKEN(SYSLIB); }
 306 <SCRIPT>"FLOAT"                         { RTOKEN(FLOAT); }
 307 <WILD>"QUAD"                            { RTOKEN(QUAD); }
 308 <WILD>"SQUAD"                           { RTOKEN(SQUAD); }
 309 <WILD>"LONG"                            { RTOKEN(LONG); }
 310 <WILD>"SHORT"                           { RTOKEN(SHORT); }
 311 <WILD>"BYTE"                            { RTOKEN(BYTE); }
 312 <SCRIPT>"NOFLOAT"                       { RTOKEN(NOFLOAT); }
 313 <SCRIPT,EXPRESSION>"NOCROSSREFS"        { RTOKEN(NOCROSSREFS); }
 314 <SCRIPT,EXPRESSION>"NOCROSSREFS_TO"     { RTOKEN(NOCROSSREFS_TO); }
 315 <SCRIPT,EXPRESSION>"OVERLAY"            { RTOKEN(OVERLAY); }
 316 <WILD>"SORT_BY_NAME"                    { RTOKEN(SORT_BY_NAME); }
 317 <WILD>"SORT_BY_ALIGNMENT"               { RTOKEN(SORT_BY_ALIGNMENT); }
 318 <WILD>"SORT"                            { RTOKEN(SORT_BY_NAME); }
 319 <WILD>"SORT_BY_INIT_PRIORITY"           { RTOKEN(SORT_BY_INIT_PRIORITY); }
 320 <WILD>"SORT_NONE"                       { RTOKEN(SORT_NONE); }
 321 <EXPRESSION>"NOLOAD"                    { RTOKEN(NOLOAD); }
 322 <EXPRESSION>"READONLY"                  { RTOKEN(READONLY); }
 323 <EXPRESSION>"DSECT"                     { RTOKEN(DSECT); }
 324 <EXPRESSION>"COPY"                      { RTOKEN(COPY); }
 325 <EXPRESSION>"INFO"                      { RTOKEN(INFO); }
 326 <EXPRESSION>"TYPE"                      { RTOKEN(TYPE); }
 327 <SCRIPT,EXPRESSION>"ONLY_IF_RO"         { RTOKEN(ONLY_IF_RO); }
 328 <SCRIPT,EXPRESSION>"ONLY_IF_RW"         { RTOKEN(ONLY_IF_RW); }
 329 <SCRIPT,EXPRESSION>"SPECIAL"            { RTOKEN(SPECIAL); }
 330 <SCRIPT>"o"                             { RTOKEN(ORIGIN); }
 331 <SCRIPT>"org"                           { RTOKEN(ORIGIN); }
 332 <SCRIPT>"l"                             { RTOKEN(LENGTH); }
 333 <SCRIPT>"len"                           { RTOKEN(LENGTH); }
 334 <WILD>"INPUT_SECTION_FLAGS"             { RTOKEN(INPUT_SECTION_FLAGS); }
 335 <SCRIPT,EXPRESSION,WILD,MRI>"INCLUDE"   { RTOKEN(INCLUDE);}
 336 <SCRIPT>"PHDRS"                         { RTOKEN(PHDRS); }
 337 <SCRIPT,EXPRESSION,WILD>"AT"            { RTOKEN(AT);}
 338 <SCRIPT,EXPRESSION>"ALIGN_WITH_INPUT"   { RTOKEN(ALIGN_WITH_INPUT);}
 339 <SCRIPT,EXPRESSION>"SUBALIGN"           { RTOKEN(SUBALIGN);}
 340 <SCRIPT,EXPRESSION,WILD>"HIDDEN"        { RTOKEN(HIDDEN); }
 341 <SCRIPT,EXPRESSION,WILD>"PROVIDE"       { RTOKEN(PROVIDE); }
 342 <SCRIPT,EXPRESSION,WILD>"PROVIDE_HIDDEN" { RTOKEN(PROVIDE_HIDDEN); }
 343 <WILD>"KEEP"                            { RTOKEN(KEEP); }
 344 <WILD>"EXCLUDE_FILE"                    { RTOKEN(EXCLUDE_FILE); }
 345 <SCRIPT,EXPRESSION>"CONSTANT"           { RTOKEN(CONSTANT);}
 346
 347 <MRI>"#".*\n?                   { ++ lineno; }
 348 <MRI>"\n"                       { ++ lineno;  RTOKEN(NEWLINE); }
 349 <MRI>"*".*                      { /* Mri comment line */ }
 350 <MRI>";".*                      { /* Mri comment line */ }
 351 <MRI>"END"                      { RTOKEN(ENDWORD); }
 352 <MRI>"ABSOLUTE"                 { RTOKEN(ABSOLUTE); }
 353 <MRI>"ALIGNMOD"                 { RTOKEN(ALIGNMOD);}
 354 <MRI>"ALIGN"                    { RTOKEN(ALIGN_K);}
 355 <MRI>"CHIP"                     { RTOKEN(CHIP); }
 356 <MRI>"BASE"                     { RTOKEN(BASE); }
 357 <MRI>"ALIAS"                    { RTOKEN(ALIAS); }
 358 <MRI>"TRUNCATE"                 { RTOKEN(TRUNCATE); }
 359 <MRI>"LOAD"                     { RTOKEN(LOAD); }
 360 <MRI>"PUBLIC"                   { RTOKEN(PUBLIC); }
 361 <MRI>"ORDER"                    { RTOKEN(ORDER); }
 362 <MRI>"NAME"                     { RTOKEN(NAMEWORD); }
 363 <MRI>"FORMAT"                   { RTOKEN(FORMAT); }
 364 <MRI>"CASE"                     { RTOKEN(CASE); }
 365 <MRI>"START"                    { RTOKEN(START); }
 366 <MRI>"LIST".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
 367 <MRI>"SECT"                     { RTOKEN(SECT); }
 368 <MRI>"end"                      { RTOKEN(ENDWORD); }
 369 <MRI>"absolute"                 { RTOKEN(ABSOLUTE); }
 370 <MRI>"alignmod"                 { RTOKEN(ALIGNMOD);}
 371 <MRI>"align"                    { RTOKEN(ALIGN_K);}
 372 <MRI>"chip"                     { RTOKEN(CHIP); }
 373 <MRI>"base"                     { RTOKEN(BASE); }
 374 <MRI>"alias"                    { RTOKEN(ALIAS); }
 375 <MRI>"truncate"                 { RTOKEN(TRUNCATE); }
 376 <MRI>"load"                     { RTOKEN(LOAD); }
 377 <MRI>"public"                   { RTOKEN(PUBLIC); }
 378 <MRI>"order"                    { RTOKEN(ORDER); }
 379 <MRI>"name"                     { RTOKEN(NAMEWORD); }
 380 <MRI>"format"                   { RTOKEN(FORMAT); }
 381 <MRI>"case"                     { RTOKEN(CASE); }
 382 <MRI>"extern"                   { RTOKEN(EXTERN); }
 383 <MRI>"start"                    { RTOKEN(START); }
 384 <MRI>"list".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
 385 <MRI>"sect"                     { RTOKEN(SECT); }
 386
 387 <MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}*  {
 388 /* Filename without commas, needed to parse mri stuff */
 389                                   yylval.name = xstrdup (yytext);
 390                                   return NAME;
 391                                 }
 392
 393
 394 <SCRIPT,INPUTLIST>{FILENAMECHAR1}{FILENAMECHAR}*        {
 395                                   yylval.name = xstrdup (yytext);
 396                                   return NAME;
 397                                 }
 398 <INPUTLIST>"="{FILENAMECHAR1}{FILENAMECHAR}*    {
 399 /* Filename to be prefixed by --sysroot or when non-sysrooted, nothing.  */
 400                                   yylval.name = xstrdup (yytext);
 401                                   return NAME;
 402                                 }
 403 <INPUTLIST>"-l"{FILENAMECHAR}+ {
 404                                   yylval.name = xstrdup (yytext + 2);
 405                                   return LNAME;
 406                                 }
 407 <EXPRESSION>{SYMBOLNAMECHAR1}{SYMBOLNAMECHAR}* {
 408                                   yylval.name = xstrdup (yytext);
 409                                   return NAME;
 410                                 }
 411   /* The following rule is to prevent a fill expression on the output
 412      section before /DISCARD/ interpreting the '/' as a divide.  */
 413 <EXPRESSION>"/DISCARD/"         {
 414                                   yylval.name = xstrdup (yytext);
 415                                   return NAME;
 416                                 }
 417 <WILD>{WILDCHAR}* {
 418                 /* Annoyingly, this pattern can match comments, and we have
 419                    longest match issues to consider.  So if the first two
 420                    characters are a comment opening, put the input back and
 421                    try again.  */
 422                 if (yytext[0] == '/' && yytext[1] == '*')
 423                   {
 424                     yyless (2);
 425                     comment ();
 426                   }
 427                 else
 428                   {
 429                     yylval.name = xstrdup (yytext);
 430                     return NAME;
 431                   }
 432         }
 433
 434 <SCRIPT,EXPRESSION,WILD,VERS_NODE,INPUTLIST>"\""[^\"]*"\"" {
 435                 /* No matter the state, quotes give what's inside.  */
 436                 yylval.name = xmemdup (yytext + 1, yyleng - 2, yyleng - 1);
 437                 return NAME;
 438         }
 439
 440 <SCRIPT,EXPRESSION,WILD,VERS_START,VERS_NODE,VERS_SCRIPT,INPUTLIST>"\n" {
 441                                 lineno++; }
 442 <MRI,SCRIPT,EXPRESSION,WILD,VERS_START,VERS_NODE,VERS_SCRIPT,INPUTLIST>[ \t\r]+ {
 443                                 /* Eat up whitespace */ }
 444 <SCRIPT,EXPRESSION,WILD,VERS_START,VERS_NODE,VERS_SCRIPT>#.* {
 445                                 /* Eat up comments */ }
 446
 447 <VERS_NODE,VERS_SCRIPT>[:,;]    { return *yytext; }
 448
 449 <VERS_NODE>global               { RTOKEN(GLOBAL); }
 450
 451 <VERS_NODE>local                { RTOKEN(LOCAL); }
 452
 453 <VERS_NODE>extern               { RTOKEN(EXTERN); }
 454
 455 <VERS_NODE>{V_IDENTIFIER}       { yylval.name = xstrdup (yytext);
 456                                   return VERS_IDENTIFIER; }
 457
 458 <VERS_SCRIPT>{V_TAG}            { yylval.name = xstrdup (yytext);
 459                                   return VERS_TAG; }
 460
 461 <VERS_START>"{"                 { BEGIN(VERS_SCRIPT); return *yytext; }
 462
 463 <VERS_SCRIPT>"{"                { BEGIN(VERS_NODE);
 464                                   vers_node_nesting = 0;
 465                                   return *yytext;
 466                                 }
 467 <VERS_SCRIPT>"}"                { return *yytext; }
 468 <VERS_NODE>"{"                  { vers_node_nesting++; return *yytext; }
 469 <VERS_NODE>"}"                  { if (--vers_node_nesting < 0)
 470                                     BEGIN(VERS_SCRIPT);
 471                                   return *yytext;
 472                                 }
 473
 474 <<EOF>> {
 475   include_stack_ptr--;
 476   if (include_stack_ptr == 0)
 477     {
 478       lineno = 0;
 479       yyterminate ();
 480     }
 481   else
 482     yy_switch_to_buffer (include_stack[include_stack_ptr]);
 483
 484   lineno = lineno_stack[include_stack_ptr];
 485   input_flags.sysrooted = sysrooted_stack[include_stack_ptr];
 486
 487   return END;
 488 }
 489
 490 <SCRIPT,WILD,MRI,VERS_START,VERS_SCRIPT,VERS_NODE>.     lex_warn_invalid (" in script", yytext);
 491 <EXPRESSION>.   lex_warn_invalid (" in expression", yytext);
 492
 493 %%
 494 \f
 495
 496 /* Switch flex to reading script file NAME, open on FILE,
 497    saving the current input info on the include stack.  */
 498
 499 void
 500 lex_push_file (FILE *file, const char *name, unsigned int sysrooted)
 501 {
 502   if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
 503     {
 504       einfo (_("%F:includes nested too deeply\n"));
 505     }
 506   file_name_stack[include_stack_ptr] = name;
 507   lineno_stack[include_stack_ptr] = lineno;
 508   sysrooted_stack[include_stack_ptr] = input_flags.sysrooted;
 509   include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
 510
 511   include_stack_ptr++;
 512   lineno = 1;
 513   input_flags.sysrooted = sysrooted;
 514   yyin = file;
 515   yy_switch_to_buffer (yy_create_buffer (yyin, YY_BUF_SIZE));
 516 }
 517
 518 /* Return a newly created flex input buffer containing STRING,
 519    which is SIZE bytes long.  */
 520
 521 static YY_BUFFER_STATE
 522 yy_create_string_buffer (const char *string, size_t size)
 523 {
 524   YY_BUFFER_STATE b;
 525
 526   b = xmalloc (sizeof (struct yy_buffer_state));
 527   b->yy_input_file = 0;
 528   b->yy_buf_size = size;
 529
 530   /* yy_ch_buf has to be 2 characters longer than the size given because
 531      we need to put in 2 end-of-buffer characters.  */
 532   b->yy_ch_buf = xmalloc ((size_t) b->yy_buf_size + 3);
 533
 534   b->yy_ch_buf[0] = '\n';
 535   strcpy (b->yy_ch_buf+1, string);
 536   b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
 537   b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
 538   b->yy_n_chars = size+1;
 539   b->yy_buf_pos = &b->yy_ch_buf[1];
 540
 541   b->yy_is_our_buffer = 1;
 542   b->yy_is_interactive = 0;
 543   b->yy_at_bol = 1;
 544   b->yy_fill_buffer = 0;
 545
 546   /* flex 2.4.7 changed the interface.  FIXME: We should not be using
 547      a flex internal interface in the first place!  */
 548 #ifdef YY_BUFFER_NEW
 549   b->yy_buffer_status = YY_BUFFER_NEW;
 550 #else
 551   b->yy_eof_status = EOF_NOT_SEEN;
 552 #endif
 553
 554   return b;
 555 }
 556
 557 /* Switch flex to reading from STRING, saving the current input info
 558    on the include stack.  */
 559
 560 void
 561 lex_redirect (const char *string, const char *fake_filename, unsigned int count)
 562 {
 563   YY_BUFFER_STATE tmp;
 564
 565   yy_init = 0;
 566   if (include_stack_ptr >= MAX_INCLUDE_DEPTH)
 567     {
 568       einfo (_("%F: macros nested too deeply\n"));
 569     }
 570   file_name_stack[include_stack_ptr] = fake_filename;
 571   lineno_stack[include_stack_ptr] = lineno;
 572   include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
 573   include_stack_ptr++;
 574   lineno = count;
 575   tmp = yy_create_string_buffer (string, strlen (string));
 576   yy_switch_to_buffer (tmp);
 577 }
 578 \f
 579 /* Functions to switch to a different flex start condition,
 580    saving the current start condition on `state_stack'.  */
 581
 582 static int state_stack[MAX_INCLUDE_DEPTH * 2];
 583 static int *state_stack_p = state_stack;
 584
 585 void
 586 ldlex_script (void)
 587 {
 588   *(state_stack_p)++ = yy_start;
 589   BEGIN (SCRIPT);
 590 }
 591
 592 void
 593 ldlex_inputlist (void)
 594 {
 595   *(state_stack_p)++ = yy_start;
 596   BEGIN (INPUTLIST);
 597 }
 598
 599 void
 600 ldlex_mri_script (void)
 601 {
 602   *(state_stack_p)++ = yy_start;
 603   BEGIN (MRI);
 604 }
 605
 606 void
 607 ldlex_version_script (void)
 608 {
 609   *(state_stack_p)++ = yy_start;
 610   BEGIN (VERS_START);
 611 }
 612
 613 void
 614 ldlex_version_file (void)
 615 {
 616   *(state_stack_p)++ = yy_start;
 617   BEGIN (VERS_SCRIPT);
 618 }
 619
 620 void
 621 ldlex_expression (void)
 622 {
 623   *(state_stack_p)++ = yy_start;
 624   BEGIN (EXPRESSION);
 625 }
 626
 627 void
 628 ldlex_wild (void)
 629 {
 630   *(state_stack_p)++ = yy_start;
 631   BEGIN (WILD);
 632 }
 633
 634 void
 635 ldlex_popstate (void)
 636 {
 637   yy_start = *(--state_stack_p);
 638 }
 639
 640 /* In cases where the parser needs to look ahead and the context
 641    changes from expression to script or vice-versa, throw away a
 642    NAME.  What constitutes a NAME depends on context.  */
 643
 644 void
 645 ldlex_backup (void)
 646 {
 647   yyless (0);
 648 }
 649
 650 /* Return the current file name, or the previous file if no file is
 651    current.  */
 652
 653 const char*
 654 ldlex_filename (void)
 655 {
 656   return file_name_stack[include_stack_ptr - (include_stack_ptr != 0)];
 657 }
 658 \f
 659
 660 /* Place up to MAX_SIZE characters in BUF and return
 661    either the number of characters read, or 0 to indicate EOF.  */
 662
 663 static int
 664 yy_input (char *buf, int max_size)
 665 {
 666   int result = 0;
 667   if (YY_CURRENT_BUFFER->yy_input_file)
 668     {
 669       if (yyin)
 670         {
 671           result = fread (buf, 1, max_size, yyin);
 672           if (result < max_size && ferror (yyin))
 673             einfo (_("%F%P: read in flex scanner failed\n"));
 674         }
 675     }
 676   return result;
 677 }
 678
 679 /* Eat the rest of a C-style comment.  */
 680
 681 static void
 682 comment (void)
 683 {
 684   int c;
 685
 686   while (1)
 687     {
 688       c = input();
 689       while (c != '*' && c != 0)
 690         {
 691           if (c == '\n')
 692             lineno++;
 693           c = input();
 694         }
 695
 696       if (c == '*')
 697         {
 698           c = input();
 699           while (c == '*')
 700             c = input();
 701           if (c == '/')
 702             break;                      /* found the end */
 703         }
 704
 705       if (c == '\n')
 706         lineno++;
 707
 708       if (c == 0)
 709         {
 710           einfo (_("%F%P: EOF in comment\n"));
 711           break;
 712         }
 713     }
 714 }
 715
 716 /* Warn the user about a garbage character WHAT in the input
 717    in context WHERE.  */
 718
 719 static void
 720 lex_warn_invalid (char *where, char *what)
 721 {
 722   char buf[5];
 723
 724   /* If we have found an input file whose format we do not recognize,
 725      and we are therefore treating it as a linker script, and we find
 726      an invalid character, then most likely this is a real object file
 727      of some different format.  Treat it as such.  */
 728   if (ldfile_assumed_script)
 729     {
 730       bfd_set_error (bfd_error_file_not_recognized);
 731       einfo (_("%F%s: file not recognized: %E\n"), ldlex_filename ());
 732     }
 733
 734   if (! ISPRINT (*what))
 735     {
 736       sprintf (buf, "\\%03o", *(unsigned char *) what);
 737       what = buf;
 738     }
 739
 740   einfo (_("%P:%pS: ignoring invalid character `%s'%s\n"), NULL, what, where);
 741 }