def parse_types_from_source(self,
source,
filename=None,
include_dirs=[],
auto_type_source=None):
"""
``parse_types_from_source`` parses the source string and any needed headers searching for them in
the optional list of directories provided in ``include_dirs``.
:param str source: source string to be parsed
:param str filename: optional source filename
:param list(str) include_dirs: optional list of string filename include directories
:param str auto_type_source: optional source of types if used for automatically generated types
:return: :py:class:`TypeParserResult` (a SyntaxError is thrown on parse error)
:rtype: TypeParserResult
:Example:
>>> platform.parse_types_from_source('int foo;\\nint bar(int x);\\nstruct bas{int x,y;};\\n')
({types: {'bas': <type: struct bas>}, variables: {'foo': <type: int32_t>}, functions:{'bar':
<type: int32_t(int32_t x)>}}, '')
>>>
"""
if filename is None:
filename = "input"
dir_buf = (ctypes.c_char_p * len(include_dirs))()
for i in range(0, len(include_dirs)):
dir_buf[i] = include_dirs[i].encode('charmap')
parse = core.BNTypeParserResult()
errors = ctypes.c_char_p()
result = core.BNParseTypesFromSource(self.handle, source, filename,
parse, errors, dir_buf,
len(include_dirs),
auto_type_source)
error_str = errors.value
core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte)))
if not result:
raise SyntaxError(error_str)
type_dict = {}
variables = {}
functions = {}
for i in range(0, parse.typeCount):
name = types.QualifiedName._from_core_struct(parse.types[i].name)
type_dict[name] = types.Type(core.BNNewTypeReference(
parse.types[i].type),
platform=self)
for i in range(0, parse.variableCount):
name = types.QualifiedName._from_core_struct(
parse.variables[i].name)
variables[name] = types.Type(core.BNNewTypeReference(
parse.variables[i].type),
platform=self)
for i in range(0, parse.functionCount):
name = types.QualifiedName._from_core_struct(
parse.functions[i].name)
functions[name] = types.Type(core.BNNewTypeReference(
parse.functions[i].type),
platform=self)
core.BNFreeTypeParserResult(parse)
return types.TypeParserResult(type_dict, variables, functions)
def parse_types_from_source(
self,
source: str,
file_name: str,
platform: 'platform.Platform',
existing_types: Optional[List[QualifiedNameTypeAndId]] = None,
options: Optional[List[str]] = None,
include_dirs: Optional[List[str]] = None,
auto_type_source: str = ""
) -> Tuple[Optional[TypeParserResult], List[TypeParserError]]:
if existing_types is None:
existing_types = []
if options is None:
options = []
if include_dirs is None:
include_dirs = []
existing_types_cpp = (core.BNQualifiedNameTypeAndId *
len(existing_types))()
for (i, qnatid) in enumerate(existing_types):
existing_types_cpp[i] = qnatid._to_core_struct()
options_cpp = (ctypes.c_char_p * len(options))()
for (i, s) in enumerate(options):
options_cpp[i] = core.cstr(s)
include_dirs_cpp = (ctypes.c_char_p * len(include_dirs))()
for (i, s) in enumerate(include_dirs):
include_dirs_cpp[i] = core.cstr(s)
result_cpp = core.BNTypeParserResult()
errors_cpp = ctypes.POINTER(core.BNTypeParserError)()
error_count = ctypes.c_size_t()
success = core.BNTypeParserParseTypesFromSource(
self.handle,
source, file_name, platform.handle, existing_types_cpp,
len(existing_types), options_cpp, len(options), include_dirs_cpp,
len(include_dirs), auto_type_source, result_cpp, errors_cpp,
error_count)
if success:
result = TypeParserResult._from_core_struct(result_cpp)
else:
result = None
core.BNFreeTypeParserResult(result_cpp)
errors = []
for i in range(error_count.value):
errors.append(TypeParserError._from_core_struct(errors_cpp[i]))
core.BNFreeTypeParserErrors(errors_cpp, error_count.value)
return result, errors
def parse_types_from_source_file(self, filename, include_dirs=[], auto_type_source=None):
"""
``parse_types_from_source_file`` parses the source file ``filename`` and any needed headers searching for them in
the optional list of directories provided in ``include_dirs``.
:param str filename: filename of file to be parsed
:param include_dirs: optional list of string filename include directories
:type include_dirs: list(str)
:param str auto_type_source: optional source of types if used for automatically generated types
:return: :py:class:`TypeParserResult` (a SyntaxError is thrown on parse error)
:rtype: TypeParserResult
:Example:
>>> file = "/Users/binja/tmp.c"
>>> open(file).read()
'int foo;\\nint bar(int x);\\nstruct bas{int x,y;};\\n'
>>> platform.parse_types_from_source_file(file)
({types: {'bas': <type: struct bas>}, variables: {'foo': <type: int32_t>}, functions:
{'bar': <type: int32_t(int32_t x)>}}, '')
>>>
"""
if not (isinstance(filename, str) and os.path.isfile(filename) and os.access(filename, os.R_OK)):
raise AttributeError("File {} doesn't exist or isn't readable".format(filename))
dir_buf = (ctypes.c_char_p * len(include_dirs))()
for i in range(0, len(include_dirs)):
dir_buf[i] = include_dirs[i].encode('charmap')
parse = core.BNTypeParserResult()
errors = ctypes.c_char_p()
result = core.BNParseTypesFromSourceFile(self.handle, filename, parse, errors, dir_buf,
len(include_dirs), auto_type_source)
error_str = errors.value.decode("utf-8")
core.BNFreeString(ctypes.cast(errors, ctypes.POINTER(ctypes.c_byte)))
if not result:
raise SyntaxError(error_str)
type_dict = {}
variables = {}
functions = {}
for i in range(0, parse.typeCount):
name = types.QualifiedName._from_core_struct(parse.types[i].name)
type_dict[name] = types.Type(core.BNNewTypeReference(parse.types[i].type), platform = self)
for i in range(0, parse.variableCount):
name = types.QualifiedName._from_core_struct(parse.variables[i].name)
variables[name] = types.Type(core.BNNewTypeReference(parse.variables[i].type), platform = self)
for i in range(0, parse.functionCount):
name = types.QualifiedName._from_core_struct(parse.functions[i].name)
functions[name] = types.Type(core.BNNewTypeReference(parse.functions[i].type), platform = self)
core.BNFreeTypeParserResult(parse)
return types.TypeParserResult(type_dict, variables, functions)
def _to_core_struct(self) -> core.BNTypeParserResult:
result = core.BNTypeParserResult()
result.typeCount = len(self.types)
result.variableCount = len(self.variables)
result.functionCount = len(self.functions)
result.types = (core.BNParsedType * len(self.types))()
result.variables = (core.BNParsedType * len(self.variables))()
result.functions = (core.BNParsedType * len(self.functions))()
for (i, type) in enumerate(self.types):
result.types[i] = type._to_core_struct()
for (i, variable) in enumerate(self.variables):
result.variables[i] = variable._to_core_struct()
for (i, function) in enumerate(self.functions):
result.functions[i] = function._to_core_struct()
return result