/* AngelCode Scripting Library Copyright (c) 2003-2011 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" #include "as_builder.h" #include "as_scriptfunction.h" #include "as_variablescope.h" #include "as_bytecode.h" #include "as_array.h" #include "as_datatype.h" #include "as_typeinfo.h" BEGIN_AS_NAMESPACE struct asSExprContext; struct asSDeferredParam { asSDeferredParam() {argNode = 0; origExpr = 0;} asCScriptNode *argNode; asCTypeInfo argType; int argInOutFlags; asSExprContext *origExpr; }; struct asSExprContext { asSExprContext(asCScriptEngine *engine) : bc(engine) { exprNode = 0; origExpr = 0; property_get = 0; property_set = 0; property_const = false; property_handle = false; property_ref = false; property_arg = 0; } ~asSExprContext() { asASSERT(property_arg == 0); } asCByteCode bc; asCTypeInfo 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 asSExprContext *property_arg; asCArray deferredParams; asCScriptNode *exprNode; asSExprContext *origExpr; }; enum EImplicitConv { asIC_IMPLICIT_CONV, asIC_EXPLICIT_REF_CAST, asIC_EXPLICIT_VAL_CAST }; class asCCompiler { public: asCCompiler(asCScriptEngine *engine); ~asCCompiler(); int CompileFunction(asCBuilder *builder, asCScriptCode *script, asCScriptNode *func, asCScriptFunction *outFunc); int CompileDefaultConstructor(asCBuilder *builder, asCScriptCode *script, asCScriptFunction *outFunc); int CompileFactory(asCBuilder *builder, asCScriptCode *script, asCScriptFunction *outFunc); int CompileTemplateFactoryStub(asCBuilder *builder, int trueFactoryId, asCObjectType *objType, 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); // Expressions int CompileAssignment(asCScriptNode *expr, asSExprContext *out); int CompileCondition(asCScriptNode *expr, asSExprContext *out); int CompileExpression(asCScriptNode *expr, asSExprContext *out); int CompilePostFixExpression(asCArray *postfix, asSExprContext *out); int CompileExpressionTerm(asCScriptNode *node, asSExprContext *out); int CompileExpressionPreOp(asCScriptNode *node, asSExprContext *out); int CompileExpressionPostOp(asCScriptNode *node, asSExprContext *out); int CompileExpressionValue(asCScriptNode *node, asSExprContext *out); void CompileFunctionCall(asCScriptNode *node, asSExprContext *out, asCObjectType *objectType, bool objIsConst, const asCString &scope = ""); void CompileConstructCall(asCScriptNode *node, asSExprContext *out); void CompileConversion(asCScriptNode *node, asSExprContext *out); int CompileOperator(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); void CompileOperatorOnHandles(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); void CompileMathOperator(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); void CompileBitwiseOperator(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); void CompileComparisonOperator(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); void CompileBooleanOperator(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); bool CompileOverloadedDualOperator(asCScriptNode *node, asSExprContext *l, asSExprContext *r, asSExprContext *out); int CompileOverloadedDualOperator2(asCScriptNode *node, const char *methodName, asSExprContext *l, asSExprContext *r, asSExprContext *out, bool specificReturn = false, const asCDataType &returnType = asCDataType::CreatePrimitive(ttVoid, false)); void CompileInitList(asCTypeInfo *var, asCScriptNode *node, asCByteCode *bc); int CallDefaultConstructor(asCDataType &type, int offset, bool isObjectOnHeap, asCByteCode *bc, asCScriptNode *node, bool isGlobalVar = false); int CallCopyConstructor(asCDataType &type, int offset, bool isObjectOnHeap, asCByteCode *bc, asSExprContext *arg, asCScriptNode *node, bool isGlobalVar = false); void CallDestructor(asCDataType &type, int offset, bool isObjectOnHeap, asCByteCode *bc); int CompileArgumentList(asCScriptNode *node, asCArray &args); int CompileDefaultArgs(asCScriptNode *node, asCArray &args, asCScriptFunction *func); void MatchFunctions(asCArray &funcs, asCArray &args, asCScriptNode *node, const char *name, asCObjectType *objectType = NULL, bool isConstMethod = false, bool silent = false, bool allowObjectConstruct = true, const asCString &scope = ""); int CompileVariableAccess(const asCString &name, const asCString &scope, asSExprContext *ctx, asCScriptNode *errNode, bool isOptional = false, bool noFunction = false, asCObjectType *objType = 0); // Helper functions void ProcessPropertyGetAccessor(asSExprContext *ctx, asCScriptNode *node); int ProcessPropertySetAccessor(asSExprContext *ctx, asSExprContext *arg, asCScriptNode *node); int FindPropertyAccessor(const asCString &name, asSExprContext *ctx, asCScriptNode *node, bool isThisAccess = false); int FindPropertyAccessor(const asCString &name, asSExprContext *ctx, asSExprContext *arg, asCScriptNode *node, bool isThisAccess = false); void SwapPostFixOperands(asCArray &postfix, asCArray &target); void PrepareTemporaryObject(asCScriptNode *node, asSExprContext *ctx, asCArray *reservedVars, bool forceOnHeap = false); void PrepareOperand(asSExprContext *ctx, asCScriptNode *node); void PrepareForAssignment(asCDataType *lvalue, asSExprContext *rvalue, asCScriptNode *node, asSExprContext *lvalueExpr = 0); void PerformAssignment(asCTypeInfo *lvalue, asCTypeInfo *rvalue, asCByteCode *bc, asCScriptNode *node); bool IsVariableInitialized(asCTypeInfo *type, asCScriptNode *node); void Dereference(asSExprContext *ctx, bool generateCode); bool CompileRefCast(asSExprContext *ctx, const asCDataType &to, bool isExplicit, asCScriptNode *node, bool generateCode = true); int MatchArgument(asCArray &funcs, asCArray &matches, const asCTypeInfo *argType, int paramNum, bool allowObjectConstruct = true); void PerformFunctionCall(int funcId, asSExprContext *out, bool isConstructor = false, asCArray *args = 0, asCObjectType *objTypeForConstruct = 0, bool useVariable = false, int varOffset = 0, int funcPtrVar = 0); void MoveArgsToStack(int funcId, asCByteCode *bc, asCArray &args, bool addOneToOffset); void MakeFunctionCall(asSExprContext *ctx, int funcId, asCObjectType *objectType, asCArray &args, asCScriptNode *node, bool useVariable = false, int stackOffset = 0, int funcPtrVar = 0); void PrepareFunctionCall(int funcId, asCByteCode *bc, asCArray &args); void AfterFunctionCall(int funcId, asCArray &args, asSExprContext *ctx, bool deferAll); void ProcessDeferredParams(asSExprContext *ctx); void PrepareArgument(asCDataType *paramType, asSExprContext *ctx, asCScriptNode *node, bool isFunction = false, int refType = 0, asCArray *reservedVars = 0, bool forceOnHeap = false); void PrepareArgument2(asSExprContext *ctx, asSExprContext *arg, asCDataType *paramType, bool isFunction = false, int refType = 0, asCArray *reservedVars = 0); bool IsLValue(asCTypeInfo &type); int DoAssignment(asSExprContext *out, asSExprContext *lctx, asSExprContext *rctx, asCScriptNode *lexpr, asCScriptNode *rexpr, int op, asCScriptNode *opNode); void MergeExprBytecode(asSExprContext *before, asSExprContext *after); void MergeExprBytecodeAndType(asSExprContext *before, asSExprContext *after); void FilterConst(asCArray &funcs); void ConvertToVariable(asSExprContext *ctx); void ConvertToVariableNotIn(asSExprContext *ctx, asSExprContext *exclude); void ConvertToVariableNotIn(asSExprContext *ctx, asCArray *reservedVars); void ConvertToTempVariable(asSExprContext *ctx); void ConvertToTempVariableNotIn(asSExprContext *ctx, asSExprContext *exclude); void ConvertToTempVariableNotIn(asSExprContext *ctx, asCArray *reservedVars); void ConvertToReference(asSExprContext *ctx); void PushVariableOnStack(asSExprContext *ctx, bool asReference); asCString GetScopeFromNode(asCScriptNode *node); void DestroyVariables(asCByteCode *bc); void ImplicitConversion(asSExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, asCArray *reservedVars = 0, bool allowObjectConstruct = true); void ImplicitConvPrimitiveToPrimitive(asSExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, asCArray *reservedVars = 0); void ImplicitConvObjectToPrimitive(asSExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, asCArray *reservedVars = 0); void ImplicitConvPrimitiveToObject(asSExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, asCArray *reservedVars = 0, bool allowObjectConstruct = true); void ImplicitConvObjectToObject(asSExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType, bool generateCode = true, asCArray *reservedVars = 0, bool allowObjectConstruct = true); void ImplicitConversionConstant(asSExprContext *ctx, const asCDataType &to, asCScriptNode *node, EImplicitConv convType); 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 char *msg, asCScriptNode *node); void Warning(const char *msg, asCScriptNode *node); void Information(const char *msg, asCScriptNode *node); void PrintMatchingFuncs(asCArray &funcs, asCScriptNode *node); void AddVariableScope(bool isBreakScope = false, bool isContinueScope = false); void RemoveVariableScope(); void FinalizeFunction(); asCByteCode byteCode; bool hasCompileErrors; int nextLabel; asCVariableScope *variables; asCBuilder *builder; asCScriptEngine *engine; asCScriptCode *script; asCScriptFunction *outFunc; bool m_isConstructor; bool m_isConstructorCalled; asCArray breakLabels; asCArray continueLabels; int AllocateVariable(const asCDataType &type, bool isTemporary, bool forceOnHeap = false); int AllocateVariableNotIn(const asCDataType &type, bool isTemporary, asCArray *vars, bool forceOnHeap = false); int GetVariableOffset(int varIndex); int GetVariableSlot(int varOffset); void DeallocateVariable(int pos); void ReleaseTemporaryVariable(asCTypeInfo &t, asCByteCode *bc); void ReleaseTemporaryVariable(int offset, asCByteCode *bc); bool IsVariableOnHeap(int offset); asCArray variableAllocations; asCArray variableIsTemporary; asCArray variableIsOnHeap; asCArray freeVariables; asCArray tempVariables; bool isCompilingDefaultArg; bool isProcessingDeferredParams; int noCodeOutput; }; END_AS_NAMESPACE #endif