cgen.py 12.2 KB
Newer Older
1
########################################################################
2 3 4 5
# Copyright (c) 2000, BeOpen.com.
# Copyright (c) 1995-2000, Corporation for National Research Initiatives.
# Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
# All rights reserved.
6
# 
7 8
# See the file "Misc/COPYRIGHT" for information on usage and
# redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
9 10
########################################################################

Guido van Rossum's avatar
Guido van Rossum committed
11
# Python script to parse cstubs file for gl and generate C stubs.
12
# usage: python cgen.py <cstubs >glmodule.c
Guido van Rossum's avatar
Guido van Rossum committed
13
#
14 15 16 17
# 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.
#
Guido van Rossum's avatar
Guido van Rossum committed
18 19 20 21 22 23 24 25 26 27
# 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
#
28
def err(*args):
Guido van Rossum's avatar
Guido van Rossum committed
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
	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 = ''
Guido van Rossum's avatar
Guido van Rossum committed
50 51
	while s and s[0] in digits:
		n = n + s[0]
Guido van Rossum's avatar
Guido van Rossum committed
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
		s = s[1:]
	return n, s


# Function to check if a string is a number
#
def isnum(s):
	if not s: return 0
	for c in s:
		if not c in digits: return 0
	return 1


# Allowed function return types
#
return_types = ['void', 'short', 'long']


# Allowed function argument types
#
72
arg_types = ['char', 'string', 'short', 'u_short', 'float', 'long', 'double']
Guido van Rossum's avatar
Guido van Rossum committed
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115


# 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".
	#
116
	if type == 'char' and arg[0] == '*':
Guido van Rossum's avatar
Guido van Rossum committed
117 118 119 120 121 122 123
		type = 'string'
		arg = arg[1:]
	#
	# Check that the type is supported.
	#
	if type not in arg_types:
		raise arg_error, ('bad type', type)
124 125
	if type[:2] == 'u_':
		type = 'unsigned ' + type[2:]
Guido van Rossum's avatar
Guido van Rossum committed
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
	#
	# 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, ''
163
		if sub[:1] == '*':
Guido van Rossum's avatar
Guido van Rossum committed
164 165 166 167
			# There is a factor prefix
			sub = sub[1:]
		else:
			raise arg_error, ('\'*\' expected', sub)
168
	if sub == 'retval':
Guido van Rossum's avatar
Guido van Rossum committed
169 170 171
		# size is retval -- must be a reply argument
		if mode <> 'r':
			raise arg_error, ('non-r mode with [retval]', mode)
172
	elif not isnum(sub) and (sub[:3] <> 'arg' or not isnum(sub[3:])):
Guido van Rossum's avatar
Guido van Rossum committed
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
		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:
195
		if a_mode == 's':
Guido van Rossum's avatar
Guido van Rossum committed
196
			n_in_args = n_in_args + 1
197
		elif a_mode == 'r':
Guido van Rossum's avatar
Guido van Rossum committed
198 199 200 201
			n_out_args = n_out_args + 1
		else:
			# Can't happen
			raise arg_error, ('bad a_mode', a_mode)
202
		if (a_mode == 'r' and a_sub) or a_sub == 'retval':
203 204
			err('Function', func, 'too complicated:',
			    a_type, a_mode, a_factor, a_sub)
Guido van Rossum's avatar
Guido van Rossum committed
205 206 207 208 209 210 211 212
			print '/* XXX Too complicated to generate code for */'
			return
	#
	functions.append(func)
	#
	# Stub header
	#
	print
Guido van Rossum's avatar
Guido van Rossum committed
213
	print 'static PyObject *'
Guido van Rossum's avatar
Guido van Rossum committed
214
	print 'gl_' + func + '(self, args)'
Guido van Rossum's avatar
Guido van Rossum committed
215 216
	print '\tPyObject *self;'
	print '\tPyObject *args;'
Guido van Rossum's avatar
Guido van Rossum committed
217 218 219 220 221 222 223 224 225 226 227 228
	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,
229 230 231 232 233 234 235 236 237 238
		brac = ket = ''
		if a_sub and not isnum(a_sub):
			if a_factor:
				brac = '('
				ket = ')'
			print brac + '*',
		print 'arg' + `i+1` + ket,
		if a_sub and isnum(a_sub):
			print '[', a_sub, ']',
		if a_factor:
