Lines Matching refs:self
83 def __init__(self, elem):
84 self.required = False
85 self.declared = False
86 self.elem = elem
87 def resetState(self):
88 self.required = False
89 self.declared = False
95 def __init__(self, elem):
96 BaseInfo.__init__(self, elem)
102 def __init__(self, elem):
103 BaseInfo.__init__(self, elem)
104 self.enums = {}
111 def __init__(self, elem):
112 BaseInfo.__init__(self, elem)
113 self.type = elem.get('type')
114 if (self.type == None):
115 self.type = ''
125 def __init__(self, elem):
126 BaseInfo.__init__(self, elem)
127 self.glxtype = None
128 self.glxopcode = None
129 self.glxequiv = None
130 self.vecequiv = None
141 def __init__(self, elem):
142 BaseInfo.__init__(self, elem)
143 self.name = elem.get('name')
147 self.category = 'VERSION'
148 self.number = elem.get('number')
150 self.category = self.name.split('_', 2)[1]
151 self.number = "0"
152 self.emit = False
219 def __init__(self,
229 self.filename = filename
230 self.apiname = apiname
231 self.profile = profile
232 self.versions = self.emptyRegex(versions)
233 self.emitversions = self.emptyRegex(emitversions)
234 self.defaultExtensions = defaultExtensions
235 self.addExtensions = self.emptyRegex(addExtensions)
236 self.removeExtensions = self.emptyRegex(removeExtensions)
237 self.sortProcedure = sortProcedure
241 def emptyRegex(self,pat):
275 def __init__(self,
294 GeneratorOptions.__init__(self, filename, apiname, profile,
297 self.prefixText = prefixText
298 self.genFuncPointers = genFuncPointers
299 self.protectFile = protectFile
300 self.protectFeature = protectFeature
301 self.protectProto = protectProto
302 self.protectProtoStr = protectProtoStr
303 self.apicall = apicall
304 self.apientry = apientry
305 self.apientryp = apientryp
336 def __init__(self,
340 self.outFile = None
341 self.errFile = errFile
342 self.warnFile = warnFile
343 self.diagFile = diagFile
345 self.featureName = None
346 self.genOpts = None
355 def logMsg(self, level, *args):
360 if (self.errFile != None):
361 write(strfile.getvalue(), file=self.errFile)
364 if (self.warnFile != None):
365 write('WARNING:', *args, file=self.warnFile)
367 if (self.diagFile != None):
368 write('DIAG:', *args, file=self.diagFile)
373 def beginFile(self, genOpts):
374 self.genOpts = genOpts
378 if (self.genOpts.filename != None):
379 self.outFile = open(self.genOpts.filename, 'w')
381 self.outFile = sys.stdout
382 def endFile(self):
383 self.errFile and self.errFile.flush()
384 self.warnFile and self.warnFile.flush()
385 self.diagFile and self.diagFile.flush()
386 self.outFile.flush()
387 if (self.outFile != sys.stdout and self.outFile != sys.stderr):
388 self.outFile.close()
389 self.genOpts = None
391 def beginFeature(self, interface, emit):
392 self.emit = emit
393 self.featureName = interface.get('name')
395 self.featureExtraProtect = interface.get('protect')
396 def endFeature(self):
398 self.featureName = None
399 self.featureExtraProtect = None
402 def genType(self, typeinfo, name):
403 if (self.featureName == None):
408 def genEnum(self, enuminfo, name):
409 if (self.featureName == None):
414 def genCmd(self, cmd, name):
415 if (self.featureName == None):
439 def __init__(self,
443 OutputGenerator.__init__(self, errFile, warnFile, diagFile)
445 self.typeBody = ''
446 self.enumBody = ''
447 self.cmdBody = ''
452 def makeCDecls(self, cmd):
457 pdecl = self.genOpts.apicall
476 pdecl += self.genOpts.apientry + text + tail
477 tdecl += '(' + self.genOpts.apientryp + 'PFN' + text.upper() + 'PROC' + tail + ')'
497 def newline(self):
498 write('', file=self.outFile)
500 def beginFile(self, genOpts):
501 OutputGenerator.beginFile(self, genOpts)
505 if (genOpts.protectFile and self.genOpts.filename):
506 headerSym = '__' + re.sub('\.h', '_h_', os.path.basename(self.genOpts.filename))
507 write('#ifndef', headerSym, file=self.outFile)
508 write('#define', headerSym, '1', file=self.outFile)
509 self.newline()
510 write('#ifdef __cplusplus', file=self.outFile)
511 write('extern "C" {', file=self.outFile)
512 write('#endif', file=self.outFile)
513 self.newline()
526 write(s, file=self.outFile)
531 write('/* Generated C header for:', file=self.outFile)
532 write(' * API:', genOpts.apiname, file=self.outFile)
534 write(' * Profile:', genOpts.profile, file=self.outFile)
535 write(' * Versions considered:', genOpts.versions, file=self.outFile)
536 write(' * Versions emitted:', genOpts.emitversions, file=self.outFile)
537 write(' * Default extensions included:', genOpts.defaultExtensions, file=self.outFile)
538 write(' * Additional extensions included:', genOpts.addExtensions, file=self.outFile)
539 write(' * Extensions removed:', genOpts.removeExtensions, file=self.outFile)
540 write(' */', file=self.outFile)
541 def endFile(self):
544 self.newline()
545 write('#ifdef __cplusplus', file=self.outFile)
546 write('}', file=self.outFile)
547 write('#endif', file=self.outFile)
548 if (self.genOpts.protectFile and self.genOpts.filename):
549 self.newline()
550 write('#endif', file=self.outFile)
552 OutputGenerator.endFile(self)
553 def beginFeature(self, interface, emit):
555 OutputGenerator.beginFeature(self, interface, emit)
560 self.typeBody = ''
561 self.enumBody = ''
562 self.cmdPointerBody = ''
563 self.cmdBody = ''
564 def endFeature(self):
567 if (self.emit):
568 self.newline()
569 if (self.genOpts.protectFeature):
570 write('#ifndef', self.featureName, file=self.outFile)
571 write('#define', self.featureName, '1', file=self.outFile)
572 if (self.typeBody != ''):
573 write(self.typeBody, end='', file=self.outFile)
577 if (self.featureExtraProtect != None):
578 write('#ifdef', self.featureExtraProtect, file=self.outFile)
579 if (self.enumBody != ''):
580 write(self.enumBody, end='', file=self.outFile)
581 if (self.genOpts.genFuncPointers and self.cmdPointerBody != ''):
582 write(self.cmdPointerBody, end='', file=self.outFile)
583 if (self.cmdBody != ''):
584 if (self.genOpts.protectProto == True):
585 prefix = '#ifdef ' + self.genOpts.protectProtoStr + '\n'
587 elif (self.genOpts.protectProto == 'nonzero'):
588 prefix = '#if ' + self.genOpts.protectProtoStr + '\n'
590 elif (self.genOpts.protectProto == False):
594 self.gen.logMsg('warn',
596 self.genOpts.protectProto,
601 write(prefix + self.cmdBody + suffix, end='', file=self.outFile)
602 if (self.featureExtraProtect != None):
603 write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)
604 if (self.genOpts.protectFeature):
605 write('#endif /*', self.featureName, '*/', file=self.outFile)
607 OutputGenerator.endFeature(self)
610 def genType(self, typeinfo, name):
611 OutputGenerator.genType(self, typeinfo, name)
614 # (from self.genOpts). Copy other text through unchanged.
620 s += self.genOpts.apientry + noneStr(elem.tail)
624 self.typeBody += s + '\n'
627 def genEnum(self, enuminfo, name):
628 OutputGenerator.genEnum(self, enuminfo, name)
631 self.enumBody += '#define ' + name.ljust(33) + ' ' + enuminfo.elem.get('value')
636 self.enumBody += enuminfo.type
637 self.enumBody += '\n'
640 def genCmd(self, cmdinfo, name):
641 OutputGenerator.genCmd(self, cmdinfo, name)
643 decls = self.makeCDecls(cmdinfo.elem)
644 self.cmdBody += decls[0]
645 if (self.genOpts.genFuncPointers):
646 self.cmdPointerBody += decls[1]
683 def __init__(self):
684 self.tree = None
685 self.typedict = {}
686 self.groupdict = {}
687 self.enumdict = {}
688 self.cmddict = {}
689 self.apidict = {}
690 self.extensions = []
691 self.extdict = {}
694 self.gen = OutputGenerator()
695 self.genOpts = None
696 self.emitFeatures = False
697 def loadElementTree(self, tree):
699 self.tree = tree
700 self.parseTree()
701 def loadFile(self, file):
703 self.tree = etree.parse(file)
704 self.parseTree()
705 def setGenerator(self, gen):
707 self.gen = gen
713 # dictionary - self.{type|group|enum|cmd|api|ext}dict
717 def addElementInfo(self, elem, info, infoName, dictionary):
723 self.gen.logMsg('warn', '*** Attempt to redefine',
731 # dictionary - self.{type|enum|cmd}dict
732 def lookupElementInfo(self, fname, dictionary):
733 key = (fname, self.genOpts.apiname)
735 # self.gen.logMsg('diag', 'Found API-specific element for feature', fname)
738 # self.gen.logMsg('diag', 'Found generic element for feature', fname)
742 def parseTree(self):
745 self.reg = self.tree.getroot()
753 self.typedict = {}
754 for type in self.reg.findall('types/type'):
759 self.addElementInfo(type, TypeInfo(type), 'type', self.typedict)
765 self.groupdict = {}
766 for group in self.reg.findall('groups/group'):
767 self.addElementInfo(group, GroupInfo(group), 'group', self.groupdict)
775 self.enumdict = {}
776 for enum in self.reg.findall('enums/enum'):
777 self.addElementInfo(enum, EnumInfo(enum), 'enum', self.enumdict)
785 self.cmddict = {}
786 for cmd in self.reg.findall('commands/command'):
792 self.addElementInfo(cmd, ci, 'command', self.cmddict)
797 self.apidict = {}
798 for feature in self.reg.findall('feature'):
800 self.addElementInfo(feature, ai, 'feature', self.apidict)
801 self.extensions = self.reg.findall('extensions/extension')
802 self.extdict = {}
803 for feature in self.extensions:
805 self.addElementInfo(feature, ei, 'extension', self.extdict)
806 def dumpReg(self, maxlen = 40, filehandle = sys.stdout):
812 for name in self.typedict:
813 tobj = self.typedict[name]
816 for name in self.groupdict:
817 gobj = self.groupdict[name]
820 for name in self.enumdict:
821 eobj = self.enumdict[name]
824 for name in self.cmddict:
825 cobj = self.cmddict[name]
828 for key in self.apidict:
830 etree.tostring(self.apidict[key].elem)[0:maxlen], file=filehandle)
832 for key in self.extdict:
834 etree.tostring(self.extdict[key].elem)[0:maxlen], file=filehandle)
838 # write(etree.tostring(self.tree.getroot(),pretty_print=True), file=filehandle)
842 def markTypeRequired(self, typename, required):
844 self.gen.logMsg('diag', '*** tagging type:', typename, '-> required =', required)
846 type = self.lookupElementInfo(typename, self.typedict)
853 self.gen.logMsg('diag', '*** Generating dependent type',
855 self.markTypeRequired(depType, required)
858 self.gen.logMsg('warn', '*** type:', typename , 'IS NOT DEFINED')
862 def markRequired(self, features, required):
864 self.gen.logMsg('diag', '*** markRequired (features = <too long to print>, required =', required, ')')
869 self.markTypeRequired(typeElem.get('name'), required)
872 self.gen.logMsg('diag', '*** tagging enum:', name, '-> required =', required)
873 enum = self.lookupElementInfo(name, self.enumdict)
877 self.gen.logMsg('warn', '*** enum:', name , 'IS NOT DEFINED')
880 self.gen.logMsg('diag', '*** tagging command:', name, '-> required =', required)
881 cmd = self.lookupElementInfo(name, self.cmddict)
893 self.gen.logMsg('diag', '*** markRequired: command implicitly requires dependent type', ptype.text)
894 self.markTypeRequired(ptype.text, required)
896 self.gen.logMsg('warn', '*** command:', name, 'IS NOT DEFINED')
902 def requireAndRemoveFeatures(self, interface, api, profile):
907 self.markRequired(feature,True)
911 self.markRequired(feature,False)
917 # dictionary - of *Info objects - self.{type|enum|cmd}dict
918 # genProc - bound function pointer for self.gen.gen{Type|Enum|Cmd}
919 def generateFeature(self, fname, ftype, dictionary, genProc):
920 f = self.lookupElementInfo(fname, dictionary)
923 self.gen.logMsg('diag', '*** No entry found for feature', fname,
929 self.gen.logMsg('diag', '*** Skipping', ftype, fname, '(not required)')
932 self.gen.logMsg('diag', '*** Skipping', ftype, fname, '(already declared)')
943 self.gen.logMsg('diag', '*** Generating required dependent type',
945 self.generateFeature(depname, 'type', self.typedict,
946 self.gen.genType)
950 self.gen.logMsg('diag', '*** Generating required parameter type',
952 self.generateFeature(depname, 'type', self.typedict,
953 self.gen.genType)
956 if self.emitFeatures:
957 self.gen.logMsg('diag', '*** Emitting', ftype, 'decl for', fname)
960 self.gen.logMsg('diag', '*** Skipping', ftype, fname,
968 def generateRequiredInterface(self, interface):
975 self.generateFeature(t.get('name'), 'type', self.typedict,
976 self.gen.genType)
978 self.generateFeature(e.get('name'), 'enum', self.enumdict,
979 self.gen.genEnum)
981 self.generateFeature(c.get('name'), 'command', self.cmddict,
982 self.gen.genCmd)
987 def apiGen(self, genOpts):
990 self.gen.logMsg('diag', '*******************************************')
991 self.gen.logMsg('diag', ' Registry.apiGen file:', genOpts.filename,
994 self.gen.logMsg('diag', '*******************************************')
996 self.genOpts = genOpts
998 self.apiReset()
1001 regVersions = re.compile(self.genOpts.versions)
1002 regEmitVersions = re.compile(self.genOpts.emitversions)
1003 regAddExtensions = re.compile(self.genOpts.addExtensions)
1004 regRemoveExtensions = re.compile(self.genOpts.removeExtensions)
1009 for key in self.apidict:
1010 fi = self.apidict[key]
1012 if (api == self.genOpts.apiname):
1021 self.gen.logMsg('diag', '*** NOT tagging feature api =', api,
1025 self.gen.logMsg('diag', '*** NOT including feature api =', api,
1029 self.gen.logMsg('diag', '*** NOT including feature api =', api,
1033 self.gen.logMsg('warn', '*** No matching API versions found!')
1040 for key in self.extdict:
1041 ei = self.extdict[key]
1050 if (self.genOpts.defaultExtensions and
1051 re.match(pat, self.genOpts.defaultExtensions)):
1052 self.gen.logMsg('diag', '*** Including extension',
1061 self.gen.logMsg('diag', '*** Including extension',
1069 self.gen.logMsg('diag', '*** Removing extension',
1079 self.gen.logMsg('diag', '*** NOT including extension',
1083 if (self.genOpts.sortProcedure):
1084 self.genOpts.sortProcedure(features)
1094 self.gen.logMsg('diag', '*** PASS 1: TAG FEATURES ********************************************')
1096 self.gen.logMsg('diag', '*** PASS 1: Tagging required and removed features for',
1098 self.requireAndRemoveFeatures(f.elem, self.genOpts.apiname, self.genOpts.profile)
1103 self.gen.logMsg('diag', '*** PASS 2: GENERATE INTERFACES FOR FEATURES ************************')
1104 self.gen.beginFile(self.genOpts)
1106 self.gen.logMsg('diag', '*** PASS 2: Generating interface for',
1108 emit = self.emitFeatures = f.emit
1110 self.gen.logMsg('diag', '*** PASS 2: NOT declaring feature',
1114 self.gen.beginFeature(f.elem, emit)
1115 self.generateRequiredInterface(f.elem)
1116 self.gen.endFeature()
1117 self.gen.endFile()
1121 def apiReset(self):
1123 for type in self.typedict:
1124 self.typedict[type].resetState()
1125 for enum in self.enumdict:
1126 self.enumdict[enum].resetState()
1127 for cmd in self.cmddict:
1128 self.cmddict[cmd].resetState()
1129 for cmd in self.apidict:
1130 self.apidict[cmd].resetState()
1134 def validateGroups(self):
1138 self.gen.logMsg('diag', '*** VALIDATING GROUP ATTRIBUTES ***')
1139 for cmd in self.reg.findall('commands/command'):
1144 # self.gen.logMsg('diag', '*** Command ', funcname, ' has return group ', group)
1145 if (group not in self.groupdict.keys()):
1146 # self.gen.logMsg('diag', '*** Command ', funcname, ' has UNKNOWN return group ', group)
1159 if (group not in self.groupdict.keys()):
1160 # self.gen.logMsg('diag', '*** Command ', funcname, ' param ', pname, ' has UNKNOWN group ', group)
1166 self.gen.logMsg('diag', '*** SUMMARY OF UNRECOGNIZED GROUPS ***')
1168 self.gen.logMsg('diag', ' ', key, ' occurred ', badGroup[key], ' times')