Lines Matching full:self
49 self,
52 self.ifcond = ifcond
54 def _cgen(self) -> str:
55 return cgen_ifcond(self.ifcond)
57 def gen_if(self) -> str:
58 return gen_if(self._cgen())
60 def gen_endif(self) -> str:
61 return gen_endif(self._cgen())
63 def docgen(self) -> str:
64 return docgen_ifcond(self.ifcond)
66 def is_present(self) -> bool:
67 return bool(self.ifcond)
77 def __init__(self, info: Optional[QAPISourceInfo]):
78 self._module: Optional[QAPISchemaModule] = None
84 self.info = info
85 self._checked = False
87 def __repr__(self) -> str:
88 return "<%s at 0x%x>" % (type(self).__name__, id(self))
90 def check(self, schema: QAPISchema) -> None:
92 self._checked = True
94 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
98 self, schema: QAPISchema, info: Optional[QAPISourceInfo]
100 assert self._checked
102 self._module = schema.module_by_fname(fname)
103 self._module.add_entity(self)
105 def set_module(self, schema: QAPISchema) -> None:
106 self._set_module(schema, self.info)
108 def visit(self, visitor: QAPISchemaVisitor) -> None:
110 assert self._checked
117 self,
127 self.name = name
128 self.doc = doc
129 self._ifcond = ifcond or QAPISchemaIfCond()
130 self.features = features or []
132 def __repr__(self) -> str:
133 return "<%s:%s at 0x%x>" % (type(self).__name__, self.name,
134 id(self))
136 def c_name(self) -> str:
137 return c_name(self.name)
139 def check(self, schema: QAPISchema) -> None:
140 assert not self._checked
143 for f in self.features:
144 f.check_clash(self.info, seen)
146 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
148 doc = doc or self.doc
150 for f in self.features:
154 def ifcond(self) -> QAPISchemaIfCond:
155 assert self._checked
156 return self._ifcond
158 def is_implicit(self) -> bool:
159 return not self.info
161 def describe(self) -> str:
162 return "%s '%s'" % (self.meta, self.name)
166 def visit_begin(self, schema: QAPISchema) -> None:
169 def visit_end(self) -> None:
172 def visit_module(self, name: str) -> None:
175 def visit_needed(self, entity: QAPISchemaEntity) -> bool:
180 def visit_include(self, name: str, info: Optional[QAPISourceInfo]) -> None:
184 self, name: str, info: Optional[QAPISourceInfo], json_type: str
189 self,
200 self,
209 self,
221 self,
232 self,
242 self,
259 self,
274 def __init__(self, name: str):
275 self.name = name
276 self._entity_list: List[QAPISchemaEntity] = []
305 def add_entity(self, ent: QAPISchemaEntity) -> None:
306 self._entity_list.append(ent)
308 def visit(self, visitor: QAPISchemaVisitor) -> None:
309 visitor.visit_module(self.name)
310 for entity in self._entity_list:
316 def __init__(self, sub_module: QAPISchemaModule, info: QAPISourceInfo):
318 self._sub_module = sub_module
320 def visit(self, visitor: QAPISchemaVisitor) -> None:
322 visitor.visit_include(self._sub_module.name, self.info)
329 def c_type(self) -> str:
333 def c_param_type(self) -> str:
334 return self.c_type()
337 def c_unboxed_type(self) -> str:
338 return self.c_type()
341 def json_type(self) -> str:
344 def alternate_qtype(self) -> Optional[str]:
354 return json2qtype.get(self.json_type())
356 def doc_type(self) -> Optional[str]:
357 if self.is_implicit():
359 return self.name
361 def need_has_if_optional(self) -> bool:
364 return not self.c_type().endswith(POINTER_SUFFIX)
366 def check(self, schema: QAPISchema) -> None:
368 for feat in self.features:
371 self.info,
374 def describe(self) -> str:
375 return "%s type '%s'" % (self.meta, self.name)
381 def __init__(self, name: str, json_type: str, c_type: str):
385 self._json_type_name = json_type
386 self._c_type_name = c_type
388 def c_name(self) -> str:
389 return self.name
391 def c_type(self) -> str:
392 return self._c_type_name
394 def c_param_type(self) -> str:
395 if self.name == 'str':
396 return 'const ' + self._c_type_name
397 return self._c_type_name
399 def json_type(self) -> str:
400 return self._json_type_name
402 def doc_type(self) -> str:
403 return self.json_type()
405 def visit(self, visitor: QAPISchemaVisitor) -> None:
407 visitor.visit_builtin_type(self.name, self.info, self.json_type())
414 self,
426 self.members = members
427 self.prefix = prefix
429 def check(self, schema: QAPISchema) -> None:
432 for m in self.members:
433 m.check_clash(self.info, seen)
435 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
437 doc = doc or self.doc
438 for m in self.members:
441 def is_implicit(self) -> bool:
443 return self.name == 'QType'
445 def c_type(self) -> str:
446 return c_name(self.name)
448 def member_names(self) -> List[str]:
449 return [m.name for m in self.members]
451 def json_type(self) -> str:
454 def visit(self, visitor: QAPISchemaVisitor) -> None:
457 self.name, self.info, self.ifcond, self.features,
458 self.members, self.prefix)
465 self, name: str, info: Optional[QAPISourceInfo], element_type: str
468 self._element_type_name = element_type
469 self.element_type: QAPISchemaType
471 def need_has_if_optional(self) -> bool:
476 def check(self, schema: QAPISchema) -> None:
478 self.element_type = schema.resolve_type(
479 self._element_type_name, self.info,
480 self.info.defn_meta if self.info else None)
481 assert not isinstance(self.element_type, QAPISchemaArrayType)
483 def set_module(self, schema: QAPISchema) -> None:
484 self._set_module(schema, self.element_type.info)
487 def ifcond(self) -> QAPISchemaIfCond:
488 assert self._checked
489 return self.element_type.ifcond
491 def is_implicit(self) -> bool:
494 def c_type(self) -> str:
495 return c_name(self.name) + POINTER_SUFFIX
497 def json_type(self) -> str:
500 def doc_type(self) -> Optional[str]:
501 elt_doc_type = self.element_type.doc_type()
506 def visit(self, visitor: QAPISchemaVisitor) -> None:
508 visitor.visit_array_type(self.name, self.info, self.ifcond,
509 self.element_type)
511 def describe(self) -> str:
512 return "%s type ['%s']" % (self.meta, self._element_type_name)
517 self,
530 self.meta = 'union' if branches else 'struct'
535 self._base_name = base
536 self.base = None
537 self.local_members = local_members
538 self.branches = branches
539 self.members: List[QAPISchemaObjectTypeMember]
540 self._check_complete = False
542 def check(self, schema: QAPISchema) -> None:
546 if self._check_complete:
549 if self._checked:
551 raise QAPISemError(self.info,
552 "object %s contains itself" % self.name)
555 assert self._checked and not self._check_complete
558 if self._base_name:
559 self.base = schema.resolve_type(self._base_name, self.info,
561 if (not isinstance(self.base, QAPISchemaObjectType)
562 or self.base.branches):
564 self.info,
566 % self.base.describe())
567 self.base.check(schema)
568 self.base.check_clash(self.info, seen)
569 for m in self.local_members:
571 m.check_clash(self.info, seen)
573 # self.check_clash() works in terms of the supertype, but
574 # self.members is declared List[QAPISchemaObjectTypeMember].
578 if self.branches:
579 self.branches.check(schema, seen)
580 self.branches.check_clash(self.info, seen)
582 self.members = members
583 self._check_complete = True # mark completed
587 # on behalf of info, which is not necessarily self.info
589 self,
593 assert self._checked
594 for m in self.members:
596 if self.branches:
597 self.branches.check_clash(info, seen)
599 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
601 doc = doc or self.doc
602 if self.base and self.base.is_implicit():
603 self.base.connect_doc(doc)
604 for m in self.local_members:
607 def is_implicit(self) -> bool:
610 return self.name.startswith('q_')
612 def is_empty(self) -> bool:
613 return not self.members and not self.branches
615 def has_conditional_members(self) -> bool:
616 return any(m.ifcond.is_present() for m in self.members)
618 def c_name(self) -> str:
619 assert self.name != 'q_empty'
622 def c_type(self) -> str:
623 assert not self.is_implicit()
624 return c_name(self.name) + POINTER_SUFFIX
626 def c_unboxed_type(self) -> str:
627 return c_name(self.name)
629 def json_type(self) -> str:
632 def visit(self, visitor: QAPISchemaVisitor) -> None:
635 self.name, self.info, self.ifcond, self.features,
636 self.base, self.local_members, self.branches)
638 self.name, self.info, self.ifcond, self.features,
639 self.members, self.branches)
646 self,
657 alternatives.tag_member.set_defined_in(self.name)
658 self.alternatives = alternatives
660 def check(self, schema: QAPISchema) -> None:
662 self.alternatives.tag_member.check(schema)
663 # Not calling self.alternatives.check_clash(), because there's
665 self.alternatives.check(schema, {})
670 for v in self.alternatives.variants:
671 v.check_clash(self.info, seen)
675 self.info,
677 % (v.describe(self.info), v.type.describe()))
693 self.info,
695 % (v.describe(self.info), types_seen[qt]))
698 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
700 doc = doc or self.doc
701 for v in self.alternatives.variants:
704 def c_type(self) -> str:
705 return c_name(self.name) + POINTER_SUFFIX
707 def json_type(self) -> str:
710 def visit(self, visitor: QAPISchemaVisitor) -> None:
713 self.name, self.info, self.ifcond, self.features,
714 self.alternatives)
719 self,
723 self.info = info
724 self.tag_member: QAPISchemaObjectTypeMember
725 self.variants = variants
727 def set_defined_in(self, name: str) -> None:
728 for v in self.variants:
733 self, schema: QAPISchema, seen: Dict[str, QAPISchemaMember]
735 for v in self.variants:
740 def __init__(self,
745 self._tag_name = tag_name
748 self, schema: QAPISchema, seen: Dict[str, QAPISchemaMember]
751 tag_member = seen.get(c_name(self._tag_name))
758 if not tag_member or self._tag_name != tag_member.name:
760 self.info,
762 % (self._tag_name, base))
763 self.tag_member = tag_member
772 self.info,
774 % (self._tag_name, base))
777 self.info,
779 % (self._tag_name, base))
782 self.info,
784 % (self._tag_name, base))
787 cases = {v.name for v in self.variants}
790 v = QAPISchemaVariant(m.name, self.info,
793 self.variants.append(v)
794 if not self.variants:
795 raise QAPISemError(self.info, "union has no branches")
796 for v in self.variants:
803 self.info,
808 self.info,
810 % (v.describe(self.info), v.type.describe()))
814 self,
818 for v in self.variants:
828 def __init__(self,
833 self.tag_member = tag_member
836 self, schema: QAPISchema, seen: Dict[str, QAPISchemaMember]
839 assert isinstance(self.tag_member.type, QAPISchemaEnumType)
840 assert not self.tag_member.optional
841 assert not self.tag_member.ifcond.is_present()
849 self,
854 self.name = name
855 self.info = info
856 self.ifcond = ifcond or QAPISchemaIfCond()
857 self.defined_in: Optional[str] = None
859 def set_defined_in(self, name: str) -> None:
860 assert not self.defined_in
861 self.defined_in = name
864 self,
868 cname = c_name(self.name)
873 % (self.describe(info), seen[cname].describe(info)))
874 seen[cname] = self
876 def connect_doc(self, doc: Optional[QAPIDoc]) -> None:
878 doc.connect_member(self)
880 def describe(self, info: Optional[QAPISourceInfo]) -> str:
881 role = self.role
883 defined_in = self.defined_in
905 return "%s '%s' of %s '%s'" % (role, self.name, meta, defined_in)
906 return "%s '%s'" % (role, self.name)
913 self,
922 self.features = features or []
924 def connect_doc(self, doc: Optional[QAPIDoc]) -> None:
927 for f in self.features:
937 def is_special(self) -> bool:
938 return self.name in QAPISchemaFeature.SPECIAL_NAMES
943 self,
954 self._type_name = typ
955 self.type: QAPISchemaType # set during check()
956 self.optional = optional
957 self.features = features or []
959 def need_has(self) -> bool:
960 return self.optional and self.type.need_has_if_optional()
962 def check(self, schema: QAPISchema) -> None:
963 assert self.defined_in
964 self.type = schema.resolve_type(self._type_name, self.info,
965 self.describe)
967 for f in self.features:
968 f.check_clash(self.info, seen)
970 def connect_doc(self, doc: Optional[QAPIDoc]) -> None:
973 for f in self.features:
981 self,
994 self,
1010 self._arg_type_name = arg_type
1011 self.arg_type: Optional[QAPISchemaObjectType] = None
1012 self._ret_type_name = ret_type
1013 self.ret_type: Optional[QAPISchemaType] = None
1014 self.gen = gen
1015 self.success_response = success_response
1016 self.boxed = boxed
1017 self.allow_oob = allow_oob
1018 self.allow_preconfig = allow_preconfig
1019 self.coroutine = coroutine
1021 def check(self, schema: QAPISchema) -> None:
1022 assert self.info is not None
1024 if self._arg_type_name:
1026 self._arg_type_name, self.info, "command's 'data'")
1029 self.info,
1032 self.arg_type = arg_type
1033 if self.arg_type.branches and not self.boxed:
1035 self.info,
1037 % self.arg_type.describe())
1038 self.arg_type.check(schema)
1039 if self.arg_type.has_conditional_members() and not self.boxed:
1041 self.info,
1043 if self._ret_type_name:
1044 self.ret_type = schema.resolve_type(
1045 self._ret_type_name, self.info, "command's 'returns'")
1046 if self.name not in self.info.pragma.command_returns_exceptions:
1047 typ = self.ret_type
1052 self.info,
1054 % self.ret_type.describe())
1056 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
1058 doc = doc or self.doc
1060 if self.arg_type and self.arg_type.is_implicit():
1061 self.arg_type.connect_doc(doc)
1063 if self.ret_type and self.info:
1064 doc.ensure_returns(self.info)
1066 def visit(self, visitor: QAPISchemaVisitor) -> None:
1069 self.name, self.info, self.ifcond, self.features,
1070 self.arg_type, self.ret_type, self.gen, self.success_response,
1071 self.boxed, self.allow_oob, self.allow_preconfig,
1072 self.coroutine)
1079 self,
1089 self._arg_type_name = arg_type
1090 self.arg_type: Optional[QAPISchemaObjectType] = None
1091 self.boxed = boxed
1093 def check(self, schema: QAPISchema) -> None:
1095 if self._arg_type_name:
1097 self._arg_type_name, self.info, "event's 'data'")
1100 self.info,
1103 self.arg_type = typ
1104 if self.arg_type.branches and not self.boxed:
1106 self.info,
1108 % self.arg_type.describe())
1109 self.arg_type.check(schema)
1110 if self.arg_type.has_conditional_members() and not self.boxed:
1112 self.info,
1115 def connect_doc(self, doc: Optional[QAPIDoc] = None) -> None:
1117 doc = doc or self.doc
1119 if self.arg_type and self.arg_type.is_implicit():
1120 self.arg_type.connect_doc(doc)
1122 def visit(self, visitor: QAPISchemaVisitor) -> None:
1125 self.name, self.info, self.ifcond, self.features,
1126 self.arg_type, self.boxed)
1130 def __init__(self, fname: str):
1131 self.fname = fname
1141 self.docs = parser.docs
1142 self._entity_list: List[QAPISchemaEntity] = []
1143 self._entity_dict: Dict[str, QAPISchemaDefinition] = {}
1144 self._module_dict: Dict[str, QAPISchemaModule] = {}
1147 self._feature_dict: Dict[str, QAPISchemaFeature] = {}
1153 self._feature_dict[f] = QAPISchemaFeature(f, None)
1155 self._schema_dir = os.path.dirname(fname)
1156 self._make_module(QAPISchemaModule.BUILTIN_MODULE_NAME)
1157 self._make_module(fname)
1158 self._predefining = True
1159 self._def_predefineds()
1160 self._predefining = False
1161 self._def_exprs(exprs)
1162 self.check()
1164 def features(self) -> ValuesView[QAPISchemaFeature]:
1165 return self._feature_dict.values()
1167 def _def_entity(self, ent: QAPISchemaEntity) -> None:
1168 self._entity_list.append(ent)
1170 def _def_definition(self, defn: QAPISchemaDefinition) -> None:
1172 assert defn.info or self._predefining
1173 self._def_entity(defn)
1176 other_defn = self._entity_dict.get(defn.name)
1185 self._entity_dict[defn.name] = defn
1187 def lookup_entity(self, name: str) -> Optional[QAPISchemaEntity]:
1188 return self._entity_dict.get(name)
1190 def lookup_type(self, name: str) -> Optional[QAPISchemaType]:
1191 typ = self.lookup_entity(name)
1197 self,
1202 typ = self.lookup_type(name)
1211 def _module_name(self, fname: str) -> str:
1214 return os.path.relpath(fname, self._schema_dir)
1216 def _make_module(self, fname: str) -> QAPISchemaModule:
1217 name = self._module_name(fname)
1218 if name not in self._module_dict:
1219 self._module_dict[name] = QAPISchemaModule(name)
1220 return self._module_dict[name]
1222 def module_by_fname(self, fname: str) -> QAPISchemaModule:
1223 name = self._module_name(fname)
1224 return self._module_dict[name]
1226 def _def_include(self, expr: QAPIExpression) -> None:
1229 self._def_entity(
1230 QAPISchemaInclude(self._make_module(include), expr.info))
1233 self, name: str, json_type: str, c_type: str
1235 self._def_definition(QAPISchemaBuiltinType(name, json_type, c_type))
1240 self._make_array_type(name, None)
1242 def _def_predefineds(self) -> None:
1258 self._def_builtin_type(*t)
1259 self.the_empty_object_type = QAPISchemaObjectType(
1261 self._def_definition(self.the_empty_object_type)
1265 qtype_values = self._make_enum_members(
1268 self._def_definition(QAPISchemaEnumType(
1272 self,
1281 if feat.name not in self._feature_dict:
1282 self._feature_dict[feat.name] = feat
1289 self,
1297 self._make_features(features, info))
1300 self, values: List[Dict[str, Any]], info: Optional[QAPISourceInfo]
1302 return [self._make_enum_member(v['name'], v.get('if'),
1307 self, element_type: str, info: Optional[QAPISourceInfo]
1310 if not self.lookup_type(name):
1311 self._def_definition(QAPISchemaArrayType(
1316 self,
1327 typ = self.lookup_entity(name)
1334 self._def_definition(QAPISchemaObjectType(
1338 def _def_enum_type(self, expr: QAPIExpression) -> None:
1344 features = self._make_features(expr.get('features'), info)
1345 self._def_definition(QAPISchemaEnumType(
1347 self._make_enum_members(data, info), prefix))
1350 self,
1363 typ = self._make_array_type(typ[0], info)
1365 self._make_features(features, info))
1368 self,
1372 return [self._make_member(key, value['type'],
1377 def _def_struct_type(self, expr: QAPIExpression) -> None:
1383 features = self._make_features(expr.get('features'), info)
1384 self._def_definition(QAPISchemaObjectType(
1386 self._make_members(data, info),
1390 self,
1398 typ = self._make_array_type(typ[0], info)
1401 def _def_union_type(self, expr: QAPIExpression) -> None:
1409 features = self._make_features(expr.get('features'), info)
1411 base = self._make_implicit_object_type(
1413 'base', self._make_members(base, info))
1415 self._make_variant(key, value['type'],
1420 self._def_definition(
1426 def _def_alternate_type(self, expr: QAPIExpression) -> None:
1432 features = self._make_features(expr.get('features'), info)
1434 self._make_variant(key, value['type'],
1439 self._def_definition(
1444 def _def_command(self, expr: QAPIExpression) -> None:
1456 features = self._make_features(expr.get('features'), info)
1458 data = self._make_implicit_object_type(
1460 'arg', self._make_members(data, info))
1463 rets = self._make_array_type(rets[0], info)
1464 self._def_definition(
1469 def _def_event(self, expr: QAPIExpression) -> None:
1475 features = self._make_features(expr.get('features'), info)
1477 data = self._make_implicit_object_type(
1479 'arg', self._make_members(data, info))
1480 self._def_definition(QAPISchemaEvent(name, info, expr.doc, ifcond,
1483 def _def_exprs(self, exprs: List[QAPIExpression]) -> None:
1486 self._def_enum_type(expr)
1488 self._def_struct_type(expr)
1490 self._def_union_type(expr)
1492 self._def_alternate_type(expr)
1494 self._def_command(expr)
1496 self._def_event(expr)
1498 self._def_include(expr)
1502 def check(self) -> None:
1503 for ent in self._entity_list:
1504 ent.check(self)
1506 for ent in self._entity_list:
1507 ent.set_module(self)
1508 for doc in self.docs:
1511 features = list(self._feature_dict.values())
1517 def visit(self, visitor: QAPISchemaVisitor) -> None:
1518 visitor.visit_begin(self)
1519 for mod in self._module_dict.values():