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.ctfeexpr

Compiler implementation of the D programming language.
Authors:

Source ctfeexpr.d

struct CtfeStatus;
Global status of the CTFE engine. Mostly used for performance diagnostics
class ClassReferenceExp: dmd.expression.Expression;
A reference to a class, or an interface. We need this when we point to a base class (we must record what the type is).
pure 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
class ThrownExceptionExp: dmd.expression.Expression;
Fake class which holds the thrown exception. Used for implementing exception handling.
class CTFEExp: dmd.expression.Expression;
This type is only used by the interpreter.
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, ref const 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, ref const Loc loc, Type type, dchar value, size_t dim, ubyte sz);
Helper for NewExp Create a string literal consisting of 'value' duplicated 'dim' times.
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
int specificCmp(TOK op, int rawCmp);
Returns cmp OP 0; where OP is ==, !=, <, >=, etc. Result is 0 or 1
int intUnsignedCmp(TOK op, dinteger_t n1, dinteger_t n2);
Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1
int intSignedCmp(TOK op, sinteger_t n1, sinteger_t n2);
Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1
int realCmp(TOK op, real_t r1, real_t r2);
Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1
int ctfeEqual(ref const Loc loc, TOK op, Expression e1, Expression e2);
Evaluate ==, !=. Resolves slices before comparing. Returns 0 or 1
int ctfeIdentity(ref const Loc loc, TOK op, Expression e1, Expression e2);
Evaluate is, !is. Resolves slices before comparing. Returns 0 or 1
int ctfeCmp(ref const Loc loc, TOK op, Expression e1, Expression e2);
Evaluate >,<=, etc. Resolves slices before comparing. Returns 0 or 1
void assignInPlace(Expression dest, Expression src);
Assignment helper functions
UnionExp changeArrayLiteralLength(ref const 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