source: trunk/binutils/ld/deffilep.y@ 3020

Last change on this file since 3020 was 610, checked in by bird, 22 years ago

This commit was generated by cvs2svn to compensate for changes in r609,
which included commits to RCS files with non-trunk default branches.
  • Property cvs2svn:cvs-rev set to 1.1.1.2
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 23.6 KB
Line 
1%{ /* deffilep.y - parser for .def files */
2
3/* Copyright 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003
4 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22#include <stdio.h>
23#include "libiberty.h"
24#include "safe-ctype.h"
25#include "bfd.h"
26#include "sysdep.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
81static void def_description PARAMS ((const char *));
82static void def_exports PARAMS ((const char *, const char *, int, int));
83static void def_heapsize PARAMS ((int, int));
84static void def_import PARAMS ((const char *, const char *, const char *, const char *, int));
85static void def_library PARAMS ((const char *, int));
86static def_file_module *def_stash_module PARAMS ((def_file *, const char *));
87static void def_name PARAMS ((const char *, int));
88static void def_section PARAMS ((const char *, int));
89static void def_section_alt PARAMS ((const char *, const char *));
90static void def_stacksize PARAMS ((int, int));
91static void def_version PARAMS ((int, int));
92static void def_directive PARAMS ((char *));
93static int def_parse PARAMS ((void));
94static int def_error PARAMS ((const char *));
95static void put_buf PARAMS ((char));
96static int def_getc PARAMS ((void));
97static int def_ungetc PARAMS ((int));
98static int def_lex PARAMS ((void));
99
100static int lex_forced_token = 0;
101static const char *lex_parse_string = 0;
102static const char *lex_parse_string_end = 0;
103
104%}
105
106%union {
107 char *id;
108 int number;
109};
110
111%token NAME, LIBRARY, DESCRIPTION, STACKSIZE, HEAPSIZE, CODE, DATAU, DATAL
112%token SECTIONS, EXPORTS, IMPORTS, VERSIONK, BASE, CONSTANTU, CONSTANTL
113%token PRIVATEU, PRIVATEL
114%token READ WRITE EXECUTE SHARED NONAMEU NONAMEL DIRECTIVE
115%token <id> ID
116%token <number> NUMBER
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
120
121%%
122
123start: start command
124 | command
125 ;
126
127command:
128 NAME opt_name opt_base { def_name ($2, $3); }
129 | LIBRARY opt_name opt_base { def_library ($2, $3); }
130 | DESCRIPTION ID { def_description ($2);}
131 | STACKSIZE NUMBER opt_number { def_stacksize ($2, $3);}
132 | HEAPSIZE NUMBER opt_number { def_heapsize ($2, $3);}
133 | CODE attr_list { def_section ("CODE", $2);}
134 | DATAU attr_list { def_section ("DATA", $2);}
135 | SECTIONS seclist
136 | EXPORTS explist
137 | IMPORTS implist
138 | VERSIONK NUMBER { def_version ($2, 0);}
139 | VERSIONK NUMBER '.' NUMBER { def_version ($2, $4);}
140 | DIRECTIVE ID { def_directive ($2);}
141 ;
142
143
144explist:
145 /* EMPTY */
146 | expline
147 | explist expline
148 ;
149
150expline:
151 /* The opt_comma is necessary to support both the usual
152 DEF file syntax as well as .drectve syntax which
153 mandates <expsym>,<expoptlist>. */
154 dot_name opt_equal_name opt_ordinal opt_comma exp_opt_list
155 { def_exports ($1, $2, $3, $5); }
156 ;
157exp_opt_list:
158 /* The opt_comma is necessary to support both the usual
159 DEF file syntax as well as .drectve syntax which
160 allows for comma separated opt list. */
161 exp_opt opt_comma exp_opt_list { $$ = $1 | $3; }
162 | { $$ = 0; }
163 ;
164exp_opt:
165 NONAMEU { $$ = 1; }
166 | NONAMEL { $$ = 1; }
167 | CONSTANTU { $$ = 2; }
168 | CONSTANTL { $$ = 2; }
169 | DATAU { $$ = 4; }
170 | DATAL { $$ = 4; }
171 | PRIVATEU { $$ = 8; }
172 | PRIVATEL { $$ = 8; }
173 ;
174implist:
175 implist impline
176 | impline
177 ;
178
179impline:
180 ID '=' ID '.' ID '.' ID { def_import ($1, $3, $5, $7, -1); }
181 | ID '=' ID '.' ID '.' NUMBER { def_import ($1, $3, $5, 0, $7); }
182 | ID '=' ID '.' ID { def_import ($1, $3, 0, $5, -1); }
183 | ID '=' ID '.' NUMBER { def_import ($1, $3, 0, 0, $5); }
184 | ID '.' ID '.' ID { def_import ( 0, $1, $3, $5, -1); }
185 | ID '.' ID { def_import ( 0, $1, 0, $3, -1); }
186;
187
188seclist:
189 seclist secline
190 | secline
191 ;
192
193secline:
194 ID attr_list { def_section ($1, $2);}
195 | ID ID { def_section_alt ($1, $2);}
196 ;
197
198attr_list:
199 attr_list opt_comma attr { $$ = $1 | $3; }
200 | attr { $$ = $1; }
201 ;
202
203opt_comma:
204 ','
205 |
206 ;
207opt_number: ',' NUMBER { $$=$2;}
208 | { $$=-1;}
209 ;
210
211attr:
212 READ { $$ = 1;}
213 | WRITE { $$ = 2;}
214 | EXECUTE { $$=4;}
215 | SHARED { $$=8;}
216 ;
217
218opt_name: ID { $$ = $1; }
219 | ID '.' ID
220 {
221 char * name = xmalloc (strlen ($1) + 1 + strlen ($3) + 1);
222 sprintf (name, "%s.%s", $1, $3);
223 $$ = name;
224 }
225 | { $$ = ""; }
226 ;
227
228opt_ordinal:
229 '@' NUMBER { $$ = $2;}
230 | { $$ = -1;}
231 ;
232
233opt_equal_name:
234 '=' dot_name { $$ = $2; }
235 | { $$ = 0; }
236 ;
237
238opt_base: BASE '=' NUMBER { $$ = $3;}
239 | { $$ = -1;}
240 ;
241
242dot_name: ID { $$ = $1; }
243 | dot_name '.' ID
244 {
245 char * name = xmalloc (strlen ($1) + 1 + strlen ($3) + 1);
246 sprintf (name, "%s.%s", $1, $3);
247 $$ = name;
248 }
249 ;
250
251
252%%
253
254/*****************************************************************************
255 API
256 *****************************************************************************/
257
258static FILE *the_file;
259static const char *def_filename;
260static int linenumber;
261static def_file *def;
262static int saw_newline;
263
264struct directive
265 {
266 struct directive *next;
267 char *name;
268 int len;
269 };
270
271static struct directive *directives = 0;
272
273def_file *
274def_file_empty ()
275{
276 def_file *rv = (def_file *) xmalloc (sizeof (def_file));
277 memset (rv, 0, sizeof (def_file));
278 rv->is_dll = -1;
279 rv->base_address = (bfd_vma) (-1);
280 rv->stack_reserve = rv->stack_commit = -1;
281 rv->heap_reserve = rv->heap_commit = -1;
282 rv->version_major = rv->version_minor = -1;
283 return rv;
284}
285
286def_file *
287def_file_parse (filename, add_to)
288 const char *filename;
289 def_file *add_to;
290{
291 struct directive *d;
292
293 the_file = fopen (filename, "r");
294 def_filename = filename;
295 linenumber = 1;
296 if (!the_file)
297 {
298 perror (filename);
299 return 0;
300 }
301 if (add_to)
302 {
303 def = add_to;
304 }
305 else
306 {
307 def = def_file_empty ();
308 }
309
310 saw_newline = 1;
311 if (def_parse ())
312 {
313 def_file_free (def);
314 fclose (the_file);
315 return 0;
316 }
317
318 fclose (the_file);
319
320 for (d = directives; d; d = d->next)
321 {
322#if TRACE
323 printf ("Adding directive %08x `%s'\n", d->name, d->name);
324#endif
325 def_file_add_directive (def, d->name, d->len);
326 }
327
328 return def;
329}
330
331void
332def_file_free (def)
333 def_file *def;
334{
335 int i;
336
337 if (!def)
338 return;
339 if (def->name)
340 free (def->name);
341 if (def->description)
342 free (def->description);
343
344 if (def->section_defs)
345 {
346 for (i = 0; i < def->num_section_defs; i++)
347 {
348 if (def->section_defs[i].name)
349 free (def->section_defs[i].name);
350 if (def->section_defs[i].class)
351 free (def->section_defs[i].class);
352 }
353 free (def->section_defs);
354 }
355
356 if (def->exports)
357 {
358 for (i = 0; i < def->num_exports; i++)
359 {
360 if (def->exports[i].internal_name
361 && def->exports[i].internal_name != def->exports[i].name)
362 free (def->exports[i].internal_name);
363 if (def->exports[i].name)
364 free (def->exports[i].name);
365 }
366 free (def->exports);
367 }
368
369 if (def->imports)
370 {
371 for (i = 0; i < def->num_imports; i++)
372 {
373 if (def->imports[i].internal_name
374 && def->imports[i].internal_name != def->imports[i].name)
375 free (def->imports[i].internal_name);
376 if (def->imports[i].name)
377 free (def->imports[i].name);
378 }
379 free (def->imports);
380 }
381
382 while (def->modules)
383 {
384 def_file_module *m = def->modules;
385 def->modules = def->modules->next;
386 free (m);
387 }
388
389 free (def);
390}
391
392#ifdef DEF_FILE_PRINT
393void
394def_file_print (file, def)
395 FILE *file;
396 def_file *def;
397{
398 int i;
399
400 fprintf (file, ">>>> def_file at 0x%08x\n", def);
401 if (def->name)
402 fprintf (file, " name: %s\n", def->name ? def->name : "(unspecified)");
403 if (def->is_dll != -1)
404 fprintf (file, " is dll: %s\n", def->is_dll ? "yes" : "no");
405 if (def->base_address != (bfd_vma) (-1))
406 fprintf (file, " base address: 0x%08x\n", def->base_address);
407 if (def->description)
408 fprintf (file, " description: `%s'\n", def->description);
409 if (def->stack_reserve != -1)
410 fprintf (file, " stack reserve: 0x%08x\n", def->stack_reserve);
411 if (def->stack_commit != -1)
412 fprintf (file, " stack commit: 0x%08x\n", def->stack_commit);
413 if (def->heap_reserve != -1)
414 fprintf (file, " heap reserve: 0x%08x\n", def->heap_reserve);
415 if (def->heap_commit != -1)
416 fprintf (file, " heap commit: 0x%08x\n", def->heap_commit);
417
418 if (def->num_section_defs > 0)
419 {
420 fprintf (file, " section defs:\n");
421
422 for (i = 0; i < def->num_section_defs; i++)
423 {
424 fprintf (file, " name: `%s', class: `%s', flags:",
425 def->section_defs[i].name, def->section_defs[i].class);
426 if (def->section_defs[i].flag_read)
427 fprintf (file, " R");
428 if (def->section_defs[i].flag_write)
429 fprintf (file, " W");
430 if (def->section_defs[i].flag_execute)
431 fprintf (file, " X");
432 if (def->section_defs[i].flag_shared)
433 fprintf (file, " S");
434 fprintf (file, "\n");
435 }
436 }
437
438 if (def->num_exports > 0)
439 {
440 fprintf (file, " exports:\n");
441
442 for (i = 0; i < def->num_exports; i++)
443 {
444 fprintf (file, " name: `%s', int: `%s', ordinal: %d, flags:",
445 def->exports[i].name, def->exports[i].internal_name,
446 def->exports[i].ordinal);
447 if (def->exports[i].flag_private)
448 fprintf (file, " P");
449 if (def->exports[i].flag_constant)
450 fprintf (file, " C");
451 if (def->exports[i].flag_noname)
452 fprintf (file, " N");
453 if (def->exports[i].flag_data)
454 fprintf (file, " D");
455 fprintf (file, "\n");
456 }
457 }
458
459 if (def->num_imports > 0)
460 {
461 fprintf (file, " imports:\n");
462
463 for (i = 0; i < def->num_imports; i++)
464 {
465 fprintf (file, " int: %s, from: `%s', name: `%s', ordinal: %d\n",
466 def->imports[i].internal_name,
467 def->imports[i].module,
468 def->imports[i].name,
469 def->imports[i].ordinal);
470 }
471 }
472
473 if (def->version_major != -1)
474 fprintf (file, " version: %d.%d\n", def->version_major, def->version_minor);
475
476 fprintf (file, "<<<< def_file at 0x%08x\n", def);
477}
478#endif
479
480def_file_export *
481def_file_add_export (def, external_name, internal_name, ordinal)
482 def_file *def;
483 const char *external_name;
484 const char *internal_name;
485 int ordinal;
486{
487 def_file_export *e;
488 int max_exports = ROUND_UP(def->num_exports, 32);
489
490 if (def->num_exports >= max_exports)
491 {
492 max_exports = ROUND_UP(def->num_exports + 1, 32);
493 if (def->exports)
494 def->exports = (def_file_export *)
495 xrealloc (def->exports, max_exports * sizeof (def_file_export));
496 else
497 def->exports = (def_file_export *)
498 xmalloc (max_exports * sizeof (def_file_export));
499 }
500 e = def->exports + def->num_exports;
501 memset (e, 0, sizeof (def_file_export));
502 if (internal_name && !external_name)
503 external_name = internal_name;
504 if (external_name && !internal_name)
505 internal_name = external_name;
506 e->name = xstrdup (external_name);
507 e->internal_name = xstrdup (internal_name);
508 e->ordinal = ordinal;
509 def->num_exports++;
510 return e;
511}
512
513def_file_module *
514def_get_module (def, name)
515 def_file *def;
516 const char *name;
517{
518 def_file_module *s;
519
520 for (s = def->modules; s; s = s->next)
521 if (strcmp (s->name, name) == 0)
522 return s;
523
524 return (def_file_module *) 0;
525}
526
527static def_file_module *
528def_stash_module (def, name)
529 def_file *def;
530 const char *name;
531{
532 def_file_module *s;
533
534 if ((s = def_get_module (def, name)) != (def_file_module *) 0)
535 return s;
536 s = (def_file_module *) xmalloc (sizeof (def_file_module) + strlen (name));
537 s->next = def->modules;
538 def->modules = s;
539 s->user_data = 0;
540 strcpy (s->name, name);
541 return s;
542}
543
544def_file_import *
545def_file_add_import (def, name, module, ordinal, internal_name)
546 def_file *def;
547 const char *name;
548 const char *module;
549 int ordinal;
550 const char *internal_name;
551{
552 def_file_import *i;
553 int max_imports = ROUND_UP(def->num_imports, 16);
554
555 if (def->num_imports >= max_imports)
556 {
557 max_imports = ROUND_UP(def->num_imports+1, 16);
558
559 if (def->imports)
560 def->imports = (def_file_import *)
561 xrealloc (def->imports, max_imports * sizeof (def_file_import));
562 else
563 def->imports = (def_file_import *)
564 xmalloc (max_imports * sizeof (def_file_import));
565 }
566 i = def->imports + def->num_imports;
567 memset (i, 0, sizeof (def_file_import));
568 if (name)
569 i->name = xstrdup (name);
570 if (module)
571 i->module = def_stash_module (def, module);
572 i->ordinal = ordinal;
573 if (internal_name)
574 i->internal_name = xstrdup (internal_name);
575 else
576 i->internal_name = i->name;
577 def->num_imports++;
578
579 return i;
580}
581
582struct
583{
584 char *param;
585 int token;
586}
587diropts[] =
588{
589 { "-heap", HEAPSIZE },
590 { "-stack", STACKSIZE },
591 { "-attr", SECTIONS },
592 { "-export", EXPORTS },
593 { 0, 0 }
594};
595
596void
597def_file_add_directive (my_def, param, len)
598 def_file *my_def;
599 const char *param;
600 int len;
601{
602 def_file *save_def = def;
603 const char *pend = param + len;
604 const char *tend = param;
605 int i;
606
607 def = my_def;
608
609 while (param < pend)
610 {
611 while (param < pend && ISSPACE (*param))
612 param++;
613
614 for (tend = param + 1;
615 tend < pend && !(ISSPACE (tend[-1]) && *tend == '-');
616 tend++)
617 ;
618
619 for (i = 0; diropts[i].param; i++)
620 {
621 int len = strlen (diropts[i].param);
622
623 if (tend - param >= len
624 && strncmp (param, diropts[i].param, len) == 0
625 && (param[len] == ':' || param[len] == ' '))
626 {
627 lex_parse_string_end = tend;
628 lex_parse_string = param + len + 1;
629 lex_forced_token = diropts[i].token;
630 saw_newline = 0;
631 def_parse ();
632 break;
633 }
634 }
635
636 if (!diropts[i].param)
637 /* xgettext:c-format */
638 einfo (_("Warning: .drectve `%.*s' unrecognized\n"),
639 tend - param, param);
640
641 lex_parse_string = 0;
642 param = tend;
643 }
644
645 def = save_def;
646}
647
648/* Parser Callbacks. */
649
650static void
651def_name (name, base)
652 const char *name;
653 int base;
654{
655 if (def->name)
656 free (def->name);
657 def->name = xstrdup (name);
658 def->base_address = base;
659 def->is_dll = 0;
660}
661
662static void
663def_library (name, base)
664 const char *name;
665 int base;
666{
667 if (def->name)
668 free (def->name);
669 def->name = xstrdup (name);
670 def->base_address = base;
671 def->is_dll = 1;
672}
673
674static void
675def_description (text)
676 const char *text;
677{
678 int len = def->description ? strlen (def->description) : 0;
679
680 len += strlen (text) + 1;
681 if (def->description)
682 {
683 def->description = (char *) xrealloc (def->description, len);
684 strcat (def->description, text);
685 }
686 else
687 {
688 def->description = (char *) xmalloc (len);
689 strcpy (def->description, text);
690 }
691}
692
693static void
694def_stacksize (reserve, commit)
695 int reserve;
696 int commit;
697{
698 def->stack_reserve = reserve;
699 def->stack_commit = commit;
700}
701
702static void
703def_heapsize (reserve, commit)
704 int reserve;
705 int commit;
706{
707 def->heap_reserve = reserve;
708 def->heap_commit = commit;
709}
710
711static void
712def_section (name, attr)
713 const char *name;
714 int attr;
715{
716 def_file_section *s;
717 int max_sections = ROUND_UP(def->num_section_defs, 4);
718
719 if (def->num_section_defs >= max_sections)
720 {
721 max_sections = ROUND_UP(def->num_section_defs+1, 4);
722
723 if (def->section_defs)
724 def->section_defs = (def_file_section *) xrealloc (def->section_defs, max_sections * sizeof (def_file_import));
725 else
726 def->section_defs = (def_file_section *) xmalloc (max_sections * sizeof (def_file_import));
727 }
728 s = def->section_defs + def->num_section_defs;
729 memset (s, 0, sizeof (def_file_section));
730 s->name = xstrdup (name);
731 if (attr & 1)
732 s->flag_read = 1;
733 if (attr & 2)
734 s->flag_write = 1;
735 if (attr & 4)
736 s->flag_execute = 1;
737 if (attr & 8)
738 s->flag_shared = 1;
739
740 def->num_section_defs++;
741}
742
743static void
744def_section_alt (name, attr)
745 const char *name;
746 const char *attr;
747{
748 int aval = 0;
749
750 for (; *attr; attr++)
751 {
752 switch (*attr)
753 {
754 case 'R':
755 case 'r':
756 aval |= 1;
757 break;
758 case 'W':
759 case 'w':
760 aval |= 2;
761 break;
762 case 'X':
763 case 'x':
764 aval |= 4;
765 break;
766 case 'S':
767 case 's':
768 aval |= 8;
769 break;
770 }
771 }
772 def_section (name, aval);
773}
774
775static void
776def_exports (external_name, internal_name, ordinal, flags)
777 const char *external_name;
778 const char *internal_name;
779 int ordinal;
780 int flags;
781{
782 def_file_export *dfe;
783
784 if (!internal_name && external_name)
785 internal_name = external_name;
786#if TRACE
787 printf ("def_exports, ext=%s int=%s\n", external_name, internal_name);
788#endif
789
790 dfe = def_file_add_export (def, external_name, internal_name, ordinal);
791 if (flags & 1)
792 dfe->flag_noname = 1;
793 if (flags & 2)
794 dfe->flag_constant = 1;
795 if (flags & 4)
796 dfe->flag_data = 1;
797 if (flags & 8)
798 dfe->flag_private = 1;
799}
800
801static void
802def_import (internal_name, module, dllext, name, ordinal)
803 const char *internal_name;
804 const char *module;
805 const char *dllext;
806 const char *name;
807 int ordinal;
808{
809 char *buf = 0;
810 const char *ext = dllext ? dllext : "dll";
811
812 buf = (char *) xmalloc (strlen (module) + strlen (ext) + 2);
813 sprintf (buf, "%s.%s", module, ext);
814 module = buf;
815
816 def_file_add_import (def, name, module, ordinal, internal_name);
817 if (buf)
818 free (buf);
819}
820
821static void
822def_version (major, minor)
823 int major;
824 int minor;
825{
826 def->version_major = major;
827 def->version_minor = minor;
828}
829
830static void
831def_directive (str)
832 char *str;
833{
834 struct directive *d = (struct directive *) xmalloc (sizeof (struct directive));
835
836 d->next = directives;
837 directives = d;
838 d->name = xstrdup (str);
839 d->len = strlen (str);
840}
841
842static int
843def_error (err)
844 const char *err;
845{
846 einfo ("%P: %s:%d: %s\n", def_filename, linenumber, err);
847
848 return 0;
849}
850
851
852/* Lexical Scanner. */
853
854#undef TRACE
855#define TRACE 0
856
857/* Never freed, but always reused as needed, so no real leak. */
858static char *buffer = 0;
859static int buflen = 0;
860static int bufptr = 0;
861
862static void
863put_buf (c)
864 char c;
865{
866 if (bufptr == buflen)
867 {
868 buflen += 50; /* overly reasonable, eh? */
869 if (buffer)
870 buffer = (char *) xrealloc (buffer, buflen + 1);
871 else
872 buffer = (char *) xmalloc (buflen + 1);
873 }
874 buffer[bufptr++] = c;
875 buffer[bufptr] = 0; /* not optimal, but very convenient. */
876}
877
878static struct
879{
880 char *name;
881 int token;
882}
883tokens[] =
884{
885 { "BASE", BASE },
886 { "CODE", CODE },
887 { "CONSTANT", CONSTANTU },
888 { "constant", CONSTANTL },
889 { "DATA", DATAU },
890 { "data", DATAL },
891 { "DESCRIPTION", DESCRIPTION },
892 { "DIRECTIVE", DIRECTIVE },
893 { "EXECUTE", EXECUTE },
894 { "EXPORTS", EXPORTS },
895 { "HEAPSIZE", HEAPSIZE },
896 { "IMPORTS", IMPORTS },
897 { "LIBRARY", LIBRARY },
898 { "NAME", NAME },
899 { "NONAME", NONAMEU },
900 { "noname", NONAMEL },
901 { "PRIVATE", PRIVATEU },
902 { "private", PRIVATEL },
903 { "READ", READ },
904 { "SECTIONS", SECTIONS },
905 { "SEGMENTS", SECTIONS },
906 { "SHARED", SHARED },
907 { "STACKSIZE", STACKSIZE },
908 { "VERSION", VERSIONK },
909 { "WRITE", WRITE },
910 { 0, 0 }
911};
912
913static int
914def_getc ()
915{
916 int rv;
917
918 if (lex_parse_string)
919 {
920 if (lex_parse_string >= lex_parse_string_end)
921 rv = EOF;
922 else
923 rv = *lex_parse_string++;
924 }
925 else
926 {
927 rv = fgetc (the_file);
928 }
929 if (rv == '\n')
930 saw_newline = 1;
931 return rv;
932}
933
934static int
935def_ungetc (c)
936 int c;
937{
938 if (lex_parse_string)
939 {
940 lex_parse_string--;
941 return c;
942 }
943 else
944 return ungetc (c, the_file);
945}
946
947static int
948def_lex ()
949{
950 int c, i, q;
951
952 if (lex_forced_token)
953 {
954 i = lex_forced_token;
955 lex_forced_token = 0;
956#if TRACE
957 printf ("lex: forcing token %d\n", i);
958#endif
959 return i;
960 }
961
962 c = def_getc ();
963
964 /* Trim leading whitespace. */
965 while (c != EOF && (c == ' ' || c == '\t') && saw_newline)
966 c = def_getc ();
967
968 if (c == EOF)
969 {
970#if TRACE
971 printf ("lex: EOF\n");
972#endif
973 return 0;
974 }
975
976 if (saw_newline && c == ';')
977 {
978 do
979 {
980 c = def_getc ();
981 }
982 while (c != EOF && c != '\n');
983 if (c == '\n')
984 return def_lex ();
985 return 0;
986 }
987
988 /* Must be something else. */
989 saw_newline = 0;
990
991 if (ISDIGIT (c))
992 {
993 bufptr = 0;
994 while (c != EOF && (ISXDIGIT (c) || (c == 'x')))
995 {
996 put_buf (c);
997 c = def_getc ();
998 }
999 if (c != EOF)
1000 def_ungetc (c);
1001 yylval.number = strtoul (buffer, 0, 0);
1002#if TRACE
1003 printf ("lex: `%s' returns NUMBER %d\n", buffer, yylval.number);
1004#endif
1005 return NUMBER;
1006 }
1007
1008 if (ISALPHA (c) || strchr ("$:-_?@", c))
1009 {
1010 bufptr = 0;
1011 q = c;
1012 put_buf (c);
1013 c = def_getc ();
1014
1015 if (q == '@')
1016 {
1017 if (ISBLANK (c) ) /* '@' followed by whitespace. */
1018 return (q);
1019 else if (ISDIGIT (c)) /* '@' followed by digit. */
1020 {
1021 def_ungetc (c);
1022 return (q);
1023 }
1024#if TRACE
1025 printf ("lex: @ returns itself\n");
1026#endif
1027 }
1028
1029 while (c != EOF && (ISALNUM (c) || strchr ("$:-_?/@", c)))
1030 {
1031 put_buf (c);
1032 c = def_getc ();
1033 }
1034 if (c != EOF)
1035 def_ungetc (c);
1036 if (ISALPHA (q)) /* Check for tokens. */
1037 {
1038 for (i = 0; tokens[i].name; i++)
1039 if (strcmp (tokens[i].name, buffer) == 0)
1040 {
1041#if TRACE
1042 printf ("lex: `%s' is a string token\n", buffer);
1043#endif
1044 return tokens[i].token;
1045 }
1046 }
1047#if TRACE
1048 printf ("lex: `%s' returns ID\n", buffer);
1049#endif
1050 yylval.id = xstrdup (buffer);
1051 return ID;
1052 }
1053
1054 if (c == '\'' || c == '"')
1055 {
1056 q = c;
1057 c = def_getc ();
1058 bufptr = 0;
1059
1060 while (c != EOF && c != q)
1061 {
1062 put_buf (c);
1063 c = def_getc ();
1064 }
1065 yylval.id = xstrdup (buffer);
1066#if TRACE
1067 printf ("lex: `%s' returns ID\n", buffer);
1068#endif
1069 return ID;
1070 }
1071
1072 if (c == '=' || c == '.' || c == ',')
1073 {
1074#if TRACE
1075 printf ("lex: `%c' returns itself\n", c);
1076#endif
1077 return c;
1078 }
1079
1080 if (c == '\n')
1081 {
1082 linenumber++;
1083 saw_newline = 1;
1084 }
1085
1086 /*printf ("lex: 0x%02x ignored\n", c); */
1087 return def_lex ();
1088}
Note: See TracBrowser for help on using the repository browser.