Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Forums
  - IRC
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Foundation
  - Donate
- Resources
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

# ddmd.dsymbol

Compiler implementation of the D programming language.
Authors:
Walter Bright
License:
Boost License 1.0

Source: dsymbol.d

class `Dsymbol`: ddmd.root.rootobject.RootObject;
  final Module `getModule`();
    Determine which Module a Dsymbol is in.
  final Module `getAccessModule`();
    Determine which Module a Dsymbol is in, as far as access rights go.
  final inout inout(Dsymbol) `toParent`();
  final inout inout(Dsymbol) `toParent2`();
    parent field returns a lexically enclosing scope symbol this is a member of.
    `toParent`() returns a logically enclosing scope symbol this is a member of. It skips over TemplateMixin's.
    `toParent2`() returns an enclosing scope symbol this is living at runtime. It skips over both TemplateInstance's and TemplateMixin's. It's used when looking for the 'this' pointer of the enclosing function/class.
    Examples:
    module mod; template Foo(alias a) { mixin Bar!(); } mixin template Bar() { public { // ProtDeclaration void baz() { a = 2; } } } void test() { int v = 1; alias foo = Foo!(v); foo.baz(); assert(v == 2); }
    // s == FuncDeclaration('mod.test.Foo!().Bar!().baz()') // s.parent == TemplateMixin('mod.test.Foo!().Bar!()') // s.`toParent`() == TemplateInstance('mod.test.Foo!()') // s.`toParent2`() == FuncDeclaration('mod.test')
  static Dsymbols* `arraySyntaxCopy`(Dsymbols* `a`);
    Do syntax copy of an array of Dsymbol's.
  Dsymbol `toAlias`();
    If this symbol is really an alias for another, return that other. If needed, semantic() is invoked due to resolve forward reference.
  Dsymbol `toAlias2`();
    Resolve recursive tuple expansion in eponymous template.
  int `apply`(Dsymbol_apply_ft_t `fp`, void* `param`);
    Iterate this dsymbol or members of this scoped dsymbol, then call `fp` with the found symbol and `param`.
    Parameters:

    Dsymbol_apply_ft_t `fp` | function pointer to process the iterated symbol. If it returns nonzero, the iteration will be aborted.
    void* `param` | a parameter passed to `fp`.

    Returns:
    nonzero if the iteration is aborted by the return value of `fp`, or 0 if it's completed.
  void `setScope`(Scope* `sc`);
    Set scope for future semantic analysis so we can deal better with forward references.
  void `semantic`(Scope* `sc`);
    Does `semantic` analysis on the public face of declarations.
  void `semantic2`(Scope* `sc`);
    Does semantic analysis on initializers and members of aggregates.
  void `semantic3`(Scope* `sc`);
    Does semantic analysis on function bodies.
  Dsymbol `search`(Loc `loc`, Identifier `ident`, int `flags` = IgnoreNone);
    Search for `ident` as member of s.
    Parameters:

    Loc `loc` | location to print for error messages
    Identifier `ident` | identifier to `search` for
    int `flags` | IgnoreXXXX

    Returns:
    `null` if not found
  final Dsymbol `searchX`(Loc `loc`, Scope* `sc`, RootObject `id`);
    Search for identifier `id` as a member of 'this'. `id` may be a template instance.
    Returns:
    symbol found, NULL if not
  d_uns64 `size`(Loc `loc`);
    Returns:
    SIZE_INVALID when the `size` cannot be determined
  final AggregateDeclaration `isMember`();
    Returns an AggregateDeclaration when toParent() is that.
  final AggregateDeclaration `isMember2`();
    Returns an AggregateDeclaration when toParent2() is that.
  Prot `prot`();
  Dsymbol `syntaxCopy`(Dsymbol `s`);
    Copy the syntax. Used for template instantiations. If `s` is NULL, allocate the new object, otherwise fill it in.
  bool `oneMember`(Dsymbol* `ps`, Identifier `ident`);
    Determine if this symbol is only one.
    Returns:
    `false`, *`ps` = NULL: There are 2 or more symbols `true`, *`ps` = NULL: There are zero symbols `true`, *`ps` = symbol: The one and only one symbol
  static bool `oneMembers`(Dsymbols* `members`, Dsymbol* `ps`, Identifier `ident`);
    Same as Dsymbol::oneMember(), but look at an array of Dsymbols.
  bool `hasPointers`();
    Is Dsymbol a variable that contains pointers?
  void `addComment`(const(char)* `comment`);
    Add documentation `comment` to Dsymbol. Ignore NULL comments.
  final bool `inNonRoot`();
    Returns `true` if this symbol is defined in a non-root module without instantiation.
  void `accept`(Visitor `v`);
class `ScopeDsymbol`: ddmd.dsymbol.Dsymbol;
  Dsymbol that generates a scope
  Dsymbol `search`(Loc `loc`, Identifier `ident`, int `flags` = SearchLocalsOnly);
    This function is #1 on the list of functions that eat cpu time. Be very, very careful about slowing it down.
  final FuncDeclaration `findGetMembers`();
    Look for member of the form: const(MemberInfo)[] getMembers(string); Returns NULL if not found
  Dsymbol `symtabLookup`(Dsymbol `s`, Identifier `id`);
    Look up identifier in symbol table.
  bool `hasStaticCtorOrDtor`();
    Return `true` if any of the members are static ctors or static dtors, or if any members have members that are.
  static size_t `dim`(Dsymbols* `members`);
    Determine number of Dsymbols, folding in AttribDeclaration `members`.
  static Dsymbol `getNth`(Dsymbols* `members`, size_t `nth`, size_t* `pn` = null);
    Get `nth` Dsymbol, folding in AttribDeclaration `members`.
    Returns:
    Dsymbol* `nth` Dsymbol NULL not found, *`pn` gets incremented by the number of Dsymbols
  static int `_foreach`(Scope* `sc`, Dsymbols* `members`, scope ForeachDg `dg`, size_t* `pn` = null);
    Expands attribute declarations in `members` in depth first order. Calls `dg`(size_t symidx, Dsymbol *sym) for each member. If `dg` returns !=0, stops and returns that value else returns 0. Use this function to avoid the O(N + N^2/2) complexity of calculating dim and calling N times getNth.
    Returns:
    last value returned by `dg`()
class `WithScopeSymbol`: ddmd.dsymbol.ScopeDsymbol;
  With statement scope
class `ArrayScopeSymbol`: ddmd.dsymbol.ScopeDsymbol;
  Array Index/Slice scope
class `OverloadSet`: ddmd.dsymbol.Dsymbol;
  Overload Sets
class `ForwardingScopeDsymbol`: ddmd.dsymbol.ScopeDsymbol;
  Forwarding ScopeDsymbol. Used by ForwardingAttribDeclaration and ForwardingScopeDeclaration to forward symbol insertions to another scope. See ddmd.attrib.ForwardingAttribDeclaration for more details.
  ScopeDsymbol `forward`;
    Symbol to `forward` insertions to. Can be null before being lazily initialized.
  Dsymbol `symtabLookup`(Dsymbol `s`, Identifier `id`);
    This override handles the following two cases: static foreach (i, i; [0]) { ... } and static foreach (i; [0]) { enum i = 2; }
class `DsymbolTable`: ddmd.root.rootobject.RootObject;
  Table of Dsymbol's
  const pure uint `len`();
    Returns:
    number of symbols in symbol table

Copyright © 1999-2017 by the D Language Foundation | Page generated by Ddoc on Fri Sep 1 12:52:35 2017