* common.h (EM_PPC64): Define.
[binutils.git] / ld / deffilep.y
blobaacde6b989edab2297ebd108658eb6b26526b1f5
1 %{ /* deffilep.y - parser for .def files */
3 /* Copyright (C) 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
5 This file is part of GNU Binutils.
7 This program 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 of the License, or
10 (at your option) any later version.
12 This program 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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 #include <stdio.h>
22 #include <ctype.h>
23 #include "libiberty.h"
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "ld.h"
27 #include "ldmisc.h"
28 #include "deffile.h"
30 #define TRACE 0
32 #define ROUND_UP(a, b) (((a)+((b)-1))&~((b)-1))
34 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
35 as well as gratuitiously global symbol names, so we can have multiple
36 yacc generated parsers in ld. Note that these are only the variables
37 produced by yacc. If other parser generators (bison, byacc, etc) produce
38 additional global names that conflict at link time, then those parser
39 generators need to be fixed instead of adding those names to this list. */
41 #define yymaxdepth def_maxdepth
42 #define yyparse def_parse
43 #define yylex def_lex
44 #define yyerror def_error
45 #define yylval def_lval
46 #define yychar def_char
47 #define yydebug def_debug
48 #define yypact def_pact
49 #define yyr1 def_r1
50 #define yyr2 def_r2
51 #define yydef def_def
52 #define yychk def_chk
53 #define yypgo def_pgo
54 #define yyact def_act
55 #define yyexca def_exca
56 #define yyerrflag def_errflag
57 #define yynerrs def_nerrs
58 #define yyps def_ps
59 #define yypv def_pv
60 #define yys def_s
61 #define yy_yys def_yys
62 #define yystate def_state
63 #define yytmp def_tmp
64 #define yyv def_v
65 #define yy_yyv def_yyv
66 #define yyval def_val
67 #define yylloc def_lloc
68 #define yyreds def_reds /* With YYDEBUG defined */
69 #define yytoks def_toks /* With YYDEBUG defined */
70 #define yylhs def_yylhs
71 #define yylen def_yylen
72 #define yydefred def_yydefred
73 #define yydgoto def_yydgoto
74 #define yysindex def_yysindex
75 #define yyrindex def_yyrindex
76 #define yygindex def_yygindex
77 #define yytable def_yytable
78 #define yycheck def_yycheck
80 static int def_lex ();
82 static void def_description PARAMS ((const char *));
83 static void def_exports PARAMS ((const char *, const char *, int, int));
84 static void def_heapsize PARAMS ((int, int));
85 static void def_import
86 PARAMS ((const char *, const char *, const char *, const char *, int));
87 static void def_library PARAMS ((const char *, int));
88 static void def_name PARAMS ((const char *, int));
89 static void def_section PARAMS ((const char *, int));
90 static void def_section_alt PARAMS ((const char *, const char *));
91 static void def_stacksize PARAMS ((int, int));
92 static void def_version PARAMS ((int, int));
93 static void def_directive PARAMS ((char *));
94 static int def_parse PARAMS ((void));
95 static int def_error PARAMS ((const char *));
96 static int def_debug;
97 static int def_lex PARAMS ((void));
99 static int lex_forced_token = 0;
100 static const char *lex_parse_string = 0;
101 static const char *lex_parse_string_end = 0;
105 %union {
106 char *id;
107 int number;
110 %token NAME, LIBRARY, DESCRIPTION, STACKSIZE, HEAPSIZE, CODE, DATA
111 %token SECTIONS, EXPORTS, IMPORTS, VERSIONK, BASE, CONSTANT, PRIVATE
112 %token READ WRITE EXECUTE SHARED NONAME DIRECTIVE
113 %token <id> ID
114 %token <number> NUMBER
115 %type <number> opt_base opt_ordinal
116 %type <number> attr attr_list opt_number exp_opt_list exp_opt
117 %type <id> opt_name opt_equal_name
121 start: start command
122 | command
125 command:
126 NAME opt_name opt_base { def_name ($2, $3); }
127 | LIBRARY opt_name opt_base { def_library ($2, $3); }
128 | DESCRIPTION ID { def_description ($2);}
129 | STACKSIZE NUMBER opt_number { def_stacksize ($2, $3);}
130 | HEAPSIZE NUMBER opt_number { def_heapsize ($2, $3);}
131 | CODE attr_list { def_section ("CODE", $2);}
132 | DATA attr_list { def_section ("DATA", $2);}
133 | SECTIONS seclist
134 | EXPORTS explist
135 | IMPORTS implist
136 | VERSIONK NUMBER { def_version ($2, 0);}
137 | VERSIONK NUMBER '.' NUMBER { def_version ($2, $4);}
138 | DIRECTIVE ID { def_directive ($2);}
142 explist:
143 /* EMPTY */
144 | expline
145 | explist expline
148 expline:
149 ID opt_equal_name opt_ordinal exp_opt_list
150 { def_exports ($1, $2, $3, $4); }
152 exp_opt_list:
153 exp_opt exp_opt_list { $$ = $1 | $2; }
154 | { $$ = 0; }
156 exp_opt:
157 NONAME { $$ = 1; }
158 | CONSTANT { $$ = 2; }
159 | DATA { $$ = 4; }
160 | PRIVATE { $$ = 8; }
162 implist:
163 implist impline
164 | impline
167 impline:
168 ID '=' ID '.' ID '.' ID { def_import ($1, $3, $5, $7, -1); }
169 | ID '=' ID '.' ID '.' NUMBER { def_import ($1, $3, $5, 0, $7); }
170 | ID '=' ID '.' ID { def_import ($1, $3, 0, $5, -1); }
171 | ID '=' ID '.' NUMBER { def_import ($1, $3, 0, 0, $5); }
172 | ID '.' ID '.' ID { def_import ( 0, $1, $3, $5, -1); }
173 | ID '.' ID { def_import ( 0, $1, 0, $3, -1); }
176 seclist:
177 seclist secline
178 | secline
181 secline:
182 ID attr_list { def_section ($1, $2);}
183 | ID ID { def_section_alt ($1, $2);}
186 attr_list:
187 attr_list opt_comma attr { $$ = $1 | $3; }
188 | attr { $$ = $1; }
191 opt_comma:
195 opt_number: ',' NUMBER { $$=$2;}
196 | { $$=-1;}
199 attr:
200 READ { $$ = 1;}
201 | WRITE { $$ = 2;}
202 | EXECUTE { $$=4;}
203 | SHARED { $$=8;}
206 opt_name: ID { $$ = $1; }
207 | { $$ = 0; }
210 opt_ordinal:
211 '@' NUMBER { $$ = $2;}
212 | { $$ = -1;}
215 opt_equal_name:
216 '=' ID { $$ = $2; }
217 | { $$ = 0; }
220 opt_base: BASE '=' NUMBER { $$ = $3;}
221 | { $$ = 0;}
228 /*****************************************************************************
230 *****************************************************************************/
232 static FILE *the_file;
233 static const char *def_filename;
234 static int linenumber;
235 static def_file *def;
236 static int saw_newline;
238 struct directive
240 struct directive *next;
241 char *name;
242 int len;
245 static struct directive *directives = 0;
247 def_file *
248 def_file_empty ()
250 def_file *rv = (def_file *) xmalloc (sizeof (def_file));
251 memset (rv, 0, sizeof (def_file));
252 rv->is_dll = -1;
253 rv->base_address = (bfd_vma) (-1);
254 rv->stack_reserve = rv->stack_commit = -1;
255 rv->heap_reserve = rv->heap_commit = -1;
256 rv->version_major = rv->version_minor = -1;
257 return rv;
260 def_file *
261 def_file_parse (filename, add_to)
262 const char *filename;
263 def_file *add_to;
265 struct directive *d;
267 the_file = fopen (filename, "r");
268 def_filename = filename;
269 linenumber = 1;
270 if (!the_file)
272 perror (filename);
273 return 0;
275 if (add_to)
277 def = add_to;
279 else
281 def = def_file_empty ();
284 saw_newline = 1;
285 if (def_parse ())
287 def_file_free (def);
288 fclose (the_file);
289 return 0;
292 fclose (the_file);
294 for (d = directives; d; d = d->next)
296 #if TRACE
297 printf ("Adding directive %08x `%s'\n", d->name, d->name);
298 #endif
299 def_file_add_directive (def, d->name, d->len);
302 return def;
305 void
306 def_file_free (def)
307 def_file *def;
309 int i;
310 if (!def)
311 return;
312 if (def->name)
313 free (def->name);
314 if (def->description)
315 free (def->description);
317 if (def->section_defs)
319 for (i = 0; i < def->num_section_defs; i++)
321 if (def->section_defs[i].name)
322 free (def->section_defs[i].name);
323 if (def->section_defs[i].class)
324 free (def->section_defs[i].class);
326 free (def->section_defs);
329 if (def->exports)
331 for (i = 0; i < def->num_exports; i++)
333 if (def->exports[i].internal_name
334 && def->exports[i].internal_name != def->exports[i].name)
335 free (def->exports[i].internal_name);
336 if (def->exports[i].name)
337 free (def->exports[i].name);
339 free (def->exports);
342 if (def->imports)
344 for (i = 0; i < def->num_imports; i++)
346 if (def->imports[i].internal_name
347 && def->imports[i].internal_name != def->imports[i].name)
348 free (def->imports[i].internal_name);
349 if (def->imports[i].name)
350 free (def->imports[i].name);
352 free (def->imports);
355 while (def->modules)
357 def_file_module *m = def->modules;
358 def->modules = def->modules->next;
359 free (m);
362 free (def);
365 #ifdef DEF_FILE_PRINT
366 void
367 def_file_print (file, def)
368 FILE *file;
369 def_file *def;
371 int i;
372 fprintf (file, ">>>> def_file at 0x%08x\n", def);
373 if (def->name)
374 fprintf (file, " name: %s\n", def->name ? def->name : "(unspecified)");
375 if (def->is_dll != -1)
376 fprintf (file, " is dll: %s\n", def->is_dll ? "yes" : "no");
377 if (def->base_address != (bfd_vma) (-1))
378 fprintf (file, " base address: 0x%08x\n", def->base_address);
379 if (def->description)
380 fprintf (file, " description: `%s'\n", def->description);
381 if (def->stack_reserve != -1)
382 fprintf (file, " stack reserve: 0x%08x\n", def->stack_reserve);
383 if (def->stack_commit != -1)
384 fprintf (file, " stack commit: 0x%08x\n", def->stack_commit);
385 if (def->heap_reserve != -1)
386 fprintf (file, " heap reserve: 0x%08x\n", def->heap_reserve);
387 if (def->heap_commit != -1)
388 fprintf (file, " heap commit: 0x%08x\n", def->heap_commit);
390 if (def->num_section_defs > 0)
392 fprintf (file, " section defs:\n");
393 for (i = 0; i < def->num_section_defs; i++)
395 fprintf (file, " name: `%s', class: `%s', flags:",
396 def->section_defs[i].name, def->section_defs[i].class);
397 if (def->section_defs[i].flag_read)
398 fprintf (file, " R");
399 if (def->section_defs[i].flag_write)
400 fprintf (file, " W");
401 if (def->section_defs[i].flag_execute)
402 fprintf (file, " X");
403 if (def->section_defs[i].flag_shared)
404 fprintf (file, " S");
405 fprintf (file, "\n");
409 if (def->num_exports > 0)
411 fprintf (file, " exports:\n");
412 for (i = 0; i < def->num_exports; i++)
414 fprintf (file, " name: `%s', int: `%s', ordinal: %d, flags:",
415 def->exports[i].name, def->exports[i].internal_name,
416 def->exports[i].ordinal);
417 if (def->exports[i].flag_private)
418 fprintf (file, " P");
419 if (def->exports[i].flag_constant)
420 fprintf (file, " C");
421 if (def->exports[i].flag_noname)
422 fprintf (file, " N");
423 if (def->exports[i].flag_data)
424 fprintf (file, " D");
425 fprintf (file, "\n");
429 if (def->num_imports > 0)
431 fprintf (file, " imports:\n");
432 for (i = 0; i < def->num_imports; i++)
434 fprintf (file, " int: %s, from: `%s', name: `%s', ordinal: %d\n",
435 def->imports[i].internal_name,
436 def->imports[i].module,
437 def->imports[i].name,
438 def->imports[i].ordinal);
441 if (def->version_major != -1)
442 fprintf (file, " version: %d.%d\n", def->version_major, def->version_minor);
443 fprintf (file, "<<<< def_file at 0x%08x\n", def);
445 #endif
447 def_file_export *
448 def_file_add_export (def, external_name, internal_name, ordinal)
449 def_file *def;
450 const char *external_name;
451 const char *internal_name;
452 int ordinal;
454 def_file_export *e;
455 int max_exports = ROUND_UP(def->num_exports, 32);
456 if (def->num_exports >= max_exports)
458 max_exports = ROUND_UP(def->num_exports+1, 32);
459 if (def->exports)
460 def->exports = (def_file_export *) xrealloc (def->exports, max_exports * sizeof (def_file_export));
461 else
462 def->exports = (def_file_export *) xmalloc (max_exports * sizeof (def_file_export));
464 e = def->exports + def->num_exports;
465 memset (e, 0, sizeof (def_file_export));
466 if (internal_name && !external_name)
467 external_name = internal_name;
468 if (external_name && !internal_name)
469 internal_name = external_name;
470 e->name = xstrdup (external_name);
471 e->internal_name = xstrdup (internal_name);
472 e->ordinal = ordinal;
473 def->num_exports++;
474 return e;
477 static def_file_module *
478 def_stash_module (def, name)
479 def_file *def;
480 char *name;
482 def_file_module *s;
483 for (s=def->modules; s; s=s->next)
484 if (strcmp (s->name, name) == 0)
485 return s;
486 s = (def_file_module *) xmalloc (sizeof (def_file_module) + strlen (name));
487 s->next = def->modules;
488 def->modules = s;
489 s->user_data = 0;
490 strcpy (s->name, name);
491 return s;
494 def_file_import *
495 def_file_add_import (def, name, module, ordinal, internal_name)
496 def_file *def;
497 const char *name;
498 const char *module;
499 int ordinal;
500 const char *internal_name;
502 def_file_import *i;
503 int max_imports = ROUND_UP(def->num_imports, 16);
504 if (def->num_imports >= max_imports)
506 max_imports = ROUND_UP(def->num_imports+1, 16);
507 if (def->imports)
508 def->imports = (def_file_import *) xrealloc (def->imports, max_imports * sizeof (def_file_import));
509 else
510 def->imports = (def_file_import *) xmalloc (max_imports * sizeof (def_file_import));
512 i = def->imports + def->num_imports;
513 memset (i, 0, sizeof (def_file_import));
514 if (name)
515 i->name = xstrdup (name);
516 if (module)
517 i->module = def_stash_module(def, module);
518 i->ordinal = ordinal;
519 if (internal_name)
520 i->internal_name = xstrdup (internal_name);
521 else
522 i->internal_name = i->name;
523 def->num_imports++;
524 return i;
527 struct
529 char *param;
530 int token;
532 diropts[] =
534 { "-heap", HEAPSIZE },
535 { "-stack", STACKSIZE },
536 { "-attr", SECTIONS },
537 { "-export", EXPORTS },
538 { 0, 0 }
541 void
542 def_file_add_directive (my_def, param, len)
543 def_file *my_def;
544 const char *param;
545 int len;
547 def_file *save_def = def;
548 const char *pend = param + len;
549 const char *tend = param;
550 int i;
552 def = my_def;
554 while (param < pend)
556 while (param < pend && isspace (*param))
557 param++;
558 for (tend = param + 1;
559 tend < pend && !(isspace (tend[-1]) && *tend == '-');
560 tend++);
562 for (i = 0; diropts[i].param; i++)
564 int len = strlen (diropts[i].param);
565 if (tend - param >= len
566 && strncmp (param, diropts[i].param, len) == 0
567 && (param[len] == ':' || param[len] == ' '))
569 lex_parse_string_end = tend;
570 lex_parse_string = param + len + 1;
571 lex_forced_token = diropts[i].token;
572 saw_newline = 0;
573 def_parse ();
574 break;
578 if (!diropts[i].param)
580 /* xgettext:c-format */
581 einfo (_("Warning: .drectve `%.*s' unrecognized\n"),
582 tend - param, param);
584 lex_parse_string = 0;
585 param = tend;
588 def = save_def;
591 /*****************************************************************************
592 Parser Callbacks
593 *****************************************************************************/
595 static void
596 def_name (name, base)
597 const char *name;
598 int base;
600 if (def->name)
601 free (def->name);
602 def->name = xstrdup (name);
603 def->base_address = base;
604 def->is_dll = 0;
607 static void
608 def_library (name, base)
609 const char *name;
610 int base;
612 if (def->name)
613 free (def->name);
614 def->name = xstrdup (name);
615 def->base_address = base;
616 def->is_dll = 1;
619 static void
620 def_description (text)
621 const char *text;
623 int len = def->description ? strlen (def->description) : 0;
624 len += strlen (text) + 1;
625 if (def->description)
627 def->description = (char *) xrealloc (def->description, len);
628 strcat (def->description, text);
630 else
632 def->description = (char *) xmalloc (len);
633 strcpy (def->description, text);
637 static void
638 def_stacksize (reserve, commit)
639 int reserve;
640 int commit;
642 def->stack_reserve = reserve;
643 def->stack_commit = commit;
646 static void
647 def_heapsize (reserve, commit)
648 int reserve;
649 int commit;
651 def->heap_reserve = reserve;
652 def->heap_commit = commit;
655 static void
656 def_section (name, attr)
657 const char *name;
658 int attr;
660 def_file_section *s;
661 int max_sections = ROUND_UP(def->num_section_defs, 4);
662 if (def->num_section_defs >= max_sections)
664 max_sections = ROUND_UP(def->num_section_defs+1, 4);
665 if (def->section_defs)
666 def->section_defs = (def_file_section *) xrealloc (def->section_defs, max_sections * sizeof (def_file_import));
667 else
668 def->section_defs = (def_file_section *) xmalloc (max_sections * sizeof (def_file_import));
670 s = def->section_defs + def->num_section_defs;
671 memset (s, 0, sizeof (def_file_section));
672 s->name = xstrdup (name);
673 if (attr & 1)
674 s->flag_read = 1;
675 if (attr & 2)
676 s->flag_write = 1;
677 if (attr & 4)
678 s->flag_execute = 1;
679 if (attr & 8)
680 s->flag_shared = 1;
682 def->num_section_defs++;
685 static void
686 def_section_alt (name, attr)
687 const char *name;
688 const char *attr;
690 int aval = 0;
691 for (; *attr; attr++)
693 switch (*attr)
695 case 'R':
696 case 'r':
697 aval |= 1;
698 break;
699 case 'W':
700 case 'w':
701 aval |= 2;
702 break;
703 case 'X':
704 case 'x':
705 aval |= 4;
706 break;
707 case 'S':
708 case 's':
709 aval |= 8;
710 break;
713 def_section (name, aval);
716 static void
717 def_exports (external_name, internal_name, ordinal, flags)
718 const char *external_name;
719 const char *internal_name;
720 int ordinal;
721 int flags;
723 def_file_export *dfe;
725 if (!internal_name && external_name)
726 internal_name = external_name;
727 #if TRACE
728 printf ("def_exports, ext=%s int=%s\n", external_name, internal_name);
729 #endif
731 dfe = def_file_add_export (def, external_name, internal_name, ordinal);
732 if (flags & 1)
733 dfe->flag_noname = 1;
734 if (flags & 2)
735 dfe->flag_constant = 1;
736 if (flags & 4)
737 dfe->flag_data = 1;
738 if (flags & 8)
739 dfe->flag_private = 1;
742 static void
743 def_import (internal_name, module, dllext, name, ordinal)
744 const char *internal_name;
745 const char *module;
746 const char *dllext;
747 const char *name;
748 int ordinal;
750 char *buf = 0;
752 if (dllext != NULL)
754 buf = (char *) xmalloc (strlen (module) + strlen (dllext) + 2);
755 sprintf (buf, "%s.%s", module, dllext);
756 module = buf;
759 def_file_add_import (def, name, module, ordinal, internal_name);
760 if (buf)
761 free (buf);
764 static void
765 def_version (major, minor)
766 int major;
767 int minor;
769 def->version_major = major;
770 def->version_minor = minor;
773 static void
774 def_directive (str)
775 char *str;
777 struct directive *d = (struct directive *) xmalloc (sizeof (struct directive));
778 d->next = directives;
779 directives = d;
780 d->name = xstrdup (str);
781 d->len = strlen (str);
784 static int
785 def_error (err)
786 const char *err;
788 einfo ("%P: %s:%d: %s\n", def_filename, linenumber, err);
790 return 0;
794 /*****************************************************************************
795 Lexical Scanner
796 *****************************************************************************/
798 #undef TRACE
799 #define TRACE 0
801 /* Never freed, but always reused as needed, so no real leak */
802 static char *buffer = 0;
803 static int buflen = 0;
804 static int bufptr = 0;
806 static void
807 put_buf (c)
808 char c;
810 if (bufptr == buflen)
812 buflen += 50; /* overly reasonable, eh? */
813 if (buffer)
814 buffer = (char *) xrealloc (buffer, buflen + 1);
815 else
816 buffer = (char *) xmalloc (buflen + 1);
818 buffer[bufptr++] = c;
819 buffer[bufptr] = 0; /* not optimal, but very convenient */
822 static struct
824 char *name;
825 int token;
827 tokens[] =
829 { "BASE", BASE },
830 { "CODE", CODE },
831 { "CONSTANT", CONSTANT },
832 { "DATA", DATA },
833 { "DESCRIPTION", DESCRIPTION },
834 { "DIRECTIVE", DIRECTIVE },
835 { "EXECUTE", EXECUTE },
836 { "EXPORTS", EXPORTS },
837 { "HEAPSIZE", HEAPSIZE },
838 { "IMPORTS", IMPORTS },
839 { "LIBRARY", LIBRARY },
840 { "NAME", NAME },
841 { "NONAME", NONAME },
842 { "PRIVATE", PRIVATE },
843 { "READ", READ },
844 { "SECTIONS", SECTIONS },
845 { "SEGMENTS", SECTIONS },
846 { "SHARED", SHARED },
847 { "STACKSIZE", STACKSIZE },
848 { "VERSION", VERSIONK },
849 { "WRITE", WRITE },
850 { 0, 0 }
853 static int
854 def_getc ()
856 int rv;
857 if (lex_parse_string)
859 if (lex_parse_string >= lex_parse_string_end)
860 rv = EOF;
861 else
862 rv = *lex_parse_string++;
864 else
866 rv = fgetc (the_file);
868 if (rv == '\n')
869 saw_newline = 1;
870 return rv;
873 static int
874 def_ungetc (c)
875 int c;
877 if (lex_parse_string)
879 lex_parse_string--;
880 return c;
882 else
883 return ungetc (c, the_file);
886 static int
887 def_lex ()
889 int c, i, q;
891 if (lex_forced_token)
893 i = lex_forced_token;
894 lex_forced_token = 0;
895 #if TRACE
896 printf ("lex: forcing token %d\n", i);
897 #endif
898 return i;
901 c = def_getc ();
903 /* trim leading whitespace */
904 while (c != EOF && (c == ' ' || c == '\t') && saw_newline)
905 c = def_getc ();
907 if (c == EOF)
909 #if TRACE
910 printf ("lex: EOF\n");
911 #endif
912 return 0;
915 if (saw_newline && c == ';')
919 c = def_getc ();
921 while (c != EOF && c != '\n');
922 if (c == '\n')
923 return def_lex ();
924 return 0;
926 /* must be something else */
927 saw_newline = 0;
929 if (isdigit (c))
931 bufptr = 0;
932 while (c != EOF && (isxdigit (c) || (c == 'x')))
934 put_buf (c);
935 c = def_getc ();
937 if (c != EOF)
938 def_ungetc (c);
939 yylval.number = strtoul (buffer, 0, 0);
940 #if TRACE
941 printf ("lex: `%s' returns NUMBER %d\n", buffer, yylval.number);
942 #endif
943 return NUMBER;
946 if (isalpha (c) || strchr ("$:-_?", c))
948 bufptr = 0;
949 while (c != EOF && (isalnum (c) || strchr ("$:-_?/@", c)))
951 put_buf (c);
952 c = def_getc ();
954 if (c != EOF)
955 def_ungetc (c);
956 for (i = 0; tokens[i].name; i++)
957 if (strcmp (tokens[i].name, buffer) == 0)
959 #if TRACE
960 printf ("lex: `%s' is a string token\n", buffer);
961 #endif
962 return tokens[i].token;
964 #if TRACE
965 printf ("lex: `%s' returns ID\n", buffer);
966 #endif
967 yylval.id = xstrdup (buffer);
968 return ID;
971 if (c == '\'' || c == '"')
973 q = c;
974 c = def_getc ();
975 bufptr = 0;
976 while (c != EOF && c != q)
978 put_buf (c);
979 c = def_getc ();
981 yylval.id = xstrdup (buffer);
982 #if TRACE
983 printf ("lex: `%s' returns ID\n", buffer);
984 #endif
985 return ID;
988 if (c == '=' || c == '.' || c == '@' || c == ',')
990 #if TRACE
991 printf ("lex: `%c' returns itself\n", c);
992 #endif
993 return c;
996 if (c == '\n')
998 linenumber++;
999 saw_newline = 1;
1002 /*printf ("lex: 0x%02x ignored\n", c); */
1003 return def_lex ();