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