Navigation

← Previous Changeset
Next Changeset →

Changeset 99

Timestamp:

03/19/04 22:58:00 (4 years ago)

Author:

Message:

Typo in import list of encodings

Files:

05/devel/kombilo.py (modified) (1 diff)
05/devel/sgfpars.py (modified) (11 diffs)
05/devel/sgfpars_wrap.cxx (modified) (70 diffs)
05/devel/v.py (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

05/devel/kombilo.py

r98	r99
63	63	import cjkcodecs.euc_jp
64	64	import cjkcodecs.euc_jisx0213
65		import cjkcodecs.iso_2002_jp
	65	import cjkcodecs.iso_2022_jp
66	66	import cjkcodecs.iso_2022_jp_1
67	67	import cjkcodecs.iso_2022_jp_2

05/devel/sgfpars.py

r62	r99
2	2	# Don't modify this file, modify the SWIG interface instead.
3	3	# This file is compatible with both classic and new-style classes.
	4
4	5	import _sgfpars
	6
5	7	def _swig_setattr(self,class_type,name,value):
6	8	if (name == "this"):
…	…
26	28	class _object : pass
27	29	_newclass = 0
	30	del types
28	31
29	32
…	…
33	36	__swig_getmethods__ = {}
34	37	__getattr__ = lambda self, name: _swig_getattr(self, SGFError, name)
35		def __init__(self,*args):
36		_swig_setattr(self, SGFError, 'this', apply(_sgfpars.new_SGFError,args))
	38	def __repr__(self):
	39	return "<C SGFError instance at %s>" % (self.this,)
	40	def __init__(self, *args):
	41	_swig_setattr(self, SGFError, 'this', _sgfpars.new_SGFError(*args))
37	42	_swig_setattr(self, SGFError, 'thisown', 1)
38		def __del__(self, destroy= _sgfpars.delete_SGFError):
39		try:
40		if self.thisown: destroy(self)
41		except: pass
42		def __repr__(self):
43		return "<C SGFError instance at %s>" % (self.this,)
	43	def __del__(self, destroy=_sgfpars.delete_SGFError):
	44	try:
	45	if self.thisown: destroy(self)
	46	except: pass
44	47
45	48	class SGFErrorPtr(SGFError):
46		def __init__(self,this):
	49	def __init__(self, this):
47	50	_swig_setattr(self, SGFError, 'this', this)
48	51	if not hasattr(self,"thisown"): _swig_setattr(self, SGFError, 'thisown', 0)
…	…
50	53	_sgfpars.SGFError_swigregister(SGFErrorPtr)
51	54
	55
52	56	SGFescape = _sgfpars.SGFescape
53
54	57	class Node(_object):
55	58	__swig_setmethods__ = {}
…	…
57	60	__swig_getmethods__ = {}
58	61	__getattr__ = lambda self, name: _swig_getattr(self, Node, name)
	62	def __repr__(self):
	63	return "<C Node instance at %s>" % (self.this,)
59	64	__swig_setmethods__["previous"] = _sgfpars.Node_previous_set
60	65	__swig_getmethods__["previous"] = _sgfpars.Node_previous_get
61		if _newclass:previous = property(_sgfpars.Node_previous_get,_sgfpars.Node_previous_set)
	66	if _newclass:previous = property(_sgfpars.Node_previous_get, _sgfpars.Node_previous_set)
62	67	__swig_setmethods__["next"] = _sgfpars.Node_next_set
63	68	__swig_getmethods__["next"] = _sgfpars.Node_next_get
64		if _newclass:next = property(_sgfpars.Node_next_get,_sgfpars.Node_next_set)
	69	if _newclass:next = property(_sgfpars.Node_next_get, _sgfpars.Node_next_set)
65	70	__swig_setmethods__["up"] = _sgfpars.Node_up_set
66	71	__swig_getmethods__["up"] = _sgfpars.Node_up_get
67		if _newclass:up = property(_sgfpars.Node_up_get,_sgfpars.Node_up_set)
	72	if _newclass:up = property(_sgfpars.Node_up_get, _sgfpars.Node_up_set)
68	73	__swig_setmethods__["down"] = _sgfpars.Node_down_set
69	74	__swig_getmethods__["down"] = _sgfpars.Node_down_get
70		if _newclass:down = property(_sgfpars.Node_down_get,_sgfpars.Node_down_set)
	75	if _newclass:down = property(_sgfpars.Node_down_get, _sgfpars.Node_down_set)
71	76	__swig_setmethods__["numChildren"] = _sgfpars.Node_numChildren_set
72	77	__swig_getmethods__["numChildren"] = _sgfpars.Node_numChildren_get
73		if _newclass:numChildren = property(_sgfpars.Node_numChildren_get,_sgfpars.Node_numChildren_set)
	78	if _newclass:numChildren = property(_sgfpars.Node_numChildren_get, _sgfpars.Node_numChildren_set)
74	79	__swig_setmethods__["level"] = _sgfpars.Node_level_set
75	80	__swig_getmethods__["level"] = _sgfpars.Node_level_get
76		if _newclass:level = property(_sgfpars.Node_level_get,_sgfpars.Node_level_set)
	81	if _newclass:level = property(_sgfpars.Node_level_get, _sgfpars.Node_level_set)
77	82	__swig_setmethods__["SGFstring"] = _sgfpars.Node_SGFstring_set
78	83	__swig_getmethods__["SGFstring"] = _sgfpars.Node_SGFstring_get
79		if _newclass:SGFstring = property(_sgfpars.Node_SGFstring_get,_sgfpars.Node_SGFstring_set)
	84	if _newclass:SGFstring = property(_sgfpars.Node_SGFstring_get, _sgfpars.Node_SGFstring_set)
80	85	__swig_setmethods__["parsed"] = _sgfpars.Node_parsed_set
81	86	__swig_getmethods__["parsed"] = _sgfpars.Node_parsed_get
82		if _newclass:parsed = property(_sgfpars.Node_parsed_get,_sgfpars.Node_parsed_set)
	87	if _newclass:parsed = property(_sgfpars.Node_parsed_get, _sgfpars.Node_parsed_set)
83	88	__swig_setmethods__["data"] = _sgfpars.Node_data_set
84	89	__swig_getmethods__["data"] = _sgfpars.Node_data_get
85		if _newclass:data = property(_sgfpars.Node_data_get,_sgfpars.Node_data_set)
	90	if _newclass:data = property(_sgfpars.Node_data_get, _sgfpars.Node_data_set)
86	91	__swig_setmethods__["posyD"] = _sgfpars.Node_posyD_set
87	92	__swig_getmethods__["posyD"] = _sgfpars.Node_posyD_get
88		if _newclass:posyD = property(_sgfpars.Node_posyD_get,_sgfpars.Node_posyD_set)
89		def __init__(self,*args):
90		_swig_setattr(self, Node, 'this', ~~apply(_sgfpars.new_Node,~~args))
	93	if _newclass:posyD = property(_sgfpars.Node_posyD_get, _sgfpars.Node_posyD_set)
	94	def __init__(self, *args):
	95	_swig_setattr(self, Node, 'this', _sgfpars.new_Node(*args))
91	96	_swig_setattr(self, Node, 'thisown', 1)
92		def __del__(self, destroy= _sgfpars.delete_Node):
93		try:
94		if self.thisown: destroy(self)
95		except: pass
96		def pathToNode(*args): return apply(_sgfpars.Node_pathToNode,args)
97		def parseNode(*args): return apply(_sgfpars.Node_parseNode,args)
98		def getData(*args): return apply(_sgfpars.Node_getData,args)
99		def __repr__(self):
100		return "<C Node instance at %s>" % (self.this,)
	97	def __del__(self, destroy=_sgfpars.delete_Node):
	98	try:
	99	if self.thisown: destroy(self)
	100	except: pass
	101	def pathToNode(args): return _sgfpars.Node_pathToNode(args)
	102	def parseNode(args): return _sgfpars.Node_parseNode(args)
	103	def getData(args): return _sgfpars.Node_getData(args)
101	104
102	105	class NodePtr(Node):
103		def __init__(self,this):
	106	def __init__(self, this):
104	107	_swig_setattr(self, Node, 'this', this)
105	108	if not hasattr(self,"thisown"): _swig_setattr(self, Node, 'thisown', 0)
…	…
113	116	__swig_getmethods__ = {}
114	117	__getattr__ = lambda self, name: _swig_getattr(self, Cursor, name)
115		def __init__(self,*args):
116		_swig_setattr(self, Cursor, 'this', apply(_sgfpars.new_Cursor,args))
	118	def __repr__(self):
	119	return "<C Cursor instance at %s>" % (self.this,)
	120	def __init__(self, *args):
	121	_swig_setattr(self, Cursor, 'this', _sgfpars.new_Cursor(*args))
117	122	_swig_setattr(self, Cursor, 'thisown', 1)
118		def __del__(self, destroy= _sgfpars.delete_Cursor):
	123	def __del__(self, destroy=_sgfpars.delete_Cursor):
119	124	try:
120	125	if self.thisown: destroy(self)
…	…
122	127	__swig_setmethods__["atStart"] = _sgfpars.Cursor_atStart_set
123	128	__swig_getmethods__["atStart"] = _sgfpars.Cursor_atStart_get
124		if _newclass:atStart = property(_sgfpars.Cursor_atStart_get,_sgfpars.Cursor_atStart_set)
	129	if _newclass:atStart = property(_sgfpars.Cursor_atStart_get, _sgfpars.Cursor_atStart_set)
125	130	__swig_setmethods__["atEnd"] = _sgfpars.Cursor_atEnd_set
126	131	__swig_getmethods__["atEnd"] = _sgfpars.Cursor_atEnd_get
127		if _newclass:atEnd = property(_sgfpars.Cursor_atEnd_get,_sgfpars.Cursor_atEnd_set)
	132	if _newclass:atEnd = property(_sgfpars.Cursor_atEnd_get, _sgfpars.Cursor_atEnd_set)
128	133	__swig_setmethods__["height"] = _sgfpars.Cursor_height_set
129	134	__swig_getmethods__["height"] = _sgfpars.Cursor_height_get
130		if _newclass:height = property(_sgfpars.Cursor_height_get,_sgfpars.Cursor_height_set)
	135	if _newclass:height = property(_sgfpars.Cursor_height_get, _sgfpars.Cursor_height_set)
131	136	__swig_setmethods__["width"] = _sgfpars.Cursor_width_set
132	137	__swig_getmethods__["width"] = _sgfpars.Cursor_width_get
133		if _newclass:width = property(_sgfpars.Cursor_width_get,_sgfpars.Cursor_width_set)
	138	if _newclass:width = property(_sgfpars.Cursor_width_get, _sgfpars.Cursor_width_set)
134	139	__swig_setmethods__["root"] = _sgfpars.Cursor_root_set
135	140	__swig_getmethods__["root"] = _sgfpars.Cursor_root_get
136		if _newclass:root = property(_sgfpars.Cursor_root_get,_sgfpars.Cursor_root_set)
	141	if _newclass:root = property(_sgfpars.Cursor_root_get, _sgfpars.Cursor_root_set)
137	142	__swig_setmethods__["currentN"] = _sgfpars.Cursor_currentN_set
138	143	__swig_getmethods__["currentN"] = _sgfpars.Cursor_currentN_get
139		if _newclass:currentN = property(_sgfpars.Cursor_currentN_get,_sgfpars.Cursor_currentN_set)
	144	if _newclass:currentN = property(_sgfpars.Cursor_currentN_get, _sgfpars.Cursor_currentN_set)
140	145	__swig_setmethods__["posx"] = _sgfpars.Cursor_posx_set
141	146	__swig_getmethods__["posx"] = _sgfpars.Cursor_posx_get
142		if _newclass:posx = property(_sgfpars.Cursor_posx_get,_sgfpars.Cursor_posx_set)
	147	if _newclass:posx = property(_sgfpars.Cursor_posx_get, _sgfpars.Cursor_posx_set)
143	148	__swig_setmethods__["posy"] = _sgfpars.Cursor_posy_set
144	149	__swig_getmethods__["posy"] = _sgfpars.Cursor_posy_get
145		if _newclass:posy = property(_sgfpars.Cursor_posy_get,_sgfpars.Cursor_posy_set)
	150	if _newclass:posy = property(_sgfpars.Cursor_posy_get, _sgfpars.Cursor_posy_set)
146	151	__swig_setmethods__["encoding"] = _sgfpars.Cursor_encoding_set
147	152	__swig_getmethods__["encoding"] = _sgfpars.Cursor_encoding_get
148		if _newclass:encoding = property(_sgfpars.Cursor_encoding_get,_sgfpars.Cursor_encoding_set)
149		def noChildren(*args): return apply(_sgfpars.Cursor_noChildren,args)
150		def currentNode(*args): return apply(_sgfpars.Cursor_currentNode,args)
151		def parse(*args): return apply(_sgfpars.Cursor_parse,args)
152		def game(*args): return apply(_sgfpars.Cursor_game,args)
153		def next(*args): return apply(_sgfpars.Cursor_next,args)
154		def previous(*args): return apply(_sgfpars.Cursor_previous,args)
155		def getRootNode(*args): return apply(_sgfpars.Cursor_getRootNode,args)
156		def updateCurrentNode(*args): return apply(_sgfpars.Cursor_updateCurrentNode,args)
157		def updateRootNode(*args): return apply(_sgfpars.Cursor_updateRootNode,args)
158		def rootNodeToString(*args): return apply(_sgfpars.Cursor_rootNodeToString,args)
159		def nodeToString(*args): return apply(_sgfpars.Cursor_nodeToString,args)
160		def outputVar(*args): return apply(_sgfpars.Cursor_outputVar,args)
161		def output(*args): return apply(_sgfpars.Cursor_output,args)
162		def add(*args): return apply(_sgfpars.Cursor_add,args)
163		def delVariation(*args): return apply(_sgfpars.Cursor_delVariation,args)
164		def setFlags(*args): return apply(_sgfpars.Cursor_setFlags,args)
165		def __repr__(self):
166		return "<C Cursor instance at %s>" % (self.this,)
	153	if _newclass:encoding = property(_sgfpars.Cursor_encoding_get, _sgfpars.Cursor_encoding_set)
	154	def noChildren(args): return _sgfpars.Cursor_noChildren(args)
	155	def currentNode(args): return _sgfpars.Cursor_currentNode(args)
	156	def parse(args): return _sgfpars.Cursor_parse(args)
	157	def game(args): return _sgfpars.Cursor_game(args)
	158	def next(args): return _sgfpars.Cursor_next(args)
	159	def previous(args): return _sgfpars.Cursor_previous(args)
	160	def getRootNode(args): return _sgfpars.Cursor_getRootNode(args)
	161	def updateCurrentNode(args): return _sgfpars.Cursor_updateCurrentNode(args)
	162	def updateRootNode(args): return _sgfpars.Cursor_updateRootNode(args)
	163	def rootNodeToString(args): return _sgfpars.Cursor_rootNodeToString(args)
	164	def nodeToString(args): return _sgfpars.Cursor_nodeToString(args)
	165	def outputVar(args): return _sgfpars.Cursor_outputVar(args)
	166	def output(args): return _sgfpars.Cursor_output(args)
	167	def add(args): return _sgfpars.Cursor_add(args)
	168	def delVariation(args): return _sgfpars.Cursor_delVariation(args)
	169	def setFlags(args): return _sgfpars.Cursor_setFlags(args)
167	170
168	171	class CursorPtr(Cursor):
169		def __init__(self,this):
	172	def __init__(self, this):
170	173	_swig_setattr(self, Cursor, 'this', this)
171	174	if not hasattr(self,"thisown"): _swig_setattr(self, Cursor, 'thisown', 0)
…	…
178	181	__swig_getmethods__ = {}
179	182	__getattr__ = lambda self, name: _swig_getattr(self, intN, name)
	183	def __repr__(self):
	184	return "<C intN instance at %s>" % (self.this,)
180	185	__swig_setmethods__["data"] = _sgfpars.intN_data_set
181	186	__swig_getmethods__["data"] = _sgfpars.intN_data_get
182		if _newclass:data = property(_sgfpars.intN_data_get,_sgfpars.intN_data_set)
	187	if _newclass:data = property(_sgfpars.intN_data_get, _sgfpars.intN_data_set)
183	188	__swig_setmethods__["prev"] = _sgfpars.intN_prev_set
184	189	__swig_getmethods__["prev"] = _sgfpars.intN_prev_get
185		if _newclass:prev = property(_sgfpars.intN_prev_get,_sgfpars.intN_prev_set)
186		def __init__(self,*args):
187		_swig_setattr(self, intN, 'this', ~~apply(_sgfpars.new_intN,~~args))
	190	if _newclass:prev = property(_sgfpars.intN_prev_get, _sgfpars.intN_prev_set)
	191	def __init__(self, *args):
	192	_swig_setattr(self, intN, 'this', _sgfpars.new_intN(*args))
188	193	_swig_setattr(self, intN, 'thisown', 1)
189		def __del__(self, destroy= _sgfpars.delete_intN):
190		try:
191		if self.thisown: destroy(self)
192		except: pass
193		def __repr__(self):
194		return "<C intN instance at %s>" % (self.this,)
	194	def __del__(self, destroy=_sgfpars.delete_intN):
	195	try:
	196	if self.thisown: destroy(self)
	197	except: pass
195	198
196	199	class intNPtr(intN):
197		def __init__(self,this):
	200	def __init__(self, this):
198	201	_swig_setattr(self, intN, 'this', this)
199	202	if not hasattr(self,"thisown"): _swig_setattr(self, intN, 'thisown', 0)
…	…
206	209	__swig_getmethods__ = {}
207	210	__getattr__ = lambda self, name: _swig_getattr(self, IntStack, name)
	211	def __repr__(self):
	212	return "<C IntStack instance at %s>" % (self.this,)
208	213	__swig_setmethods__["root"] = _sgfpars.IntStack_root_set
209	214	__swig_getmethods__["root"] = _sgfpars.IntStack_root_get
210		if _newclass:root = property(_sgfpars.IntStack_root_get,_sgfpars.IntStack_root_set)
211		def __init__(self,*args):
212		_swig_setattr(self, IntStack, 'this', ~~apply(_sgfpars.new_IntStack,~~args))
	215	if _newclass:root = property(_sgfpars.IntStack_root_get, _sgfpars.IntStack_root_set)
	216	def __init__(self, *args):
	217	_swig_setattr(self, IntStack, 'this', _sgfpars.new_IntStack(*args))
213	218	_swig_setattr(self, IntStack, 'thisown', 1)
214		def push(*args): return apply(_sgfpars.IntStack_push,args)
215		def pop(*args): return apply(_sgfpars.IntStack_pop,args)
216		def top(*args): return apply(_sgfpars.IntStack_top,args)
217		def nonempty(*args): return apply(_sgfpars.IntStack_nonempty,args)
218		def __del__(self, destroy= _sgfpars.delete_IntStack):
219		try:
220		if self.thisown: destroy(self)
221		except: pass
222		def __repr__(self):
223		return "<C IntStack instance at %s>" % (self.this,)
	219	def push(args): return _sgfpars.IntStack_push(args)
	220	def pop(args): return _sgfpars.IntStack_pop(args)
	221	def top(args): return _sgfpars.IntStack_top(args)
	222	def nonempty(args): return _sgfpars.IntStack_nonempty(args)
	223	def __del__(self, destroy=_sgfpars.delete_IntStack):
	224	try:
	225	if self.thisown: destroy(self)
	226	except: pass
224	227
225	228	class IntStackPtr(IntStack):
226		def __init__(self,this):
	229	def __init__(self, this):
227	230	_swig_setattr(self, IntStack, 'this', this)
228	231	if not hasattr(self,"thisown"): _swig_setattr(self, IntStack, 'thisown', 0)
…	…
235	238	__swig_getmethods__ = {}
236	239	__getattr__ = lambda self, name: _swig_getattr(self, nodeN, name)
	240	def __repr__(self):
	241	return "<C nodeN instance at %s>" % (self.this,)
237	242	__swig_setmethods__["data"] = _sgfpars.nodeN_data_set
238	243	__swig_getmethods__["data"] = _sgfpars.nodeN_data_get
239		if _newclass:data = property(_sgfpars.nodeN_data_get,_sgfpars.nodeN_data_set)
	244	if _newclass:data = property(_sgfpars.nodeN_data_get, _sgfpars.nodeN_data_set)
240	245	__swig_setmethods__["prev"] = _sgfpars.nodeN_prev_set
241	246	__swig_getmethods__["prev"] = _sgfpars.nodeN_prev_get
242		if _newclass:prev = property(_sgfpars.nodeN_prev_get,_sgfpars.nodeN_prev_set)
243		def __init__(self,*args):
244		_swig_setattr(self, nodeN, 'this', ~~apply(_sgfpars.new_nodeN,~~args))
	247	if _newclass:prev = property(_sgfpars.nodeN_prev_get, _sgfpars.nodeN_prev_set)
	248	def __init__(self, *args):
	249	_swig_setattr(self, nodeN, 'this', _sgfpars.new_nodeN(*args))
245	250	_swig_setattr(self, nodeN, 'thisown', 1)
246		def __del__(self, destroy= _sgfpars.delete_nodeN):
247		try:
248		if self.thisown: destroy(self)
249		except: pass
250		def __repr__(self):
251		return "<C nodeN instance at %s>" % (self.this,)
	251	def __del__(self, destroy=_sgfpars.delete_nodeN):
	252	try:
	253	if self.thisown: destroy(self)
	254	except: pass
252	255
253	256	class nodeNPtr(nodeN):
254		def __init__(self,this):
	257	def __init__(self, this):
255	258	_swig_setattr(self, nodeN, 'this', this)
256	259	if not hasattr(self,"thisown"): _swig_setattr(self, nodeN, 'thisown', 0)
…	…
263	266	__swig_getmethods__ = {}
264	267	__getattr__ = lambda self, name: _swig_getattr(self, NodeStack, name)
	268	def __repr__(self):
	269	return "<C NodeStack instance at %s>" % (self.this,)
265	270	__swig_setmethods__["root"] = _sgfpars.NodeStack_root_set
266	271	__swig_getmethods__["root"] = _sgfpars.NodeStack_root_get
267		if _newclass:root = property(_sgfpars.NodeStack_root_get,_sgfpars.NodeStack_root_set)
268		def __init__(self,*args):
269		_swig_setattr(self, NodeStack, 'this', ~~apply(_sgfpars.new_NodeStack,~~args))
	272	if _newclass:root = property(_sgfpars.NodeStack_root_get, _sgfpars.NodeStack_root_set)
	273	def __init__(self, *args):
	274	_swig_setattr(self, NodeStack, 'this', _sgfpars.new_NodeStack(*args))
270	275	_swig_setattr(self, NodeStack, 'thisown', 1)
271		def push(*args): return apply(_sgfpars.NodeStack_push,args)
272		def pop(*args): return apply(_sgfpars.NodeStack_pop,args)
273		def top(*args): return apply(_sgfpars.NodeStack_top,args)
274		def nonempty(*args): return apply(_sgfpars.NodeStack_nonempty,args)
275		def __del__(self, destroy= _sgfpars.delete_NodeStack):
276		try:
277		if self.thisown: destroy(self)
278		except: pass
279		def __repr__(self):
280		return "<C NodeStack instance at %s>" % (self.this,)
	276	def push(args): return _sgfpars.NodeStack_push(args)
	277	def pop(args): return _sgfpars.NodeStack_pop(args)
	278	def top(args): return _sgfpars.NodeStack_top(args)
	279	def nonempty(args): return _sgfpars.NodeStack_nonempty(args)
	280	def __del__(self, destroy=_sgfpars.delete_NodeStack):
	281	try:
	282	if self.thisown: destroy(self)
	283	except: pass
281	284
282	285	class NodeStackPtr(NodeStack):
283		def __init__(self,this):
	286	def __init__(self, this):
284	287	_swig_setattr(self, NodeStack, 'this', this)
285	288	if not hasattr(self,"thisown"): _swig_setattr(self, NodeStack, 'thisown', 0)

05/devel/sgfpars_wrap.cxx

r62	r99
1	1	/* ----------------------------------------------------------------------------
2	2	* This file was automatically generated by SWIG (http://www.swig.org).
3		* Version 1.3.19
	3	* Version 1.3.21
4	4	*
5	5	* This file is not intended to be easily readable and contains a number of
…	…
15	15	T *tt;
16	16	public:
17		inline SwigValueWrapper() : tt(0) { }
18		inline ~SwigValueWrapper() { if (tt) delete tt; }
19		inline SwigValueWrapper& operator=(const T& t) { tt = new T(t); return *this; }
20		inline operator T&() const { return *tt; }
21		inline T *operator&() { return tt; }
	17	SwigValueWrapper() : tt(0) { }
	18	SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
	19	SwigValueWrapper(const T& t) : tt(new T(t)) { }
	20	~SwigValueWrapper() { delete tt; }
	21	SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
	22	operator T&() const { return *tt; }
	23	T *operator&() { return tt; }
	24	private:
	25	SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
22	26	};
23	27	#endif
…	…
25	29
26	30	#include "Python.h"
	31
	32	/*************************************************************** -- c --
	33	* python/precommon.swg
	34	*
	35	* Rename all exported symbols from common.swg, to avoid symbol
	36	* clashes if multiple interpreters are included
	37	*
	38	************************************************************************/
	39
	40	#define SWIG_TypeRegister SWIG_Python_TypeRegister
	41	#define SWIG_TypeCheck SWIG_Python_TypeCheck
	42	#define SWIG_TypeCast SWIG_Python_TypeCast
	43	#define SWIG_TypeDynamicCast SWIG_Python_TypeDynamicCast
	44	#define SWIG_TypeName SWIG_Python_TypeName
	45	#define SWIG_TypeQuery SWIG_Python_TypeQuery
	46	#define SWIG_TypeClientData SWIG_Python_TypeClientData
	47	#define SWIG_PackData SWIG_Python_PackData
	48	#define SWIG_UnpackData SWIG_Python_UnpackData
	49
27	50
28	51	/***********************************************************************
…	…
43	66	#include <string.h>
44	67
45		#if defined(_WIN32) \|\| defined(__WIN32__)
46		# ~~if defined(_MSC_VER~~)
47		# if defined(STATIC_LINKED)
48		# define SWIGEXPORT(a) a
49		# define SWIGIMPORT(a) extern a
50		# else
51		# define SWIGEXPORT(a) __declspec(dllexport) a
52		# define SWIGIMPORT(a) extern a
53		# endif
54		# else
55		# if defined(__BORLANDC__)
56		# define SWIGEXPORT(a) a _export
57		# define SWIGIMPORT(a) a _export
58		# else
59		# define SWIGEXPORT(a) a
60		# define SWIGIMPORT(a) a
61		# endif
62		# endif
	68	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
	69	# if defined(_MSC_VER) \|\| defined(__GNUC__)
	70	# if defined(STATIC_LINKED)
	71	# define SWIGEXPORT(a) a
	72	# define SWIGIMPORT(a) extern a
	73	# else
	74	# define SWIGEXPORT(a) __declspec(dllexport) a
	75	# define SWIGIMPORT(a) extern a
	76	# endif
	77	# else
	78	# if defined(__BORLANDC__)
	79	# define SWIGEXPORT(a) a _export
	80	# define SWIGIMPORT(a) a _export
	81	# else
	82	# define SWIGEXPORT(a) a
	83	# define SWIGIMPORT(a) a
	84	# endif
	85	# endif
63	86	#else
64		# define SWIGEXPORT(a) a
65		# define SWIGIMPORT(a) a
	87	# define SWIGEXPORT(a) a
	88	# define SWIGIMPORT(a) a
66	89	#endif
67	90
68	91	#ifdef SWIG_GLOBAL
69		#define SWIGRUNTIME(a) SWIGEXPORT(a)
	92	# define SWIGRUNTIME(a) SWIGEXPORT(a)
70	93	#else
71		#define SWIGRUNTIME(a) static a
	94	# define SWIGRUNTIME(a) static a
72	95	#endif
73	96
…	…
80	103
81	104	typedef struct swig_type_info {
82		const char *name;
	105	const char *name;
83	106	swig_converter_func converter;
84	107	const char *str;
85		void *clientdata;
	108	void *clientdata;
86	109	swig_dycast_func dcast;
87	110	struct swig_type_info *next;
…	…
98	121	SWIGIMPORT(swig_type_info ) SWIG_TypeQuery(const char );
99	122	SWIGIMPORT(void) SWIG_TypeClientData(swig_type_info , void );
	123	SWIGIMPORT(char ) SWIG_PackData(char , void *, int);
	124	SWIGIMPORT(char ) SWIG_UnpackData(char , void *, int);
100	125
101	126	#else
…	…
105	130	/* Register a type mapping with the type-checking */
106	131	SWIGRUNTIME(swig_type_info *)
107		SWIG_TypeRegister(swig_type_info *ti)
108		{
	132	SWIG_TypeRegister(swig_type_info *ti) {
109	133	swig_type_info tc, head, ret, next;
110	134	/* Check to see if this type has already been registered */
…	…
113	137	if (strcmp(tc->name, ti->name) == 0) {
114	138	/* Already exists in the table. Just add additional types to the list */
115		if (tc->clientdata) ti->clientdata = tc->clientdata;
	139	if (tc->clientdata) ti->clientdata = tc->clientdata;
116	140	head = tc;
117	141	next = tc->next;
…	…
128	152
129	153	/* Build linked lists */
130		l1:
	154	l1:
131	155	ret = head;
132	156	tc = ti + 1;
…	…
138	162	tc++;
139	163	}
140		if (next) next->prev = head; ~~/**/~~
	164	if (next) next->prev = head;
141	165	head->next = next;
142	166	return ret;
…	…
145	169	/* Check the typename */
146	170	SWIGRUNTIME(swig_type_info *)
147		SWIG_TypeCheck(char c, swig_type_info ty)
148		{
	171	SWIG_TypeCheck(char c, swig_type_info ty) {
149	172	swig_type_info *s;
150	173	if (!ty) return 0; /* Void pointer */
…	…
156	179	s->prev->next = s->next;
157	180	if (s->next) {
158		s->next->prev = s->prev;
	181	s->next->prev = s->prev;
159	182	}
160	183	/* Insert s as second element in the list */
…	…
162	185	if (ty->next) ty->next->prev = s;
163	186	ty->next = s;
164		s->prev = ty; ~~/**/~~
	187	s->prev = ty;
165	188	return s;
166	189	}
…	…
172	195	/* Cast a pointer up an inheritance hierarchy */
173	196	SWIGRUNTIME(void *)
174		SWIG_TypeCast(swig_type_info ty, void ptr)
175		{
	197	SWIG_TypeCast(swig_type_info ty, void ptr) {
176	198	if ((!ty) \|\| (!ty->converter)) return ptr;
177	199	return (*ty->converter)(ptr);
…	…
180	202	/* Dynamic pointer casting. Down an inheritance hierarchy */
181	203	SWIGRUNTIME(swig_type_info *)
182		SWIG_TypeDynamicCast(swig_type_info ty, void *ptr)
183		{
	204	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
184	205	swig_type_info *lastty = ty;
185	206	if (!ty \|\| !ty->dcast) return ty;
186	207	while (ty && (ty->dcast)) {
187		ty = (*ty->dcast)(ptr);
188		if (ty) lastty = ty;
	208	ty = (*ty->dcast)(ptr);
	209	if (ty) lastty = ty;
189	210	}
190	211	return lastty;
…	…
220	241	tc = swig_type_list;
221	242	while (tc) {
222		if ((strcmp(tc->name, equiv->name) == 0))
223		SWIG_TypeClientData(tc,clientdata);
224		tc = tc->prev;
	243	if ((strcmp(tc->name, equiv->name) == 0))
	244	SWIG_TypeClientData(tc,clientdata);
	245	tc = tc->prev;
225	246	}
226	247	}
227	248	equiv = equiv->next;
228	249	}
229		}
230		~~#endif~~
231
232		~~#ifdef __cplusplus~~
233		}
234
235		~~#endif~~
236
237		/***********************************************************************
238		* python.swg
239		*
240		* This file contains the runtime support for Python modules
241		* and includes code for managing global variables and pointer
242		* type checking.
243		*
244		* Author : David Beazley (beazley@cs.uchicago.edu)
245		************************************************************************/
246
247		~~#include "Python.h"~~
248
249		~~#ifdef __cplusplus~~
250		~~extern "C" {~~
251		~~#endif~~
252
253		~~#define SWIG_PY_INT 1~~
254		~~#define SWIG_PY_FLOAT 2~~
255		~~#define SWIG_PY_STRING 3~~
256		~~#define SWIG_PY_POINTER 4~~
257		~~#define SWIG_PY_BINARY 5~~
258
259		~~/* Flags for pointer conversion */~~
260
261		~~#define SWIG_POINTER_EXCEPTION 0x1~~
262		~~#define SWIG_POINTER_DISOWN 0x2~~
263
264		~~/* Exception handling in wrappers */~~
265		~~#define SWIG_fail goto fail~~
266
267		~~/* Constant information structure */~~
268		~~typedef struct swig_const_info {~~
269		~~int type;~~
270		~~char *name;~~
271		~~long lvalue;~~
272		~~double dvalue;~~
273		~~void *pvalue;~~
274		~~swig_type_info **ptype;~~
275		~~} swig_const_info;~~
276
277		~~#ifdef SWIG_NOINCLUDE~~
278
279		~~SWIGEXPORT(PyObject *) SWIG_newvarlink(void);~~
280		~~SWIGEXPORT(void) SWIG_addvarlink(PyObject , char , PyObject ()(void), int ()(PyObject ));~~
281		~~SWIGEXPORT(int) SWIG_ConvertPtr(PyObject , void , swig_type_info , int);~~
282		~~SWIGEXPORT(int) SWIG_ConvertPacked(PyObject , void , int sz, swig_type_info *, int);~~
283		~~SWIGEXPORT(char ) SWIG_PackData(char c, void *, int);~~
284		~~SWIGEXPORT(char ) SWIG_UnpackData(char c, void *, int);~~
285		~~SWIGEXPORT(PyObject ) SWIG_NewPointerObj(void , swig_type_info *,int own);~~
286		~~SWIGEXPORT(PyObject ) SWIG_NewPackedObj(void , int sz, swig_type_info *);~~
287		~~SWIGEXPORT(void) SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);~~
288		~~#else~~
289
290		~~/* -----------------------------------------------------------------------------~~
291		* global variable support code.
292		* ----------------------------------------------------------------------------- */
293
294		~~typedef struct swig_globalvar {~~
295		~~char name; / Name of global variable */~~
296		~~PyObject (get_attr)(void); /* Return the current value */~~
297		~~int (set_attr)(PyObject ); /* Set the value */~~
298		~~struct swig_globalvar *next;~~
299		~~} swig_globalvar;~~
300
301		~~typedef struct swig_varlinkobject {~~
302		~~PyObject_HEAD~~
303		~~swig_globalvar *vars;~~
304		~~} swig_varlinkobject;~~
305
306		static PyObject *
307		~~swig_varlink_repr(swig_varlinkobject *v) {~~
308		~~v = v;~~
309		~~return PyString_FromString("<Global variables>");~~
310		}
311
312		~~static int~~
313		~~swig_varlink_print(swig_varlinkobject v, FILE fp, int flags) {~~
314		~~swig_globalvar *var;~~
315		~~flags = flags;~~
316		~~fprintf(fp,"Global variables { ");~~
317		~~for (var = v->vars; var; var=var->next) {~~
318		~~fprintf(fp,"%s", var->name);~~
319		~~if (var->next) fprintf(fp,", ");~~
320		}
321		~~fprintf(fp," }\n");~~
322		~~return 0;~~
323		}
324
325		static PyObject *
326		~~swig_varlink_getattr(swig_varlinkobject v, char n) {~~
327		~~swig_globalvar *var = v->vars;~~
328		~~while (var) {~~
329		~~if (strcmp(var->name,n) == 0) {~~
330		~~return (*var->get_attr)();~~
331		}
332		~~var = var->next;~~
333		}
334		~~PyErr_SetString(PyExc_NameError,"Unknown C global variable");~~
335		~~return NULL;~~
336		}
337
338		~~static int~~
339		~~swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {~~
340		~~swig_globalvar *var = v->vars;~~
341		~~while (var) {~~
342		~~if (strcmp(var->name,n) == 0) {~~
343		~~return (*var->set_attr)(p);~~
344		}
345		~~var = var->next;~~
346		}
347		~~PyErr_SetString(PyExc_NameError,"Unknown C global variable");~~
348		~~return 1;~~
349		}
350
351		~~statichere PyTypeObject varlinktype = {~~
352		~~PyObject_HEAD_INIT(0)~~
353		0,
354		~~(char )"swigvarlink", / Type name */~~
355		~~sizeof(swig_varlinkobject), /* Basic size */~~
356		~~0, /* Itemsize */~~
357		~~0, /* Deallocator */~~
358		~~(printfunc) swig_varlink_print, /* Print */~~
359		~~(getattrfunc) swig_varlink_getattr, /* get attr */~~
360		~~(setattrfunc) swig_varlink_setattr, /* Set attr */~~
361		~~0, /* tp_compare */~~
362		~~(reprfunc) swig_varlink_repr, /* tp_repr */~~
363		~~0, /* tp_as_number */~~
364		~~0, /* tp_as_mapping*/~~
365		~~0, /* tp_hash */~~
366		};
367
368		~~/* Create a variable linking object for use later */~~
369		~~SWIGRUNTIME(PyObject *)~~
370		~~SWIG_newvarlink(void) {~~
371		~~swig_varlinkobject *result = 0;~~
372		~~result = PyMem_NEW(swig_varlinkobject,1);~~
373		~~varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */~~
374		~~result->ob_type = &varlinktype;~~
375		~~result->vars = 0;~~
376		~~result->ob_refcnt = 0;~~
377		~~Py_XINCREF((PyObject *) result);~~
378		~~return ((PyObject*) result);~~
379		}
380
381		~~SWIGRUNTIME(void)~~
382		~~SWIG_addvarlink(PyObject p, char name,~~
383		~~PyObject (get_attr)(void), int (set_attr)(PyObject p)) {~~
384		~~swig_varlinkobject *v;~~
385		~~swig_globalvar *gv;~~
386		~~v= (swig_varlinkobject *) p;~~
387		~~gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));~~
388		~~gv->name = (char *) malloc(strlen(name)+1);~~
389		~~strcpy(gv->name,name);~~
390		~~gv->get_attr = get_attr;~~
391		~~gv->set_attr = set_attr;~~
392		~~gv->next = v->vars;~~
393		~~v->vars = gv;~~
394	250	}
395	251
…	…
432	288	}
433	289
	290	#endif
	291
	292	#ifdef __cplusplus
	293	}
	294	#endif
	295
	296	/***********************************************************************
	297	* python.swg
	298	*
	299	* This file contains the runtime support for Python modules
	300	* and includes code for managing global variables and pointer
	301	* type checking.
	302	*
	303	* Author : David Beazley (beazley@cs.uchicago.edu)
	304	************************************************************************/
	305
	306	#include "Python.h"
	307
	308	#ifdef __cplusplus
	309	extern "C" {
	310	#endif
	311
	312	#define SWIG_PY_INT 1
	313	#define SWIG_PY_FLOAT 2
	314	#define SWIG_PY_STRING 3
	315	#define SWIG_PY_POINTER 4
	316	#define SWIG_PY_BINARY 5
	317
	318	/* Flags for pointer conversion */
	319
	320	#define SWIG_POINTER_EXCEPTION 0x1
	321	#define SWIG_POINTER_DISOWN 0x2
	322
	323	/* Exception handling in wrappers */
	324	#define SWIG_fail goto fail
	325
	326	/* Constant information structure */
	327	typedef struct swig_const_info {
	328	int type;
	329	char *name;
	330	long lvalue;
	331	double dvalue;
	332	void *pvalue;
	333	swig_type_info **ptype;
	334	} swig_const_info;
	335
	336	/* Common SWIG API */
	337	#define SWIG_ConvertPtr(obj, pp, type, flags) \
	338	SWIG_Python_ConvertPtr(obj, pp, type, flags)
	339	#define SWIG_NewPointerObj(p, type, flags) \
	340	SWIG_Python_NewPointerObj(p, type, flags)
	341	#define SWIG_MustGetPtr(p, type, argnum, flags) \
	342	SWIG_Python_MustGetPtr(p, type, argnum, flags)
	343
	344	/* Python-specific SWIG API */
	345	#define SWIG_newvarlink() \
	346	SWIG_Python_newvarlink()
	347	#define SWIG_addvarlink(p, name, get_attr, set_attr) \
	348	SWIG_Python_addvarlink(p, name, get_attr, set_attr)
	349	#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
	350	SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
	351	#define SWIG_NewPackedObj(ptr, sz, type) \
	352	SWIG_Python_NewPackedObj(ptr, sz, type)
	353	#define SWIG_InstallConstants(d, constants) \
	354	SWIG_Python_InstallConstants(d, constants)
	355
	356	#ifdef SWIG_NOINCLUDE
	357
	358	SWIGIMPORT(int) SWIG_Python_ConvertPtr(PyObject , void , swig_type_info , int);
	359	SWIGIMPORT(PyObject ) SWIG_Python_NewPointerObj(void , swig_type_info *,int own);
	360	SWIGIMPORT(void ) SWIG_Python_MustGetPtr(PyObject , swig_type_info *, int, int);
	361	SWIGIMPORT(PyObject *) SWIG_Python_newvarlink(void);
	362	SWIGIMPORT(void) SWIG_Python_addvarlink(PyObject , char , PyObject ()(void), int ()(PyObject ));
	363	SWIGIMPORT(int) SWIG_Python_ConvertPacked(PyObject , void , int sz, swig_type_info *, int);
	364	SWIGIMPORT(PyObject ) SWIG_Python_NewPackedObj(void , int sz, swig_type_info *);
	365	SWIGIMPORT(void) SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]);
	366
	367	#else
	368
	369	/* -----------------------------------------------------------------------------
	370	* global variable support code.
	371	* ----------------------------------------------------------------------------- */
	372
	373	typedef struct swig_globalvar {
	374	char name; / Name of global variable */
	375	PyObject (get_attr)(void); /* Return the current value */
	376	int (set_attr)(PyObject ); /* Set the value */
	377	struct swig_globalvar *next;
	378	} swig_globalvar;
	379
	380	typedef struct swig_varlinkobject {
	381	PyObject_HEAD
	382	swig_globalvar *vars;
	383	} swig_varlinkobject;
	384
	385	static PyObject *
	386	swig_varlink_repr(swig_varlinkobject *v) {
	387	v = v;
	388	return PyString_FromString("<Global variables>");
	389	}
	390
	391	static int
	392	swig_varlink_print(swig_varlinkobject v, FILE fp, int flags) {
	393	swig_globalvar *var;
	394	flags = flags;
	395	fprintf(fp,"Global variables { ");
	396	for (var = v->vars; var; var=var->next) {
	397	fprintf(fp,"%s", var->name);
	398	if (var->next) fprintf(fp,", ");
	399	}
	400	fprintf(fp," }\n");
	401	return 0;
	402	}
	403
	404	static PyObject *
	405	swig_varlink_getattr(swig_varlinkobject v, char n) {
	406	swig_globalvar *var = v->vars;
	407	while (var) {
	408	if (strcmp(var->name,n) == 0) {
	409	return (*var->get_attr)();
	410	}
	411	var = var->next;
	412	}
	413	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
	414	return NULL;
	415	}
	416
	417	static int
	418	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
	419	swig_globalvar *var = v->vars;
	420	while (var) {
	421	if (strcmp(var->name,n) == 0) {
	422	return (*var->set_attr)(p);
	423	}
	424	var = var->next;
	425	}
	426	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
	427	return 1;
	428	}
	429
	430	statichere PyTypeObject varlinktype = {
	431	PyObject_HEAD_INIT(0)
	432	0,
	433	(char )"swigvarlink", / Type name */
	434	sizeof(swig_varlinkobject), /* Basic size */
	435	0, /* Itemsize */
	436	0, /* Deallocator */
	437	(printfunc) swig_varlink_print, /* Print */
	438	(getattrfunc) swig_varlink_getattr, /* get attr */
	439	(setattrfunc) swig_varlink_setattr, /* Set attr */
	440	0, /* tp_compare */
	441	(reprfunc) swig_varlink_repr, /* tp_repr */
	442	0, /* tp_as_number */
	443	0, /* tp_as_mapping*/
	444	0, /* tp_hash */
	445	};
	446
	447	/* Create a variable linking object for use later */
	448	SWIGRUNTIME(PyObject *)
	449	SWIG_Python_newvarlink(void) {
	450	swig_varlinkobject *result = 0;
	451	result = PyMem_NEW(swig_varlinkobject,1);
	452	varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
	453	result->ob_type = &varlinktype;
	454	result->vars = 0;
	455	result->ob_refcnt = 0;
	456	Py_XINCREF((PyObject *) result);
	457	return ((PyObject*) result);
	458	}
	459
	460	SWIGRUNTIME(void)
	461	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
	462	swig_varlinkobject *v;
	463	swig_globalvar *gv;
	464	v= (swig_varlinkobject *) p;
	465	gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
	466	gv->name = (char *) malloc(strlen(name)+1);
	467	strcpy(gv->name,name);
	468	gv->get_attr = get_attr;
	469	gv->set_attr = set_attr;
	470	gv->next = v->vars;
	471	v->vars = gv;
	472	}
	473
