[Python-checkins] python/dist/src/Modules cgen.py,2.17,2.18

tim_one at users.sourceforge.net tim_one at users.sourceforge.net
Sun Jul 18 08:16:10 CEST 2004


Update of /cvsroot/python/python/dist/src/Modules
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv31781

Modified Files:
	cgen.py 
Log Message:
Whitespace normalization, via reindent.py.


Index: cgen.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Modules/cgen.py,v
retrieving revision 2.17
retrieving revision 2.18
diff -C2 -d -r2.17 -r2.18
*** cgen.py	12 Feb 2004 17:35:14 -0000	2.17
--- cgen.py	18 Jul 2004 06:16:08 -0000	2.18
***************
*** 4,8 ****
  # 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.
--- 4,8 ----
  # 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.
***************
*** 13,18 ****
  #
  # 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
--- 13,18 ----
  #
  # 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
***************
*** 27,38 ****
  #
  def err(*args):
! 	savestdout = sys.stdout
! 	try:
! 		sys.stdout = sys.stderr
! 		for i in args:
! 			print i,
! 		print
! 	finally:
! 		sys.stdout = savestdout
  
  
--- 27,38 ----
  #
  def err(*args):
!     savestdout = sys.stdout
!     try:
!         sys.stdout = sys.stderr
!         for i in args:
!             print i,
!         print
!     finally:
!         sys.stdout = savestdout
  
  
***************
*** 47,55 ****
  #
  def getnum(s):
! 	n = ''
! 	while s and s[0] in digits:
! 		n = n + s[0]
! 		s = s[1:]
! 	return n, s
  
  
--- 47,55 ----
  #
  def getnum(s):
!     n = ''
!     while s and s[0] in digits:
!         n = n + s[0]
!         s = s[1:]
!     return n, s
  
  
***************
*** 57,64 ****
  #
  def isnum(s):
! 	if not s: return False
! 	for c in s:
! 		if not c in digits: return False
! 	return True
  
  
--- 57,64 ----
  #
  def isnum(s):
!     if not s: return False
!     for c in s:
!         if not c in digits: return False
!     return True
  
  
***************
*** 74,89 ****
  
  # 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
--- 74,89 ----
  
  # 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
***************
*** 91,97 ****
  #
  # 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
--- 91,97 ----
  #
  # 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
***************
*** 111,177 ****
  #
  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
  
  
--- 111,177 ----
  #
  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
  
  
***************
*** 185,405 ****
  #
  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 '}'
  
  
--- 185,405 ----
  #
  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 '}'
  
  
***************
*** 407,414 ****
  #
  def mkobject(type, arg):
! 	if type[:9] == 'unsigned ':
! 		type = type[9:]
! 		return 'mknew' + type + 'object((' + type + ') ' + arg + ')'
! 	return 'mknew' + type + 'object(' + arg + ')'
  
  
--- 407,414 ----
  #
  def mkobject(type, arg):
!     if type[:9] == 'unsigned ':
!         type = type[9:]
!         return 'mknew' + type + 'object((' + type + ') ' + arg + ')'
!     return 'mknew' + type + 'object(' + arg + ')'
  
  
***************
*** 417,425 ****
  # 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')
  
  
--- 417,425 ----
  # 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')
  
  
***************
*** 429,434 ****
  
  # 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.
--- 429,434 ----
  
  # 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.
***************
*** 439,508 ****
  #
  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)
  
  
--- 439,508 ----
  #
  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)
  
  
***************
*** 510,514 ****
  print 'static struct PyMethodDef gl_methods[] = {'
  for func in functions:
! 	print '\t{"' + func + '", gl_' + func + '},'
  print '\t{NULL, NULL} /* Sentinel */'
  print '};'
--- 510,514 ----
  print 'static struct PyMethodDef gl_methods[] = {'
  for func in functions:
!     print '\t{"' + func + '", gl_' + func + '},'
  print '\t{NULL, NULL} /* Sentinel */'
  print '};'



More information about the Python-checkins mailing list