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
