dmd.dmodule - D Programming Language
Description: D Programming Language
Keywords: D programming language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - 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.

# dmd.dmodule

Defines a package and module.

Specification Modules

Authors:
Walter Bright
License:
Boost License 1.0

Source dmodule.d

Documentation https://dlang.org/phobos/dmd_dmodule.html

Coverage https://codecov.io/gh/dlang/dmd/src/master/src/dmd/dmodule.d

class `Package`: dmd.dsymbol.ScopeDsymbol;
  static DsymbolTable `resolve`(Identifiers* `packages`, Dsymbol* `pparent`, Package* `ppkg`);

    Input packages[] the pkg1.pkg2 of pkg1.pkg2.mod

    Returns:
    the symbol table that mod should be inserted into

    Output *pparent the rightmost package, i.e. pkg2, or NULL if no packages *ppkg the leftmost package, i.e. pkg1, or NULL if no packages

  final const bool `isAncestorPackageOf`(const Package `pkg`);
    Checks if pkg is a sub-package of this
    For example, if this qualifies to 'a1.a2' and pkg - to 'a1.a2.a3', this function returns 'true'. If it is other way around or qualified package paths conflict function returns 'false'.
    Parameters:

    Package `pkg` | possible subpackage

    Returns:
    see description
  final void `resolvePKGunknown`();
    Checks for the existence of a package.d to set isPkgMod appropriately if isPkgMod == PKG.unknown
class `Module`: dmd.dmodule.Package;
  static void `deinitialize`();
    Deinitializes the global state of the compiler.
    This can be used to restore the state set by _init to its original state.
  bool `selfImports`();
    Return true if module imports itself.
  bool `rootImports`();
    Return true if module imports root module.
  Module `importedFrom`;
    A root module is one that will be compiled all the way to object code. This field holds the root module that caused this module to be loaded. If this module is a root module, then it will be set to this. This is used to determine ownership of template instantiation.
  FileName `setOutfilename`(const(char)[] `name`, const(char)[] `dir`, const(char)[] `arg`, const(char)[] `ext`);
    Combines things into output file name for .html and .di files.

    Input name Command line name given for the file, NULL if none dir Command line directory given for the file, NULL if none arg Name of the source file ext File name extension to use if 'name' is NULL global.params.preservePaths get output path from arg srcfile Input file - output file name must not match input file

  bool `loadSourceBuffer`(ref const Loc `loc`, ref File.ReadResult `readResult`);
    Loads the source buffer from the given read result into this.srcBuffer.
    Will take ownership of the buffer located inside `readResult`.
    Parameters:

    Loc `loc` | the location
    File.ReadResult `readResult` | the result of reading a file containing the source code

    Returns:
    true if successful
  bool `read`(ref const Loc `loc`);
    Reads the file from srcfile and loads the source buffer.
    Parameters:

    Loc `loc` | the location

    Returns:
    true if successful
    See Also:
    loadSourceBuffer
  Module `parse`();
  Module `parseModule`(AST)();
    syntactic parse
  int `needModuleInfo`();
    Determine if we need to generate an instance of ModuleInfo for this Module.
  void `checkImportDeprecation`(ref const Loc `loc`, Scope* `sc`);
    Print deprecation warning if we're deprecated, when this module is imported from scope sc.
    Parameters:

    Scope* `sc` | the scope into which we are imported
    Loc `loc` | the location of the import statement

  static void `addDeferredSemantic`(Dsymbol `s`);
    Can't run semantic on s now, try again later.
  static void `runDeferredSemantic`();
    Run semantic() on deferred symbols.
  int `imports`(Module `m`);
    Recursively look at every module this module imports, return true if it imports m. Can be used to detect circular imports.
  void `fullyQualifiedName`(ref OutBuffer `buf`);
    Writes this module's fully-qualified name to buf
    Parameters:

    OutBuffer `buf` | The buffer to write to

struct `ModuleDeclaration`;
  const const(char)[] `toString`();
    Provide a human readable representation

Copyright © 1999-2020 by the D Language Foundation | Page generated by Ddoc on Mon May 11 10:58:02 2020