#!/usr/bin/env python #NOTE: If you make modifications here, consider whether they should #be duplicated in ../lsteamclient/gen_wrapper.py from __future__ import print_function CLANG_PATH='/usr/lib/clang/9.0.1' import pprint import sys import clang.cindex import os import re sdk_versions = [ "v1.10.30", "v1.9.16", "v1.8.19", "v1.7.15", "v1.6.10", "v1.5.17", "v1.4.18", "v1.3.22", "v1.2.10", "v1.1.3b", "v1.0.17", "v1.0.16", "v1.0.15", "v1.0.14", "v1.0.13", "v1.0.12", "v1.0.11", "v1.0.10", "v1.0.9", "v1.0.8", "v1.0.7", "v1.0.6", "v1.0.5", "v1.0.4", "v1.0.3a", #non-public build used by The Lab, see Proton github PR#2075 "v1.0.3", "v1.0.2", "v1.0.1", "v1.0.0", "v0.9.20", "v0.9.19", "v0.9.18", "v0.9.17", "v0.9.16", "v0.9.15", "v0.9.14", "v0.9.13", "v0.9.12", # "v0.9.11", problematic GetComponentState, may cause crash since we don't implement it "v0.9.10", "v0.9.9", "v0.9.8", "v0.9.7", "v0.9.6", # "v0.9.5", doesn't compile, fixed in 0.9.6 "v0.9.4", "0.9.3", "0.9.2", "0.9.1", "0.9.0", ] files = [ ("openvr.h", [ #classes "IVRApplications", "IVRChaperone", "IVRChaperoneSetup", "IVRCompositor", "IVRControlPanel", "IVRDriverManager", "IVRExtendedDisplay", "IVRNotifications", "IVRInput", "IVRIOBuffer", "IVRMailbox", "IVROverlay", "IVRRenderModels", "IVRResources", "IVRScreenshots", "IVRSettings", "IVRSystem", "IVRTrackedCamera", "IVRHeadsetView", "IVROverlayView", ], [ #vrclient-allocated structs "RenderModel_t", "RenderModel_TextureMap_t", ] ), ("ivrclientcore.h", [ #classes "IVRClientCore", ], [ #vrclient-allocated structs ] ), ] next_is_size_structs = [ "VREvent_t", "VRControllerState001_t", "InputAnalogActionData_t", "InputDigitalActionData_t", "InputPoseActionData_t", "InputSkeletalActionData_t", "CameraVideoStreamFrameHeader_t", "Compositor_CumulativeStats", "VRActiveActionSet_t", "InputOriginInfo_t", "InputBindingInfo_t", ] unhandled_next_is_size_structs = [ "VROverlayIntersectionMaskPrimitive_t" # not next, but next-next uint32 is the size ] struct_size_fields = { "Compositor_OverlaySettings": ["size"], "Compositor_FrameTiming": ["size", "m_nSize"], "DriverDirectMode_FrameTiming": ["m_nSize"], } path_conversions = [ { "parent_name": "SetActionManifestPath", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchActionManifestPath"], "w2l_arrays": [False], "return_is_size": False }, { "parent_name": "SetOverlayFromFile", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchFilePath"], "w2l_arrays": [False], "return_is_size": False }, { "parent_name": "AddApplicationManifest", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchApplicationManifestFullPath"], "w2l_arrays": [False], "return_is_size": False }, { "parent_name": "RemoveApplicationManifest", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchApplicationManifestFullPath"], "w2l_arrays": [False], "return_is_size": False }, { "parent_name": "RequestScreenshot", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchPreviewFilename", "pchVRFilename"], "w2l_arrays": [False, False], "return_is_size": False }, { "parent_name": "TakeStereoScreenshot", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchPreviewFilename", "pchVRFilename"], "w2l_arrays": [False, False], "return_is_size": False }, { "parent_name": "SubmitScreenshot", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchSourcePreviewFilename", "pchSourceVRFilename"], "w2l_arrays": [False, False], "return_is_size": False }, { "parent_name": "GetScreenshotPropertyFilename", "l2w_names":["pchFilename"], "l2w_lens":["cchFilename"], "w2l_names": [], "w2l_arrays": [], "return_is_size": True }, { "parent_name": "undoc23", "l2w_names":[], "l2w_lens":[], "w2l_names": ["a"], "w2l_arrays": [False], "return_is_size": False }, { "parent_name": "undoc27", "l2w_names":[], "l2w_lens":[], "w2l_names": ["a"], "w2l_arrays": [False], "return_is_size": False }, { "parent_name": "SetStageOverride_Async", "l2w_names":[], "l2w_lens":[], "w2l_names": ["pchRenderModelPath"], "w2l_arrays": [False], "return_is_size": False }, # {#maybe? # "parent_name": "GetRenderModelOriginalPath", # "l2w_names":[pchOriginalPath], # "l2w_lens":[unOriginalPathLen], # "w2l_names": [], # "w2l_arrays": [], # "return_is_size": False # }, # {#maybe? # "parent_name": "GetResourceFullPath", # "l2w_names":[pchPathBuffer], # "l2w_lens":[unBufferLen], # "w2l_names": [pchResourceTypeDirectory], # "w2l_arrays": [False], # "return_is_size": False # }, #IVRInput::GetInputSourceHandle #IVRIOBuffer::Open #TODO: LaunchInternalProcess, need steam cooperation ] aliases = { #Some interface versions are not present in the public SDK #headers, but are actually requested by games. It would be nice #to verify that these interface versions are actually binary #compatible. Lacking that, we hope the next highest version #is compatible. # "SteamClient012":["SteamClient013"], # "SteamUtils004":["SteamUtils003"], # TimeShift uses SteamUtils003 #leaving these commented-out. let's see if they turn up in practice, #and handle them correctly if so. # "SteamFriends011":["SteamFriends010"], # "SteamFriends013":["SteamFriends012"], # "SteamGameServer008":["SteamGameServer007", "SteamGameServer006"], # "SteamMatchMaking004":["SteamMatchMaking003"], # "SteamMatchMaking006":["SteamMatchMaking005"], # "STEAMREMOTESTORAGE_INTERFACE_VERSION004":["STEAMREMOTESTORAGE_INTERFACE_VERSION003"], # "STEAMREMOTESTORAGE_INTERFACE_VERSION008":["STEAMREMOTESTORAGE_INTERFACE_VERSION007"], # "STEAMREMOTESTORAGE_INTERFACE_VERSION010":["STEAMREMOTESTORAGE_INTERFACE_VERSION009"], # "STEAMUGC_INTERFACE_VERSION005":["STEAMUGC_INTERFACE_VERSION004"], # "STEAMUGC_INTERFACE_VERSION007":["STEAMUGC_INTERFACE_VERSION006"], # "SteamUser016":["SteamUser015"], # "STEAMUSERSTATS_INTERFACE_VERSION009":["STEAMUSERSTATS_INTERFACE_VERSION008"], } # TODO: we could do this automatically by creating temp files and # having clang parse those and detect when the MS-style padding results # in identical struct widths. But there's only a couple, so let's cheat... skip_structs = [ # "RemoteStorageGetPublishedFileDetailsResult_t_9740", # "SteamUGCQueryCompleted_t_20", # "SteamUGCRequestUGCDetailsResult_t_9764" ] struct_conversion_cache = {} print_sizes = [] class_versions = {} def get_params(f): return [p for p in f.get_children() if p.kind == clang.cindex.CursorKind.PARM_DECL] def ivrclientcore_init(cppname, method): if "002" in cppname: return "ivrclientcore_002_init" return "ivrclientcore_init" def ivrclientcore_get_generic_interface(cppname, method): return "ivrclientcore_get_generic_interface" def ivrclientcore_cleanup(cppname, method): return "ivrclientcore_cleanup" def ivrsystem_get_dxgi_output_info(cppname, method): param_count = len(get_params(method)) return { 1: "get_dxgi_output_info", 2: "get_dxgi_output_info2" }.get(param_count, "unhandled_get_dxgi_output_info_method") def ivrsystem_get_output_device(cppname, method): #introduced in 016, changed in 017 if "016" in cppname: return "ivrsystem_016_get_output_device" return "ivrsystem_get_output_device" def ivrcompositor_submit(cppname, method): if "005" in cppname: return "ivrcompositor_005_submit" if "006" in cppname: return "ivrcompositor_006_submit" if "007" in cppname: return "ivrcompositor_007_submit" if "008" in cppname: return "ivrcompositor_008_submit" return "ivrcompositor_submit" def ivrcompositor_post_present_handoff(cppname, method): return "ivrcompositor_post_present_handoff" def ivrcompositor_wait_get_poses(cppname, method): for version in ["016", "017", "018", "019", "020", "021", "022", "024", "026"]: if version in cppname: return "ivrcompositor_wait_get_poses" return None def ivrcompositor_get_vulkan_device_extensions_required(cppname, method): return "ivrcompositor_get_vulkan_device_extensions_required" def ivrrendermodels_load_texture_d3d11_async(cppname, method): assert "004" in cppname or "005" in cppname or "006" in cppname return "ivrrendermodels_load_texture_d3d11_async" def ivrrendermodels_free_texture_d3d11(cppname, method): assert "004" in cppname or "005" in cppname or "006" in cppname return "ivrrendermodels_free_texture_d3d11" def ivrrendermodels_load_into_texture_d3d11_async(cppname, method): assert "005" in cppname or "006" in cppname return "ivrrendermodels_load_into_texture_d3d11_async" def ivrmailbox_undoc3(cppname, method): assert "001" in cppname return "ivrmailbox_undoc3" method_overrides = [ ("IVRClientCore", "Init", ivrclientcore_init), ("IVRClientCore", "GetGenericInterface", ivrclientcore_get_generic_interface), ("IVRClientCore", "Cleanup", ivrclientcore_cleanup), ("IVRSystem", "GetDXGIOutputInfo", ivrsystem_get_dxgi_output_info), ("IVRSystem", "GetOutputDevice", ivrsystem_get_output_device), ("IVRCompositor", "Submit", ivrcompositor_submit), ("IVRCompositor", "PostPresentHandoff", ivrcompositor_post_present_handoff), ("IVRCompositor", "WaitGetPoses", ivrcompositor_wait_get_poses), ("IVRCompositor", "GetVulkanDeviceExtensionsRequired", ivrcompositor_get_vulkan_device_extensions_required), ("IVRRenderModels", "LoadTextureD3D11_Async", ivrrendermodels_load_texture_d3d11_async), ("IVRRenderModels", "FreeTextureD3D11", ivrrendermodels_free_texture_d3d11), ("IVRRenderModels", "LoadIntoTextureD3D11_Async", ivrrendermodels_load_into_texture_d3d11_async), ("IVRMailbox", "undoc3", ivrmailbox_undoc3), ] method_overrides_data = [ ("IVRClientCore", "struct client_core_data", None), ("IVRCompositor", "struct compositor_data", "destroy_compositor_data"), ] def display_sdkver(s): if s.startswith("v"): s = s[1:] return s.replace(".", "") def strip_ns(name): return name.replace("vr::","") def get_path_converter(parent): for conv in path_conversions: if conv["parent_name"] in parent.spelling: if None in conv["l2w_names"]: return conv if type(parent) == clang.cindex.Type: children = list(parent.get_fields()) else: children = list(parent.get_children()) for child in children: if child.spelling in conv["w2l_names"] or \ child.spelling in conv["l2w_names"]: return conv return None def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, existing_methods, iface_version): used_name = method.spelling if used_name in existing_methods: number = '2' while used_name in existing_methods: idx = existing_methods.index(used_name) used_name = "%s_%s" % (method.spelling, number) number = chr(ord(number) + 1) existing_methods.insert(idx, used_name) else: existing_methods.append(used_name) returns_record = method.result_type.get_canonical().kind == clang.cindex.TypeKind.RECORD if returns_record: parambytes = 8 #_this + return pointer else: parambytes = 4 #_this for param in get_params(method): parambytes += param.type.get_size() cfile.write("DEFINE_THISCALL_WRAPPER(%s_%s, %s)\n" % (winclassname, used_name, parambytes)) cpp_h.write("extern ") if strip_ns(method.result_type.spelling).startswith("IVR"): cfile.write("win%s " % (strip_ns(method.result_type.spelling))) cpp.write("void *") cpp_h.write("void *") elif returns_record: cfile.write("%s *" % strip_ns(method.result_type.spelling)) cpp.write("%s " % method.result_type.spelling) cpp_h.write("%s " % strip_ns(method.result_type.spelling)) else: cfile.write("%s " % strip_ns(method.result_type.spelling)) cpp.write("%s " % method.result_type.spelling) cpp_h.write("%s " % strip_ns(method.result_type.spelling)) cfile.write('__thiscall %s_%s(%s *_this' % (winclassname, used_name, winclassname)) cpp.write("%s_%s(void *linux_side" % (cppname, used_name)) cpp_h.write("%s_%s(void *" % (cppname, used_name)) if returns_record: cfile.write(", %s *_r" % strip_ns(method.result_type.spelling)) unnamed = 'a' do_lin_to_win = None do_win_to_lin = None do_wrap = None do_unwrap = None need_convert = [] for param in get_params(method): if param.type.kind == clang.cindex.TypeKind.POINTER and \ param.type.get_pointee().kind == clang.cindex.TypeKind.UNEXPOSED: #unspecified function pointer typename = "void *" else: typename = param.type.spelling.split("::")[-1].replace("&", "*") real_type = param.type; while real_type.kind == clang.cindex.TypeKind.POINTER: real_type = real_type.get_pointee() if param.type.kind == clang.cindex.TypeKind.POINTER: if strip_ns(param.type.get_pointee().get_canonical().spelling) in system_structs: do_unwrap = (strip_ns(param.type.get_pointee().get_canonical().spelling), param.spelling) typename = "win" + do_unwrap[0] + "_" + display_sdkver(sdkver) + " *" elif param.type.get_pointee().get_canonical().kind == clang.cindex.TypeKind.POINTER and \ strip_ns(param.type.get_pointee().get_pointee().get_canonical().spelling) in system_structs: do_wrap = (strip_ns(param.type.get_pointee().get_pointee().get_canonical().spelling), param.spelling) typename = "win" + do_wrap[0] + "_" + display_sdkver(sdkver) + " **" elif real_type.get_canonical().kind == clang.cindex.TypeKind.RECORD and \ struct_needs_conversion(real_type.get_canonical()): do_win_to_lin = (strip_const(strip_ns(real_type.get_canonical().spelling)), param.spelling) if not real_type.is_const_qualified(): do_lin_to_win = (strip_const(strip_ns(real_type.get_canonical().spelling)), param.spelling) #preserve pointers typename = typename.replace(strip_ns(real_type.spelling), "win%s_%s" % (strip_ns(real_type.get_canonical().spelling), display_sdkver(sdkver))) if param.spelling == "": cfile.write(", %s _%s" % (typename, unnamed)) cpp.write(", %s _%s" % (typename, unnamed)) cpp_h.write(", %s" % typename) unnamed = chr(ord(unnamed) + 1) else: cfile.write(", %s %s" % (typename, param.spelling)) cpp.write(", %s %s" % (typename, param.spelling)) cpp_h.write(", %s" % (typename)) cfile.write(")\n{\n") cpp.write(")\n{\n") cpp_h.write(");\n") path_conv = get_path_converter(method) if path_conv: for i in range(len(path_conv["w2l_names"])): if path_conv["w2l_arrays"][i]: cfile.write(" const char **lin_%s = vrclient_dos_to_unix_stringlist(%s);\n" % (path_conv["w2l_names"][i], path_conv["w2l_names"][i])) # TODO pass else: cfile.write(" char lin_%s[PATH_MAX];\n" % path_conv["w2l_names"][i]) cfile.write(" vrclient_dos_path_to_unix_path(%s, lin_%s);\n" % (path_conv["w2l_names"][i], path_conv["w2l_names"][i])) if None in path_conv["l2w_names"]: cfile.write(" const char *path_result;\n") elif path_conv["return_is_size"]: cfile.write(" uint32_t path_result;\n") elif len(path_conv["l2w_names"]) > 0: cfile.write(" %s path_result;\n" % method.result_type.spelling) if do_lin_to_win or do_win_to_lin: if do_lin_to_win: cpp.write(" %s lin;\n" % do_lin_to_win[0]) else: cpp.write(" %s lin;\n" % do_win_to_lin[0]) if not method.result_type.kind == clang.cindex.TypeKind.VOID: cpp.write(" %s _ret;\n" % method.result_type.spelling) if do_wrap: cpp.write(" %s *lin;\n" % do_wrap[0]) if not method.result_type.kind == clang.cindex.TypeKind.VOID: cpp.write(" %s _ret;\n" % method.result_type.spelling) cfile.write(" TRACE(\"%p\\n\", _this);\n") if do_win_to_lin: #XXX we should pass the struct size here cpp.write(" if(%s)\n" % do_win_to_lin[1]) cpp.write(" struct_%s_%s_win_to_lin(%s, &lin);\n" % (strip_ns(do_win_to_lin[0]), display_sdkver(sdkver), do_win_to_lin[1])) if method.result_type.kind == clang.cindex.TypeKind.VOID: cfile.write(" ") cpp.write(" ") elif path_conv and (len(path_conv["l2w_names"]) > 0 or path_conv["return_is_size"]): cfile.write(" path_result = ") cpp.write(" return ") elif returns_record: cfile.write(" *_r = ") cpp.write(" return ") elif do_lin_to_win or do_win_to_lin: cfile.write(" return ") cpp.write(" _ret = ") elif do_wrap: cfile.write(" return ") cpp.write(" _ret = ") else: cfile.write(" return ") cpp.write(" return ") should_gen_wrapper = strip_ns(method.result_type.spelling).startswith("IVR") if should_gen_wrapper: cfile.write("create_win_interface(pchNameAndVersion,\n ") is_method_overridden = False for classname_pattern, methodname, override_generator in method_overrides: if used_name == methodname and classname_pattern in classname: fn_name = override_generator(cppname, method) if fn_name: cfile.write("%s(%s_%s, _this->linux_side" % (fn_name, cppname, used_name)) is_method_overridden = True break else: cfile.write("%s_%s(_this->linux_side" % (cppname, used_name)) cpp.write("((%s*)linux_side)->%s(" % (classname, method.spelling)) unnamed = 'a' first = True next_is_size = False convert_size_param = "" for param in get_params(method): if not first: cpp.write(", ") else: first = False if param.spelling == "": cfile.write(", _%s" % unnamed) cpp.write("(%s)_%s" % (param.type.spelling, unnamed)) unnamed = chr(ord(unnamed) + 1) else: if do_lin_to_win and do_lin_to_win[1] == param.spelling or \ do_win_to_lin and do_win_to_lin[1] == param.spelling or \ do_wrap and do_wrap[1] == param.spelling: cfile.write(", %s" % param.spelling) cpp.write("%s ? &lin : nullptr" % param.spelling) if do_win_to_lin: assert(not do_win_to_lin[0] in unhandled_next_is_size_structs) if do_win_to_lin[0] in next_is_size_structs: next_is_size = True elif do_unwrap and do_unwrap[1] == param.spelling: cfile.write(", %s" % param.spelling) cpp.write("struct_%s_%s_unwrap(%s)" % (strip_ns(do_unwrap[0]), display_sdkver(sdkver), do_unwrap[1])) elif path_conv and param.spelling in path_conv["w2l_names"]: cfile.write(", %s ? lin_%s : NULL" % (param.spelling, param.spelling)) cpp.write("(%s)%s" % (param.type.spelling, param.spelling)) elif next_is_size: cfile.write(", %s" % param.spelling) next_is_size = False if param.type.spelling == "uint32_t": cpp.write("%s ? sizeof(lin) : 0" % param.spelling) convert_size_param = ", " + param.spelling else: cpp.write("(%s)%s" % (param.type.spelling, param.spelling)) convert_size_param = ", -1" elif "&" in param.type.spelling: cfile.write(", %s" % param.spelling) cpp.write("*%s" % param.spelling) else: cfile.write(", %s" % param.spelling) cpp.write("(%s)%s" % (param.type.spelling, param.spelling)) if should_gen_wrapper: cfile.write(")") if is_method_overridden: cfile.write(", %s" % iface_version[iface_version.find("_") + 1:].lstrip("0")) for classname_pattern, user_data_type, _ in method_overrides_data: if classname_pattern in classname: cfile.write(", &_this->user_data") break cfile.write(");\n") cpp.write(");\n") if returns_record: cfile.write(" return _r;\n") if path_conv and len(path_conv["l2w_names"]) > 0: for i in range(len(path_conv["l2w_names"])): assert(path_conv["l2w_names"][i]) #otherwise, no name means string is in return value. needs special handling. cfile.write(" ") if path_conv["return_is_size"]: cfile.write("path_result = ") cfile.write("vrclient_unix_path_to_dos_path(path_result, %s, %s, %s);\n" % (path_conv["l2w_names"][i], path_conv["l2w_names"][i], path_conv["l2w_lens"][i])) cfile.write(" return path_result;\n") if path_conv: for i in range(len(path_conv["w2l_names"])): if path_conv["w2l_arrays"][i]: cfile.write(" vrclient_free_stringlist(lin_%s);\n" % path_conv["w2l_names"][i]) if do_lin_to_win: if next_is_size and not convert_size_param: convert_size_param = ", -1" cpp.write(" if(%s)\n" % do_lin_to_win[1]) cpp.write(" struct_%s_%s_lin_to_win(&lin, %s%s);\n" % (strip_ns(do_lin_to_win[0]), display_sdkver(sdkver), do_lin_to_win[1], convert_size_param)) if do_lin_to_win or do_win_to_lin: if not method.result_type.kind == clang.cindex.TypeKind.VOID: cpp.write(" return _ret;\n") if do_wrap and not method.result_type.kind == clang.cindex.TypeKind.VOID: cpp.write(" if(_ret == 0)\n") cpp.write(" *%s = struct_%s_%s_wrap(lin);\n" % (do_wrap[1], strip_ns(do_wrap[0]), display_sdkver(sdkver))) cpp.write(" return _ret;\n") cfile.write("}\n\n") cpp.write("}\n\n") def get_iface_version(classname): if classname in iface_versions.keys(): ver = iface_versions[classname] else: ver = "UNVERSIONED" if classname in class_versions.keys() and ver in class_versions[classname]: return (ver, True) if not classname in class_versions.keys(): class_versions[classname] = [] class_versions[classname].append(ver) return (ver, False) max_c_api_param_count = 0 def get_capi_thunk_params(method): def toBOOL(x): return "TRUE" if x else "FALSE" returns_record = method.result_type.get_canonical().kind == clang.cindex.TypeKind.RECORD param_types = [x.type for x in get_params(method)] if returns_record: param_types.insert(0, method.result_type) param_count = len(param_types) has_float_params = any(x.spelling == "float" for x in param_types) is_4th_float = param_count >= 4 and param_types[3].spelling == "float" return "%s, %s, %s" % (param_count, toBOOL(has_float_params), toBOOL(is_4th_float)) def handle_class(sdkver, classnode): print("handle_class: " + classnode.displayname) children = list(classnode.get_children()) if len(children) == 0: return (iface_version, already_generated) = get_iface_version(classnode.spelling) if already_generated: return winname = "win%s" % classnode.spelling cppname = "cpp%s_%s" % (classnode.spelling, iface_version) file_exists = os.path.isfile("vrclient_x64/%s.c" % winname) cfile = open("vrclient_x64/%s.c" % winname, "a") if not file_exists: cfile.write("""/* This file is auto-generated, do not edit. */ #include #include #include "windef.h" #include "winbase.h" #include "wine/debug.h" #include "cxx.h" #include "vrclient_defs.h" #include "vrclient_private.h" #include "struct_converters.h" #include "flatapi.h" WINE_DEFAULT_DEBUG_CHANNEL(vrclient); """) cpp = open("vrclient_x64/%s.cpp" % cppname, "w") cpp.write("#include \"vrclient_private.h\"\n") cpp.write("#include \"vrclient_defs.h\"\n") if os.path.isfile("openvr_%s/ivrclientcore.h" % sdkver): cpp.write("#include \"openvr_%s/ivrclientcore.h\"\n" % sdkver) else: cpp.write("#include \"openvr_%s/openvr.h\"\n" % sdkver) cpp.write("using namespace vr;\n") cpp.write("extern \"C\" {\n") cpp.write("#include \"struct_converters.h\"\n") cpp.write("}\n") cpp.write("#include \"%s.h\"\n" % cppname) cpp.write("#ifdef __cplusplus\nextern \"C\" {\n#endif\n") cpp_h = open("vrclient_x64/%s.h" % cppname, "w") cpp_h.write("#ifdef __cplusplus\nextern \"C\" {\n#endif\n") winclassname = "win%s_%s" % (classnode.spelling, iface_version) cfile.write("#include \"%s.h\"\n\n" % cppname) cfile.write("typedef struct __%s {\n" % winclassname) cfile.write(" vtable_ptr *vtable;\n") # make sure to keep this first (flat API depends on it) cfile.write(" void *linux_side;\n") for classname_pattern, user_data_type, _ in method_overrides_data: if classname_pattern in classnode.spelling: cfile.write(" %s user_data;\n" % user_data_type) break cfile.write("} %s;\n\n" % winclassname) methods = [] method_names = [] for child in children: if child.kind == clang.cindex.CursorKind.CXX_METHOD: handle_method(cfile, classnode.spelling, winclassname, cppname, child, cpp, cpp_h, method_names, iface_version) methods.append(child) cfile.write("extern vtable_ptr %s_vtable;\n\n" % winclassname) cfile.write("#ifndef __GNUC__\n") cfile.write("void __asm_dummy_vtables(void) {\n") cfile.write("#endif\n") cfile.write(" __ASM_VTABLE(%s,\n" % winclassname) for method in method_names: cfile.write(" VTABLE_ADD_FUNC(%s_%s)\n" % (winclassname, method)) cfile.write(" );\n") cfile.write("#ifndef __GNUC__\n") cfile.write("}\n") cfile.write("#endif\n\n") cfile.write("%s *create_%s(void *linux_side)\n{\n" % (winclassname, winclassname)) cfile.write(" %s *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(%s));\n" % (winclassname, winclassname)) cfile.write(" TRACE(\"-> %p\\n\", r);\n") cfile.write(" r->vtable = &%s_vtable;\n" % winclassname) cfile.write(" r->linux_side = linux_side;\n") cfile.write(" return r;\n}\n\n") cfile.write("void destroy_%s(void *object)\n{\n" % winclassname) cfile.write(" TRACE(\"%p\\n\", object);\n") for classname_pattern, user_data_type, user_data_destructor in method_overrides_data: if user_data_destructor and classname_pattern in classnode.spelling: cfile.write(" struct __%s *win_object = object;\n" % winclassname) cfile.write(" %s(&win_object->user_data);\n" % user_data_destructor) break cfile.write(" HeapFree(GetProcessHeap(), 0, object);\n}\n\n") # flat (FnTable) API cfile.write("%s *create_%s_FnTable(void *linux_side)\n{\n" % (winclassname, winclassname)) cfile.write(" %s *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(%s));\n" % (winclassname, winclassname)) cfile.write(" struct thunk *thunks = alloc_thunks(%d);\n" % len(methods)) cfile.write(" struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, %d * sizeof(*vtable));\n" % len(methods)) cfile.write(" int i;\n\n") cfile.write(" TRACE(\"-> %p, vtable %p, thunks %p\\n\", r, vtable, thunks);\n") for i in range(len(methods)): thunk_params = get_capi_thunk_params(methods[i]) global max_c_api_param_count max_c_api_param_count = max(len(get_params(methods[i])), max_c_api_param_count) cfile.write(" init_thunk(&thunks[%d], r, %s_%s, %s);\n" % (i, winclassname, method_names[i], thunk_params)) cfile.write(" for (i = 0; i < %d; i++)\n" % len(methods)) cfile.write(" vtable[i] = &thunks[i];\n") cfile.write(" r->linux_side = linux_side;\n") cfile.write(" r->vtable = (void *)vtable;\n") cfile.write(" return r;\n}\n\n") cfile.write("void destroy_%s_FnTable(void *object)\n{\n" % winclassname) cfile.write(" %s *win_object = object;\n" % winclassname) cfile.write(" TRACE(\"%p\\n\", win_object);\n") for classname_pattern, user_data_type, user_data_destructor in method_overrides_data: if user_data_destructor and classname_pattern in classnode.spelling: cfile.write(" %s(&win_object->user_data);\n" % user_data_destructor) break cfile.write(" VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);\n") cfile.write(" HeapFree(GetProcessHeap(), 0, win_object->vtable);\n") cfile.write(" HeapFree(GetProcessHeap(), 0, win_object);\n}\n\n") cpp.write("#ifdef __cplusplus\n}\n#endif\n") cpp_h.write("#ifdef __cplusplus\n}\n#endif\n") constructors = open("vrclient_x64/win_constructors.h", "a") constructors.write("extern void *create_%s(void *);\n" % winclassname) constructors.write("extern void *create_%s_FnTable(void *);\n" % winclassname) destructors = open("vrclient_x64/win_destructors.h", "a") destructors.write("extern void destroy_%s(void *);\n" % winclassname) destructors.write("extern void destroy_%s_FnTable(void *);\n" % winclassname) constructors = open("vrclient_x64/win_constructors_table.dat", "a") constructors.write(" {\"%s\", &create_%s, &destroy_%s},\n" % (iface_version, winclassname, winclassname)) constructors.write(" {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (iface_version, winclassname, winclassname)) if iface_version in aliases.keys(): for alias in aliases[iface_version]: constructors.write(" {\"%s\", &create_%s, &destroy_%s}, /* alias */\n" % (alias, winclassname, winclassname)) constructors.write(" {\"FnTable:%s\", &create_%s_FnTable, &destroy_%s_FnTable},\n" % (alias, winclassname, winclassname)) generate_c_api_thunk_tests(winclassname, methods, method_names) def strip_const(typename): return typename.replace("const ", "", 1) def find_windows_struct(struct): children = list(windows_build.cursor.get_children()) for child in children: if child.kind == clang.cindex.CursorKind.NAMESPACE and child.displayname == "vr": for vrchild in list(child.get_children()): if strip_const(strip_ns(struct.spelling)) == strip_ns(vrchild.type.spelling): return vrchild.type else: if strip_const(strip_ns(struct.spelling)) == strip_ns(child.type.spelling): return child.type return None def find_windows64_struct(struct): children = list(windows_build64.cursor.get_children()) for child in children: if child.kind == clang.cindex.CursorKind.NAMESPACE and child.displayname == "vr": for vrchild in list(child.get_children()): if strip_const(struct.spelling) == vrchild.type.spelling: return vrchild.type else: if strip_const(strip_ns(struct.spelling)) == strip_ns(child.type.spelling): return child.type return None def find_linux64_struct(struct): children = list(linux_build64.cursor.get_children()) for child in children: if child.kind == clang.cindex.CursorKind.NAMESPACE and child.displayname == "vr": for vrchild in list(child.get_children()): if strip_const(struct.spelling) == vrchild.type.spelling: return vrchild.type else: if strip_const(strip_ns(struct.spelling)) == strip_ns(child.type.spelling): return child.type return None def struct_needs_conversion_nocache(struct): # if strip_const(struct.spelling) in exempt_structs: # return False # if strip_const(struct.spelling) in manually_handled_structs: # return True #check 32-bit compat windows_struct = find_windows_struct(struct) assert(not windows_struct is None) #must find windows_struct for field in struct.get_fields(): if struct.get_offset(field.spelling) != windows_struct.get_offset(field.spelling): return True if field.type.get_canonical().kind == clang.cindex.TypeKind.RECORD and \ struct_needs_conversion(field.type.get_canonical()): return True #check 64-bit compat windows_struct = find_windows64_struct(struct) assert(not windows_struct is None) #must find windows_struct lin64_struct = find_linux64_struct(struct) assert(not lin64_struct is None) #must find lin64_struct for field in lin64_struct.get_fields(): if lin64_struct.get_offset(field.spelling) != windows_struct.get_offset(field.spelling): return True if field.type.get_canonical().kind == clang.cindex.TypeKind.RECORD and \ struct_needs_conversion(field.type.get_canonical()): return True return False def struct_needs_conversion(struct): if not sdkver in struct_conversion_cache: struct_conversion_cache[sdkver] = {} if not strip_const(struct.spelling) in struct_conversion_cache[sdkver]: struct_conversion_cache[sdkver][strip_const(struct.spelling)] = struct_needs_conversion_nocache(struct) return struct_conversion_cache[sdkver][strip_const(struct.spelling)] def get_field_attribute_str(field): ftype = field.type.get_canonical() if ftype.kind != clang.cindex.TypeKind.RECORD: return "" win_struct = find_windows_struct(ftype) align = win_struct.get_align() return " __attribute__((aligned(" + str(align) + ")))" generated_struct_handlers = [] cpp_files_need_close_brace = [] LIN_TO_WIN=1 WIN_TO_LIN=2 WRAPPERS=3 #because of struct packing differences between win32 and linux, we #need to convert these structs from their linux layout to the win32 #layout. def handle_struct(sdkver, struct): handler_name = "%s_%s" % (struct.displayname, display_sdkver(sdkver)) if handler_name in generated_struct_handlers: # we already have a handler for the struct struct of this size return which = set() if struct_needs_conversion(struct.type.get_canonical()): which.add(LIN_TO_WIN) which.add(WIN_TO_LIN) if strip_ns(struct.displayname) in system_structs: which.add(WRAPPERS) if len(which) == 0: return filename_base = "struct_converters_%s" % display_sdkver(sdkver) cppname = "vrclient_x64/%s.cpp" % filename_base file_exists = os.path.isfile(cppname) cppfile = open(cppname, "a") if not file_exists: cppfile.write("#include \n"); cppfile.write("#include \n"); cppfile.write("#include \"vrclient_private.h\"\n") cppfile.write("#include \"vrclient_defs.h\"\n") cppfile.write("#include \"openvr_%s/openvr.h\"\n" % sdkver) cppfile.write("using namespace vr;\n") cppfile.write("extern \"C\" {\n") cppfile.write("#include \"struct_converters.h\"\n") cpp_files_need_close_brace.append(cppname) hfile = open("vrclient_x64/struct_converters.h", "a") hfile.write("typedef struct win%s win%s;\n" % (handler_name, handler_name)) cppfile.write("#pragma pack(push, 8)\n") cppfile.write("struct win%s {\n" % handler_name) for m in struct.get_children(): if m.kind == clang.cindex.CursorKind.FIELD_DECL: if m.type.get_canonical().kind == clang.cindex.TypeKind.CONSTANTARRAY: cppfile.write(" %s %s[%u]" % (m.type.element_type.spelling, m.displayname, m.type.element_count)) elif m.type.get_canonical().kind == clang.cindex.TypeKind.RECORD and \ struct_needs_conversion(m.type.get_canonical()): cppfile.write(" win%s_%s %s" % (strip_ns(m.type.spelling), display_sdkver(sdkver), m.displayname)) else: if m.type.get_canonical().kind == clang.cindex.TypeKind.POINTER and \ m.type.get_pointee().kind == clang.cindex.TypeKind.FUNCTIONPROTO: cppfile.write(" void *%s /*fn pointer*/ " % m.displayname) else: cppfile.write(" %s %s" % (m.type.spelling, m.displayname)) cppfile.write(get_field_attribute_str(m) + ";\n") if WRAPPERS in which: cppfile.write("\n %s *linux_side;\n" % struct.displayname) cppfile.write("} __attribute__ ((ms_struct));\n") cppfile.write("#pragma pack(pop)\n\n") def dump_converter(src, dst, size): for m in struct.get_children(): if m.kind == clang.cindex.CursorKind.FIELD_DECL: if m.type.get_canonical().kind == clang.cindex.TypeKind.CONSTANTARRAY: #TODO: if this is a struct, or packed differently, we'll have to # copy each element in a for-loop cppfile.write(" memcpy(" + dst + "->" + m.displayname + ", " + src + "->" + m.displayname + ", sizeof(" + dst + "->" + m.displayname + "));\n") elif m.type.get_canonical().kind == clang.cindex.TypeKind.RECORD and \ struct_needs_conversion(m.type.get_canonical()): cppfile.write(" struct_" + strip_ns(m.type.spelling) + "_" + display_sdkver(sdkver) + "_" + src + "_to_" + dst + \ "(&" + src + "->" + m.displayname + ", &" + dst + "->" + m.displayname + ");\n") elif struct.displayname in struct_size_fields and \ m.displayname in struct_size_fields[struct.displayname]: cppfile.write(" " + dst + "->" + m.displayname + " = sizeof(*" + dst + ");\n") elif size and strip_ns(m.type.get_canonical().spelling) == "VREvent_Data_t": #truncate variable-length data struct at the end of the parent struct #XXX: dumb hard-coding. are the other types with lengths variable length? cppfile.write(" memcpy(&" + dst + "->data, &" + src + "->data, " + size + " - (((char*)&" + dst + "->data) - ((char*)" + dst + ")));\n") else: cppfile.write(" " + dst + "->" + m.displayname + " = " + src + "->" + m.displayname + ";\n") if strip_ns(struct.displayname) in next_is_size_structs: size_arg = "sz" size_arg_type = ", uint32_t sz" else: size_arg = None size_arg_type = "" if LIN_TO_WIN in which: hfile.write("extern void struct_%s_lin_to_win(void *l, void *w%s);\n" % (handler_name, size_arg_type)) cppfile.write("void struct_%s_lin_to_win(void *l, void *w%s)\n{\n" % (handler_name, size_arg_type)) cppfile.write(" struct win%s *win = (struct win%s *)w;\n" % (handler_name, handler_name)) cppfile.write(" %s *lin = (%s *)l;\n" % (struct.displayname, struct.displayname)) dump_converter("lin", "win", size_arg) cppfile.write("}\n\n") if WIN_TO_LIN in which: #XXX: should pass size param here, too hfile.write("extern void struct_%s_win_to_lin(void *w, void *l);\n" % handler_name) cppfile.write("void struct_%s_win_to_lin(void *w, void *l)\n{\n" % handler_name) cppfile.write(" struct win%s *win = (struct win%s *)w;\n" % (handler_name, handler_name)) cppfile.write(" %s *lin = (%s *)l;\n" % (struct.displayname, struct.displayname)) dump_converter("win", "lin", None) cppfile.write("}\n\n") if WRAPPERS in which: hfile.write("extern struct win%s *struct_%s_wrap(void *l);\n" % (handler_name, handler_name)) cppfile.write("struct win%s *struct_%s_wrap(void *l)\n{\n" % (handler_name, handler_name)) cppfile.write(" struct win%s *win = (struct win%s *)malloc(sizeof(*win));\n" % (handler_name, handler_name)) cppfile.write(" %s *lin = (%s *)l;\n" % (struct.displayname, struct.displayname)) dump_converter("lin", "win", None) cppfile.write(" win->linux_side = lin;\n"); cppfile.write(" return win;\n") cppfile.write("}\n\n") hfile.write("extern %s *struct_%s_unwrap(win%s *w);\n" % (struct.displayname, handler_name, handler_name)) cppfile.write("struct %s *struct_%s_unwrap(win%s *w)\n{\n" % (struct.displayname, handler_name, handler_name)) cppfile.write(" %s *ret = w->linux_side;\n" % struct.displayname) cppfile.write(" free(w);\n") cppfile.write(" return ret;\n") cppfile.write("}\n\n") generated_struct_handlers.append(handler_name) def generate_x64_call_flat_method(cfile, param_count, has_floats, is_4th_float): assert param_count >= 4 if is_4th_float: assert has_floats def l(line): cfile.write(line + '\n') stack_space = 0x20 # shadow register space stack_space += 0x8 * (param_count - 3) stack_space |= 0x8 src_offset = 0x20 + 0x8 + stack_space # shadow register space + ret dst_offset = 0x20 name = "call_flat_method%s%s%s" % (param_count, "_f" if has_floats else "", "_f" if is_4th_float else "") l(r"__ASM_GLOBAL_FUNC(%s," % name) l(r' "subq $0x%x, %%rsp\n\t"' % stack_space); l(r' __ASM_CFI(".cfi_adjust_cfa_offset %d\n\t")' % stack_space) if is_4th_float: l(r' "movq %%xmm3, 0x%x(%%rsp)\n\t"' % dst_offset) else: l(r' "movq %%r9, 0x%x(%%rsp)\n\t"' % dst_offset) dst_offset += 8 for i in range(5, param_count + 1): l(r' "movq 0x%x(%%rsp), %%rax\n\t" // copy parameter' % src_offset) l(r' "movq %%rax, 0x%x(%%rsp)\n\t"' % dst_offset) src_offset += 8 dst_offset += 8 l(r' "movq %r8, %r9\n\t" // shift over arguments') l(r' "movq %rdx, %r8\n\t"') l(r' "movq %rcx, %rdx\n\t"') l(r' "movq %r10, %rcx\n\t" // add This pointer') if has_floats: l(r' "movaps %xmm2, %xmm3\n\t"') l(r' "movaps %xmm1, %xmm2\n\t"') l(r' "movaps %xmm0, %xmm1\n\t"') l(r' "call *%r11\n\t"') l(r' "addq $0x%x, %%rsp\n\t"' % stack_space); l(r' __ASM_CFI(".cfi_adjust_cfa_offset -%d\n\t")' % stack_space) l(r' "ret");') l(r'extern void %s(void);' % name); def generate_flatapi_c(): with open("vrclient_x64/flatapi.c", "w") as f: f.write(r"""/* This file is auto-generated, do not edit. */ #include #include "windef.h" #include "winbase.h" #include "cxx.h" #include "flatapi.h" #ifdef __i386__ __ASM_GLOBAL_FUNC(call_flat_method, "popl %eax\n\t" "pushl %ecx\n\t" "pushl %eax\n\t" "jmp *%edx"); #else // handles "this" and up to 3 parameters __ASM_GLOBAL_FUNC(call_flat_method, "movq %r8, %r9\n\t" // shift over arguments "movq %rdx, %r8\n\t" "movq %rcx, %rdx\n\t" "movq %r10, %rcx\n\t" // add This pointer "jmp *%r11"); extern void call_flat_method(void); __ASM_GLOBAL_FUNC(call_flat_method_f, "movq %r8, %r9\n\t" // shift over arguments "movq %rdx, %r8\n\t" "movq %rcx, %rdx\n\t" "movq %r10, %rcx\n\t" // add This pointer "movaps %xmm2, %xmm3\n\t" "movaps %xmm1, %xmm2\n\t" "movaps %xmm0, %xmm1\n\t" "jmp *%r11"); extern void call_flat_method_f(void); """) for i in range(4, max_c_api_param_count + 1): f.write("\n") generate_x64_call_flat_method(f, i, False, False) for i in range(4, max_c_api_param_count + 1): f.write("\n") generate_x64_call_flat_method(f, i, True, False) f.write("\n") generate_x64_call_flat_method(f, i, True, True) f.write('\npfn_call_flat_method\n') f.write('get_call_flat_method_pfn( int param_count, BOOL has_floats, BOOL is_4th_float )\n{\n') f.write(' if (!has_floats)\n') f.write(' {\n') f.write(' if (param_count <= 3) return call_flat_method;\n') for i in range(4, max_c_api_param_count): f.write(' if (param_count == %s) return call_flat_method%s;\n' % (i, i)) f.write(' return call_flat_method%s;\n' % max_c_api_param_count) f.write(' }\n') f.write(' if (is_4th_float)\n') f.write(' {\n') f.write(' if (param_count <= 3) return call_flat_method_f;\n') for i in range(4, max_c_api_param_count): f.write(' if (param_count == %s) return call_flat_method%s_f_f;\n' % (i, i)) f.write(' return call_flat_method%s_f_f;\n' % max_c_api_param_count) f.write(' }\n') f.write(' if (param_count <= 3) return call_flat_method_f;\n') for i in range(4, max_c_api_param_count): f.write(' if (param_count == %s) return call_flat_method%s_f;\n' % (i, i)) f.write(' return call_flat_method%s_f;\n' % max_c_api_param_count) f.write('}\n') f.write("#endif\n") def generate_c_api_method_test(f, header, thunks_c, class_name, method_name, method): thunk_params = get_capi_thunk_params(method) f.write("\n init_thunk(t, this_ptr_value, %s_%s, %s);\n" % (class_name, method_name, thunk_params)) f.write(" ") header.write("\n") thunks_c.write("\n") returns_record = method.result_type.get_canonical().kind == clang.cindex.TypeKind.RECORD if returns_record: f.write("%s *" % strip_ns(method.result_type.spelling)) header.write("%s *" % strip_ns(method.result_type.spelling)) thunks_c.write("%s *" % strip_ns(method.result_type.spelling)) else: f.write("%s " % strip_ns(method.result_type.spelling)) header.write("%s " % strip_ns(method.result_type.spelling)) thunks_c.write("%s " % strip_ns(method.result_type.spelling)) first_param = True f.write('(__stdcall *capi_%s_%s)(' % (class_name, method_name)) header.write('__thiscall %s_%s(void *_this' % (class_name, method_name)) thunks_c.write('__thiscall %s_%s(void *_this' % (class_name, method_name)) if returns_record: f.write("%s *_r" % strip_ns(method.result_type.spelling)) first_param = False header.write(", %s *_r" % strip_ns(method.result_type.spelling)) thunks_c.write(", %s *_r" % strip_ns(method.result_type.spelling)) for param in get_params(method): if param.type.kind == clang.cindex.TypeKind.POINTER \ and param.type.get_pointee().kind == clang.cindex.TypeKind.UNEXPOSED: typename = "void *" else: typename = param.type.spelling.split("::")[-1].replace("&", "*"); if not first_param: f.write(", ") first_param = False f.write("%s %s" % (typename, param.spelling)) header.write(", %s %s" % (typename, param.spelling)) thunks_c.write(", %s %s" % (typename, param.spelling)) f.write(") = (void *)t;\n") header.write(");\n") thunks_c.write(")\n{\n") def get_param_typename(param): param_size = param.type.get_size() if param.type.kind == clang.cindex.TypeKind.POINTER \ or param.type.spelling.endswith("&") \ or param.type.spelling == "vr::glSharedTextureHandle_t": return "ptr" elif param.type.spelling == "bool": return "bool" elif param.type.spelling == "float": return "float" elif param.type.spelling == "vr::HmdRect2_t": return "HmdRect2" elif param.type.spelling == "vr::HmdVector2_t": return "HmdVector2" elif param.type.spelling == "vr::HmdVector3_t": return "HmdVector3" elif param.type.spelling == "vr::HmdColor_t": return "HmdColor" elif param_size == 8: return "uint64" elif param_size == 4 or param_size == 2: return "uint32" else: return "unknown" thunks_c.write(" push_ptr_parameter(_this);\n") if returns_record: thunks_c.write(" push_ptr_parameter(_r);\n") for param in get_params(method): typename = get_param_typename(param) thunks_c.write(" push_%s_parameter(%s);\n" % (typename, param.spelling)) if method.result_type.kind != clang.cindex.TypeKind.VOID: thunks_c.write(" return 0;\n") thunks_c.write("}\n") parameter_checks = [] def add_parameter_check(typename, value): parameter_checks.append("check_%s_parameter(\"%s_%s\", %s)" % (typename, class_name, method_name, value)) add_parameter_check("ptr", "this_ptr_value") f.write("\n") f.write(" clear_parameters();\n") f.write(" capi_%s_%s(" % (class_name, method_name)) first_param = True if returns_record: f.write("data_ptr_value") first_param = False add_parameter_check("ptr", "data_ptr_value") for i, param in enumerate(get_params(method)): i += 1 typename = get_param_typename(param) if typename == "ptr": v = "(void *)%s" % i elif typename == "bool": v = "1" elif typename == "float": v = "%s.0f" % i elif typename == "HmdRect2": v = "DEFAULT_RECT" elif typename == "HmdVector2": v = "DEFAULT_VECTOR2" elif typename == "HmdVector3": v = "DEFAULT_VECTOR3" elif typename == "HmdColor": v = "DEFAULT_COLOR" else: v = str(i) if not first_param: f.write(", ") first_param = False f.write(v) add_parameter_check(typename, v) f.write(");\n") for c in parameter_checks: f.write(" %s;\n" % c) def generate_c_api_thunk_tests(winclassname, methods, method_names): class_name = re.sub(r'^win[A-Za-z]+_', '', winclassname) filename = "tests/capi_thunks_autogen.h" file_exists = os.path.isfile(filename) header = open(filename, "a") if not file_exists: header.write("""/* This file is auto-generated, do not edit. */ #include #include #include "windef.h" #include "winbase.h" #include "cxx.h" #include "flatapi.h" #include "vrclient_defs.h" #include "capi_thunks.h" """) header.write("\nvoid test_capi_thunks_%s(void);\n" % class_name) filename = "tests/capi_thunks_autogen.c" file_exists = os.path.isfile(filename) thunks_c = open(filename, "a") if not file_exists: thunks_c.write("""/* This file is auto-generated, do not edit. */ #include "capi_thunks_autogen.h" """) filename = "tests/capi_thunks_tests_autogen.c" file_exists = os.path.isfile(filename) with open(filename, "a") as f: if not file_exists: f.write("""/* This file is auto-generated, do not edit. */ #include "capi_thunks_autogen.h" """) f.write("\nvoid test_capi_thunks_%s(void)\n{\n" % class_name) f.write(" struct thunk *t = alloc_thunks(1);\n"); for i in range(len(methods)): generate_c_api_method_test(f, header, thunks_c, class_name, method_names[i], methods[i]) f.write(" VirtualFree(t, 0, MEM_RELEASE);\n") f.write("}\n") filename = "tests/main_autogen.c" file_exists = os.path.isfile(filename) with open(filename, "a") as f: if not file_exists: f.write("""/* This file is auto-generated, do not edit. */ #include "capi_thunks_autogen.h" #include int main(void) { """) f.write(" test_capi_thunks_%s();\n" % class_name) #clang.cindex.Config.set_library_file("/usr/lib/llvm-3.8/lib/libclang-3.8.so.1"); prog = re.compile("^.*const\s*char.* \*?(\w*)_Version.*\"(.*)\"") for sdkver in sdk_versions: iface_versions = {} print("sdkver is: " + sdkver) for f in os.listdir("openvr_%s" % sdkver): x = open("openvr_%s/%s" % (sdkver, f), "r") for l in x: if "_Version" in l: result = prog.match(l) if result: iface, version = result.group(1, 2) iface_versions[iface] = version for fname, classes, system_structs in files: # Parse as 32-bit C++ input_name = "openvr_%s/%s" % (sdkver, fname) sys.stdout.write("about to parse %s\n" % input_name) if not os.path.isfile(input_name): continue index = clang.cindex.Index.create() windows_build = index.parse(input_name, args=['-x', 'c++', '-m32', '-Iopenvr_%s/' % sdkver, '-I' + CLANG_PATH + '/include/', '-mms-bitfields', '-U__linux__', '-Wno-incompatible-ms-struct']) windows_build64 = index.parse(input_name, args=['-x', 'c++', '-m64', '-Iopenvr_%s/' % sdkver, '-I' + CLANG_PATH + '/include/', '-mms-bitfields', '-U__linux__', '-Wno-incompatible-ms-struct']) tu = index.parse(input_name, args=['-x', 'c++', '-m32', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I' + CLANG_PATH + '/include/']) linux_build64 = index.parse(input_name, args=['-x', 'c++', '-m64', '-std=c++11', '-DGNUC', '-Iopenvr_%s/' % sdkver, '-I' + CLANG_PATH + '/include/']) diagnostics = list(tu.diagnostics) if len(diagnostics) > 0: print('There were parse errors') pprint.pprint(diagnostics) else: children = list(tu.cursor.get_children()) for child in children: if child.kind == clang.cindex.CursorKind.NAMESPACE and child.displayname == "vr": for vrchild in list(child.get_children()): if vrchild.kind == clang.cindex.CursorKind.CLASS_DECL and vrchild.displayname in classes: handle_class(sdkver, vrchild) if vrchild.kind == clang.cindex.CursorKind.STRUCT_DECL or \ vrchild.kind == clang.cindex.CursorKind.CLASS_DECL: handle_struct(sdkver, vrchild) if vrchild.displayname in print_sizes: sys.stdout.write("size of %s is %u\n" % (vrchild.displayname, vrchild.type.get_size())) for f in cpp_files_need_close_brace: m = open(f, "a") m.write("\n}\n") with open("tests/main_autogen.c", "a") as f: f.write(" printf(\"All tests executed.\\n\");\n") f.write("}\n") generate_flatapi_c()