dmd.backend.dtype

Compiler implementation of the D programming language.

Members

Functions

param_append_type
param_t* param_append_type(param_t** pp, type* t): Allocate a param_t of type t, and append it to parameter list.
param_calloc param_t* param_calloc(): Allocate a param_t.
param_free
void param_free(param_t** pparamlst): Free parameter list. Output: paramlst = null
param_free_l void param_free_l(param_t* p): Version of param_free() suitable for list_free().
param_search
Symbol* param_search(const(char)* name, param_t** pp): Search for member, create symbol as needed. Used for symbol tables for VLA's such as: void func(int n, int an);
param_t_createTal param_t* param_t_createTal(param_t* p, param_t* ptali): Create template-argument-list blank from template-parameter-list Input: ptali initial template-argument-list
param_t_length uint param_t_length(param_t* p): Compute number of parameters
param_t_print void param_t_print(param_t* p): Pretty-print a param_t
param_t_search param_t* param_t_search(param_t* p, const(char)* id): Look for Pident matching id
param_t_searchn int param_t_searchn(param_t* p, char* id): Look for Pident matching id
type_alignsize uint type_alignsize(type* t): Return the size of a type for alignment purposes.
type_alloc type* type_alloc(tym_t ty): Create a type & initialize it. Input: ty = TYxxxx
type_allocn type* type_allocn(tym_t ty, type* tn): Allocate a type of ty with a Tnext of tn.
type_assoc_array type* type_assoc_array(type* tkey, type* tvalue): Allocate an associative array type, which are key=value pairs
type_copy type* type_copy(type* t): Make copy of a type.
type_delegate type* type_delegate(type* tnext): Allocate a delegate type.
type_dyn_array type* type_dyn_array(type* tnext): Allocate a dynamic array type.
type_embed int type_embed(type* t, type* u): Recursively check if type u is embedded in type t.
type_enum type* type_enum(const(char)* name, type* tbase): Create an enum type. Input: name name of enum tbase "base" type of enum
type_fake type* type_fake(tym_t ty): Fake a type & initialize it. Input: ty = TYxxxx
type_free void type_free(type* t): Free up data type.
type_function type* type_function(tym_t tyf, type*[] ptypes, bool variadic, type* tret): Allocation a function type.
type_isdependent int type_isdependent(type* t): Determine if type t is a dependent type.
type_isvla int type_isvla(type* t): Determine if type is a VLA.
type_parameterSize uint type_parameterSize(type* t, tym_t tyf): Compute the size of a single parameter.
type_paramsize uint type_paramsize(type* t): Compute the total size of parameters for function call. Used for stdcall name mangling. Note that hidden parameters do not contribute to size.
type_pointer type* type_pointer(type* tnext): Allocate a pointer type.
type_print void type_print(type* t): Pretty-print a type.
type_setcv
type* type_setcv(type** pt, tym_t cv): Set/clear const and volatile bits in *pt according to the settings in cv.
type_setdependent type* type_setdependent(type* t): Create a 'dependent' version of type t.
type_setdim
type* type_setdim(type** pt, targ_size_t dim): Set dimension of array.
type_setmangle
type* type_setmangle(type** pt, mangle_t mangle): Modify the Tmangle field of a type.
type_setty
type* type_setty(type** pt, uint newty): Modify the tym_t field of a type.
type_settype
type* type_settype(type** pt, type* t): Set type field of some object to t.
type_size targ_size_t type_size(type* t): Compute size of type in bytes.
type_static_array type* type_static_array(targ_size_t dim, type* tnext): Allocate a static array type.
type_struct_class type* type_struct_class(const(char)* name, uint alignsize, uint structsize, type* arg1type, type* arg2type, bool isUnion, bool isClass, bool isPOD, bool is0size): Create a struct/union/class type.
type_term void type_term(): Free type_list.
type_zeroSize bool type_zeroSize(type* t, tym_t tyf): Compute special zero sized struct.
typematch int typematch(type* t1, type* t2, int relax): A cheap version of exp2.typematch() and exp2.paramlstmatch(), so that we can get cpp_mangle() to work for MARS. It's less complex because it doesn't do templates and can rely on strict typechecking.

dmd.backend.dtype

Members

Functions

Meta

Source

Authors

Copyright

License