def generate_input(self, type_name, var_name, recursive_count=1): result = '' type_component = typeutil.parse_type(type_name) base = type_component['base'] pointer = type_component['pointer'] array = type_component['array'] if array: if config.get('handle_array') == 'true': return self.generate_input_for_array(type_name, var_name) else: return '' # alloc if pointer: # char array should be treated separately if config.get('handle_array') == 'true' and base == 'char': result += self.generate_input_for_array('char[]', var_name+'_array') result += var_name +' = '+var_name + '_array;\n' return result; result += generate_alloc_string(type_name, var_name) # init if typeutil.is_primitive_type(base): result += generate_primitive_input(type_name, var_name) elif local.check_struct_or_typedef(base.replace('struct','').strip()): if config.get('handle_struct') != 'true': return '' code = local.resolve_single_simple(base.replace('struct','').strip(), t='st') if '{' in code.strip() and code.strip().startswith('typedef struct'): code = code.replace('typedef','').strip() code = code[:code.rfind('}')+1] + ';' result += self.generate_input_for_struct(type_name, var_name, code, recursive_count) elif code.strip().startswith('struct'): result += self.generate_input_for_struct(type_name, var_name, code, recursive_count) elif code.startswith('typedef'): if code.startswith('typedef struct'): code = local.resolve_single_simple(base.replace('struct', '').strip(), t='s') if code: result += self.generate_input_for_struct(type_name, var_name, code, recursive_count) else: _,original = syntaxutil.parse_typedef_code(code) result += self.generate_input(original+pointer+array, var_name, recursive_count) else: logger.warning('Not recognized code for generate input') else: sys_type = systype.resolve(base) if sys_type: result += self.generate_input(sys_type+pointer+array, var_name) else: logger.warning('the type '+type_name+' is not solved for init') return result
def build(function_node): _,func_name, fields = syntaxutil.parse_function(function_node) code = '' function_code = domutil.get_text_content(function_node) instrumented_function = function_code[:function_code.find('{')+1]+'\nprintf("%d ", 1);\n'+function_code[function_code.find('{')+1:] code += includes code += instrumented_function code += '\nint main() {\n' for type_name, var_name in fields: code += type_name + ' ' + var_name + ';\n' # if typeutil.is_primitive_type(type_name) type_component = typeutil.parse_type(type_name) if typeutil.is_primitive_type(type_component['base']): code += instrumenter.generate_primitive_input(type_name, var_name) code += func_name + '(' + ','.join([var for _,var in fields]) + ');\n' code += '}\n' return code
def generate_input_for_array(self, type_name, var_name): result = '' type_component = typeutil.parse_type(type_name) base = type_component['base'] # now only support primitive type if not typeutil.is_primitive_type(base): return result # now only support char array if base != 'char': return result # Only support one dimension array if not self.helium_size_defined: result += 'int helium_size;\n' self.helium_size_defined = True result += 'scanf("%d", &helium_size);\n' result += base +' '+ var_name + '[helium_size];\n' # result += 'for (int i=0;i<helium_size;i++) {\n' # var_name = var_name + '[i]' # result += self.generate_input(base, var_name) # result += '}\n' result += 'scanf("%s", '+var_name+');\n' return result
def resolve(name): """ :param name: uint8_t :return "unsigned char" """ match = re.findall(r"\n" + re.escape(name) + r"\s.*\st", this["tag_file"]) results = [] for line in match: # line = line.strip() match = re.search(r"typedef .*" + name + ";", line) if match: typedef = match.group() to_type = " ".join(typedef.split()[1:-1]) if typeutil.is_primitive_type(to_type): return to_type else: results.append(to_type) # self.resolve(to_type) for to_type in results: result = resolve(to_type) if result: return result return None