1 /* Helper routines for D support in GDB.
3 Copyright (C) 2014-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
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 3 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, see <http://www.gnu.org/licenses/>. */
24 #include "namespace.h"
26 #include "gdb_obstack.h"
28 /* This returns the length of first component of NAME, which should be
29 the demangled name of a D variable/function/method/etc.
30 Specifically, it returns the index of the first dot forming the
31 boundary of the first component: so, given 'A.foo' or 'A.B.foo'
32 it returns the 1, and given 'foo', it returns 0. */
34 /* The character in NAME indexed by the return value is guaranteed to
35 always be either '.' or '\0'. */
38 d_find_first_component (const char *name
)
40 unsigned int index
= 0;
44 if (name
[index
] == '.' || name
[index
] == '\0')
49 /* If NAME is the fully-qualified name of a D function/variable/method,
50 this returns the length of its entire prefix: all of the modules and
51 classes that make up its name. Given 'A.foo', it returns 1, given
52 'A.B.foo', it returns 4, given 'foo', it returns 0. */
55 d_entire_prefix_len (const char *name
)
57 unsigned int current_len
= d_find_first_component (name
);
58 unsigned int previous_len
= 0;
60 while (name
[current_len
] != '\0')
62 gdb_assert (name
[current_len
] == '.');
63 previous_len
= current_len
;
66 current_len
+= d_find_first_component (name
+ current_len
);
72 /* Look up NAME in BLOCK's static block and in global blocks.
73 If SEARCH is non-zero, search through base classes for a matching
74 symbol. Other arguments are as in d_lookup_symbol_nonlocal. */
76 static struct block_symbol
77 d_lookup_symbol (const struct language_defn
*langdef
,
78 const char *name
, const struct block
*block
,
79 const domain_enum domain
, int search
)
81 struct block_symbol sym
;
83 sym
= lookup_symbol_in_static_block (name
, block
, domain
);
84 if (sym
.symbol
!= NULL
)
87 /* If we didn't find a definition for a builtin type in the static block,
88 such as "ucent" which is a specialist type, search for it now. */
89 if (langdef
!= NULL
&& domain
== VAR_DOMAIN
)
91 struct gdbarch
*gdbarch
;
94 gdbarch
= target_gdbarch ();
96 gdbarch
= block_gdbarch (block
);
98 = language_lookup_primitive_type_as_symbol (langdef
, gdbarch
, name
);
100 if (sym
.symbol
!= NULL
)
104 sym
= lookup_global_symbol (name
, block
, domain
);
106 if (sym
.symbol
!= NULL
)
111 char *classname
, *nested
;
112 unsigned int prefix_len
;
113 struct cleanup
*cleanup
;
114 struct block_symbol class_sym
;
116 /* A simple lookup failed. Check if the symbol was defined in
119 cleanup
= make_cleanup (null_cleanup
, NULL
);
121 /* Find the name of the class and the name of the method,
123 prefix_len
= d_entire_prefix_len (name
);
125 /* If no prefix was found, search "this". */
129 struct block_symbol lang_this
;
131 lang_this
= lookup_language_this (language_def (language_d
), block
);
132 if (lang_this
.symbol
== NULL
)
134 do_cleanups (cleanup
);
135 return null_block_symbol
;
138 type
= check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this
.symbol
)));
139 classname
= xstrdup (TYPE_NAME (type
));
140 nested
= xstrdup (name
);
144 /* The class name is everything up to and including PREFIX_LEN. */
145 classname
= savestring (name
, prefix_len
);
147 /* The rest of the name is everything else past the initial scope
149 nested
= xstrdup (name
+ prefix_len
+ 1);
152 /* Add cleanups to free memory for these strings. */
153 make_cleanup (xfree
, classname
);
154 make_cleanup (xfree
, nested
);
156 /* Lookup a class named CLASSNAME. If none is found, there is nothing
157 more that can be done. */
158 class_sym
= lookup_global_symbol (classname
, block
, domain
);
159 if (class_sym
.symbol
== NULL
)
161 do_cleanups (cleanup
);
162 return null_block_symbol
;
165 /* Look for a symbol named NESTED in this class. */
166 sym
= d_lookup_nested_symbol (SYMBOL_TYPE (class_sym
.symbol
),
168 do_cleanups (cleanup
);
174 /* Look up NAME in the D module MODULE. Other arguments are as in
175 d_lookup_symbol_nonlocal. If SEARCH is non-zero, search through
176 base classes for a matching symbol. */
178 static struct block_symbol
179 d_lookup_symbol_in_module (const char *module
, const char *name
,
180 const struct block
*block
,
181 const domain_enum domain
, int search
)
183 char *concatenated_name
= NULL
;
185 if (module
[0] != '\0')
188 = (char *) alloca (strlen (module
) + strlen (name
) + 2);
189 strcpy (concatenated_name
, module
);
190 strcat (concatenated_name
, ".");
191 strcat (concatenated_name
, name
);
192 name
= concatenated_name
;
195 return d_lookup_symbol (NULL
, name
, block
, domain
, search
);
198 /* Lookup NAME at module scope. SCOPE is the module that the current
199 function is defined within; only consider modules whose length is at
200 least SCOPE_LEN. Other arguments are as in d_lookup_symbol_nonlocal.
202 For example, if we're within a function A.B.f and looking for a
203 symbol x, this will get called with NAME = "x", SCOPE = "A.B", and
204 SCOPE_LEN = 0. It then calls itself with NAME and SCOPE the same,
205 but with SCOPE_LEN = 1. And then it calls itself with NAME and
206 SCOPE the same, but with SCOPE_LEN = 4. This third call looks for
207 "A.B.x"; if it doesn't find it, then the second call looks for "A.x",
208 and if that call fails, then the first call looks for "x". */
210 static struct block_symbol
211 lookup_module_scope (const struct language_defn
*langdef
,
212 const char *name
, const struct block
*block
,
213 const domain_enum domain
, const char *scope
,
218 if (scope
[scope_len
] != '\0')
220 /* Recursively search for names in child modules first. */
222 struct block_symbol sym
;
223 int new_scope_len
= scope_len
;
225 /* If the current scope is followed by ".", skip past that. */
226 if (new_scope_len
!= 0)
228 gdb_assert (scope
[new_scope_len
] == '.');
231 new_scope_len
+= d_find_first_component (scope
+ new_scope_len
);
232 sym
= lookup_module_scope (langdef
, name
, block
, domain
,
233 scope
, new_scope_len
);
234 if (sym
.symbol
!= NULL
)
238 /* Okay, we didn't find a match in our children, so look for the
239 name in the current module.
241 If we there is no scope and we know we have a bare symbol, then short
242 circuit everything and call d_lookup_symbol directly.
243 This isn't an optimization, rather it allows us to pass LANGDEF which
244 is needed for primitive type lookup. */
246 if (scope_len
== 0 && strchr (name
, '.') == NULL
)
247 return d_lookup_symbol (langdef
, name
, block
, domain
, 1);
249 module
= (char *) alloca (scope_len
+ 1);
250 strncpy (module
, scope
, scope_len
);
251 module
[scope_len
] = '\0';
252 return d_lookup_symbol_in_module (module
, name
,
256 /* Search through the base classes of PARENT_TYPE for a symbol named
257 NAME in block BLOCK. */
259 static struct block_symbol
260 find_symbol_in_baseclass (struct type
*parent_type
, const char *name
,
261 const struct block
*block
)
263 char *concatenated_name
= NULL
;
264 struct block_symbol sym
;
265 struct cleanup
*cleanup
;
270 cleanup
= make_cleanup (free_current_contents
, &concatenated_name
);
272 for (i
= 0; i
< TYPE_N_BASECLASSES (parent_type
); ++i
)
275 struct type
*base_type
= TYPE_BASECLASS (parent_type
, i
);
276 const char *base_name
= TYPE_BASECLASS_NAME (parent_type
, i
);
278 if (base_name
== NULL
)
281 /* Search this particular base class. */
282 sym
= d_lookup_symbol_in_module (base_name
, name
, block
,
284 if (sym
.symbol
!= NULL
)
287 /* Now search all static file-level symbols. We have to do this for
288 things like typedefs in the class. First search in this symtab,
289 what we want is possibly there. */
290 len
= strlen (base_name
) + strlen (name
) + 2;
291 concatenated_name
= (char *) xrealloc (concatenated_name
, len
);
292 xsnprintf (concatenated_name
, len
, "%s.%s", base_name
, name
);
293 sym
= lookup_symbol_in_static_block (concatenated_name
, block
,
295 if (sym
.symbol
!= NULL
)
298 /* Nope. We now have to search all static blocks in all objfiles,
299 even if block != NULL, because there's no guarantees as to which
300 symtab the symbol we want is in. */
301 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
302 if (sym
.symbol
!= NULL
)
305 /* If this class has base classes, search them next. */
306 base_type
= check_typedef (base_type
);
307 if (TYPE_N_BASECLASSES (base_type
) > 0)
309 sym
= find_symbol_in_baseclass (base_type
, name
, block
);
310 if (sym
.symbol
!= NULL
)
315 do_cleanups (cleanup
);
319 /* Look up a symbol named NESTED_NAME that is nested inside the D
320 class or module given by PARENT_TYPE, from within the context
321 given by BLOCK. Return NULL if there is no such nested type. */
324 d_lookup_nested_symbol (struct type
*parent_type
,
325 const char *nested_name
,
326 const struct block
*block
)
328 /* type_name_no_tag_required provides better error reporting using the
330 struct type
*saved_parent_type
= parent_type
;
332 parent_type
= check_typedef (parent_type
);
334 switch (TYPE_CODE (parent_type
))
336 case TYPE_CODE_STRUCT
:
337 case TYPE_CODE_UNION
:
339 case TYPE_CODE_MODULE
:
342 const char *parent_name
= type_name_no_tag_or_error (saved_parent_type
);
343 struct block_symbol sym
344 = d_lookup_symbol_in_module (parent_name
, nested_name
,
345 block
, VAR_DOMAIN
, 0);
346 char *concatenated_name
;
348 if (sym
.symbol
!= NULL
)
351 /* Now search all static file-level symbols. We have to do this
352 for things like typedefs in the class. We do not try to
353 guess any imported module as even the fully specified
354 module search is already not D compliant and more assumptions
355 could make it too magic. */
356 size
= strlen (parent_name
) + strlen (nested_name
) + 2;
357 concatenated_name
= (char *) alloca (size
);
359 xsnprintf (concatenated_name
, size
, "%s.%s",
360 parent_name
, nested_name
);
362 sym
= lookup_static_symbol (concatenated_name
, VAR_DOMAIN
);
363 if (sym
.symbol
!= NULL
)
366 /* If no matching symbols were found, try searching any
368 return find_symbol_in_baseclass (parent_type
, nested_name
, block
);
372 case TYPE_CODE_METHOD
:
373 return null_block_symbol
;
376 gdb_assert_not_reached ("called with non-aggregate type.");
380 /* Used for cleanups to reset the "searched" flag incase
384 reset_directive_searched (void *data
)
386 struct using_direct
*direct
= (struct using_direct
*) data
;
387 direct
->searched
= 0;
390 /* Search for NAME by applying all import statements belonging to
391 BLOCK which are applicable in SCOPE.
393 If SEARCH_PARENTS the search will include imports which are
394 applicable in parents of SCOPE.
403 If SCOPE is "A.B" and SEARCH_PARENTS is true, the imports of
404 modules X and Y will be considered. If SEARCH_PARENTS is false
405 only the import of Y is considered. */
407 static struct block_symbol
408 d_lookup_symbol_imports (const char *scope
, const char *name
,
409 const struct block
*block
,
410 const domain_enum domain
,
411 const int search_parents
)
413 struct using_direct
*current
;
414 struct block_symbol sym
;
416 struct cleanup
*searched_cleanup
;
418 /* First, try to find the symbol in the given module. */
419 sym
= d_lookup_symbol_in_module (scope
, name
, block
, domain
, 1);
421 if (sym
.symbol
!= NULL
)
424 /* Go through the using directives. If any of them add new names to
425 the module we're searching in, see if we can find a match by
428 for (current
= block_using (block
);
430 current
= current
->next
)
432 const char **excludep
;
433 int len
= strlen (current
->import_dest
);
435 directive_match
= (search_parents
436 ? (strncmp (scope
, current
->import_dest
, len
) == 0
439 || scope
[len
] == '\0'))
440 : strcmp (scope
, current
->import_dest
) == 0);
442 /* If the import destination is the current scope or one of its
443 ancestors then it is applicable. */
444 if (directive_match
&& !current
->searched
)
446 /* Mark this import as searched so that the recursive call
447 does not search it again. */
448 current
->searched
= 1;
449 searched_cleanup
= make_cleanup (reset_directive_searched
,
452 /* If there is an import of a single declaration, compare the
453 imported declaration (after optional renaming by its alias)
454 with the sought out name. If there is a match pass
455 current->import_src as MODULE to direct the search towards
456 the imported module. */
457 if (current
->declaration
458 && strcmp (name
, current
->alias
459 ? current
->alias
: current
->declaration
) == 0)
460 sym
= d_lookup_symbol_in_module (current
->import_src
,
461 current
->declaration
,
464 /* If a symbol was found or this import statement was an import
465 declaration, the search of this import is complete. */
466 if (sym
.symbol
!= NULL
|| current
->declaration
)
468 current
->searched
= 0;
469 discard_cleanups (searched_cleanup
);
471 if (sym
.symbol
!= NULL
)
477 /* Do not follow CURRENT if NAME matches its EXCLUDES. */
478 for (excludep
= current
->excludes
; *excludep
; excludep
++)
479 if (strcmp (name
, *excludep
) == 0)
483 discard_cleanups (searched_cleanup
);
487 /* If the import statement is creating an alias. */
488 if (current
->alias
!= NULL
)
490 if (strcmp (name
, current
->alias
) == 0)
492 /* If the alias matches the sought name. Pass
493 current->import_src as the NAME to direct the
494 search towards the aliased module. */
495 sym
= lookup_module_scope (NULL
, current
->import_src
, block
,
500 /* If the alias matches the first component of the
501 sought name, pass current->import_src as MODULE
502 to direct the search, skipping over the aliased
503 component in NAME. */
504 int name_scope
= d_find_first_component (name
);
506 if (name
[name_scope
] != '\0'
507 && strncmp (name
, current
->alias
, name_scope
) == 0)
511 sym
= d_lookup_symbol_imports (current
->import_src
,
519 /* If this import statement creates no alias, pass
520 current->import_src as MODULE to direct the search
521 towards the imported module. */
522 sym
= d_lookup_symbol_imports (current
->import_src
,
523 name
, block
, domain
, 0);
525 current
->searched
= 0;
526 discard_cleanups (searched_cleanup
);
528 if (sym
.symbol
!= NULL
)
533 return null_block_symbol
;
536 /* Searches for NAME in the current module, and by applying relevant
537 import statements belonging to BLOCK and its parents. SCOPE is the
538 module scope of the context in which the search is being evaluated. */
540 static struct block_symbol
541 d_lookup_symbol_module (const char *scope
, const char *name
,
542 const struct block
*block
,
543 const domain_enum domain
)
545 struct block_symbol sym
;
547 /* First, try to find the symbol in the given module. */
548 sym
= d_lookup_symbol_in_module (scope
, name
,
550 if (sym
.symbol
!= NULL
)
553 /* Search for name in modules imported to this and parent
555 while (block
!= NULL
)
557 sym
= d_lookup_symbol_imports (scope
, name
, block
, domain
, 1);
559 if (sym
.symbol
!= NULL
)
562 block
= BLOCK_SUPERBLOCK (block
);
565 return null_block_symbol
;
568 /* The D-specific version of name lookup for static and global names
569 This makes sure that names get looked for in all modules that are
570 in scope. NAME is the natural name of the symbol that we're looking
571 looking for, BLOCK is the block that we're searching within, DOMAIN
572 says what kind of symbols we're looking for, and if SYMTAB is non-NULL,
573 we should store the symtab where we found the symbol in it. */
576 d_lookup_symbol_nonlocal (const struct language_defn
*langdef
,
578 const struct block
*block
,
579 const domain_enum domain
)
581 struct block_symbol sym
;
582 const char *scope
= block_scope (block
);
584 sym
= lookup_module_scope (langdef
, name
, block
, domain
, scope
, 0);
585 if (sym
.symbol
!= NULL
)
588 return d_lookup_symbol_module (scope
, name
, block
, domain
);
This page took 0.042249 seconds and 4 git commands to generate.