434	474	/* Convert a pointer value */
435	475	SWIGRUNTIME(int)
436		SWIG_ConvertPtr(PyObject obj, void ptr, swig_type_info ty, int flags) {
	476	SWIG_Python_ConvertPtr(PyObject obj, void ptr, swig_type_info ty, int flags) {
437	477	swig_type_info *tc;
438		char *c;
	478	char *c = 0;
439	479	static PyObject *SWIG_this = 0;
440	480	int newref = 0;
…	…
504	544
505	545	if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
506		PyObject *zero = PyInt_FromLong(0);
507		PyObject_SetAttrString(pyobj,(char*)"thisown",zero);
508		Py_DECREF(zero);
	546	PyObject *zero = PyInt_FromLong(0);
	547	PyObject_SetAttrString(pyobj,(char*)"thisown",zero);
	548	Py_DECREF(zero);
509	549	}
510	550	return 0;
…	…
512	552	type_error:
513	553	if (flags & SWIG_POINTER_EXCEPTION) {
514		if (ty) {
515		char temp = (char ) malloc(64+strlen(ty->name));
516		sprintf(temp,"Type error. ~~Expected %s"~~, ty->name);
	554	if (ty && c) {
	555	char temp = (char ) malloc(64+strlen(ty->name)+strlen(c));
	556	sprintf(temp,"Type error. Got %s, expected %s", c, ty->name);
517	557	PyErr_SetString(PyExc_TypeError, temp);
518	558	free((char *) temp);
…	…
524	564	}
525	565
	566	/* Convert a pointer value, signal an exception on a type mismatch */
	567	SWIGRUNTIME(void *)
	568	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
	569	void *result;
	570	SWIG_Python_ConvertPtr(obj, &result, ty, flags \| SWIG_POINTER_EXCEPTION);
	571	return result;
	572	}
	573
526	574	/* Convert a packed value value */
527	575	SWIGRUNTIME(int)
528		SWIG_ConvertPacked(PyObject obj, void ptr, int sz, swig_type_info *ty, int flags) {
	576	SWIG_Python_ConvertPacked(PyObject obj, void ptr, int sz, swig_type_info *ty, int flags) {
529	577	swig_type_info *tc;