/* Helper routines for D support in GDB.
- Copyright (C) 2014-2017 Free Software Foundation, Inc.
+ Copyright (C) 2014-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "language.h"
#include "namespace.h"
#include "d-lang.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
+#include "gdbarch.h"
/* This returns the length of first component of NAME, which should be
the demangled name of a D variable/function/method/etc.
if (block == NULL)
gdbarch = target_gdbarch ();
else
- gdbarch = block_gdbarch (block);
+ gdbarch = block->gdbarch ();
sym.symbol
= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
sym.block = NULL;
lang_this = lookup_language_this (language_def (language_d), block);
if (lang_this.symbol == NULL)
- return null_block_symbol;
+ return {};
- type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
- classname = TYPE_NAME (type);
+ type = check_typedef (lang_this.symbol->type ()->target_type ());
+ classname = type->name ();
nested = name;
}
else
more that can be done. */
class_sym = lookup_global_symbol (classname.c_str (), block, domain);
if (class_sym.symbol == NULL)
- return null_block_symbol;
+ return {};
/* Look for a symbol named NESTED in this class. */
- sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
+ sym = d_lookup_nested_symbol (class_sym.symbol->type (),
nested.c_str (), block);
}
find_symbol_in_baseclass (struct type *parent_type, const char *name,
const struct block *block)
{
- struct block_symbol sym;
+ struct block_symbol sym = {};
int i;
- sym.symbol = NULL;
- sym.block = NULL;
-
for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
{
struct type *base_type = TYPE_BASECLASS (parent_type, i);
parent_type = check_typedef (parent_type);
- switch (TYPE_CODE (parent_type))
+ switch (parent_type->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
case TYPE_CODE_MODULE:
{
int size;
- const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
+ const char *parent_name = type_name_or_error (saved_parent_type);
struct block_symbol sym
= d_lookup_symbol_in_module (parent_name, nested_name,
block, VAR_DOMAIN, 0);
case TYPE_CODE_FUNC:
case TYPE_CODE_METHOD:
- return null_block_symbol;
+ return {};
default:
gdb_assert_not_reached ("called with non-aggregate type.");
the module we're searching in, see if we can find a match by
applying them. */
- for (current = block_using (block);
+ for (current = block->get_using ();
current != NULL;
current = current->next)
{
}
}
- return null_block_symbol;
+ return {};
}
/* Searches for NAME in the current module, and by applying relevant
if (sym.symbol != NULL)
return sym;
- block = BLOCK_SUPERBLOCK (block);
+ block = block->superblock ();
}
- return null_block_symbol;
+ return {};
}
/* The D-specific version of name lookup for static and global names
const domain_enum domain)
{
struct block_symbol sym;
- const char *scope = block_scope (block);
+ const char *scope = block == nullptr ? "" : block->scope ();
sym = lookup_module_scope (langdef, name, block, domain, scope, 0);
if (sym.symbol != NULL)