ld/deffilep.y

   1 %{ /* deffilep.y - parser for .def files */
   2
   3 /*   Copyright 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
   4      2007, 2009 Free Software Foundation, Inc.
   5
   6      This file is part of GNU Binutils.
   7
   8      This program is free software; you can redistribute it and/or modify
   9      it under the terms of the GNU General Public License as published by
  10      the Free Software Foundation; either version 3 of the License, or
  11      (at your option) any later version.
  12
  13      This program is distributed in the hope that it will be useful,
  14      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16      GNU General Public License for more details.
  17
  18      You should have received a copy of the GNU General Public License
  19      along with this program; if not, write to the Free Software
  20      Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21      MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "libiberty.h"
  25 #include "safe-ctype.h"
  26 #include "bfd.h"
  27 #include "ld.h"
  28 #include "ldmisc.h"
  29 #include "deffile.h"
  30
  31 #define TRACE 0
  32
  33 #define ROUND_UP(a, b) (((a)+((b)-1))&~((b)-1))
  34
  35 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
  36    as well as gratuitiously global symbol names, so we can have multiple
  37    yacc generated parsers in ld.  Note that these are only the variables
  38    produced by yacc.  If other parser generators (bison, byacc, etc) produce
  39    additional global names that conflict at link time, then those parser
  40    generators need to be fixed instead of adding those names to this list.  */
  41
  42 #define yymaxdepth def_maxdepth
  43 #define yyparse def_parse
  44 #define yylex   def_lex
  45 #define yyerror def_error
  46 #define yylval  def_lval
  47 #define yychar  def_char
  48 #define yydebug def_debug
  49 #define yypact  def_pact
  50 #define yyr1    def_r1
  51 #define yyr2    def_r2
  52 #define yydef   def_def
  53 #define yychk   def_chk
  54 #define yypgo   def_pgo
  55 #define yyact   def_act
  56 #define yyexca  def_exca
  57 #define yyerrflag def_errflag
  58 #define yynerrs def_nerrs
  59 #define yyps    def_ps
  60 #define yypv    def_pv
  61 #define yys     def_s
  62 #define yy_yys  def_yys
  63 #define yystate def_state
  64 #define yytmp   def_tmp
  65 #define yyv     def_v
  66 #define yy_yyv  def_yyv
  67 #define yyval   def_val
  68 #define yylloc  def_lloc
  69 #define yyreds  def_reds                /* With YYDEBUG defined.  */
  70 #define yytoks  def_toks                /* With YYDEBUG defined.  */
  71 #define yylhs   def_yylhs
  72 #define yylen   def_yylen
  73 #define yydefred def_yydefred
  74 #define yydgoto def_yydgoto
  75 #define yysindex def_yysindex
  76 #define yyrindex def_yyrindex
  77 #define yygindex def_yygindex
  78 #define yytable  def_yytable
  79 #define yycheck  def_yycheck
  80
  81 static void def_description (const char *);
  82 static void def_exports (const char *, const char *, int, int, const char *);
  83 static void def_heapsize (int, int);
  84 static void def_import (const char *, const char *, const char *, const char *,
  85                         int, const char *);
  86 static void def_image_name (const char *, int, int);
  87 static void def_section (const char *, int);
  88 static void def_section_alt (const char *, const char *);
  89 static void def_stacksize (int, int);
  90 static void def_version (int, int);
  91 static void def_directive (char *);
  92 static void def_aligncomm (char *str, int align);
  93 static int def_parse (void);
  94 static int def_error (const char *);
  95 static int def_lex (void);
  96
  97 static int lex_forced_token = 0;
  98 static const char *lex_parse_string = 0;
  99 static const char *lex_parse_string_end = 0;
 100
 101 %}
 102
 103 %union {
 104   char *id;
 105   int number;
 106   char *digits;
 107 };
 108
 109 %token NAME LIBRARY DESCRIPTION STACKSIZE_K HEAPSIZE CODE DATAU DATAL
 110 %token SECTIONS EXPORTS IMPORTS VERSIONK BASE CONSTANTU CONSTANTL
 111 %token PRIVATEU PRIVATEL ALIGNCOMM
 112 %token READ WRITE EXECUTE SHARED NONAMEU NONAMEL DIRECTIVE EQUAL
 113 %token <id> ID
 114 %token <digits> DIGITS
 115 %type  <number> NUMBER
 116 %type  <digits> opt_digits
 117 %type  <number> opt_base opt_ordinal
 118 %type  <number> attr attr_list opt_number exp_opt_list exp_opt
 119 %type  <id> opt_name opt_equal_name dot_name anylang_id opt_id
 120 %type  <id> opt_equalequal_name
 121
 122 %%
 123
 124 start: start command
 125         | command
 126         ;
 127
 128 command:
 129                 NAME opt_name opt_base { def_image_name ($2, $3, 0); }
 130         |       LIBRARY opt_name opt_base { def_image_name ($2, $3, 1); }
 131         |       DESCRIPTION ID { def_description ($2);}
 132         |       STACKSIZE_K NUMBER opt_number { def_stacksize ($2, $3);}
 133         |       HEAPSIZE NUMBER opt_number { def_heapsize ($2, $3);}
 134         |       CODE attr_list { def_section ("CODE", $2);}
 135         |       DATAU attr_list  { def_section ("DATA", $2);}
 136         |       SECTIONS seclist
 137         |       EXPORTS explist
 138         |       IMPORTS implist
 139         |       VERSIONK NUMBER { def_version ($2, 0);}
 140         |       VERSIONK NUMBER '.' NUMBER { def_version ($2, $4);}
 141         |       DIRECTIVE ID { def_directive ($2);}
 142         |       ALIGNCOMM anylang_id ',' NUMBER { def_aligncomm ($2, $4);}
 143         ;
 144
 145
 146 explist:
 147                 /* EMPTY */
 148         |       expline
 149         |       explist expline
 150         ;
 151
 152 expline:
 153                 /* The opt_comma is necessary to support both the usual
 154                   DEF file syntax as well as .drectve syntax which
 155                   mandates <expsym>,<expoptlist>.  */
 156                 dot_name opt_equal_name opt_ordinal opt_comma exp_opt_list opt_comma opt_equalequal_name
 157                         { def_exports ($1, $2, $3, $5, $7); }
 158         ;
 159 exp_opt_list:
 160                 /* The opt_comma is necessary to support both the usual
 161                    DEF file syntax as well as .drectve syntax which
 162                    allows for comma separated opt list.  */
 163                 exp_opt opt_comma exp_opt_list { $$ = $1 | $3; }
 164         |       { $$ = 0; }
 165         ;
 166 exp_opt:
 167                 NONAMEU         { $$ = 1; }
 168         |       NONAMEL         { $$ = 1; }
 169         |       CONSTANTU       { $$ = 2; }
 170         |       CONSTANTL       { $$ = 2; }
 171         |       DATAU           { $$ = 4; }
 172         |       DATAL           { $$ = 4; }
 173         |       PRIVATEU        { $$ = 8; }
 174         |       PRIVATEL        { $$ = 8; }
 175         ;
 176 implist:
 177                 implist impline
 178         |       impline
 179         ;
 180
 181 impline:
 182                ID '=' ID '.' ID '.' ID opt_equalequal_name
 183                  { def_import ($1, $3, $5, $7, -1, $8); }
 184        |       ID '=' ID '.' ID '.' NUMBER opt_equalequal_name
 185                                  { def_import ($1, $3, $5,  0, $7, $8); }
 186        |       ID '=' ID '.' ID opt_equalequal_name
 187                  { def_import ($1, $3,  0, $5, -1, $6); }
 188        |       ID '=' ID '.' NUMBER opt_equalequal_name
 189                  { def_import ($1, $3,  0,  0, $5, $6); }
 190        |       ID '.' ID '.' ID opt_equalequal_name
 191                  { def_import( 0, $1, $3, $5, -1, $6); }
 192        |       ID '.' ID opt_equalequal_name
 193                  { def_import ( 0, $1,  0, $3, -1, $4); }
 194 ;
 195
 196 seclist:
 197                 seclist secline
 198         |       secline
 199         ;
 200
 201 secline:
 202         ID attr_list { def_section ($1, $2);}
 203         | ID ID { def_section_alt ($1, $2);}
 204         ;
 205
 206 attr_list:
 207         attr_list opt_comma attr { $$ = $1 | $3; }
 208         | attr { $$ = $1; }
 209         ;
 210
 211 opt_comma:
 212         ','
 213         |
 214         ;
 215 opt_number: ',' NUMBER { $$=$2;}
 216         |          { $$=-1;}
 217         ;
 218
 219 attr:
 220                 READ    { $$ = 1;}
 221         |       WRITE   { $$ = 2;}
 222         |       EXECUTE { $$=4;}
 223         |       SHARED  { $$=8;}
 224         ;
 225
 226 opt_name: ID            { $$ = $1; }
 227         | '.' ID
 228           {
 229             char *name = xmalloc (strlen ($2) + 2);
 230             sprintf (name, ".%s", $2);
 231             $$ = name;
 232           }
 233         | ID '.' ID
 234           {
 235             char *name = xmalloc (strlen ($1) + 1 + strlen ($3) + 1);
 236             sprintf (name, "%s.%s", $1, $3);
 237             $$ = name;
 238           }
 239         |               { $$ = ""; }
 240         ;
 241
 242 opt_equalequal_name: EQUAL ID   { $$ = $2; }
 243         |                                                       { $$ = 0; }
 244         ;
 245
 246 opt_ordinal:
 247           '@' NUMBER     { $$ = $2;}
 248         |                { $$ = -1;}
 249         ;
 250
 251 opt_equal_name:
 252           '=' dot_name  { $$ = $2; }
 253         |               { $$ =  0; }
 254         ;
 255
 256 opt_base: BASE  '=' NUMBER      { $$ = $3;}
 257         |       { $$ = -1;}
 258         ;
 259
 260 dot_name: ID            { $$ = $1; }
 261         | '.' ID
 262           {
 263             char *name = xmalloc (strlen ($2) + 2);
 264             sprintf (name, ".%s", $2);
 265             $$ = name;
 266           }
 267         | dot_name '.' ID
 268           {
 269             char *name = xmalloc (strlen ($1) + 1 + strlen ($3) + 1);
 270             sprintf (name, "%s.%s", $1, $3);
 271             $$ = name;
 272           }
 273         ;
 274
 275 anylang_id: ID          { $$ = $1; }
 276         | '.' ID
 277           {
 278             char *id = xmalloc (strlen ($2) + 2);
 279             sprintf (id, ".%s", $2);
 280             $$ = id;
 281           }
 282         | anylang_id '.' opt_digits opt_id
 283           {
 284             char *id = xmalloc (strlen ($1) + 1 + strlen ($3) + strlen ($4) + 1);
 285             sprintf (id, "%s.%s%s", $1, $3, $4);
 286             $$ = id;
 287           }
 288         ;
 289
 290 opt_digits: DIGITS      { $$ = $1; }
 291         |               { $$ = ""; }
 292         ;
 293
 294 opt_id: ID              { $$ = $1; }
 295         |               { $$ = ""; }
 296         ;
 297
 298 NUMBER: DIGITS          { $$ = strtoul ($1, 0, 0); }
 299
 300 %%
 301
 302 /*****************************************************************************
 303  API
 304  *****************************************************************************/
 305
 306 static FILE *the_file;
 307 static const char *def_filename;
 308 static int linenumber;
 309 static def_file *def;
 310 static int saw_newline;
 311
 312 struct directive
 313   {
 314     struct directive *next;
 315     char *name;
 316     int len;
 317   };
 318
 319 static struct directive *directives = 0;
 320
 321 def_file *
 322 def_file_empty (void)
 323 {
 324   def_file *rv = xmalloc (sizeof (def_file));
 325   memset (rv, 0, sizeof (def_file));
 326   rv->is_dll = -1;
 327   rv->base_address = (bfd_vma) -1;
 328   rv->stack_reserve = rv->stack_commit = -1;
 329   rv->heap_reserve = rv->heap_commit = -1;
 330   rv->version_major = rv->version_minor = -1;
 331   return rv;
 332 }
 333
 334 def_file *
 335 def_file_parse (const char *filename, def_file *add_to)
 336 {
 337   struct directive *d;
 338
 339   the_file = fopen (filename, "r");
 340   def_filename = filename;
 341   linenumber = 1;
 342   if (!the_file)
 343     {
 344       perror (filename);
 345       return 0;
 346     }
 347   if (add_to)
 348     {
 349       def = add_to;
 350     }
 351   else
 352     {
 353       def = def_file_empty ();
 354     }
 355
 356   saw_newline = 1;
 357   if (def_parse ())
 358     {
 359       def_file_free (def);
 360       fclose (the_file);
 361       return 0;
 362     }
 363
 364   fclose (the_file);
 365
 366   for (d = directives; d; d = d->next)
 367     {
 368 #if TRACE
 369       printf ("Adding directive %08x `%s'\n", d->name, d->name);
 370 #endif
 371       def_file_add_directive (def, d->name, d->len);
 372     }
 373
 374   return def;
 375 }
 376
 377 void
 378 def_file_free (def_file *fdef)
 379 {
 380   int i;
 381
 382   if (!fdef)
 383     return;
 384   if (fdef->name)
 385     free (fdef->name);
 386   if (fdef->description)
 387     free (fdef->description);
 388
 389   if (fdef->section_defs)
 390     {
 391       for (i = 0; i < fdef->num_section_defs; i++)
 392         {
 393           if (fdef->section_defs[i].name)
 394             free (fdef->section_defs[i].name);
 395           if (fdef->section_defs[i].class)
 396             free (fdef->section_defs[i].class);
 397         }
 398       free (fdef->section_defs);
 399     }
 400
 401   if (fdef->exports)
 402     {
 403       for (i = 0; i < fdef->num_exports; i++)
 404         {
 405           if (fdef->exports[i].internal_name
 406               && fdef->exports[i].internal_name != fdef->exports[i].name)
 407             free (fdef->exports[i].internal_name);
 408           if (fdef->exports[i].name)
 409             free (fdef->exports[i].name);
 410           if (fdef->exports[i].its_name)
 411             free (fdef->exports[i].its_name);
 412         }
 413       free (fdef->exports);
 414     }
 415
 416   if (fdef->imports)
 417     {
 418       for (i = 0; i < fdef->num_imports; i++)
 419         {
 420           if (fdef->imports[i].internal_name
 421               && fdef->imports[i].internal_name != fdef->imports[i].name)
 422             free (fdef->imports[i].internal_name);
 423           if (fdef->imports[i].name)
 424             free (fdef->imports[i].name);
 425           if (fdef->imports[i].its_name)
 426             free (fdef->imports[i].its_name);
 427         }
 428       free (fdef->imports);
 429     }
 430
 431   while (fdef->modules)
 432     {
 433       def_file_module *m = fdef->modules;
 434
 435       fdef->modules = fdef->modules->next;
 436       free (m);
 437     }
 438
 439   while (fdef->aligncomms)
 440     {
 441       def_file_aligncomm *c = fdef->aligncomms;
 442
 443       fdef->aligncomms = fdef->aligncomms->next;
 444       free (c->symbol_name);
 445       free (c);
 446     }
 447
 448   free (fdef);
 449 }
 450
 451 #ifdef DEF_FILE_PRINT
 452 void
 453 def_file_print (FILE *file, def_file *fdef)
 454 {
 455   int i;
 456
 457   fprintf (file, ">>>> def_file at 0x%08x\n", fdef);
 458   if (fdef->name)
 459     fprintf (file, "  name: %s\n", fdef->name ? fdef->name : "(unspecified)");
 460   if (fdef->is_dll != -1)
 461     fprintf (file, "  is dll: %s\n", fdef->is_dll ? "yes" : "no");
 462   if (fdef->base_address != (bfd_vma) -1)
 463     fprintf (file, "  base address: 0x%08x\n", fdef->base_address);
 464   if (fdef->description)
 465     fprintf (file, "  description: `%s'\n", fdef->description);
 466   if (fdef->stack_reserve != -1)
 467     fprintf (file, "  stack reserve: 0x%08x\n", fdef->stack_reserve);
 468   if (fdef->stack_commit != -1)
 469     fprintf (file, "  stack commit: 0x%08x\n", fdef->stack_commit);
 470   if (fdef->heap_reserve != -1)
 471     fprintf (file, "  heap reserve: 0x%08x\n", fdef->heap_reserve);
 472   if (fdef->heap_commit != -1)
 473     fprintf (file, "  heap commit: 0x%08x\n", fdef->heap_commit);
 474
 475   if (fdef->num_section_defs > 0)
 476     {
 477       fprintf (file, "  section defs:\n");
 478
 479       for (i = 0; i < fdef->num_section_defs; i++)
 480         {
 481           fprintf (file, "    name: `%s', class: `%s', flags:",
 482                    fdef->section_defs[i].name, fdef->section_defs[i].class);
 483           if (fdef->section_defs[i].flag_read)
 484             fprintf (file, " R");
 485           if (fdef->section_defs[i].flag_write)
 486             fprintf (file, " W");
 487           if (fdef->section_defs[i].flag_execute)
 488             fprintf (file, " X");
 489           if (fdef->section_defs[i].flag_shared)
 490             fprintf (file, " S");
 491           fprintf (file, "\n");
 492         }
 493     }
 494
 495   if (fdef->num_exports > 0)
 496     {
 497       fprintf (file, "  exports:\n");
 498
 499       for (i = 0; i < fdef->num_exports; i++)
 500         {
 501           fprintf (file, "    name: `%s', int: `%s', ordinal: %d, flags:",
 502                    fdef->exports[i].name, fdef->exports[i].internal_name,
 503                    fdef->exports[i].ordinal);
 504           if (fdef->exports[i].flag_private)
 505             fprintf (file, " P");
 506           if (fdef->exports[i].flag_constant)
 507             fprintf (file, " C");
 508           if (fdef->exports[i].flag_noname)
 509             fprintf (file, " N");
 510           if (fdef->exports[i].flag_data)
 511             fprintf (file, " D");
 512           fprintf (file, "\n");
 513         }
 514     }
 515
 516   if (fdef->num_imports > 0)
 517     {
 518       fprintf (file, "  imports:\n");
 519
 520       for (i = 0; i < fdef->num_imports; i++)
 521         {
 522           fprintf (file, "    int: %s, from: `%s', name: `%s', ordinal: %d\n",
 523                    fdef->imports[i].internal_name,
 524                    fdef->imports[i].module,
 525                    fdef->imports[i].name,
 526                    fdef->imports[i].ordinal);
 527         }
 528     }
 529
 530   if (fdef->version_major != -1)
 531     fprintf (file, "  version: %d.%d\n", fdef->version_major, fdef->version_minor);
 532
 533   fprintf (file, "<<<< def_file at 0x%08x\n", fdef);
 534 }
 535 #endif
 536
 537 def_file_export *
 538 def_file_add_export (def_file *fdef,
 539                      const char *external_name,
 540                      const char *internal_name,
 541                      int ordinal,
 542                      const char *its_name)
 543 {
 544   def_file_export *e;
 545   int max_exports = ROUND_UP(fdef->num_exports, 32);
 546
 547   if (fdef->num_exports >= max_exports)
 548     {
 549       max_exports = ROUND_UP(fdef->num_exports + 1, 32);
 550       if (fdef->exports)
 551         fdef->exports = xrealloc (fdef->exports,
 552                                  max_exports * sizeof (def_file_export));
 553       else
 554         fdef->exports = xmalloc (max_exports * sizeof (def_file_export));
 555     }
 556   e = fdef->exports + fdef->num_exports;
 557   memset (e, 0, sizeof (def_file_export));
 558   if (internal_name && !external_name)
 559     external_name = internal_name;
 560   if (external_name && !internal_name)
 561     internal_name = external_name;
 562   e->name = xstrdup (external_name);
 563   e->internal_name = xstrdup (internal_name);
 564   e->its_name = (its_name ? xstrdup (its_name) : NULL);
 565   e->ordinal = ordinal;
 566   fdef->num_exports++;
 567   return e;
 568 }
 569
 570 def_file_module *
 571 def_get_module (def_file *fdef, const char *name)
 572 {
 573   def_file_module *s;
 574
 575   for (s = fdef->modules; s; s = s->next)
 576     if (strcmp (s->name, name) == 0)
 577       return s;
 578
 579   return NULL;
 580 }
 581
 582 static def_file_module *
 583 def_stash_module (def_file *fdef, const char *name)
 584 {
 585   def_file_module *s;
 586
 587   if ((s = def_get_module (fdef, name)) != NULL)
 588       return s;
 589   s = xmalloc (sizeof (def_file_module) + strlen (name));
 590   s->next = fdef->modules;
 591   fdef->modules = s;
 592   s->user_data = 0;
 593   strcpy (s->name, name);
 594   return s;
 595 }
 596
 597 def_file_import *
 598 def_file_add_import (def_file *fdef,
 599                      const char *name,
 600                      const char *module,
 601                      int ordinal,
 602                      const char *internal_name,
 603                      const char *its_name)
 604 {
 605   def_file_import *i;
 606   int max_imports = ROUND_UP (fdef->num_imports, 16);
 607
 608   if (fdef->num_imports >= max_imports)
 609     {
 610       max_imports = ROUND_UP (fdef->num_imports+1, 16);
 611
 612       if (fdef->imports)
 613         fdef->imports = xrealloc (fdef->imports,
 614                                  max_imports * sizeof (def_file_import));
 615       else
 616         fdef->imports = xmalloc (max_imports * sizeof (def_file_import));
 617     }
 618   i = fdef->imports + fdef->num_imports;
 619   memset (i, 0, sizeof (def_file_import));
 620   if (name)
 621     i->name = xstrdup (name);
 622   if (module)
 623     i->module = def_stash_module (fdef, module);
 624   i->ordinal = ordinal;
 625   if (internal_name)
 626     i->internal_name = xstrdup (internal_name);
 627   else
 628     i->internal_name = i->name;
 629   i->its_name = (its_name ? xstrdup (its_name) : NULL);
 630   fdef->num_imports++;
 631
 632   return i;
 633 }
 634
 635 struct
 636 {
 637   char *param;
 638   int token;
 639 }
 640 diropts[] =
 641 {
 642   { "-heap", HEAPSIZE },
 643   { "-stack", STACKSIZE_K },
 644   { "-attr", SECTIONS },
 645   { "-export", EXPORTS },
 646   { "-aligncomm", ALIGNCOMM },
 647   { 0, 0 }
 648 };
 649
 650 void
 651 def_file_add_directive (def_file *my_def, const char *param, int len)
 652 {
 653   def_file *save_def = def;
 654   const char *pend = param + len;
 655   char * tend = (char *) param;
 656   int i;
 657
 658   def = my_def;
 659
 660   while (param < pend)
 661     {
 662       while (param < pend
 663              && (ISSPACE (*param) || *param == '\n' || *param == 0))
 664         param++;
 665
 666       if (param == pend)
 667         break;
 668
 669       /* Scan forward until we encounter any of:
 670           - the end of the buffer
 671           - the start of a new option
 672           - a newline seperating options
 673           - a NUL seperating options.  */
 674       for (tend = (char *) (param + 1);
 675            (tend < pend
 676             && !(ISSPACE (tend[-1]) && *tend == '-')
 677             && *tend != '\n' && *tend != 0);
 678            tend++)
 679         ;
 680
 681       for (i = 0; diropts[i].param; i++)
 682         {
 683           len = strlen (diropts[i].param);
 684
 685           if (tend - param >= len
 686               && strncmp (param, diropts[i].param, len) == 0
 687               && (param[len] == ':' || param[len] == ' '))
 688             {
 689               lex_parse_string_end = tend;
 690               lex_parse_string = param + len + 1;
 691               lex_forced_token = diropts[i].token;
 692               saw_newline = 0;
 693               if (def_parse ())
 694                 continue;
 695               break;
 696             }
 697         }
 698
 699       if (!diropts[i].param)
 700         {
 701           char saved;
 702
 703           saved = * tend;
 704           * tend = 0;
 705           /* xgettext:c-format */
 706           einfo (_("Warning: .drectve `%s' unrecognized\n"), param);
 707           * tend = saved;
 708         }
 709
 710       lex_parse_string = 0;
 711       param = tend;
 712     }
 713
 714   def = save_def;
 715 }
 716
 717 /* Parser Callbacks.  */
 718
 719 static void
 720 def_image_name (const char *name, int base, int is_dll)
 721 {
 722   /* If a LIBRARY or NAME statement is specified without a name, there is nothing
 723      to do here.  We retain the output filename specified on command line.  */
 724   if (*name)
 725     {
 726       const char* image_name = lbasename (name);
 727
 728       if (image_name != name)
 729         einfo ("%s:%d: Warning: path components stripped from %s, '%s'\n",
 730                def_filename, linenumber, is_dll ? "LIBRARY" : "NAME",
 731                name);
 732       if (def->name)
 733         free (def->name);
 734       /* Append the default suffix, if none specified.  */
 735       if (strchr (image_name, '.') == 0)
 736         {
 737           const char * suffix = is_dll ? ".dll" : ".exe";
 738
 739           def->name = xmalloc (strlen (image_name) + strlen (suffix) + 1);
 740           sprintf (def->name, "%s%s", image_name, suffix);
 741         }
 742       else
 743         def->name = xstrdup (image_name);
 744     }
 745
 746   /* Honor a BASE address statement, even if LIBRARY string is empty.  */
 747   def->base_address = base;
 748   def->is_dll = is_dll;
 749 }
 750
 751 static void
 752 def_description (const char *text)
 753 {
 754   int len = def->description ? strlen (def->description) : 0;
 755
 756   len += strlen (text) + 1;
 757   if (def->description)
 758     {
 759       def->description = xrealloc (def->description, len);
 760       strcat (def->description, text);
 761     }
 762   else
 763     {
 764       def->description = xmalloc (len);
 765       strcpy (def->description, text);
 766     }
 767 }
 768
 769 static void
 770 def_stacksize (int reserve, int commit)
 771 {
 772   def->stack_reserve = reserve;
 773   def->stack_commit = commit;
 774 }
 775
 776 static void
 777 def_heapsize (int reserve, int commit)
 778 {
 779   def->heap_reserve = reserve;
 780   def->heap_commit = commit;
 781 }
 782
 783 static void
 784 def_section (const char *name, int attr)
 785 {
 786   def_file_section *s;
 787   int max_sections = ROUND_UP (def->num_section_defs, 4);
 788
 789   if (def->num_section_defs >= max_sections)
 790     {
 791       max_sections = ROUND_UP (def->num_section_defs+1, 4);
 792
 793       if (def->section_defs)
 794         def->section_defs = xrealloc (def->section_defs,
 795                                       max_sections * sizeof (def_file_import));
 796       else
 797         def->section_defs = xmalloc (max_sections * sizeof (def_file_import));
 798     }
 799   s = def->section_defs + def->num_section_defs;
 800   memset (s, 0, sizeof (def_file_section));
 801   s->name = xstrdup (name);
 802   if (attr & 1)
 803     s->flag_read = 1;
 804   if (attr & 2)
 805     s->flag_write = 1;
 806   if (attr & 4)
 807     s->flag_execute = 1;
 808   if (attr & 8)
 809     s->flag_shared = 1;
 810
 811   def->num_section_defs++;
 812 }
 813
 814 static void
 815 def_section_alt (const char *name, const char *attr)
 816 {
 817   int aval = 0;
 818
 819   for (; *attr; attr++)
 820     {
 821       switch (*attr)
 822         {
 823         case 'R':
 824         case 'r':
 825           aval |= 1;
 826           break;
 827         case 'W':
 828         case 'w':
 829           aval |= 2;
 830           break;
 831         case 'X':
 832         case 'x':
 833           aval |= 4;
 834           break;
 835         case 'S':
 836         case 's':
 837           aval |= 8;
 838           break;
 839         }
 840     }
 841   def_section (name, aval);
 842 }
 843
 844 static void
 845 def_exports (const char *external_name,
 846              const char *internal_name,
 847              int ordinal,
 848              int flags,
 849              const char *its_name)
 850 {
 851   def_file_export *dfe;
 852
 853   if (!internal_name && external_name)
 854     internal_name = external_name;
 855 #if TRACE
 856   printf ("def_exports, ext=%s int=%s\n", external_name, internal_name);
 857 #endif
 858
 859   dfe = def_file_add_export (def, external_name, internal_name, ordinal,
 860                                                          its_name);
 861   if (flags & 1)
 862     dfe->flag_noname = 1;
 863   if (flags & 2)
 864     dfe->flag_constant = 1;
 865   if (flags & 4)
 866     dfe->flag_data = 1;
 867   if (flags & 8)
 868     dfe->flag_private = 1;
 869 }
 870
 871 static void
 872 def_import (const char *internal_name,
 873             const char *module,
 874             const char *dllext,
 875             const char *name,
 876             int ordinal,
 877             const char *its_name)
 878 {
 879   char *buf = 0;
 880   const char *ext = dllext ? dllext : "dll";
 881
 882   buf = xmalloc (strlen (module) + strlen (ext) + 2);
 883   sprintf (buf, "%s.%s", module, ext);
 884   module = buf;
 885
 886   def_file_add_import (def, name, module, ordinal, internal_name, its_name);
 887   if (buf)
 888     free (buf);
 889 }
 890
 891 static void
 892 def_version (int major, int minor)
 893 {
 894   def->version_major = major;
 895   def->version_minor = minor;
 896 }
 897
 898 static void
 899 def_directive (char *str)
 900 {
 901   struct directive *d = xmalloc (sizeof (struct directive));
 902
 903   d->next = directives;
 904   directives = d;
 905   d->name = xstrdup (str);
 906   d->len = strlen (str);
 907 }
 908
 909 static void
 910 def_aligncomm (char *str, int align)
 911 {
 912   def_file_aligncomm *c = xmalloc (sizeof (def_file_aligncomm));
 913
 914   c->symbol_name = xstrdup (str);
 915   c->alignment = (unsigned int) align;
 916
 917   c->next = def->aligncomms;
 918   def->aligncomms = c;
 919 }
 920
 921 static int
 922 def_error (const char *err)
 923 {
 924   einfo ("%P: %s:%d: %s\n",
 925          def_filename ? def_filename : "<unknown-file>", linenumber, err);
 926   return 0;
 927 }
 928
 929
 930 /* Lexical Scanner.  */
 931
 932 #undef TRACE
 933 #define TRACE 0
 934
 935 /* Never freed, but always reused as needed, so no real leak.  */
 936 static char *buffer = 0;
 937 static int buflen = 0;
 938 static int bufptr = 0;
 939
 940 static void
 941 put_buf (char c)
 942 {
 943   if (bufptr == buflen)
 944     {
 945       buflen += 50;             /* overly reasonable, eh?  */
 946       if (buffer)
 947         buffer = xrealloc (buffer, buflen + 1);
 948       else
 949         buffer = xmalloc (buflen + 1);
 950     }
 951   buffer[bufptr++] = c;
 952   buffer[bufptr] = 0;           /* not optimal, but very convenient.  */
 953 }
 954
 955 static struct
 956 {
 957   char *name;
 958   int token;
 959 }
 960 tokens[] =
 961 {
 962   { "BASE", BASE },
 963   { "CODE", CODE },
 964   { "CONSTANT", CONSTANTU },
 965   { "constant", CONSTANTL },
 966   { "DATA", DATAU },
 967   { "data", DATAL },
 968   { "DESCRIPTION", DESCRIPTION },
 969   { "DIRECTIVE", DIRECTIVE },
 970   { "EXECUTE", EXECUTE },
 971   { "EXPORTS", EXPORTS },
 972   { "HEAPSIZE", HEAPSIZE },
 973   { "IMPORTS", IMPORTS },
 974   { "LIBRARY", LIBRARY },
 975   { "NAME", NAME },
 976   { "NONAME", NONAMEU },
 977   { "noname", NONAMEL },
 978   { "PRIVATE", PRIVATEU },
 979   { "private", PRIVATEL },
 980   { "READ", READ },
 981   { "SECTIONS", SECTIONS },
 982   { "SEGMENTS", SECTIONS },
 983   { "SHARED", SHARED },
 984   { "STACKSIZE", STACKSIZE_K },
 985   { "VERSION", VERSIONK },
 986   { "WRITE", WRITE },
 987   { 0, 0 }
 988 };
 989
 990 static int
 991 def_getc (void)
 992 {
 993   int rv;
 994
 995   if (lex_parse_string)
 996     {
 997       if (lex_parse_string >= lex_parse_string_end)
 998         rv = EOF;
 999       else
1000         rv = *lex_parse_string++;
1001     }
1002   else
1003     {
1004       rv = fgetc (the_file);
1005     }
1006   if (rv == '\n')
1007     saw_newline = 1;
1008   return rv;
1009 }
1010
1011 static int
1012 def_ungetc (int c)
1013 {
1014   if (lex_parse_string)
1015     {
1016       lex_parse_string--;
1017       return c;
1018     }
1019   else
1020     return ungetc (c, the_file);
1021 }
1022
1023 static int
1024 def_lex (void)
1025 {
1026   int c, i, q;
1027
1028   if (lex_forced_token)
1029     {
1030       i = lex_forced_token;
1031       lex_forced_token = 0;
1032 #if TRACE
1033       printf ("lex: forcing token %d\n", i);
1034 #endif
1035       return i;
1036     }
1037
1038   c = def_getc ();
1039
1040   /* Trim leading whitespace.  */
1041   while (c != EOF && (c == ' ' || c == '\t') && saw_newline)
1042     c = def_getc ();
1043
1044   if (c == EOF)
1045     {
1046 #if TRACE
1047       printf ("lex: EOF\n");
1048 #endif
1049       return 0;
1050     }
1051
1052   if (saw_newline && c == ';')
1053     {
1054       do
1055         {
1056           c = def_getc ();
1057         }
1058       while (c != EOF && c != '\n');
1059       if (c == '\n')
1060         return def_lex ();
1061       return 0;
1062     }
1063
1064   /* Must be something else.  */
1065   saw_newline = 0;
1066
1067   if (ISDIGIT (c))
1068     {
1069       bufptr = 0;
1070       while (c != EOF && (ISXDIGIT (c) || (c == 'x')))
1071         {
1072           put_buf (c);
1073           c = def_getc ();
1074         }
1075       if (c != EOF)
1076         def_ungetc (c);
1077       yylval.digits = xstrdup (buffer);
1078 #if TRACE
1079       printf ("lex: `%s' returns DIGITS\n", buffer);
1080 #endif
1081       return DIGITS;
1082     }
1083
1084   if (ISALPHA (c) || strchr ("$:-_?@", c))
1085     {
1086       bufptr = 0;
1087       q = c;
1088       put_buf (c);
1089       c = def_getc ();
1090
1091       if (q == '@')
1092         {
1093           if (ISBLANK (c) ) /* '@' followed by whitespace.  */
1094             return (q);
1095           else if (ISDIGIT (c)) /* '@' followed by digit.  */
1096             {
1097               def_ungetc (c);
1098               return (q);
1099             }
1100 #if TRACE
1101           printf ("lex: @ returns itself\n");
1102 #endif
1103         }
1104
1105       while (c != EOF && (ISALNUM (c) || strchr ("$:-_?/@<>", c)))
1106         {
1107           put_buf (c);
1108           c = def_getc ();
1109         }
1110       if (c != EOF)
1111         def_ungetc (c);
1112       if (ISALPHA (q)) /* Check for tokens.  */
1113         {
1114           for (i = 0; tokens[i].name; i++)
1115             if (strcmp (tokens[i].name, buffer) == 0)
1116               {
1117 #if TRACE
1118                 printf ("lex: `%s' is a string token\n", buffer);
1119 #endif
1120                 return tokens[i].token;
1121               }
1122         }
1123 #if TRACE
1124       printf ("lex: `%s' returns ID\n", buffer);
1125 #endif
1126       yylval.id = xstrdup (buffer);
1127       return ID;
1128     }
1129
1130   if (c == '\'' || c == '"')
1131     {
1132       q = c;
1133       c = def_getc ();
1134       bufptr = 0;
1135
1136       while (c != EOF && c != q)
1137         {
1138           put_buf (c);
1139           c = def_getc ();
1140         }
1141       yylval.id = xstrdup (buffer);
1142 #if TRACE
1143       printf ("lex: `%s' returns ID\n", buffer);
1144 #endif
1145       return ID;
1146     }
1147
1148   if ( c == '=')
1149     {
1150       c = def_getc ();
1151       if (c == '=')
1152         {
1153 #if TRACE
1154           printf ("lex: `==' returns EQUAL\n");
1155 #endif
1156                   return EQUAL;
1157         }
1158       def_ungetc (c);
1159 #if TRACE
1160       printf ("lex: `=' returns itself\n");
1161 #endif
1162       return '=';
1163     }
1164   if (c == '.' || c == ',')
1165     {
1166 #if TRACE
1167       printf ("lex: `%c' returns itself\n", c);
1168 #endif
1169       return c;
1170     }
1171
1172   if (c == '\n')
1173     {
1174       linenumber++;
1175       saw_newline = 1;
1176     }
1177
1178   /*printf ("lex: 0x%02x ignored\n", c); */
1179   return def_lex ();
1180 }