862 lines
36 KiB
Python
862 lines
36 KiB
Python
# Copyright (C) 2020 Red Hat Inc.
|
|
#
|
|
# Authors:
|
|
# Eduardo Habkost <ehabkost@redhat.com>
|
|
#
|
|
# This work is licensed under the terms of the GNU GPL, version 2. See
|
|
# the COPYING file in the top-level directory.
|
|
import re
|
|
from itertools import chain
|
|
from typing import *
|
|
|
|
from .regexps import *
|
|
from .patching import *
|
|
from .utils import *
|
|
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
DBG = logger.debug
|
|
INFO = logger.info
|
|
WARN = logger.warning
|
|
|
|
# simple expressions:
|
|
|
|
RE_CONSTANT = OR(RE_STRING, RE_NUMBER)
|
|
|
|
class DefineDirective(FileMatch):
|
|
"""Match any #define directive"""
|
|
regexp = S(r'^[ \t]*#[ \t]*define', CPP_SPACE, NAMED('name', RE_IDENTIFIER), r'\b')
|
|
|
|
class ExpressionDefine(FileMatch):
|
|
"""Simple #define preprocessor directive for an expression"""
|
|
regexp = S(r'^[ \t]*#[ \t]*define', CPP_SPACE, NAMED('name', RE_IDENTIFIER),
|
|
CPP_SPACE, NAMED('value', RE_EXPRESSION), r'[ \t]*\n')
|
|
|
|
def provided_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('constant', self.group('name'))
|
|
|
|
class ConstantDefine(ExpressionDefine):
|
|
"""Simple #define preprocessor directive for a number or string constant"""
|
|
regexp = S(r'^[ \t]*#[ \t]*define', CPP_SPACE, NAMED('name', RE_IDENTIFIER),
|
|
CPP_SPACE, NAMED('value', RE_CONSTANT), r'[ \t]*\n')
|
|
|
|
|
|
class TypeIdentifiers(NamedTuple):
|
|
"""Type names found in type declarations"""
|
|
# TYPE_MYDEVICE
|
|
typename: Optional[str]
|
|
# MYDEVICE
|
|
uppercase: Optional[str] = None
|
|
# MyDevice
|
|
instancetype: Optional[str] = None
|
|
# MyDeviceClass
|
|
classtype: Optional[str] = None
|
|
# my_device
|
|
lowercase: Optional[str] = None
|
|
|
|
def allfields(self):
|
|
return tuple(getattr(self, f) for f in self._fields)
|
|
|
|
def merge(self, other: 'TypeIdentifiers') -> Optional['TypeIdentifiers']:
|
|
"""Check if identifiers match, return new identifier with complete list"""
|
|
if any(not opt_compare(a, b) for a,b in zip(self, other)):
|
|
return None
|
|
return TypeIdentifiers(*(merge(a, b) for a,b in zip(self, other)))
|
|
|
|
def __str__(self) -> str:
|
|
values = ((f, getattr(self, f)) for f in self._fields)
|
|
s = ', '.join('%s=%s' % (f,v) for f,v in values if v is not None)
|
|
return f'{s}'
|
|
|
|
def check_consistency(self) -> List[str]:
|
|
"""Check if identifiers are consistent with each other,
|
|
return list of problems (or empty list if everything seems consistent)
|
|
"""
|
|
r = []
|
|
if self.typename is None:
|
|
r.append("typename (TYPE_MYDEVICE) is unavailable")
|
|
|
|
if self.uppercase is None:
|
|
r.append("uppercase name is unavailable")
|
|
|
|
if (self.instancetype is not None
|
|
and self.classtype is not None
|
|
and self.classtype != f'{self.instancetype}Class'):
|
|
r.append("class typedef %s doesn't match instance typedef %s" %
|
|
(self.classtype, self.instancetype))
|
|
|
|
if (self.uppercase is not None
|
|
and self.typename is not None
|
|
and f'TYPE_{self.uppercase}' != self.typename):
|
|
r.append("uppercase name (%s) doesn't match type name (%s)" %
|
|
(self.uppercase, self.typename))
|
|
|
|
return r
|
|
|
|
class TypedefMatch(FileMatch):
|
|
"""typedef declaration"""
|
|
def provided_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('type', self.group('name'))
|
|
|
|
class SimpleTypedefMatch(TypedefMatch):
|
|
"""Simple typedef declaration
|
|
(no replacement rules)"""
|
|
regexp = S(r'^[ \t]*typedef', SP,
|
|
NAMED('typedef_type', RE_TYPE), SP,
|
|
NAMED('name', RE_IDENTIFIER), r'\s*;[ \t]*\n')
|
|
|
|
RE_MACRO_DEFINE = S(r'^[ \t]*#\s*define\s+', NAMED('name', RE_IDENTIFIER),
|
|
r'\s*\(\s*', RE_IDENTIFIER, r'\s*\)', CPP_SPACE)
|
|
|
|
RE_STRUCT_ATTRIBUTE = r'QEMU_PACKED'
|
|
|
|
# This doesn't parse the struct definitions completely, it just assumes
|
|
# the closing brackets are going to be in an unindented line:
|
|
RE_FULL_STRUCT = S('struct', SP, M(RE_IDENTIFIER, n='?', name='structname'), SP,
|
|
NAMED('body', r'{\n',
|
|
# acceptable inside the struct body:
|
|
# - lines starting with space or tab
|
|
# - empty lines
|
|
# - preprocessor directives
|
|
# - comments
|
|
OR(r'[ \t][^\n]*\n',
|
|
r'#[^\n]*\n',
|
|
r'\n',
|
|
S(r'[ \t]*', RE_COMMENT, r'[ \t]*\n'),
|
|
repeat='*?'),
|
|
r'}', M(RE_STRUCT_ATTRIBUTE, SP, n='*')))
|
|
RE_STRUCT_TYPEDEF = S(r'^[ \t]*typedef', SP, RE_FULL_STRUCT, SP,
|
|
NAMED('name', RE_IDENTIFIER), r'\s*;[ \t]*\n')
|
|
|
|
class FullStructTypedefMatch(TypedefMatch):
|
|
"""typedef struct [SomeStruct] { ...} SomeType
|
|
Will be replaced by separate struct declaration + typedef
|
|
"""
|
|
regexp = RE_STRUCT_TYPEDEF
|
|
|
|
def make_structname(self) -> str:
|
|
"""Make struct name for struct+typedef split"""
|
|
name = self.group('structname')
|
|
if not name:
|
|
name = self.name
|
|
return name
|
|
|
|
def strip_typedef(self) -> Patch:
|
|
"""generate patch that will strip typedef from the struct declartion
|
|
|
|
The caller is responsible for readding the typedef somewhere else.
|
|
"""
|
|
name = self.make_structname()
|
|
body = self.group('body')
|
|
return self.make_patch(f'struct {name} {body};\n')
|
|
|
|
def make_simple_typedef(self) -> str:
|
|
structname = self.make_structname()
|
|
name = self.name
|
|
return f'typedef struct {structname} {name};\n'
|
|
|
|
def move_typedef(self, position) -> Iterator[Patch]:
|
|
"""Generate patches to move typedef elsewhere"""
|
|
yield self.strip_typedef()
|
|
yield Patch(position, position, self.make_simple_typedef())
|
|
|
|
def split_typedef(self) -> Iterator[Patch]:
|
|
"""Split into struct definition + typedef in-place"""
|
|
yield self.strip_typedef()
|
|
yield self.append(self.make_simple_typedef())
|
|
|
|
class StructTypedefSplit(FullStructTypedefMatch):
|
|
"""split struct+typedef declaration"""
|
|
def gen_patches(self) -> Iterator[Patch]:
|
|
if self.group('structname'):
|
|
yield from self.split_typedef()
|
|
|
|
class DuplicatedTypedefs(SimpleTypedefMatch):
|
|
"""Delete ALL duplicate typedefs (unsafe)"""
|
|
def gen_patches(self) -> Iterable[Patch]:
|
|
other_td = [td for td in chain(self.file.matches_of_type(SimpleTypedefMatch),
|
|
self.file.matches_of_type(FullStructTypedefMatch))
|
|
if td.name == self.name]
|
|
DBG("other_td: %r", other_td)
|
|
if any(td.start() < self.start() for td in other_td):
|
|
# patch only if handling the first typedef
|
|
return
|
|
for td in other_td:
|
|
if isinstance(td, SimpleTypedefMatch):
|
|
DBG("other td: %r", td.match.groupdict())
|
|
if td.group('typedef_type') != self.group('typedef_type'):
|
|
yield td.make_removal_patch()
|
|
elif isinstance(td, FullStructTypedefMatch):
|
|
DBG("other td: %r", td.match.groupdict())
|
|
if self.group('typedef_type') == 'struct '+td.group('structname'):
|
|
yield td.strip_typedef()
|
|
|
|
class QOMDuplicatedTypedefs(DuplicatedTypedefs):
|
|
"""Delete duplicate typedefs if used by QOM type"""
|
|
def gen_patches(self) -> Iterable[Patch]:
|
|
qom_macros = [TypeCheckMacro, DeclareInstanceChecker, DeclareClassCheckers, DeclareObjCheckers]
|
|
qom_matches = chain(*(self.file.matches_of_type(t) for t in qom_macros))
|
|
in_use = any(RequiredIdentifier('type', self.name) in m.required_identifiers()
|
|
for m in qom_matches)
|
|
if in_use:
|
|
yield from DuplicatedTypedefs.gen_patches(self)
|
|
|
|
class QOMStructTypedefSplit(FullStructTypedefMatch):
|
|
"""split struct+typedef declaration if used by QOM type"""
|
|
def gen_patches(self) -> Iterator[Patch]:
|
|
qom_macros = [TypeCheckMacro, DeclareInstanceChecker, DeclareClassCheckers, DeclareObjCheckers]
|
|
qom_matches = chain(*(self.file.matches_of_type(t) for t in qom_macros))
|
|
in_use = any(RequiredIdentifier('type', self.name) in m.required_identifiers()
|
|
for m in qom_matches)
|
|
if in_use:
|
|
yield from self.split_typedef()
|
|
|
|
def typedefs(file: FileInfo) -> Iterable[TypedefMatch]:
|
|
return (cast(TypedefMatch, m)
|
|
for m in chain(file.matches_of_type(SimpleTypedefMatch),
|
|
file.matches_of_type(FullStructTypedefMatch)))
|
|
|
|
def find_typedef(f: FileInfo, name: Optional[str]) -> Optional[TypedefMatch]:
|
|
if not name:
|
|
return None
|
|
for td in typedefs(f):
|
|
if td.name == name:
|
|
return td
|
|
return None
|
|
|
|
CHECKER_MACROS = ['OBJECT_CHECK', 'OBJECT_CLASS_CHECK', 'OBJECT_GET_CLASS']
|
|
CheckerMacroName = Literal['OBJECT_CHECK', 'OBJECT_CLASS_CHECK', 'OBJECT_GET_CLASS']
|
|
|
|
RE_CHECK_MACRO = \
|
|
S(RE_MACRO_DEFINE,
|
|
OR(*CHECKER_MACROS, name='checker'),
|
|
M(r'\s*\(\s*', OR(NAMED('typedefname', RE_IDENTIFIER), RE_TYPE, name='c_type'), r'\s*,', CPP_SPACE,
|
|
OPTIONAL_PARS(RE_IDENTIFIER), r',', CPP_SPACE,
|
|
NAMED('qom_typename', RE_IDENTIFIER), r'\s*\)\n',
|
|
n='?', name='check_args'))
|
|
|
|
EXPECTED_CHECKER_SUFFIXES: List[Tuple[CheckerMacroName, str]] = [
|
|
('OBJECT_GET_CLASS', '_GET_CLASS'),
|
|
('OBJECT_CLASS_CHECK', '_CLASS'),
|
|
]
|
|
|
|
class TypeCheckMacro(FileMatch):
|
|
"""OBJECT_CHECK/OBJECT_CLASS_CHECK/OBJECT_GET_CLASS macro definitions
|
|
Will be replaced by DECLARE_*_CHECKERS macro
|
|
"""
|
|
regexp = RE_CHECK_MACRO
|
|
|
|
@property
|
|
def checker(self) -> CheckerMacroName:
|
|
"""Name of checker macro being used"""
|
|
return self.group('checker') # type: ignore
|
|
|
|
@property
|
|
def typedefname(self) -> Optional[str]:
|
|
return self.group('typedefname')
|
|
|
|
def find_typedef(self) -> Optional[TypedefMatch]:
|
|
return find_typedef(self.file, self.typedefname)
|
|
|
|
def sanity_check(self) -> None:
|
|
DBG("groups: %r", self.match.groups())
|
|
if not self.group('check_args'):
|
|
self.warn("type check macro not parsed completely: %s", self.name)
|
|
return
|
|
DBG("type identifiers: %r", self.type_identifiers)
|
|
if self.typedefname and self.find_typedef() is None:
|
|
self.warn("typedef used by %s not found", self.name)
|
|
|
|
def find_matching_macros(self) -> List['TypeCheckMacro']:
|
|
"""Find other check macros that generate the same macro names
|
|
|
|
The returned list will always be sorted.
|
|
"""
|
|
my_ids = self.type_identifiers
|
|
assert my_ids
|
|
return [m for m in self.file.matches_of_type(TypeCheckMacro)
|
|
if m.type_identifiers is not None
|
|
and my_ids.uppercase is not None
|
|
and (my_ids.uppercase == m.type_identifiers.uppercase
|
|
or my_ids.typename == m.type_identifiers.typename)]
|
|
|
|
def merge_ids(self, matches: List['TypeCheckMacro']) -> Optional[TypeIdentifiers]:
|
|
"""Try to merge info about type identifiers from all matches in a list"""
|
|
if not matches:
|
|
return None
|
|
r = matches[0].type_identifiers
|
|
if r is None:
|
|
return None
|
|
for m in matches[1:]:
|
|
assert m.type_identifiers
|
|
new = r.merge(m.type_identifiers)
|
|
if new is None:
|
|
self.warn("macro %s identifiers (%s) don't match macro %s (%s)",
|
|
matches[0].name, r, m.name, m.type_identifiers)
|
|
return None
|
|
r = new
|
|
return r
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
if self.type_identifiers is None:
|
|
return
|
|
# to make sure typedefs will be moved above all related macros,
|
|
# return dependencies from all of them, not just this match
|
|
for m in self.find_matching_macros():
|
|
yield RequiredIdentifier('type', m.group('c_type'))
|
|
yield RequiredIdentifier('constant', m.group('qom_typename'))
|
|
|
|
@property
|
|
def type_identifiers(self) -> Optional[TypeIdentifiers]:
|
|
"""Extract type identifier information from match"""
|
|
typename = self.group('qom_typename')
|
|
c_type = self.group('c_type')
|
|
if not typename or not c_type:
|
|
return None
|
|
typedef = self.group('typedefname')
|
|
classtype = None
|
|
instancetype = None
|
|
uppercase = None
|
|
expected_suffix = dict(EXPECTED_CHECKER_SUFFIXES).get(self.checker)
|
|
|
|
# here the available data depends on the checker macro being called:
|
|
# - we need to remove the suffix from the macro name
|
|
# - depending on the macro type, we know the class type name, or
|
|
# the instance type name
|
|
if self.checker in ('OBJECT_GET_CLASS', 'OBJECT_CLASS_CHECK'):
|
|
classtype = c_type
|
|
elif self.checker == 'OBJECT_CHECK':
|
|
instancetype = c_type
|
|
uppercase = self.name
|
|
else:
|
|
assert False
|
|
if expected_suffix and self.name.endswith(expected_suffix):
|
|
uppercase = self.name[:-len(expected_suffix)]
|
|
return TypeIdentifiers(typename=typename, classtype=classtype,
|
|
instancetype=instancetype, uppercase=uppercase)
|
|
|
|
def gen_patches(self) -> Iterable[Patch]:
|
|
# the implementation is a bit tricky because we need to group
|
|
# macros dealing with the same type into a single declaration
|
|
if self.type_identifiers is None:
|
|
self.warn("couldn't extract type information from macro %s", self.name)
|
|
return
|
|
|
|
if self.name == 'INTERFACE_CLASS':
|
|
# INTERFACE_CLASS is special and won't be patched
|
|
return
|
|
|
|
for checker,suffix in EXPECTED_CHECKER_SUFFIXES:
|
|
if self.name.endswith(suffix):
|
|
if self.checker != checker:
|
|
self.warn("macro %s is using macro %s instead of %s", self.name, self.checker, checker)
|
|
return
|
|
break
|
|
|
|
matches = self.find_matching_macros()
|
|
DBG("found %d matching macros: %s", len(matches), ' '.join(m.name for m in matches))
|
|
# we will generate patches only when processing the first macro:
|
|
if matches[0].start != self.start:
|
|
DBG("skipping %s (will patch when handling %s)", self.name, matches[0].name)
|
|
return
|
|
|
|
|
|
ids = self.merge_ids(matches)
|
|
if ids is None:
|
|
DBG("type identifier mismatch, won't patch %s", self.name)
|
|
return
|
|
|
|
if not ids.uppercase:
|
|
self.warn("macro %s doesn't follow the expected name pattern", self.name)
|
|
return
|
|
if not ids.typename:
|
|
self.warn("macro %s: couldn't extract type name", self.name)
|
|
return
|
|
|
|
#issues = ids.check_consistency()
|
|
#if issues:
|
|
# for i in issues:
|
|
# self.warn("inconsistent identifiers: %s", i)
|
|
|
|
names = [n for n in (ids.instancetype, ids.classtype, ids.uppercase, ids.typename)
|
|
if n is not None]
|
|
if len(set(names)) != len(names):
|
|
self.warn("duplicate names used by macro: %r", ids)
|
|
return
|
|
|
|
assert ids.classtype or ids.instancetype
|
|
assert ids.typename
|
|
assert ids.uppercase
|
|
if ids.classtype and ids.instancetype:
|
|
new_decl = (f'DECLARE_OBJ_CHECKERS({ids.instancetype}, {ids.classtype},\n'
|
|
f' {ids.uppercase}, {ids.typename})\n')
|
|
elif ids.classtype:
|
|
new_decl = (f'DECLARE_CLASS_CHECKERS({ids.classtype}, {ids.uppercase},\n'
|
|
f' {ids.typename})\n')
|
|
elif ids.instancetype:
|
|
new_decl = (f'DECLARE_INSTANCE_CHECKER({ids.instancetype}, {ids.uppercase},\n'
|
|
f' {ids.typename})\n')
|
|
else:
|
|
assert False
|
|
|
|
# we need to ensure the typedefs are already available
|
|
issues = []
|
|
for t in [ids.instancetype, ids.classtype]:
|
|
if not t:
|
|
continue
|
|
if re.fullmatch(RE_STRUCT_TYPE, t):
|
|
self.info("type %s is not a typedef", t)
|
|
continue
|
|
td = find_typedef(self.file, t)
|
|
#if not td and self.allfiles.find_file('include/qemu/typedefs.h'):
|
|
#
|
|
if not td:
|
|
# it is OK if the typedef is in typedefs.h
|
|
f = self.allfiles.find_file('include/qemu/typedefs.h')
|
|
if f and find_typedef(f, t):
|
|
self.info("typedef %s found in typedefs.h", t)
|
|
continue
|
|
|
|
issues.append("couldn't find typedef %s" % (t))
|
|
elif td.start() > self.start():
|
|
issues.append("typedef %s need to be moved earlier in the file" % (td.name))
|
|
|
|
for issue in issues:
|
|
self.warn(issue)
|
|
|
|
if issues and not self.file.force:
|
|
return
|
|
|
|
# delete all matching macros and add new declaration:
|
|
for m in matches:
|
|
yield m.make_patch('')
|
|
for issue in issues:
|
|
yield self.prepend("/* FIXME: %s */\n" % (issue))
|
|
yield self.append(new_decl)
|
|
|
|
class InterfaceCheckMacro(FileMatch):
|
|
"""Type checking macro using INTERFACE_CHECK
|
|
Will be replaced by DECLARE_INTERFACE_CHECKER
|
|
"""
|
|
regexp = S(RE_MACRO_DEFINE,
|
|
'INTERFACE_CHECK',
|
|
r'\s*\(\s*', OR(NAMED('instancetype', RE_IDENTIFIER), RE_TYPE, name='c_type'),
|
|
r'\s*,', CPP_SPACE,
|
|
OPTIONAL_PARS(RE_IDENTIFIER), r',', CPP_SPACE,
|
|
NAMED('qom_typename', RE_IDENTIFIER), r'\s*\)\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('type', self.group('instancetype'))
|
|
yield RequiredIdentifier('constant', self.group('qom_typename'))
|
|
|
|
def gen_patches(self) -> Iterable[Patch]:
|
|
if self.file.filename_matches('qom/object.h'):
|
|
self.debug("skipping object.h")
|
|
return
|
|
|
|
typename = self.group('qom_typename')
|
|
uppercase = self.name
|
|
instancetype = self.group('instancetype')
|
|
c = f"DECLARE_INTERFACE_CHECKER({instancetype}, {uppercase},\n"+\
|
|
f" {typename})\n"
|
|
yield self.make_patch(c)
|
|
|
|
|
|
class TypeDeclaration(FileMatch):
|
|
"""Parent class to all type declarations"""
|
|
@property
|
|
def instancetype(self) -> Optional[str]:
|
|
return self.getgroup('instancetype')
|
|
|
|
@property
|
|
def classtype(self) -> Optional[str]:
|
|
return self.getgroup('classtype')
|
|
|
|
@property
|
|
def typename(self) -> Optional[str]:
|
|
return self.getgroup('typename')
|
|
|
|
class TypeCheckerDeclaration(TypeDeclaration):
|
|
"""Parent class to all type checker declarations"""
|
|
@property
|
|
def typename(self) -> str:
|
|
return self.group('typename')
|
|
|
|
@property
|
|
def uppercase(self) -> str:
|
|
return self.group('uppercase')
|
|
|
|
class DeclareInstanceChecker(TypeCheckerDeclaration):
|
|
"""DECLARE_INSTANCE_CHECKER use"""
|
|
#TODO: replace lonely DECLARE_INSTANCE_CHECKER with DECLARE_OBJ_CHECKERS
|
|
# if all types are found.
|
|
# This will require looking up the correct class type in the TypeInfo
|
|
# structs in another file
|
|
regexp = S(r'^[ \t]*DECLARE_INSTANCE_CHECKER\s*\(\s*',
|
|
NAMED('instancetype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
OR(RE_IDENTIFIER, RE_STRING, RE_MACRO_CONCAT, RE_FUN_CALL, name='typename'), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('constant', self.group('typename'))
|
|
yield RequiredIdentifier('type', self.group('instancetype'))
|
|
|
|
class DeclareInterfaceChecker(TypeCheckerDeclaration):
|
|
"""DECLARE_INTERFACE_CHECKER use"""
|
|
regexp = S(r'^[ \t]*DECLARE_INTERFACE_CHECKER\s*\(\s*',
|
|
NAMED('instancetype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
OR(RE_IDENTIFIER, RE_STRING, RE_MACRO_CONCAT, RE_FUN_CALL, name='typename'), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('constant', self.group('typename'))
|
|
yield RequiredIdentifier('type', self.group('instancetype'))
|
|
|
|
class DeclareInstanceType(TypeDeclaration):
|
|
"""DECLARE_INSTANCE_TYPE use"""
|
|
regexp = S(r'^[ \t]*DECLARE_INSTANCE_TYPE\s*\(\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
NAMED('instancetype', RE_TYPE), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('type', self.group('instancetype'))
|
|
|
|
class DeclareClassType(TypeDeclaration):
|
|
"""DECLARE_CLASS_TYPE use"""
|
|
regexp = S(r'^[ \t]*DECLARE_CLASS_TYPE\s*\(\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
NAMED('classtype', RE_TYPE), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('type', self.group('classtype'))
|
|
|
|
|
|
|
|
class DeclareClassCheckers(TypeCheckerDeclaration):
|
|
"""DECLARE_CLASS_CHECKER use"""
|
|
regexp = S(r'^[ \t]*DECLARE_CLASS_CHECKERS\s*\(\s*',
|
|
NAMED('classtype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
OR(RE_IDENTIFIER, RE_STRING, RE_MACRO_CONCAT, RE_FUN_CALL, name='typename'), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('constant', self.group('typename'))
|
|
yield RequiredIdentifier('type', self.group('classtype'))
|
|
|
|
class DeclareObjCheckers(TypeCheckerDeclaration):
|
|
"""DECLARE_OBJ_CHECKERS use"""
|
|
#TODO: detect when OBJECT_DECLARE_SIMPLE_TYPE can be used
|
|
regexp = S(r'^[ \t]*DECLARE_OBJ_CHECKERS\s*\(\s*',
|
|
NAMED('instancetype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('classtype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
OR(RE_IDENTIFIER, RE_STRING, RE_MACRO_CONCAT, RE_FUN_CALL, name='typename'), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def required_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', '"qom/object.h"')
|
|
yield RequiredIdentifier('constant', self.group('typename'))
|
|
yield RequiredIdentifier('type', self.group('classtype'))
|
|
yield RequiredIdentifier('type', self.group('instancetype'))
|
|
|
|
class TypeDeclarationFixup(FileMatch):
|
|
"""Common base class for code that will look at a set of type declarations"""
|
|
regexp = RE_FILE_BEGIN
|
|
def gen_patches(self) -> Iterable[Patch]:
|
|
if self.file.filename_matches('qom/object.h'):
|
|
self.debug("skipping object.h")
|
|
return
|
|
|
|
# group checkers by uppercase name:
|
|
decl_types: List[Type[TypeDeclaration]] = [DeclareInstanceChecker, DeclareInstanceType,
|
|
DeclareClassCheckers, DeclareClassType,
|
|
DeclareObjCheckers]
|
|
checker_dict: Dict[str, List[TypeDeclaration]] = {}
|
|
for t in decl_types:
|
|
for m in self.file.matches_of_type(t):
|
|
checker_dict.setdefault(m.group('uppercase'), []).append(m)
|
|
self.debug("checker_dict: %r", checker_dict)
|
|
for uppercase,checkers in checker_dict.items():
|
|
fields = ('instancetype', 'classtype', 'uppercase', 'typename')
|
|
fvalues = dict((field, set(getattr(m, field) for m in checkers
|
|
if getattr(m, field, None) is not None))
|
|
for field in fields)
|
|
for field,values in fvalues.items():
|
|
if len(values) > 1:
|
|
for c in checkers:
|
|
c.warn("%s mismatch (%s)", field, ' '.join(values))
|
|
return
|
|
|
|
field_dict = dict((f, v.pop() if v else None) for f,v in fvalues.items())
|
|
yield from self.gen_patches_for_type(uppercase, checkers, field_dict)
|
|
|
|
def find_conflicts(self, uppercase: str, checkers: List[TypeDeclaration]) -> bool:
|
|
"""Look for conflicting declarations that would make it unsafe to add new ones"""
|
|
conflicting: List[FileMatch] = []
|
|
# conflicts in the same file:
|
|
conflicting.extend(chain(self.file.find_matches(DefineDirective, uppercase),
|
|
self.file.find_matches(DeclareInterfaceChecker, uppercase, 'uppercase'),
|
|
self.file.find_matches(DeclareClassType, uppercase, 'uppercase'),
|
|
self.file.find_matches(DeclareInstanceType, uppercase, 'uppercase')))
|
|
|
|
# conflicts in another file:
|
|
conflicting.extend(o for o in chain(self.allfiles.find_matches(DeclareInstanceChecker, uppercase, 'uppercase'),
|
|
self.allfiles.find_matches(DeclareClassCheckers, uppercase, 'uppercase'),
|
|
self.allfiles.find_matches(DeclareInterfaceChecker, uppercase, 'uppercase'),
|
|
self.allfiles.find_matches(DefineDirective, uppercase))
|
|
if o is not None and o.file != self.file
|
|
# if both are .c files, there's no conflict at all:
|
|
and not (o.file.filename.suffix == '.c' and
|
|
self.file.filename.suffix == '.c'))
|
|
|
|
if conflicting:
|
|
for c in checkers:
|
|
c.warn("skipping due to conflicting %s macro", uppercase)
|
|
for o in conflicting:
|
|
if o is None:
|
|
continue
|
|
o.warn("conflicting %s macro is here", uppercase)
|
|
return True
|
|
|
|
return False
|
|
|
|
def gen_patches_for_type(self, uppercase: str,
|
|
checkers: List[TypeDeclaration],
|
|
fields: Dict[str, Optional[str]]) -> Iterable[Patch]:
|
|
"""Should be reimplemented by subclasses"""
|
|
return
|
|
yield
|
|
|
|
class DeclareVoidTypes(TypeDeclarationFixup):
|
|
"""Add DECLARE_*_TYPE(..., void) when there's no declared type"""
|
|
regexp = RE_FILE_BEGIN
|
|
def gen_patches_for_type(self, uppercase: str,
|
|
checkers: List[TypeDeclaration],
|
|
fields: Dict[str, Optional[str]]) -> Iterable[Patch]:
|
|
if self.find_conflicts(uppercase, checkers):
|
|
return
|
|
|
|
#_,last_checker = max((m.start(), m) for m in checkers)
|
|
_,first_checker = min((m.start(), m) for m in checkers)
|
|
|
|
if not any(m.instancetype for m in checkers):
|
|
yield first_checker.prepend(f'DECLARE_INSTANCE_TYPE({uppercase}, void)\n')
|
|
if not any(m.classtype for m in checkers):
|
|
yield first_checker.prepend(f'DECLARE_CLASS_TYPE({uppercase}, void)\n')
|
|
|
|
#if not all(len(v) == 1 for v in fvalues.values()):
|
|
# return
|
|
#
|
|
#final_values = dict((field, values.pop())
|
|
# for field,values in fvalues.items())
|
|
#s = (f"DECLARE_OBJ_CHECKERS({final_values['instancetype']}, {final_values['classtype']},\n"+
|
|
# f" {final_values['uppercase']}, {final_values['typename']})\n")
|
|
#for c in checkers:
|
|
# yield c.make_removal_patch()
|
|
#yield last_checker.append(s)
|
|
|
|
|
|
class AddDeclareTypeName(TypeDeclarationFixup):
|
|
"""Add DECLARE_TYPE_NAME declarations if necessary"""
|
|
def gen_patches_for_type(self, uppercase: str,
|
|
checkers: List[TypeDeclaration],
|
|
fields: Dict[str, Optional[str]]) -> Iterable[Patch]:
|
|
typename = fields.get('typename')
|
|
if typename is None:
|
|
self.warn("typename unavailable")
|
|
return
|
|
if typename == f'TYPE_{uppercase}':
|
|
self.info("already using TYPE_%s as type name", uppercase)
|
|
return
|
|
if self.file.find_match(DeclareTypeName, uppercase, 'uppercase'):
|
|
self.info("type name for %s already declared", uppercase)
|
|
return
|
|
_,first_checker = min((m.start(), m) for m in checkers)
|
|
s = f'DECLARE_TYPE_NAME({uppercase}, {typename})\n'
|
|
yield first_checker.prepend(s)
|
|
|
|
class TrivialClassStruct(FileMatch):
|
|
"""Trivial class struct"""
|
|
regexp = S(r'^[ \t]*struct\s*', NAMED('name', RE_IDENTIFIER),
|
|
r'\s*{\s*', NAMED('parent_struct', RE_IDENTIFIER), r'\s*parent(_class)?\s*;\s*};\n')
|
|
|
|
class DeclareTypeName(FileMatch):
|
|
"""DECLARE_TYPE_NAME usage"""
|
|
regexp = S(r'^[ \t]*DECLARE_TYPE_NAME\s*\(',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
OR(RE_IDENTIFIER, RE_STRING, RE_MACRO_CONCAT, RE_FUN_CALL, name='typename'),
|
|
r'\s*\);?[ \t]*\n')
|
|
|
|
class ObjectDeclareType(TypeCheckerDeclaration):
|
|
"""OBJECT_DECLARE_TYPE usage
|
|
Will be replaced with OBJECT_DECLARE_SIMPLE_TYPE if possible
|
|
"""
|
|
regexp = S(r'^[ \t]*OBJECT_DECLARE_TYPE\s*\(',
|
|
NAMED('instancetype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('classtype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
def gen_patches(self):
|
|
DBG("groups: %r", self.match.groupdict())
|
|
trivial_struct = self.file.find_match(TrivialClassStruct, self.group('classtype'))
|
|
if trivial_struct:
|
|
d = self.match.groupdict().copy()
|
|
d['parent_struct'] = trivial_struct.group("parent_struct")
|
|
yield trivial_struct.make_removal_patch()
|
|
c = ("OBJECT_DECLARE_SIMPLE_TYPE(%(instancetype)s, %(lowercase)s,\n"
|
|
" %(uppercase)s, %(parent_struct)s)\n" % d)
|
|
yield self.make_patch(c)
|
|
|
|
class ObjectDeclareSimpleType(TypeCheckerDeclaration):
|
|
"""OBJECT_DECLARE_SIMPLE_TYPE usage"""
|
|
regexp = S(r'^[ \t]*OBJECT_DECLARE_SIMPLE_TYPE\s*\(',
|
|
NAMED('instancetype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
class OldStyleObjectDeclareSimpleType(TypeCheckerDeclaration):
|
|
"""OBJECT_DECLARE_SIMPLE_TYPE usage (old API)"""
|
|
regexp = S(r'^[ \t]*OBJECT_DECLARE_SIMPLE_TYPE\s*\(',
|
|
NAMED('instancetype', RE_TYPE), r'\s*,\s*',
|
|
NAMED('lowercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
NAMED('uppercase', RE_IDENTIFIER), r'\s*,\s*',
|
|
NAMED('parent_classtype', RE_TYPE), SP,
|
|
r'\)[ \t]*;?[ \t]*\n')
|
|
|
|
@property
|
|
def classtype(self) -> Optional[str]:
|
|
instancetype = self.instancetype
|
|
assert instancetype
|
|
return f"{instancetype}Class"
|
|
|
|
def find_typename_uppercase(files: FileList, typename: str) -> Optional[str]:
|
|
"""Try to find what's the right MODULE_OBJ_NAME for a given type name"""
|
|
decl = files.find_match(DeclareTypeName, name=typename, group='typename')
|
|
if decl:
|
|
return decl.group('uppercase')
|
|
if typename.startswith('TYPE_'):
|
|
return typename[len('TYPE_'):]
|
|
return None
|
|
|
|
def find_type_checkers(files:FileList, name:str, group:str='uppercase') -> Iterable[TypeCheckerDeclaration]:
|
|
"""Find usage of DECLARE*CHECKER macro"""
|
|
c: Type[TypeCheckerDeclaration]
|
|
for c in (DeclareInstanceChecker, DeclareClassCheckers, DeclareObjCheckers, ObjectDeclareType, ObjectDeclareSimpleType):
|
|
yield from files.find_matches(c, name=name, group=group)
|
|
|
|
class Include(FileMatch):
|
|
"""#include directive"""
|
|
regexp = RE_INCLUDE
|
|
def provided_identifiers(self) -> Iterable[RequiredIdentifier]:
|
|
yield RequiredIdentifier('include', self.group('includepath'))
|
|
|
|
class InitialIncludes(FileMatch):
|
|
"""Initial #include block"""
|
|
regexp = S(RE_FILE_BEGIN,
|
|
M(SP, RE_COMMENTS,
|
|
r'^[ \t]*#[ \t]*ifndef[ \t]+', RE_IDENTIFIER, r'[ \t]*\n',
|
|
n='?', name='ifndef_block'),
|
|
M(SP, RE_COMMENTS,
|
|
OR(RE_INCLUDE, RE_SIMPLEDEFINE),
|
|
n='*', name='includes'))
|
|
|
|
class SymbolUserList(NamedTuple):
|
|
definitions: List[FileMatch]
|
|
users: List[FileMatch]
|
|
|
|
class MoveSymbols(FileMatch):
|
|
"""Handle missing symbols
|
|
- Move typedefs and defines when necessary
|
|
- Add missing #include lines when necessary
|
|
"""
|
|
regexp = RE_FILE_BEGIN
|
|
|
|
def gen_patches(self) -> Iterator[Patch]:
|
|
if self.file.filename_matches('qom/object.h'):
|
|
self.debug("skipping object.h")
|
|
return
|
|
|
|
index: Dict[RequiredIdentifier, SymbolUserList] = {}
|
|
definition_classes = [SimpleTypedefMatch, FullStructTypedefMatch, ConstantDefine, Include]
|
|
user_classes = [TypeCheckMacro, DeclareObjCheckers, DeclareInstanceChecker, DeclareClassCheckers, InterfaceCheckMacro]
|
|
|
|
# first we scan for all symbol definitions and usage:
|
|
for dc in definition_classes:
|
|
defs = self.file.matches_of_type(dc)
|
|
for d in defs:
|
|
DBG("scanning %r", d)
|
|
for i in d.provided_identifiers():
|
|
index.setdefault(i, SymbolUserList([], [])).definitions.append(d)
|
|
DBG("index: %r", list(index.keys()))
|
|
for uc in user_classes:
|
|
users = self.file.matches_of_type(uc)
|
|
for u in users:
|
|
for i in u.required_identifiers():
|
|
index.setdefault(i, SymbolUserList([], [])).users.append(u)
|
|
|
|
# validate all symbols:
|
|
for i,ul in index.items():
|
|
if not ul.users:
|
|
# unused symbol
|
|
continue
|
|
|
|
# symbol not defined
|
|
if len(ul.definitions) == 0:
|
|
if i.type == 'include':
|
|
includes, = self.file.matches_of_type(InitialIncludes)
|
|
#FIXME: don't do this if we're already inside qom/object.h
|
|
yield includes.append(f'#include {i.name}\n')
|
|
else:
|
|
u.warn("definition of %s %s not found in file", i.type, i.name)
|
|
continue
|
|
|
|
# symbol defined twice:
|
|
if len(ul.definitions) > 1:
|
|
ul.definitions[1].warn("%s defined twice", i.name)
|
|
ul.definitions[0].warn("previously defined here")
|
|
continue
|
|
|
|
# symbol defined. check if all users are after its definition:
|
|
assert len(ul.definitions) == 1
|
|
definition = ul.definitions[0]
|
|
DBG("handling repositioning of %r", definition)
|
|
earliest = min(ul.users, key=lambda u: u.start())
|
|
if earliest.start() > definition.start():
|
|
DBG("%r is OK", definition)
|
|
continue
|
|
|
|
DBG("%r needs to be moved", definition)
|
|
if isinstance(definition, SimpleTypedefMatch) \
|
|
or isinstance(definition, ConstantDefine):
|
|
# simple typedef or define can be moved directly:
|
|
yield definition.make_removal_patch()
|
|
yield earliest.prepend(definition.group(0))
|
|
elif isinstance(definition, FullStructTypedefMatch) \
|
|
and definition.group('structname'):
|
|
# full struct typedef is more complex: we need to remove
|
|
# the typedef
|
|
yield from definition.move_typedef(earliest.start())
|
|
else:
|
|
definition.warn("definition of %s %s needs to be moved earlier in the file", i.type, i.name)
|
|
earliest.warn("definition of %s %s is used here", i.type, i.name)
|
|
|
|
|
|
class EmptyPreprocessorConditional(FileMatch):
|
|
"""Delete empty preprocessor conditionals"""
|
|
regexp = r'^[ \t]*#(if|ifdef)[ \t].*\n+[ \t]*#endif[ \t]*\n'
|
|
def gen_patches(self) -> Iterable[Patch]:
|
|
yield self.make_removal_patch()
|