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)
768 self.gen.logMsg('diag', 'Generating dependent command',
770 self.markCmdRequired(depname, required)
780 …self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type_elem.text)
781 self.markTypeRequired(type_elem.text, required)
783 self.gen.logMsg('warn', 'command:', cmdname, 'IS NOT DEFINED')
785 def markRequired(self, featurename, feature, required): argument
791 … self.gen.logMsg('diag', 'markRequired (feature = <too long to print>, required =', required, ')')
797 self.markTypeRequired(typeElem.get('name'), required)
799 self.markEnumRequired(enumElem.get('name'), required)
801 self.markCmdRequired(cmdElem.get('name'), required)
812 … self.commandextensionsuccesses.append(self.commandextensiontuple(command=commandName,
818 … self.commandextensionerrors.append(self.commandextensiontuple(command=commandName,
822 self.gen.logMsg('warn', 'extend type:', extendType, 'IS NOT SUPPORTED')
824 def getAlias(self, elem, dict): argument
833 typeinfo = self.lookupElementInfo(name, dict)
838 def checkForCorrectionAliases(self, alias, require, tag): argument
850 def fillFeatureDictionary(self, interface, featurename, api, profile): argument
860 self.gen.featureDictionary[featurename] = {
887 typeinfo = self.lookupElementInfo(typename, self.typedict)
891 alias = self.getAlias(typeElem, self.typedict)
892 if not self.checkForCorrectionAliases(alias, require, 'type'):
895 typeinfo = self.lookupElementInfo(alias, self.typedict)
900 if not required_key in self.gen.featureDictionary[featurename][typecat]:
901 self.gen.featureDictionary[featurename][typecat][required_key] = {}
902 … if not typeextends in self.gen.featureDictionary[featurename][typecat][required_key]:
903 … self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
904 … self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
908 typeinfo = self.lookupElementInfo(enumname, self.enumdict)
911 alias = self.getAlias(enumElem, self.enumdict)
912 if not self.checkForCorrectionAliases(alias, require, 'enum'):
914 … if not required_key in self.gen.featureDictionary[featurename]['enumconstant']:
915 … self.gen.featureDictionary[featurename]['enumconstant'][required_key] = {}
916 … if not enumextends in self.gen.featureDictionary[featurename]['enumconstant'][required_key]:
917 … self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
918 …self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
923 alias = self.getAlias(cmdElem, self.cmddict)
924 if not self.checkForCorrectionAliases(alias, require, 'command'):
925 if not required_key in self.gen.featureDictionary[featurename]['command']:
926 self.gen.featureDictionary[featurename]['command'][required_key] = []
927 … self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
930 def requireAndRemoveFeatures(self, interface, featurename, api, profile): argument
941 self.markRequired(featurename, feature, True)
945 self.markRequired(featurename, feature, False)
947 def assignAdditionalValidity(self, interface, api, profile): argument
953 self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v))
955 self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v))
962 self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v))
964 self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v))
966 def generateFeature(self, fname, ftype, dictionary): argument
974 self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname)
975 f = self.lookupElementInfo(fname, dictionary)
978 self.gen.logMsg('diag', 'No entry found for feature', fname,
984 self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)')
987 self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)')
995 self.gen.logMsg('diag', fname, 'is an alias of', alias)
1007 genProc = self.gen.genType
1011 self.generateFeature(alias, 'type', self.typedict)
1014 self.gen.logMsg('diag', 'Generating required dependent type',
1016 self.generateFeature(requires, 'type', self.typedict)
1023 self.gen.logMsg('diag', 'Generating required dependent <type>',
1025 self.generateFeature(subtype.text, 'type', self.typedict)
1030 self.gen.logMsg('diag', 'Generating required dependent <enum>',
1032 self.generateFeature(subtype.text, 'enum', self.enumdict)
1037 self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead')
1038 group = self.lookupElementInfo(fname, self.groupdict)
1042 self.gen.logMsg('diag', 'Generating alias', fname,
1046 genProc = self.gen.genGroup
1047 f = self.lookupElementInfo(alias, self.groupdict)
1049 self.gen.logMsg('warn', 'Skipping enum type', fname,
1053 genProc = self.gen.genGroup
1069 self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname)
1084 if self.genOpts.defaultExtensions == elem.get('supported'):
1086 elif re.match(self.genOpts.addExtensions, extname) is not None:
1089 required = re.match(self.genOpts.emitversions, version) is not None
1093 self.gen.logMsg('diag', '* required =', required, 'for', name)
1105 self.gen.logMsg('diag', '* also need to require alias', name)
1111 self.generateFeature(alias, 'command', self.cmddict)
1113 genProc = self.gen.genCmd
1116 self.gen.logMsg('diag', 'Generating required parameter type',
1118 self.generateFeature(depname, 'type', self.typedict)
1122 self.generateFeature(alias, 'enum', self.enumdict)
1123 genProc = self.gen.genEnum
1126 if self.emitFeatures:
1127 self.gen.logMsg('diag', 'Emitting', ftype, 'decl for', fname)
1130 self.gen.logMsg('diag', 'Skipping', ftype, fname,
1134 self.gen.logMsg('diag', 'Generating required bitvalues <enum>',
1136 self.generateFeature(followupFeature, "type", self.typedict)
1138 def generateRequiredInterface(self, interface): argument
1146 self.generateFeature(t.get('name'), 'type', self.typedict)
1153 self.generateFeature(e.get('name'), 'enum', self.enumdict)
1155 self.generateFeature(c.get('name'), 'command', self.cmddict)
1157 def generateSpirv(self, spirv, dictionary): argument
1159 self.gen.logMsg('diag', 'No entry found for element', name,
1167 genProc = self.gen.genSpirv
1170 def apiGen(self): argument
1174 self.gen.logMsg('diag', '*******************************************')
1175 self.gen.logMsg('diag', ' Registry.apiGen file:', self.genOpts.filename,
1176 'api:', self.genOpts.apiname,
1177 'profile:', self.genOpts.profile)
1178 self.gen.logMsg('diag', '*******************************************')
1181 self.apiReset()
1184 regVersions = re.compile(self.genOpts.versions)
1185 regEmitVersions = re.compile(self.genOpts.emitversions)
1186 regAddExtensions = re.compile(self.genOpts.addExtensions)
1187 regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
1188 regEmitExtensions = re.compile(self.genOpts.emitExtensions)
1189 regEmitSpirv = re.compile(self.genOpts.emitSpirv)
1195 for key in self.apidict:
1196 fi = self.apidict[key]
1198 if apiNameMatch(self.genOpts.apiname, api):
1207 self.gen.logMsg('diag', 'NOT tagging feature api =', api,
1211 self.gen.logMsg('diag', 'Including feature api =', api,
1215 self.gen.logMsg('diag', 'NOT including feature api =', api,
1219 self.gen.logMsg('diag', 'NOT including feature api =', api,
1223 self.gen.logMsg('warn', 'No matching API versions found!')
1231 …for (extName, ei) in sorted(self.extdict.items(), key=lambda x: x[1].number if x[1].number is not …
1237 if apiNameMatch(self.genOpts.defaultExtensions,
1239 self.gen.logMsg('diag', 'Including extension',
1248 self.gen.logMsg('diag', 'Including extension',
1256 self.gen.logMsg('diag', 'Removing extension',
1266 self.gen.logMsg('diag', 'NOT tagging extension',
1273 self.requiredextensions.append(extName)
1275 self.gen.logMsg('diag', 'NOT including extension',
1282 for key in self.spirvextdict:
1283 si = self.spirvextdict[key]
1287 for key in self.spirvcapdict:
1288 si = self.spirvcapdict[key]
1293 if self.genOpts.sortProcedure:
1294 self.genOpts.sortProcedure(features)
1305 self.gen.logMsg('diag', 'PASS 1: TAG FEATURES')
1307 self.gen.logMsg('diag', 'PASS 1: Tagging required and removed features for',
1309 self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1310 … self.requireAndRemoveFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1311 self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
1316 self.gen.logMsg('diag', 'PASS 2: GENERATE INTERFACES FOR FEATURES')
1317 self.gen.beginFile(self.genOpts)
1319 self.gen.logMsg('diag', 'PASS 2: Generating interface for',
1321 emit = self.emitFeatures = f.emit
1323 self.gen.logMsg('diag', 'PASS 2: NOT declaring feature',
1327 self.gen.beginFeature(f.elem, emit)
1328 self.generateRequiredInterface(f.elem)
1329 self.gen.endFeature()
1332 self.generateSpirv(s, self.spirvextdict)
1334 self.generateSpirv(s, self.spirvcapdict)
1335 self.gen.endFile()
1337 def apiReset(self): argument
1341 for datatype in self.typedict:
1342 self.typedict[datatype].resetState()
1343 for enum in self.enumdict:
1344 self.enumdict[enum].resetState()
1345 for cmd in self.cmddict:
1346 self.cmddict[cmd].resetState()
1347 for cmd in self.apidict:
1348 self.apidict[cmd].resetState()
1350 def validateGroups(self): argument
1356 self.gen.logMsg('diag', 'VALIDATING GROUP ATTRIBUTES')
1357 for cmd in self.reg.findall('commands/command'):
1361 if group is not None and group not in self.groupdict:
1375 if group is not None and group not in self.groupdict:
1383 self.gen.logMsg('diag', 'SUMMARY OF UNRECOGNIZED GROUPS')
1385 self.gen.logMsg('diag', ' ', key, ' occurred ', badGroup[key], ' times')