Lines Matching refs:self
21 def __init__(self, msg=None):
78 def __init__(self, *args, **kwargs):
81 self.currentExtension = ''
84 self.trace = False
87 def null(self):
92 return self.conventions.null
95 def structtype_member_name(self):
100 return self.conventions.structtype_member_name
103 def nextpointer_member_name(self):
108 return self.conventions.nextpointer_member_name
110 def makeProseList(self, elements, fmt=plf.AND,
125 return self.conventions.makeProseList(elements,
131 def makeProseListIs(self, elements, fmt=plf.AND,
146 return self.conventions.makeProseList(elements,
152 def makeValidityCollection(self, entity_name):
154 return ValidityCollection(entity_name, self.conventions)
156 def beginFile(self, genOpts):
160 self.conventions = genOpts.conventions
163 self.valid_pointer_text = ' '.join(
164 (x for x in (self.conventions.valid_pointer_prefix, 'pointer') if x))
165 OutputGenerator.beginFile(self, genOpts)
167 def endFile(self):
168 OutputGenerator.endFile(self)
170 def beginFeature(self, interface, emit):
172 OutputGenerator.beginFeature(self, interface, emit)
173 self.currentExtension = interface.get('name')
175 def endFeature(self):
177 OutputGenerator.endFeature(self)
180 def struct_macro(self):
183 return self.conventions.struct_macro
185 def makeStructName(self, name):
188 return self.conventions.makeStructName(name)
190 def makeParameterName(self, name):
194 def makeBaseTypeName(self, name):
198 def makeEnumerationName(self, name):
202 def makeFlagsName(self, name):
206 def makeFuncPointerName(self, name):
210 def makeExternalTypeName(self, name):
213 return self.conventions.makeExternalTypeName(name)
215 def makeEnumerantName(self, name):
219 def writeInclude(self, directory, basename, validity: ValidityCollection,
234 directory = Path(self.genOpts.directory) / directory
235 self.makeDir(str(directory))
238 filename = str(directory / f'{basename}{self.file_suffix}')
239 self.logMsg('diag', '# Generating include file:', filename)
242 write(self.conventions.warning_comment, file=fp)
267 write(self.makeCommandPropertiesTableHeader(), file=fp)
296 def paramIsStaticArray(self, param):
301 def paramIsConst(self, param):
305 def staticArrayLength(self, param):
311 # return self.makeEnumerantName(paramenumsize.text)
315 def getHandleDispatchableAncestors(self, typename):
320 current = self.getHandleParent(current)
323 if self.isHandleTypeDispatchable(current):
326 def isHandleTypeDispatchable(self, handlename):
328 handle = self.registry.tree.find(
335 def isHandleOptional(self, param, params):
345 if self.paramIsArray(param):
353 self.logMsg('warn', length.other_param_name,
360 def makeOptionalPre(self, param):
364 type_category = self.getTypeCategory(paramtype)
367 if self.paramIsArray(param) or self.paramIsPointer(param):
368 optional_val = self.null
370 if self.isHandleTypeDispatchable(paramtype):
371 optional_val = self.null
373 optional_val = 'dlink:' + self.conventions.api_prefix + 'NULL_HANDLE'
375 optional_val = self.conventions.zero
377 self.makeParameterName(param_name),
382 def makeParamValidityPre(self, param, params, selector):
396 self.makeParameterName(selector),
397 self.makeEnumerantName(selection))
401 optionalpre = self.makeOptionalPre(param)
406 if self.paramIsStaticArray(param):
411 if self.paramIsArray(param) and param.get('len') != LengthEntry.NULL_TERMINATED_STRING:
428 if self.paramIsPointer(other_param):
430 'the value referenced by ' + self.makeParameterName(length.other_param_name))
433 self.makeParameterName(length.other_param_name))
439 entry += self.makeProseListIs(optionallengths, fmt=plf.OR)
440 entry += ' not %s, ' % self.conventions.zero
446 entry += self.makeParameterName(param_name)
448 # entry += ' is not {}, '.format(self.null)
453 entry += self.makeOptionalPre(param)
460 def createValidationLineForParameterImpl(self, blockname, param, params, typetext, selector, parentname):
468 validity = self.makeValidityCollection(blockname)
472 entry = self.makeParamValidityPre(param, params, selector)
475 if self.conventions.xml_api_name == "vulkansc" and param_name == 'pAllocator' and paramtype == 'VkAllocationCallbacks':
482 entry += 'the {} member of {} must: be '.format(self.makeParameterName(param_name), self.makeParameterName(parentname))
484 entry += '{} must: be '.format(self.makeParameterName(param_name))
486 if self.paramIsStaticArray(param) and paramtype == 'char':
488 if self.paramIsConst(param) or blockname.startswith(self.conventions.type_prefix):
490 entry += self.staticArrayLength(param)
493 entry += 'a character array of length %s ' % self.staticArrayLength(param)
497 elif self.paramIsArray(param):
507 pointer_text = self.valid_pointer_text
510 pointer_text = self.valid_pointer_text + 's'
530 entry += self.makeParameterName(str(length))
557 elif self.paramIsConst(param):
562 if not self.isStructAlwaysValid(paramtype):
569 if array_element_optional and self.getTypeCategory(paramtype) != 'bitmask': # bitmask is handled later
570 entry += 'or dlink:' + self.conventions.api_prefix + 'NULL_HANDLE '
578 return self.handleRequiredBitmask(blockname, param, paramtype, entry, 'true' if array_element_optional else None)
580 if self.paramIsPointer(param):
597 entry += (self.valid_pointer_text + ' to a ') * pointercount
607 elif self.paramIsConst(param) and paramtype != 'void':
611 return self.handleRequiredBitmask(blockname, param, paramtype, entry, param.get('optional'))
614 if self.getTypeCategory(paramtype) == 'bitmask':
620 # entry += self.conventions.zero
625 return self.handleRequiredBitmask(blockname, param, paramtype, entry, param.get('optional'))
631 def handleRequiredBitmask(self, blockname, param, paramtype, entry, optional):
633 if self.getTypeCategory(paramtype) != 'bitmask' or optional == 'true':
635 if self.paramIsPointer(param) and not self.paramIsArray(param):
641 validity = self.makeValidityCollection(blockname)
645 if self.paramIsArray(param):
648 self.makeParameterName(param_name), self.conventions.zero)
652 def createValidationLineForParameter(self, blockname, param, params, typecategory, selector, parentname):
657 is_array = self.paramIsArray(param)
658 is_pointer = self.paramIsPointer(param)
661 or not self.isStructAlwaysValid(paramtype))
672 bitselem = self.registry.tree.find("enums[@name='" + bitsname + "']")
675 typeElem = self.registry.lookupElementInfo(bitsname, self.registry.typedict)
677 alias = self.registry.getAlias(typeElem.elem, self.registry.typedict)
679 bitselem = self.registry.tree.find("enums[@name='" + alias + "']")
686 entry += self.makeParameterName(param_name)
688 entry += self.conventions.zero
692 is_const = self.paramIsConst(param)
710 bitsname=self.makeEnumerationName(bitsname),
711 paramtype=self.makeFlagsName(paramtype))
714 typetext = '{} handle'.format(self.makeStructName(paramtype))
717 typetext = '{} value'.format(self.makeEnumerationName(paramtype))
720 typetext = '{} value'.format(self.makeFuncPointerName(paramtype))
725 self.makeStructName(paramtype))
729 typetext = '{} union'.format(self.makeStructName(paramtype))
731 elif self.paramIsArray(param) or self.paramIsPointer(param):
736 typetext = '{} value'.format(self.makeBaseTypeName(paramtype))
739 if not self.isStructAlwaysValid(paramtype):
741 self.makeExternalTypeName(paramtype))
749 return self.createValidationLineForParameterImpl(
753 def makeHandleValidityParent(self, param, params):
769 handleparent = self.getHandleParent(paramtype)
771 if self.trace:
786 is_optional = self.isHandleOptional(param, params)
788 if self.paramIsArray(param):
798 entry += template.format(self.makeParameterName(param_name))
801 self.makeParameterName(parent_name))
805 def makeAsciiDocHandlesCommonAncestor(self, blockname, handles, params):
811 See self.makeAsciiDocHandleParent() for instances where the parent
826 if not self.paramIsPointer(param) or (param.text and 'const' in param.text):
827 ancestors = self.getHandleDispatchableAncestors(paramtype)
831 anyoptional |= self.isHandleOptional(param, params)
863 parametertext = self.makeParameterName(param_name)
864 if self.paramIsArray(param):
875 entry += self.makeProseList(parametertexts,
880 entry += self.makeStructName(commonancestor)
884 def makeStructureTypeFromName(self, structname):
886 return self.makeEnumerantName(self.conventions.generate_structure_type_from_name(structname))
888 def makeStructureTypeValidity(self, structname):
893 info = self.registry.typedict.get(structname)
903 param = findNamedElem(members, self.structtype_member_name)
910 anchor=(self.structtype_member_name, self.structtype_member_name))
911 entry += self.makeParameterName(self.structtype_member_name)
920 entry += self.makeProseList((self.makeEnumerantName(v)
930 self.logMsg('warn', 'No values were marked-up for the structure type member of',
932 entry += self.makeStructureTypeFromName(structname)
936 def makeStructureExtensionPointer(self, blockname, param):
941 self.logMsg('warn', blockname,
945 anchor=(param_name, self.nextpointer_member_name))
946 validextensionstructs = self.registry.validextensionstructs.get(
960 t = self.registry.lookupElementInfo(
961 struct, self.registry.typedict)
963 self.logMsg('warn', 'makeStructureExtensionPointer: struct', struct,
970 self.logMsg(
975 self.makeParameterName(param_name), self.null)
979 entry += '{} must: be {} or a pointer to a valid instance of {}'.format(self.makeParameterName(param_name), self.null,
984 self.makeParameterName(param_name), self.nextpointer_member_name)
986 self.null)
988 entry += self.makeProseList(extensionstructs, fmt=plf.OR)
990 validity = self.makeValidityCollection(blockname)
999 self.structtype_member_name +
1001 self.nextpointer_member_name +
1003 anchor = (self.conventions.member_used_for_unique_vuid, 'unique')
1011 self.makeProseList(duplicatestructs, fmt=plf.OR))
1017 def addSharedStructMemberValidity(self, struct, blockname, param, validity):
1025 if self.conventions.is_structure_type_member(paramtype, param_name):
1026 validity += self.makeStructureTypeValidity(blockname)
1029 if self.conventions.is_nextpointer_member(paramtype, param_name):
1032 validity += self.makeStructureExtensionPointer(
1037 def makeOutputOnlyStructValidity(self, cmd, blockname, params):
1045 validity = self.makeValidityCollection(blockname)
1048 self.addSharedStructMemberValidity(
1053 def isVKVersion11(self):
1055 vk11 = re.match(self.registry.genOpts.emitversions, 'VK_VERSION_1_1') is not None
1058 def videocodingRequired(self):
1061 return 'VK_KHR_video_queue' in self.registry.requiredextensions
1063 def getVideocoding(self, cmd):
1071 def conditionallyRemoveQueueType(self, queues, queuetype, condition):
1076 def getQueueList(self, cmd):
1084 self.conditionallyRemoveQueueType(queues, 'sparse_binding', self.conventions.xml_api_name == "vulkansc")
1085 self.conditionallyRemoveQueueType(queues, 'decode', 'VK_KHR_video_decode_queue' not in self.registry.requiredextensions)
1086 self.conditionallyRemoveQueueType(queues, 'encode', 'VK_KHR_video_encode_queue' not in self.registry.requiredextensions)
1087 self.conditionallyRemoveQueueType(queues, 'opticalflow', 'VK_NV_optical_flow' not in self.registry.requiredextensions)
1092 self.logMsg('error', f'Unknown queue type "{queue}".')
1096 def getPrettyQueueList(self, cmd):
1098 queues = self.getQueueList(cmd)
1108 def makeStructOrCommandValidity(self, cmd, blockname, params):
1110 validity = self.makeValidityCollection(blockname)
1123 typecategory = self.getTypeCategory(paramtype)
1125 if not self.addSharedStructMemberValidity(
1128 validity += self.createValidationLineForParameter(
1133 self.logMsg('warn', 'selector attribute set on non-union parameter', param_name, 'in', blockname)
1135 paraminfo = self.registry.lookupElementInfo(paramtype, self.registry.typedict)
1139 membertypecategory = self.getTypeCategory(membertype)
1141 validity += self.createValidationLineForParameter(
1158 queues = self.getPrettyQueueList(cmd)
1162 entry += self.makeProseList(queues,
1184 if self.isVKVersion11() or 'VK_KHR_maintenance1' in self.registry.requiredextensions:
1190 queues = self.getPrettyQueueList(cmd)
1193 entry += self.makeProseList(queues,
1209 if self.videocodingRequired():
1210 videocoding = self.getVideocoding(cmd)
1256 array_length_parent = self.registry.tree.find("./types/type/[@name='{}']".format(type))
1276 optional_array_names = (self.makeParameterName(getElemName(array))
1278 entry += self.makeProseListIs(optional_array_names,
1281 entry += ' not {}, '.format(self.null)
1284 if self.paramIsPointer(param):
1288 entry += '::'.join(self.makeParameterName(part)
1291 # entry += length.get_human_readable(make_param_name=self.makeParameterName)
1294 entry += self.conventions.zero
1300 if not self.paramIsPointer(param) or self.paramIsConst(param):
1301 validity += self.makeHandleValidityParent(param, params)
1304 validity += self.makeAsciiDocHandlesCommonAncestor(
1309 def makeThreadSafetyBlock(self, cmd, paramtext):
1312 validity = self.makeValidityCollection(getElemName(cmd))
1329 if self.paramIsArray(param):
1331 elif self.paramIsPointer(param):
1334 entry += self.makeParameterName(param_name)
1343 # entry += attrib.get_human_readable(make_param_name=self.makeParameterName)
1367 def makeCommandPropertiesTableHeader(self):
1370 if self.videocodingRequired():
1376 def makeCommandPropertiesTableEntry(self, cmd, name):
1389 if self.videocodingRequired():
1390 videocoding = self.getVideocoding(cmd).capitalize()
1397 if self.isVKVersion11() or 'VK_KHR_maintenance1' in self.registry.requiredextensions:
1402 queues = self.getQueueList(cmd)
1413 if self.videocodingRequired():
1416 queues = self.getQueueList(cmd)
1430 def findRequiredEnums(self, enums):
1435 return self.keepOnlyRequired(enums, self.registry.enumdict)
1437 def findRequiredCommands(self, commands):
1442 return self.keepOnlyRequired(commands, self.registry.cmddict)
1444 def keepOnlyRequired(self, names, info_dict):
1452 info = self.registry.lookupElementInfo(name, info_dict)
1456 self.logMsg('diag', 'keepOnlyRequired: element',
1464 def makeReturnCodeList(self, attrib, cmd, name):
1474 codes = self.findRequiredEnums(codes_attr.split(','))
1480 for ext_code in self.registry.commandextensionsuccesses
1486 self.conventions.formatExtension(ext_code.extension))
1494 def makeSuccessCodes(self, cmd, name):
1495 return self.makeReturnCodeList('successcodes', cmd, name)
1497 def makeErrorCodes(self, cmd, name):
1498 return self.makeReturnCodeList('errorcodes', cmd, name)
1500 def genCmd(self, cmdinfo, name, alias):
1502 OutputGenerator.genCmd(self, cmdinfo, name, alias)
1506 validity = self.makeValidityCollection(name)
1509 # validity.possiblyAddExtensionRequirement(self.currentExtension, 'calling flink:')
1511 validity += self.makeStructOrCommandValidity(
1514 threadsafety = self.makeThreadSafetyBlock(cmdinfo.elem, 'param')
1518 commandpropertiesentry = self.makeCommandPropertiesTableEntry(
1520 successcodes = self.makeSuccessCodes(cmdinfo.elem, name)
1521 errorcodes = self.makeErrorCodes(cmdinfo.elem, name)
1524 # self.generateStateValidity(validity, name)
1526 self.writeInclude('protos', name, validity, threadsafety,
1529 def genStruct(self, typeinfo, typeName, alias):
1531 OutputGenerator.genStruct(self, typeinfo, typeName, alias)
1537 validity = self.makeValidityCollection(typeName)
1541 # validity.possiblyAddExtensionRequirement(self.currentExtension, 'using slink:')
1545 validity += self.makeStructOrCommandValidity(
1547 threadsafety = self.makeThreadSafetyBlock(typeinfo.elem, 'member')
1551 validity += self.makeOutputOnlyStructValidity(
1554 self.writeInclude('structs', typeName, validity,
1557 def genGroup(self, groupinfo, groupName, alias):
1562 OutputGenerator.genGroup(self, groupinfo, groupName, alias)
1574 ei = self.registry.lookupElementInfo(name, self.registry.enumdict)
1577 self.logMsg('error',
1581 ei.required = self.isEnumRequired(elem)
1583 def genType(self, typeinfo, name, alias):
1585 OutputGenerator.genType(self, typeinfo, name, alias)
1591 self.genStruct(typeinfo, name, alias)