| ######################################################################## |
| # Copyright (c) 2000, BeOpen.com. |
| # Copyright (c) 1995-2000, Corporation for National Research Initiatives. |
| # Copyright (c) 1990-1995, Stichting Mathematisch Centrum. |
| # All rights reserved. |
| # |
| # See the file "Misc/COPYRIGHT" for information on usage and |
| # redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. |
| ######################################################################## |
| |
| # Python script to parse cstubs file for gl and generate C stubs. |
| # usage: python cgen.py <cstubs >glmodule.c |
| # |
| # NOTE: You must first make a python binary without the "GL" option |
| # before you can run this, when building Python for the first time. |
| # See comments in the Makefile. |
| # |
| # XXX BUG return arrays generate wrong code |
| # XXX need to change error returns into gotos to free mallocked arrays |
| |
| |
| import string |
| import sys |
| |
| |
| # Function to print to stderr |
| # |
| def err(*args): |
| savestdout = sys.stdout |
| try: |
| sys.stdout = sys.stderr |
| for i in args: |
| print i, |
| print |
| finally: |
| sys.stdout = savestdout |
| |
| |
| # The set of digits that form a number |
| # |
| digits = '0123456789' |
| |
| |
| # Function to extract a string of digits from the front of the string. |
| # Returns the leading string of digits and the remaining string. |
| # If no number is found, returns '' and the original string. |
| # |
| def getnum(s): |
| n = '' |
| while s and s[0] in digits: |
| n = n + s[0] |
| s = s[1:] |
| return n, s |
| |
| |
| # Function to check if a string is a number |
| # |
| def isnum(s): |
| if not s: return False |
| for c in s: |
| if not c in digits: return False |
| return True |
| |
| |
| # Allowed function return types |
| # |
| return_types = ['void', 'short', 'long'] |
| |
| |
| # Allowed function argument types |
| # |
| arg_types = ['char', 'string', 'short', 'u_short', 'float', 'long', 'double'] |
| |
| |
| # Need to classify arguments as follows |
| # simple input variable |
| # simple output variable |
| # input array |
| # output array |
| # input giving size of some array |
| # |
| # Array dimensions can be specified as follows |
| # constant |
| # argN |
| # constant * argN |
| # retval |
| # constant * retval |
| # |
| # The dimensions given as constants * something are really |
| # arrays of points where points are 2- 3- or 4-tuples |
| # |
| # We have to consider three lists: |
| # python input arguments |
| # C stub arguments (in & out) |
| # python output arguments (really return values) |
| # |
| # There is a mapping from python input arguments to the input arguments |
| # of the C stub, and a further mapping from C stub arguments to the |
| # python return values |
| |
| |
| # Exception raised by checkarg() and generate() |
| # |
| arg_error = 'bad arg' |
| |
| |
| # Function to check one argument. |
| # Arguments: the type and the arg "name" (really mode plus subscript). |
| # Raises arg_error if something's wrong. |
| # Return type, mode, factor, rest of subscript; factor and rest may be empty. |
| # |
| def checkarg(type, arg): |
| # |
| # Turn "char *x" into "string x". |
| # |
| if type == 'char' and arg[0] == '*': |
| type = 'string' |
| arg = arg[1:] |
| # |
| # Check that the type is supported. |
| # |
| if type not in arg_types: |
| raise arg_error, ('bad type', type) |
| if type[:2] == 'u_': |
| type = 'unsigned ' + type[2:] |
| # |
| # Split it in the mode (first character) and the rest. |
| # |
| mode, rest = arg[:1], arg[1:] |
| # |
| # The mode must be 's' for send (= input) or 'r' for return argument. |
| # |
| if mode not in ('r', 's'): |
| raise arg_error, ('bad arg mode', mode) |
| # |
| # Is it a simple argument: if so, we are done. |
| # |
| if not rest: |
| return type, mode, '', '' |
| # |
| # Not a simple argument; must be an array. |
| # The 'rest' must be a subscript enclosed in [ and ]. |
| # The subscript must be one of the following forms, |
| # otherwise we don't handle it (where N is a number): |
| # N |
| # argN |
| # retval |
| # N*argN |
| # N*retval |
| # |
| if rest[:1] != '[' or rest[-1:] != ']': |
| raise arg_error, ('subscript expected', rest) |
| sub = rest[1:-1] |
| # |
| # Is there a leading number? |
| # |
| num, sub = getnum(sub) |
| if num: |
| # There is a leading number |
| if not sub: |
| # The subscript is just a number |
| return type, mode, num, '' |
| if sub[:1] == '*': |
| # There is a factor prefix |
| sub = sub[1:] |
| else: |
| raise arg_error, ('\'*\' expected', sub) |
| if sub == 'retval': |
| # size is retval -- must be a reply argument |
| if mode != 'r': |
| raise arg_error, ('non-r mode with [retval]', mode) |
| elif not isnum(sub) and (sub[:3] != 'arg' or not isnum(sub[3:])): |
| raise arg_error, ('bad subscript', sub) |
| # |
| return type, mode, num, sub |
| |
| |
| # List of functions for which we have generated stubs |
| # |
| functions = [] |
| |
| |
| # Generate the stub for the given function, using the database of argument |
| # information build by successive calls to checkarg() |
| # |
| def generate(type, func, database): |
| # |
| # Check that we can handle this case: |
| # no variable size reply arrays yet |
| # |
| n_in_args = 0 |
| n_out_args = 0 |
| # |
| for a_type, a_mode, a_factor, a_sub in database: |
| if a_mode == 's': |
| n_in_args = n_in_args + 1 |
| elif a_mode == 'r': |
| n_out_args = n_out_args + 1 |
| else: |
| # Can't happen |
| raise arg_error, ('bad a_mode', a_mode) |
| if (a_mode == 'r' and a_sub) or a_sub == 'retval': |
| err('Function', func, 'too complicated:', |
| a_type, a_mode, a_factor, a_sub) |
| print '/* XXX Too complicated to generate code for */' |
| return |
| # |
| functions.append(func) |
| # |
| # Stub header |
| # |
| print |
| print 'static PyObject *' |
| print 'gl_' + func + '(self, args)' |
| print '\tPyObject *self;' |
| print '\tPyObject *args;' |
| print '{' |
| # |
| # Declare return value if any |
| # |
| if type != 'void': |
| print '\t' + type, 'retval;' |
| # |
| # Declare arguments |
| # |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| print '\t' + a_type, |
| brac = ket = '' |
| if a_sub and not isnum(a_sub): |
| if a_factor: |
| brac = '(' |
| ket = ')' |
| print brac + '*', |
| print 'arg' + repr(i+1) + ket, |
| if a_sub and isnum(a_sub): |
| print '[', a_sub, ']', |
| if a_factor: |
| print '[', a_factor, ']', |
| print ';' |
| # |
| # Find input arguments derived from array sizes |
| # |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_mode == 's' and a_sub[:3] == 'arg' and isnum(a_sub[3:]): |
| # Sending a variable-length array |
| n = eval(a_sub[3:]) |
| if 1 <= n <= len(database): |
| b_type, b_mode, b_factor, b_sub = database[n-1] |
| if b_mode == 's': |
| database[n-1] = b_type, 'i', a_factor, repr(i) |
| n_in_args = n_in_args - 1 |
| # |
| # Assign argument positions in the Python argument list |
| # |
| in_pos = [] |
| i_in = 0 |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_mode == 's': |
| in_pos.append(i_in) |
| i_in = i_in + 1 |
| else: |
| in_pos.append(-1) |
| # |
| # Get input arguments |
| # |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_type[:9] == 'unsigned ': |
| xtype = a_type[9:] |
| else: |
| xtype = a_type |
| if a_mode == 'i': |
| # |
| # Implicit argument; |
| # a_factor is divisor if present, |
| # a_sub indicates which arg (`database index`) |
| # |
| j = eval(a_sub) |
| print '\tif', |
| print '(!geti' + xtype + 'arraysize(args,', |
| print repr(n_in_args) + ',', |
| print repr(in_pos[j]) + ',', |
| if xtype != a_type: |
| print '('+xtype+' *)', |
| print '&arg' + repr(i+1) + '))' |
| print '\t\treturn NULL;' |
| if a_factor: |
| print '\targ' + repr(i+1), |
| print '= arg' + repr(i+1), |
| print '/', a_factor + ';' |
| elif a_mode == 's': |
| if a_sub and not isnum(a_sub): |
| # Allocate memory for varsize array |
| print '\tif ((arg' + repr(i+1), '=', |
| if a_factor: |
| print '('+a_type+'(*)['+a_factor+'])', |
| print 'PyMem_NEW(' + a_type, ',', |
| if a_factor: |
| print a_factor, '*', |
| print a_sub, ')) == NULL)' |
| print '\t\treturn PyErr_NoMemory();' |
| print '\tif', |
| if a_factor or a_sub: # Get a fixed-size array array |
| print '(!geti' + xtype + 'array(args,', |
| print repr(n_in_args) + ',', |
| print repr(in_pos[i]) + ',', |
| if a_factor: print a_factor, |
| if a_factor and a_sub: print '*', |
| if a_sub: print a_sub, |
| print ',', |
| if (a_sub and a_factor) or xtype != a_type: |
| print '('+xtype+' *)', |
| print 'arg' + repr(i+1) + '))' |
| else: # Get a simple variable |
| print '(!geti' + xtype + 'arg(args,', |
| print repr(n_in_args) + ',', |
| print repr(in_pos[i]) + ',', |
| if xtype != a_type: |
| print '('+xtype+' *)', |
| print '&arg' + repr(i+1) + '))' |
| print '\t\treturn NULL;' |
| # |
| # Begin of function call |
| # |
| if type != 'void': |
| print '\tretval =', func + '(', |
| else: |
| print '\t' + func + '(', |
| # |
| # Argument list |
| # |
| for i in range(len(database)): |
| if i > 0: print ',', |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_mode == 'r' and not a_factor: |
| print '&', |
| print 'arg' + repr(i+1), |
| # |
| # End of function call |
| # |
| print ');' |
| # |
| # Free varsize arrays |
| # |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_mode == 's' and a_sub and not isnum(a_sub): |
| print '\tPyMem_DEL(arg' + repr(i+1) + ');' |
| # |
| # Return |
| # |
| if n_out_args: |
| # |
| # Multiple return values -- construct a tuple |
| # |
| if type != 'void': |
| n_out_args = n_out_args + 1 |
| if n_out_args == 1: |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_mode == 'r': |
| break |
| else: |
| raise arg_error, 'expected r arg not found' |
| print '\treturn', |
| print mkobject(a_type, 'arg' + repr(i+1)) + ';' |
| else: |
| print '\t{ PyObject *v = PyTuple_New(', |
| print n_out_args, ');' |
| print '\t if (v == NULL) return NULL;' |
| i_out = 0 |
| if type != 'void': |
| print '\t PyTuple_SetItem(v,', |
| print repr(i_out) + ',', |
| print mkobject(type, 'retval') + ');' |
| i_out = i_out + 1 |
| for i in range(len(database)): |
| a_type, a_mode, a_factor, a_sub = database[i] |
| if a_mode == 'r': |
| print '\t PyTuple_SetItem(v,', |
| print repr(i_out) + ',', |
| s = mkobject(a_type, 'arg' + repr(i+1)) |
| print s + ');' |
| i_out = i_out + 1 |
| print '\t return v;' |
| print '\t}' |
| else: |
| # |
| # Simple function return |
| # Return None or return value |
| # |
| if type == 'void': |
| print '\tPy_INCREF(Py_None);' |
| print '\treturn Py_None;' |
| else: |
| print '\treturn', mkobject(type, 'retval') + ';' |
| # |
| # Stub body closing brace |
| # |
| print '}' |
| |
| |
| # Subroutine to return a function call to mknew<type>object(<arg>) |
| # |
| def mkobject(type, arg): |
| if type[:9] == 'unsigned ': |
| type = type[9:] |
| return 'mknew' + type + 'object((' + type + ') ' + arg + ')' |
| return 'mknew' + type + 'object(' + arg + ')' |
| |
| |
| defined_archs = [] |
| |
| # usage: cgen [ -Dmach ... ] [ file ] |
| for arg in sys.argv[1:]: |
| if arg[:2] == '-D': |
| defined_archs.append(arg[2:]) |
| else: |
| # Open optional file argument |
| sys.stdin = open(arg, 'r') |
| |
| |
| # Input line number |
| lno = 0 |
| |
| |
| # Input is divided in two parts, separated by a line containing '%%'. |
| # <part1> -- literally copied to stdout |
| # <part2> -- stub definitions |
| |
| # Variable indicating the current input part. |
| # |
| part = 1 |
| |
| # Main loop over the input |
| # |
| while 1: |
| try: |
| line = raw_input() |
| except EOFError: |
| break |
| # |
| lno = lno+1 |
| words = string.split(line) |
| # |
| if part == 1: |
| # |
| # In part 1, copy everything literally |
| # except look for a line of just '%%' |
| # |
| if words == ['%%']: |
| part = part + 1 |
| else: |
| # |
| # Look for names of manually written |
| # stubs: a single percent followed by the name |
| # of the function in Python. |
| # The stub name is derived by prefixing 'gl_'. |
| # |
| if words and words[0][0] == '%': |
| func = words[0][1:] |
| if (not func) and words[1:]: |
| func = words[1] |
| if func: |
| functions.append(func) |
| else: |
| print line |
| continue |
| if not words: |
| continue # skip empty line |
| elif words[0] == 'if': |
| # if XXX rest |
| # if !XXX rest |
| if words[1][0] == '!': |
| if words[1][1:] in defined_archs: |
| continue |
| elif words[1] not in defined_archs: |
| continue |
| words = words[2:] |
| if words[0] == '#include': |
| print line |
| elif words[0][:1] == '#': |
| pass # ignore comment |
| elif words[0] not in return_types: |
| err('Line', lno, ': bad return type :', words[0]) |
| elif len(words) < 2: |
| err('Line', lno, ': no funcname :', line) |
| else: |
| if len(words) % 2 != 0: |
| err('Line', lno, ': odd argument list :', words[2:]) |
| else: |
| database = [] |
| try: |
| for i in range(2, len(words), 2): |
| x = checkarg(words[i], words[i+1]) |
| database.append(x) |
| print |
| print '/*', |
| for w in words: print w, |
| print '*/' |
| generate(words[0], words[1], database) |
| except arg_error, msg: |
| err('Line', lno, ':', msg) |
| |
| |
| print |
| print 'static struct PyMethodDef gl_methods[] = {' |
| for func in functions: |
| print '\t{"' + func + '", gl_' + func + '},' |
| print '\t{NULL, NULL} /* Sentinel */' |
| print '};' |
| print |
| print 'void' |
| print 'initgl()' |
| print '{' |
| print '\t(void) Py_InitModule("gl", gl_methods);' |
| print '}' |