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