Guido van Rossum's avatar
Guido van Rossum committed
239 240 241 242 243 244 245
			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]
246
		if a_mode == 's' and a_sub[:3] == 'arg' and isnum(a_sub[3:]):
Guido van Rossum's avatar
Guido van Rossum committed
247 248 249 250
			# 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]
251
			    if b_mode == 's':
Guido van Rossum's avatar
Guido van Rossum committed
252 253 254 255 256 257 258 259 260
			        database[n-1] = b_type, 'i', a_factor, `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]
261
		if a_mode == 's':
Guido van Rossum's avatar
Guido van Rossum committed
262 263 264 265 266 267 268 269 270
			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]
271 272 273 274
		if a_type[:9] == 'unsigned ':
			xtype = a_type[9:]
		else:
			xtype = a_type
275
		if a_mode == 'i':
Guido van Rossum's avatar
Guido van Rossum committed
276 277 278 279 280 281 282
			#
			# Implicit argument;
			# a_factor is divisor if present,
			# a_sub indicates which arg (`database index`)
			#
			j = eval(a_sub)
			print '\tif',
283
			print '(!geti' + xtype + 'arraysize(args,',
Guido van Rossum's avatar
Guido van Rossum committed
284 285
			print `n_in_args` + ',',
			print `in_pos[j]` + ',',
286 287
			if xtype <> a_type:
				print '('+xtype+' *)',
Guido van Rossum's avatar
Guido van Rossum committed
288 289 290 291 292 293
			print '&arg' + `i+1` + '))'
			print '\t\treturn NULL;'
			if a_factor:
				print '\targ' + `i+1`,
				print '= arg' + `i+1`,
				print '/', a_factor + ';'
294
		elif a_mode == 's':
295 296
			if a_sub and not isnum(a_sub):
				# Allocate memory for varsize array
Guido van Rossum's avatar
Guido van Rossum committed
297
				print '\tif ((arg' + `i+1`, '=',
298 299
				if a_factor:
					print '('+a_type+'(*)['+a_factor+'])',
Guido van Rossum's avatar
Guido van Rossum committed
300
				print 'PyMem_NEW(' + a_type, ',',
301 302
				if a_factor:
					print a_factor, '*',
Guido van Rossum's avatar
Guido van Rossum committed
303
				print a_sub, ')) == NULL)'
Guido van Rossum's avatar
Guido van Rossum committed
304
				print '\t\treturn PyErr_NoMemory();'
Guido van Rossum's avatar
Guido van Rossum committed
305 306
			print '\tif',
			if a_factor or a_sub: # Get a fixed-size array array
307
				print '(!geti' + xtype + 'array(args,',
Guido van Rossum's avatar
Guido van Rossum committed
308 309 310 311 312
				print `n_in_args` + ',',
				print `in_pos[i]` + ',',
				if a_factor: print a_factor,
				if a_factor and a_sub: print '*',
				if a_sub: print a_sub,
313 314 315 316
				print ',',
				if (a_sub and a_factor) or xtype <> a_type:
					print '('+xtype+' *)',
				print 'arg' + `i+1` + '))'
Guido van Rossum's avatar
Guido van Rossum committed
317
			else: # Get a simple variable
318
				print '(!geti' + xtype + 'arg(args,',
Guido van Rossum's avatar
Guido van Rossum committed
319 320
				print `n_in_args` + ',',
				print `in_pos[i]` + ',',
321 322
				if xtype <> a_type:
					print '('+xtype+' *)',
Guido van Rossum's avatar
Guido van Rossum committed
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
				print '&arg' + `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]
338
		if a_mode == 'r' and not a_factor:
