| Module | Description |
std.algorithm.comparison
|
This is a submodule of std.algorithm.
It contains generic comparison algorithms.
|
std.algorithm.iteration
|
This is a submodule of std.algorithm.
It contains generic iteration algorithms.
|
std.algorithm.mutation
|
This is a submodule of std.algorithm.
It contains generic mutation algorithms.
|
std.algorithm.searching
|
This is a submodule of std.algorithm.
It contains generic searching algorithms.
|
std.algorithm.setops
|
This is a submodule of std.algorithm.
It contains generic algorithms that implement set operations.
|
std.algorithm.sorting
|
This is a submodule of std.algorithm.
It contains generic sorting algorithms.
|
std.container.array
|
This module provides an Array type with deterministic memory usage not
reliant on the GC, as an alternative to the built-in arrays.
|
std.container.binaryheap
|
This module provides a BinaryHeap (aka priority queue)
adaptor that makes a binary heap out of any user-provided random-access range.
|
std.container.dlist
|
This module implements a generic doubly-linked list container.
It can be used as a queue, dequeue or stack.
|
std.container.rbtree
|
This module implements a red-black tree container.
|
std.container.slist
|
This module implements a singly-linked list container.
It can be used as a stack.
|
std.container.util
|
This module contains some common utilities used by containers.
|
std.datetime.date
|
|
std.datetime.interval
|
|
std.datetime.stopwatch
|
Module containing some basic benchmarking and timing functionality.
|
std.datetime.systime
|
|
std.datetime.timezone
|
|
std.digest.crc
|
Cyclic Redundancy Check (32-bit) implementation.
|
std.digest.hmac
|
This package implements the hash-based message authentication code (HMAC)
algorithm as defined in RFC2104. See also
the corresponding Wikipedia article.
|
std.digest.md
|
Computes MD5 hashes of arbitrary data. MD5 hashes are 16 byte quantities that are like a
checksum or CRC, but are more robust.
|
std.digest.murmurhash
|
Computes MurmurHash hashes
of arbitrary data. MurmurHash is a non-cryptographic hash function suitable
for general hash-based lookup. It is optimized for x86 but can be used on
all architectures.
|
std.digest.ripemd
|
Computes RIPEMD-160 hashes of arbitrary data. RIPEMD-160 hashes are 20 byte quantities
that are like a checksum or CRC, but are more robust.
|
std.digest.sha
|
Computes SHA1 and SHA2 hashes of arbitrary data. SHA hashes are 20 to 64 byte
quantities (depending on the SHA algorithm) that are like a checksum or CRC,
but are more robust.
|
std.experimental.allocator.building_blocks.affix_allocator
|
|
std.experimental.allocator.building_blocks.aligned_block_list
|
AlignedBlockList represents a wrapper around a chain of allocators, allowing for fast deallocations
and preserving a low degree of fragmentation by means of aligned allocations.
|
std.experimental.allocator.building_blocks.allocator_list
|
|
std.experimental.allocator.building_blocks.ascending_page_allocator
|
|
std.experimental.allocator.building_blocks.bitmapped_block
|
|
std.experimental.allocator.building_blocks.bucketizer
|
|
std.experimental.allocator.building_blocks.fallback_allocator
|
|
std.experimental.allocator.building_blocks.free_list
|
|
std.experimental.allocator.building_blocks.free_tree
|
|
std.experimental.allocator.building_blocks.kernighan_ritchie
|
|
std.experimental.allocator.building_blocks.null_allocator
|
|
std.experimental.allocator.building_blocks.quantizer
|
|
std.experimental.allocator.building_blocks.region
|
|
std.experimental.allocator.building_blocks.scoped_allocator
|
|
std.experimental.allocator.building_blocks.segregator
|
|
std.experimental.allocator.building_blocks.stats_collector
|
Allocator that collects useful statistics about allocations, both global and per
calling point. The statistics collected can be configured statically by choosing
combinations of Options appropriately.
|
std.experimental.allocator.building_blocks
|
Assembling Your Own Allocator
|
std.experimental.allocator.common
|
Utility and ancillary artifacts of std.experimental.allocator. This module
shouldn't be used directly; its functionality will be migrated into more
appropriate parts of std.
|
std.experimental.allocator.gc_allocator
|
D's built-in garbage-collected allocator.
|
std.experimental.allocator.mallocator
|
The C heap allocator.
|
std.experimental.allocator.mmap_allocator
|
|
std.experimental.allocator.showcase
|
Collection of typical and useful prebuilt allocators using the given
components. User code would typically import this module and use its
facilities, or import individual heap building blocks and assemble them.
|
std.experimental.allocator.typed
|
This module defines TypedAllocator, a statically-typed allocator that
aggregates multiple untyped allocators and uses them depending on the static
properties of the types allocated. For example, distinct allocators may be used
for thread-local vs. thread-shared data, or for fixed-size data (struct,
class objects) vs. resizable data (arrays).
|
std.experimental.logger.core
|
|
std.experimental.logger.filelogger
|
|
std.experimental.logger.multilogger
|
|
std.experimental.logger.nulllogger
|
|
std.experimental.allocator
|
High-level interface for allocators. Implements bundled allocation/creation
and destruction/deallocation of data including structs and classes,
and also array primitives related to allocation. This module is the entry point
for both making use of allocators and for their documentation.
|
std.experimental.checkedint
|
This module is now deprecated, use std.experimental
instead.
|
std.experimental.logger
|
Implements logging facilities.
|
std.experimental.typecons
|
This module implements experimental additions/modifications to std.typecons.
|
std.format.read
|
This is a submodule of std.format.
|
std.format.spec
|
This is a submodule of std.format.
|
std.format.write
|
This is a submodule of std.format.
|
std.math.algebraic
|
This is a submodule of std.math.
|
std.math.constants
|
This is a submodule of std.math.
|
std.math.exponential
|
This is a submodule of std.math.
|
std.math.hardware
|
This is a submodule of std.math.
|
std.math.operations
|
This is a submodule of std.math.
|
std.math.remainder
|
This is a submodule of std.math.
|
std.math.rounding
|
This is a submodule of std.math.
|
std.math.traits
|
This is a submodule of std.math.
|
std.math.trigonometry
|
This is a submodule of std.math.
|
std.net.curl
|
Networking client functionality as provided by libcurl. The libcurl library must be installed on the system in order to use
this module.
|
std.net.isemail
|
Validates an email address according to RFCs 5321, 5322 and others.
|
std.range.interfaces
|
This module is a submodule of std.range.
|
std.range.primitives
|
This module is a submodule of std.range.
|
std.windows.charset
|
Support UTF-8 on Windows 95, 98 and ME systems.
|
std.windows.syserror
|
Convert Win32 error code to string.
|
std.algorithm
|
This package implements generic algorithms oriented towards the processing of
sequences. Sequences processed by these functions define range-based
interfaces. See also Reference on ranges and
tutorial on ranges.
|
std.array
|
Functions and types that manipulate built-in arrays and associative arrays.
|
std.ascii
|
Functions which operate on ASCII characters.
|
std.base64
|
Support for Base64 encoding and decoding.
|
std.bigint
|
Arbitrary-precision ('bignum') arithmetic.
|
std.bitmanip
|
Bit-level manipulation facilities.
|
std.checkedint
|
|
std.compiler
|
Identify the compiler used and its various features.
|
std.complex
|
This module contains the Complex type, which is used to represent
complex numbers, along with related mathematical operations and functions.
|
std.concurrency
|
|
std.container
|
This module defines generic containers.
|
std.conv
|
A one-stop shop for converting values from one type to another.
|
std.csv
|
Implements functionality to read Comma Separated Values and its variants
from an input range of dchar.
|
std.datetime
|
|
std.demangle
|
Demangle D mangled names.
|
std.digest
|
This module describes the digest APIs used in Phobos. All digests follow
these APIs. Additionally, this module contains useful helper methods which
can be used with every digest type.
|
std.encoding
|
Classes and functions for handling and transcoding between various encodings.
|
std.exception
|
This module defines functions related to exceptions and general error
handling. It also defines functions intended to aid in unit testing.
|
std.file
|
Utilities for manipulating files and scanning directories. Functions
in this module handle files as a unit, e.g., read or write one file
at a time. For opening files and manipulating them via handles refer
to module std.stdio.
|
std.format
|
This package provides string formatting functionality using
printf style format strings.
|
std.functional
|
Functions that manipulate other functions.
|
std.getopt
|
Processing of command line options.
|
std.json
|
JavaScript Object Notation
|
std.math
|
Contains the elementary mathematical functions (powers, roots,
and trigonometric functions), and low-level floating-point operations.
Mathematical special functions are available in std.mathspecial.
|
std.mathspecial
|
Mathematical Special Functions
|
std.meta
|
Templates to manipulate
template parameter sequences
(also known as alias sequences).
|
std.mmfile
|
Read and write memory mapped files.
|
std.numeric
|
This module is a port of a growing fragment of the numeric
header in Alexander Stepanov's Standard Template Library, with a few additions.
|
std.outbuffer
|
Serialize data to ubyte arrays.
|
std.parallelism
|
std.parallelism implements high-level primitives for SMP parallelism.
These include parallel foreach, parallel reduce, parallel eager map, pipelining
and future/promise parallelism. std.parallelism is recommended when the
same operation is to be executed in parallel on different data, or when a
function is to be executed in a background thread and its result returned to a
well-defined main thread. For communication between arbitrary threads, see
std.concurrency.
|
std.path
|
This module is used to manipulate path strings.
|
std.process
|
Functions for starting and interacting with other processes, and for
working with the current process' execution environment.
|
std.random
|
Facilities for random number generation.
|
std.range
|
This module defines the notion of a range. Ranges generalize the concept of
arrays, lists, or anything that involves sequential access. This abstraction
enables the same set of algorithms (see std.algorithm) to be used
with a vast variety of different concrete types. For example,
a linear search algorithm such as find
works not just for arrays, but for linked-lists, input files,
incoming network data, etc.
|
std.regex
|
Regular expressions
are a commonly used method of pattern matching
on strings, with regex being a catchy word for a pattern in this domain
specific language. Typical problems usually solved by regular expressions
include validation of user input and the ubiquitous find & replace
in text processing utilities.
|
std.signals
|
Signals and Slots are an implementation of the Observer Pattern.
Essentially, when a Signal is emitted, a list of connected Observers
(called slots) are called.
|
std.socket
|
Socket primitives.
|
std.stdint
|
D constrains integral types to specific sizes. But efficiency
of different sizes varies from machine to machine,
pointer sizes vary, and the maximum integer size varies.
stdint offers a portable way of trading off size
vs efficiency, in a manner compatible with the stdint.h
definitions in C.
|
std.stdio
|
|
std.string
|
String handling functions.
|
std.sumtype
|
[SumType] is a generic discriminated union implementation that uses
design-by-introspection to generate safe and efficient code. Its features
|
std.system
|
Information about the target operating system, environment, and CPU.
|
std.traits
|
Templates which extract information about types and symbols at compile time.
|
std.typecons
|
This module implements a variety of type constructors, i.e., templates
that allow construction of new, useful general-purpose types.
|
std.uni
|
The std.uni module provides an implementation
of fundamental Unicode algorithms and data structures.
This doesn't include UTF encoding and decoding primitives,
see decode and encode in std.utf
for this functionality.
|
std.uri
|
Encode and decode Uniform Resource Identifiers (URIs).
URIs are used in internet transfer protocols.
Valid URI characters consist of letters, digits,
and the characters ;/?:@&=+$,-_.!~*'()
Reserved URI characters are ;/?:@&=+$
Escape sequences consist of % followed by two hex digits.
|
std.utf
|
Encode and decode UTF-8, UTF-16 and UTF-32 strings.
|
std.uuid
|
A UUID, or
Universally unique identifier,
is intended to uniquely identify information in a distributed environment
without significant central coordination. It can be
used to tag objects with very short lifetimes, or to reliably identify very
persistent objects across a network.
|
std.variant
|
This module implements a
discriminated union
type (a.k.a.
tagged union,
algebraic type).
Such types are useful
for type-uniform binary interfaces, interfacing with scripting
languages, and comfortable exploratory programming.
|
std.xml
|
Warning: This module is considered out-dated and not up to Phobos'
current standards. It will be removed from Phobos in 2.101.0.
If you still need it, go to https://github.com/DigitalMars/undeaD
|
std.zip
|
Read and write data in the
zip archive
format.
|
std.zlib
|
Compress/decompress data using the zlib library.
|
core.gc.config
|
Contains the garbage collector configuration.
|
core.gc.gcinterface
|
Contains the internal GC interface.
|
core.gc.registry
|
Contains a registry for GC factories.
|
core.stdcpp.allocator
|
D binding to C++ std::allocator.
|
core.stdcpp.array
|
D header file for interaction with C++ std::array.
|
core.stdcpp.exception
|
Interface to C++
|
core.stdcpp.memory
|
D binding to C++ .
|
core.stdcpp.new_
|
D binding to C++
|
core.stdcpp.string
|
D header file for interaction with C++ std::string.
|
core.stdcpp.string_view
|
D header file for interaction with C++ std::string_view.
|
core.stdcpp.type_traits
|
D header file for interaction with C++ std::type_traits.
|
core.stdcpp.typeinfo
|
Interface to C++
|
core.stdcpp.utility
|
D header file for interaction with Microsoft C++
|
core.stdcpp.vector
|
D header file for interaction with C++ std::vector.
|
core.stdcpp.xutility
|
D header file for interaction with Microsoft C++
|
core.sync.barrier
|
The barrier module provides a primitive for synchronizing the progress of
a group of threads.
|
core.sync.condition
|
The condition module provides a primitive for synchronized condition
checking.
|
core.sync.config
|
The config module contains utility routines and configuration information
specific to this package.
|
core.sync.event
|
The event module provides a primitive for lightweight signaling of other threads
(emulating Windows events on Posix)
|
core.sync.exception
|
Define base class for synchronization exceptions.
|
core.sync.mutex
|
The mutex module provides a primitive for maintaining mutually exclusive
access.
|
core.sync.rwmutex
|
The read/write mutex module provides a primitive for maintaining shared read
access and mutually exclusive write access.
|
core.sync.semaphore
|
The semaphore module provides a general use semaphore for synchronization.
|
core.thread.context
|
The thread module provides support for thread creation and management.
|
core.thread.fiber
|
The fiber module provides OS-indepedent lightweight threads aka fibers.
|
core.thread.osthread
|
The osthread module provides low-level, OS-dependent code
for thread creation and management.
|
core.thread.threadbase
|
The threadbase module provides OS-independent code
for thread storage and management.
|
core.thread.threadgroup
|
The osthread module provides types used in threads modules.
|
core.thread.types
|
This module provides types and constants used in thread package.
|
core.atomic
|
The atomic module provides basic support for lock-free
concurrent programming.
|
core.attribute
|
This module contains UDA's (User Defined Attributes) either used in
the runtime or special UDA's recognized by compiler.
|
core.bitop
|
This module contains a collection of bit-level operations.
|
core.builtins
|
To provide access to features that would be otherwise counterproductive or
difficult to implement, compilers provide an interface consisting of a set
of builtins (also called intrinsics) which can be called like normal functions.
|
core.checkedint
|
This module implements integral arithmetic primitives that check
for out-of-range results.
|
core.cpuid
|
Identify the characteristics of the host CPU, providing information
about cache sizes and assembly optimisation hints. This module is
provided primarily for assembly language programmers.
|
core.demangle
|
The demangle module converts mangled D symbols to a representation similar
to what would have existed in code.
|
core.exception
|
The exception module defines all system-level exceptions and provides a
mechanism to alter system-level error handling.
|
core.math
|
Builtin mathematical intrinsics
|
core.memory
|
This module provides an interface to the garbage collector used by
applications written in the D programming language. It allows the
garbage collector in the runtime to be swapped without affecting
binary compatibility of applications.
|
core.runtime
|
The runtime module exposes information specific to the D runtime code.
|
core.simd
|
Builtin SIMD intrinsics
|
core.thread
|
The thread module provides support for thread creation and management.
|
core.time
|
Module containing core time functionality, such as Duration (which
represents a duration of time) or MonoTime (which represents a
timestamp of the system's monotonic clock).
|
core.vararg
|
The vararg module is intended to facilitate vararg manipulation in D.
It should be interface compatible with the C module "stdarg," and the
two modules may share a common implementation if possible (as is done
here).
|
core.volatile
|
This module declares intrinsics for volatile operations.
|
dmd.backend.aarray
|
Associative Array implementation
|
dmd.backend.backconfig
|
Configure the back end (optimizer and code generator)
|
dmd.backend.backend
|
Internal header file for the backend
|
dmd.backend.barray
|
Generic resizeable array
|
dmd.backend.bcomplex
|
A complex number implementation
|
dmd.backend.blockopt
|
Manipulating basic blocks and their edges.
|
dmd.backend.cc
|
Common definitions
|
dmd.backend.cdef
|
Configuration enums/variables for different targets
|
dmd.backend.cg
|
Various global symbols.
|
dmd.backend.cg87
|
x87 FPU code generation
|
dmd.backend.cgcod
|
Top level code for the code generator.
|
dmd.backend.cgcs
|
Compute common subexpressions for non-optimized code generation
|
dmd.backend.cgcse
|
Manage the memory allocated on the runtime stack to save Common Subexpressions (CSE).
|
dmd.backend.cgcv
|
Interface for CodeView symbol debug info generation
|
dmd.backend.cgelem
|
Local optimizations of elem trees
|
dmd.backend.cgen
|
Generate code instructions
|
dmd.backend.cgobj
|
Compiler implementation of the
D programming language.
|
dmd.backend.cgreg
|
Register allocator
|
dmd.backend.cgsched
|
Instruction scheduler
|
dmd.backend.cgxmm
|
xmm specific code generation
|
dmd.backend.cod1
|
Code generation 1
|
dmd.backend.cod2
|
Code generation 2
|
dmd.backend.cod3
|
Code generation 3
|
dmd.backend.cod4
|
Code generation 4
|
dmd.backend.cod5
|
Code generation 5
|
dmd.backend.code
|
Define registers, register masks, and the CPU instruction linked list
|
dmd.backend.code_x86
|
Constants and data structures specific to the x86 platform.
|
dmd.backend.codebuilder
|
Construct linked list of generated code
|
dmd.backend.cv4
|
CodeView 4 symbolic debug info declarations
|
dmd.backend.cv8
|
CodeView 8 symbolic debug info generation
|
dmd.backend.dcgcv
|
CodeView 4 symbolic debug info generation
|
dmd.backend.dcode
|
Allocate and free code blocks
|
dmd.backend.debugprint
|
Pretty print data structures
|
dmd.backend.disasm86
|
X86 disassembler. Can disassemble 16, 32, and 64 bit code. Includes
x87 FPU instructions and vector instructions.
|
dmd.backend.dlist
|
Interface to the C linked list type.
|
dmd.backend.dout
|
Transition from intermediate representation to code generator
|
dmd.backend.drtlsym
|
Compiler runtime function symbols
|
dmd.backend.dt
|
Intermediate representation for static data
|
dmd.backend.dtype
|
Compiler implementation of the
D programming language.
|
dmd.backend.dvarstats
|
Support for lexical scope of local variables
|
dmd.backend.dvec
|
Compiler implementation of the
D programming language.
|
dmd.backend.dwarf
|
Definitions for DWARF debug infos (v3 to v5)
|
dmd.backend.dwarf2
|
Reflects declarations from the DWARF 3 to 5 specification, not the The D Language Foundation
dwarf implementation
|
dmd.backend.dwarfdbginf
|
Emit Dwarf symbolic debug info
|
dmd.backend.dwarfeh
|
Implements LSDA (Language Specific Data Area) table generation
for Dwarf Exception Handling.
|
dmd.backend.ee
|
Code to handle debugger expression evaluation
|
dmd.backend.el
|
Expression trees (intermediate representation)
|
dmd.backend.elem
|
Routines to handle elems.
|
dmd.backend.elfobj
|
Output to ELF object files
|
dmd.backend.elpicpie
|
Generate elems for fixed, PIC, and PIE code generation.
|
dmd.backend.errors
|
Compiler implementation of the
D programming language.
|
dmd.backend.evalu8
|
Constant folding
|
dmd.backend.exh
|
Interface for exception handling support
|
dmd.backend.fp
|
Compiler implementation of the
D programming language.
|
dmd.backend.gdag
|
Directed acyclic graphs and global optimizer common subexpressions
|
dmd.backend.gflow
|
Code to do the Data Flow Analysis (doesn't act on the data).
|
dmd.backend.global
|
Declarations for back end
|
dmd.backend.glocal
|
Local optimizations
|
dmd.backend.gloop
|
Global loop optimizations
|
dmd.backend.go
|
Global optimizer main loop
|
dmd.backend.goh
|
Global optimizer declarations
|
dmd.backend.gother
|
Other global optimizations
|
dmd.backend.gsroa
|
SROA structured replacement of aggregate optimization
|
dmd.backend.iasm
|
Declarations for ptrntab.d, the instruction tables for the inline assembler.
|
dmd.backend.mach
|
Mach-O object file format
|
dmd.backend.machobj
|
Generate Mach-O object files
|
dmd.backend.md5
|
|
dmd.backend.melf
|
Declarations for ELF file format
|
dmd.backend.mem
|
Compiler implementation of the
D programming language.
|
dmd.backend.mscoff
|
Microsoft COFF object file format
|
dmd.backend.mscoffobj
|
Compiler implementation of the
D programming language.
|
dmd.backend.newman
|
"new" C++ name mangling scheme
|
dmd.backend.nteh
|
Support for NT exception handling
|
dmd.backend.obj
|
Compiler implementation of the
D programming language.
|
dmd.backend.oper
|
Compiler implementation of the
D programming language.
|
dmd.backend.os
|
Operating system specific routines.
|
dmd.backend.pdata
|
Generates the .pdata and .xdata sections for Win64
|
dmd.backend.ph2
|
A leaking bump-the-pointer allocator
|
dmd.backend.ptrntab
|
Instruction tables for inline assembler.
|
dmd.backend.rtlsym
|
Compiler runtime function symbols
|
dmd.backend.symbol
|
Symbols for the back end
|
dmd.backend.symtab
|
Symbol table array.
|
dmd.backend.ty
|
Define basic types and type masks
|
dmd.backend.type
|
Types for the back end
|
dmd.backend.util2
|
Utility subroutines
|
dmd.backend.var
|
Global variables for PARSER
|
dmd.backend.xmm
|
XMM opcodes
|
dmd.common.file
|
File utilities.
|
dmd.common.outbuffer
|
An expandable buffer in which you can write text or binary data.
|
dmd.common.string
|
Common string functions including filename manipulation.
|
dmd.root.aav
|
Associative array implementation.
|
dmd.root.array
|
Dynamic array implementation.
|
dmd.root.bitarray
|
Implementation of a bit array.
|
dmd.root.complex
|
Implements a complex number type.
|
dmd.root.ctfloat
|
Collects functions for compile-time floating-point calculations.
|
dmd.root.env
|
Functions for modifying environment variables.
|
dmd.root.file
|
Read a file from disk and store it in memory.
|
dmd.root.filename
|
Encapsulate path and file names.
|
dmd.root.hash
|
Hash functions for arbitrary binary data.
|
dmd.root.longdouble
|
80-bit floating point value implementation if the C/D compiler does not support them natively.
|
dmd.root.man
|
Open an online manual page.
|
dmd.root.optional
|
Implementation of an 'Optional' type
|
dmd.root.port
|
Portable routines for functions that have different implementations on different platforms.
|
dmd.root.region
|
Region storage allocator implementation.
|
dmd.root.response
|
Parse command line arguments from response files.
|
dmd.root.rmem
|
Allocate memory using malloc or the GC depending on the configuration.
|
dmd.root.rootobject
|
Provide the root object that classes in dmd inherit from.
|
dmd.root.speller
|
Spell checker
|
dmd.root.string
|
Contains various string related functions.
|
dmd.root.stringtable
|
A specialized associative array with string keys stored in a variable length structure.
|
dmd.root.strtold
|
Provides a D implementation of the standard C function strtold (String to long double).
|
dmd.root.utf
|
Functions related to UTF encoding.
|
dmd.access
|
Enforce visibility contrains such as public and private.
|
dmd.aggregate
|
Defines a Dsymbol representing an aggregate, which is a struct, union or class.
|
dmd.aliasthis
|
Implements the alias this symbol.
|
dmd.apply
|
A depth-first visitor for expressions.
|
dmd.argtypes_aarch64
|
Break down a D type into basic (register) types for the AArch64 ABI.
|
dmd.argtypes_sysv_x64
|
Break down a D type into basic (register) types for the x86_64 System V ABI.
|
dmd.argtypes_x86
|
Break down a D type into basic (register) types for the 32-bit x86 ABI.
|
dmd.arrayop
|
Implement array operations, such as a[] = b[] + c[].
|
dmd.arraytypes
|
Provide aliases for arrays of certain declarations or statements.
|
dmd.ast_node
|
Defines the base class for all nodes which are part of the AST.
|
dmd.astbase
|
Defines AST nodes for the parsing stage.
|
dmd.astcodegen
|
Defines AST nodes for the code generation stage.
|
dmd.astenums
|
Defines enums common to dmd and dmd as parse library.
|
dmd.asttypename
|
Development utility for printing AST nodes by their internal name, instead of as D source code.
|
dmd.attrib
|
Defines declarations of various attributes.
|
dmd.blockexit
|
Find out in what ways control flow can exit a statement block.
|
dmd.builtin
|
Implement CTFE for intrinsic (builtin) functions.
|
dmd.canthrow
|
Perform checks for nothrow.
|
dmd.chkformat
|
Check the arguments to printf and scanf against the format string.
|
dmd.cli
|
Defines the help texts for the CLI options offered by DMD.
|
dmd.clone
|
Builds struct member functions if needed and not defined by the user.
Includes opEquals, opAssign, post blit, copy constructor and destructor.
|
dmd.compiler
|
Describes a back-end compiler and implements compiler-specific actions.
|
dmd.cond
|
Evaluate compile-time conditionals, such as static if version and debug.
|
dmd.console
|
Control the various text mode attributes, such as color, when writing text
to the console.
|
dmd.constfold
|
Perform constant folding of arithmetic expressions.
|
dmd.cparse
|
Takes a token stream from the lexer, and parses it into an abstract syntax tree.
|
dmd.cppmangle
|
Do mangling for C++ linkage.
|
dmd.cppmanglewin
|
Do mangling for C++ linkage for Digital Mars C++ and Microsoft Visual C++.
|
dmd.ctfeexpr
|
CTFE for expressions involving pointers, slices, array concatenation etc.
|
dmd.ctorflow
|
Manage flow analysis for constructors.
|
dmd.dcast
|
Semantic analysis for cast-expressions.
|
dmd.dclass
|
Defines a class declaration.
|
dmd.declaration
|
Miscellaneous declarations, including typedef, alias, variable declarations including the
implicit this declaration, type tuples, ClassInfo, ModuleInfo and various TypeInfos.
|
dmd.delegatize
|
Implements conversion from expressions to delegates for lazy parameters.
|
dmd.denum
|
Define enum declarations and enum members.
|
dmd.dimport
|
A Dsymbol representing a renamed import.
|
dmd.dinifile
|
Parses compiler settings from a .ini file.
|
dmd.dinterpret
|
The entry point for CTFE.
|
dmd.dmacro
|
Text macro processor for Ddoc.
|
dmd.dmangle
|
Does name mangling for extern(D) symbols.
|
dmd.dmdparams
|
DMD-specific parameters.
|
dmd.dmodule
|
Defines a package and module.
|
dmd.dmsc
|
Configures and initializes the backend.
|
dmd.doc
|
Ddoc documentation generation.
|
dmd.dscope
|
A scope as defined by curly braces {}.
|
dmd.dstruct
|
Struct and union declarations.
|
dmd.dsymbol
|
The base class for a D symbol, which can be a module, variable, function, enum, etc.
|
dmd.dsymbolsem
|
Does the semantic 1 pass on the AST, which looks at symbol declarations but not initializers
or function bodies.
|
dmd.dtemplate
|
Defines TemplateDeclaration, TemplateInstance and a few utilities
|
dmd.dtoh
|
This module contains the implementation of the C++ header generation available through
the command line switch -Hc.
|
dmd.dversion
|
Defines a Dsymbol for version = identifier and debug = identifier statements.
|
dmd.e2ir
|
Converts expressions to Intermediate Representation (IR) for the backend.
|
dmd.eh
|
Support for exception handling for EH_DM and EH_WIN32.
Generate exception handling tables.
|
dmd.entity
|
Defines the named entities to support the "\\&Entity;" escape sequence for strings / character literals.
|
dmd.errors
|
Functions for raising errors.
|
dmd.escape
|
Most of the logic to implement scoped pointers and scoped references is here.
|
dmd.expression
|
Defines the bulk of the classes which represent the AST at the expression level.
|
dmd.expressionsem
|
Semantic analysis of expressions.
|
dmd.file_manager
|
Read a file from disk and store it in memory.
|
dmd.foreachvar
|
Utility to visit every variable in an expression.
|
dmd.frontend
|
Contains high-level interfaces for interacting with DMD as a library.
|
dmd.func
|
Defines a function declaration.
|
dmd.globals
|
Stores command line options and contains other miscellaneous declarations.
|
dmd.glue
|
Generate the object file for function declarations and critical sections.
|
dmd.gluelayer
|
Declarations for back-end functions that the front-end invokes.
|
dmd.hdrgen
|
Generate D interface files.
|
dmd.iasm
|
Inline assembler for the D programming language compiler.
|
dmd.iasmdmd
|
Inline assembler implementation for DMD.
|
dmd.iasmgcc
|
Inline assembler for the GCC D compiler.
|
dmd.id
|
Contains the Id struct with a list of predefined symbols the compiler knows about.
|
dmd.identifier
|
Defines an identifier, which is the name of a Dsymbol.
|
dmd.impcnvtab
|
Provides an implicit conversion table for basic types.
|
dmd.imphint
|
Give import hints for common symbol names that couldn't be resolved.
|
dmd.importc
|
Contains semantic routines specific to ImportC
|
dmd.init
|
Defines initializers of variables, e.g. the array literal in int[3] x = [0, 1, 2].
|
dmd.initsem
|
Semantic analysis of initializers.
|
dmd.inline
|
Performs inlining, which is an optimization pass enabled with the -inline flag.
|
dmd.inlinecost
|
Compute the cost of inlining a function call by counting expressions.
|
dmd.intrange
|
Implement Value Range Propagation.
|
dmd.json
|
Code for generating .json descriptions of the module when passing the -X flag to dmd.
|
dmd.lambdacomp
|
Implements the serialization of a lambda function.
|
dmd.lexer
|
Implements the lexical analyzer, which converts source code into lexical tokens.
|
dmd.lib
|
A module defining an abstract library.
Implementations for various formats are in separate libXXX.d modules.
|
dmd.libelf
|
A library in the ELF format, used on Unix.
|
dmd.libomf
|
A library in the OMF format, a legacy format for 32-bit Windows.
|
dmd.link
|
Invoke the linker as a separate process.
|
dmd.mars
|
Entry point for DMD.
|
dmd.mtype
|
Defines a D type.
|
dmd.nogc
|
Checks that a function marked @nogc does not invoke the Garbage Collector.
|
dmd.nspace
|
A scoped C++ namespace symbol
|
dmd.ob
|
Flow analysis for Ownership/Borrowing
|
dmd.objc
|
Interfacing with Objective-C.
|
dmd.objc_glue
|
Glue code for Objective-C interop.
|
dmd.opover
|
Handles operator overloading.
|
dmd.optimize
|
Perform constant folding.
|
dmd.parse
|
Takes a token stream from the lexer, and parses it into an abstract syntax tree.
|
dmd.parsetimevisitor
|
Defines a visitor for the AST.
|
dmd.permissivevisitor
|
A visitor that facilitates the traversal of subsets of the AST.
|
dmd.printast
|
Provides an AST printer for debugging.
|
dmd.s2ir
|
Convert statements to Intermediate Representation (IR) for the back-end.
|
dmd.safe
|
Checks whether member access or array casting is allowed in @safe code.
|
dmd.sapply
|
Provides a depth-first statement visitor.
|
dmd.scanelf
|
Extract symbols from an ELF object file.
|
dmd.scanomf
|
Extract symbols from an OMF object file.
|
dmd.semantic2
|
Performs the semantic2 stage, which deals with initializer expressions.
|
dmd.semantic3
|
Performs the semantic3 stage, which deals with function bodies.
|
dmd.sideeffect
|
Find side-effects of expressions.
|
dmd.statement
|
Defines AST nodes for statements.
|
dmd.statement_rewrite_walker
|
Provides a visitor for statements that allows rewriting the currently visited node.
|
dmd.statementsem
|
Does semantic analysis for statements.
|
dmd.staticassert
|
Defines the Dsymbol representing a static assert().
|
dmd.staticcond
|
Lazily evaluate static conditions for static if, static assert and template constraints.
|
dmd.stmtstate
|
Used to help transform statement AST into flow graph.
|
dmd.strictvisitor
|
|
dmd.target
|
Handles target-specific parameters
|
dmd.templateparamsem
|
Semantic analysis of template parameters.
|
dmd.tocsym
|
Convert a D symbol to a symbol the linker understands (with mangled name).
|
dmd.toctype
|
Convert a D type to a type the backend understands.
|
dmd.tocvdebug
|
Generate debug info in the CV4 debug format.
|
dmd.todt
|
Put initializers and objects created from CTFE into a dt_t data structure
so the backend puts them into the data segment.
|
dmd.toir
|
Convert to Intermediate Representation (IR) for the back-end.
|
dmd.tokens
|
Defines lexical tokens.
|
dmd.toobj
|
Convert an AST that went through all semantic phases into an object file.
|
dmd.traits
|
Handle introspection functionality of the __traits() construct.
|
dmd.transitivevisitor
|
|
dmd.typesem
|
Semantic analysis for D types.
|
dmd.typinf
|
Generate TypeInfo objects, which are needed for run-time introspection of types.
|
dmd.utils
|
This module defines some utility functions for DMD.
|
dmd.visitor
|
Provides a visitor class visiting all AST nodes present in the compiler.
|
dmd.vsoptions
|
When compiling on Windows with the Microsoft toolchain, try to detect the Visual Studio setup.
|
etc.c.odbc.sql
|
Deprecated. Use core.sys.windows.sql instead. This module will be
removed in February 2022.
|
etc.c.odbc.sqlext
|
Deprecated. Use core.sys.windows.sqlext instead. This module will be
removed in February 2022.
|
etc.c.odbc.sqltypes
|
Deprecated. Use core.sys.windows.sqltypes instead. This module will be
removed in February 2022.
|
etc.c.odbc.sqlucode
|
Deprecated. Use core.sys.windows.sqlucode instead. This module will be
removed in February 2022.
|
etc.c.curl
|
This is an interface to the libcurl library.
|
rt.util.typeinfo
|
This module contains utilities for TypeInfo implementation.
|
rt.util.utility
|
Contains various utility functions used by the runtime implementation.
|
rt.aaA
|
Implementation of associative arrays.
|
rt.aApply
|
This code handles decoding UTF strings for foreach loops. There are 6
combinations of conversions between char, wchar, and dchar, and 2 of each
of those.
|
rt.aApplyR
|
This code handles decoding UTF strings for foreach_reverse loops. There are
6 combinations of conversions between char, wchar, and dchar, and 2 of each
of those.
|
rt.adi
|
Implementation of dynamic array property support routines.
|
rt.alloca
|
Implementation of alloca() standard C routine.
|
rt.arrayassign
|
Implementation of array assignment support routines.
|
rt.arraycat
|
Implementation of array copy support routines.
|
rt.cast_
|
Implementation of array assignment support routines.
|
rt.cmath2
|
Runtime support for complex arithmetic code generation (for Posix).
|
rt.config
|
Configuration options for druntime.
|
rt.cover
|
Implementation of code coverage analyzer.
|
rt.critical_
|
Implementation of support routines for synchronized blocks.
|
rt.deh
|
Entry point for exception handling support routines.
|
rt.deh_win32
|
Implementation of exception handling support routines for Win32.
|
rt.deh_win64_posix
|
Implementation of exception handling support routines for Win64.
|
rt.dmain2
|
Contains druntime startup and shutdown routines.
|
rt.dwarfeh
|
Exception handling support for Dwarf-style portable exceptions.
|
rt.ehalloc
|
Exception allocation, cloning, and release compiler support routines.
|
rt.lifetime
|
This module contains all functions related to an object's lifetime:
allocation, resizing, deallocation, and finalization.
|
rt.llmath
|
Support for 64-bit longs.
|
rt.memory
|
This module tells the garbage collector about the static data and bss segments,
so the GC can scan them for roots. It does not deal with thread local static data.
|
rt.memset
|
Contains a memset implementation used by compiler-generated code.
|
rt.minfo
|
Written in the D programming language.
Module initialization routines.
|
rt.monitor_
|
Contains the implementation for object monitors.
|
rt.msvc
|
This module provides MS VC runtime helper functions that
wrap differences between MS C runtime versions.
|
rt.msvc_math
|
Alternate implementations of single-precision math functions missing in at
least some 32-bit x86 MS VC runtime versions.
These alternate symbols are referenced in the rt.msvc module.
|
rt.sections
|
|
rt.sections_android
|
Written in the D programming language.
This module provides bionic-specific support for sections.
|
rt.sections_darwin_64
|
Written in the D programming language.
This module provides Darwin 64 bit specific support for sections.
|
rt.sections_elf_shared
|
Written in the D programming language.
This module provides ELF-specific support for sections with shared libraries.
|
rt.sections_osx_x86
|
Written in the D programming language.
This module provides OS X x86 specific support for sections.
|
rt.sections_osx_x86_64
|
Written in the D programming language.
This module provides OS X x86-64 specific support for sections.
|
rt.sections_solaris
|
Written in the D programming language.
This module provides Solaris-specific support for sections.
|
rt.sections_win32
|
Written in the D programming language.
This module provides Win32-specific support for sections.
|
rt.sections_win64
|
Written in the D programming language.
This module provides Win32-specific support for sections.
|
rt.tlsgc
|
|
rt.trace
|
Contains support code for code profiling.
|
rt.tracegc
|
Contains implementations of functions called when the
-profile=gc
switch is thrown.
|
object
|
|
std
|
Convenience file that allows to import entire Phobos in one import.
|
Access to plattform libraries is supported by specific D header files.
Deprecated D header files.
