self._pydoc = pydoc
self._genc: Optional[QAPIGenC] = None
self._genh: Optional[QAPIGenH] = None
- self._module: Dict[Optional[str], Tuple[QAPIGenC, QAPIGenH]] = {}
+ self._module: Dict[str, Tuple[QAPIGenC, QAPIGenH]] = {}
self._main_module: Optional[str] = None
@staticmethod
- def _module_dirname(name: Optional[str]) -> str:
+ def _module_dirname(name: str) -> str:
if QAPISchemaModule.is_user_module(name):
return os.path.dirname(name)
return ''
- def _module_basename(self, what: str, name: Optional[str]) -> str:
+ def _module_basename(self, what: str, name: str) -> str:
ret = '' if QAPISchemaModule.is_builtin_module(name) else self._prefix
if QAPISchemaModule.is_user_module(name):
basename = os.path.basename(name)
if name != self._main_module:
ret += '-' + os.path.splitext(basename)[0]
else:
- name = name[2:] if name else 'builtin'
- ret += re.sub(r'-', '-' + name + '-', what)
+ assert QAPISchemaModule.is_system_module(name)
+ ret += re.sub(r'-', '-' + name[2:] + '-', what)
return ret
- def _module_filename(self, what: str, name: Optional[str]) -> str:
+ def _module_filename(self, what: str, name: str) -> str:
return os.path.join(self._module_dirname(name),
self._module_basename(what, name))
- def _add_module(self, name: Optional[str], blurb: str) -> None:
+ def _add_module(self, name: str, blurb: str) -> None:
basename = self._module_filename(self._what, name)
genc = QAPIGenC(basename + '.c', blurb, self._pydoc)
genh = QAPIGenH(basename + '.h', blurb, self._pydoc)
self._main_module = name
self._add_module(name, blurb)
- def _add_system_module(self, name: Optional[str], blurb: str) -> None:
+ def _add_system_module(self, name: str, blurb: str) -> None:
assert QAPISchemaModule.is_system_module(name)
self._add_module(name, blurb)
def _begin_user_module(self, name: str) -> None:
pass
- def visit_module(self, name: Optional[str]) -> None:
+ def visit_module(self, name: str) -> None:
if QAPISchemaModule.is_builtin_module(name):
if self._builtin_blurb:
self._add_system_module(name, self._builtin_blurb)
def _set_module(self, schema, info):
assert self._checked
- self._module = schema.module_by_fname(info and info.fname)
+ fname = info.fname if info else './builtin'
+ self._module = schema.module_by_fname(fname)
self._module.add_entity(self)
def set_module(self, schema):
self._entity_list = []
@staticmethod
- def is_system_module(name: Optional[str]) -> bool:
+ def is_system_module(name: str) -> bool:
"""
System modules are internally defined modules.
Their names start with the "./" prefix.
"""
- return name is None or name.startswith('./')
+ return name.startswith('./')
@classmethod
- def is_user_module(cls, name: Optional[str]) -> bool:
+ def is_user_module(cls, name: str) -> bool:
"""
User modules are those defined by the user in qapi JSON files.
return not cls.is_system_module(name)
@staticmethod
- def is_builtin_module(name: Optional[str]) -> bool:
+ def is_builtin_module(name: str) -> bool:
"""
The built-in module is a single System module for the built-in types.
- It is presently always the value 'None'.
+ It is always "./builtin".
"""
- return name is None
+ return name == './builtin'
def add_entity(self, ent):
self._entity_list.append(ent)
self._entity_dict = {}
self._module_dict = OrderedDict()
self._schema_dir = os.path.dirname(fname)
- self._make_module(None) # built-ins
+ self._make_module('./builtin')
self._make_module(fname)
self._predefining = True
self._def_predefineds()
info, "%s uses unknown type '%s'" % (what, name))
return typ
- def _module_name(self, fname):
+ def _module_name(self, fname: str) -> str:
if QAPISchemaModule.is_system_module(fname):
return fname
return os.path.relpath(fname, self._schema_dir)
def module_by_fname(self, fname):
name = self._module_name(fname)
- assert name in self._module_dict
return self._module_dict[name]
def _def_include(self, expr, info, doc):
projects / qemu.git / commitdiff