Guido van Rossum's avatar
Guido van Rossum committed
339 340 341 342 343 344 345 346 347 348 349
			print '&',
		print 'arg' + `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]
350
		if a_mode == 's' and a_sub and not isnum(a_sub):
Guido van Rossum's avatar
Guido van Rossum committed
351
			print '\tPyMem_DEL(arg' + `i+1` + ');'
Guido van Rossum's avatar
Guido van Rossum committed
352 353 354 355 356 357 358 359 360
	#
	# Return
	#
	if n_out_args:
		#
		# Multiple return values -- construct a tuple
		#
		if type <> 'void':
			n_out_args = n_out_args + 1
361
		if n_out_args == 1:
Guido van Rossum's avatar
Guido van Rossum committed
362 363
			for i in range(len(database)):
				a_type, a_mode, a_factor, a_sub = database[i]
364
				if a_mode == 'r':
Guido van Rossum's avatar
Guido van Rossum committed
365 366 367 368 369 370
					break
			else:
				raise arg_error, 'expected r arg not found'
			print '\treturn',
			print mkobject(a_type, 'arg' + `i+1`) + ';'
		else:
Guido van Rossum's avatar
Guido van Rossum committed
371
			print '\t{ PyObject *v = PyTuple_New(',
Guido van Rossum's avatar
Guido van Rossum committed
372 373 374 375
			print n_out_args, ');'
			print '\t  if (v == NULL) return NULL;'
			i_out = 0
			if type <> 'void':
Guido van Rossum's avatar
Guido van Rossum committed
376
				print '\t  PyTuple_SetItem(v,',
Guido van Rossum's avatar
Guido van Rossum committed
377 378 379 380 381
				print `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]
382
				if a_mode == 'r':
Guido van Rossum's avatar
Guido van Rossum committed
383
					print '\t  PyTuple_SetItem(v,',
Guido van Rossum's avatar
Guido van Rossum committed
384 385 386 387 388 389 390 391 392 393 394
					print `i_out` + ',',
					s = mkobject(a_type, 'arg' + `i+1`)
					print s + ');'
					i_out = i_out + 1
			print '\t  return v;'
			print '\t}'
	else:
		#
		# Simple function return
		# Return None or return value
		#
395
		if type == 'void':
Guido van Rossum's avatar
Guido van Rossum committed
396 397
			print '\tPy_INCREF(Py_None);'
			print '\treturn Py_None;'
Guido van Rossum's avatar
Guido van Rossum committed
398 399 400 401 402 403 404 405 406 407 408
		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):
409 410 411
	if type[:9] == 'unsigned ':
		type = type[9:]
		return 'mknew' + type + 'object((' + type + ') ' + arg + ')'
Guido van Rossum's avatar
Guido van Rossum committed
412 413 414
	return 'mknew' + type + 'object(' + arg + ')'


415 416 417 418 419 420 421 422 423
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')
424 425


Guido van Rossum's avatar
Guido van Rossum committed
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
# 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)
	#
449
	if part == 1:
Guido van Rossum's avatar
Guido van Rossum committed
450 451 452 453
		#
		# In part 1, copy everything literally
		# except look for a line of just '%%'
		#
454
		if words == ['%%']:
Guido van Rossum's avatar
Guido van Rossum committed
455 456 457 458 459 460 461 462
			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_'.
			#
463
			if words and words[0][0] == '%':
Guido van Rossum's avatar
Guido van Rossum committed
464 465 466 467 468 469 470
				func = words[0][1:]
				if (not func) and words[1:]:
					func = words[1]
				if func:
					functions.append(func)
			else:
				print line
471 472 473 474 475 476 477 478 479 480 481 482 483
		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':
Guido van Rossum's avatar
Guido van Rossum committed
484
		print line
485
	elif words[0][:1] == '#':
Guido van Rossum's avatar
Guido van Rossum committed
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
		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
Guido van Rossum's avatar
Guido van Rossum committed
510
print 'static struct PyMethodDef gl_methods[] = {'
Guido van Rossum's avatar
Guido van Rossum committed
511 512 513 514 515
for func in functions:
	print '\t{"' + func + '", gl_' + func + '},'
print '\t{NULL, NULL} /* Sentinel */'
print '};'
print
516
print 'void'
Guido van Rossum's avatar
Guido van Rossum committed
517 518
print 'initgl()'
print '{'
Guido van Rossum's avatar
Guido van Rossum committed
519
print '\t(void) Py_InitModule("gl", gl_methods);'
Guido van Rossum's avatar
Guido van Rossum committed
520
print '}'