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