1 ######################################################################## 2 # Copyright (c) 2000, BeOpen.com. 3 # Copyright (c) 1995-2000, Corporation for National Research Initiatives. 4 # Copyright (c) 1990-1995, Stichting Mathematisch Centrum. 5 # All rights reserved. 6 # 7 # See the file "Misc/COPYRIGHT" for information on usage and 8 # redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. 9 ######################################################################## 10 11 # Python script to parse cstubs file for gl and generate C stubs. 12 # usage: python cgen.py <cstubs >glmodule.c 13 # 14 # NOTE: You must first make a python binary without the "GL" option 15 # before you can run this, when building Python for the first time. 16 # See comments in the Makefile. 17 # 18 # XXX BUG return arrays generate wrong code 19 # XXX need to change error returns into gotos to free mallocked arrays 20 from warnings import warnpy3k 21 warnpy3k("the cgen module has been removed in Python 3.0", stacklevel=2) 22 del warnpy3k 23 24 25 import string 26 import sys 27 28 29 # Function to print to stderr 30 # 31 def err(*args): 32 savestdout = sys.stdout 33 try: 34 sys.stdout = sys.stderr 35 for i in args: 36 print i, 37 print 38 finally: 39 sys.stdout = savestdout 40 41 42 # The set of digits that form a number 43 # 44 digits = '0123456789' 45 46 47 # Function to extract a string of digits from the front of the string. 48 # Returns the leading string of digits and the remaining string. 49 # If no number is found, returns '' and the original string. 50 # 51 def getnum(s): 52 n = '' 53 while s and s[0] in digits: 54 n = n + s[0] 55 s = s[1:] 56 return n, s 57 58 59 # Function to check if a string is a number 60 # 61 def isnum(s): 62 if not s: return False 63 for c in s: 64 if not c in digits: return False 65 return True 66 67 68 # Allowed function return types 69 # 70 return_types = ['void', 'short', 'long'] 71 72 73 # Allowed function argument types 74 # 75 arg_types = ['char', 'string', 'short', 'u_short', 'float', 'long', 'double'] 76 77 78 # Need to classify arguments as follows 79 # simple input variable 80 # simple output variable 81 # input array 82 # output array 83 # input giving size of some array 84 # 85 # Array dimensions can be specified as follows 86 # constant 87 # argN 88 # constant * argN 89 # retval 90 # constant * retval 91 # 92 # The dimensions given as constants * something are really 93 # arrays of points where points are 2- 3- or 4-tuples 94 # 95 # We have to consider three lists: 96 # python input arguments 97 # C stub arguments (in & out) 98 # python output arguments (really return values) 99 # 100 # There is a mapping from python input arguments to the input arguments 101 # of the C stub, and a further mapping from C stub arguments to the 102 # python return values 103 104 105 # Exception raised by checkarg() and generate() 106 # 107 arg_error = 'bad arg' 108 109 110 # Function to check one argument. 111 # Arguments: the type and the arg "name" (really mode plus subscript). 112 # Raises arg_error if something's wrong. 113 # Return type, mode, factor, rest of subscript; factor and rest may be empty. 114 # 115 def checkarg(type, arg): 116 # 117 # Turn "char *x" into "string x". 118 # 119 if type == 'char' and arg[0] == '*': 120 type = 'string' 121 arg = arg[1:] 122 # 123 # Check that the type is supported. 124 # 125 if type not in arg_types: 126 raise arg_error, ('bad type', type) 127 if type[:2] == 'u_': 128 type = 'unsigned ' + type[2:] 129 # 130 # Split it in the mode (first character) and the rest. 131 # 132 mode, rest = arg[:1], arg[1:] 133 # 134 # The mode must be 's' for send (= input) or 'r' for return argument. 135 # 136 if mode not in ('r', 's'): 137 raise arg_error, ('bad arg mode', mode) 138 # 139 # Is it a simple argument: if so, we are done. 140 # 141 if not rest: 142 return type, mode, '', '' 143 # 144 # Not a simple argument; must be an array. 145 # The 'rest' must be a subscript enclosed in [ and ]. 146 # The subscript must be one of the following forms, 147 # otherwise we don't handle it (where N is a number): 148 # N 149 # argN 150 # retval 151 # N*argN 152 # N*retval 153 # 154 if rest[:1] <> '[' or rest[-1:] <> ']': 155 raise arg_error, ('subscript expected', rest) 156 sub = rest[1:-1] 157 # 158 # Is there a leading number? 159 # 160 num, sub = getnum(sub) 161 if num: 162 # There is a leading number 163 if not sub: 164 # The subscript is just a number 165 return type, mode, num, '' 166 if sub[:1] == '*': 167 # There is a factor prefix 168 sub = sub[1:] 169 else: 170 raise arg_error, ('\'*\' expected', sub) 171 if sub == 'retval': 172 # size is retval -- must be a reply argument 173 if mode <> 'r': 174 raise arg_error, ('non-r mode with [retval]', mode) 175 elif not isnum(sub) and (sub[:3] <> 'arg' or not isnum(sub[3:])): 176 raise arg_error, ('bad subscript', sub) 177 # 178 return type, mode, num, sub 179 180 181 # List of functions for which we have generated stubs 182 # 183 functions = [] 184 185 186 # Generate the stub for the given function, using the database of argument 187 # information build by successive calls to checkarg() 188 # 189 def generate(type, func, database): 190 # 191 # Check that we can handle this case: 192 # no variable size reply arrays yet 193 # 194 n_in_args = 0 195 n_out_args = 0 196 # 197 for a_type, a_mode, a_factor, a_sub in database: 198 if a_mode == 's': 199 n_in_args = n_in_args + 1 200 elif a_mode == 'r': 201 n_out_args = n_out_args + 1 202 else: 203 # Can't happen 204 raise arg_error, ('bad a_mode', a_mode) 205 if (a_mode == 'r' and a_sub) or a_sub == 'retval': 206 err('Function', func, 'too complicated:', 207 a_type, a_mode, a_factor, a_sub) 208 print '/* XXX Too complicated to generate code for */' 209 return 210 # 211 functions.append(func) 212 # 213 # Stub header 214 # 215 print 216 print 'static PyObject *' 217 print 'gl_' + func + '(self, args)' 218 print '\tPyObject *self;' 219 print '\tPyObject *args;' 220 print '{' 221 # 222 # Declare return value if any 223 # 224 if type <> 'void': 225 print '\t' + type, 'retval;' 226 # 227 # Declare arguments 228 # 229 for i in range(len(database)): 230 a_type, a_mode, a_factor, a_sub = database[i] 231 print '\t' + a_type, 232 brac = ket = '' 233 if a_sub and not isnum(a_sub): 234 if a_factor: 235 brac = '(' 236 ket = ')' 237 print brac + '*', 238 print 'arg' + repr(i+1) + ket, 239 if a_sub and isnum(a_sub): 240 print '[', a_sub, ']', 241 if a_factor: 242 print '[', a_factor, ']', 243 print ';' 244 # 245 # Find input arguments derived from array sizes 246 # 247 for i in range(len(database)): 248 a_type, a_mode, a_factor, a_sub = database[i] 249 if a_mode == 's' and a_sub[:3] == 'arg' and isnum(a_sub[3:]): 250 # Sending a variable-length array 251 n = eval(a_sub[3:]) 252 if 1 <= n <= len(database): 253 b_type, b_mode, b_factor, b_sub = database[n-1] 254 if b_mode == 's': 255 database[n-1] = b_type, 'i', a_factor, repr(i) 256 n_in_args = n_in_args - 1 257 # 258 # Assign argument positions in the Python argument list 259 # 260 in_pos = [] 261 i_in = 0 262 for i in range(len(database)): 263 a_type, a_mode, a_factor, a_sub = database[i] 264 if a_mode == 's': 265 in_pos.append(i_in) 266 i_in = i_in + 1 267 else: 268 in_pos.append(-1) 269 # 270 # Get input arguments 271 # 272 for i in range(len(database)): 273 a_type, a_mode, a_factor, a_sub = database[i] 274 if a_type[:9] == 'unsigned ': 275 xtype = a_type[9:] 276 else: 277 xtype = a_type 278 if a_mode == 'i': 279 # 280 # Implicit argument; 281 # a_factor is divisor if present, 282 # a_sub indicates which arg (`database index`) 283 # 284 j = eval(a_sub) 285 print '\tif', 286 print '(!geti' + xtype + 'arraysize(args,', 287 print repr(n_in_args) + ',', 288 print repr(in_pos[j]) + ',', 289 if xtype <> a_type: 290 print '('+xtype+' *)', 291 print '&arg' + repr(i+1) + '))' 292 print '\t\treturn NULL;' 293 if a_factor: 294 print '\targ' + repr(i+1), 295 print '= arg' + repr(i+1), 296 print '/', a_factor + ';' 297 elif a_mode == 's': 298 if a_sub and not isnum(a_sub): 299 # Allocate memory for varsize array 300 print '\tif ((arg' + repr(i+1), '=', 301 if a_factor: 302 print '('+a_type+'(*)['+a_factor+'])', 303 print 'PyMem_NEW(' + a_type, ',', 304 if a_factor: 305 print a_factor, '*', 306 print a_sub, ')) == NULL)' 307 print '\t\treturn PyErr_NoMemory();' 308 print '\tif', 309 if a_factor or a_sub: # Get a fixed-size array array 310 print '(!geti' + xtype + 'array(args,', 311 print repr(n_in_args) + ',', 312 print repr(in_pos[i]) + ',', 313 if a_factor: print a_factor, 314 if a_factor and a_sub: print '*', 315 if a_sub: print a_sub, 316 print ',', 317 if (a_sub and a_factor) or xtype <> a_type: 318 print '('+xtype+' *)', 319 print 'arg' + repr(i+1) + '))' 320 else: # Get a simple variable 321 print '(!geti' + xtype + 'arg(args,', 322 print repr(n_in_args) + ',', 323 print repr(in_pos[i]) + ',', 324 if xtype <> a_type: 325 print '('+xtype+' *)', 326 print '&arg' + repr(i+1) + '))' 327 print '\t\treturn NULL;' 328 # 329 # Begin of function call 330 # 331 if type <> 'void': 332 print '\tretval =', func + '(', 333 else: 334 print '\t' + func + '(', 335 # 336 # Argument list 337 # 338 for i in range(len(database)): 339 if i > 0: print ',', 340 a_type, a_mode, a_factor, a_sub = database[i] 341 if a_mode == 'r' and not a_factor: 342 print '&', 343 print 'arg' + repr(i+1), 344 # 345 # End of function call 346 # 347 print ');' 348 # 349 # Free varsize arrays 350 # 351 for i in range(len(database)): 352 a_type, a_mode, a_factor, a_sub = database[i] 353 if a_mode == 's' and a_sub and not isnum(a_sub): 354 print '\tPyMem_DEL(arg' + repr(i+1) + ');' 355 # 356 # Return 357 # 358 if n_out_args: 359 # 360 # Multiple return values -- construct a tuple 361 # 362 if type <> 'void': 363 n_out_args = n_out_args + 1 364 if n_out_args == 1: 365 for i in range(len(database)): 366 a_type, a_mode, a_factor, a_sub = database[i] 367 if a_mode == 'r': 368 break 369 else: 370 raise arg_error, 'expected r arg not found' 371 print '\treturn', 372 print mkobject(a_type, 'arg' + repr(i+1)) + ';' 373 else: 374 print '\t{ PyObject *v = PyTuple_New(', 375 print n_out_args, ');' 376 print '\t if (v == NULL) return NULL;' 377 i_out = 0 378 if type <> 'void': 379 print '\t PyTuple_SetItem(v,', 380 print repr(i_out) + ',', 381 print mkobject(type, 'retval') + ');' 382 i_out = i_out + 1 383 for i in range(len(database)): 384 a_type, a_mode, a_factor, a_sub = database[i] 385 if a_mode == 'r': 386 print '\t PyTuple_SetItem(v,', 387 print repr(i_out) + ',', 388 s = mkobject(a_type, 'arg' + repr(i+1)) 389 print s + ');' 390 i_out = i_out + 1 391 print '\t return v;' 392 print '\t}' 393 else: 394 # 395 # Simple function return 396 # Return None or return value 397 # 398 if type == 'void': 399 print '\tPy_INCREF(Py_None);' 400 print '\treturn Py_None;' 401 else: 402 print '\treturn', mkobject(type, 'retval') + ';' 403 # 404 # Stub body closing brace 405 # 406 print '}' 407 408 409 # Subroutine to return a function call to mknew<type>object(<arg>) 410 # 411 def mkobject(type, arg): 412 if type[:9] == 'unsigned ': 413 type = type[9:] 414 return 'mknew' + type + 'object((' + type + ') ' + arg + ')' 415 return 'mknew' + type + 'object(' + arg + ')' 416 417 418 defined_archs = [] 419 420 # usage: cgen [ -Dmach ... ] [ file ] 421 for arg in sys.argv[1:]: 422 if arg[:2] == '-D': 423 defined_archs.append(arg[2:]) 424 else: 425 # Open optional file argument 426 sys.stdin = open(arg, 'r') 427 428 429 # Input line number 430 lno = 0 431 432 433 # Input is divided in two parts, separated by a line containing '%%'. 434 # <part1> -- literally copied to stdout 435 # <part2> -- stub definitions 436 437 # Variable indicating the current input part. 438 # 439 part = 1 440 441 # Main loop over the input 442 # 443 while 1: 444 try: 445 line = raw_input() 446 except EOFError: 447 break 448 # 449 lno = lno+1 450 words = string.split(line) 451 # 452 if part == 1: 453 # 454 # In part 1, copy everything literally 455 # except look for a line of just '%%' 456 # 457 if words == ['%%']: 458 part = part + 1 459 else: 460 # 461 # Look for names of manually written 462 # stubs: a single percent followed by the name 463 # of the function in Python. 464 # The stub name is derived by prefixing 'gl_'. 465 # 466 if words and words[0][0] == '%': 467 func = words[0][1:] 468 if (not func) and words[1:]: 469 func = words[1] 470 if func: 471 functions.append(func) 472 else: 473 print line 474 continue 475 if not words: 476 continue # skip empty line 477 elif words[0] == 'if': 478 # if XXX rest 479 # if !XXX rest 480 if words[1][0] == '!': 481 if words[1][1:] in defined_archs: 482 continue 483 elif words[1] not in defined_archs: 484 continue 485 words = words[2:] 486 if words[0] == '#include': 487 print line 488 elif words[0][:1] == '#': 489 pass # ignore comment 490 elif words[0] not in return_types: 491 err('Line', lno, ': bad return type :', words[0]) 492 elif len(words) < 2: 493 err('Line', lno, ': no funcname :', line) 494 else: 495 if len(words) % 2 <> 0: 496 err('Line', lno, ': odd argument list :', words[2:]) 497 else: 498 database = [] 499 try: 500 for i in range(2, len(words), 2): 501 x = checkarg(words[i], words[i+1]) 502 database.append(x) 503 print 504 print '/*', 505 for w in words: print w, 506 print '*/' 507 generate(words[0], words[1], database) 508 except arg_error, msg: 509 err('Line', lno, ':', msg) 510 511 512 print 513 print 'static struct PyMethodDef gl_methods[] = {' 514 for func in functions: 515 print '\t{"' + func + '", gl_' + func + '},' 516 print '\t{NULL, NULL} /* Sentinel */' 517 print '};' 518 print 519 print 'void' 520 print 'initgl()' 521 print '{' 522 print '\t(void) Py_InitModule("gl", gl_methods);' 523 print '}' 524
