Modules/cgen.py

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