Compiler implementation of the D programming language.

Walter Bright
Boost License 1.0
bool expressionsToString(ref OutBuffer buf, Scope* sc, Expressions* exps);

Perform semantic analysis and CTFE on expressions to produce a string.

OutBuffer buf append generated string to buffer
Scope* sc context
Expressions* exps array of Expressions
true on error
StringExp semanticString(Scope* sc, Expression exp, const char* s);

Resolve exp as a compile-time known string.

Scope* sc scope
Expression exp Expression which expected as a string
char* s What the string is expected for, will be used in error diagnostic.
String literal, or null if error happens.
Expression resolveOpDollar(Scope* sc, ArrayExp ae, Expression* pe0);

Runs semantic on ae.arguments. Declares temporary variables if '$' was used.

Expression resolveOpDollar(Scope* sc, ArrayExp ae, IntervalExp ie, Expression* pe0);

Runs semantic on se.lwr and se.upr. Declares a temporary variable if '$' was used.

ae, or ErrorExp if errors occurred
bool arrayExpressionSemantic(Expressions* exps, Scope* sc, bool preserveErrors = false);

Perform semantic() on an array of Expressions.

Expression resolvePropertiesOnly(Scope* sc, Expression e1);

If e1 is a property function (template), resolve it.

Expression symbolToExp(Dsymbol s, ref const Loc loc, Scope* sc, bool hasOverloads);

Turn symbol s into the expression it represents.

Dsymbol s symbol to resolve
Loc loc location of use of s
Scope* sc context
bool hasOverloads applies if s represents a function. true means it's overloaded and will be resolved later, false means it's the exact function symbol.
s turned into an expression, ErrorExp if an error occurred
Package resolveIsPackage(Dsymbol sym);

Determines whether a symbol represents a module or package (Used as a helper for is(type == module) and is(type == package))

Dsymbol sym the symbol to be checked
the symbol which sym represents (or null if it doesn't represent a Package)
Expression trySemantic(Expression exp, Scope* sc);

Try to run semantic routines. If they fail, return NULL.

Expression unaSemantic(UnaExp e, Scope* sc);

Helper function for easy error propagation. If error occurs, returns ErrorExp. Otherwise returns NULL.

Expression binSemantic(BinExp e, Scope* sc);

Helper function for easy error propagation. If error occurs, returns ErrorExp. Otherwise returns NULL.

bool checkSharedAccess(Expression e, Scope* sc);

If expression is shared, check that we can access it. Give error message if not.

Expression e expression to check
Scope* sc context
true on error
Expression getThisSkipNestedFuncs(ref const Loc loc, Scope* sc, Dsymbol s, AggregateDeclaration ad, Expression e1, Type t, Dsymbol var, bool flag = false);

Helper function for getRightThis(). Gets this of the next outer aggregate.

Loc loc location to use for error messages
Scope* sc context
Dsymbol s the parent symbol of the existing this
AggregateDeclaration ad struct or class we need the correct this for
Expression e1 existing this
Type t type of the existing this
Dsymbol var the specific member of ad we're accessing
bool flag if true, return null instead of throwing an error
Expression representing the this for the var
VarDeclaration makeThis2Argument(ref const Loc loc, Scope* sc, FuncDeclaration fd);

Make a dual-context container for use as a this argument.

Loc loc location to use for error messages
Scope* sc current scope
FuncDeclaration fd target function that will take the this argument
Temporary closure variable.
The function fd is added to the nested references of the newly created variable such that a closure is made for the variable when the address of fd is taken.
bool verifyHookExist(ref const Loc loc, ref Scope sc, Identifier id, string description, Identifier module_ = Id.object);

Make sure that the runtime hook id exists.

Loc loc location to use for error messages
Scope sc current scope
Identifier id the hook identifier
string description what the hook does
Identifier module_ what module the hook is located in
a bool indicating if the hook is present.

© 1999–2019 The D Language Foundation
Licensed under the Boost License 1.0.