d493d7bf29a50ae5f62c9cca6a15a58def76ce35
[mesa.git] / src / egl / generate / genCommon.py
1 #!/usr/bin/env python
2
3 # (C) Copyright 2015, NVIDIA CORPORATION.
4 # All Rights Reserved.
5 #
6 # Permission is hereby granted, free of charge, to any person obtaining a
7 # copy of this software and associated documentation files (the "Software"),
8 # to deal in the Software without restriction, including without limitation
9 # on the rights to use, copy, modify, merge, publish, distribute, sub
10 # license, and/or sell copies of the Software, and to permit persons to whom
11 # the Software is furnished to do so, subject to the following conditions:
12 #
13 # The above copyright notice and this permission notice (including the next
14 # paragraph) shall be included in all copies or substantial portions of the
15 # Software.
16 #
17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 # FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
20 # IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
23 # IN THE SOFTWARE.
24 #
25 # Authors:
26 # Kyle Brenneman <kbrenneman@nvidia.com>
27
28 import collections
29 import re
30 import sys
31 import xml.etree.cElementTree as etree
32
33 MAPI_TABLE_NUM_DYNAMIC = 4096
34
35 _LIBRARY_FEATURE_NAMES = {
36 # libGL and libGLdiapatch both include every function.
37 "gl" : None,
38 "gldispatch" : None,
39 "opengl" : frozenset(( "GL_VERSION_1_0", "GL_VERSION_1_1",
40 "GL_VERSION_1_2", "GL_VERSION_1_3", "GL_VERSION_1_4", "GL_VERSION_1_5",
41 "GL_VERSION_2_0", "GL_VERSION_2_1", "GL_VERSION_3_0", "GL_VERSION_3_1",
42 "GL_VERSION_3_2", "GL_VERSION_3_3", "GL_VERSION_4_0", "GL_VERSION_4_1",
43 "GL_VERSION_4_2", "GL_VERSION_4_3", "GL_VERSION_4_4", "GL_VERSION_4_5",
44 )),
45 "glesv1" : frozenset(("GL_VERSION_ES_CM_1_0", "GL_OES_point_size_array")),
46 "glesv2" : frozenset(("GL_ES_VERSION_2_0", "GL_ES_VERSION_3_0",
47 "GL_ES_VERSION_3_1" "GL_ES_VERSION_3_2",
48 )),
49 }
50
51 def getFunctions(xmlFiles):
52 """
53 Reads an XML file and returns all of the functions defined in it.
54
55 xmlFile should be the path to Khronos's gl.xml file. The return value is a
56 sequence of FunctionDesc objects, ordered by slot number.
57 """
58 roots = [ etree.parse(xmlFile).getroot() for xmlFile in xmlFiles ]
59 return getFunctionsFromRoots(roots)
60
61 def getFunctionsFromRoots(roots):
62 functions = {}
63 for root in roots:
64 for func in _getFunctionList(root):
65 functions[func.name] = func
66 functions = functions.values()
67
68 # Sort the function list by name.
69 functions = sorted(functions, key=lambda f: f.name)
70
71 # Assign a slot number to each function. This isn't strictly necessary,
72 # since you can just look at the index in the list, but it makes it easier
73 # to include the slot when formatting output.
74 for i in range(len(functions)):
75 functions[i] = functions[i]._replace(slot=i)
76
77 return functions
78
79 def getExportNamesFromRoots(target, roots):
80 """
81 Goes through the <feature> tags from gl.xml and returns a set of OpenGL
82 functions that a library should export.
83
84 target should be one of "gl", "gldispatch", "opengl", "glesv1", or
85 "glesv2".
86 """
87 featureNames = _LIBRARY_FEATURE_NAMES[target]
88 if featureNames is None:
89 return set(func.name for func in getFunctionsFromRoots(roots))
90
91 names = set()
92 for root in roots:
93 features = []
94 for featElem in root.findall("feature"):
95 if featElem.get("name") in featureNames:
96 features.append(featElem)
97 for featElem in root.findall("extensions/extension"):
98 if featElem.get("name") in featureNames:
99 features.append(featElem)
100 for featElem in features:
101 for commandElem in featElem.findall("require/command"):
102 names.add(commandElem.get("name"))
103 return names
104
105 class FunctionArg(collections.namedtuple("FunctionArg", "type name")):
106 @property
107 def dec(self):
108 """
109 Returns a "TYPE NAME" string, suitable for a function prototype.
110 """
111 rv = str(self.type)
112 if not rv.endswith("*"):
113 rv += " "
114 rv += self.name
115 return rv
116
117 class FunctionDesc(collections.namedtuple("FunctionDesc", "name rt args slot")):
118 def hasReturn(self):
119 """
120 Returns true if the function returns a value.
121 """
122 return (self.rt != "void")
123
124 @property
125 def decArgs(self):
126 """
127 Returns a string with the types and names of the arguments, as you
128 would use in a function declaration.
129 """
130 if not self.args:
131 return "void"
132 else:
133 return ", ".join(arg.dec for arg in self.args)
134
135 @property
136 def callArgs(self):
137 """
138 Returns a string with the names of the arguments, as you would use in a
139 function call.
140 """
141 return ", ".join(arg.name for arg in self.args)
142
143 @property
144 def basename(self):
145 assert self.name.startswith("gl")
146 return self.name[2:]
147
148 def _getFunctionList(root):
149 for elem in root.findall("commands/command"):
150 yield _parseCommandElem(elem)
151
152 def _parseCommandElem(elem):
153 protoElem = elem.find("proto")
154 (rt, name) = _parseProtoElem(protoElem)
155
156 args = []
157 for ch in elem.findall("param"):
158 # <param> tags have the same format as a <proto> tag.
159 args.append(FunctionArg(*_parseProtoElem(ch)))
160 func = FunctionDesc(name, rt, tuple(args), slot=None)
161
162 return func
163
164 def _parseProtoElem(elem):
165 # If I just remove the tags and string the text together, I'll get valid C code.
166 text = _flattenText(elem)
167 text = text.strip()
168 m = re.match(r"^(.+)\b(\w+)(?:\s*\[\s*(\d*)\s*\])?$", text, re.S)
169 if m:
170 typename = _fixupTypeName(m.group(1))
171 name = m.group(2)
172 if m.group(3):
173 # HACK: glPathGlyphIndexRangeNV defines an argument like this:
174 # GLuint baseAndCount[2]
175 # Convert it to a pointer and hope for the best.
176 typename += "*"
177 return (typename, name)
178 else:
179 raise ValueError("Can't parse element %r -> %r" % (elem, text))
180
181 def _flattenText(elem):
182 """
183 Returns the text in an element and all child elements, with the tags
184 removed.
185 """
186 text = ""
187 if elem.text is not None:
188 text = elem.text
189 for ch in elem:
190 text += _flattenText(ch)
191 if ch.tail is not None:
192 text += ch.tail
193 return text
194
195 def _fixupTypeName(typeName):
196 """
197 Converts a typename into a more consistent format.
198 """
199
200 rv = typeName.strip()
201
202 # Replace "GLvoid" with just plain "void".
203 rv = re.sub(r"\bGLvoid\b", "void", rv)
204
205 # Remove the vendor suffixes from types that have a suffix-less version.
206 rv = re.sub(r"\b(GLhalf|GLintptr|GLsizeiptr|GLint64|GLuint64)(?:ARB|EXT|NV|ATI)\b", r"\1", rv)
207
208 rv = re.sub(r"\bGLvoid\b", "void", rv)
209
210 # Clear out any leading and trailing whitespace.
211 rv = rv.strip()
212
213 # Remove any whitespace before a '*'
214 rv = re.sub(r"\s+\*", r"*", rv)
215
216 # Change "foo*" to "foo *"
217 rv = re.sub(r"([^\*])\*", r"\1 *", rv)
218
219 # Condense all whitespace into a single space.
220 rv = re.sub(r"\s+", " ", rv)
221
222 return rv
223