Fix things for 64-bit systems

[gldbg.git] / generate.py

diff --git a/generate.py b/generate.py
index e30f6d1f869c1f8581953a08f8e992a537c9e4d6..4b6bb7902c7187f493a8868d9e2c07b17b2865b7 100755 (executable)
--- a/generate.py
+++ b/generate.py
@@ -1,8 +1,8 @@
 #!/usr/bin/python
-# $Id$
 
 import sys
 import os
+import optparse
 
 class InputFile:
        def __init__(self, fn):
@@ -145,10 +145,6 @@ class Function:
                                        if (s.type=="SizeI" or s.type.endswith("Int32") or s.type.startswith("BufferSize")):
                                                if s.kind=="value":
                                                        self.csize = "%s"%self.size
-                                                       if self.func.name.startswith("glUniformMatrix") and self.func.name[16]!='x':
-                                                               self.csize += "*%d"%(int(self.func.name[15])**2)
-                                                       elif self.func.name.startswith("glUniform") and self.func.name[9].isdigit():
-                                                               self.csize += "*%s"%self.func.name[9]
                                                        if strip_name(self.base_ctype)!="void":
                                                                self.csize += "*sizeof(%s)"%self.base_ctype
                                                elif s.kind=="array" and s.size==1:
@@ -306,6 +302,8 @@ class Template:
                                iomap = IOmap(api.iomap)
                                for spec in api.specs:
                                        funcs = read_spec(spec, api.prefix)
+                                       for err in api.errata:
+                                               read_spec(err, api.prefix, funcs)
                                        funcs = [f for f in funcs if f.name not in api.ignore_funcs and f.category not in api.ignore_categs]
                                        for func in funcs:
                                                func.finalize(typemap, iomap)
@@ -327,24 +325,29 @@ class Api:
                self.typemap = None
                self.iomap = None
                self.specs = []
+               self.errata = []
                self.prefix = None
                self.enumspecs = []
                self.enumprefix = None
                self.ignore_categs = []
                self.ignore_funcs = []
 
+               path = os.path.split(fn)[0]
+
                for line in InputFile(fn):
                        parts = line.split()
                        if parts[0]=="typemap":
-                               self.typemap = parts[1]
+                               self.typemap = os.path.join(path, parts[1])
                        elif parts[0]=="iomap":
-                               self.iomap = parts[1]
+                               self.iomap = os.path.join(path, parts[1])
                        elif parts[0]=="spec":
-                               self.specs.append(parts[1])
+                               self.specs.append(os.path.join(path, parts[1]))
+                       elif parts[0]=="errata":
+                               self.errata.append(os.path.join(path, parts[1]))
                        elif parts[0]=="prefix":
                                self.prefix = parts[1]
                        elif parts[0]=="enumspec":
-                               self.enumspecs.append(parts[1])
+                               self.enumspecs.append(os.path.join(path, parts[1]))
                        elif parts[0]=="enumprefix":
                                self.enumprefix = parts[1]
                        elif parts[0]=="ignore":
@@ -356,8 +359,9 @@ class Api:
                                sys.stderr.write("Unknown keyword '%s'\n", parts[0])
 
 
-def read_spec(fn, prefix):
-       funcs = []
+def read_spec(fn, prefix, funcs=None):
+       if funcs is None:
+               funcs = []
        cur_func = None
 
        for line in InputFile(fn):
@@ -389,8 +393,15 @@ def read_spec(fn, prefix):
                                        pnames = [n.strip() for n in line[paren+1:cparen].split(",")]
                                else:
                                        pnames = []
-                               cur_func = Function(prefix+line[:paren], pnames)
-                               funcs.append(cur_func)
+                               fname = prefix+line[:paren]
+                               cur_func = None
+                               for f in funcs:
+                                       if f.name==fname:
+                                               cur_func = f
+                                               break
+                               if not cur_func:
+                                       cur_func = Function(prefix+line[:paren], pnames)
+                                       funcs.append(cur_func)
 
        return funcs
 
@@ -423,9 +434,25 @@ def read_enums(fn, prefix):
 
        return enums
 
-template = Template(sys.argv[1])
+parser = optparse.OptionParser()
+parser.add_option("--depends", dest="depends", default=False)
+(options, args) = parser.parse_args()
+
+template = Template(args[0])
 apis = []
-for i in sys.argv[2:]:
+for i in args[1:]:
        apis.append(Api(i))
 
-template.process(apis)
+if options.depends:
+       deps = args[:]
+       if template.mode=="functions":
+               for api in apis:
+                       deps += api.specs
+                       deps.append(api.typemap)
+                       deps.append(api.iomap)
+       elif template.mode=="enums":
+               for api in apis:
+                       deps += api.enumspecs
+       sys.stdout.write("%s: %s\n"%(options.depends, " ".join(deps)))
+else:
+       template.process(apis)