Lines Matching refs:self
201 def __init__(self, elem):
202 self.required = False
206 self.declared = False
209 self.elem = elem
212 def resetState(self):
215 self.required = False
216 self.declared = False
218 def compareKeys(self, info, key, required = False):
219 """Return True if self.elem and info.elem have the same attribute
224 if required and key not in self.elem.keys():
226 return self.elem.get(key) == info.elem.get(key)
228 def compareElem(self, info, infoName):
229 """Return True if self.elem and info.elem have the same definition.
235 if self.compareKeys(info, 'extends'):
237 if (self.compareKeys(info, 'value', required = True) or
238 self.compareKeys(info, 'bitpos', required = True)):
242 elif (self.compareKeys(info, 'extnumber') and
243 self.compareKeys(info, 'offset') and
244 self.compareKeys(info, 'dir')):
247 elif (self.compareKeys(info, 'alias')):
264 def __init__(self, elem):
265 BaseInfo.__init__(self, elem)
266 self.additionalValidity = []
267 self.removedValidity = []
269 def getMembers(self):
271 return self.elem.findall('member')
273 def resetState(self):
274 BaseInfo.resetState(self)
275 self.additionalValidity = []
276 self.removedValidity = []
283 def __init__(self, elem):
284 BaseInfo.__init__(self, elem)
290 def __init__(self, elem):
291 BaseInfo.__init__(self, elem)
292 self.type = elem.get('type')
295 if self.type is None:
296 self.type = ''
302 def __init__(self, elem):
303 BaseInfo.__init__(self, elem)
304 self.additionalValidity = []
305 self.removedValidity = []
307 def getParams(self):
309 return self.elem.findall('param')
311 def resetState(self):
312 BaseInfo.resetState(self)
313 self.additionalValidity = []
314 self.removedValidity = []
321 def __init__(self, elem):
322 BaseInfo.__init__(self, elem)
323 self.name = elem.get('name')
326 self.emit = False
329 self.sortorder = int(elem.get('sortorder', 0))
337 self.category = 'VERSION'
340 self.version = elem.get('name')
343 self.versionNumber = elem.get('number')
348 self.number = 0
349 self.supported = None
352 self.category = self.name.split('_', 2)[1]
353 self.version = "0"
354 self.versionNumber = "0"
356 self.number = int(elem.get('number','0'))
362 self.supported = elem.get('supported', 'disabled')
368 def __init__(self, elem):
369 BaseInfo.__init__(self, elem)
374 def __init__(self, elem, condition):
375 BaseInfo.__init__(self, elem)
377 self.condition = condition
382 def __init__(self, elem, condition):
383 BaseInfo.__init__(self, elem)
385 self.condition = condition
390 def __init__(self, elem, condition):
391 BaseInfo.__init__(self, elem)
393 self.condition = condition
398 def __init__(self, elem):
399 BaseInfo.__init__(self, elem)
404 def __init__(self, gen=None, genOpts=None):
407 self.gen = OutputGenerator()
409 self.gen = gen
415 self.genOpts = GeneratorOptions(apiname = APIConventions().xml_api_name)
417 self.genOpts = genOpts
420 self.gen.registry = self
421 self.gen.genOpts = self.genOpts
422 self.gen.genOpts.registry = self
424 self.tree = None
427 self.typedict = {}
430 self.groupdict = {}
433 self.enumdict = {}
436 self.cmddict = {}
439 self.apidict = {}
442 self.extensions = []
445 self.extdict = {}
448 self.spirvextdict = {}
451 self.spirvcapdict = {}
454 self.formatsdict = {}
457 self.syncstagedict = {}
460 self.syncaccessdict = {}
463 self.syncpipelinedict = {}
466 self.emitFeatures = False
470 self.breakPat = None
472 # self.breakPat = re.compile('VkFenceImportFlagBits.*')
474 self.requiredextensions = [] # Hack - can remove it after validity generator goes away
478 self.commandextensiontuple = namedtuple('commandextensiontuple',
482 self.validextensionstructs = defaultdict(list)
483 self.commandextensionsuccesses = []
484 self.commandextensionerrors = []
486 self.filename = None
488 def loadElementTree(self, tree):
490 self.tree = tree
491 self.parseTree()
493 def loadFile(self, file):
495 self.filename = file
496 self.tree = etree.parse(file)
497 self.parseTree()
499 def setGenerator(self, gen):
503 self.gen = gen
504 self.gen.setRegistry(self)
506 def addElementInfo(self, elem, info, infoName, dictionary):
514 - dictionary - self.{type|group|enum|cmd|api|ext|format|spirvext|spirvcap|sync}dict
518 # self.gen.logMsg('diag', 'Adding ElementInfo.required =',
523 self.gen.logMsg('warn', 'Attempt to redefine', key,
528 def lookupElementInfo(self, fname, dictionary):
536 - dictionary - self.{type|enum|cmd}dict"""
537 key = (fname, self.genOpts.apiname)
539 # self.gen.logMsg('diag', 'Found API-specific element for feature', fname)
542 # self.gen.logMsg('diag', 'Found generic element for feature', fname)
547 def breakOnName(self, regexp):
549 self.breakPat = re.compile(regexp)
551 def parseTree(self):
554 if self.tree is None:
556 self.reg = self.tree.getroot()
569 if self.genOpts.mergeApiNames:
570 mergeAPIs(self.reg, self.genOpts.mergeApiNames.split(','), self.genOpts.apiname)
572 stripNonmatchingAPIs(self.reg, self.genOpts.apiname, actuallyDelete = True)
580 self.typedict = {}
581 for type_elem in self.reg.findall('types/type'):
589 self.addElementInfo(type_elem, TypeInfo(type_elem), 'type', self.typedict)
596 self.groupdict = {}
597 for group in self.reg.findall('enums'):
598 self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict)
609 self.enumdict = {}
610 for enums in self.reg.findall('enums'):
615 self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
623 self.cmddict = {}
628 for cmd in self.reg.findall('commands/command'):
638 self.addElementInfo(cmd, ci, 'command', self.cmddict)
647 if alias in self.cmddict:
648 aliasInfo = self.cmddict[alias]
655 self.cmddict[name] = ci
660 self.gen.logMsg('warn', 'No matching <command> found for command',
665 self.apidict = {}
667 for feature in self.reg.findall('feature'):
669 self.addElementInfo(feature, featureInfo, 'feature', self.apidict)
690 # self.gen.logMsg('diag', 'Found extension enum',
695 if groupName in self.groupdict:
696 # self.gen.logMsg('diag', 'Matching group',
698 gi = self.groupdict[groupName]
701 self.gen.logMsg('warn', 'NO matching group',
710 # self.gen.logMsg('diag', 'Adding extension constant "enum"',
715 self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
720 self.extensions = self.reg.findall('extensions/extension')
721 self.extdict = {}
722 for feature in self.extensions:
724 self.addElementInfo(feature, featureInfo, 'extension', self.extdict)
737 # self.gen.logMsg('diag', 'Found extension enum',
750 if groupName in self.groupdict:
751 # self.gen.logMsg('diag', 'Matching group',
753 gi = self.groupdict[groupName]
756 self.gen.logMsg('warn', 'NO matching group',
788 # self.gen.logMsg('diag', 'Adding extension constant "enum"',
793 self.addElementInfo(enum, enumInfo, 'enum', self.enumdict)
797 for spirv in self.reg.findall('spirvextensions/spirvextension'):
799 self.addElementInfo(spirv, spirvInfo, 'spirvextension', self.spirvextdict)
800 for spirv in self.reg.findall('spirvcapabilities/spirvcapability'):
802 self.addElementInfo(spirv, spirvInfo, 'spirvcapability', self.spirvcapdict)
804 for format in self.reg.findall('formats/format'):
810 self.addElementInfo(format, formatInfo, 'format', self.formatsdict)
812 for stage in self.reg.findall('sync/syncstage'):
818 self.addElementInfo(stage, syncInfo, 'syncstage', self.syncstagedict)
820 for access in self.reg.findall('sync/syncaccess'):
826 self.addElementInfo(access, syncInfo, 'syncaccess', self.syncaccessdict)
828 for pipeline in self.reg.findall('sync/syncpipeline'):
830 self.addElementInfo(pipeline, syncInfo, 'syncpipeline', self.syncpipelinedict)
832 def dumpReg(self, maxlen=120, filehandle=sys.stdout):
841 for name in self.typedict:
842 tobj = self.typedict[name]
845 for name in self.groupdict:
846 gobj = self.groupdict[name]
849 for name in self.enumdict:
850 eobj = self.enumdict[name]
853 for name in self.cmddict:
854 cobj = self.cmddict[name]
857 for key in self.apidict:
859 etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle)
861 for key in self.extdict:
863 etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle)
865 for key in self.spirvextdict:
867 etree.tostring(self.spirvextdict[key].elem)[0:maxlen], file=filehandle)
868 for key in self.spirvcapdict:
870 etree.tostring(self.spirvcapdict[key].elem)[0:maxlen], file=filehandle)
872 for key in self.formatsdict:
874 etree.tostring(self.formatsdict[key].elem)[0:maxlen], file=filehandle)
876 def markTypeRequired(self, typename, required):
882 self.gen.logMsg('diag', 'tagging type:', typename, '-> required =', required)
885 typeinfo = self.lookupElementInfo(typename, self.typedict)
894 self.gen.logMsg('diag', 'Generating dependent type',
896 # Do not recurse on self-referential structures.
898 self.markTypeRequired(depname, required)
900 self.gen.logMsg('diag', 'type', typename, 'is self-referential')
906 self.gen.logMsg('diag', 'markRequired: type requires dependent <type>', subtype.text)
908 self.markTypeRequired(subtype.text, required)
910 self.gen.logMsg('diag', 'type', typename, 'is self-referential')
914 self.gen.logMsg('diag', 'markRequired: type requires dependent <enum>', subenum.text)
915 self.markEnumRequired(subenum.text, required)
921 self.gen.logMsg('diag', 'Generating bitflag type',
923 self.markTypeRequired(depType, required)
924 group = self.lookupElementInfo(depType, self.groupdict)
930 self.gen.logMsg('warn', 'type:', typename, 'IS NOT DEFINED')
932 def markEnumRequired(self, enumname, required):
938 self.gen.logMsg('diag', 'markEnumRequired: tagging enum:', enumname, '-> required =', required)
939 enum = self.lookupElementInfo(enumname, self.enumdict)
948 self.gen.logMsg('diag', f'markEnumRequired: Removing extending enum {enum.elem.get("name")}')
951 if groupName in self.groupdict:
952 gi = self.groupdict[groupName]
958 self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
962 self.gen.logMsg('warn', 'markEnumRequired: Cannot remove enum',
972 self.gen.logMsg('diag', f'markEnumRequired: Removing non-extending enum {enumName}')
975 for enums in self.reg.findall('enums'):
983 self.gen.logMsg('warn', f'markEnumRequired: {enumName}) not found in any <enums> tag')
989 self.gen.logMsg('diag', 'markEnumRequired: Generating dependent enum',
991 self.markEnumRequired(depname, required)
993 self.gen.logMsg('warn', f'markEnumRequired: {enumname} IS NOT DEFINED')
995 def markCmdRequired(self, cmdname, required):
1000 self.gen.logMsg('diag', 'tagging command:', cmdname, '-> required =', required)
1001 cmd = self.lookupElementInfo(cmdname, self.cmddict)
1014 if self.genOpts.requireCommandAliases:
1017 self.gen.logMsg('diag', 'Generating dependent command',
1019 self.markCmdRequired(depname, required)
1030 self.gen.logMsg('diag', 'markRequired: command implicitly requires dependent type', type_elem.text)
1031 self.markTypeRequired(type_elem.text, required)
1033 self.gen.logMsg('warn', 'command:', cmdname, 'IS NOT DEFINED')
1035 def markRequired(self, featurename, feature, required):
1041 self.gen.logMsg('diag', 'markRequired (feature = <too long to print>, required =', required, ')')
1047 self.markTypeRequired(typeElem.get('name'), required)
1049 self.markEnumRequired(enumElem.get('name'), required)
1052 self.markCmdRequired(cmdElem.get('name'), required)
1063 self.commandextensionsuccesses.append(self.commandextensiontuple(command=commandName,
1069 self.commandextensionerrors.append(self.commandextensiontuple(command=commandName,
1073 self.gen.logMsg('warn', 'extend type:', extendType, 'IS NOT SUPPORTED')
1075 def getAlias(self, elem, dict):
1084 typeinfo = self.lookupElementInfo(name, dict)
1086 self.gen.logMsg('error', name, 'is not a known name')
1091 def checkForCorrectionAliases(self, alias, require, tag):
1108 def fillFeatureDictionary(self, interface, featurename, api, profile):
1118 self.gen.featureDictionary[featurename] = {
1148 typeinfo = self.lookupElementInfo(typename, self.typedict)
1152 alias = self.getAlias(typeElem, self.typedict)
1153 if not self.checkForCorrectionAliases(alias, require, 'type'):
1156 typeinfo = self.lookupElementInfo(alias, self.typedict)
1161 if not required_key in self.gen.featureDictionary[featurename][typecat]:
1162 self.gen.featureDictionary[featurename][typecat][required_key] = {}
1163 if not typeextends in self.gen.featureDictionary[featurename][typecat][required_key]:
1164 self.gen.featureDictionary[featurename][typecat][required_key][typeextends] = []
1165 self.gen.featureDictionary[featurename][typecat][required_key][typeextends].append(typename)
1167 self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
1172 typeinfo = self.lookupElementInfo(enumname, self.enumdict)
1175 alias = self.getAlias(enumElem, self.enumdict)
1176 if not self.checkForCorrectionAliases(alias, require, 'enum'):
1178 if not required_key in self.gen.featureDictionary[featurename]['enumconstant']:
1179 self.gen.featureDictionary[featurename]['enumconstant'][required_key] = {}
1180 if not enumextends in self.gen.featureDictionary[featurename]['enumconstant'][required_key]:
1181 self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends] = []
1182 self.gen.featureDictionary[featurename]['enumconstant'][required_key][enumextends].append(enumname)
1184 self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
1188 alias = self.getAlias(cmdElem, self.cmddict)
1189 if not self.checkForCorrectionAliases(alias, require, 'command'):
1190 if not required_key in self.gen.featureDictionary[featurename]['command']:
1191 self.gen.featureDictionary[featurename]['command'][required_key] = []
1192 self.gen.featureDictionary[featurename]['command'][required_key].append(cmdElem.get('name'))
1194 self.gen.logMsg('warn', 'fillFeatureDictionary: NOT filling for {}'.format(typename))
1196 def requireFeatures(self, interface, featurename, api, profile):
1208 self.markRequired(featurename, feature, True)
1210 def removeFeatures(self, interface, featurename, api, profile):
1222 self.markRequired(featurename, feature, False)
1224 def assignAdditionalValidity(self, interface, api, profile):
1230 self.cmddict[v.get('command')].additionalValidity.append(copy.deepcopy(v))
1232 self.typedict[v.get('struct')].additionalValidity.append(copy.deepcopy(v))
1234 def removeAdditionalValidity(self, interface, api, profile):
1240 self.cmddict[v.get('command')].removedValidity.append(copy.deepcopy(v))
1242 self.typedict[v.get('struct')].removedValidity.append(copy.deepcopy(v))
1244 def generateFeature(self, fname, ftype, dictionary, explicit=False):
1250 - dictionary - of *Info objects - self.{type|enum|cmd}dict
1255 self.gen.logMsg('diag', 'generateFeature: generating', ftype, fname)
1257 if not (explicit or self.genOpts.requireDepends):
1258 self.gen.logMsg('diag', 'generateFeature: NOT generating', ftype, fname, 'because generator does not require dependencies')
1261 f = self.lookupElementInfo(fname, dictionary)
1264 self.gen.logMsg('diag', 'No entry found for feature', fname,
1270 self.gen.logMsg('diag', 'Skipping', ftype, fname, '(not required)')
1273 self.gen.logMsg('diag', 'Skipping', ftype, fname, '(already declared)')
1281 self.gen.logMsg('diag', fname, 'is an alias of', alias)
1293 genProc = self.gen.genType
1297 self.generateFeature(alias, 'type', self.typedict)
1300 self.gen.logMsg('diag', 'Generating required dependent type',
1302 self.generateFeature(requires, 'type', self.typedict)
1309 self.gen.logMsg('diag', 'Generating required dependent <type>',
1311 self.generateFeature(subtype.text, 'type', self.typedict)
1316 self.gen.logMsg('diag', 'Generating required dependent <enum>',
1318 self.generateFeature(subtype.text, 'enum', self.enumdict)
1323 self.gen.logMsg('diag', 'Type', fname, 'is an enum group, so generate that instead')
1324 group = self.lookupElementInfo(fname, self.groupdict)
1328 self.gen.logMsg('diag', 'Generating alias', fname,
1332 genProc = self.gen.genGroup
1333 f = self.lookupElementInfo(alias, self.groupdict)
1335 self.gen.logMsg('warn', 'Skipping enum type', fname,
1339 genProc = self.gen.genGroup
1355 self.gen.logMsg('diag', 'generateFeature: checking enums for group', fname)
1371 if self.genOpts.defaultExtensions in supported_list:
1373 elif re.match(self.genOpts.addExtensions, extname) is not None:
1376 required = re.match(self.genOpts.emitversions, version) is not None
1380 self.gen.logMsg('diag', '* required =', required, 'for', name)
1392 self.gen.logMsg('diag', '* also need to require alias', name)
1400 self.generateFeature(alias, 'command', self.cmddict)
1402 genProc = self.gen.genCmd
1405 self.gen.logMsg('diag', 'Generating required parameter type',
1407 self.generateFeature(depname, 'type', self.typedict)
1411 self.generateFeature(alias, 'enum', self.enumdict)
1412 genProc = self.gen.genEnum
1415 if self.emitFeatures:
1416 self.gen.logMsg('diag', 'Emitting', ftype, 'decl for', fname)
1421 self.gen.logMsg('diag', 'Skipping', ftype, fname,
1425 self.gen.logMsg('diag', 'Generating required bitvalues <enum>',
1427 self.generateFeature(followupFeature, "type", self.typedict)
1429 def generateRequiredInterface(self, interface):
1437 self.generateFeature(t.get('name'), 'type', self.typedict, explicit=True)
1444 self.generateFeature(e.get('name'), 'enum', self.enumdict, explicit=True)
1446 self.generateFeature(c.get('name'), 'command', self.cmddict, explicit=True)
1448 def generateSpirv(self, spirv, dictionary):
1450 self.gen.logMsg('diag', 'No entry found for element', name,
1458 genProc = self.gen.genSpirv
1461 def stripUnsupportedAPIs(self, dictionary, attribute, supportedDictionary):
1487 def stripUnsupportedAPIsFromList(self, dictionary, supportedDictionary):
1511 def generateFormat(self, format, dictionary):
1513 self.gen.logMsg('diag', 'No entry found for format element',
1521 genProc = self.gen.genFormat
1524 def generateSyncStage(self, sync):
1525 genProc = self.gen.genSyncStage
1528 def generateSyncAccess(self, sync):
1529 genProc = self.gen.genSyncAccess
1532 def generateSyncPipeline(self, sync):
1533 genProc = self.gen.genSyncPipeline
1536 def tagValidExtensionStructs(self):
1541 for typeinfo in self.typedict.values():
1547 # self.gen.logMsg('diag', type_elem.get('name'), 'extends', parent)
1548 self.validextensionstructs[parent].append(type_elem.get('name'))
1551 for parent in self.validextensionstructs:
1552 self.validextensionstructs[parent].sort()
1554 def apiGen(self):
1558 self.gen.logMsg('diag', '*******************************************')
1559 self.gen.logMsg('diag', ' Registry.apiGen file:', self.genOpts.filename,
1560 'api:', self.genOpts.apiname,
1561 'profile:', self.genOpts.profile)
1562 self.gen.logMsg('diag', '*******************************************')
1570 # self.apiReset()
1573 regVersions = re.compile(self.genOpts.versions)
1574 regEmitVersions = re.compile(self.genOpts.emitversions)
1575 regAddExtensions = re.compile(self.genOpts.addExtensions)
1576 regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
1577 regEmitExtensions = re.compile(self.genOpts.emitExtensions)
1578 regEmitSpirv = re.compile(self.genOpts.emitSpirv)
1579 regEmitFormats = re.compile(self.genOpts.emitFormats)
1585 for key in self.apidict:
1586 fi = self.apidict[key]
1588 if apiNameMatch(self.genOpts.apiname, api):
1597 self.gen.logMsg('diag', 'NOT tagging feature api =', api,
1601 self.gen.logMsg('diag', 'Including feature api =', api,
1605 self.gen.logMsg('diag', 'NOT including feature api =', api,
1609 self.gen.logMsg('diag', 'NOT including feature api =', api,
1613 self.gen.logMsg('warn', 'No matching API versions found!')
1621 for (extName, ei) in sorted(self.extdict.items(), key=lambda x: x[1].number if x[1].number is not None else '0'):
1627 if apiNameMatch(self.genOpts.defaultExtensions,
1629 self.gen.logMsg('diag', 'Including extension',
1639 if not apiNameMatch(self.genOpts.apiname, ei.elem.get('supported')):
1640 self.gen.logMsg('diag', 'NOT including extension',
1644 self.gen.logMsg('diag', 'Including extension',
1652 self.gen.logMsg('diag', 'Removing extension',
1662 self.gen.logMsg('diag', 'NOT tagging extension',
1669 self.requiredextensions.append(extName)
1671 self.gen.logMsg('diag', 'NOT including extension',
1678 for key in self.spirvextdict:
1679 si = self.spirvextdict[key]
1683 for key in self.spirvcapdict:
1684 si = self.spirvcapdict[key]
1689 for key in self.formatsdict:
1690 si = self.formatsdict[key]
1695 if self.genOpts.sortProcedure:
1696 self.genOpts.sortProcedure(features)
1705 self.gen.logMsg('diag', 'PASS 1: TAG FEATURES')
1707 self.gen.logMsg('diag', 'PASS 1: Tagging required and features for', f.name)
1708 self.fillFeatureDictionary(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1709 self.requireFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1710 self.assignAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
1713 self.gen.logMsg('diag', 'PASS 2: Tagging removed features for', f.name)
1714 self.removeFeatures(f.elem, f.name, self.genOpts.apiname, self.genOpts.profile)
1715 self.removeAdditionalValidity(f.elem, self.genOpts.apiname, self.genOpts.profile)
1721 self.stripUnsupportedAPIs(self.typedict, 'structextends', self.typedict)
1722 self.stripUnsupportedAPIs(self.cmddict, 'successcodes', self.enumdict)
1723 self.stripUnsupportedAPIs(self.cmddict, 'errorcodes', self.enumdict)
1724 self.stripUnsupportedAPIsFromList(self.validextensionstructs, self.typedict)
1727 self.tagValidExtensionStructs()
1739 self.gen.logMsg('diag', 'PASS 3: GENERATE INTERFACES FOR FEATURES')
1740 self.gen.beginFile(self.genOpts)
1742 self.gen.logMsg('diag', 'PASS 3: Generating interface for',
1744 emit = self.emitFeatures = f.emit
1746 self.gen.logMsg('diag', 'PASS 3: NOT declaring feature',
1750 self.gen.beginFeature(f.elem, emit)
1751 self.generateRequiredInterface(f.elem)
1752 self.gen.endFeature()
1755 self.generateSpirv(s, self.spirvextdict)
1757 self.generateSpirv(s, self.spirvcapdict)
1759 self.generateFormat(s, self.formatsdict)
1760 for s in self.syncstagedict:
1761 self.generateSyncStage(self.syncstagedict[s])
1762 for s in self.syncaccessdict:
1763 self.generateSyncAccess(self.syncaccessdict[s])
1764 for s in self.syncpipelinedict:
1765 self.generateSyncPipeline(self.syncpipelinedict[s])
1766 self.gen.endFile()
1768 def apiReset(self):
1772 for datatype in self.typedict:
1773 self.typedict[datatype].resetState()
1774 for enum in self.enumdict:
1775 self.enumdict[enum].resetState()
1776 for cmd in self.cmddict:
1777 self.cmddict[cmd].resetState()
1778 for cmd in self.apidict:
1779 self.apidict[cmd].resetState()