Tobin Ehlis | ee33fa5 | 2014-10-22 15:13:53 -0600 | [diff] [blame^] | 1 | import argparse |
| 2 | import os |
| 3 | import sys |
| 4 | |
| 5 | # code_gen.py overview |
| 6 | # This script generates code based on input headers |
| 7 | # Initially it's intended to support Mantle and XGL headers and |
| 8 | # generate wrappers functions that can be used to display |
| 9 | # structs in a human-readable txt format, as well as utility functions |
| 10 | # to print enum values as strings |
| 11 | |
| 12 | |
| 13 | def handle_args(): |
| 14 | parser = argparse.ArgumentParser(description='Perform analysis of vogl trace.') |
| 15 | parser.add_argument('input_file', help='The input header file from which code will be generated.') |
| 16 | parser.add_argument('--rel_out_dir', required=False, default='glave_gen', help='Path relative to exec path to write output files. Will be created if needed.') |
| 17 | parser.add_argument('--abs_out_dir', required=False, default=None, help='Absolute path to write output files. Will be created if needed.') |
| 18 | parser.add_argument('--gen_enum_string_helper', required=False, action='store_true', default=False, help='Enable generation of helper header file to print string versions of enums.') |
| 19 | parser.add_argument('--gen_struct_wrappers', required=False, action='store_true', default=False, help='Enable generation of struct wrapper classes.') |
| 20 | parser.add_argument('--gen_cmake', required=False, action='store_true', default=False, help='Enable generation of cmake file for generated code.') |
| 21 | parser.add_argument('--gen_graphviz', required=False, action='store_true', default=False, help='Enable generation of graphviz dot file.') |
| 22 | #parser.add_argument('--test', action='store_true', default=False, help='Run simple test.') |
| 23 | return parser.parse_args() |
| 24 | |
| 25 | # TODO : Ideally these data structs would be opaque to user and could be wrapped |
| 26 | # in their own class(es) to make them friendly for data look-up |
| 27 | # Dicts for Data storage |
| 28 | # enum_val_dict[value_name] = dict keys are the string enum value names for all enums |
| 29 | # |-------->['type'] = the type of enum class into which the value falls |
| 30 | # |-------->['val'] = the value assigned to this particular value_name |
| 31 | # '-------->['unique'] = bool designating if this enum 'val' is unique within this enum 'type' |
| 32 | enum_val_dict = {} |
| 33 | # enum_type_dict['type'] = the type or class of of enum |
| 34 | # '----->['val_name1', 'val_name2'...] = each type references a list of val_names within this type |
| 35 | enum_type_dict = {} |
| 36 | # struct_dict['struct_basename'] = the base (non-typedef'd) name of the struct |
| 37 | # |->[<member_num>] = members are stored via their integer placement in the struct |
| 38 | # | |->['name'] = string name of this struct member |
| 39 | # ... |->['full_type'] = complete type qualifier for this member |
| 40 | # |->['type'] = base type for this member |
| 41 | # |->['ptr'] = bool indicating if this member is ptr |
| 42 | # |->['const'] = bool indicating if this member is const |
| 43 | # |->['struct'] = bool indicating if this member is a struct type |
| 44 | # |->['array'] = bool indicating if this member is an array |
| 45 | # '->['array_size'] = int indicating size of array members (0 by default) |
| 46 | struct_dict = {} |
| 47 | # typedef_fwd_dict stores mapping from orig_type_name -> new_type_name |
| 48 | typedef_fwd_dict = {} |
| 49 | # typedef_rev_dict stores mapping from new_type_name -> orig_type_name |
| 50 | typedef_rev_dict = {} # store new_name -> orig_name mapping |
| 51 | # types_dict['id_name'] = identifier name will map to it's type |
| 52 | # '---->'type' = currently either 'struct' or 'enum' |
| 53 | types_dict = {} # store orig_name -> type mapping |
| 54 | |
| 55 | |
| 56 | # Class that parses header file and generates data structures that can |
| 57 | # Then be used for other tasks |
| 58 | class HeaderFileParser: |
| 59 | def __init__(self, header_file=None): |
| 60 | self.header_file = header_file |
| 61 | # store header data in various formats, see above for more info |
| 62 | self.enum_val_dict = {} |
| 63 | self.enum_type_dict = {} |
| 64 | self.struct_dict = {} |
| 65 | self.typedef_fwd_dict = {} |
| 66 | self.typedef_rev_dict = {} |
| 67 | self.types_dict = {} |
| 68 | |
| 69 | def setHeaderFile(self, header_file): |
| 70 | self.header_file = header_file |
| 71 | |
| 72 | def get_enum_val_dict(self): |
| 73 | return self.enum_val_dict |
| 74 | |
| 75 | def get_enum_type_dict(self): |
| 76 | return self.enum_type_dict |
| 77 | |
| 78 | def get_struct_dict(self): |
| 79 | return self.struct_dict |
| 80 | |
| 81 | def get_typedef_fwd_dict(self): |
| 82 | return self.typedef_fwd_dict |
| 83 | |
| 84 | def get_typedef_rev_dict(self): |
| 85 | return self.typedef_rev_dict |
| 86 | |
| 87 | def get_types_dict(self): |
| 88 | return self.types_dict |
| 89 | |
| 90 | # Parse header file into data structures |
| 91 | def parse(self): |
| 92 | # parse through the file, identifying different sections |
| 93 | parse_enum = False |
| 94 | parse_struct = False |
| 95 | member_num = 0 |
| 96 | # TODO : Comment parsing is very fragile but handles 2 known files |
| 97 | block_comment = False |
| 98 | with open(self.header_file) as f: |
| 99 | for line in f: |
| 100 | if block_comment: |
| 101 | if '*/' in line: |
| 102 | block_comment = False |
| 103 | continue |
| 104 | if '/*' in line: |
| 105 | block_comment = True |
| 106 | elif 0 == len(line.split()): |
| 107 | #print("Skipping empty line") |
| 108 | continue |
| 109 | elif line.split()[0].strip().startswith("//"): |
| 110 | #print("Skipping commentted line %s" % line) |
| 111 | continue |
| 112 | elif 'typedef enum' in line: |
| 113 | (ty_txt, en_txt, base_type) = line.strip().split(None, 2) |
| 114 | #print("Found ENUM type %s" % base_type) |
| 115 | parse_enum = True |
| 116 | self.types_dict[base_type] = 'enum' |
| 117 | elif 'typedef struct' in line: |
| 118 | (ty_txt, st_txt, base_type) = line.strip().split(None, 2) |
| 119 | #print("Found STRUCT type: %s" % base_type) |
| 120 | parse_struct = True |
| 121 | self.types_dict[base_type] = 'struct' |
| 122 | elif '}' in line and (parse_enum or parse_struct): |
| 123 | if len(line.split()) > 1: # deals with embedded union in one struct |
| 124 | parse_enum = False |
| 125 | parse_struct = False |
| 126 | member_num = 0 |
| 127 | # TODO : Can pull target of typedef here for remapping |
| 128 | (cur_char, targ_type) = line.strip().split(None, 1) |
| 129 | self.typedef_fwd_dict[base_type] = targ_type.strip(';') |
| 130 | self.typedef_rev_dict[targ_type.strip(';')] = base_type |
| 131 | elif parse_enum: |
| 132 | if '=' in line: |
| 133 | self._add_enum(line, base_type) |
| 134 | elif parse_struct: |
| 135 | if ';' in line: |
| 136 | self._add_struct(line, base_type, member_num) |
| 137 | member_num = member_num + 1 |
| 138 | #elif '(' in line: |
| 139 | #print("Function: %s" % line) |
| 140 | |
| 141 | # populate enum dicts based on enum lines |
| 142 | def _add_enum(self, line_txt, enum_type): |
| 143 | #print("Parsing enum line %s" % line_txt) |
| 144 | (enum_name, eq_char, enum_val) = line_txt.split(None, 2) |
| 145 | if '=' != eq_char: |
| 146 | print("ERROR: Couldn't parse enum line: %s" % line_txt) |
| 147 | self.enum_val_dict[enum_name] = {} |
| 148 | self.enum_val_dict[enum_name]['type'] = enum_type |
| 149 | # strip comma and comment, then extra split in case of no comma w/ comments |
| 150 | enum_val = enum_val.strip().split(',', 1)[0] |
| 151 | self.enum_val_dict[enum_name]['val'] = enum_val.split()[0] |
| 152 | # TODO : Make this more robust, to verify if enum value is unique |
| 153 | # Currently just try to cast to int which works ok but missed -(HEX) values |
| 154 | try: |
| 155 | #print("ENUM val:", self.enum_val_dict[enum_name]['val']) |
| 156 | int(self.enum_val_dict[enum_name]['val'], 0) |
| 157 | self.enum_val_dict[enum_name]['unique'] = True |
| 158 | #print("ENUM has num value") |
| 159 | except ValueError: |
| 160 | self.enum_val_dict[enum_name]['unique'] = False |
| 161 | #print("ENUM is not a number value") |
| 162 | # Update enum_type_dict as well |
| 163 | if not enum_type in self.enum_type_dict: |
| 164 | self.enum_type_dict[enum_type] = [] |
| 165 | self.enum_type_dict[enum_type].append(enum_name) |
| 166 | |
| 167 | # populate struct dicts based on struct lines |
| 168 | # TODO : Handle ":" bitfield, "**" ptr->ptr and "const type*const*" |
| 169 | def _add_struct(self, line_txt, struct_type, num): |
| 170 | #print("Parsing struct line %s" % line_txt) |
| 171 | if not struct_type in self.struct_dict: |
| 172 | self.struct_dict[struct_type] = {} |
| 173 | members = line_txt.strip().split(';', 1)[0] # first strip semicolon & comments |
| 174 | # TODO : Handle bitfields more correctly |
| 175 | members = members.strip().split(':', 1)[0] # strip bitfield element |
| 176 | (member_type, member_name) = members.rsplit(None, 1) |
| 177 | self.struct_dict[struct_type][num] = {} |
| 178 | self.struct_dict[struct_type][num]['full_type'] = member_type |
| 179 | if '*' in member_type: |
| 180 | self.struct_dict[struct_type][num]['ptr'] = True |
| 181 | member_type = member_type.strip('*') |
| 182 | else: |
| 183 | self.struct_dict[struct_type][num]['ptr'] = False |
| 184 | if 'const' in member_type: |
| 185 | self.struct_dict[struct_type][num]['const'] = True |
| 186 | member_type = member_type.strip('const').strip() |
| 187 | else: |
| 188 | self.struct_dict[struct_type][num]['const'] = False |
| 189 | if is_type(member_type, 'struct'): |
| 190 | self.struct_dict[struct_type][num]['struct'] = True |
| 191 | else: |
| 192 | self.struct_dict[struct_type][num]['struct'] = False |
| 193 | self.struct_dict[struct_type][num]['type'] = member_type |
| 194 | if '[' in member_name: |
| 195 | (member_name, array_size) = member_name.split('[', 1) |
| 196 | self.struct_dict[struct_type][num]['array'] = True |
| 197 | self.struct_dict[struct_type][num]['array_size'] = array_size.strip(']') |
| 198 | else: |
| 199 | self.struct_dict[struct_type][num]['array'] = False |
| 200 | self.struct_dict[struct_type][num]['array_size'] = 0 |
| 201 | self.struct_dict[struct_type][num]['name'] = member_name |
| 202 | |
| 203 | # check if given identifier if of specified type_to_check |
| 204 | def is_type(identifier, type_to_check): |
| 205 | #print("Checking if %s is type %s" % (identifier, type_to_check)) |
| 206 | if identifier in types_dict and type_to_check == types_dict[identifier]: |
| 207 | return True |
| 208 | if identifier in typedef_rev_dict: |
| 209 | new_id = typedef_rev_dict[identifier] |
| 210 | if new_id in types_dict and type_to_check == types_dict[new_id]: |
| 211 | return True |
| 212 | return False |
| 213 | |
| 214 | # This is a validation function to verify that we can reproduce the original structs |
| 215 | def recreate_structs(): |
| 216 | for struct_name in struct_dict: |
| 217 | sys.stdout.write("typedef struct %s\n{\n" % struct_name) |
| 218 | for mem_num in sorted(struct_dict[struct_name]): |
| 219 | sys.stdout.write(" ") |
| 220 | if struct_dict[struct_name][mem_num]['const']: |
| 221 | sys.stdout.write("const ") |
| 222 | #if struct_dict[struct_name][mem_num]['struct']: |
| 223 | # sys.stdout.write("struct ") |
| 224 | sys.stdout.write (struct_dict[struct_name][mem_num]['type']) |
| 225 | if struct_dict[struct_name][mem_num]['ptr']: |
| 226 | sys.stdout.write("*") |
| 227 | sys.stdout.write(" ") |
| 228 | sys.stdout.write(struct_dict[struct_name][mem_num]['name']) |
| 229 | if struct_dict[struct_name][mem_num]['array']: |
| 230 | sys.stdout.write("[") |
| 231 | sys.stdout.write(struct_dict[struct_name][mem_num]['array_size']) |
| 232 | sys.stdout.write("]") |
| 233 | sys.stdout.write(";\n") |
| 234 | sys.stdout.write("} ") |
| 235 | sys.stdout.write(typedef_fwd_dict[struct_name]) |
| 236 | sys.stdout.write(";\n\n") |
| 237 | |
| 238 | # class for writing common file elements |
| 239 | # Here's how this class lays out a file: |
| 240 | # COPYRIGHT |
| 241 | # HEADER |
| 242 | # BODY |
| 243 | # FOOTER |
| 244 | # |
| 245 | # For each of these sections, there's a "set*" function |
| 246 | # The class as a whole has a generate function which will write each section in order |
| 247 | class CommonFileGen: |
| 248 | def __init__(self, filename=None, copyright_txt="", header_txt="", body_txt="", footer_txt=""): |
| 249 | self.filename = filename |
| 250 | self.contents = {'copyright': copyright_txt, 'header': header_txt, 'body': body_txt, 'footer': footer_txt} |
| 251 | # TODO : Set a default copyright & footer at least |
| 252 | |
| 253 | def setFilename(self, filename): |
| 254 | self.filename = filename |
| 255 | |
| 256 | def setCopyright(self, c): |
| 257 | self.contents['copyright'] = c |
| 258 | |
| 259 | def setHeader(self, h): |
| 260 | self.contents['header'] = h |
| 261 | |
| 262 | def setBody(self, b): |
| 263 | self.contents['body'] = b |
| 264 | |
| 265 | def setFooter(self, f): |
| 266 | self.contents['footer'] = f |
| 267 | |
| 268 | def generate(self): |
| 269 | #print("Generate to file %s" % self.filename) |
| 270 | with open(self.filename, "w") as f: |
| 271 | f.write(self.contents['copyright']) |
| 272 | f.write(self.contents['header']) |
| 273 | f.write(self.contents['body']) |
| 274 | f.write(self.contents['footer']) |
| 275 | |
| 276 | # class for writing a wrapper class for structures |
| 277 | # The wrapper class wraps the structs and includes utility functions for |
| 278 | # setting/getting member values and displaying the struct data in various formats |
| 279 | class StructWrapperGen: |
| 280 | def __init__(self, in_struct_dict, prefix, out_dir): |
| 281 | self.struct_dict = in_struct_dict |
| 282 | self.include_headers = [] |
| 283 | self.api = prefix |
| 284 | self.header_filename = os.path.join(out_dir, self.api+"_struct_wrappers.h") |
| 285 | self.class_filename = os.path.join(out_dir, self.api+"_struct_wrappers.cpp") |
| 286 | self.string_helper_filename = os.path.join(out_dir, self.api+"_struct_string_helper.h") |
| 287 | self.hfg = CommonFileGen(self.header_filename) |
| 288 | self.cfg = CommonFileGen(self.class_filename) |
| 289 | self.shg = CommonFileGen(self.string_helper_filename) |
| 290 | #print(self.header_filename) |
| 291 | self.header_txt = "" |
| 292 | self.definition_txt = "" |
| 293 | |
| 294 | def set_include_headers(self, include_headers): |
| 295 | self.include_headers = include_headers |
| 296 | |
| 297 | # Return class name for given struct name |
| 298 | def get_class_name(self, struct_name): |
| 299 | class_name = struct_name.strip('_').lower() + "_struct_wrapper" |
| 300 | return class_name |
| 301 | |
| 302 | def get_file_list(self): |
| 303 | return [os.path.basename(self.header_filename), os.path.basename(self.class_filename), os.path.basename(self.string_helper_filename)] |
| 304 | |
| 305 | # Generate class header file |
| 306 | def generateHeader(self): |
| 307 | self.hfg.setCopyright(self._generateCopyright()) |
| 308 | self.hfg.setHeader(self._generateHeader()) |
| 309 | self.hfg.setBody(self._generateClassDeclaration()) |
| 310 | self.hfg.setFooter(self._generateFooter()) |
| 311 | self.hfg.generate() |
| 312 | |
| 313 | # Generate class definition |
| 314 | def generateBody(self): |
| 315 | self.cfg.setCopyright(self._generateCopyright()) |
| 316 | self.cfg.setHeader(self._generateCppHeader()) |
| 317 | self.cfg.setBody(self._generateClassDefinition()) |
| 318 | self.cfg.setFooter(self._generateFooter()) |
| 319 | self.cfg.generate() |
| 320 | |
| 321 | # Generate c-style .h file that contains functions for printing structs |
| 322 | def generateStringHelper(self): |
| 323 | print("Generating struct string helper") |
| 324 | self.shg.setCopyright(self._generateCopyright()) |
| 325 | self.shg.setHeader(self._generateStringHelperHeader()) |
| 326 | self.shg.setBody(self._generateStringHelperFunctions()) |
| 327 | self.shg.generate() |
| 328 | |
| 329 | def _generateCopyright(self): |
| 330 | return "//This is the copyright\n" |
| 331 | |
| 332 | def _generateCppHeader(self): |
| 333 | header = [] |
| 334 | header.append("//#includes, #defines, globals and such...\n") |
| 335 | header.append("#include <stdio.h>\n#include <%s>\n#include <%s_string_helper.h>\n" % (os.path.basename(self.header_filename), self.api)) |
| 336 | return "".join(header) |
| 337 | |
| 338 | def _generateClassDefinition(self): |
| 339 | class_def = [] |
| 340 | if 'xgl' == self.api: # Mantle doesn't have pNext to worry about |
| 341 | class_def.append(self._generateDynamicPrintFunctions()) |
| 342 | for s in self.struct_dict: |
| 343 | class_def.append("\n// %s class definition" % self.get_class_name(s)) |
| 344 | class_def.append(self._generateConstructorDefinitions(s)) |
| 345 | class_def.append(self._generateDestructorDefinitions(s)) |
| 346 | class_def.append(self._generateDisplayDefinitions(s)) |
| 347 | return "\n".join(class_def) |
| 348 | |
| 349 | def _generateConstructorDefinitions(self, s): |
| 350 | con_defs = [] |
| 351 | con_defs.append("%s::%s() : m_struct(), m_indent(0), m_dummy_prefix('\\0'), m_origStructAddr(NULL) {}" % (self.get_class_name(s), self.get_class_name(s))) |
| 352 | # TODO : This is a shallow copy of ptrs |
| 353 | con_defs.append("%s::%s(%s* pInStruct) : m_indent(0), m_dummy_prefix('\\0')\n{\n m_struct = *pInStruct;\n m_origStructAddr = pInStruct;\n}" % (self.get_class_name(s), self.get_class_name(s), typedef_fwd_dict[s])) |
| 354 | con_defs.append("%s::%s(const %s* pInStruct) : m_indent(0), m_dummy_prefix('\\0')\n{\n m_struct = *pInStruct;\n m_origStructAddr = pInStruct;\n}" % (self.get_class_name(s), self.get_class_name(s), typedef_fwd_dict[s])) |
| 355 | return "\n".join(con_defs) |
| 356 | |
| 357 | def _generateDestructorDefinitions(self, s): |
| 358 | return "%s::~%s() {}" % (self.get_class_name(s), self.get_class_name(s)) |
| 359 | |
| 360 | def _generateDynamicPrintFunctions(self): |
| 361 | dp_funcs = [] |
| 362 | dp_funcs.append("\nvoid dynamic_display_full_txt(const XGL_VOID* pStruct, uint32_t indent)\n{\n // Cast to APP_INFO ptr initially just to pull sType off struct") |
| 363 | dp_funcs.append(" XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;\n") |
| 364 | dp_funcs.append(" switch (sType)\n {") |
| 365 | for e in enum_type_dict: |
| 366 | class_num = 0 |
| 367 | if "_STRUCTURE_TYPE" in e: |
| 368 | for v in sorted(enum_type_dict[e]): |
| 369 | struct_name = v.replace("_STRUCTURE_TYPE", "") |
| 370 | class_name = self.get_class_name(struct_name) |
| 371 | # TODO : Hand-coded fixes for some exceptions |
| 372 | if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name: |
| 373 | struct_name = 'XGL_PIPELINE_CB_STATE' |
| 374 | elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name: |
| 375 | struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO' |
| 376 | class_name = self.get_class_name(struct_name) |
| 377 | elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name: |
| 378 | struct_name = 'XGL_QUEUE_SEMAPHORE_OPEN_INFO' |
| 379 | class_name = self.get_class_name(struct_name) |
| 380 | instance_name = "swc%i" % class_num |
| 381 | dp_funcs.append(" case %s:\n {" % (v)) |
| 382 | dp_funcs.append(" %s %s((%s*)pStruct);" % (class_name, instance_name, struct_name)) |
| 383 | dp_funcs.append(" %s.set_indent(indent);" % (instance_name)) |
| 384 | dp_funcs.append(" %s.display_full_txt();" % (instance_name)) |
| 385 | dp_funcs.append(" }") |
| 386 | dp_funcs.append(" break;") |
| 387 | class_num += 1 |
| 388 | dp_funcs.append(" }") |
| 389 | dp_funcs.append("}\n") |
| 390 | return "\n".join(dp_funcs) |
| 391 | |
| 392 | def _get_sh_func_name(self, struct): |
| 393 | return "%s_print_%s" % (self.api, struct.lower().strip("_")) |
| 394 | |
| 395 | # Return elements to create formatted string for given struct member |
| 396 | def _get_struct_print_formatted(self, struct_member, pre_var_name="prefix", postfix = "\\n", struct_var_name="pStruct", struct_ptr=True, print_array=False): |
| 397 | struct_op = "->" |
| 398 | if not struct_ptr: |
| 399 | struct_op = "." |
| 400 | member_name = struct_member['name'] |
| 401 | print_type = "p" |
| 402 | cast_type = "" |
| 403 | member_post = "" |
| 404 | array_index = "" |
| 405 | member_print_post = "" |
| 406 | if struct_member['array'] and 'CHAR' in struct_member['type']: # just print char array as string |
| 407 | print_type = "s" |
| 408 | print_array = False |
| 409 | elif struct_member['array'] and not print_array: |
| 410 | # Just print base address of array when not full print_array |
| 411 | cast_type = "(void*)" |
| 412 | elif is_type(struct_member['type'], 'enum'): |
| 413 | cast_type = "string_%s" % struct_member['type'] |
| 414 | print_type = "s" |
| 415 | elif is_type(struct_member['type'], 'struct'): # print struct address for now |
| 416 | cast_type = "(void*)" |
| 417 | if not struct_member['ptr']: |
| 418 | cast_type = "(void*)&" |
| 419 | elif 'BOOL' in struct_member['type']: |
| 420 | print_type = "s" |
| 421 | member_post = ' ? "TRUE" : "FALSE"' |
| 422 | elif 'FLOAT' in struct_member['type']: |
| 423 | print_type = "f" |
| 424 | elif 'UINT64' in struct_member['type']: |
| 425 | print_type = "lu" |
| 426 | elif 'UINT8' in struct_member['type']: |
| 427 | print_type = "hu" |
| 428 | elif True in [ui_str in struct_member['type'] for ui_str in ['UINT', '_SIZE', '_FLAGS', '_SAMPLE_MASK']]: |
| 429 | print_type = "u" |
| 430 | elif 'INT' in struct_member['type']: |
| 431 | print_type = "i" |
| 432 | elif struct_member['ptr']: |
| 433 | #cast_type = "" |
| 434 | pass |
| 435 | else: |
| 436 | #print("Unhandled struct type: %s" % struct_member['type']) |
| 437 | cast_type = "(void*)" |
| 438 | if print_array and struct_member['array']: |
| 439 | member_print_post = "[%u]" |
| 440 | array_index = " i," |
| 441 | member_post = "[i]" |
| 442 | print_out = "%%s%s%s = %%%s%s" % (member_name, member_print_post, print_type, postfix) # section of print that goes inside of quotes |
| 443 | print_arg = ", %s,%s %s(%s%s%s)%s" % (pre_var_name, array_index, cast_type, struct_var_name, struct_op, member_name, member_post) # section of print passed to portion in quotes |
| 444 | return (print_out, print_arg) |
| 445 | |
| 446 | def _generateStringHelperFunctions(self): |
| 447 | sh_funcs = [] |
| 448 | for s in self.struct_dict: |
| 449 | p_out = "" |
| 450 | p_args = "" |
| 451 | # This isn't great but this pre-pass counts chars in struct members and flags structs w/ pNext |
| 452 | struct_char_count = 0 # TODO : Use this to vary size of memory allocations for strings? |
| 453 | has_pnext = False |
| 454 | for m in self.struct_dict[s]: |
| 455 | if 'pNext' == self.struct_dict[s][m]['name']: |
| 456 | has_pnext = True |
| 457 | struct_char_count += len(self.struct_dict[s][m]['name']) + 32 |
| 458 | if 'graphics_pipeline_create' in s.lower(): # this is small struct w/ potentially large struct chain so bump it up |
| 459 | struct_char_count = 300 |
| 460 | sh_funcs.append('char* %s(const %s* pStruct, const char* prefix)\n{\n char* str;\n' % (self._get_sh_func_name(s), typedef_fwd_dict[s])) |
| 461 | # when we have a pnext, have to handle dynamically printing struct trees |
| 462 | extra_indent = '' |
| 463 | if has_pnext: |
| 464 | sh_funcs.append(' if (!pStruct->pNext) {\n') |
| 465 | extra_indent = ' ' |
| 466 | sh_funcs.append(' %sstr = (char*)malloc(sizeof(char)*1024);\n' % (extra_indent)) |
| 467 | sh_funcs.append(' %ssprintf(str, "' % (extra_indent)) |
| 468 | for m in sorted(self.struct_dict[s]): |
| 469 | (p_out1, p_args1) = self._get_struct_print_formatted(self.struct_dict[s][m]) |
| 470 | p_out += p_out1 |
| 471 | p_args += p_args1 |
| 472 | # Store values up to this point to re-use in case of pnext below |
| 473 | tmp_p_out = p_out |
| 474 | tmp_p_args = p_args |
| 475 | p_out += '"' |
| 476 | p_args += ");\n" |
| 477 | sh_funcs.append(p_out) |
| 478 | sh_funcs.append(p_args) |
| 479 | if has_pnext: |
| 480 | tmp_p_out += ' %spNext (%p)\\n%s\\n"' |
| 481 | tmp_p_args += ", prefix, (void*)pStruct->pNext, pTmpStr);\n" |
| 482 | sh_funcs.append(' } else {\n') |
| 483 | sh_funcs.append(' str = (char*)malloc(sizeof(char)*2048);\n') |
| 484 | sh_funcs.append(' char *pTmpStr = dynamic_display((XGL_VOID*)pStruct->pNext, prefix);\n') |
| 485 | sh_funcs.append(' sprintf(str, "') |
| 486 | sh_funcs.append('%s%s' % (tmp_p_out, tmp_p_args)) |
| 487 | sh_funcs.append(' free(pTmpStr);\n') |
| 488 | sh_funcs.append(' }\n') |
| 489 | sh_funcs.append(" return str;\n}\n") |
| 490 | # Add function to dynamically print out unknown struct |
| 491 | sh_funcs.append("char* dynamic_display(const XGL_VOID* pStruct, const char* prefix)\n{\n") |
| 492 | sh_funcs.append(" // Cast to APP_INFO ptr initially just to pull sType off struct\n") |
| 493 | sh_funcs.append(" XGL_STRUCTURE_TYPE sType = ((XGL_APPLICATION_INFO*)pStruct)->sType;\n") |
| 494 | sh_funcs.append(' char indent[100];\n strcpy(indent, " ");\n strcat(indent, prefix);\n') |
| 495 | sh_funcs.append(" switch (sType)\n {\n") |
| 496 | for e in enum_type_dict: |
| 497 | if "_STRUCTURE_TYPE" in e: |
| 498 | for v in sorted(enum_type_dict[e]): |
| 499 | struct_name = v.replace("_STRUCTURE_TYPE", "") |
| 500 | print_func_name = self._get_sh_func_name(struct_name) |
| 501 | # TODO : Hand-coded fixes for some exceptions |
| 502 | if 'XGL_PIPELINE_CB_STATE_CREATE_INFO' in struct_name: |
| 503 | struct_name = 'XGL_PIPELINE_CB_STATE' |
| 504 | elif 'XGL_SEMAPHORE_CREATE_INFO' in struct_name: |
| 505 | struct_name = 'XGL_QUEUE_SEMAPHORE_CREATE_INFO' |
| 506 | print_func_name = self._get_sh_func_name(struct_name) |
| 507 | elif 'XGL_SEMAPHORE_OPEN_INFO' in struct_name: |
| 508 | struct_name = 'XGL_QUEUE_SEMAPHORE_OPEN_INFO' |
| 509 | print_func_name = self._get_sh_func_name(struct_name) |
| 510 | sh_funcs.append(' case %s:\n {\n' % (v)) |
| 511 | sh_funcs.append(' return %s((%s*)pStruct, indent);\n' % (print_func_name, struct_name)) |
| 512 | sh_funcs.append(' }\n') |
| 513 | sh_funcs.append(' break;\n') |
| 514 | sh_funcs.append(" }\n") |
| 515 | sh_funcs.append("}") |
| 516 | return "".join(sh_funcs) |
| 517 | |
| 518 | |
| 519 | def _genStructMemberPrint(self, member, s, array, struct_array): |
| 520 | (p_out, p_arg) = self._get_struct_print_formatted(self.struct_dict[s][member], pre_var_name="&m_dummy_prefix", struct_var_name="m_struct", struct_ptr=False, print_array=True) |
| 521 | extra_indent = "" |
| 522 | if array: |
| 523 | extra_indent = " " |
| 524 | if is_type(self.struct_dict[s][member]['type'], 'struct'): # print struct address for now |
| 525 | struct_array.insert(0, self.struct_dict[s][member]) |
| 526 | elif self.struct_dict[s][member]['ptr']: |
| 527 | # Special case for VOID* named "pNext" |
| 528 | if "VOID" in self.struct_dict[s][member]['type'] and "pNext" == self.struct_dict[s][member]['name']: |
| 529 | struct_array.insert(0, self.struct_dict[s][member]) |
| 530 | return (' %sprintf("%%*s %s", m_indent, ""%s);' % (extra_indent, p_out, p_arg), struct_array) |
| 531 | |
| 532 | def _generateDisplayDefinitions(self, s): |
| 533 | disp_def = [] |
| 534 | struct_array = [] |
| 535 | # Single-line struct print function |
| 536 | disp_def.append("// Output 'structname = struct_address' on a single line") |
| 537 | disp_def.append("void %s::display_single_txt()\n{" % self.get_class_name(s)) |
| 538 | disp_def.append(' printf(" %%*s%s = %%p", m_indent, "", (void*)m_origStructAddr);' % typedef_fwd_dict[s]) |
| 539 | disp_def.append("}\n") |
| 540 | # Private helper function to print struct members |
| 541 | disp_def.append("// Private helper function that displays the members of the wrapped struct") |
| 542 | disp_def.append("void %s::display_struct_members()\n{" % self.get_class_name(s)) |
| 543 | i_declared = False |
| 544 | for member in sorted(self.struct_dict[s]): |
| 545 | # TODO : Need to display each member based on its type |
| 546 | # TODO : Need to handle pNext which are structs, but of XGL_VOID* type |
| 547 | # Can grab struct type off of header of struct pointed to |
| 548 | # TODO : Handle Arrays |
| 549 | if self.struct_dict[s][member]['array']: |
| 550 | # Create for loop to print each element of array |
| 551 | if not i_declared: |
| 552 | disp_def.append(' uint32_t i;') |
| 553 | i_declared = True |
| 554 | disp_def.append(' for (i = 0; i<%s; i++) {' % self.struct_dict[s][member]['array_size']) |
| 555 | (return_str, struct_array) = self._genStructMemberPrint(member, s, True, struct_array) |
| 556 | disp_def.append(return_str) |
| 557 | disp_def.append(' }') |
| 558 | else: |
| 559 | (return_str, struct_array) = self._genStructMemberPrint(member, s, False, struct_array) |
| 560 | disp_def.append(return_str) |
| 561 | disp_def.append("}\n") |
| 562 | i_declared = False |
| 563 | # Basic print function to display struct members |
| 564 | disp_def.append("// Output all struct elements, each on their own line") |
| 565 | disp_def.append("void %s::display_txt()\n{" % self.get_class_name(s)) |
| 566 | disp_def.append(' printf("%%*s%s struct contents at %%p:\\n", m_indent, "", (void*)m_origStructAddr);' % typedef_fwd_dict[s]) |
| 567 | disp_def.append(' this->display_struct_members();') |
| 568 | disp_def.append("}\n") |
| 569 | # Advanced print function to display current struct and contents of any pointed-to structs |
| 570 | disp_def.append("// Output all struct elements, and for any structs pointed to, print complete contents") |
| 571 | disp_def.append("void %s::display_full_txt()\n{" % self.get_class_name(s)) |
| 572 | disp_def.append(' printf("%%*s%s struct contents at %%p:\\n", m_indent, "", (void*)m_origStructAddr);' % typedef_fwd_dict[s]) |
| 573 | disp_def.append(' this->display_struct_members();') |
| 574 | class_num = 0 |
| 575 | # TODO : Need to handle arrays of structs here |
| 576 | for ms in struct_array: |
| 577 | swc_name = "class%s" % str(class_num) |
| 578 | if ms['array']: |
| 579 | if not i_declared: |
| 580 | disp_def.append(' uint32_t i;') |
| 581 | i_declared = True |
| 582 | disp_def.append(' for (i = 0; i<%s; i++) {' % ms['array_size']) |
| 583 | #disp_def.append(" if (m_struct.%s[i]) {" % (ms['name'])) |
| 584 | disp_def.append(" %s %s(&(m_struct.%s[i]));" % (self.get_class_name(ms['type']), swc_name, ms['name'])) |
| 585 | disp_def.append(" %s.set_indent(m_indent + 4);" % (swc_name)) |
| 586 | disp_def.append(" %s.display_full_txt();" % (swc_name)) |
| 587 | #disp_def.append(' }') |
| 588 | disp_def.append(' }') |
| 589 | elif 'pNext' == ms['name']: |
| 590 | # Need some code trickery here |
| 591 | # I'm thinking have a generated function that takes pNext ptr value |
| 592 | # then it checks sType and in large switch statement creates appropriate |
| 593 | # wrapper class type and then prints contents |
| 594 | disp_def.append(" if (m_struct.%s) {" % (ms['name'])) |
| 595 | #disp_def.append(' printf("%*s This is where we would call dynamic print function\\n", m_indent, "");') |
| 596 | disp_def.append(' dynamic_display_full_txt(m_struct.%s, m_indent);' % (ms['name'])) |
| 597 | disp_def.append(" }") |
| 598 | else: |
| 599 | if ms['ptr']: |
| 600 | disp_def.append(" if (m_struct.%s) {" % (ms['name'])) |
| 601 | disp_def.append(" %s %s(m_struct.%s);" % (self.get_class_name(ms['type']), swc_name, ms['name'])) |
| 602 | else: |
| 603 | disp_def.append(" if (&m_struct.%s) {" % (ms['name'])) |
| 604 | disp_def.append(" %s %s(&m_struct.%s);" % (self.get_class_name(ms['type']), swc_name, ms['name'])) |
| 605 | disp_def.append(" %s.set_indent(m_indent + 4);" % (swc_name)) |
| 606 | disp_def.append(" %s.display_full_txt();\n }" % (swc_name)) |
| 607 | class_num += 1 |
| 608 | disp_def.append("}\n") |
| 609 | return "\n".join(disp_def) |
| 610 | |
| 611 | def _generateStringHelperHeader(self): |
| 612 | header = [] |
| 613 | header.append("//#includes, #defines, globals and such...\n") |
| 614 | for f in self.include_headers: |
| 615 | if 'xgl_string_helper' not in f: |
| 616 | header.append("#include <%s>\n" % f) |
| 617 | header.append('#include "xgl_string_helper.h"\n\n// Prototype for dynamic print function\n') |
| 618 | header.append("char* dynamic_display(const XGL_VOID* pStruct, const char* prefix);\n") |
| 619 | return "".join(header) |
| 620 | |
| 621 | def _generateHeader(self): |
| 622 | header = [] |
| 623 | header.append("//#includes, #defines, globals and such...\n") |
| 624 | for f in self.include_headers: |
| 625 | header.append("#include <%s>\n" % f) |
| 626 | return "".join(header) |
| 627 | |
| 628 | # Declarations |
| 629 | def _generateConstructorDeclarations(self, s): |
| 630 | constructors = [] |
| 631 | constructors.append(" %s();\n" % self.get_class_name(s)) |
| 632 | constructors.append(" %s(%s* pInStruct);\n" % (self.get_class_name(s), typedef_fwd_dict[s])) |
| 633 | constructors.append(" %s(const %s* pInStruct);\n" % (self.get_class_name(s), typedef_fwd_dict[s])) |
| 634 | return "".join(constructors) |
| 635 | |
| 636 | def _generateDestructorDeclarations(self, s): |
| 637 | return " virtual ~%s();\n" % self.get_class_name(s) |
| 638 | |
| 639 | def _generateDisplayDeclarations(self, s): |
| 640 | return " void display_txt();\n void display_single_txt();\n void display_full_txt();\n" |
| 641 | |
| 642 | def _generateGetSetDeclarations(self, s): |
| 643 | get_set = [] |
| 644 | get_set.append(" void set_indent(uint32_t indent) { m_indent = indent; }\n") |
| 645 | for member in sorted(self.struct_dict[s]): |
| 646 | # TODO : Skipping array set/get funcs for now |
| 647 | if self.struct_dict[s][member]['array']: |
| 648 | continue |
| 649 | get_set.append(" %s get_%s() { return m_struct.%s; }\n" % (self.struct_dict[s][member]['full_type'], self.struct_dict[s][member]['name'], self.struct_dict[s][member]['name'])) |
| 650 | if not self.struct_dict[s][member]['const']: |
| 651 | get_set.append(" void set_%s(%s inValue) { m_struct.%s = inValue; }\n" % (self.struct_dict[s][member]['name'], self.struct_dict[s][member]['full_type'], self.struct_dict[s][member]['name'])) |
| 652 | return "".join(get_set) |
| 653 | |
| 654 | def _generatePrivateMembers(self, s): |
| 655 | priv = [] |
| 656 | priv.append("\nprivate:\n") |
| 657 | priv.append(" %s m_struct;\n" % typedef_fwd_dict[s]) |
| 658 | priv.append(" const %s* m_origStructAddr;\n" % typedef_fwd_dict[s]) |
| 659 | priv.append(" uint32_t m_indent;\n") |
| 660 | priv.append(" const char m_dummy_prefix;\n") |
| 661 | priv.append(" void display_struct_members();\n") |
| 662 | return "".join(priv) |
| 663 | |
| 664 | def _generateClassDeclaration(self): |
| 665 | class_decl = [] |
| 666 | for s in self.struct_dict: |
| 667 | class_decl.append("\n//class declaration") |
| 668 | class_decl.append("class %s\n{\npublic:" % self.get_class_name(s)) |
| 669 | class_decl.append(self._generateConstructorDeclarations(s)) |
| 670 | class_decl.append(self._generateDestructorDeclarations(s)) |
| 671 | class_decl.append(self._generateDisplayDeclarations(s)) |
| 672 | class_decl.append(self._generateGetSetDeclarations(s)) |
| 673 | class_decl.append(self._generatePrivateMembers(s)) |
| 674 | class_decl.append("};\n") |
| 675 | return "\n".join(class_decl) |
| 676 | |
| 677 | def _generateFooter(self): |
| 678 | return "\n//any footer info for class\n" |
| 679 | |
| 680 | class EnumCodeGen: |
| 681 | def __init__(self, enum_type_dict=None, enum_val_dict=None, typedef_fwd_dict=None, in_file=None, out_file=None): |
| 682 | self.et_dict = enum_type_dict |
| 683 | self.ev_dict = enum_val_dict |
| 684 | self.tf_dict = typedef_fwd_dict |
| 685 | self.in_file = in_file |
| 686 | self.out_file = out_file |
| 687 | self.efg = CommonFileGen(self.out_file) |
| 688 | |
| 689 | def generateStringHelper(self): |
| 690 | self.efg.setHeader(self._generateSHHeader()) |
| 691 | self.efg.setBody(self._generateSHBody()) |
| 692 | self.efg.generate() |
| 693 | |
| 694 | def _generateSHBody(self): |
| 695 | body = [] |
| 696 | # with open(self.out_file, "a") as hf: |
| 697 | # bet == base_enum_type, fet == final_enum_type |
| 698 | for bet in self.et_dict: |
| 699 | fet = self.tf_dict[bet] |
| 700 | body.append("static const char* string_%s(%s input_value)\n{\n switch ((%s)input_value)\n {\n" % (fet, fet, fet)) |
| 701 | for e in sorted(self.et_dict[bet]): |
| 702 | if (self.ev_dict[e]['unique']): |
| 703 | body.append(' case %s:\n return "%s";\n' % (e, e)) |
| 704 | body.append(' default:\n return "Unhandled %s";\n }\n return "Unhandled %s";\n}\n\n' % (fet, fet)) |
| 705 | return "\n".join(body) |
| 706 | |
| 707 | def _generateSHHeader(self): |
| 708 | return "#pragma once\n\n#include <%s>\n\n" % self.in_file |
| 709 | |
| 710 | |
| 711 | class CMakeGen: |
| 712 | def __init__(self, struct_wrapper=None, out_dir=None): |
| 713 | self.sw = struct_wrapper |
| 714 | self.add_lib_file_list = self.sw.get_file_list() |
| 715 | self.out_dir = out_dir |
| 716 | self.out_file = os.path.join(self.out_dir, "CMakeLists.txt") |
| 717 | self.cmg = CommonFileGen(self.out_file) |
| 718 | |
| 719 | def generate(self): |
| 720 | self.cmg.setBody(self._generateBody()) |
| 721 | self.cmg.generate() |
| 722 | |
| 723 | def _generateBody(self): |
| 724 | body = [] |
| 725 | body.append("project(%s)" % os.path.basename(self.out_dir)) |
| 726 | body.append("cmake_minimum_required(VERSION 2.8)\n") |
| 727 | body.append("add_library(${PROJECT_NAME} %s)\n" % " ".join(self.add_lib_file_list)) |
| 728 | body.append('set(COMPILE_FLAGS "-fpermissive")') |
| 729 | body.append('set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COMPILE_FLAGS}")\n') |
| 730 | body.append("include_directories(${SRC_DIR}/thirdparty/${GEN_API}/inc/)\n") |
| 731 | body.append("target_include_directories (%s PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})\n" % os.path.basename(self.out_dir)) |
| 732 | return "\n".join(body) |
| 733 | |
| 734 | class GraphVizGen: |
| 735 | def __init__(self, struct_dict=None): |
| 736 | self.struc_dict = struct_dict |
| 737 | self.out_file = os.path.join(os.getcwd(), "struct_gv.dot") |
| 738 | self.gvg = CommonFileGen(self.out_file) |
| 739 | |
| 740 | def generate(self): |
| 741 | self.gvg.setHeader(self._generateHeader()) |
| 742 | self.gvg.setBody(self._generateBody()) |
| 743 | self.gvg.setFooter('}') |
| 744 | self.gvg.generate() |
| 745 | |
| 746 | def _generateHeader(self): |
| 747 | hdr = [] |
| 748 | hdr.append('digraph g {\ngraph [\nrankdir = "LR"\n];') |
| 749 | hdr.append('node [\nfontsize = "16"\nshape = "plaintext"\n];') |
| 750 | hdr.append('edge [\n];\n') |
| 751 | return "\n".join(hdr) |
| 752 | |
| 753 | def _generateBody(self): |
| 754 | body = [] |
| 755 | for s in self.struc_dict: |
| 756 | field_num = 1 |
| 757 | body.append('"%s" [\nlabel = <<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0"> <TR><TD COLSPAN="2" PORT="f0">%s</TD></TR>' % (s, typedef_fwd_dict[s])) |
| 758 | for m in sorted(self.struc_dict[s]): |
| 759 | body.append('<TR><TD PORT="f%i">%s</TD><TD PORT="f%i">%s</TD></TR>' % (field_num, self.struc_dict[s][m]['full_type'], field_num+1, self.struc_dict[s][m]['name'])) |
| 760 | field_num += 2 |
| 761 | body.append('</TABLE>>\n];\n') |
| 762 | return "".join(body) |
| 763 | |
| 764 | |
| 765 | def main(argv=None): |
| 766 | opts = handle_args() |
| 767 | # Parse input file and fill out global dicts |
| 768 | hfp = HeaderFileParser(opts.input_file) |
| 769 | hfp.parse() |
| 770 | # TODO : Don't want these to be global, see note at top about wrapper classes |
| 771 | global enum_val_dict |
| 772 | global enum_type_dict |
| 773 | global struct_dict |
| 774 | global typedef_fwd_dict |
| 775 | global typedef_rev_dict |
| 776 | global types_dict |
| 777 | enum_val_dict = hfp.get_enum_val_dict() |
| 778 | enum_type_dict = hfp.get_enum_type_dict() |
| 779 | struct_dict = hfp.get_struct_dict() |
| 780 | typedef_fwd_dict = hfp.get_typedef_fwd_dict() |
| 781 | typedef_rev_dict = hfp.get_typedef_rev_dict() |
| 782 | types_dict = hfp.get_types_dict() |
| 783 | #print(enum_val_dict) |
| 784 | #print(typedef_dict) |
| 785 | #print(struct_dict) |
| 786 | if (opts.abs_out_dir is not None): |
| 787 | enum_filename = os.path.join(opts.abs_out_dir, os.path.basename(opts.input_file).strip(".h")+"_string_helper.h") |
| 788 | else: |
| 789 | enum_filename = os.path.join(os.getcwd(), opts.rel_out_dir, os.path.basename(opts.input_file).strip(".h")+"_string_helper.h") |
| 790 | enum_filename = os.path.abspath(enum_filename) |
| 791 | if not os.path.exists(os.path.dirname(enum_filename)): |
| 792 | print("Creating output dir %s" % os.path.dirname(enum_filename)) |
| 793 | os.mkdir(os.path.dirname(enum_filename)) |
| 794 | if opts.gen_enum_string_helper: |
| 795 | print("Generating enum string helper to %s" % enum_filename) |
| 796 | eg = EnumCodeGen(enum_type_dict, enum_val_dict, typedef_fwd_dict, os.path.basename(opts.input_file), enum_filename) |
| 797 | eg.generateStringHelper() |
| 798 | #for struct in struct_dict: |
| 799 | #print(struct) |
| 800 | if opts.gen_struct_wrappers: |
| 801 | sw = StructWrapperGen(struct_dict, os.path.basename(opts.input_file).strip(".h"), os.path.dirname(enum_filename)) |
| 802 | #print(sw.get_class_name(struct)) |
| 803 | sw.set_include_headers([os.path.basename(opts.input_file),os.path.basename(enum_filename),"stdint.h","stdio.h","stdlib.h"]) |
| 804 | print("Generating struct wrapper header to %s" % sw.header_filename) |
| 805 | sw.generateHeader() |
| 806 | print("Generating struct wrapper class to %s" % sw.class_filename) |
| 807 | sw.generateBody() |
| 808 | sw.generateStringHelper() |
| 809 | if opts.gen_cmake: |
| 810 | cmg = CMakeGen(sw, os.path.dirname(enum_filename)) |
| 811 | cmg.generate() |
| 812 | if opts.gen_graphviz: |
| 813 | gv = GraphVizGen(struct_dict) |
| 814 | gv.generate() |
| 815 | print("DONE!") |
| 816 | #print(typedef_rev_dict) |
| 817 | #print(types_dict) |
| 818 | #recreate_structs() |
| 819 | |
| 820 | if __name__ == "__main__": |
| 821 | sys.exit(main()) |
| 822 | |
| 823 | |
| 824 | ## Example class for GR_APPLICATION_INFO struct |
| 825 | ##include <mantle.h> |
| 826 | # |
| 827 | #class gr_application_info_struct_wrapper { |
| 828 | #public: |
| 829 | # // Constructors |
| 830 | # gr_application_info_struct_wrapper(); |
| 831 | # gr_application_info_struct_wrapper(GR_APPLICATION_INFO* pInStruct); |
| 832 | # // Destructor |
| 833 | # virtual ~gr_application_info_struct_wrapper(); |
| 834 | # |
| 835 | # void display_txt() |
| 836 | # // get functions |
| 837 | # // set functions for every non-const struct member |
| 838 | # |
| 839 | #private: |
| 840 | # GR_APPLICATION_INFO m_struct; |
| 841 | #}; |
| 842 | # |
| 843 | #gr_application_info_struct_wrapper::gr_application_info_struct_wrapper() : m_struct() {} |
| 844 | # |
| 845 | #// Output struct address on single line |
| 846 | #gr_application_info_struct_wrapper::display_single_txt() |
| 847 | #{ |
| 848 | # printf(" GR_APPLICATION_INFO = %p", &m_struct); |
| 849 | #} |
| 850 | #// Output struct in txt format |
| 851 | #gr_application_info_struct_wrapper::display_txt() |
| 852 | #{ |
| 853 | # printf("GR_APPLICATION_INFO struct contents:\n"); |
| 854 | # printf(" pAppName: %s\n", m_struct.pAppName); |
| 855 | # printf(" appVersion: %i\n", m_struct.appVersion); |
| 856 | # printf(" pEngineNmae: %s\n", m_struct.pEngineName); |
| 857 | # printf(" engineVersion: %i\n", m_struct.engineVersion); |
| 858 | # printf(" apiVersion: %i\n", m_struct.apiVersion); |
| 859 | #} |
| 860 | #// Output struct including detailed info on pointed-to structs |
| 861 | #gr_application_info_struct_wrapper::display_full_txt() |
| 862 | #{ |
| 863 | # |
| 864 | # printf("%*s%GR_APPLICATION_INFO struct contents:\n", indent, ""); |
| 865 | # printf(" pAppName: %s\n", m_struct.pAppName); |
| 866 | # printf(" appVersion: %i\n", m_struct.appVersion); |
| 867 | # printf(" pEngineNmae: %s\n", m_struct.pEngineName); |
| 868 | # printf(" engineVersion: %i\n", m_struct.engineVersion); |
| 869 | # printf(" apiVersion: %i\n", m_struct.apiVersion); |
| 870 | #} |
| 871 | |
| 872 | |
| 873 | # Example of helper function to pretty-print enum info |
| 874 | #static const char* string_GR_RESULT_CODE(GR_RESULT result) |
| 875 | #{ |
| 876 | # switch ((GR_RESULT_CODE)result) |
| 877 | # { |
| 878 | # // Return codes for successful operation execution |
| 879 | # case GR_SUCCESS: |
| 880 | # return "GR_SUCCESS"; |
| 881 | # case GR_UNSUPPORTED: |
| 882 | # return "GR_UNSUPPORTED"; |
| 883 | # case GR_NOT_READY: |
| 884 | # return "GR_NOT_READY"; |
| 885 | # case GR_TIMEOUT: |
| 886 | # return "GR_TIMEOUT"; |
| 887 | # } |
| 888 | # return "Unhandled GR_RESULT_CODE"; |
| 889 | #} |
| 890 | |
| 891 | # Dynamic print function |
| 892 | # void dynamic_display_full_txt(XGL_STRUCTURE_TYPE sType, void* pStruct, uint32_t indent) |
| 893 | # { |
| 894 | # switch (sType) |
| 895 | # { |
| 896 | # case XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO: |
| 897 | # xgl_color_blend_state_create_info_struct_wrapper swc((XGL_COLOR_BLEND_STATE_CREATE_INFO*)pStruct); |
| 898 | # swc.set_indent(indent); |
| 899 | # swc.display_full_txt(); |
| 900 | # } |
| 901 | # } |