########################################################################
# 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
from warnings import warnpy3k
warnpy3k("the cgen module has been removed in Python 3.0", stacklevel=2)
del warnpy3k


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 '}'