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.parent: method.parent = orig_method.parent.translation method.orig_name = orig_method.name 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))) 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 make_binder(orig_class, lua_cls): cls_type = cpp.cpp_type('void') binder = cpp.cpp_method('bind', static=True, returns=cls_type, params=[cpp.cpp_variable('L', cpp.cpp_type('lua_State', pointer=True))]) binder.exprs.append('lua_newtable(L)') binder.exprs.append('luaL_setfuncs (L, lua_reg_{},0)'.format(orig_class.identifier_name)) binder.exprs.append('lua_setfield(L, -2, "{}")'.format(orig_class.name)) return binder
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) orig_class.translation = lua_cls luaReg = cpp.cpp_variable_array('lua_reg_' + orig_class.identifier_name, cpp.cpp_type('constexpr luaL_Reg', static=True)) logging.debug('baking methods for class: %s : %s' % (orig_class.name ,orig_class.public)) #lua_cls.public.append(make_getter(orig_class)) #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 item.public: luaReg.expr.append('{ "%s" , lua_munch_%s::%s }' % (item.orig_name, orig_class.identifier_name, item.name)) lua_cls.public.append(make_binder(orig_class, lua_cls)) #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, %d)' % (orig_class.qualname, orig_class.identifier_name, 1)) 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) context.binder_method.exprs.append('{}::bind(L)'.format(lua_cls.name)) luaReg.parent = lua_cls vardecl = luaReg.define() vardecl = vardecl.replace('static', '') context.luareg_declarations.append(vardecl) orig_class.translation = lua_cls
def lua_preprocess(data, context): classes = filter(lambda item: type(item) == cpp.cpp_class, data) functions = filter(lambda item: type(item) == cpp.cpp_method and item.parent == None, data) other = filter(lambda item: type(item) != cpp.cpp_method and type(item) != cpp.cpp_class, data) del data[:] #resolving overloads for item in classes: item.identifier_name = item.qualname\ .replace('::', '_')\ .replace(' ', '')\ .replace('<','_')\ .replace('>', '_')\ .replace(',', '_') process_functions(item) #resolving dependencies sorted_classes = [] class_set = set([]) previous_count = len(classes) iteration = 0 while classes: current = classes.pop(0) processed = True #print 'testing', current.name, current.dependencies for dependency in current.dependencies: if 'std' in dependency or dependency == current.qualname: continue #remove this once the generator knows how to get template items if '<' in dependency: templates = dependency[dependency.find('<') + 1:dependency.find('>')].split(',') current.dependencies += templates if not dependency in class_set and not iteration == 10: #print 'I dont have dependency: ', dependency classes.append(current) processed = False break if processed: #print '### added', current.name sorted_classes.append(current) class_set.add(current.qualname) iteration = 0 if previous_count == len(classes): if iteration == 10: raise Exception("Couldn't resolve dependencies for the classes:" + str(classes)) iteration += 1 previous_count = len(classes) fake_cls = cpp.cpp_class('Fake') fake_cls.public = functions process_functions(fake_cls) data += sorted_classes + fake_cls.public + other context.binder_method = cpp.cpp_method('luaopen_gdx', returns=cpp.cpp_type('int'), attributes=['extern', '"C"'], params=[cpp.cpp_variable('L', cpp.cpp_type('lua_State', pointer=True))]) context.luareg_declarations = [] context.binder_method.exprs.append('lua_newtable(L)') context.binder_method.return_value = cpp.cpp_return(1)
def process_functions(cls): overloads = {} for item in cls.public: if type(item) == cpp.cpp_method: if item.name in overloads: overloads[item.name].append(item) else: overloads[item.name] = [item] final_functions = [] overload_count = 0 for func in overloads: #if there is only one function with this name, it's not an overload it safely if len(overloads[func]) == 1: overloads[func][0].is_overload = False overloads[func][0].has_overload = False final_functions.append(overloads[func][0]) else: newfun = cpp.cpp_method(func) newfun.has_overload = True newfun.is_overload = False newfun.overloads = { 'by_arg_count' : [], 'by_lua_type' : [], 'by_cpp_type' : [] } newfun.is_constructor = overloads[func][0].is_constructor newfun.parent = cls for i, function in enumerate(overloads[func]): function.name = '%s_overload_%d' % (function.name, overload_count) function.is_overload = True function.has_overload = False function.orig_name = newfun.name overload_count += 1 if function.is_virtual: newfun.is_virtual = True #resolving functions that can be deduced by the count of it's arguments same_qnt = False for other_f in overloads[func]: if other_f == function: continue if len(function.parameters) == len(other_f.parameters): same_qnt = True break if not same_qnt: newfun.overloads['by_arg_count'].append(function) continue #resolving functions that can be deduced by the type of it's lua arguments for other_f in overloads[func]: if other_f == function: continue same_basic_types = False for a,b in zip(function.parameters, other_f.parameters): if a.ctype == b.ctype and not is_basic(a): same_basic_types = True break if same_basic_types: break if not same_basic_types: newfun.overloads['by_lua_type'].append(function) continue newfun.overloads['by_cpp_type'].append(function) final_functions.append(newfun) #filter every final_public = filter(lambda item: type(item) != cpp.cpp_method, cls.public) cls.public = final_public + final_functions