def process_overload_by_lua_type(orig_method, context):
logging.debug('processing overloads by lua type for method: %s' % orig_method.name)
aluatype = orig_method.overloads['by_lua_type']
cif = None
tmp = None
stack_init = 1 if not orig_method.is_constructor else 0
for by_lua_type in aluatype:
cand = cpp.cpp_and()
for i, param in enumerate(by_lua_type.parameters):
lua_type = get_lua_tye(param.ctype)
cand.exprs.append('lua_type(L, %d) == %s'
% (stack_init + i, lua_type))
if not cand.exprs:
raise Exception("Error processing items by lua type: %r" % (by_lua_type))
by_lua_type.is_overload = False
#we bake the overload method and add it back to our context
other_method = lua_context_builder.bake([by_lua_type], preprocess = False).translated[0]
other_method.public = False
context.translated.append(other_method)
for item in other_method.execution:
if type(item) == cpp.cpp_method_call:
item.expr = orig_method.name if not orig_method.parent else 'lua_self->' + orig_method.name
break
if not tmp:
cif = tmp = cpp.cpp_if()
else:
tmp.cpp_else = cpp.cpp_if()
tmp = cif.cpp_else
tmp.exprs.append(cand)
params = ['L']
if orig_method.is_virtual:
params.append('lua_self')
ret = cpp.cpp_return(cpp.cpp_method_call('lua_munch_' + by_lua_type.name, params = params))
tmp.body.append(ret)
orig_method.translation.execution.append(cif)
def process_function(function, context):
logging.debug('translating:' + repr(function))
method = function.translation
#adding an index value to each positional parameter
for i, parameter in enumerate(function.parameters):
parameter.index = i if function.is_constructor else i + 2
#firstly we add the default initializers for each mapped type
for parameter in function.parameters:
method.initialization.append(lua_context_builder.apply_variable_initialization(parameter, context))
#this additional step will ensure that the amount of parameters is correct
method.validation.append('assert(lua_gettop(L) == %d)' % (len(function.parameters) + (0 if function.is_constructor else 1)))
#then we add type checking
for parameter in function.parameters:
method.validation.append(lua_context_builder.apply_variable_check(parameter, context))
#then we get the variables from LUA
if function.parent:
if function.is_virtual:
cif = cpp.cpp_if(['lua_self != nullptr'])
cif.body.append('lua_self = lua_munch_%s::get(L)' % (function.parent.identifier_name))
method.recover.append(cif)
else:
method.initialization.append('{0}* lua_self = lua_munch_{1}::get(L)'.format(function.parent.qualname, function.parent.identifier_name))
for parameter in function.parameters:
method.recover.append(lua_context_builder.apply_variable_conversion_from_target(parameter, context))
applied_parameters = []
for parameter in function.parameters:
applied_parameters.append(cpp.cpp_dereference(parameter))
#then we call the original method!
method.execution.append(cpp.cpp_method_call(function.name if not function.parent else 'lua_self->' + function.name, applied_parameters))
if function.returns != cpp.cpp_type('void'):
#if the function is not void, we recover the method execution
method_execution = method.execution[0]
#create a variable assignment
assign = cpp.cpp_assignment(cpp.cpp_variable('lua_return', function.returns), method_execution)
#put id back to the execution
method.execution[0] = assign
#push the value to lua
method.lua_return.append(lua_context_builder.apply_variable_conversion_to_target(assign.expr_a, context))
#and then change the call function to 1 so LUA knows it has one value to unpack
method.return_value = cpp.cpp_return(1)
method.exprs += method.initialization + method.validation + method.recover + method.execution + method.lua_return