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()));
}
}
