dmd.ctfeexpr

CTFE for expressions involving pointers, slices, array concatenation etc.

Authors

Walter Bright

License

Boost License 1.0

Source: ctfeexpr.d

Documentation: https://dlang.org/phobos/dmd_ctfeexpr.html

Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/ctfeexpr.d

  • ClassReferenceExp

    Declaration

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

  • findFieldIndexByName

    Declaration

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

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

    Return Value

    index of the field, or -1 if not found

  • ThrownExceptionExp

    Declaration

    class ThrownExceptionExp: dmd.expression.Expression;

    Fake class which holds the thrown exception. Used for implementing exception handling.

  • CTFEExp

    Declaration

    class CTFEExp: dmd.expression.Expression;

    This type is only used by the interpreter.

  • needToCopyLiteral

    Declaration

    bool needToCopyLiteral(const Expression expr);

    Aggregate literals (AA/string/array/struct)

  • resolveSlice

    Declaration

    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

    Return Value

    resulting expression

  • createBlockDuplicatedArrayLiteral

    Declaration

    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

    Return Value

    Constructed ArrayLiteralExp

  • createBlockDuplicatedStringLiteral

    Declaration

    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.

  • isTypeInfo_Class

    Declaration

    bool isTypeInfo_Class(const Type type);

    TypeInfo operations

  • isPointer

    Declaration

    bool isPointer(Type t);

    Pointer operations

  • pointToSameMemoryBlock

    Declaration

    bool pointToSameMemoryBlock(Expression agg1, Expression agg2);

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

  • isCtfeComparable

    Declaration

    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

  • specificCmp

    Declaration

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

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

  • intUnsignedCmp

    Declaration

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

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

  • intSignedCmp

    Declaration

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

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

  • realCmp

    Declaration

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

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

  • ctfeEqual

    Declaration

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

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

  • ctfeIdentity

    Declaration

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

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

  • ctfeCmp

    Declaration

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

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

  • assignInPlace

    Declaration

    void assignInPlace(Expression dest, Expression src);

    Assignment helper functions

  • changeArrayLiteralLength

    Declaration

    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.

  • isCtfeValueValid

    Declaration

    bool isCtfeValueValid(Expression newval);

    CTFE Sanity Checks

  • voidInitLiteral

    Declaration

    UnionExp voidInitLiteral(Type t, VarDeclaration var);

    Void initialization