Lines Matching refs:self
92 def __init__(self, elem): argument
93 self.required = False
97 self.declared = False
100 self.elem = elem
103 def resetState(self): argument
106 self.required = False
107 self.declared = False
109 def compareKeys(self, info, key, required = False): argument
115 if required and key not in self.elem.keys():
117 return self.elem.get(key) == info.elem.get(key)
119 def compareElem(self, info, infoName): argument
126 if self.compareKeys(info, 'extends'):
128 if (self.compareKeys(info, 'value', required = True) or
129 self.compareKeys(info, 'bitpos', required = True)):
133 elif (self.compareKeys(info, 'extnumber') and
134 self.compareKeys(info, 'offset') and
135 self.compareKeys(info, 'dir')):
138 elif (self.compareKeys(info, 'alias')):
155 def __init__(self, elem): argument
156 BaseInfo.__init__(self, elem)
157 self.additionalValidity = []
158 self.removedValidity = []
160 def getMembers(self): argument
162 return self.elem.findall('member')
164 def resetState(self): argument
165 BaseInfo.resetState(self)
166 self.additionalValidity = []
167 self.removedValidity = []
174 def __init__(self, elem): argument
175 BaseInfo.__init__(self, elem)
181 def __init__(self, elem): argument
182 BaseInfo.__init__(self, elem)
183 self.type = elem.get('type')
186 if self.type is None:
187 self.type = ''
193 def __init__(self, elem): argument
194 BaseInfo.__init__(self, elem)
195 self.additionalValidity = []
196 self.removedValidity = []
198 def getParams(self): argument
200 return self.elem.findall('param')
202 def resetState(self): argument
203 BaseInfo.resetState(self)
204 self.additionalValidity = []
205 self.removedValidity = []
212 def __init__(self, elem): argument
213 BaseInfo.__init__(self, elem)
214 self.name = elem.get('name')
217 self.emit = False
220 self.sortorder = int(elem.get('sortorder', 0))
228 self.category = 'VERSION'
231 self.version = elem.get('name')
234 self.versionNumber = elem.get('number')
239 self.number = "0"
240 self.supported = None
243 self.category = self.name.split('_', 2)[1]
244 self.version = "0"
245 self.versionNumber = "0"
246 self.number = elem.get('number')
252 if self.number is None:
253 self.number = 0
254 self.supported = elem.get('supported')
260 def __init__(self, elem): argument
261 BaseInfo.__init__(self, elem)
266 def __init__(self, gen=None, genOpts=None): argument
269 self.gen = OutputGenerator()
271 self.gen = gen
275 self.genOpts = GeneratorOptions()
277 self.genOpts = genOpts
280 self.gen.registry = self
281 self.gen.genOpts = self.genOpts
282 self.gen.genOpts.registry = self
284 self.tree = None
287 self.typedict = {}
290 self.groupdict = {}
293 self.enumdict = {}
296 self.cmddict = {}
299 self.apidict = {}
302 self.extensions = []
305 self.extdict = {}
308 self.spirvextdict = {}
311 self.spirvcapdict = {}
314 self.emitFeatures = False
318 self.breakPat = None
322 self.requiredextensions = [] # Hack - can remove it after validity generator goes away
326 self.commandextensiontuple = namedtuple('commandextensiontuple',
330 self.validextensionstructs = defaultdict(list)
331 self.commandextensionsuccesses = []
332 self.commandextensionerrors = []
334 self.filename = None
336 def loadElementTree(self, tree): argument
338 self.tree = tree
339 self.parseTree()
341 def loadFile(self, file): argument
343 self.filename = file
344 self.tree = etree.parse(file)
345 self.parseTree()
347 def setGenerator(self, gen): argument
351 self.gen = gen
352 self.gen.setRegistry(self)
354 def addElementInfo(self, elem, info, infoName, dictionary): argument
376 self.gen.logMsg('warn', 'Attempt to redefine', key,
383 def lookupElementInfo(self, fname, dictionary): argument
392 key = (fname, self.genOpts.apiname)
402 def breakOnName(self, regexp): argument
404 self.breakPat = re.compile(regexp)
406 def parseTree(self): argument
409 self.reg = self.tree.getroot()
417 self.typedict = {}
418 for type_elem in self.reg.findall('types/type'):
423 self.addElementInfo(type_elem, TypeInfo(type_elem), 'type', self.typedict)
430 self.groupdict = {}
431 for group in self.reg.findall('enums'):
432 self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict)
443 self.enumdict = {}
444 for enums in self.reg.findall('enums'):
449 self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
457 self.cmddict = {}
462 for cmd in self.reg.findall('commands/command'):
469 self.addElementInfo(cmd, ci, 'command', self.cmddict)
478 if alias in self.cmddict:
479 aliasInfo = self.cmddict[alias]
486 self.cmddict[name] = ci
491 self.gen.logMsg('warn', 'No matching <command> found for command',
496 self.apidict = {}
497 for feature in self.reg.findall('feature'):
499 self.addElementInfo(feature, featureInfo, 'feature', self.apidict)
525 if groupName in self.groupdict:
528 gi = self.groupdict[groupName]
531 self.gen.logMsg('warn', 'NO matching group',
540 self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
542 self.extensions = self.reg.findall('extensions/extension')
543 self.extdict = {}
544 for feature in self.extensions:
546 self.addElementInfo(feature, featureInfo, 'extension', self.extdict)
572 if groupName in self.groupdict:
575 gi = self.groupdict[groupName]
578 self.gen.logMsg('warn', 'NO matching group',
587 self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
592 for disabled_ext in self.reg.findall('extensions/extension[@supported="disabled"]'):
595 for type_elem in self.reg.findall('types/type'):
601 self.validextensionstructs[parent].append(type_elem.get('name'))
603 for parent in self.validextensionstructs:
604 self.validextensionstructs[parent].sort()
608 for spirv in self.reg.findall('spirvextensions/spirvextension'):
610 self.addElementInfo(spirv, spirvInfo, 'spirvextension', self.spirvextdict)
611 for spirv in self.reg.findall('spirvcapabilities/spirvcapability'):
613 self.addElementInfo(spirv, spirvInfo, 'spirvcapability', self.spirvcapdict)
615 def dumpReg(self, maxlen=120, filehandle=sys.stdout): argument
624 for name in self.typedict:
625 tobj = self.typedict[name]
628 for name in self.groupdict:
629 gobj = self.groupdict[name]
632 for name in self.enumdict:
633 eobj = self.enumdict[name]
636 for name in self.cmddict:
637 cobj = self.cmddict[name]
640 for key in self.apidict:
642 etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle)
644 for key in self.extdict:
646 etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle)
648 for key in self.spirvextdict:
650 etree.tostring(self.spirvextdict[key].elem)[0:maxlen], file=filehandle)
651 for key in self.spirvcapdict:
653 etree.tostring(self.spirvcapdict[key].elem)[0:maxlen], file=filehandle)
655 def markTypeRequired(self, typename, required): argument
661 self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required)
663 typeinfo = self.lookupElementInfo(typename, self.typedict)
672 self.gen.logMsg('diag', 'Generating dependent type',
676 self.markTypeRequired(depname, required)
678 self.gen.logMsg('diag', 'type', typename, 'is self-referential')
684 … self.gen.logMsg('diag', 'markRequired: type requires dependent <type>', subtype.text)
686 self.markTypeRequired(subtype.text, required)
688 self.gen.logMsg('diag', 'type', typename, 'is self-referential')
692 … self.gen.logMsg('diag', 'markRequired: type requires dependent <enum>', subenum.text)
693 self.markEnumRequired(subenum.text, required)
699 self.gen.logMsg('diag', 'Generating bitflag type',
701 self.markTypeRequired(depType, required)
702 group = self.lookupElementInfo(depType, self.groupdict)
708 self.gen.logMsg('warn', 'type:', typename, 'IS NOT DEFINED')
710 def markEnumRequired(self, enumname, required): argument
716 self.gen.logMsg('diag', 'tagging enum:', enumname, '-> required =', required)
717 enum = self.lookupElementInfo(enumname, self.enumdict)
731 if groupName in self.groupdict:
732 gi = self.groupdict[groupName]
738 self.gen.logMsg('warn', 'Cannot remove enum',
742 self.gen.logMsg('warn', 'Cannot remove enum',
750 self.gen.logMsg('diag', 'Generating dependent enum',
752 self.markEnumRequired(depname, required)
754 self.gen.logMsg('warn', 'enum:', enumname, 'IS NOT DEFINED')
756 def markCmdRequired(self, cmdname, required): argument
761 self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required)
762 cmd = self.lookupElementInfo(cmdname, self.cmddict)
775 if self.genOpts.requireCommandAliases:
778 self.gen.logMsg('diag', 'Generating dependent command',
780 self.markCmdRequired(depname, required)
791 …self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type_elem.text)
792 self.markTypeRequired(type_elem.text, required)
794 self.gen.logMsg('warn', 'command:', cmdname, 'IS NOT DEFINED')
796 def markRequired(self, featurename, feature, required): argument
802 … self.gen.logMsg('diag', 'markRequired (feature = <too long to print>, required =', required, ')')
808 self.markTypeRequired(typeElem.get('name'), required)
810 self.markEnumRequired(enumElem.get('name'), required)
812 self.markCmdRequired(cmdElem.get('name'), required)
823 … self.commandextensionsuccesses.append(self.commandextensiontuple(command=commandName,
829 … self.commandextensionerrors.append(self.commandextensiontuple(command=commandName,
833 self.gen.logMsg('warn', 'extend type:', extendType, 'IS NOT SUPPORTED')
835 def getAlias(self, elem, dict): argument
844 typeinfo = self.lookupElementInfo(name, dict)
849 def checkForCorrectionAliases(self, alias, require, tag): argument
866 def fillFeatureDictionary(self, interface, featurename, api, profile): argument
876 self.gen.featureDictionary[featurename] = {
903 typeinfo = self.lookupElementInfo(typename, self.typedict)
907 alias = self.getAlias(typeElem, self.typedict)
908 if not self.checkForCorrectionAliases(alias, require, 'type'):
911 typeinfo = self.lookupElementInfo(alias, self.typedict)
916 if not required_key in self.gen.featureDictionary[featurename][typecat]:
917 self.gen.featureDictionary[featurename][typecat][required_key] = {}
918 … if not typeextends in self.gen.featureDictionary[featurename][typecat][required_key]:
919 … self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
920 … self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
922 … self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
927 typeinfo = self.lookupElementInfo(enumname, self.enumdict)
930 alias = self.getAlias(enumElem, self.enumdict)
931 if not self.checkForCorrectionAliases(alias, require, 'enum'):
933 … if not required_key in self.gen.featureDictionary[featurename]['enumconstant']:
934 … self.gen.featureDictionary[featurename]['enumconstant'][required_key] = {}
935 … if not enumextends in self.gen.featureDictionary[featurename]['enumconstant'][required_key]:
936 … self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
937 …self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
939 … self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
943 alias = self.getAlias(cmdElem, self.cmddict)
944 if not self.checkForCorrectionAliases(alias, require, 'command'):
945 if not required_key in self.gen.featureDictionary[featurename]['command']:
946 self.gen.featureDictionary[featurename]['command'][required_key] = []
947 … self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
949 … self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
951 def requireAndRemoveFeatures(self, interface, featurename, api, profile): argument
963 self.markRequired(featurename, feature, True)
968 self.markRequired(featurename, feature, False)
970 def assignAdditionalValidity(self, interface, api, profile): argument
976 self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v))
978 self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v))
985 self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v))
987 self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v))
989 def generateFeature(self, fname, ftype, dictionary): argument
997 self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname)
998 f = self.lookupElementInfo(fname, dictionary)
1001 self.gen.logMsg('diag', 'No entry found for feature', fname,
1007 self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)')
1010 self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)')
1018 self.gen.logMsg('diag', fname, 'is an alias of', alias)
1030 genProc = self.gen.genType
1034 self.generateFeature(alias, 'type', self.typedict)
1037 self.gen.logMsg('diag', 'Generating required dependent type',
1039 self.generateFeature(requires, 'type', self.typedict)
1046 self.gen.logMsg('diag', 'Generating required dependent <type>',
1048 self.generateFeature(subtype.text, 'type', self.typedict)
1053 self.gen.logMsg('diag', 'Generating required dependent <enum>',
1055 self.generateFeature(subtype.text, 'enum', self.enumdict)
1060 self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead')
1061 group = self.lookupElementInfo(fname, self.groupdict)
1065 self.gen.logMsg('diag', 'Generating alias', fname,
1069 genProc = self.gen.genGroup
1070 f = self.lookupElementInfo(alias, self.groupdict)
1072 self.gen.logMsg('warn', 'Skipping enum type', fname,
1076 genProc = self.gen.genGroup
1092 self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname)
1107 if self.genOpts.defaultExtensions == elem.get('supported'):
1109 elif re.match(self.genOpts.addExtensions, extname) is not None:
1112 required = re.match(self.genOpts.emitversions, version) is not None
1116 self.gen.logMsg('diag', '* required =', required, 'for', name)
1128 self.gen.logMsg('diag', '* also need to require alias', name)
1134 self.generateFeature(alias, 'command', self.cmddict)
1136 genProc = self.gen.genCmd
1139 self.gen.logMsg('diag', 'Generating required parameter type',
1141 self.generateFeature(depname, 'type', self.typedict)
1145 self.generateFeature(alias, 'enum', self.enumdict)
1146 genProc = self.gen.genEnum
1149 if self.emitFeatures:
1150 self.gen.logMsg('diag', 'Emitting', ftype, 'decl for', fname)
1153 self.gen.logMsg('diag', 'Skipping', ftype, fname,
1157 self.gen.logMsg('diag', 'Generating required bitvalues <enum>',
1159 self.generateFeature(followupFeature, "type", self.typedict)
1161 def generateRequiredInterface(self, interface): argument
1169 self.generateFeature(t.get('name'), 'type', self.typedict)
1176 self.generateFeature(e.get('name'), 'enum', self.enumdict)
1178 self.generateFeature(c.get('name'), 'command', self.cmddict)
1180 def generateSpirv(self, spirv, dictionary): argument
1182 self.gen.logMsg('diag', 'No entry found for element', name,
1190 genProc = self.gen.genSpirv
1193 def stripUnsupportedAPIs(self, dictionary, attribute, supportedDictionary): argument
1219 def apiGen(self): argument
1223 self.gen.logMsg('diag', '*******************************************')
1224 self.gen.logMsg('diag', ' Registry.apiGen file:', self.genOpts.filename,
1225 'api:', self.genOpts.apiname,
1226 'profile:', self.genOpts.profile)
1227 self.gen.logMsg('diag', '*******************************************')
1238 regVersions = re.compile(self.genOpts.versions)
1239 regEmitVersions = re.compile(self.genOpts.emitversions)
1240 regAddExtensions = re.compile(self.genOpts.addExtensions)
1241 regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
1242 regEmitExtensions = re.compile(self.genOpts.emitExtensions)
1243 regEmitSpirv = re.compile(self.genOpts.emitSpirv)
1249 for key in self.apidict:
1250 fi = self.apidict[key]
1252 if apiNameMatch(self.genOpts.apiname, api):
1261 self.gen.logMsg('diag', 'NOT tagging feature api =', api,
1265 self.gen.logMsg('diag', 'Including feature api =', api,
1269 self.gen.logMsg('diag', 'NOT including feature api =', api,
1273 self.gen.logMsg('diag', 'NOT including feature api =', api,
1277 self.gen.logMsg('warn', 'No matching API versions found!')
1285 …for (extName, ei) in sorted(self.extdict.items(), key=lambda x: x[1].number if x[1].number is not …
1291 if apiNameMatch(self.genOpts.defaultExtensions,
1293 self.gen.logMsg('diag', 'Including extension',
1303 if not apiNameMatch(self.genOpts.apiname, ei.elem.get('supported')):
1304 self.gen.logMsg('diag', 'NOT including extension',
1308 self.gen.logMsg('diag', 'Including extension',
1316 self.gen.logMsg('diag', 'Removing extension',
1326 self.gen.logMsg('diag', 'NOT tagging extension',
1333 self.requiredextensions.append(extName)
1335 self.gen.logMsg('diag', 'NOT including extension',
1342 for key in self.spirvextdict:
1343 si = self.spirvextdict[key]
1347 for key in self.spirvcapdict:
1348 si = self.spirvcapdict[key]
1353 if self.genOpts.sortProcedure:
1354 self.genOpts.sortProcedure(features)
1365 self.gen.logMsg('diag', 'PASS 1: TAG FEATURES')
1367 self.gen.logMsg('diag', 'PASS 1: Tagging required and removed features for',
1369 self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1370 … self.requireAndRemoveFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1371 self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
1377 self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict)
1378 self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict)
1379 self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict)
1391 self.gen.logMsg('diag', 'PASS 2: GENERATE INTERFACES FOR FEATURES')
1392 self.gen.beginFile(self.genOpts)
1394 self.gen.logMsg('diag', 'PASS 2: Generating interface for',
1396 emit = self.emitFeatures = f.emit
1398 self.gen.logMsg('diag', 'PASS 2: NOT declaring feature',
1402 self.gen.beginFeature(f.elem, emit)
1403 self.generateRequiredInterface(f.elem)
1404 self.gen.endFeature()
1407 self.generateSpirv(s, self.spirvextdict)
1409 self.generateSpirv(s, self.spirvcapdict)
1410 self.gen.endFile()
1412 def apiReset(self): argument
1416 for datatype in self.typedict:
1417 self.typedict[datatype].resetState()
1418 for enum in self.enumdict:
1419 self.enumdict[enum].resetState()
1420 for cmd in self.cmddict:
1421 self.cmddict[cmd].resetState()
1422 for cmd in self.apidict:
1423 self.apidict[cmd].resetState()
1425 def __validateStructLimittypes(self, struct): argument
1439 memberType = self.typedict[typeName]
1440 badFields.update(self.__validateStructLimittypes(memberType))
1445 def __validateLimittype(self): argument
1447 self.gen.logMsg('diag', 'VALIDATING LIMITTYPE ATTRIBUTES')
1448 badFields = self.__validateStructLimittypes(self.typedict['VkPhysicalDeviceProperties2'])
1449 for featStructName in self.validextensionstructs['VkPhysicalDeviceProperties2']:
1450 featStruct = self.typedict[featStructName]
1451 badFields.update(self.__validateStructLimittypes(featStruct))
1454 self.gen.logMsg('diag', 'SUMMARY OF FIELDS WITH INCORRECT LIMITTYPES')
1458 … self.gen.logMsg('diag', ' ', key, 'missing limittype:', ', '.join(badFields[key].missing))
1460 … self.gen.logMsg('diag', ' ', key, 'invalid limittype:', ', '.join(badFields[key].invalid))
1464 def validateRegistry(self): argument
1466 return self.__validateLimittype()