- 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()
- 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_hydrate
void param_hydrate(param_t** pp)
Hydrate/dehydrate a type.
- 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(const param_t* p)
- param_t_search
param_t* param_t_search(param_t* p, 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_alloc_template
type* type_alloc_template(Symbol* s)
- type_allocmemptr
type* type_allocmemptr(Classsym* stag, type* tn)
Allocate a TYmemptr type.
- 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)
- type_dehydrate
void type_dehydrate(type** pt)
- 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)
- type_function
type* type_function(tym_t tyf, type*[] ptypes, bool variadic, type* tret)
Allocation a function type.
- type_hydrate
void type_hydrate(type** pt)
- 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)
- type_print
void type_print(const type* t)
- 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)
- 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.
Mark size as known after error message if it is not known.
Instantiate templates as needed to compute size.
- type_size
targ_size_t type_size(const 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()
- type_vla_fix
elem* type_vla_fix(type** pt)
- 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.
Compiler implementation of the D programming language.