void LuaInstance::postframe() { if( !isFunction( "postframe" ) ) return; pushFunction( "postframe" ); callVoid(); }
void LuaInstance::stop() { if( !isFunction( "stop" ) ) return; pushFunction( "stop" ); callVoid(); }
void Stack::pushVariable(const Variable &var) { switch (var.getType()) { case kTypeNil: pushNil(); break; case kTypeBoolean: pushBoolean(var.getBool()); break; case kTypeNumber: pushFloat(var.getFloat()); break; case kTypeString: pushString(var.getString()); break; case kTypeTable: pushTable(var.getTable()); break; case kTypeFunction: pushFunction(var.getFunction()); break; case kTypeUserType: pushRawUserType(var.getRawUserType(), var.getExactType()); break; default: warning("Pushing a varible of type \"%s\" not supported", var.getExactType().c_str()); break; } }
int CCLuaEngine::executeFunctionByHandler(int nHandler, int numArgs) { if (pushFunction(nHandler)) /* stack: ... arg1 arg2 ... func */ { if (numArgs > 0) { lua_insert(m_state, -(numArgs + 1)); /* stack: ... func arg1 arg2 ... */ } int traceback = 0; lua_getglobal(m_state, "__G__TRACKBACK__"); /* stack: ... func arg1 arg2 ... G */ if (!lua_isfunction(m_state, -1)) { lua_pop(m_state, 1); /* stack: ... func arg1 arg2 ... */ } else { traceback = -(numArgs + 2); lua_insert(m_state, traceback); /* stack: ... G func arg1 arg2 ... */ } int error = 0; ++m_callFromLua; error = lua_pcall(m_state, numArgs, 1, traceback); /* stack: ... ret */ --m_callFromLua; if (error) { if (traceback == 0) { CCLOG("[LUA ERROR] %s", lua_tostring(m_state, - 1)); /* stack: ... error */ lua_pop(m_state, 1); // remove error message from stack } return 0; } // get return value int ret = 0; if (lua_isnumber(m_state, -1)) { ret = lua_tointeger(m_state, -1); } else if (lua_isboolean(m_state, -1)) { ret = lua_toboolean(m_state, -1); } lua_pop(m_state, 1); // remove return value from stack return ret; } else { lua_pop(m_state, numArgs); // remove args from stack return 0; } }
void ConvertTypeInstance(Context& context, AST::Node<AST::TypeInstance>& typeInstanceNode) { for (const auto& function: *(typeInstanceNode->functionDecls)) { PushScopeElement pushScopeElement(context.scopeStack(), ScopeElement::Function(*function)); ConvertFunctionDef(context, function); } if (typeInstanceNode->isEnum()) { size_t enumValue = 0; // Generate enum constructors. for (const auto& constructorName: *(typeInstanceNode->constructors)) { const auto canonicalMethodName = CanonicalizeMethodName(constructorName); CreateEnumConstructorMethod(context, typeInstanceNode, typeInstanceNode->getFunction(canonicalMethodName), enumValue++); } } // Generate default constructor for applicable types. if (typeInstanceNode->isException()) { CreateExceptionConstructor(context, typeInstanceNode, typeInstanceNode->getFunction(context.getCString("create"))); } else if (typeInstanceNode->isDatatype() || typeInstanceNode->isStruct() || typeInstanceNode->isUnion()) { (void) DefaultMethods(context).createDefaultMethod(typeInstanceNode.get(), typeInstanceNode->getFunction(context.getCString("create")), typeInstanceNode.location()); } // Generate default implicitCopy if relevant. if (typeInstanceNode->isEnum() || typeInstanceNode->isStruct() || typeInstanceNode->isDatatype() || typeInstanceNode->isVariant() || typeInstanceNode->isUnion()) { const auto existingFunction = typeInstanceNode->findFunction(context.getCString("implicitcopy")); if (existingFunction != nullptr) { CreateDefaultMethodOrRemove(context, *typeInstanceNode, *existingFunction, typeInstanceNode.location()); } } // Generate default compare if relevant. if (typeInstanceNode->isEnum() || typeInstanceNode->isStruct() || typeInstanceNode->isDatatype() || typeInstanceNode->isVariant()) { const auto existingFunction = typeInstanceNode->findFunction(context.getCString("compare")); if (existingFunction != nullptr) { CreateDefaultMethodOrRemove(context, *typeInstanceNode, *existingFunction, typeInstanceNode.location()); } } // Simplify all predicates to avoid confusing CodeGen. for (auto& function: typeInstanceNode->functions()) { PushScopeElement pushFunction(context.scopeStack(), ScopeElement::Function(*function)); function->setConstPredicate(reducePredicate(context, function->constPredicate().copy())); function->setRequiresPredicate(reducePredicate(context, function->requiresPredicate().copy())); // Simplify function type noexcept predicate. const auto oldFunctionType = function->type(); const bool isVarArg = oldFunctionType.attributes().isVarArg(); const bool isMethod = oldFunctionType.attributes().isMethod(); const bool isTemplated = oldFunctionType.attributes().isTemplated(); auto noExceptPredicate = reducePredicate(context, oldFunctionType.attributes().noExceptPredicate().copy()); const auto returnType = oldFunctionType.returnType(); const auto& argTypes = oldFunctionType.parameterTypes(); AST::FunctionAttributes attributes(isVarArg, isMethod, isTemplated, std::move(noExceptPredicate)); function->setType(AST::FunctionType(std::move(attributes), returnType, argTypes.copy())); } }