dmd.ctfeexpr - D Programming Language

Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
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:
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

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
bool `specificCmp`(TOK `op`, int `rawCmp`);
  Returns cmp OP 0; where OP is ==, !=, <, >=, etc. Result is 0 or 1
bool `intUnsignedCmp`(TOK `op`, dinteger_t `n1`, dinteger_t `n2`);
  Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1
bool `intSignedCmp`(TOK `op`, sinteger_t `n1`, sinteger_t `n2`);
  Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1
bool `realCmp`(TOK `op`, real_t `r1`, real_t `r2`);
  Returns e1 OP e2; where OP is ==, !=, <, >=, etc. Result is 0 or 1
bool `ctfeEqual`(ref const Loc `loc`, TOK `op`, Expression `e1`, Expression `e2`);
  Evaluate ==, !=. Resolves slices before comparing. Returns 0 or 1
bool `ctfeIdentity`(ref const Loc `loc`, TOK `op`, Expression `e1`, Expression `e2`);
  Evaluate is, !is. Resolves slices before comparing. Returns 0 or 1
bool `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

Copyright © 1999-2020 by the D Language Foundation | Page generated by Ddoc on Sun Jan 5 12:40:47 2020