dmd.ctfeexpr

struct UnionExp;

pure nothrow @safe int findFieldIndexByName(const StructDeclaration sd, const VarDeclaration v);

Same as getFieldIndex, but checks for a direct match with the VarDeclaration

Returns:

index of the field, or -1 if not found

nothrow bool needToCopyLiteral(const Expression expr);

Aggregate literals (AA/string/array/struct)

Expression resolveSlice(Expression e, UnionExp* pue = null);

If e is a SliceExp, constant fold it.

Parameters:

Expression e	expression to resolve
UnionExp* pue	if not null, store resulting expression here

Returns:

resulting expression

ArrayLiteralExp createBlockDuplicatedArrayLiteral(UnionExp* pue, const ref Loc loc, Type type, Expression elem, size_t dim);

Helper for NewExp Create an array literal consisting of 'elem' duplicated 'dim' times.

Parameters:

UnionExp* pue	where to store result
Loc loc	source location where the interpretation occurs
Type type	target type of the result
Expression elem	the source of array element, it will be owned by the result
size_t dim	element number of the result

Returns:

Constructed ArrayLiteralExp

StringExp createBlockDuplicatedStringLiteral(UnionExp* pue, const ref Loc loc, Type type, dchar value, size_t dim, ubyte sz);

Helper for NewExp Create a string literal consisting of 'value' duplicated 'dim' times.

nothrow bool isTypeInfo_Class(const Type type);

TypeInfo operations

bool isPointer(Type t);

Pointer operations

bool pointToSameMemoryBlock(Expression agg1, Expression agg2);

Return true if agg1 and agg2 are pointers to the same memory block

bool isCtfeComparable(Expression e);

Constant folding, with support for CTFE Return true if non-pointer expression e can be compared with >,is, ==, etc, using ctfeCmp, ctfeEqual, ctfeIdentity

nothrow @safe bool specificCmp(EXP op, int rawCmp);

Returns cmp OP 0; where OP is ==, !=, <, >=, etc. Result is 0 or 1

nothrow @safe bool intUnsignedCmp(EXP op, dinteger_t n1, dinteger_t n2);

Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1

nothrow @safe bool intSignedCmp(EXP op, sinteger_t n1, sinteger_t n2);

Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1

nothrow @safe bool realCmp(EXP op, real_t r1, real_t r2);

Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1

bool ctfeEqual(const ref Loc loc, EXP op, Expression e1, Expression e2);

Evaluate ==, !=. Resolves slices before comparing. Returns 0 or 1

bool ctfeIdentity(const ref Loc loc, EXP op, Expression e1, Expression e2);

Evaluate is, !is. Resolves slices before comparing. Returns 0 or 1

bool ctfeCmp(const ref Loc loc, EXP op, Expression e1, Expression e2);

Evaluate >,<=, etc. Resolves slices before comparing. Returns 0 or 1

void assignInPlace(Expression dest, Expression src);

Assignment helper functions

Expression changeArrayLiteralLength(UnionExp* pue, const ref Loc loc, TypeArray arrayType, Expression oldval, size_t oldlen, size_t newlen);

Given array literal oldval of type ArrayLiteralExp or StringExp, of length oldlen, change its length to newlen. If the newlen is longer than oldlen, all new elements will be set to the default initializer for the element type.

bool isCtfeValueValid(Expression newval);

CTFE Sanity Checks

UnionExp voidInitLiteral(Type t, VarDeclaration var);

Void initialization