home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / gnu / djgpp / src / binutils.2 / ld / ldlex.l < prev    next >
Encoding:
Lex Description  |  1993-05-30  |  15.4 KB  |  584 lines
  1. %{
  2.  
  3. /* Copyright (C) 1991 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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /*
  22. This was written by steve chamberlain
  23.                     sac@cygnus.com
  24. */
  25.  
  26.  
  27. typedef int bfd_vma;
  28. #include <ansidecl.h>
  29. #include "ldgram.h"
  30.  
  31. int ldgram_in_defsym;
  32. int ldgram_had_equals;
  33. int ldgram_in_script;
  34.  
  35. int hex_mode;
  36. extern int fgetc();
  37. extern int yyparse();
  38.  
  39.  
  40.  
  41. char *buystring();
  42.  
  43. unsigned int lineno = 1;
  44. int old;
  45.  
  46. static comment();
  47.  
  48. #undef YY_INPUT
  49. #define YY_INPUT(buf,result,max_size) yy_input(buf, &result, max_size)
  50. #undef YY_FATAL_ERROR
  51. #define YY_FATAL_ERROR ;
  52. #define MAX_INCLUDE_DEPTH 10
  53. YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
  54. char *file_name_stack[MAX_INCLUDE_DEPTH];
  55. unsigned int include_stack_ptr = 0;
  56.  
  57.  
  58. /* STATES 
  59.     COMMAND         on command line
  60.     COMMENT        in a C comment
  61.     EXPRESSION    definiatelyt in an expression
  62.     SCRIPT        definately in a script
  63.     SOMEWHERE    either EXPRESSION or SCRIPT
  64.         MRI             in an MRI script
  65. */
  66. #define RTOKEN(x)  {  yylval.token = x; return x; }
  67. %}
  68.  
  69. %a 4000
  70. %o 5000
  71.  
  72. CMDFILENAMECHAR   [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\-\~]
  73. CMDFILENAMECHAR1  [_a-zA-Z0-9\/\.\\_\+\$\:\[\]\\\,\=\&\!\<\>\~]
  74. FILENAMECHAR1    [_a-zA-Z\/\.\\\$\_\~]
  75. SYMBOLCHARN     [_a-zA-Z\/\.\\0-9]
  76. FILENAMECHAR    [_a-zA-Z0-9\/\.\-\_\+\=\$\:\[\]\\\,\~]
  77. FILENAME    {FILENAMECHAR}+
  78. WHITE        [ \t\n]+ 
  79.  
  80. NOCFILENAMECHAR    [_a-zA-Z0-9\/\.\-\_\+\$\:\[\]\\\~]
  81.  
  82.  
  83. %s COMMAND
  84. %s SCRIPT
  85. %s EXPRESSION
  86. %s COMMENT
  87. %s BOTH
  88. %s DEFSYMEXP
  89. %s MRI
  90. %%
  91.  
  92.  
  93. <BOTH,SCRIPT,EXPRESSION,COMMAND>"/*"    { comment(); }
  94.  
  95.  
  96. <DEFSYMEXP>"-"                  { RTOKEN('-');}
  97. <DEFSYMEXP>"+"                  { RTOKEN('+');}
  98. <DEFSYMEXP>{FILENAMECHAR1}{SYMBOLCHARN}*   { yylval.name = buystring(yytext); return NAME; }
  99. <DEFSYMEXP>[ \t]                { RTOKEN(DEFSYMEND); }
  100. <DEFSYMEXP>"="                  { RTOKEN('='); }
  101. <COMMAND>"-defsym"{WHITE}*    { return OPTION_defsym; }
  102. <COMMAND>"-noinhibit_exec"     { return OPTION_noinhibit_exec; }
  103. <COMMAND>"-noinhibit-exec"    { return OPTION_noinhibit_exec; }
  104. <COMMAND>"-sort_common"        { return OPTION_sort_common;}
  105. <COMMAND>"-sort-common"        { return OPTION_sort_common;}
  106. <COMMAND>"-format"        { return OPTION_format; }
  107. <COMMAND>"-n"            { return OPTION_n; }
  108. <COMMAND>"-N"            { return OPTION_N; }
  109. <COMMAND>"-r"            { return OPTION_r; }
  110. <COMMAND>"-relax"        { return OPTION_relax; }
  111. <COMMAND>"-i"            { return OPTION_r; }
  112. <COMMAND>"-Ur"            { return OPTION_Ur; }
  113. <COMMAND>"-o"            { return OPTION_o; }
  114. <COMMAND>"-g"            { return OPTION_g; }
  115. <COMMAND>"-e"            { return OPTION_e; }
  116. <COMMAND>"-b"            { return OPTION_b; }
  117. <COMMAND>"-dc"            { return OPTION_dc; }
  118. <COMMAND>"-dp"            { return OPTION_dp; }
  119. <COMMAND>"-d"            { return OPTION_d; }
  120. <COMMAND>"-v"            { return OPTION_v; }
  121. <COMMAND>"-V"            { return OPTION_V; }
  122. <COMMAND>"-M"            { return OPTION_M; }
  123. <COMMAND>"-Map"                     { return OPTION_Map;}
  124. <COMMAND>"-t"            { return OPTION_t; }
  125. <COMMAND>"-X"            { return OPTION_X; }
  126. <COMMAND>"-x"            { return OPTION_x; }
  127. <COMMAND>"-c"            { return OPTION_c; }
  128. <COMMAND>"-R"            { return OPTION_R; }
  129. <COMMAND>"-u"            { return OPTION_u; }
  130. <COMMAND>"-s"                   { return OPTION_s; }
  131. <COMMAND>"-S"                   { return OPTION_S; }
  132. <COMMAND>"-Bstat"         { return OPTION_Bstatic; }
  133. <COMMAND>"-B"{FILENAME}           { /* Ignored */ }
  134. <COMMAND>"-l"{FILENAME}     {
  135.                      yylval.name = buystring(yytext+2);
  136.                       return OPTION_l; 
  137.                 }
  138.  
  139. <COMMAND>"-L"{FILENAME}     { 
  140.                     yylval.name = buystring(yytext+2);
  141.                     return OPTION_L; 
  142.                 }
  143. <COMMAND>"-Ttext"             {
  144.                  yylval.name = ".text";
  145.                  return OPTION_Texp;
  146.                 }
  147. <COMMAND>"-Tdata"          {
  148.                  yylval.name = ".data";
  149.                  return OPTION_Texp;
  150.                    }
  151. <COMMAND>"-Tbss"        {
  152.                  yylval.name = ".bss";
  153.                  return OPTION_Texp;
  154.                    }
  155. <COMMAND>"-O"{FILENAME}     {
  156.                 yylval.name = buystring(yytext+2);
  157.                 return OPTION_Texp;
  158.                 }
  159.  
  160. <COMMAND>"-T"{FILENAME}      {
  161.                  yylval.name = buystring(yytext+2);
  162.                  return OPTION_Tfile;
  163.                    }
  164. <COMMAND>"-T"                  {
  165.                  return OPTION_T;
  166.                    }
  167.  
  168. <COMMAND>"-F"{FILENAME}      {
  169.                  return OPTION_F;
  170.                    }
  171. <COMMAND>"-F"                  {
  172.                  return OPTION_F;
  173.                    }
  174.  
  175. <COMMAND>"-y"{FILENAME}         {
  176.                     yylval.name = buystring(yytext+2);
  177.                     return OPTION_y;
  178.                 }
  179.                 
  180. <COMMAND>"-A"{FILENAME}     {
  181.                             yylval.name = buystring(yytext+2);
  182.                      return OPTION_Aarch;
  183.                        }
  184.  
  185. <COMMAND>"-retain-symbols-file"    { return OPTION_RETAIN_SYMBOLS_FILE; }
  186.  
  187. <COMMAND>"-EB"              {
  188.                     return OPTION_EB;
  189.                 }
  190. <COMMAND>"-EL"                {
  191.                     return OPTION_EL;
  192.                 }
  193. <COMMAND>"-G"            {
  194.                     return OPTION_G;
  195.                 }
  196. <COMMAND>"-G"([0-9])+        {
  197.                     yylval.integer = atoi (yytext + 2);
  198.                     return OPTION_Gval;
  199.                 }
  200. <MRI,EXPRESSION>"$"([0-9A-Fa-f])+ {
  201.                   yylval.integer = strtoul(yytext+1, 0,16);
  202.                 return INT;
  203.             }
  204.  
  205. <MRI,EXPRESSION>([0-9A-Fa-f])+(H|X|B|O|D) {
  206.                    int base ;
  207.                    switch (yytext[yyleng-1]) {
  208.                     case 'X': 
  209.                     case 'H':
  210.                      base = 16;
  211.                      break;
  212.                     case 'O':
  213.                      base = 8;
  214.                      break;
  215.                     case 'B':
  216.                      base = 2;
  217.                      break;
  218.                     default:
  219.                      base = 10;
  220.                    }
  221.                    yylval.integer = strtoul(yytext+1, 0, base);    
  222.                    return INT;
  223.                  }
  224. <SCRIPT,DEFSYMEXP,MRI,BOTH,EXPRESSION>"$"?"0x"?([0-9A-Fa-f])+(M|K|m|k)? {
  225.                   yylval.integer = strtoul(yytext,0,hex_mode);
  226.                   if (yytext[yyleng-1]=='M'
  227.                     || yytext[yyleng-1] == 'm') {
  228.                       yylval.integer *= 1024*1024;
  229.                     }    
  230.                   if (yytext[yyleng-1]=='K' 
  231.                 || yytext[yyleng-1]=='k') {
  232.                       yylval.integer *= 1024;
  233.                     }        
  234.                   return INT;
  235.                 }
  236. <BOTH,SCRIPT,EXPRESSION>"]"        { RTOKEN(']');}
  237. <BOTH,SCRIPT,EXPRESSION>"["        { RTOKEN('[');}
  238. <BOTH,SCRIPT,EXPRESSION>"<<="    { RTOKEN(LSHIFTEQ);}
  239. <BOTH,SCRIPT,EXPRESSION>">>="    { RTOKEN(RSHIFTEQ);}
  240. <BOTH,SCRIPT,EXPRESSION>"||"    { RTOKEN(OROR);}
  241. <BOTH,SCRIPT,EXPRESSION>"=="    { RTOKEN(EQ);}
  242. <BOTH,SCRIPT,EXPRESSION>"!="    { RTOKEN(NE);}
  243. <BOTH,SCRIPT,EXPRESSION>">="    { RTOKEN(GE);}
  244. <BOTH,SCRIPT,EXPRESSION>"<="    { RTOKEN(LE);}
  245. <BOTH,SCRIPT,EXPRESSION>"<<"    { RTOKEN(LSHIFT);}
  246. <BOTH,SCRIPT,EXPRESSION>">>"    { RTOKEN(RSHIFT);}
  247. <BOTH,SCRIPT,EXPRESSION>"+="    { RTOKEN(PLUSEQ);}
  248. <BOTH,SCRIPT,EXPRESSION>"-="    { RTOKEN(MINUSEQ);}
  249. <BOTH,SCRIPT,EXPRESSION>"*="    { RTOKEN(MULTEQ);}
  250. <BOTH,SCRIPT,EXPRESSION>"/="    { RTOKEN(DIVEQ);}
  251. <BOTH,SCRIPT,EXPRESSION>"&="    { RTOKEN(ANDEQ);}
  252. <BOTH,SCRIPT,EXPRESSION>"|="    { RTOKEN(OREQ);}
  253. <BOTH,SCRIPT,EXPRESSION>"&&"    { RTOKEN(ANDAND);}
  254. <BOTH,SCRIPT,EXPRESSION>">"        { RTOKEN('>');}
  255. <MRI,BOTH,SCRIPT,EXPRESSION>","        { RTOKEN(',');}
  256. <BOTH,SCRIPT,EXPRESSION>"&"        { RTOKEN('&');}
  257. <BOTH,SCRIPT,EXPRESSION>"|"        { RTOKEN('|');}
  258. <BOTH,SCRIPT,EXPRESSION>"~"        { RTOKEN('~');}
  259. <BOTH,SCRIPT,EXPRESSION>"!"        { RTOKEN('!');}
  260. <BOTH,SCRIPT,EXPRESSION>"?"        { RTOKEN('?');}
  261. <BOTH,SCRIPT,EXPRESSION>"*"        { RTOKEN('*');}
  262. <BOTH,SCRIPT,EXPRESSION>"+"        { RTOKEN('+');}
  263. <BOTH,SCRIPT,EXPRESSION>"-"        { RTOKEN('-');}
  264. <BOTH,SCRIPT,EXPRESSION>"/"        { RTOKEN('/');}
  265. <BOTH,SCRIPT,EXPRESSION>"%"        { RTOKEN('%');}
  266. <BOTH,SCRIPT,EXPRESSION>"<"        { RTOKEN('<');}
  267. <BOTH,SCRIPT,EXPRESSION>">"        { RTOKEN('>');}
  268. <MRI,BOTH,SCRIPT,EXPRESSION>"="          { RTOKEN('=');}
  269. <BOTH,SCRIPT,EXPRESSION>"}"            { RTOKEN('}') ; }
  270. <BOTH,SCRIPT,EXPRESSION>"{"            { RTOKEN('{'); }
  271. <BOTH,SCRIPT,EXPRESSION>")"            { RTOKEN(')');}
  272. <BOTH,SCRIPT,EXPRESSION>"("            { RTOKEN('(');}
  273. <BOTH,SCRIPT,EXPRESSION>"]"        { RTOKEN(']');}
  274. <BOTH,SCRIPT,EXPRESSION>"["        { RTOKEN('[');}
  275. <BOTH,SCRIPT,EXPRESSION>":"        { RTOKEN(':'); }
  276. <BOTH,SCRIPT,EXPRESSION>";"        { RTOKEN(';');}
  277. <BOTH,SCRIPT,EXPRESSION>"-"        { RTOKEN('-');}
  278. <BOTH,SCRIPT,EXPRESSION>"/"        { RTOKEN('/');}
  279. <BOTH,SCRIPT>"MEMORY"        { RTOKEN(MEMORY);}
  280. <BOTH,SCRIPT>"ORIGIN"        { RTOKEN(ORIGIN);}
  281. <BOTH,SCRIPT>"BLOCK"            { RTOKEN(BLOCK);}
  282. <BOTH,SCRIPT>"LENGTH"        { RTOKEN(LENGTH);}
  283. <EXPRESSION,BOTH,SCRIPT>"ALIGN"            { RTOKEN(ALIGN_K);}
  284. <EXPRESSION,BOTH,SCRIPT>"ADDR"            { RTOKEN(ADDR);}
  285. <BOTH,SCRIPT>"ENTRY"            { RTOKEN(ENTRY);}
  286. <EXPRESSION,BOTH,SCRIPT>"NEXT"            { RTOKEN(NEXT);}
  287. <EXPRESSION,BOTH,SCRIPT>"sizeof_headers"    { RTOKEN(SIZEOF_HEADERS);}
  288. <EXPRESSION,BOTH,SCRIPT>"SIZEOF_HEADERS"    { RTOKEN(SIZEOF_HEADERS);}
  289. <BOTH,SCRIPT>"MAP"            { RTOKEN(MAP);}
  290. <EXPRESSION,BOTH,SCRIPT>"SIZEOF"        { RTOKEN(SIZEOF);}
  291. <BOTH,SCRIPT>"TARGET"        { RTOKEN(TARGET_K);}
  292. <BOTH,SCRIPT>"SEARCH_DIR"        { RTOKEN(SEARCH_DIR);}
  293. <BOTH,SCRIPT>"OUTPUT"        { RTOKEN(OUTPUT);}
  294. <BOTH,SCRIPT>"INPUT"            { RTOKEN(INPUT);}
  295. <EXPRESSION,BOTH,SCRIPT>"DEFINED"        { RTOKEN(DEFINED);}
  296. <BOTH,SCRIPT>"CREATE_OBJECT_SYMBOLS"    { RTOKEN(CREATE_OBJECT_SYMBOLS);}
  297. <BOTH,SCRIPT>"CONSTRUCTORS"        { RTOKEN( CONSTRUCTORS);}
  298. <BOTH,SCRIPT>"FORCE_COMMON_ALLOCATION" { RTOKEN(FORCE_COMMON_ALLOCATION);}
  299. <BOTH,SCRIPT>"SECTIONS"        { RTOKEN(SECTIONS);}
  300. <BOTH,SCRIPT>"FILL"            { RTOKEN(FILL);}
  301. <BOTH,SCRIPT>"STARTUP"        { RTOKEN(STARTUP);}
  302. <BOTH,SCRIPT>"OUTPUT_FORMAT"        { RTOKEN(OUTPUT_FORMAT);}
  303. <BOTH,SCRIPT>"OUTPUT_ARCH"        { RTOKEN( OUTPUT_ARCH);}
  304. <BOTH,SCRIPT>"HLL"            { RTOKEN(HLL);}
  305. <BOTH,SCRIPT>"SYSLIB"        { RTOKEN(SYSLIB);}
  306. <BOTH,SCRIPT>"FLOAT"            { RTOKEN(FLOAT);}
  307. <BOTH,SCRIPT>"LONG"            { RTOKEN( LONG);}
  308. <BOTH,SCRIPT>"SHORT"            { RTOKEN( SHORT);}
  309. <BOTH,SCRIPT>"BYTE"            { RTOKEN( BYTE);}
  310. <BOTH,SCRIPT>"NOFLOAT"        { RTOKEN(NOFLOAT);}
  311. <EXPRESSION,BOTH,SCRIPT>"NOLOAD"        { RTOKEN(NOLOAD);}
  312. <BOTH,SCRIPT>"DSECT"            { RTOKEN(DSECT);}
  313. <BOTH,SCRIPT>"COPY"            { RTOKEN(COPY);}
  314. <BOTH,SCRIPT>"INFO"            { RTOKEN(INFO);}
  315. <BOTH,SCRIPT>"OVERLAY"        { RTOKEN(OVERLAY);}
  316. <BOTH,SCRIPT>"o"            { RTOKEN(ORIGIN);}
  317. <BOTH,SCRIPT>"org"            { RTOKEN(ORIGIN);}
  318. <BOTH,SCRIPT>"l"            { RTOKEN( LENGTH);}
  319. <BOTH,SCRIPT>"len"            { RTOKEN( LENGTH);}
  320. <BOTH,SCRIPT>"INCLUDE"            { RTOKEN(INCLUDE);}
  321. <EXPRESSION,BOTH,SCRIPT>"AT"            { RTOKEN(AT);}
  322. <MRI>"\n"                    { ++ lineno;  RTOKEN(NEWLINE); }
  323. <MRI>"*".*            { /* Mri comment line */ }
  324. <MRI>"END"                      { RTOKEN(ENDWORD); }
  325. <MRI>"ALIGNMOD"        { RTOKEN(ALIGNMOD);}
  326. <MRI>"ALIGN"        { RTOKEN(ALIGN_K);}
  327.  
  328. <MRI>"CHIP"                     { RTOKEN(CHIP); }
  329. <MRI>"BASE"                     { RTOKEN(BASE); }
  330. <MRI>"ALIAS"                     { RTOKEN(ALIAS); }
  331. <MRI>"TRUNCATE"                     { RTOKEN(TRUNCATE); }
  332. <MRI>"LOAD"                     { RTOKEN(LOAD); }
  333. <MRI>"PUBLIC"                   { RTOKEN(PUBLIC); }
  334. <MRI>"ORDER"                    { RTOKEN(ORDER); }
  335. <MRI>"NAME"                     { RTOKEN(NAMEWORD); }
  336. <MRI>"FORMAT"                   { RTOKEN(FORMAT); }
  337. <MRI>"LIST".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
  338. <MRI>"SECT"            { RTOKEN(SECT); }
  339. <EXPRESSION,BOTH,SCRIPT,MRI>"ABSOLUTE"            { RTOKEN(ABSOLUTE); }
  340. <MRI>"end"                      { RTOKEN(ENDWORD); }
  341. <MRI>"chip"                     { RTOKEN(CHIP); }
  342. <MRI>"load"                     { RTOKEN(LOAD); }
  343. <MRI>"order"                    { RTOKEN(ORDER); }
  344. <MRI>"name"                     { RTOKEN(NAMEWORD); }
  345. <MRI>"format"                   { RTOKEN(FORMAT); }
  346. <MRI>"list".*                   { RTOKEN(LIST); /* LIST and ignore to end of line */ }
  347. <MRI>"sect"            { RTOKEN(SECT); }
  348. <EXPRESSION,BOTH,SCRIPT,MRI>"absolute"            { RTOKEN(ABSOLUTE); }
  349.  
  350. <COMMAND>{CMDFILENAMECHAR1}{CMDFILENAMECHAR}*    {
  351.                  yylval.name = buystring(yytext); 
  352.                   return NAME;
  353.                 }
  354.  
  355.  
  356. <MRI>{FILENAMECHAR1}{NOCFILENAMECHAR}*    {
  357. /* Filename without commas, needed to parse mri stuff */
  358.                  yylval.name = buystring(yytext); 
  359.                   return NAME;
  360.                 }
  361.  
  362.  
  363. <BOTH,EXPRESSION>{FILENAMECHAR1}{FILENAMECHAR}*    {
  364.                  yylval.name = buystring(yytext); 
  365.                   return NAME;
  366.                 }
  367. <SCRIPT,COMMAND>{FILENAMECHAR}* { yylval.name = buystring(yytext); 
  368.                   return NAME;
  369.                 }
  370.  
  371. <EXPRESSION,BOTH,COMMAND,SCRIPT>"\""[^\"]*"\"" {
  372.                     /* No matter the state, quotes
  373.                        give what's inside */
  374.                     yylval.name = buystring(yytext+1);
  375.                     yylval.name[yyleng-2] = 0;
  376.                     return NAME;
  377.                 }
  378. <BOTH,SCRIPT,EXPRESSION>"\n"        { lineno++;}
  379. <MRI,COMMAND,BOTH,SCRIPT,EXPRESSION>[ \t]
  380.  
  381. <<EOF>> {
  382.   extern char *ldfile_input_filename;
  383.   include_stack_ptr--;
  384.     
  385.   if (include_stack_ptr == 0) 
  386.   {
  387.     yyterminate();
  388.   }
  389.   else 
  390.   {
  391.     yy_switch_to_buffer(include_stack[include_stack_ptr]);
  392.  
  393.   }
  394.   if (include_stack_ptr==1) 
  395.   {
  396.     BEGIN(COMMAND);
  397.   }
  398.   else 
  399.   {
  400.     BEGIN(SCRIPT);
  401.     ldfile_input_filename = file_name_stack[include_stack_ptr-1];
  402.   }
  403.  
  404.   return END;
  405. }
  406.     
  407. %%
  408.  
  409. void
  410. DEFUN(lex_push_file,(file,name),
  411.      FILE *file AND
  412.      char *name)
  413. {
  414.   if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  415.   {
  416.     einfo("%F:includes nested too deeply");
  417.   }
  418.   file_name_stack[include_stack_ptr] = name;
  419.   include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
  420.  
  421.   include_stack_ptr++;
  422.   yyin = file;
  423.   yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
  424.  
  425.   BEGIN(SCRIPT);
  426. }
  427.  
  428. YY_BUFFER_STATE 
  429. DEFUN(yy_create_string_buffer,(string,  size),
  430.       CONST char *string AND
  431.       int size )
  432. {
  433.   YY_BUFFER_STATE b;
  434.  
  435.   b = (YY_BUFFER_STATE) malloc( sizeof( struct yy_buffer_state ) );
  436.   b->yy_input_file = 0;
  437.   
  438.   if ( ! b )
  439.    YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  440.  
  441.   b->yy_buf_size = size;
  442.  
  443.   /* yy_ch_buf has to be 2 characters longer than the size given because
  444.    * we need to put in 2 end-of-buffer characters.
  445.    */
  446.   b->yy_ch_buf = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 3) );
  447.  
  448.   if ( ! b->yy_ch_buf )
  449.    YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  450.  
  451.  
  452.   b->yy_ch_buf[0] = '\n';
  453.   strcpy(b->yy_ch_buf+1,  string);
  454.   b->yy_ch_buf[size+1] = YY_END_OF_BUFFER_CHAR;
  455.   b->yy_ch_buf[size+2] = YY_END_OF_BUFFER_CHAR;
  456.     b->yy_n_chars = size+1;
  457.   b->yy_buf_pos = &b->yy_ch_buf[1];
  458.  
  459.   b->yy_eof_status = EOF_NOT_SEEN;
  460.  
  461.   return ( b );
  462. }
  463.  
  464.  
  465.  
  466. void
  467. DEFUN(lex_redirect,( string),
  468.     CONST  char *string)
  469. {
  470.   YY_BUFFER_STATE tmp;
  471.  
  472.   int len = strlen(string);
  473.   yy_init = 0  ;  
  474.   if (include_stack_ptr >= MAX_INCLUDE_DEPTH) 
  475.   {
  476.     einfo("%F: macros nested too deeply");
  477.   }
  478.   file_name_stack[include_stack_ptr] = "redirect";
  479.   include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;
  480.   include_stack_ptr++;
  481.   tmp =   yy_create_string_buffer(string, len);
  482.   
  483.   yy_switch_to_buffer(tmp);
  484.   BEGIN(COMMAND);
  485.   yyout = stdout;
  486. }
  487.  
  488. int state_stack[20];
  489. int *state_stack_p = state_stack;
  490.  
  491. void
  492. DEFUN_VOID(ldlex_script)
  493. {
  494.   *(state_stack_p)++ = yy_start;
  495.  
  496.   BEGIN(SCRIPT);
  497. }
  498.  
  499.  
  500. void
  501. DEFUN_VOID(ldlex_mri_script)
  502. {
  503.   *(state_stack_p)++ = yy_start;
  504.   BEGIN(MRI);
  505. }
  506.  
  507. void
  508. DEFUN_VOID(ldlex_defsym)
  509. {
  510.   *(state_stack_p)++ = yy_start;
  511.   BEGIN(DEFSYMEXP);
  512. }
  513.        
  514. void
  515. DEFUN_VOID(ldlex_expression)
  516. {
  517.   *(state_stack_p)++ = yy_start;
  518.   BEGIN(EXPRESSION);
  519.  
  520. }
  521. void
  522. DEFUN_VOID(ldlex_both)
  523. {
  524.   *(state_stack_p)++ = yy_start;
  525.   BEGIN(BOTH);
  526. }
  527. void
  528. DEFUN_VOID(ldlex_command)
  529. {
  530.   *(state_stack_p)++ = yy_start;
  531.   BEGIN(COMMAND);
  532. }
  533.  
  534. void
  535. DEFUN_VOID(ldlex_popstate)
  536. {
  537.   yy_start = *(--state_stack_p);
  538. }
  539.  
  540. yy_input(buf, result, max_size)
  541. char *buf;
  542. int *result;
  543. int max_size;
  544. {
  545.   *result = 0; 
  546.   if (yy_current_buffer->yy_input_file)
  547.   {
  548.     if (yyin)
  549.      if ( (*result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) 
  550.       YY_FATAL_ERROR( "read() in flex scanner failed" );
  551.   }
  552. }
  553.  
  554. static
  555. comment()
  556. {
  557.   int c;
  558.   while (1)
  559.   {
  560.     c = input();
  561.     while (c !='*' && c != EOF) 
  562.     {
  563.       if (c == '\n') lineno++;
  564.       c = input();
  565.     }
  566.  
  567.  
  568.     if (c == '*')
  569.     {
  570.       c = input();
  571.       while ( c == '*')
  572.        c = input();
  573.       if ( c == '/' )
  574.        break;            /* found the end */
  575.     }
  576.  
  577.     if ( c == EOF )
  578.     {
  579.       einfo( "%F%P :EOF in comment");
  580.       break;
  581.     }
  582.   }
  583. }
  584.