def init_translated_method(orig_method, context): assert 'translation' not in orig_method.__dict__ logging.debug('entered [init_translated_method] with method:' + repr(orig_method)) method = cpp.cpp_method('lua_munch_' + orig_method.name, static=True, returns= cpp.cpp_type('int'), params=[cpp.cpp_variable('L', cpp.cpp_type('lua_State', pointer=True))]) if orig_method.is_virtual: method.parameters.append(cpp.cpp_type(orig_method.parent.qualname, pointer= True)) method.public = True #now we embed the default object with a very specific format that will be useful later method.initialization = [] # will contain initialization steps method.validation = [] # will contain validation steps method.recover = [] # will contain the steps to translate the lua arg to a C++ arg method.execution = [] # will contain execution steps, i.e, calling the native method method.lua_return = [] # will contain the steps to push a value back to lua if not 'is_overload' in method.__dict__: method.is_overload = False if orig_method.parent and orig_method.is_virtual: method.parameters.append(cpp.cpp_variable('lua_self', cpp.cpp_type(orig_method.parent.qualname, pointer=True))) if orig_method.is_constructor: method.name = 'lua_munch_' + orig_method.parent.name + '_constructor' method.return_value = cpp.cpp_return(0) #we 'tie' the translated method on the original method #so it's easier to work with them without needing to search for them on every callback orig_method.translation = method
def test_class_method_overload(): cls = cpp.cpp_class('MyTest') cls.qualname = "MyTest" method = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('MyTestClass', const=True))]) method1 = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('int', const=True))]) method2 = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('int', const=True)), cpp.cpp_variable('othervar', cpp.cpp_type('int', const=True))]) cls.public.append(method) method.parent = cls cls.public.append(method1) method1.parent = cls cls.public.append(method2) method2.parent = cls context = lua.lua_context_builder.bake([cls]) assert len(context.translated) == 1 t_cls = context.translated[0] assert t_cls assert t_cls.name == 'lua_munch_MyTest'
def init_translated_class(orig_class, context): assert 'translation' not in orig_class.__dict__ lua_cls = cpp.cpp_class('lua_munch_' + orig_class.identifier_name) luaReg = cpp.cpp_variable_array('lua_reg_' + orig_class.identifier_name, cpp.cpp_type('luaL_Reg', static=True)) logging.debug('baking methods for class: %s : %s' % (orig_class.name ,orig_class.public)) #we now bake all methods and subclasses from this class, but not preprocess them class_ctx = lua_context_builder.bake(orig_class.public, preprocess=False) for item in class_ctx.translated: if item.public: lua_cls.public.append(item) else: lua_cls.protected.append(item) if type(item) == cpp.cpp_method and not item.is_constructor and item.public: luaReg.expr.append('{ "%s" , lua_munch_%s::lua_munch_%s }' % (item.name, orig_class.name, item.name)) #the base methods are shims that only retrieve it's self and pass it down to the #base class for base in orig_class.bases: for item in base.public: if type(item) != cpp.cpp_method: continue method = cpp.cpp_method('lua_munch_' + item.name, static=True, returns=cpp.cpp_type('int'), params=[cpp.cpp_variable('L', cpp.cpp_type('lua_State', pointer=True))]) if item.parent: item.parameters.append(cpp.cpp_variable('lua_self', cpp.cpp_type(item.parent.name, pointer=True))) method.exprs.append('%s* lua_self = lua_munch_%s::get(L)' % (orig_class.qualname, orig_class.identifier_name)) method.exprs.append(cpp.cpp_return(cpp.cpp_method_call('lua_munch_%s::lua_munch_%s' % (item.parent.name, item.name), params=['L', 'lua_self']))) lua_cls.public.append(method) if not item.is_constructor: luaReg.expr.append('{ "%s" , lua_munch_%s::lua_munch_%s }' % (item.name, orig_class.name, item.name)) luaReg.expr.append('{ 0, 0 }') lua_cls.public.append(luaReg) orig_class.translation = lua_cls
def test_class_base(): base = cpp.cpp_class('base') base.qualname = 'MyBaseClass' bmethod = cpp.cpp_method('base_method', params=[cpp.cpp_variable('variable', cpp.cpp_type('int'))]) bmethod.is_virtual = True base.public.append(bmethod) bmethod.parent = base cls = cpp.cpp_class('MyTest') cls.qualname = 'MyTestClass' cls.bases.append(base) method = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('MyTestClass', const=True))]) method1 = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('int', const=True))]) cls.public.append(method) method.parent = cls cls.public.append(method1) method1.parent = cls context = lua.lua_context_builder.bake([base, cls]) assert len(context.translated) == 2 t_cls = context.translated[1] assert t_cls assert t_cls.name == 'lua_munch_MyTest' print context.translated[0] print t_cls assert False
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
def test_method_param_lua_primitives(): method = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('int'))]) context = lua.lua_context_builder.bake([method]) assert len(context.translated) == 1 t_method = context.translated[0] assert t_method.static assert t_method.name == 'lua_munch_method' assert t_method.initialization assert t_method.initialization[0] assert t_method.initialization[0] == method.parameters[0]
def test_class(): cls = cpp.cpp_class('MyTest') cls.qualname = "MyTest" method = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('MyTestClass', const=True))]) cls.public.append(method) context = lua.lua_context_builder.bake([cls]) assert len(context.translated) == 1 t_cls = context.translated[0] assert t_cls assert t_cls.name == 'lua_munch_MyTest'
def test_method_param_class(): method = cpp.cpp_method('method', params=[cpp.cpp_variable('myvar', cpp.cpp_type('MyTestClass', const=True))]) var = lua.lua_context_builder.apply_variable_initialization(method.parameters[0], None) assert type(var.ctype) == cpp.cpp_qual_type assert var.ctype.pointer == True context = lua.lua_context_builder.bake([method]) assert len(context.translated) == 1 t_method = context.translated[0] assert t_method.static assert t_method.name == 'lua_munch_method' assert t_method.initialization assert t_method.initialization[0]
def anytype_initializer(variable, ctype): #the initialized variable shouldn't carry refs and other stuff, so we bake a new one here new_ctype = cpp.cpp_type(variable.ctype.name, pointer=variable.ctype.pointer) return cpp.cpp_variable(variable.name, cpp.cpp_type(new_ctype, pointer=True, reference=False))
def string_initializer(variable, ctype): return cpp.cpp_variable(variable.name, cpp.cpp_type('char', pointer=True))