5 # Copyright (c) 2015-2016 The Khronos Group Inc.
6 # Copyright (c) 2015-2016 Valve Corporation
7 # Copyright (c) 2015-2016 LunarG, Inc.
8 # Copyright (c) 2015-2016 Google Inc.
10 # Licensed under the Apache License, Version 2.0 (the "License");
11 # you may not use this file except in compliance with the License.
12 # You may obtain a copy of the License at
14 # http://www.apache.org/licenses/LICENSE-2.0
16 # Unless required by applicable law or agreed to in writing, software
17 # distributed under the License is distributed on an "AS IS" BASIS,
18 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 # See the License for the specific language governing permissions and
20 # limitations under the License.
22 # Author: Tobin Ehlis <tobine@google.com>
23 # Author: Courtney Goeltzenleuchter <courtneygo@google.com>
24 # Author: Jon Ashburn <jon@lunarg.com>
25 # Author: Mark Lobodzinski <mark@lunarg.com>
26 # Author: Mike Stroyan <stroyan@google.com>
27 # Author: Tony Barbour <tony@LunarG.com>
28 # Author: Chia-I Wu <olv@google.com>
29 # Author: Gwan-gyeong Mun <kk.moon@samsung.com>
37 from source_line_info import sourcelineinfo
38 from collections import defaultdict
40 def proto_is_global(proto):
41 global_function_names = [
43 "EnumerateInstanceLayerProperties",
44 "EnumerateInstanceExtensionProperties",
45 "EnumerateDeviceLayerProperties",
46 "EnumerateDeviceExtensionProperties",
47 "CreateXcbSurfaceKHR",
48 "GetPhysicalDeviceXcbPresentationSupportKHR",
49 "CreateXlibSurfaceKHR",
50 "GetPhysicalDeviceXlibPresentationSupportKHR",
51 "CreateWaylandSurfaceKHR",
52 "GetPhysicalDeviceWaylandPresentationSupportKHR",
53 "CreateMirSurfaceKHR",
54 "GetPhysicalDeviceMirPresentationSupportKHR",
55 "CreateAndroidSurfaceKHR",
56 "CreateWin32SurfaceKHR",
57 "GetPhysicalDeviceWin32PresentationSupportKHR",
58 "GetPhysicalDeviceDisplayPropertiesKHR",
59 "GetPhysicalDeviceDisplayPlanePropertiesKHR",
60 "GetDisplayPlaneSupportedDisplaysKHR",
61 "GetDisplayModePropertiesKHR",
62 "CreateDisplayModeKHR",
63 "GetDisplayPlaneCapabilitiesKHR",
64 "CreateDisplayPlaneSurfaceKHR"
66 if proto.params[0].ty == "VkInstance" or proto.params[0].ty == "VkPhysicalDevice" or proto.name in global_function_names:
71 def wsi_name(ext_name):
75 elif 'Xlib' in ext_name:
77 elif 'Win32' in ext_name:
79 elif 'Mir' in ext_name:
81 elif 'Wayland' in ext_name:
82 wsi_prefix = 'WAYLAND'
83 elif 'Android' in ext_name:
84 wsi_prefix = 'ANDROID'
89 def wsi_ifdef(ext_name):
90 wsi_prefix = wsi_name(ext_name)
94 return "#ifdef VK_USE_PLATFORM_%s_KHR" % wsi_prefix
96 def wsi_endif(ext_name):
97 wsi_prefix = wsi_name(ext_name)
101 return "#endif // VK_USE_PLATFORM_%s_KHR" % wsi_prefix
103 def generate_get_proc_addr_check(name):
104 return " if (!%s || %s[0] != 'v' || %s[1] != 'k')\n" \
105 " return NULL;" % ((name,) * 3)
107 def ucc_to_U_C_C(CamelCase):
108 temp = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', CamelCase)
109 return re.sub('([a-z0-9])([A-Z])', r'\1_\2', temp).upper()
111 # Parse complete struct chain and add any new ndo_uses to the dict
112 def gather_object_uses_in_struct(obj_list, struct_type):
114 if vk_helper.typedef_rev_dict[struct_type] in vk_helper.struct_dict:
115 struct_type = vk_helper.typedef_rev_dict[struct_type]
116 # Parse elements of this struct param to identify objects and/or arrays of objects
117 for m in sorted(vk_helper.struct_dict[struct_type]):
118 array_len = "%s" % (str(vk_helper.struct_dict[struct_type][m]['array_size']))
119 base_type = vk_helper.struct_dict[struct_type][m]['type']
120 mem_name = vk_helper.struct_dict[struct_type][m]['name']
122 mem_name = "%s[%s]" % (mem_name, array_len)
123 if base_type in obj_list:
124 #if array_len not in ndo_uses:
125 # struct_uses[array_len] = []
126 #struct_uses[array_len].append("%s%s,%s" % (name_prefix, struct_name, base_type))
127 struct_uses[mem_name] = base_type
128 elif vk_helper.is_type(base_type, 'struct'):
129 sub_uses = gather_object_uses_in_struct(obj_list, base_type)
130 if len(sub_uses) > 0:
131 struct_uses[mem_name] = sub_uses
134 # For the given list of object types, Parse the given list of params
135 # and return dict of params that use one of the obj_list types
136 # Format of the dict is that terminal elements have <name>,<type>
137 # non-terminal elements will have <name>[<array_size>]
138 # TODO : This analysis could be done up-front at vk_helper time
139 def get_object_uses(obj_list, params):
142 param_count = 'NONE' # track params that give array sizes
144 base_type = p.ty.replace('const ', '').strip('*')
147 if 'count' in p.name.lower():
153 if base_type in obj_list:
154 if is_ptr and 'const' in p.ty and param_count != 'NONE':
155 array_len = "[%s]" % param_count
156 # Non-arrays we can overwrite in place, but need local decl for arrays
157 local_decls[p.name] = '%s%s' % (base_type, ptr_txt)
158 #if array_len not in obj_uses:
159 # obj_uses[array_len] = {}
160 # obj_uses[array_len][p.name] = base_type
161 obj_uses["%s%s" % (p.name, array_len)] = base_type
162 elif vk_helper.is_type(base_type, 'struct'):
164 if 'NONE' != param_count:
165 struct_name = "%s[%s]" % (struct_name, param_count)
166 struct_uses = gather_object_uses_in_struct(obj_list, base_type)
167 if len(struct_uses) > 0:
168 obj_uses[struct_name] = struct_uses
169 # This is a top-level struct w/ uses below it, so need local decl
170 local_decls['%s' % (p.name)] = '%s%s' % (base_type, ptr_txt)
171 return (obj_uses, local_decls)
173 class Subcommand(object):
174 def __init__(self, outfile):
175 self.outfile = outfile
176 self.headers = vulkan.headers
177 self.protos = vulkan.protos
180 self.lineinfo = sourcelineinfo()
181 self.wsi = sys.argv[1]
185 with open(self.outfile, "w") as outfile:
186 outfile.write(self.generate())
188 print(self.generate())
191 copyright = self.generate_copyright()
192 header = self.generate_header()
193 body = self.generate_body()
194 footer = self.generate_footer()
198 contents.append(copyright)
200 contents.append(header)
202 contents.append(body)
204 contents.append(footer)
206 return "\n\n".join(contents)
208 def generate_copyright(self):
209 return """/* THIS FILE IS GENERATED. DO NOT EDIT. */
212 * Copyright (c) 2015-2016 The Khronos Group Inc.
213 * Copyright (c) 2015-2016 Valve Corporation
214 * Copyright (c) 2015-2016 LunarG, Inc.
215 * Copyright (c) 2015-2016 Google, Inc.
217 * Licensed under the Apache License, Version 2.0 (the "License");
218 * you may not use this file except in compliance with the License.
219 * You may obtain a copy of the License at
221 * http://www.apache.org/licenses/LICENSE-2.0
223 * Unless required by applicable law or agreed to in writing, software
224 * distributed under the License is distributed on an "AS IS" BASIS,
225 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
226 * See the License for the specific language governing permissions and
227 * limitations under the License.
229 * Author: Tobin Ehlis <tobine@google.com>
230 * Author: Courtney Goeltzenleuchter <courtneygo@google.com>
231 * Author: Jon Ashburn <jon@lunarg.com>
232 * Author: Mark Lobodzinski <mark@lunarg.com>
233 * Author: Mike Stroyan <stroyan@google.com>
234 * Author: Tony Barbour <tony@LunarG.com>
237 def generate_header(self):
238 return "\n".join(["#include <" + h + ">" for h in self.headers])
240 def generate_body(self):
243 def generate_footer(self):
246 # Return set of printf '%' qualifier and input to that qualifier
247 def _get_printf_params(self, vk_type, name, output_param, cpp=False):
248 # TODO : Need ENUM and STRUCT checks here
249 if vk_helper.is_type(vk_type, 'enum'):#"_TYPE" in vk_type: # TODO : This should be generic ENUM check
250 return ("%s", "string_%s(%s)" % (vk_type.replace('const ', '').strip('*'), name))
251 if "char*" == vk_type:
253 if "uint64" in vk_type:
255 return ("%lu", "*%s" % name)
257 if vk_type.strip('*') in vulkan.object_non_dispatch_list:
259 return ("%lu", "%s" % name)
260 return ("%lu", "%s" % name)
261 if "size" in vk_type:
263 return ("%lu", "(unsigned long)*%s" % name)
264 return ("%lu", "(unsigned long)%s" % name)
265 if "float" in vk_type:
266 if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
268 return ("[%i, %i, %i, %i]", '"[" << %s[0] << "," << %s[1] << "," << %s[2] << "," << %s[3] << "]"' % (name, name, name, name))
269 return ("[%f, %f, %f, %f]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
271 if "bool" in vk_type.lower() or 'xcb_randr_crtc_t' in vk_type:
273 if True in [t in vk_type.lower() for t in ["int", "flags", "mask", "xcb_window_t"]]:
274 if '[' in vk_type: # handle array, current hard-coded to 4 (TODO: Make this dynamic)
276 return ("[%i, %i, %i, %i]", "%s[0] << %s[1] << %s[2] << %s[3]" % (name, name, name, name))
277 return ("[%i, %i, %i, %i]", "%s[0], %s[1], %s[2], %s[3]" % (name, name, name, name))
279 if 'pUserData' == name:
280 return ("%i", "((pUserData == 0) ? 0 : *(pUserData))")
281 if 'const' in vk_type.lower():
282 return ("0x%p", "(void*)(%s)" % name)
283 return ("%i", "*(%s)" % name)
285 # TODO : This is special-cased as there's only one "format" param currently and it's nice to expand it
286 if "VkFormat" == vk_type:
288 return ("0x%p", "&%s" % name)
289 return ("{%s.channelFormat = %%s, %s.numericFormat = %%s}" % (name, name), "string_VK_COLOR_COMPONENT_FORMAT(%s.channelFormat), string_VK_FORMAT_RANGE_SIZE(%s.numericFormat)" % (name, name))
291 return ("0x%p", "(void*)*%s" % name)
292 if vk_helper.is_type(vk_type, 'struct') and '*' not in vk_type:
293 return ("0x%p", "(void*)(&%s)" % name)
294 return ("0x%p", "(void*)(%s)" % name)
296 def _gen_create_msg_callback(self):
298 r_body.append('%s' % self.lineinfo.get())
299 r_body.append('VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(')
300 r_body.append(' VkInstance instance,')
301 r_body.append(' const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,')
302 r_body.append(' const VkAllocationCallbacks* pAllocator,')
303 r_body.append(' VkDebugReportCallbackEXT* pCallback)')
305 # Switch to this code section for the new per-instance storage and debug callbacks
306 if self.layer_name in ['unique_objects']:
307 r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
308 r_body.append(' VkResult result = pInstanceTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);')
309 r_body.append(' if (VK_SUCCESS == result) {')
310 r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
311 r_body.append(' result = layer_create_msg_callback(my_data->report_data,')
312 r_body.append(' false,')
313 r_body.append(' pCreateInfo,')
314 r_body.append(' pAllocator,')
315 r_body.append(' pCallback);')
317 r_body.append(' return result;')
319 r_body.append(' VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);')
320 r_body.append(' if (VK_SUCCESS == result) {')
321 r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
322 r_body.append(' result = layer_create_msg_callback(my_data->report_data, false, pCreateInfo, pAllocator, pCallback);')
324 r_body.append(' return result;')
326 return "\n".join(r_body)
328 def _gen_destroy_msg_callback(self):
330 r_body.append('%s' % self.lineinfo.get())
331 r_body.append('VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback, const VkAllocationCallbacks *pAllocator)')
333 # Switch to this code section for the new per-instance storage and debug callbacks
334 if self.layer_name in ['unique_objects']:
335 r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
337 r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = instance_dispatch_table(instance);')
338 r_body.append(' pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);')
339 r_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
340 r_body.append(' layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);')
342 return "\n".join(r_body)
344 def _gen_debug_report_msg(self):
346 r_body.append('%s' % self.lineinfo.get())
347 r_body.append('VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg)')
349 # Switch to this code section for the new per-instance storage and debug callbacks
350 r_body.append(' VkLayerInstanceDispatchTable *pInstanceTable = instance_dispatch_table(instance);')
351 r_body.append(' pInstanceTable->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);')
353 return "\n".join(r_body)
355 def _gen_layer_logging_workaround(self):
357 body.append('%s' % self.lineinfo.get())
358 body.append('// vk_layer_logging.h expects these to be defined')
360 body.append('VKAPI_ATTR VkResult VKAPI_CALL')
361 body.append('vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,')
362 body.append(' const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pMsgCallback) {')
363 body.append(' return %s::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);' % self.layer_name)
366 body.append('VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance,')
367 body.append(' VkDebugReportCallbackEXT msgCallback,')
368 body.append(' const VkAllocationCallbacks *pAllocator) {')
369 body.append(' %s::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);' % self.layer_name)
372 body.append('VKAPI_ATTR void VKAPI_CALL')
373 body.append('vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objType, uint64_t object,')
374 body.append(' size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {')
375 body.append(' %s::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);' % self.layer_name)
378 return "\n".join(body)
380 def _gen_layer_interface_v0_functions(self):
382 body.append('%s' % self.lineinfo.get())
383 body.append('// loader-layer interface v0, just wrappers since there is only a layer')
386 body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties* pProperties)')
388 body.append(' return %s::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);' % self.layer_name)
391 body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties* pProperties)')
393 body.append(' return %s::EnumerateInstanceLayerProperties(pCount, pProperties);' % self.layer_name)
396 body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties* pProperties)')
398 body.append(' // the layer command handles VK_NULL_HANDLE just fine internally')
399 body.append(' assert(physicalDevice == VK_NULL_HANDLE);')
400 body.append(' return %s::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);' % self.layer_name)
403 body.append('VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName)')
405 body.append(' return %s::GetDeviceProcAddr(dev, funcName);' % self.layer_name)
408 body.append('VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName)')
410 body.append(' return %s::GetInstanceProcAddr(instance, funcName);' % self.layer_name)
413 body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,')
414 body.append(' const char *pLayerName, uint32_t *pCount,')
415 body.append(' VkExtensionProperties *pProperties)')
417 body.append(' // the layer command handles VK_NULL_HANDLE just fine internally')
418 body.append(' assert(physicalDevice == VK_NULL_HANDLE);')
419 body.append(' return %s::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);' % self.layer_name)
422 return "\n".join(body)
424 def _generate_dispatch_entrypoints(self, qual=""):
430 for proto in self.protos:
431 if proto.name in ["EnumerateInstanceExtensionProperties",
432 "EnumerateInstanceLayerProperties",
433 "EnumerateDeviceLayerProperties",
435 "GetInstanceProcAddr"]:
436 funcs.append(proto.c_func(attr="VKAPI") + ';')
437 intercepted.append(proto)
439 intercept = self.generate_intercept(proto, qual)
440 if intercept is None:
441 # fill in default intercept for certain entrypoints
442 if 'CreateDebugReportCallbackEXT' == proto.name:
443 intercept = self._gen_layer_dbg_create_msg_callback()
444 elif 'DestroyDebugReportCallbackEXT' == proto.name:
445 intercept = self._gen_layer_dbg_destroy_msg_callback()
446 elif 'DebugReportMessageEXT' == proto.name:
447 intercept = self._gen_debug_report_msg()
448 elif 'CreateDevice' == proto.name:
449 funcs.append('/* CreateDevice HERE */')
451 if intercept is not None:
452 funcs.append(intercept)
453 if not "KHR" in proto.name:
454 intercepted.append(proto)
456 instance_lookups = []
458 for proto in intercepted:
459 if proto_is_global(proto):
460 instance_lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
461 instance_lookups.append(" return (PFN_vkVoidFunction) %s;" % (proto.name))
463 device_lookups.append("if (!strcmp(name, \"%s\"))" % proto.name)
464 device_lookups.append(" return (PFN_vkVoidFunction) %s;" % (proto.name))
466 # add customized intercept_core_device_command
468 body.append('%s' % self.lineinfo.get())
469 body.append("static inline PFN_vkVoidFunction intercept_core_device_command(const char *name)")
471 body.append(generate_get_proc_addr_check("name"))
473 body.append(" name += 2;")
474 body.append(" %s" % "\n ".join(device_lookups))
476 body.append(" return NULL;")
478 # add intercept_core_instance_command
479 body.append("static inline PFN_vkVoidFunction intercept_core_instance_command(const char *name)")
481 body.append(generate_get_proc_addr_check("name"))
483 body.append(" name += 2;")
484 body.append(" %s" % "\n ".join(instance_lookups))
486 body.append(" return NULL;")
489 funcs.append("\n".join(body))
490 return "\n\n".join(funcs)
492 def _generate_extensions(self):
494 exts.append('%s' % self.lineinfo.get())
495 exts.append(self._gen_create_msg_callback())
496 exts.append(self._gen_destroy_msg_callback())
497 exts.append(self._gen_debug_report_msg())
498 return "\n".join(exts)
500 def _generate_layer_introspection_function(self):
502 body.append('%s' % self.lineinfo.get())
503 body.append('static const VkLayerProperties globalLayerProps = {')
504 body.append(' "VK_LAYER_GOOGLE_%s",' % self.layer_name)
505 body.append(' VK_LAYER_API_VERSION, // specVersion')
506 body.append(' 1, // implementationVersion')
507 body.append(' "Google Validation Layer"')
511 body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties* pProperties)')
513 body.append(' return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties);')
516 body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties* pProperties)')
518 body.append(' return util_GetLayerProperties(1, &globalLayerProps, pCount, pProperties);')
521 body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount, VkExtensionProperties* pProperties)')
523 body.append(' if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))')
524 body.append(' return util_GetExtensionProperties(0, NULL, pCount, pProperties);')
526 body.append(' return VK_ERROR_LAYER_NOT_PRESENT;')
529 body.append('VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,')
530 body.append(' const char *pLayerName, uint32_t *pCount,')
531 body.append(' VkExtensionProperties *pProperties)')
533 body.append(' if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))')
534 body.append(' return util_GetExtensionProperties(0, nullptr, pCount, pProperties);')
536 body.append(' assert(physicalDevice);')
537 body.append(' VkLayerInstanceDispatchTable* pTable = get_dispatch_table(%s_instance_table_map, physicalDevice);' % self.layer_name)
538 body.append(' return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);')
541 return "\n".join(body)
543 def _generate_layer_gpa_function(self, extensions=[], instance_extensions=[]):
546 # New style of GPA Functions for the new layer_data/layer_logging changes
548 if self.layer_name in ['unique_objects']:
549 for ext_enable, ext_list in extensions:
550 func_body.append('%s' % self.lineinfo.get())
551 func_body.append('static inline PFN_vkVoidFunction intercept_%s_command(const char *name, VkDevice dev)' % ext_enable)
552 func_body.append('{')
553 func_body.append(' if (dev) {')
554 func_body.append(' layer_data *my_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);')
555 func_body.append(' if (!my_data->%s)' % ext_enable)
556 func_body.append(' return nullptr;')
557 func_body.append(' }\n')
559 for ext_name in ext_list:
560 func_body.append(' if (!strcmp("%s", name))\n'
561 ' return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (ext_name, ext_name[2:]))
562 func_body.append('\n return nullptr;')
563 func_body.append('}\n')
565 func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName)\n"
567 " PFN_vkVoidFunction addr;\n"
568 " addr = intercept_core_device_command(funcName);\n"
571 " assert(device);\n")
572 for ext_enable, _ in extensions:
573 func_body.append(' addr = intercept_%s_command(funcName, device);' % ext_enable)
574 func_body.append(' if (addr)\n'
576 func_body.append("\n if (get_dispatch_table(%s_device_table_map, device)->GetDeviceProcAddr == NULL)\n"
578 " return get_dispatch_table(%s_device_table_map, device)->GetDeviceProcAddr(device, funcName);\n"
579 "}\n" % (self.layer_name, self.layer_name))
581 # The WSI-related extensions have independent extension enables
582 wsi_sub_enables = {'WIN32': 'win32_enabled',
583 'XLIB': 'xlib_enabled',
584 'XCB': 'xcb_enabled',
585 'MIR': 'mir_enabled',
586 'WAYLAND': 'wayland_enabled',
587 'ANDROID': 'android_enabled'}
589 for ext_enable, ext_list in instance_extensions:
590 func_body.append('%s' % self.lineinfo.get())
591 func_body.append('static inline PFN_vkVoidFunction intercept_%s_command(const char *name, VkInstance instance)' % ext_enable)
592 func_body.append('{')
593 if ext_enable == 'msg_callback_get_proc_addr':
594 func_body.append(" layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);\n"
595 " return debug_report_get_instance_proc_addr(my_data->report_data, name);")
597 func_body.append(" VkLayerInstanceDispatchTable* pTable = get_dispatch_table(%s_instance_table_map, instance);" % self.layer_name)
598 func_body.append(' if (instanceExtMap.size() == 0 || !instanceExtMap[pTable].%s)' % ext_enable)
599 func_body.append(' return nullptr;\n')
601 for ext_name in ext_list:
602 if wsi_name(ext_name):
603 func_body.append('%s' % wsi_ifdef(ext_name))
604 if wsi_sub_enables[wsi_name(ext_name)]:
605 func_body.append(' if ((instanceExtMap[pTable].%s == true) && !strcmp("%s", name))\n'
606 ' return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (wsi_sub_enables[wsi_name(ext_name)], ext_name, ext_name[2:]))
608 func_body.append(' if (!strcmp("%s", name))\n'
609 ' return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (ext_name, ext_name[2:]))
610 if wsi_name(ext_name):
611 func_body.append('%s' % wsi_endif(ext_name))
613 func_body.append('\n return nullptr;')
614 func_body.append('}\n')
616 func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
618 " PFN_vkVoidFunction addr;\n"
619 " addr = intercept_core_instance_command(funcName);\n"
621 " addr = intercept_core_device_command(funcName);\n"
624 for ext_enable, _ in extensions:
625 func_body.append(" if (!addr) {\n"
626 " addr = intercept_%s_command(funcName, VkDevice(VK_NULL_HANDLE));\n"
629 func_body.append(" if (addr) {\n"
632 " assert(instance);\n"
635 for ext_enable, _ in instance_extensions:
636 func_body.append(' addr = intercept_%s_command(funcName, instance);' % ext_enable)
637 func_body.append(' if (addr)\n'
640 func_body.append(" if (get_dispatch_table(%s_instance_table_map, instance)->GetInstanceProcAddr == NULL) {\n"
643 " return get_dispatch_table(%s_instance_table_map, instance)->GetInstanceProcAddr(instance, funcName);\n"
644 "}\n" % (self.layer_name, self.layer_name))
645 return "\n".join(func_body)
647 func_body.append('%s' % self.lineinfo.get())
648 func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName)\n"
650 " PFN_vkVoidFunction addr;\n")
651 func_body.append("\n"
652 " loader_platform_thread_once(&initOnce, init%s);\n\n"
653 " addr = intercept_core_device_command(funcName);\n"
655 " return addr;" % self.layer_name)
656 func_body.append(" assert(device);\n")
658 func_body.append(' VkLayerDispatchTable *pDisp = device_dispatch_table(device);')
659 if 0 != len(extensions):
661 for (ext_enable, ext_list) in extensions:
662 if 0 != len(ext_enable):
663 func_body.append(' if (deviceExtMap.size() != 0 && deviceExtMap[pDisp].%s)' % ext_enable)
664 func_body.append(' {')
666 for ext_name in ext_list:
667 func_body.append(' %sif (!strcmp("%s", funcName))\n'
668 ' return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (extra_space, ext_name, ext_name))
669 if 0 != len(ext_enable):
670 func_body.append(' }')
671 func_body.append('%s' % self.lineinfo.get())
672 func_body.append(" {\n"
673 " if (pDisp->GetDeviceProcAddr == NULL)\n"
675 " return pDisp->GetDeviceProcAddr(device, funcName);\n"
678 func_body.append('%s' % self.lineinfo.get())
679 func_body.append("VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char* funcName)\n"
681 " PFN_vkVoidFunction addr;\n"
684 " loader_platform_thread_once(&initOnce, init%s);\n\n"
685 " addr = intercept_core_instance_command(funcName);\n"
687 " return addr;" % self.layer_name)
688 func_body.append(" assert(instance);\n")
690 func_body.append(" VkLayerInstanceDispatchTable* pTable = instance_dispatch_table(instance);\n")
691 if 0 != len(instance_extensions):
693 for (ext_enable, ext_list) in instance_extensions:
694 if 0 != len(ext_enable):
695 if ext_enable == 'msg_callback_get_proc_addr':
696 func_body.append(" layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);\n"
697 " addr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);\n"
702 func_body.append(' if (instanceExtMap.size() != 0 && instanceExtMap[pTable].%s)' % ext_enable)
703 func_body.append(' {')
705 for ext_name in ext_list:
706 if wsi_name(ext_name):
707 func_body.append('%s' % wsi_ifdef(ext_name))
708 func_body.append(' %sif (!strcmp("%s", funcName))\n'
709 ' return reinterpret_cast<PFN_vkVoidFunction>(%s);' % (extra_space, ext_name, ext_name))
710 if wsi_name(ext_name):
711 func_body.append('%s' % wsi_endif(ext_name))
712 if 0 != len(ext_enable):
713 func_body.append(' }\n')
715 func_body.append(" if (pTable->GetInstanceProcAddr == NULL)\n"
717 " return pTable->GetInstanceProcAddr(instance, funcName);\n"
719 return "\n".join(func_body)
722 def _generate_layer_initialization(self, init_opts=False, prefix='vk', lockname=None, condname=None):
723 func_body = ["#include \"vk_dispatch_table_helper.h\""]
724 func_body.append('%s' % self.lineinfo.get())
725 func_body.append('static void init_%s(layer_data *my_data, const VkAllocationCallbacks *pAllocator)\n'
726 '{\n' % self.layer_name)
728 func_body.append('%s' % self.lineinfo.get())
730 func_body.append(' layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_%s");' % self.layer_name)
732 if lockname is not None:
733 func_body.append('%s' % self.lineinfo.get())
734 func_body.append(" if (!%sLockInitialized)" % lockname)
735 func_body.append(" {")
736 func_body.append(" // TODO/TBD: Need to delete this mutex sometime. How???")
737 func_body.append(" loader_platform_thread_create_mutex(&%sLock);" % lockname)
738 if condname is not None:
739 func_body.append(" loader_platform_thread_init_cond(&%sCond);" % condname)
740 func_body.append(" %sLockInitialized = 1;" % lockname)
741 func_body.append(" }")
742 func_body.append("}\n")
744 return "\n".join(func_body)
746 class UniqueObjectsSubcommand(Subcommand):
747 def generate_header(self):
749 header_txt.append('%s' % self.lineinfo.get())
750 header_txt.append('#include "unique_objects.h"')
751 return "\n".join(header_txt)
753 # Generate UniqueObjects code for given struct_uses dict of objects that need to be unwrapped
754 # vector_name_set is used to make sure we don't replicate vector names
755 # first_level_param indicates if elements are passed directly into the function else they're below a ptr/struct
756 # TODO : Comment this code
757 def _gen_obj_code(self, struct_uses, param_type, indent, prefix, array_index, vector_name_set, first_level_param):
761 for obj in sorted(struct_uses):
765 (name, array) = obj.split('[')
766 array = array.strip(']')
768 if 'p' == obj[0] and obj[1] != obj[1].lower(): # TODO : Not ideal way to determine ptr
770 if isinstance(struct_uses[obj], dict):
772 name = '%s%s' % (prefix, name)
774 if first_level_param and name in param_type:
775 pre_code += '%sif (%s) {\n' % (indent, name)
776 else: # shadow ptr will have been initialized at this point so check it vs. source ptr
777 pre_code += '%sif (local_%s) {\n' % (indent, name)
780 if 'p' == array[0] and array[1] != array[1].lower(): # TODO : Not ideal way to determine ptr
784 idx = 'idx%s' % str(array_index)
786 if first_level_param and name in param_type:
787 pre_code += '%slocal_%s = new safe_%s[%s%s];\n' % (indent, name, param_type[name].strip('*'), count_prefix, array)
788 post_code += ' if (local_%s)\n' % (name)
789 post_code += ' delete[] local_%s;\n' % (name)
790 pre_code += '%sfor (uint32_t %s=0; %s<%s%s%s; ++%s) {\n' % (indent, idx, idx, count_prefix, prefix, array, idx)
792 if first_level_param:
793 pre_code += '%slocal_%s[%s].initialize(&%s[%s]);\n' % (indent, name, idx, name, idx)
794 local_prefix = '%s[%s].' % (name, idx)
796 if first_level_param and name in param_type:
797 pre_code += '%slocal_%s = new safe_%s(%s);\n' % (indent, name, param_type[name].strip('*'), name)
798 post_code += ' if (local_%s)\n' % (name)
799 post_code += ' delete local_%s;\n' % (name)
800 local_prefix = '%s->' % (name)
802 local_prefix = '%s.' % (name)
803 assert isinstance(decls, object)
804 (tmp_decl, tmp_pre, tmp_post) = self._gen_obj_code(struct_uses[obj], param_type, indent, local_prefix, array_index, vector_name_set, False)
807 post_code += tmp_post
810 pre_code += '%s}\n' % (indent)
813 pre_code += '%s}\n' % (indent)
815 if (array_index > 0) or array != '': # TODO : This is not ideal, really want to know if we're anywhere under an array
816 if first_level_param:
817 decls += '%s%s* local_%s = NULL;\n' % (indent, struct_uses[obj], name)
818 if array != '' and not first_level_param: # ptrs under structs will have been initialized so use local_*
819 pre_code += '%sif (local_%s%s) {\n' %(indent, prefix, name)
821 pre_code += '%sif (%s%s) {\n' %(indent, prefix, name)
824 idx = 'idx%s' % str(array_index)
826 if first_level_param:
827 pre_code += '%slocal_%s = new %s[%s];\n' % (indent, name, struct_uses[obj], array)
828 post_code += ' if (local_%s)\n' % (name)
829 post_code += ' delete[] local_%s;\n' % (name)
830 pre_code += '%sfor (uint32_t %s=0; %s<%s%s; ++%s) {\n' % (indent, idx, idx, prefix, array, idx)
832 name = '%s[%s]' % (name, idx)
833 if name not in vector_name_set:
834 vector_name_set.add(name)
835 pre_code += '%slocal_%s%s = (%s)my_map_data->unique_id_mapping[reinterpret_cast<const uint64_t &>(%s%s)];\n' % (indent, prefix, name, struct_uses[obj], prefix, name)
838 pre_code += '%s}\n' % (indent)
840 pre_code += '%s}\n' % (indent)
842 pre_code += '%s\n' % (self.lineinfo.get())
843 if '->' in prefix: # need to update local struct
844 pre_code += '%slocal_%s%s = (%s)my_map_data->unique_id_mapping[reinterpret_cast<const uint64_t &>(%s%s)];\n' % (indent, prefix, name, struct_uses[obj], prefix, name)
846 pre_code += '%s%s = (%s)my_map_data->unique_id_mapping[reinterpret_cast<uint64_t &>(%s)];\n' % (indent, name, struct_uses[obj], name)
847 return decls, pre_code, post_code
849 def generate_intercept(self, proto, qual):
852 last_param_index = None #typcially we look at all params for ndos
853 pre_call_txt = '' # code prior to calling down chain such as unwrap uses of ndos
854 post_call_txt = '' # code following call down chain such to wrap newly created ndos, or destroy local wrap struct
856 indent = ' ' # indent level for generated code
857 decl = proto.c_func(attr="VKAPI")
858 # A few API cases that are manual code
859 # TODO : Special case Create*Pipelines funcs to handle creating multiple unique objects
860 explicit_unique_objects_functions = ['GetSwapchainImagesKHR',
861 'CreateSwapchainKHR',
867 'CreateComputePipelines',
868 'CreateGraphicsPipelines',
869 'GetPhysicalDeviceDisplayPropertiesKHR',
870 'GetDisplayPlaneSupportedDisplaysKHR',
871 'GetDisplayModePropertiesKHR'
873 # TODO : This is hacky, need to make this a more general-purpose solution for all layers
874 ifdef_dict = {'CreateXcbSurfaceKHR': 'VK_USE_PLATFORM_XCB_KHR',
875 'CreateAndroidSurfaceKHR': 'VK_USE_PLATFORM_ANDROID_KHR',
876 'CreateWin32SurfaceKHR': 'VK_USE_PLATFORM_WIN32_KHR',
877 'CreateXlibSurfaceKHR': 'VK_USE_PLATFORM_XLIB_KHR',
878 'CreateWaylandSurfaceKHR': 'VK_USE_PLATFORM_WAYLAND_KHR',
879 'CreateMirSurfaceKHR': 'VK_USE_PLATFORM_MIR_KHR'}
880 # Give special treatment to create functions that return multiple new objects
881 # This dict stores array name and size of array
882 custom_create_dict = {'pDescriptorSets' : 'pAllocateInfo->descriptorSetCount'}
883 pre_call_txt += '%s\n' % (self.lineinfo.get())
884 if proto.name in explicit_unique_objects_functions:
885 funcs.append('%s%s\n'
887 ' return explicit_%s;\n'
888 '}' % (qual, decl, proto.c_call()))
889 return "".join(funcs)
890 if True in [create_txt in proto.name for create_txt in ['Create', 'Allocate']]:
892 last_param_index = -1 # For create funcs don't care if last param is ndo
893 if True in [destroy_txt in proto.name for destroy_txt in ['Destroy', 'Free']]:
894 destroy_obj_type = proto.params[-2].ty
895 if destroy_obj_type in vulkan.object_non_dispatch_list:
898 # First thing we need to do is gather uses of non-dispatchable-objects (ndos)
899 (struct_uses, local_decls) = get_object_uses(vulkan.object_non_dispatch_list, proto.params[1:last_param_index])
901 dispatch_param = proto.params[0].name
902 if 'CreateInstance' in proto.name:
903 dispatch_param = '*' + proto.params[1].name
904 pre_call_txt += '%slayer_data *my_map_data = get_my_data_ptr(get_dispatch_key(%s), layer_data_map);\n' % (indent, dispatch_param)
905 if len(struct_uses) > 0:
906 pre_call_txt += '// STRUCT USES:%s\n' % sorted(struct_uses)
907 if len(local_decls) > 0:
908 pre_call_txt += '//LOCAL DECLS:%s\n' % sorted(local_decls)
909 if destroy_func: # only one object
910 pre_call_txt += '%sstd::unique_lock<std::mutex> lock(global_lock);\n' % (indent)
911 for del_obj in sorted(struct_uses):
912 pre_call_txt += '%suint64_t local_%s = reinterpret_cast<uint64_t &>(%s);\n' % (indent, del_obj, del_obj)
913 pre_call_txt += '%s%s = (%s)my_map_data->unique_id_mapping[local_%s];\n' % (indent, del_obj, struct_uses[del_obj], del_obj)
914 pre_call_txt += '%smy_map_data->unique_id_mapping.erase(local_%s);\n' % (indent, proto.params[-2].name)
915 pre_call_txt += '%slock.unlock();\n' % (indent)
916 (pre_decl, pre_code, post_code) = ('', '', '')
918 (pre_decl, pre_code, post_code) = self._gen_obj_code(struct_uses, local_decls, ' ', '', 0, set(), True)
919 # This is a bit hacky but works for now. Need to decl local versions of top-level structs
920 for ld in sorted(local_decls):
921 init_null_txt = 'NULL';
922 if '*' not in local_decls[ld]:
923 init_null_txt = '{}';
924 if local_decls[ld].strip('*') not in vulkan.object_non_dispatch_list:
925 pre_decl += ' safe_%s local_%s = %s;\n' % (local_decls[ld], ld, init_null_txt)
926 if pre_code != '': # lock around map uses
927 pre_code = '%s{\n%sstd::lock_guard<std::mutex> lock(global_lock);\n%s%s}\n' % (indent, indent, pre_code, indent)
928 pre_call_txt += '%s%s' % (pre_decl, pre_code)
929 post_call_txt += '%s' % (post_code)
931 base_type = proto.params[-1].ty.replace('const ', '').strip('*')
932 if base_type not in vulkan.object_non_dispatch_list:
939 if proto.ret != "void":
940 ret_val = "%s result = " % proto.ret
941 ret_stmt = " return result;\n"
943 obj_type = proto.params[-1].ty.strip('*')
944 obj_name = proto.params[-1].name
945 if obj_type in vulkan.object_non_dispatch_list:
946 local_name = "unique%s" % obj_type[2:]
947 post_call_txt += '%sif (VK_SUCCESS == result) {\n' % (indent)
949 post_call_txt += '%sstd::lock_guard<std::mutex> lock(global_lock);\n' % (indent)
950 if obj_name in custom_create_dict:
951 post_call_txt += '%s\n' % (self.lineinfo.get())
952 local_name = '%ss' % (local_name) # add 's' to end for vector of many
953 post_call_txt += '%sfor (uint32_t i=0; i<%s; ++i) {\n' % (indent, custom_create_dict[obj_name])
955 post_call_txt += '%suint64_t unique_id = global_unique_id++;\n' % (indent)
956 post_call_txt += '%smy_map_data->unique_id_mapping[unique_id] = reinterpret_cast<uint64_t &>(%s[i]);\n' % (indent, obj_name)
957 post_call_txt += '%s%s[i] = reinterpret_cast<%s&>(unique_id);\n' % (indent, obj_name, obj_type)
959 post_call_txt += '%s}\n' % (indent)
961 post_call_txt += '%s\n' % (self.lineinfo.get())
962 post_call_txt += '%suint64_t unique_id = global_unique_id++;\n' % (indent)
963 post_call_txt += '%smy_map_data->unique_id_mapping[unique_id] = reinterpret_cast<uint64_t &>(*%s);\n' % (indent, obj_name)
964 post_call_txt += '%s*%s = reinterpret_cast<%s&>(unique_id);\n' % (indent, obj_name, obj_type)
966 post_call_txt += '%s}\n' % (indent)
968 call_sig = proto.c_call()
969 # Replace default params with any custom local params
970 for ld in local_decls:
972 for p in proto.params:
973 if ld == p.name and 'const' in p.ty:
974 const_qualifier = 'const'
975 call_sig = call_sig.replace(ld, '(%s %s)local_%s' % (const_qualifier, local_decls[ld], ld))
976 if proto_is_global(proto):
977 table_type = "instance"
979 table_type = "device"
980 pre_call_txt += '%s\n' % (self.lineinfo.get())
983 if proto.name in ifdef_dict:
984 open_ifdef = '#ifdef %s\n' % (ifdef_dict[proto.name])
985 close_ifdef = '#endif\n'
990 ' %sget_dispatch_table(unique_objects_%s_table_map, %s)->%s;\n'
994 '%s' % (open_ifdef, qual, decl, pre_call_txt, ret_val, table_type, dispatch_param, call_sig, post_call_txt, ret_stmt, close_ifdef))
995 return "\n\n".join(funcs)
997 def generate_body(self):
998 self.layer_name = "unique_objects"
999 extensions=[('wsi_enabled',
1000 ['vkCreateSwapchainKHR',
1001 'vkDestroySwapchainKHR', 'vkGetSwapchainImagesKHR',
1002 'vkAcquireNextImageKHR', 'vkQueuePresentKHR'])]
1003 surface_wsi_instance_exts = [
1004 'vkDestroySurfaceKHR',
1005 'vkGetPhysicalDeviceSurfaceSupportKHR',
1006 'vkGetPhysicalDeviceSurfaceCapabilitiesKHR',
1007 'vkGetPhysicalDeviceSurfaceFormatsKHR',
1008 'vkGetPhysicalDeviceSurfacePresentModesKHR']
1009 display_wsi_instance_exts = [
1010 'vkGetPhysicalDeviceDisplayPropertiesKHR',
1011 'vkGetPhysicalDeviceDisplayPlanePropertiesKHR',
1012 'vkGetDisplayPlaneSupportedDisplaysKHR',
1013 'vkGetDisplayModePropertiesKHR',
1014 'vkCreateDisplayModeKHR',
1015 'vkGetDisplayPlaneCapabilitiesKHR',
1016 'vkCreateDisplayPlaneSurfaceKHR']
1017 if self.wsi == 'Win32':
1018 instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1019 ('display_enabled', display_wsi_instance_exts),
1020 ('win32_enabled', ['vkCreateWin32SurfaceKHR'])]
1021 elif self.wsi == 'Android':
1022 instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1023 ('android_enabled', ['vkCreateAndroidSurfaceKHR'])]
1024 elif self.wsi == 'Xcb' or self.wsi == 'Xlib' or self.wsi == 'Wayland' or self.wsi == 'Mir':
1025 instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1026 ('display_enabled', display_wsi_instance_exts),
1027 ('xcb_enabled', ['vkCreateXcbSurfaceKHR']),
1028 ('xlib_enabled', ['vkCreateXlibSurfaceKHR']),
1029 ('wayland_enabled', ['vkCreateWaylandSurfaceKHR']),
1030 ('mir_enabled', ['vkCreateMirSurfaceKHR'])]
1031 elif self.wsi == 'Display':
1032 instance_extensions=[('wsi_enabled', surface_wsi_instance_exts),
1033 ('display_enabled', display_wsi_instance_exts)]
1035 print('Error: Undefined DisplayServer')
1036 instance_extensions=[]
1038 body = ["namespace %s {" % self.layer_name,
1039 self._generate_dispatch_entrypoints(),
1040 self._generate_layer_introspection_function(),
1041 self._generate_layer_gpa_function(extensions,
1042 instance_extensions),
1043 "} // namespace %s" % self.layer_name,
1044 self._gen_layer_interface_v0_functions()]
1045 return "\n\n".join(body)
1059 "unique_objects" : UniqueObjectsSubcommand,
1062 if len(sys.argv) < 4 or sys.argv[1] not in wsi or sys.argv[2] not in subcommands or not os.path.exists(sys.argv[3]):
1063 print("Usage: %s <wsi> <subcommand> <input_header> [outdir]" % sys.argv[0])
1065 print("Available subcommands are: %s" % " ".join(subcommands))
1068 hfp = vk_helper.HeaderFileParser(sys.argv[3])
1070 vk_helper.enum_val_dict = hfp.get_enum_val_dict()
1071 vk_helper.enum_type_dict = hfp.get_enum_type_dict()
1072 vk_helper.struct_dict = hfp.get_struct_dict()
1073 vk_helper.typedef_fwd_dict = hfp.get_typedef_fwd_dict()
1074 vk_helper.typedef_rev_dict = hfp.get_typedef_rev_dict()
1075 vk_helper.types_dict = hfp.get_types_dict()
1078 if len(sys.argv) >= 5:
1079 outfile = sys.argv[4]
1081 subcmd = subcommands[sys.argv[2]](outfile)
1084 if __name__ == "__main__":