435 lines
13 KiB
Python
435 lines
13 KiB
Python
import logging
|
|
from collections import defaultdict
|
|
from dataclasses import dataclass, field
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from .clang.cindex import (
|
|
Config,
|
|
Cursor,
|
|
CursorKind,
|
|
Index,
|
|
Token,
|
|
TranslationUnit,
|
|
)
|
|
|
|
logger = logging.getLogger(__file__)
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
|
|
@dataclass
|
|
class Variable:
|
|
name: str
|
|
type: str
|
|
parent: Any = None
|
|
constant: bool = False
|
|
static: bool = False
|
|
default: Any = None
|
|
|
|
|
|
@dataclass
|
|
class LiteralVariable(Variable):
|
|
literal: str = None
|
|
literal_valid: bool = True
|
|
|
|
|
|
@dataclass
|
|
class Enum:
|
|
name: str
|
|
type: str
|
|
parent: "Namespace" = None
|
|
values: Dict[str, Variable] = field(default_factory=dict)
|
|
is_strong_typed: bool = False
|
|
|
|
@property
|
|
def full_name(self):
|
|
if self.parent is None:
|
|
# return "::" + self.name
|
|
return self.name
|
|
return self.parent.full_name + "::" + self.name
|
|
|
|
def full_name_of(self, v: Variable):
|
|
return self.full_name + "::" + v.name
|
|
|
|
|
|
@dataclass
|
|
class Function:
|
|
name: str
|
|
ret_type: str
|
|
parent: "Namespace" = None
|
|
args: List[Variable] = field(default_factory=list)
|
|
calling_convention: str = "__cdecl"
|
|
|
|
@property
|
|
def type(self, show_calling_convention: bool = False):
|
|
args = ",".join([i.type for i in self.args])
|
|
calling = (
|
|
self.calling_convention + " " if show_calling_convention else ""
|
|
)
|
|
return f"{self.ret_type}({calling} *)({args})"
|
|
|
|
@property
|
|
def full_name(self):
|
|
return f"::{self.name}"
|
|
|
|
@property
|
|
def full_signature(self):
|
|
s = f"{self.name} ("
|
|
for arg in self.args:
|
|
s += arg.type + " " + arg.name + ","
|
|
s = s[:-2] + ")"
|
|
return s
|
|
|
|
def __str__(self):
|
|
return self.full_signature
|
|
|
|
|
|
@dataclass
|
|
class Namespace:
|
|
name: str = ""
|
|
parent: "Namespace" = None
|
|
enums: Dict[str, Enum] = field(default_factory=dict)
|
|
typedefs: Dict[str, str] = field(default_factory=dict)
|
|
classes: Dict[str, "Class"] = field(default_factory=dict)
|
|
variables: Dict[str, Variable] = field(default_factory=dict)
|
|
functions: Dict[str, List[Function]] = field(
|
|
default_factory=(lambda: defaultdict(list))
|
|
)
|
|
|
|
@property
|
|
def full_name(self):
|
|
if self.parent is None:
|
|
return self.name
|
|
return self.parent.full_name + "::" + self.name
|
|
|
|
|
|
@dataclass
|
|
class Class(Namespace):
|
|
functions: Dict[str, List["Method"]] = field(
|
|
default_factory=(lambda: defaultdict(list))
|
|
)
|
|
constructors: List["Method"] = field(default_factory=list)
|
|
destructor: "Method" = None
|
|
|
|
is_polymorphic: bool = False
|
|
|
|
def __str__(self):
|
|
return "class " + self.name
|
|
|
|
# without this, PyCharm will crash
|
|
def __repr__(self):
|
|
return "class" + self.name
|
|
|
|
|
|
@dataclass
|
|
class Method(Function):
|
|
name: str
|
|
ret_type: str
|
|
parent: Class = None
|
|
access: str = "public"
|
|
is_virtual: bool = False
|
|
is_pure_virtual: bool = False
|
|
is_static: bool = False
|
|
is_final: bool = False
|
|
|
|
@property
|
|
def type(self, show_calling_convention: bool = False):
|
|
args = ",".join([i.type for i in self.args])
|
|
calling = (
|
|
self.calling_convention + " " if show_calling_convention else ""
|
|
)
|
|
parent_prefix = ""
|
|
if not self.is_static:
|
|
parent_prefix = f"{self.parent.full_name}::"
|
|
return f"{self.ret_type}({calling}{parent_prefix}*)({args})"
|
|
|
|
@property
|
|
def full_name(self):
|
|
return f"{self.parent.name}::{self.name}"
|
|
|
|
@property
|
|
def full_signature(self):
|
|
return (
|
|
"{} {}{} {}::".format(
|
|
self.access,
|
|
"virtual" if self.is_virtual else "",
|
|
"static" if self.is_static else "",
|
|
self.parent.name,
|
|
)
|
|
+ super().full_signature
|
|
+ (" = 0" if self.is_pure_virtual else "")
|
|
)
|
|
|
|
def __str__(self):
|
|
return self.full_signature
|
|
|
|
|
|
@dataclass()
|
|
class CXXParseResult(Namespace):
|
|
macros: Dict[str, str] = field(default_factory=dict)
|
|
|
|
|
|
class CXXFileParser:
|
|
def __init__(self, file_path: Optional[str], unsaved_files=None):
|
|
self.unsaved_files = unsaved_files
|
|
self.file_path = file_path
|
|
|
|
def parse(self) -> CXXParseResult:
|
|
idx = Index.create()
|
|
rs = idx.parse(
|
|
self.file_path,
|
|
args="-std=c++11 ".split(" "),
|
|
unsaved_files=self.unsaved_files,
|
|
options=(
|
|
TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD
|
|
| TranslationUnit.PARSE_SKIP_FUNCTION_BODIES
|
|
| TranslationUnit.PARSE_INCLUDE_BRIEF_COMMENTS_IN_CODE_COMPLETION
|
|
),
|
|
)
|
|
result = CXXParseResult()
|
|
# todo: parse namespace
|
|
for c in rs.cursor.walk_preorder():
|
|
if c.kind == CursorKind.FUNCTION_DECL:
|
|
func = CXXFileParser._process_function(c)
|
|
result.functions[func.name] = func
|
|
elif c.kind == CursorKind.ENUM_DECL:
|
|
e = CXXFileParser._process_enum(c)
|
|
result.enums[e.name] = e
|
|
elif (
|
|
c.kind == CursorKind.CLASS_DECL
|
|
or c.kind == CursorKind.STRUCT_DECL
|
|
):
|
|
class_ = CXXFileParser._process_class(c)
|
|
cname = class_.name
|
|
result.classes[cname] = class_
|
|
elif c.kind == CursorKind.VAR_DECL:
|
|
name, value = CXXFileParser._process_variable(c)
|
|
if value:
|
|
result.variables[name] = value
|
|
elif c.kind == CursorKind.TYPEDEF_DECL:
|
|
name, target = CXXFileParser._process_typedef(c)
|
|
result.typedefs[name] = target
|
|
elif c.kind == CursorKind.MACRO_DEFINITION:
|
|
name, definition = CXXFileParser._process_macro_definition(c)
|
|
result.macros[name] = definition
|
|
elif (
|
|
False
|
|
or c.kind == CursorKind.ENUM_CONSTANT_DECL
|
|
or c.kind == CursorKind.CXX_METHOD
|
|
or c.kind == CursorKind.CXX_FINAL_ATTR
|
|
or c.kind == CursorKind.DESTRUCTOR
|
|
or c.kind == CursorKind.PARM_DECL
|
|
or c.kind == CursorKind.CXX_ACCESS_SPEC_DECL
|
|
or c.kind == CursorKind.FIELD_DECL
|
|
):
|
|
pass
|
|
elif c.kind == CursorKind.COMPOUND_STMT:
|
|
# ignore any body
|
|
pass
|
|
elif (
|
|
CXXFileParser._is_literal_cursor(c)
|
|
or c.kind == CursorKind.MACRO_INSTANTIATION
|
|
or c.kind == CursorKind.INCLUSION_DIRECTIVE
|
|
):
|
|
# just not need to process
|
|
pass
|
|
elif (
|
|
c.kind == CursorKind.TYPE_REF
|
|
or c.kind == CursorKind.UNEXPOSED_EXPR
|
|
or c.kind == CursorKind.TRANSLATION_UNIT
|
|
):
|
|
# i don't know what those are
|
|
pass
|
|
else:
|
|
logging.warning(
|
|
"unrecognized cursor kind: %s, %s, %s",
|
|
c.kind,
|
|
c.spelling,
|
|
c.extent,
|
|
)
|
|
return result
|
|
|
|
@staticmethod
|
|
def _process_function(c: Cursor):
|
|
func = Function(
|
|
name=c.displayname,
|
|
ret_type=c.result_type.spelling,
|
|
args=[
|
|
Variable(name=ac.displayname, type=ac.type.spelling)
|
|
for ac in c.get_children()
|
|
],
|
|
)
|
|
return func
|
|
|
|
@staticmethod
|
|
def _process_method(c: Cursor, class_):
|
|
func = Method(
|
|
parent=class_,
|
|
name=c.spelling,
|
|
ret_type=c.result_type.spelling,
|
|
access=c.access_specifier.name.lower(),
|
|
is_virtual=c.is_virtual_method(),
|
|
is_pure_virtual=c.is_pure_virtual_method(),
|
|
is_static=c.is_static_method(),
|
|
)
|
|
for ac in c.get_children():
|
|
if ac.kind == CursorKind.PARM_DECL:
|
|
arg = Variable(ac.displayname, ac.type.spelling)
|
|
func.args.append(arg)
|
|
elif ac.kind == CursorKind.CXX_FINAL_ATTR:
|
|
func.is_final = True
|
|
elif ac.kind == CursorKind.COMPOUND_STMT:
|
|
# we don't care about the function body
|
|
pass
|
|
elif ac.kind == CursorKind.TYPE_REF:
|
|
# I don't what this is, maybe a mistake of clang?
|
|
pass
|
|
else:
|
|
logger.warning(
|
|
"unknown kind in cxx_method child: %s %s",
|
|
ac.kind,
|
|
ac.extent,
|
|
)
|
|
return func
|
|
|
|
@staticmethod
|
|
def _process_class(c: Cursor):
|
|
# noinspection PyArgumentList
|
|
class_ = Class(name=c.displayname)
|
|
for ac in c.get_children():
|
|
if ac.kind == CursorKind.CONSTRUCTOR:
|
|
func = CXXFileParser._process_method(ac, class_)
|
|
if func.is_virtual:
|
|
class_.is_polymorphic = True
|
|
class_.constructors = func
|
|
elif ac.kind == CursorKind.DESTRUCTOR:
|
|
func = CXXFileParser._process_method(ac, class_)
|
|
if func.is_virtual:
|
|
class_.is_polymorphic = True
|
|
class_.destructor = func
|
|
elif ac.kind == CursorKind.FIELD_DECL:
|
|
v = Variable(ac.spelling, ac.type.spelling)
|
|
class_.variables[v.name] = v
|
|
elif ac.kind == CursorKind.CXX_METHOD:
|
|
func = CXXFileParser._process_method(ac, class_)
|
|
if func.is_virtual:
|
|
class_.is_polymorphic = True
|
|
class_.functions[func.name].append(func)
|
|
elif ac.kind == CursorKind.CXX_ACCESS_SPEC_DECL:
|
|
pass
|
|
else:
|
|
logger.warning(
|
|
"unknown kind in class child, and not handled: %s %s",
|
|
ac.kind,
|
|
ac.extent,
|
|
)
|
|
return class_
|
|
|
|
@staticmethod
|
|
def _process_enum(c: Cursor):
|
|
e = Enum(name=c.spelling, type=c.enum_type.spelling)
|
|
for i in list(c.get_children()):
|
|
e.values[i.spelling] = Variable(
|
|
name=i.spelling, type=e.name, default=i.enum_value
|
|
)
|
|
return e
|
|
|
|
@staticmethod
|
|
def _process_variable(c: Cursor):
|
|
children = list(c.get_children())
|
|
length = len(children)
|
|
if length == 1:
|
|
child = children[0]
|
|
if CXXFileParser._is_literal_cursor(child):
|
|
value = CXXFileParser._process_literal(child)
|
|
return c.spelling, value
|
|
logger.warning(
|
|
"unable to process variable : %s %s", c.spelling, c.extent
|
|
)
|
|
return c.spelling, None
|
|
|
|
@staticmethod
|
|
def _process_typedef(c: Cursor):
|
|
return c.spelling, c.underlying_typedef_type.spelling
|
|
|
|
@staticmethod
|
|
def _process_macro_definition(c: Cursor):
|
|
name = c.spelling
|
|
tokens = list(c.get_tokens())
|
|
length = len(tokens)
|
|
if length == 1:
|
|
return name, ""
|
|
return name, " ".join([i.spelling for i in tokens[1:]])
|
|
|
|
@staticmethod
|
|
def _get_source_from_file(file, start, end, encoding="utf-8"):
|
|
with open(file, "rb") as f:
|
|
f.seek(start)
|
|
return f.read(end - start).decode(encoding=encoding)
|
|
|
|
@staticmethod
|
|
def _get_source(token: Token, encoding="utf-8"):
|
|
return CXXFileParser._get_source_from_file(
|
|
token.location.file.name,
|
|
token.extent.start.offset,
|
|
token.extent.end.offset,
|
|
encoding,
|
|
)
|
|
|
|
LITERAL_KINDS = {
|
|
CursorKind.INTEGER_LITERAL,
|
|
CursorKind.STRING_LITERAL,
|
|
CursorKind.CHARACTER_LITERAL,
|
|
CursorKind.CXX_NULL_PTR_LITERAL_EXPR,
|
|
CursorKind.FLOATING_LITERAL,
|
|
CursorKind.IMAGINARY_LITERAL,
|
|
CursorKind.CXX_BOOL_LITERAL_EXPR,
|
|
# CursorKind.OBJC_STRING_LITERAL,
|
|
# CursorKind.OBJ_BOOL_LITERAL_EXPR,
|
|
# CursorKind.COMPOUND_LITERAL_EXPR,
|
|
}
|
|
|
|
@staticmethod
|
|
def _is_literal_cursor(c: Cursor):
|
|
return c.kind in CXXFileParser.LITERAL_KINDS
|
|
# return str(c)[-9:-1] == 'LITERAL'
|
|
|
|
@staticmethod
|
|
def _process_literal(c):
|
|
tokens = list(c.get_tokens())
|
|
if len(tokens) == 1:
|
|
spelling = tokens[0].spelling
|
|
if c.kind == CursorKind.INTEGER_LITERAL:
|
|
return int(spelling)
|
|
elif c.kind == CursorKind.STRING_LITERAL:
|
|
return str(spelling)
|
|
elif c.kind == CursorKind.CHARACTER_LITERAL:
|
|
return CXXFileParser.character_literal_to_int(spelling)
|
|
elif c.kind == CursorKind.FLOATING_LITERAL:
|
|
return float(spelling)
|
|
logger.warning(
|
|
"unknown literal : %s, %s %s", c.kind, c.spelling, c.extent
|
|
)
|
|
return None
|
|
|
|
@staticmethod
|
|
def character_literal_to_int(string):
|
|
s = 0
|
|
for i in string.encode():
|
|
s = s * 255 + i
|
|
return s
|
|
|
|
pass
|
|
|
|
|
|
class CXXParser(CXXFileParser):
|
|
def __init__(self, files: List[str]):
|
|
dummy_code = ""
|
|
for file in files:
|
|
dummy_code += f'#include "{file}"\n'
|
|
|
|
dummy_name = "dummy.cpp"
|
|
super().__init__(dummy_name, unsaved_files=[[dummy_name, dummy_code]])
|
|
|
|
|
|
Config.set_library_path("")
|