This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / gdb / macrotab.c
1 /* C preprocessor macro tables for GDB.
2    Copyright (C) 2002 Free Software Foundation, Inc.
3    Contributed by Red Hat, Inc.
4
5    This file is part of GDB.
6
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.
11
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.
16
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., 51 Franklin Street, Fifth Floor,
20    Boston, MA 02110-1301, USA.  */
21
22 #include "defs.h"
23 #include "gdb_obstack.h"
24 #include "splay-tree.h"
25 #include "symtab.h"
26 #include "symfile.h"
27 #include "objfiles.h"
28 #include "macrotab.h"
29 #include "gdb_assert.h"
30 #include "bcache.h"
31 #include "complaints.h"
32
33 \f
34 /* The macro table structure.  */
35
36 struct macro_table
37 {
38   /* The obstack this table's data should be allocated in, or zero if
39      we should use xmalloc.  */
40   struct obstack *obstack;
41
42   /* The bcache we should use to hold macro names, argument names, and
43      definitions, or zero if we should use xmalloc.  */
44   struct bcache *bcache;
45
46   /* The main source file for this compilation unit --- the one whose
47      name was given to the compiler.  This is the root of the
48      #inclusion tree; everything else is #included from here.  */
49   struct macro_source_file *main_source;
50
51   /* The table of macro definitions.  This is a splay tree (an ordered
52      binary tree that stays balanced, effectively), sorted by macro
53      name.  Where a macro gets defined more than once (presumably with
54      an #undefinition in between), we sort the definitions by the
55      order they would appear in the preprocessor's output.  That is,
56      if `a.c' #includes `m.h' and then #includes `n.h', and both
57      header files #define X (with an #undef somewhere in between),
58      then the definition from `m.h' appears in our splay tree before
59      the one from `n.h'.
60
61      The splay tree's keys are `struct macro_key' pointers;
62      the values are `struct macro_definition' pointers.
63
64      The splay tree, its nodes, and the keys and values are allocated
65      in obstack, if it's non-zero, or with xmalloc otherwise.  The
66      macro names, argument names, argument name arrays, and definition
67      strings are all allocated in bcache, if non-zero, or with xmalloc
68      otherwise.  */
69   splay_tree definitions;
70 };
71
72
73 \f
74 /* Allocation and freeing functions.  */
75
76 /* Allocate SIZE bytes of memory appropriately for the macro table T.
77    This just checks whether T has an obstack, or whether its pieces
78    should be allocated with xmalloc.  */
79 static void *
80 macro_alloc (int size, struct macro_table *t)
81 {
82   if (t->obstack)
83     return obstack_alloc (t->obstack, size);
84   else
85     return xmalloc (size);
86 }
87
88
89 static void
90 macro_free (void *object, struct macro_table *t)
91 {
92   gdb_assert (! t->obstack);
93   xfree (object);
94 }
95
96
97 /* If the macro table T has a bcache, then cache the LEN bytes at ADDR
98    there, and return the cached copy.  Otherwise, just xmalloc a copy
99    of the bytes, and return a pointer to that.  */
100 static const void *
101 macro_bcache (struct macro_table *t, const void *addr, int len)
102 {
103   if (t->bcache)
104     return bcache (addr, len, t->bcache);
105   else
106     {
107       void *copy = xmalloc (len);
108       memcpy (copy, addr, len);
109       return copy;
110     }
111 }
112
113
114 /* If the macro table T has a bcache, cache the null-terminated string
115    S there, and return a pointer to the cached copy.  Otherwise,
116    xmalloc a copy and return that.  */
117 static const char *
118 macro_bcache_str (struct macro_table *t, const char *s)
119 {
120   return (char *) macro_bcache (t, s, strlen (s) + 1);
121 }
122
123
124 /* Free a possibly bcached object OBJ.  That is, if the macro table T
125    has a bcache, it's an error; otherwise, xfree OBJ.  */
126 static void
127 macro_bcache_free (struct macro_table *t, void *obj)
128 {
129   gdb_assert (! t->bcache);
130   xfree (obj);
131 }
132
133
134 \f
135 /* Macro tree keys, w/their comparison, allocation, and freeing functions.  */
136
137 /* A key in the splay tree.  */
138 struct macro_key
139 {
140   /* The table we're in.  We only need this in order to free it, since
141      the splay tree library's key and value freeing functions require
142      that the key or value contain all the information needed to free
143      themselves.  */
144   struct macro_table *table;
145
146   /* The name of the macro.  This is in the table's bcache, if it has
147      one. */
148   const char *name;
149
150   /* The source file and line number where the definition's scope
151      begins.  This is also the line of the definition itself.  */
152   struct macro_source_file *start_file;
153   int start_line;
154
155   /* The first source file and line after the definition's scope.
156      (That is, the scope does not include this endpoint.)  If end_file
157      is zero, then the definition extends to the end of the
158      compilation unit.  */
159   struct macro_source_file *end_file;
160   int end_line;
161 };
162
163
164 /* Return the #inclusion depth of the source file FILE.  This is the
165    number of #inclusions it took to reach this file.  For the main
166    source file, the #inclusion depth is zero; for a file it #includes
167    directly, the depth would be one; and so on.  */
168 static int
169 inclusion_depth (struct macro_source_file *file)
170 {
171   int depth;
172
173   for (depth = 0; file->included_by; depth++)
174     file = file->included_by;
175
176   return depth;
177 }
178
179
180 /* Compare two source locations (from the same compilation unit).
181    This is part of the comparison function for the tree of
182    definitions.
183
184    LINE1 and LINE2 are line numbers in the source files FILE1 and
185    FILE2.  Return a value:
186    - less than zero if {LINE,FILE}1 comes before {LINE,FILE}2,
187    - greater than zero if {LINE,FILE}1 comes after {LINE,FILE}2, or
188    - zero if they are equal.
189
190    When the two locations are in different source files --- perhaps
191    one is in a header, while another is in the main source file --- we
192    order them by where they would appear in the fully pre-processed
193    sources, where all the #included files have been substituted into
194    their places.  */
195 static int
196 compare_locations (struct macro_source_file *file1, int line1, 
197                    struct macro_source_file *file2, int line2)
198 {
199   /* We want to treat positions in an #included file as coming *after*
200      the line containing the #include, but *before* the line after the
201      include.  As we walk up the #inclusion tree toward the main
202      source file, we update fileX and lineX as we go; includedX
203      indicates whether the original position was from the #included
204      file.  */
205   int included1 = 0;
206   int included2 = 0;
207
208   /* If a file is zero, that means "end of compilation unit."  Handle
209      that specially.  */
210   if (! file1)
211     {
212       if (! file2)
213         return 0;
214       else
215         return 1;
216     }
217   else if (! file2)
218     return -1;
219
220   /* If the two files are not the same, find their common ancestor in
221      the #inclusion tree.  */
222   if (file1 != file2)
223     {
224       /* If one file is deeper than the other, walk up the #inclusion
225          chain until the two files are at least at the same *depth*.
226          Then, walk up both files in synchrony until they're the same
227          file.  That file is the common ancestor.  */
228       int depth1 = inclusion_depth (file1);
229       int depth2 = inclusion_depth (file2);
230
231       /* Only one of these while loops will ever execute in any given
232          case.  */
233       while (depth1 > depth2)
234         {
235           line1 = file1->included_at_line;
236           file1 = file1->included_by;
237           included1 = 1;
238           depth1--;
239         }
240       while (depth2 > depth1)
241         {
242           line2 = file2->included_at_line;
243           file2 = file2->included_by;
244           included2 = 1;
245           depth2--;
246         }
247
248       /* Now both file1 and file2 are at the same depth.  Walk toward
249          the root of the tree until we find where the branches meet.  */
250       while (file1 != file2)
251         {
252           line1 = file1->included_at_line;
253           file1 = file1->included_by;
254           /* At this point, we know that the case the includedX flags
255              are trying to deal with won't come up, but we'll just
256              maintain them anyway.  */
257           included1 = 1;
258
259           line2 = file2->included_at_line;
260           file2 = file2->included_by;
261           included2 = 1;
262
263           /* Sanity check.  If file1 and file2 are really from the
264              same compilation unit, then they should both be part of
265              the same tree, and this shouldn't happen.  */
266           gdb_assert (file1 && file2);
267         }
268     }
269
270   /* Now we've got two line numbers in the same file.  */
271   if (line1 == line2)
272     {
273       /* They can't both be from #included files.  Then we shouldn't
274          have walked up this far.  */
275       gdb_assert (! included1 || ! included2);
276
277       /* Any #included position comes after a non-#included position
278          with the same line number in the #including file.  */
279       if (included1)
280         return 1;
281       else if (included2)
282         return -1;
283       else
284         return 0;
285     }
286   else
287     return line1 - line2;
288 }
289
290
291 /* Compare a macro key KEY against NAME, the source file FILE, and
292    line number LINE.
293
294    Sort definitions by name; for two definitions with the same name,
295    place the one whose definition comes earlier before the one whose
296    definition comes later.
297
298    Return -1, 0, or 1 if key comes before, is identical to, or comes
299    after NAME, FILE, and LINE.  */
300 static int
301 key_compare (struct macro_key *key,
302              const char *name, struct macro_source_file *file, int line)
303 {
304   int names = strcmp (key->name, name);
305   if (names)
306     return names;
307
308   return compare_locations (key->start_file, key->start_line,
309                             file, line);
310 }
311
312
313 /* The macro tree comparison function, typed for the splay tree
314    library's happiness.  */
315 static int
316 macro_tree_compare (splay_tree_key untyped_key1,
317                     splay_tree_key untyped_key2)
318 {
319   struct macro_key *key1 = (struct macro_key *) untyped_key1;
320   struct macro_key *key2 = (struct macro_key *) untyped_key2;
321
322   return key_compare (key1, key2->name, key2->start_file, key2->start_line);
323 }
324
325
326 /* Construct a new macro key node for a macro in table T whose name is
327    NAME, and whose scope starts at LINE in FILE; register the name in
328    the bcache.  */
329 static struct macro_key *
330 new_macro_key (struct macro_table *t,
331                const char *name,
332                struct macro_source_file *file,
333                int line)
334 {
335   struct macro_key *k = macro_alloc (sizeof (*k), t);
336
337   memset (k, 0, sizeof (*k));
338   k->table = t;
339   k->name = macro_bcache_str (t, name);
340   k->start_file = file;
341   k->start_line = line;
342   k->end_file = 0;
343
344   return k;
345 }
346
347
348 static void
349 macro_tree_delete_key (void *untyped_key)
350 {
351   struct macro_key *key = (struct macro_key *) untyped_key;
352
353   macro_bcache_free (key->table, (char *) key->name);
354   macro_free (key, key->table);
355 }
356
357
358 \f
359 /* Building and querying the tree of #included files.  */
360
361
362 /* Allocate and initialize a new source file structure.  */
363 static struct macro_source_file *
364 new_source_file (struct macro_table *t,
365                  const char *filename)
366 {
367   /* Get space for the source file structure itself.  */
368   struct macro_source_file *f = macro_alloc (sizeof (*f), t);
369
370   memset (f, 0, sizeof (*f));
371   f->table = t;
372   f->filename = macro_bcache_str (t, filename);
373   f->includes = 0;
374
375   return f;
376 }
377
378
379 /* Free a source file, and all the source files it #included.  */
380 static void
381 free_macro_source_file (struct macro_source_file *src)
382 {
383   struct macro_source_file *child, *next_child;
384
385   /* Free this file's children.  */
386   for (child = src->includes; child; child = next_child)
387     {
388       next_child = child->next_included;
389       free_macro_source_file (child);
390     }
391
392   macro_bcache_free (src->table, (char *) src->filename);
393   macro_free (src, src->table);
394 }
395
396
397 struct macro_source_file *
398 macro_set_main (struct macro_table *t,
399                 const char *filename)
400 {
401   /* You can't change a table's main source file.  What would that do
402      to the tree?  */
403   gdb_assert (! t->main_source);
404
405   t->main_source = new_source_file (t, filename);
406
407   return t->main_source;
408 }
409
410
411 struct macro_source_file *
412 macro_main (struct macro_table *t)
413 {
414   gdb_assert (t->main_source);
415
416   return t->main_source;
417 }
418
419
420 struct macro_source_file *
421 macro_include (struct macro_source_file *source,
422                int line,
423                const char *included)
424 {
425   struct macro_source_file *new;
426   struct macro_source_file **link;
427
428   /* Find the right position in SOURCE's `includes' list for the new
429      file.  Skip inclusions at earlier lines, until we find one at the
430      same line or later --- or until the end of the list.  */
431   for (link = &source->includes;
432        *link && (*link)->included_at_line < line;
433        link = &(*link)->next_included)
434     ;
435
436   /* Did we find another file already #included at the same line as
437      the new one?  */
438   if (*link && line == (*link)->included_at_line)
439     {
440       /* This means the compiler is emitting bogus debug info.  (GCC
441          circa March 2002 did this.)  It also means that the splay
442          tree ordering function, macro_tree_compare, will abort,
443          because it can't tell which #inclusion came first.  But GDB
444          should tolerate bad debug info.  So:
445
446          First, squawk.  */
447       complaint (&symfile_complaints,
448                  _("both `%s' and `%s' allegedly #included at %s:%d"), included,
449                  (*link)->filename, source->filename, line);
450
451       /* Now, choose a new, unoccupied line number for this
452          #inclusion, after the alleged #inclusion line.  */
453       while (*link && line == (*link)->included_at_line)
454         {
455           /* This line number is taken, so try the next line.  */
456           line++;
457           link = &(*link)->next_included;
458         }
459     }
460
461   /* At this point, we know that LINE is an unused line number, and
462      *LINK points to the entry an #inclusion at that line should
463      precede.  */
464   new = new_source_file (source->table, included);
465   new->included_by = source;
466   new->included_at_line = line;
467   new->next_included = *link;
468   *link = new;
469
470   return new;
471 }
472
473
474 struct macro_source_file *
475 macro_lookup_inclusion (struct macro_source_file *source, const char *name)
476 {
477   /* Is SOURCE itself named NAME?  */
478   if (strcmp (name, source->filename) == 0)
479     return source;
480
481   /* The filename in the source structure is probably a full path, but
482      NAME could be just the final component of the name.  */
483   {
484     int name_len = strlen (name);
485     int src_name_len = strlen (source->filename);
486
487     /* We do mean < here, and not <=; if the lengths are the same,
488        then the strcmp above should have triggered, and we need to
489        check for a slash here.  */
490     if (name_len < src_name_len
491         && source->filename[src_name_len - name_len - 1] == '/'
492         && strcmp (name, source->filename + src_name_len - name_len) == 0)
493       return source;
494   }
495
496   /* It's not us.  Try all our children, and return the lowest.  */
497   {
498     struct macro_source_file *child;
499     struct macro_source_file *best = NULL;
500     int best_depth = 0;
501
502     for (child = source->includes; child; child = child->next_included)
503       {
504         struct macro_source_file *result
505           = macro_lookup_inclusion (child, name);
506
507         if (result)
508           {
509             int result_depth = inclusion_depth (result);
510
511             if (! best || result_depth < best_depth)
512               {
513                 best = result;
514                 best_depth = result_depth;
515               }
516           }
517       }
518
519     return best;
520   }
521 }
522
523
524 \f
525 /* Registering and looking up macro definitions.  */
526
527
528 /* Construct a definition for a macro in table T.  Cache all strings,
529    and the macro_definition structure itself, in T's bcache.  */
530 static struct macro_definition *
531 new_macro_definition (struct macro_table *t,
532                       enum macro_kind kind,
533                       int argc, const char **argv,
534                       const char *replacement)
535 {
536   struct macro_definition *d = macro_alloc (sizeof (*d), t);
537
538   memset (d, 0, sizeof (*d));
539   d->table = t;
540   d->kind = kind;
541   d->replacement = macro_bcache_str (t, replacement);
542
543   if (kind == macro_function_like)
544     {
545       int i;
546       const char **cached_argv;
547       int cached_argv_size = argc * sizeof (*cached_argv);
548
549       /* Bcache all the arguments.  */
550       cached_argv = alloca (cached_argv_size);
551       for (i = 0; i < argc; i++)
552         cached_argv[i] = macro_bcache_str (t, argv[i]);
553
554       /* Now bcache the array of argument pointers itself.  */
555       d->argv = macro_bcache (t, cached_argv, cached_argv_size);
556       d->argc = argc;
557     }
558
559   /* We don't bcache the entire definition structure because it's got
560      a pointer to the macro table in it; since each compilation unit
561      has its own macro table, you'd only get bcache hits for identical
562      definitions within a compilation unit, which seems unlikely.
563
564      "So, why do macro definitions have pointers to their macro tables
565      at all?"  Well, when the splay tree library wants to free a
566      node's value, it calls the value freeing function with nothing
567      but the value itself.  It makes the (apparently reasonable)
568      assumption that the value carries enough information to free
569      itself.  But not all macro tables have bcaches, so not all macro
570      definitions would be bcached.  There's no way to tell whether a
571      given definition is bcached without knowing which table the
572      definition belongs to.  ...  blah.  The thing's only sixteen
573      bytes anyway, and we can still bcache the name, args, and
574      definition, so we just don't bother bcaching the definition
575      structure itself.  */
576   return d;
577 }
578
579
580 /* Free a macro definition.  */
581 static void
582 macro_tree_delete_value (void *untyped_definition)
583 {
584   struct macro_definition *d = (struct macro_definition *) untyped_definition;
585   struct macro_table *t = d->table;
586
587   if (d->kind == macro_function_like)
588     {
589       int i;
590
591       for (i = 0; i < d->argc; i++)
592         macro_bcache_free (t, (char *) d->argv[i]);
593       macro_bcache_free (t, (char **) d->argv);
594     }
595   
596   macro_bcache_free (t, (char *) d->replacement);
597   macro_free (d, t);
598 }
599
600
601 /* Find the splay tree node for the definition of NAME at LINE in
602    SOURCE, or zero if there is none.  */
603 static splay_tree_node
604 find_definition (const char *name,
605                  struct macro_source_file *file,
606                  int line)
607 {
608   struct macro_table *t = file->table;
609   splay_tree_node n;
610
611   /* Construct a macro_key object, just for the query.  */
612   struct macro_key query;
613
614   query.name = name;
615   query.start_file = file;
616   query.start_line = line;
617   query.end_file = NULL;
618
619   n = splay_tree_lookup (t->definitions, (splay_tree_key) &query);
620   if (! n)
621     {
622       /* It's okay for us to do two queries like this: the real work
623          of the searching is done when we splay, and splaying the tree
624          a second time at the same key is a constant time operation.
625          If this still bugs you, you could always just extend the
626          splay tree library with a predecessor-or-equal operation, and
627          use that.  */
628       splay_tree_node pred = splay_tree_predecessor (t->definitions,
629                                                      (splay_tree_key) &query);
630      
631       if (pred)
632         {
633           /* Make sure this predecessor actually has the right name.
634              We just want to search within a given name's definitions.  */
635           struct macro_key *found = (struct macro_key *) pred->key;
636
637           if (strcmp (found->name, name) == 0)
638             n = pred;
639         }
640     }
641
642   if (n)
643     {
644       struct macro_key *found = (struct macro_key *) n->key;
645
646       /* Okay, so this definition has the right name, and its scope
647          begins before the given source location.  But does its scope
648          end after the given source location?  */
649       if (compare_locations (file, line, found->end_file, found->end_line) < 0)
650         return n;
651       else
652         return 0;
653     }
654   else
655     return 0;
656 }
657
658
659 /* If NAME already has a definition in scope at LINE in SOURCE, return
660    the key.  If the old definition is different from the definition
661    given by KIND, ARGC, ARGV, and REPLACEMENT, complain, too.
662    Otherwise, return zero.  (ARGC and ARGV are meaningless unless KIND
663    is `macro_function_like'.)  */
664 static struct macro_key *
665 check_for_redefinition (struct macro_source_file *source, int line,
666                         const char *name, enum macro_kind kind,
667                         int argc, const char **argv,
668                         const char *replacement)
669 {
670   splay_tree_node n = find_definition (name, source, line);
671
672   if (n)
673     {
674       struct macro_key *found_key = (struct macro_key *) n->key;
675       struct macro_definition *found_def
676         = (struct macro_definition *) n->value;
677       int same = 1;
678
679       /* Is this definition the same as the existing one?
680          According to the standard, this comparison needs to be done
681          on lists of tokens, not byte-by-byte, as we do here.  But
682          that's too hard for us at the moment, and comparing
683          byte-by-byte will only yield false negatives (i.e., extra
684          warning messages), not false positives (i.e., unnoticed
685          definition changes).  */
686       if (kind != found_def->kind)
687         same = 0;
688       else if (strcmp (replacement, found_def->replacement))
689         same = 0;
690       else if (kind == macro_function_like)
691         {
692           if (argc != found_def->argc)
693             same = 0;
694           else
695             {
696               int i;
697
698               for (i = 0; i < argc; i++)
699                 if (strcmp (argv[i], found_def->argv[i]))
700                   same = 0;
701             }
702         }
703
704       if (! same)
705         {
706           complaint (&symfile_complaints,
707                      _("macro `%s' redefined at %s:%d; original definition at %s:%d"),
708                      name, source->filename, line,
709                      found_key->start_file->filename, found_key->start_line);
710         }
711
712       return found_key;
713     }
714   else
715     return 0;
716 }
717
718
719 void
720 macro_define_object (struct macro_source_file *source, int line,
721                      const char *name, const char *replacement)
722 {
723   struct macro_table *t = source->table;
724   struct macro_key *k;
725   struct macro_definition *d;
726
727   k = check_for_redefinition (source, line, 
728                               name, macro_object_like,
729                               0, 0,
730                               replacement);
731
732   /* If we're redefining a symbol, and the existing key would be
733      identical to our new key, then the splay_tree_insert function
734      will try to delete the old definition.  When the definition is
735      living on an obstack, this isn't a happy thing.
736
737      Since this only happens in the presence of questionable debug
738      info, we just ignore all definitions after the first.  The only
739      case I know of where this arises is in GCC's output for
740      predefined macros, and all the definitions are the same in that
741      case.  */
742   if (k && ! key_compare (k, name, source, line))
743     return;
744
745   k = new_macro_key (t, name, source, line);
746   d = new_macro_definition (t, macro_object_like, 0, 0, replacement);
747   splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
748 }
749
750
751 void
752 macro_define_function (struct macro_source_file *source, int line,
753                        const char *name, int argc, const char **argv,
754                        const char *replacement)
755 {
756   struct macro_table *t = source->table;
757   struct macro_key *k;
758   struct macro_definition *d;
759
760   k = check_for_redefinition (source, line,
761                               name, macro_function_like,
762                               argc, argv,
763                               replacement);
764
765   /* See comments about duplicate keys in macro_define_object.  */
766   if (k && ! key_compare (k, name, source, line))
767     return;
768
769   /* We should also check here that all the argument names in ARGV are
770      distinct.  */
771
772   k = new_macro_key (t, name, source, line);
773   d = new_macro_definition (t, macro_function_like, argc, argv, replacement);
774   splay_tree_insert (t->definitions, (splay_tree_key) k, (splay_tree_value) d);
775 }
776
777
778 void
779 macro_undef (struct macro_source_file *source, int line,
780              const char *name)
781 {
782   splay_tree_node n = find_definition (name, source, line);
783
784   if (n)
785     {
786       /* This function is the only place a macro's end-of-scope
787          location gets set to anything other than "end of the
788          compilation unit" (i.e., end_file is zero).  So if this macro
789          already has its end-of-scope set, then we're probably seeing
790          a second #undefinition for the same #definition.  */
791       struct macro_key *key = (struct macro_key *) n->key;
792
793       if (key->end_file)
794         {
795           complaint (&symfile_complaints,
796                      _("macro '%s' is #undefined twice, at %s:%d and %s:%d"), name,
797                      source->filename, line, key->end_file->filename,
798                      key->end_line);
799         }
800
801       /* Whatever the case, wipe out the old ending point, and 
802          make this the ending point.  */
803       key->end_file = source;
804       key->end_line = line;
805     }
806   else
807     {
808       /* According to the ISO C standard, an #undef for a symbol that
809          has no macro definition in scope is ignored.  So we should
810          ignore it too.  */
811 #if 0
812       complaint (&symfile_complaints,
813                  _("no definition for macro `%s' in scope to #undef at %s:%d"),
814                  name, source->filename, line);
815 #endif
816     }
817 }
818
819
820 struct macro_definition *
821 macro_lookup_definition (struct macro_source_file *source,
822                          int line, const char *name)
823 {
824   splay_tree_node n = find_definition (name, source, line);
825
826   if (n)
827     return (struct macro_definition *) n->value;
828   else
829     return 0;
830 }
831
832
833 struct macro_source_file *
834 macro_definition_location (struct macro_source_file *source,
835                            int line,
836                            const char *name,
837                            int *definition_line)
838 {
839   splay_tree_node n = find_definition (name, source, line);
840
841   if (n)
842     {
843       struct macro_key *key = (struct macro_key *) n->key;
844       *definition_line = key->start_line;
845       return key->start_file;
846     }
847   else
848     return 0;
849 }
850
851
852 \f
853 /* Creating and freeing macro tables.  */
854
855
856 struct macro_table *
857 new_macro_table (struct obstack *obstack,
858                  struct bcache *b)
859 {
860   struct macro_table *t;
861
862   /* First, get storage for the `struct macro_table' itself.  */
863   if (obstack)
864     t = obstack_alloc (obstack, sizeof (*t));
865   else
866     t = xmalloc (sizeof (*t));
867
868   memset (t, 0, sizeof (*t));
869   t->obstack = obstack;
870   t->bcache = b;
871   t->main_source = NULL;
872   t->definitions = (splay_tree_new_with_allocator
873                     (macro_tree_compare,
874                      ((splay_tree_delete_key_fn) macro_tree_delete_key),
875                      ((splay_tree_delete_value_fn) macro_tree_delete_value),
876                      ((splay_tree_allocate_fn) macro_alloc),
877                      ((splay_tree_deallocate_fn) macro_free),
878                      t));
879   
880   return t;
881 }
882
883
884 void
885 free_macro_table (struct macro_table *table)
886 {
887   /* Free the source file tree.  */
888   free_macro_source_file (table->main_source);
889
890   /* Free the table of macro definitions.  */
891   splay_tree_delete (table->definitions);
892 }