437 lines
22 KiB
C++
437 lines
22 KiB
C++
/*
|
|
AngelCode Scripting Library
|
|
Copyright (c) 2003-2019 Andreas Jonsson
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any
|
|
damages arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any
|
|
purpose, including commercial applications, and to alter it and
|
|
redistribute it freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you
|
|
must not claim that you wrote the original software. If you use
|
|
this software in a product, an acknowledgment in the product
|
|
documentation would be appreciated but is not required.
|
|
|
|
2. Altered source versions must be plainly marked as such, and
|
|
must not be misrepresented as being the original software.
|
|
|
|
3. This notice may not be removed or altered from any source
|
|
distribution.
|
|
|
|
The original version of this library can be located at:
|
|
http://www.angelcode.com/angelscript/
|
|
|
|
Andreas Jonsson
|
|
andreas@angelcode.com
|
|
*/
|
|
|
|
|
|
//
|
|
// as_compiler.h
|
|
//
|
|
// The class that does the actual compilation of the functions
|
|
//
|
|
|
|
|
|
|
|
#ifndef AS_COMPILER_H
|
|
#define AS_COMPILER_H
|
|
|
|
#include "as_config.h"
|
|
|
|
#ifndef AS_NO_COMPILER
|
|
|
|
#include "as_builder.h"
|
|
#include "as_scriptfunction.h"
|
|
#include "as_variablescope.h"
|
|
#include "as_bytecode.h"
|
|
#include "as_array.h"
|
|
#include "as_datatype.h"
|
|
|
|
BEGIN_AS_NAMESPACE
|
|
|
|
// This class represents the value of an expression as evaluated by the compiler.
|
|
// It holds information such as the type of the value, stack offset for a local
|
|
// variable, value of constants, whether the value can be modified (i.e. lvalue), etc.
|
|
struct asCExprValue
|
|
{
|
|
asCExprValue();
|
|
void Set(const asCDataType &dataType);
|
|
|
|
void SetVariable(const asCDataType &dataType, int stackOffset, bool isTemporary);
|
|
void SetConstantB(const asCDataType &dataType, asBYTE value);
|
|
void SetConstantQW(const asCDataType &dataType, asQWORD value);
|
|
void SetConstantDW(const asCDataType &dataType, asDWORD value);
|
|
void SetConstantW(const asCDataType &dataType, asWORD value);
|
|
void SetConstantF(const asCDataType &dataType, float value);
|
|
void SetConstantD(const asCDataType &dataType, double value);
|
|
void SetConstantB(asBYTE value);
|
|
void SetConstantW(asWORD value);
|
|
void SetConstantQW(asQWORD value);
|
|
void SetConstantDW(asDWORD value);
|
|
void SetConstantF(float value);
|
|
void SetConstantD(double value);
|
|
asBYTE GetConstantB();
|
|
asWORD GetConstantW();
|
|
asQWORD GetConstantQW();
|
|
asDWORD GetConstantDW();
|
|
float GetConstantF();
|
|
double GetConstantD();
|
|
|
|
void SetConstantData(const asCDataType &dataType, asQWORD value);
|
|
asQWORD GetConstantData();
|
|
|
|
void SetNullConstant();
|
|
void SetUndefinedFuncHandle(asCScriptEngine *engine);
|
|
void SetVoid();
|
|
void SetDummy();
|
|
|
|
bool IsUndefinedFuncHandle() const;
|
|
bool IsNullConstant() const;
|
|
bool IsVoid() const;
|
|
|
|
asCDataType dataType;
|
|
bool isLValue : 1; // Can this value be updated in assignment, or increment operators, etc
|
|
bool isTemporary : 1;
|
|
bool isConstant : 1;
|
|
bool isVariable : 1;
|
|
bool isExplicitHandle : 1;
|
|
bool isRefToLocal : 1; // The reference may be to a local variable
|
|
bool isRefSafe : 1; // the life-time of the ref is guaranteed for the duration of the access
|
|
short dummy : 9;
|
|
short stackOffset;
|
|
|
|
private:
|
|
// These values must not be accessed directly in order to avoid problems with endianess.
|
|
// Use the appropriate accessor methods instead
|
|
union
|
|
{
|
|
asQWORD qwordValue;
|
|
double doubleValue;
|
|
asDWORD dwordValue;
|
|
float floatValue;
|
|
asWORD wordValue;
|
|
asBYTE byteValue;
|
|
};
|
|
};
|
|
|
|
struct asCExprContext;
|
|
|
|
// This class holds information for arguments that needs to be
|
|
// cleaned up after the result of a function has been evaluated.
|
|
struct asSDeferredParam
|
|
{
|
|
asSDeferredParam() {argNode = 0; origExpr = 0;}
|
|
|
|
asCScriptNode *argNode;
|
|
asCExprValue argType;
|
|
int argInOutFlags;
|
|
asCExprContext *origExpr;
|
|
};
|
|
|
|
// TODO: refactor: asCExprContext should have indicators to inform where the value is,
|
|
// i.e. if the reference to an object is pushed on the stack or not, etc
|
|
|
|
// This class holds information about an expression that is being evaluated, e.g.
|
|
// the current bytecode, ambiguous symbol names, property accessors, etc.
|
|
struct asCExprContext
|
|
{
|
|
asCExprContext(asCScriptEngine *engine);
|
|
~asCExprContext();
|
|
void Clear();
|
|
bool IsClassMethod() const;
|
|
bool IsGlobalFunc() const;
|
|
void SetLambda(asCScriptNode *funcDecl);
|
|
bool IsLambda() const;
|
|
void SetVoidExpression();
|
|
bool IsVoidExpression() const;
|
|
void Merge(asCExprContext *after);
|
|
void Copy(asCExprContext *other);
|
|
void SetAnonymousInitList(asCScriptNode *initList, asCScriptCode *script);
|
|
bool IsAnonymousInitList() const;
|
|
|
|
asCByteCode bc;
|
|
asCExprValue type;
|
|
int property_get;
|
|
int property_set;
|
|
bool property_const; // If the object that is being accessed through property accessor is read-only
|
|
bool property_handle; // If the property accessor is called on an object stored in a handle
|
|
bool property_ref; // If the property accessor is called on a reference
|
|
bool isVoidExpression; // Set to true if the expression is an explicit 'void', e.g. used to ignore out parameters in func calls
|
|
bool isCleanArg; // Set to true if the expression has only been initialized with default constructor
|
|
asCExprContext *property_arg;
|
|
asCArray<asSDeferredParam> deferredParams;
|
|
asCScriptNode *exprNode;
|
|
asCExprContext *origExpr;
|
|
asCScriptCode *origCode;
|
|
// TODO: cleanup: use ambiguousName and an enum to say if it is a method, global func, or enum value
|
|
asCString methodName;
|
|
asCString enumValue;
|
|
asSNameSpace *symbolNamespace; // The namespace in which the ambiguous symbol was found
|
|
bool isAnonymousInitList; // Set to true if the expression is an init list for which the type has not yet been determined
|
|
};
|
|
|
|
struct asSOverloadCandidate
|
|
{
|
|
asSOverloadCandidate() : funcId(0), cost(0) {}
|
|
asSOverloadCandidate(int _id, asUINT _cost) : funcId(_id), cost(_cost) {}
|
|
int funcId;
|
|
asUINT cost;
|
|
};
|
|
|
|
struct asSNamedArgument
|
|
{
|
|
asCString name;
|
|
asCExprContext *ctx;
|
|
asUINT match;
|
|
};
|
|
|
|
enum EImplicitConv
|
|
{
|
|
asIC_IMPLICIT_CONV,
|
|
asIC_EXPLICIT_REF_CAST,
|
|
asIC_EXPLICIT_VAL_CAST
|
|
};
|
|
|
|
enum EConvCost
|
|
{
|
|
asCC_NO_CONV = 0,
|
|
asCC_CONST_CONV = 1,
|
|
asCC_ENUM_SAME_SIZE_CONV = 2,
|
|
asCC_ENUM_DIFF_SIZE_CONV = 3,
|
|
asCC_PRIMITIVE_SIZE_CONV = 4,
|
|
asCC_SIGNED_CONV = 5,
|
|
asCC_INT_FLOAT_CONV = 6,
|
|
asCC_REF_CONV = 7,
|
|
asCC_OBJ_TO_PRIMITIVE_CONV = 8,
|
|
asCC_TO_OBJECT_CONV = 9,
|
|
asCC_VARIABLE_CONV = 10
|
|
};
|
|
|
|
class asCCompiler
|
|
{
|
|
public:
|
|
asCCompiler(asCScriptEngine *engine);
|
|
~asCCompiler();
|
|
|
|
int CompileFunction(asCBuilder *builder, asCScriptCode *script, asCArray<asCString> ¶meterNames, asCScriptNode *func, asCScriptFunction *outFunc, sClassDeclaration *classDecl);
|
|
int CompileDefaultConstructor(asCBuilder *builder, asCScriptCode *script, asCScriptNode *node, asCScriptFunction *outFunc, sClassDeclaration *classDecl);
|
|
int CompileFactory(asCBuilder *builder, asCScriptCode *script, asCScriptFunction *outFunc);
|
|
int CompileGlobalVariable(asCBuilder *builder, asCScriptCode *script, asCScriptNode *expr, sGlobalVariableDescription *gvar, asCScriptFunction *outFunc);
|
|
|
|
protected:
|
|
friend class asCBuilder;
|
|
|
|
void Reset(asCBuilder *builder, asCScriptCode *script, asCScriptFunction *outFunc);
|
|
|
|
// Statements
|
|
void CompileStatementBlock(asCScriptNode *block, bool ownVariableScope, bool *hasReturn, asCByteCode *bc);
|
|
void CompileDeclaration(asCScriptNode *decl, asCByteCode *bc);
|
|
void CompileStatement(asCScriptNode *statement, bool *hasReturn, asCByteCode *bc);
|
|
void CompileIfStatement(asCScriptNode *node, bool *hasReturn, asCByteCode *bc);
|
|
void CompileSwitchStatement(asCScriptNode *node, bool *hasReturn, asCByteCode *bc);
|
|
void CompileCase(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileForStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileWhileStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileDoWhileStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileBreakStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileContinueStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileReturnStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileExpressionStatement(asCScriptNode *node, asCByteCode *bc);
|
|
void CompileTryCatch(asCScriptNode *node, bool *hasReturn, asCByteCode *bc);
|
|
|
|
// Expressions
|
|
int CompileAssignment(asCScriptNode *expr, asCExprContext *out);
|
|
int CompileCondition(asCScriptNode *expr, asCExprContext *out);
|
|
int CompileExpression(asCScriptNode *expr, asCExprContext *out);
|
|
int CompilePostFixExpression(asCArray<asCScriptNode *> *postfix, asCExprContext *out);
|
|
int CompileExpressionTerm(asCScriptNode *node, asCExprContext *out);
|
|
int CompileExpressionPreOp(asCScriptNode *node, asCExprContext *out);
|
|
int CompileExpressionPostOp(asCScriptNode *node, asCExprContext *out);
|
|
int CompileExpressionValue(asCScriptNode *node, asCExprContext *out);
|
|
int CompileFunctionCall(asCScriptNode *node, asCExprContext *out, asCObjectType *objectType, bool objIsConst, const asCString &scope = "");
|
|
int CompileConstructCall(asCScriptNode *node, asCExprContext *out);
|
|
int CompileConversion(asCScriptNode *node, asCExprContext *out);
|
|
int CompileOperator(asCScriptNode *node, asCExprContext *l, asCExprContext *r, asCExprContext *out, eTokenType opToken = ttUnrecognizedToken, bool leftToRight = true);
|
|
void CompileOperatorOnHandles(asCScriptNode *node, asCExprContext *l, asCExprContext *r, asCExprContext *out, eTokenType opToken = ttUnrecognizedToken);
|
|
void CompileMathOperator(asCScriptNode *node, asCExprContext *l, asCExprContext *r, asCExprContext *out, eTokenType opToken = ttUnrecognizedToken);
|
|
void CompileBitwiseOperator(asCScriptNode *node, asCExprContext *l, asCExprContext *r, asCExprContext *out, eTokenType opToken = ttUnrecognizedToken);
|
|
void CompileComparisonOperator(asCScriptNode *node, asCExprContext *l, asCExprContext *r, asCExprContext *out, eTokenType opToken = ttUnrecognizedToken);
|
|
void CompileBooleanOperator(asCScriptNode *node, asCExprContext *l, asCExprContext *r, asCExprContext *out, eTokenType opToken = ttUnrecognizedToken);
|
|
bool CompileOverloadedDualOperator(asCScriptNode *node, asCExprContext *l, asCExprContext *r, bool leftToRight, asCExprContext *out, bool isHandle = false, eTokenType opToken = ttUnrecognizedToken);
|
|
int CompileOverloadedDualOperator2(asCScriptNode *node, const char *methodName, asCExprContext *l, asCExprContext *r, bool leftToRight, asCExprContext *out, bool specificReturn = false, const asCDataType &returnType = asCDataType::CreatePrimitive(ttVoid, false));
|
|
|
|
void CompileInitList(asCExprValue *var, asCScriptNode *node, asCByteCode *bc, int isVarGlobOrMem);
|
|
int CompileInitListElement(asSListPatternNode *&patternNode, asCScriptNode *&valueNode, int bufferTypeId, short bufferVar, asUINT &bufferSize, asCByteCode &byteCode, int &elementsInSubList);
|
|
int CompileAnonymousInitList(asCScriptNode *listNode, asCExprContext *ctx, const asCDataType &dt);
|
|
|
|
int CallDefaultConstructor(const asCDataType &type, int offset, bool isObjectOnHeap, asCByteCode *bc, asCScriptNode *node, int isVarGlobOrMem = 0, bool derefDest = false);
|
|
int CallCopyConstructor(asCDataType &type, int offset, bool isObjectOnHeap, asCByteCode *bc, asCExprContext *arg, asCScriptNode *node, bool isGlobalVar = false, bool derefDestination = false);
|
|
void CallDestructor(asCDataType &type, int offset, bool isObjectOnHeap, asCByteCode *bc);
|
|
int CompileArgumentList(asCScriptNode *node, asCArray<asCExprContext *> &args, asCArray<asSNamedArgument> &namedArgs);
|
|
int CompileDefaultAndNamedArgs(asCScriptNode *node, asCArray<asCExprContext*> &args, int funcId, asCObjectType *type, asCArray<asSNamedArgument> *namedArgs = 0);
|
|
asUINT MatchFunctions(asCArray<int> &funcs, asCArray<asCExprContext*> &args, asCScriptNode *node, const char *name, asCArray<asSNamedArgument> *namedArgs = NULL, asCObjectType *objectType = NULL, bool isConstMethod = false, bool silent = false, bool allowObjectConstruct = true, const asCString &scope = "");
|
|
int CompileVariableAccess(const asCString &name, const asCString &scope, asCExprContext *ctx, asCScriptNode *errNode, bool isOptional = false, asCObjectType *objType = 0);
|
|
void CompileMemberInitialization(asCByteCode *bc, bool onlyDefaults);
|
|
bool CompileAutoType(asCDataType &autoType, asCExprContext &compiledCtx, asCScriptNode *exprNode, asCScriptNode *errNode);
|
|
bool CompileInitialization(asCScriptNode *node, asCByteCode *bc, const asCDataType &type, asCScriptNode *errNode, int offset, asQWORD *constantValue, int isVarGlobOrMem, asCExprContext *preCompiled = 0);
|
|
void CompileInitAsCopy(asCDataType &type, int offset, asCByteCode *bc, asCExprContext *arg, asCScriptNode *node, bool derefDestination);
|
|
|
|
// Helper functions
|
|
void ConvertToPostFix(asCScriptNode *expr, asCArray<asCScriptNode *> &postfix);
|
|
int ProcessPropertyGetAccessor(asCExprContext *ctx, asCScriptNode *node);
|
|
int ProcessPropertySetAccessor(asCExprContext *ctx, asCExprContext *arg, asCScriptNode *node);
|
|
int ProcessPropertyGetSetAccessor(asCExprContext *ctx, asCExprContext *lctx, asCExprContext *rctx, eTokenType op, asCScriptNode *errNode);
|
|
int FindPropertyAccessor(const asCString &name, asCExprContext *ctx, asCScriptNode *node, asSNameSpace *ns, bool isThisAccess = false);
|
|
int FindPropertyAccessor(const asCString &name, asCExprContext *ctx, asCExprContext *arg, asCScriptNode *node, asSNameSpace *ns, bool isThisAccess = false);
|
|
void PrepareTemporaryVariable(asCScriptNode *node, asCExprContext *ctx, bool forceOnHeap = false);
|
|
void PrepareOperand(asCExprContext *ctx, asCScriptNode *node);
|
|
void PrepareForAssignment(asCDataType *lvalue, asCExprContext *rvalue, asCScriptNode *node, bool toTemporary, asCExprContext *lvalueExpr = 0);
|
|
int PerformAssignment(asCExprValue *lvalue, asCExprValue *rvalue, asCByteCode *bc, asCScriptNode *node);
|
|
bool IsVariableInitialized(asCExprValue *type, asCScriptNode *node);
|
|
void Dereference(asCExprContext *ctx, bool generateCode);
|
|
bool CompileRefCast(asCExprContext *ctx, const asCDataType &to, bool isExplicit, asCScriptNode *node, bool generateCode = true);
|
|
asUINT MatchArgument(asCArray<int> &funcs, asCArray<asSOverloadCandidate> &matches, const asCExprContext *argExpr, int paramNum, bool allowObjectConstruct = true);
|
|
int MatchArgument(asCScriptFunction *desc, const asCExprContext *argExpr, int paramNum, bool allowObjectConstruct = true);
|
|
void PerformFunctionCall(int funcId, asCExprContext *out, bool isConstructor = false, asCArray<asCExprContext*> *args = 0, asCObjectType *objTypeForConstruct = 0, bool useVariable = false, int varOffset = 0, int funcPtrVar = 0);
|
|
void MoveArgsToStack(int funcId, asCByteCode *bc, asCArray<asCExprContext *> &args, bool addOneToOffset);
|
|
int MakeFunctionCall(asCExprContext *ctx, int funcId, asCObjectType *objectType, asCArray<asCExprContext*> &args, asCScriptNode *node, bool useVariable = false, int stackOffset = 0, int funcPtrVar = 0);
|
|
int PrepareFunctionCall(int funcId, asCByteCode *bc, asCArray<asCExprContext *> &args);
|
|
void AfterFunctionCall(int funcId, asCArray<asCExprContext*> &args, asCExprContext *ctx, bool deferAll);
|
|
void ProcessDeferredParams(asCExprContext *ctx);
|
|
int PrepareArgument(asCDataType *paramType, asCExprContext *ctx, asCScriptNode *node, bool isFunction = false, int refType = 0, bool isMakingCopy = false);
|
|
int PrepareArgument2(asCExprContext *ctx, asCExprContext *arg, asCDataType *paramType, bool isFunction = false, int refType = 0, bool isMakingCopy = false);
|
|
bool IsLValue(asCExprValue &type);
|
|
int DoAssignment(asCExprContext *out, asCExprContext *lctx, asCExprContext *rctx, asCScriptNode *lexpr, asCScriptNode *rexpr, eTokenType op, asCScriptNode *opNode);
|
|
void MergeExprBytecode(asCExprContext *before, asCExprContext *after);
|
|
void MergeExprBytecodeAndType(asCExprContext *before, asCExprContext *after);
|
|
void FilterConst(asCArray<int> &funcs, bool removeConst = true);
|
|
void ConvertToVariable(asCExprContext *ctx);
|
|
void ConvertToVariableNotIn(asCExprContext *ctx, asCExprContext *exclude);
|
|
void ConvertToTempVariable(asCExprContext *ctx);
|
|
void ConvertToTempVariableNotIn(asCExprContext *ctx, asCExprContext *exclude);
|
|
void ConvertToReference(asCExprContext *ctx);
|
|
void PushVariableOnStack(asCExprContext *ctx, bool asReference);
|
|
void DestroyVariables(asCByteCode *bc);
|
|
asSNameSpace *DetermineNameSpace(const asCString &scope);
|
|
int SetupParametersAndReturnVariable(asCArray<asCString> ¶meterNames, asCScriptNode *func);
|
|
|
|
enum SYMBOLTYPE
|
|
{
|
|
SL_NOMATCH,
|
|
SL_LOCALCONST,
|
|
SL_LOCALVAR,
|
|
SL_THISPTR,
|
|
SL_CLASSPROPACCESS,
|
|
SL_CLASSPROP,
|
|
SL_CLASSMETHOD,
|
|
SL_CLASSTYPE,
|
|
SL_GLOBALPROPACCESS,
|
|
SL_GLOBALCONST,
|
|
SL_GLOBALVAR,
|
|
SL_GLOBALFUNC,
|
|
SL_GLOBALTYPE,
|
|
SL_ENUMVAL,
|
|
SL_ERROR = -1
|
|
};
|
|
|
|
SYMBOLTYPE SymbolLookup(const asCString &name, const asCString &scope, asCObjectType *objType, asCExprContext *outResult);
|
|
SYMBOLTYPE SymbolLookupLocalVar(const asCString &name, asCExprContext *outResult);
|
|
SYMBOLTYPE SymbolLookupMember(const asCString &name, asCObjectType *objType, asCExprContext *outResult);
|
|
|
|
void DetermineSingleFunc(asCExprContext *ctx, asCScriptNode *node);
|
|
|
|
// Returns the cost of the conversion (the sum of the EConvCost performed)
|
|
asUINT ImplicitConversion(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, bool allowObjectConstruct = true);
|
|
asUINT ImplicitConvPrimitiveToPrimitive(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true);
|
|
asUINT ImplicitConvObjectToPrimitive(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true);
|
|
asUINT ImplicitConvPrimitiveToObject(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, bool allowObjectConstruct = true);
|
|
asUINT ImplicitConvObjectToObject(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, bool allowObjectConstruct = true);
|
|
asUINT ImplicitConvObjectRef(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode);
|
|
asUINT ImplicitConvObjectValue(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode);
|
|
void ImplicitConversionConstant(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType);
|
|
void ImplicitConvObjectToBestMathType(asCExprContext *ctx, asCScriptNode *node);
|
|
asUINT ImplicitConvLambdaToFunc(asCExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true);
|
|
|
|
void LineInstr(asCByteCode *bc, size_t pos);
|
|
|
|
asUINT ProcessStringConstant(asCString &str, asCScriptNode *node, bool processEscapeSequences = true);
|
|
void ProcessHeredocStringConstant(asCString &str, asCScriptNode *node);
|
|
int GetPrecedence(asCScriptNode *op);
|
|
void Error(const asCString &msg, asCScriptNode *node);
|
|
void Warning(const asCString &msg, asCScriptNode *node);
|
|
void Information(const asCString &msg, asCScriptNode *node);
|
|
void PrintMatchingFuncs(asCArray<int> &funcs, asCScriptNode *node, asCObjectType *inType = 0);
|
|
void AddVariableScope(bool isBreakScope = false, bool isContinueScope = false);
|
|
void RemoveVariableScope();
|
|
void FinalizeFunction();
|
|
|
|
asCByteCode byteCode;
|
|
|
|
bool hasCompileErrors;
|
|
|
|
int nextLabel;
|
|
int numLambdas;
|
|
|
|
asCVariableScope *variables;
|
|
asCBuilder *builder;
|
|
asCScriptEngine *engine;
|
|
asCScriptCode *script;
|
|
asCScriptFunction *outFunc;
|
|
|
|
bool m_isConstructor;
|
|
bool m_isConstructorCalled;
|
|
sClassDeclaration *m_classDecl;
|
|
sGlobalVariableDescription *m_globalVar;
|
|
|
|
asCArray<int> breakLabels;
|
|
asCArray<int> continueLabels;
|
|
|
|
int AllocateVariable(const asCDataType &type, bool isTemporary, bool forceOnHeap = false, bool asReference = false);
|
|
int AllocateVariableNotIn(const asCDataType &type, bool isTemporary, bool forceOnHeap, asCExprContext *ctx);
|
|
int GetVariableOffset(int varIndex);
|
|
int GetVariableSlot(int varOffset);
|
|
void DeallocateVariable(int pos);
|
|
void ReleaseTemporaryVariable(asCExprValue &t, asCByteCode *bc);
|
|
void ReleaseTemporaryVariable(int offset, asCByteCode *bc);
|
|
bool IsVariableOnHeap(int offset);
|
|
|
|
// This ordered array indicates the type of each variable
|
|
asCArray<asCDataType> variableAllocations;
|
|
|
|
// This ordered array indicates which variables are temporaries or not
|
|
asCArray<bool> variableIsTemporary;
|
|
|
|
// This unordered array gives the offsets of all temporary variables, whether currently allocated or not
|
|
asCArray<int> tempVariableOffsets;
|
|
|
|
// This ordered array indicated if the variable is on the heap or not
|
|
asCArray<bool> variableIsOnHeap;
|
|
|
|
// This unordered array gives the indexes of the currently unused variables
|
|
asCArray<int> freeVariables;
|
|
|
|
// This array holds the offsets of the currently allocated temporary variables
|
|
asCArray<int> tempVariables;
|
|
|
|
// This array holds the indices of variables that must not be used in an allocation
|
|
asCArray<int> reservedVariables;
|
|
|
|
// This array holds the string constants that were allocated during the compilation,
|
|
// so they can be released upon completion, whether the compilation was successful or not.
|
|
asCArray<void*> usedStringConstants;
|
|
|
|
bool isCompilingDefaultArg;
|
|
bool isProcessingDeferredParams;
|
|
int noCodeOutput;
|
|
};
|
|
|
|
END_AS_NAMESPACE
|
|
|
|
#endif // AS_NO_COMPILER
|
|
|
|
#endif
|