Context Navigation

source: trunk/python2/class_parser.py@ 242

Last change on this file since 242 was 198, checked in by tim, 15 years ago
misc tweaks to run under python2.5-dbg
File size: 98.9 KB

Rev	Line
[196]	1	import sys, os, re, pdb, StringIO
	2
	3	DEBUG = 0
	4
	5	def log(msg):
	6	if DEBUG>0:
	7	sys.stderr.write(msg+"\n")
	8
	9	def escape_for_string(string):
	10	result = string
	11	result = result.encode("string-escape")
	12	result = result.replace('"',r'\"')
	13
	14	return result
	15
	16	class Module:
	17	def __init__(self, name):
	18	self.name = name
	19	self.constants = set()
	20	self.classes = {}
	21	self.headers = '#include <Python.h>\n'
[198]	22
[196]	23	self.files = []
	24
	25	def __str__(self):
	26	result = "Module %s\n" % (self.name)
	27	l = self.classes.values()
	28	l.sort()
	29	for attr in l:
	30	if attr.is_active():
	31	result += " %s\n" % attr
	32
	33	l = list(self.constants)
	34	l.sort()
	35	result += 'Constants:\n'
	36	for attr, type in l:
	37	result += " %s\n" % attr
	38
	39	return result
	40
	41	init_string = ''
	42	def initialization(self):
	43	result = self.init_string + """
[198]	44	talloc_set_log_fn((void()(const char))printf);
[196]	45	//talloc_enable_leak_report();
	46	"""
	47	for cls in self.classes.values():
	48	if cls.is_active():
	49	result += cls.initialise()
	50
	51	return result
	52
	53	def add_constant(self, constant, type="numeric"):
	54	""" This will be called to add #define constant macros """
	55	self.constants.add((constant, type))
	56
	57	def add_class(self, cls, handler):
	58	self.classes[cls.class_name] = cls
	59
	60	## Make a wrapper in the type dispatcher so we can handle
	61	## passing this class from/to python
	62	type_dispatcher[cls.class_name] = handler
	63
	64	def private_functions(self):
	65	""" Emits hard coded private functions for doing various things """
	66	return """
	67	/* The following is a static array mapping CLASS() pointers to their
	68	python wrappers. This is used to allow the correct wrapper to be
	69	chosen depending on the object type found - regardless of the
	70	prototype.
	71
	72	This is basically a safer way for us to cast the correct python type
	73	depending on context rather than assuming a type based on the .h
	74	definition. For example consider the function
	75
	76	AFFObject Resolver.open(uri, mode)
	77
	78	The .h file implies that an AFFObject object is returned, but this is
	79	not true as most of the time an object of a derived class will be
	80	returned. In C we cast the returned value to the correct type. In the
	81	python wrapper we just instantiate the correct python object wrapper
	82	at runtime depending on the actual returned type. We use this lookup
	83	table to do so.
	84	*/
	85	static int TOTAL_CLASSES=0;
	86
	87	/* This is a global reference to this module so classes can call each
	88	other.
	89	*/
	90	static PyObject *g_module = NULL;
	91
	92	static struct python_wrapper_map_t {
	93	Object class_ref;
	94	PyTypeObject *python_type;
	95	} python_wrappers[%s];
	96
	97	/** This is a generic wrapper type */
	98	typedef struct {
	99	PyObject_HEAD
	100	void *base;
	101	void *ctx;
	102	} Gen_wrapper;
	103
	104	/* Create the relevant wrapper from the item based on the lookup
	105	table.
	106	*/
	107	Gen_wrapper *new_class_wrapper(Object item) {
	108	int i;
	109	Gen_wrapper *result;
	110	Object cls;
	111
	112	/* Hack to get the current null_context */
	113	void* null_context;
	114	int* tmp = talloc(NULL, int);
	115	null_context = talloc_parent(tmp);
	116	talloc_free(tmp);
	117
	118	// Return None for a NULL pointer
	119	if(!item) {
	120	Py_INCREF(Py_None);
	121	return (Gen_wrapper *)Py_None;
[198]	122	}
[196]	123
	124	// Search for subclasses
	125	for(cls=(Object)item->__class__; cls != cls->__super__; cls=cls->__super__) {
	126	for(i=0; i<TOTAL_CLASSES; i++) {
	127	if(python_wrappers[i].class_ref == cls) {
	128	PyErr_Clear();
	129
	130	result = (Gen_wrapper *)_PyObject_New(python_wrappers[i].python_type);
[198]	131	result->ctx = talloc_asprintf(NULL, "new_class_wrapper %%s@%%p",
	132	NAMEOF(item), (void*)item);
[196]	133	result->base = (void *)item;
	134
	135	/* If its owned by the null_context it means that the function does
	136	not want to own the memory - we therefore steal it so it gets freed
	137	with the python object. */
	138	if(talloc_parent(result->base) == null_context)
	139	talloc_steal(result->ctx, result->base);
	140
	141	return result;
[198]	142	}
	143	}
	144	}
[196]	145
	146	PyErr_Format(PyExc_RuntimeError, "Unable to find a wrapper for object %%s", NAMEOF(item));
	147	return NULL;
[198]	148	}
[196]	149
	150	static PyObject resolve_exception(char *error_buff) {
	151	enum _error_type *type = aff4_get_current_error(error_buff);
	152	switch(*type) {
	153	case EProgrammingError:
	154	return PyExc_SystemError;
	155	case EKeyError:
	156	return PyExc_KeyError;
	157	case ERuntimeError:
	158	return PyExc_RuntimeError;
	159	case EWarning:
	160	return PyExc_AssertionError;
	161	default:
	162	return PyExc_RuntimeError;
	163	};
[198]	164	}
[196]	165
	166	static int type_check(PyObject obj, PyTypeObject type) {
	167	PyTypeObject *tmp;
	168
	169	// Recurse through the inheritance tree and check if the types are expected
	170	if(obj)
	171	for(tmp = obj->ob_type; tmp && tmp != &PyBaseObject_Type; tmp = tmp->tp_base) {
	172	if(tmp == type) return 1;
[198]	173	}
[196]	174
	175	return 0;
[198]	176	}
[196]	177
	178	static int check_error() {
	179	if(!CheckError(EZero)) {
	180	char *buffer;
	181	PyObject *exception = resolve_exception(&buffer);
	182
	183	PyErr_Format(exception, "%%s", buffer);
	184	ClearError();
	185	return 1;
[198]	186	}
[196]	187	return 0;
[198]	188	}
[196]	189
	190	#define CHECK_ERROR if(check_error()) goto error;
	191
	192	""" % (len(self.classes)+1)
	193
	194	def initialise_class(self, class_name, out, done = None):
	195	if done and class_name in done: return
	196
	197	done.add(class_name)
	198
	199	cls = self.classes[class_name]
	200	""" Write out class initialisation code into the main init function. """
	201	if cls.is_active():
	202	base_class = self.classes.get(cls.base_class_name)
	203
	204	if base_class and base_class.is_active():
	205	## We have a base class - ensure it gets written out
	206	## first:
	207	self.initialise_class(cls.base_class_name, out, done)
	208
	209	## Now assign ourselves as derived from them
	210	out.write(" %s_Type.tp_base = &%s_Type;" % (
	211	cls.class_name, cls.base_class_name))
	212
	213	out.write("""
	214	%(name)s_Type.tp_new = PyType_GenericNew;
	215	if (PyType_Ready(&%(name)s_Type) < 0)
	216	return;
	217
	218	Py_INCREF((PyObject *)&%(name)s_Type);
	219	PyModule_AddObject(m, "%(name)s", (PyObject *)&%(name)s_Type);
	220	""" % {'name': cls.class_name})
	221
	222	def write(self, out):
	223	## Prepare all classes
	224	for cls in self.classes.values():
	225	cls.prepare()
	226
	227	out.write("""
	228	/**********************************************************************
	229	Autogenerated module %s
	230
	231	This module was autogenerated from the following files:
	232	""" % self.name)
	233	for file in self.files:
	234	out.write("%s\n" % file)
	235
	236	out.write("\nThis module implements the following classes:\n")
	237	out.write(self.__str__())
	238	out.write("""***********************************************************************/
	239	""")
	240	out.write(self.headers)
	241	out.write(self.private_functions())
	242
	243	for cls in self.classes.values():
	244	if cls.is_active():
	245	out.write("/****************** %s *********************/" % cls.class_name)
	246	cls.struct(out)
	247	cls.prototypes(out)
	248
	249	out.write("/***************************************************\n Implementation\n****************************************************/\n\n")
	250	for cls in self.classes.values():
	251	if cls.is_active():
	252	cls.PyMethodDef(out)
	253	cls.code(out)
	254	cls.PyTypeObject(out)
	255
	256	## Write the module initializer
	257	out.write("""
	258	static PyMethodDef %(module)s_methods[] = {
	259	{NULL} /* Sentinel */
	260	};
	261
	262	PyMODINIT_FUNC init%(module)s(void) {
	263	/* Make sure threads are enabled */
	264	PyEval_InitThreads();
	265
	266	/* create module */
	267	PyObject *m = Py_InitModule3("%(module)s", %(module)s_methods,
	268	"%(module)s module.");
	269	PyObject *d = PyModule_GetDict(m);
	270	PyObject *tmp;
	271
	272	g_module = m;
	273	""" % {'module': self.name})
	274
	275	## The trick is to initialise the classes in order of their
	276	## inheritance. The following code will order initializations
	277	## according to their inheritance tree
	278	done = set()
	279	for class_name in self.classes.keys():
	280	self.initialise_class(class_name, out, done)
	281
	282	## Add the constants in here
	283	for constant, type in self.constants:
	284	if type == 'integer':
	285	out.write(""" tmp = PyLong_FromUnsignedLongLong((int64_t)%s); \n""" % constant)
	286	elif type == 'string':
	287	out.write(" tmp = PyString_FromString((char *)%s); \n" % constant)
	288	else:
	289	out.write(" // I dont know how to convert %s type %s\n" % (constant, type))
	290	continue
	291
	292	out.write("""
	293	PyDict_SetItemString(d, "%s", tmp);
	294	Py_DECREF(tmp);\n""" % (constant))
	295
	296	out.write(self.initialization())
	297	out.write("}\n\n")
	298
	299	class Type:
	300	interface = None
	301	buildstr = 'O'
	302	sense = 'IN'
	303	error_value = "return 0;"
	304	active = True
	305
	306	def __init__(self, name, type):
	307	self.name = name
	308	self.type = type
	309	self.attributes = set()
	310
	311	def comment(self):
	312	return "%s %s " % (self.type, self.name)
	313
	314	def python_name(self):
	315	return self.name
	316
	317	def python_proxy_post_call(self):
	318	""" This is called after a proxy call """
	319	return ''
	320
	321	def returned_python_definition(self, arg, *kw):
	322	return self.definition(arg, *kw)
	323
	324	def definition(self, default=None, **kw):
	325	if default:
	326	return "%s %s=%s;\n" % (self.type, self.name, default)
	327	else:
	328	return "%s __attribute__((unused)) %s;\n" % (self.type, self.name)
	329
	330	def byref(self):
	331	return "&%s" % self.name
	332
	333	def call_arg(self):
	334	return self.name
	335
	336	def pre_call(self, method):
	337	return ''
	338
	339	def assign(self, call, method, target=None):
	340	return "Py_BEGIN_ALLOW_THREADS\n%s = %s;\nPy_END_ALLOW_THREADS\n" % (target or self.name, call)
	341
	342	def post_call(self, method):
	343	if "DESTRUCTOR" in self.attributes:
	344	return "talloc_free(self->ctx); self->base = NULL;\n"
	345
	346	return ''
	347
	348	def from_python_object(self, source, destination, method, **kw):
	349	return ''
	350
	351	def return_value(self, value):
	352	return "return %s;" % value
	353
	354	def __str__(self):
	355	if self.name == 'func_return':
	356	return self.type
	357	if 'void' in self.type:
	358	return ''
	359
	360	result = "%s : %s" % (self.type, self.name)
	361
	362	return result
	363
	364	class String(Type):
	365	interface = 'string'
	366	buildstr = 's'
	367	error_value = "return NULL;"
	368
	369	def __init__(self, name, type):
	370	Type.__init__(self, name, type)
	371	self.length = "strlen(%s)" % name
	372
	373	def byref(self):
	374	return "&%s" % self.name
	375
	376	def to_python_object(self, name=None, result='py_result',**kw):
	377	name = name or self.name
	378
	379	result = """PyErr_Clear();
[198]	380	if(!%(name)s) { PyErr_Format(PyExc_RuntimeError, "%(name)s is NULL"); goto error; }
[196]	381	%(result)s = PyString_FromStringAndSize((char *)%(name)s, %(length)s);\nif(!%(result)s) goto error;
	382	""" % dict(name=name, result=result,length=self.length)
	383
	384	if "BORROWED" not in self.attributes and 'BORROWED' not in kw:
	385	result += "talloc_unlink(NULL, %s);\n" % name
	386
	387	return result
	388
	389	def from_python_object(self, source, destination, method, context='NULL'):
	390	method.error_set = True
	391	return """
	392	{
	393	char *buff; Py_ssize_t length;
	394
	395	PyErr_Clear();
	396	if(-1==PyString_AsStringAndSize(%(source)s, &buff, &length))
	397	goto error;
	398
	399	%(destination)s = talloc_size(%(context)s, length + 1);
	400	memcpy(%(destination)s, buff, length);
	401	%(destination)s[length]=0;
[198]	402	}
[196]	403	""" % dict(source = source, destination = destination, context =context)
	404
	405	class ZString(String):
	406	interface = 'null_terminated_string'
	407
	408	class BorrowedString(String):
	409	def to_python_object(self, name=None, result='py_result', **kw):
	410	name = name or self.name
	411	return "PyErr_Clear();\n" +\
	412	"%s = PyString_FromStringAndSize((char *)%(name)s, %(length)s);\n" % dict(
	413	name=name, length=self.length, result=result)
	414
	415	class Char_and_Length(Type):
	416	interface = 'char_and_length'
	417	buildstr = 's#'
	418	error_value = "return NULL;"
	419
	420	def __init__(self, data, data_type, length, length_type):
	421	Type.__init__(self, data, data_type)
	422
	423	self.name = data
	424	self.data_type=data_type
	425	self.length = length
	426	self.length_type = length_type
	427
	428	def comment(self):
	429	return "%s %s, %s %s" % (self.data_type, self.name,
	430	self.length_type, self.length)
	431
	432	def definition(self, default = '""', **kw):
	433	return "char *%s=%s; Py_ssize_t %s=strlen(%s);\n" % (
	434	self.name, default,
	435	self.length, default)
	436
	437	def byref(self):
	438	return "&%s, &%s" % (self.name, self.length)
	439
	440	def call_arg(self):
	441	return "(%s)%s, (%s)%s" % (self.data_type, self.name, self.length_type,
	442	self.length)
	443
	444	def to_python_object(self, name=None, result='py_result', **kw):
	445	return "PyErr_Clear();\n"\
	446	"%s = PyString_FromStringAndSize(%s, %s);\nif(!%s) goto error;" % (
	447	result, self.name, self.length, result);
	448
	449	class Integer(Type):
	450	interface = 'integer'
	451	buildstr = 'K'
	452
	453	def __init__(self, name,type):
	454	Type.__init__(self,name,type)
	455	self.type = 'uint64_t'
	456	self.original_type = type
	457
	458	def definition(self, default = 0, **kw):
	459	return Type.definition(self, default)
	460
	461	def to_python_object(self, name=None, result='py_result', **kw):
	462	name = name or self.name
	463	return "PyErr_Clear();\n%s = PyLong_FromLongLong(%s);\n" % (result, name)
	464
	465	def from_python_object(self, source, destination, method, **kw):
	466	return "PyErr_Clear();\n"\
	467	"%(destination)s = PyLong_AsUnsignedLong(%(source)s);\n" % dict(
	468	source = source, destination= destination)
	469
	470	def comment(self):
	471	return "%s %s " % (self.original_type, self.name)
	472
	473	class Integer32(Integer):
	474	buildstr = 'I'
	475
	476	def __init__(self, name,type):
	477	Type.__init__(self,name,type)
	478	self.type = 'unsigned int '
	479	self.original_type = type
	480
	481	def to_python_object(self, name=None, result='py_result', **kw):
	482	name = name or self.name
	483	return "PyErr_Clear();\n%s = PyLong_FromLong(%s);\n" % (result, name)
	484
	485	class Integer64(Integer):
	486	buildstr = 'K'
	487	type = 'unsigned int'
	488
	489	class Char(Integer):
	490	buildstr = "s"
	491	interface = 'small_integer'
	492
	493	def to_python_object(self, name = None, result = 'py_result', **kw):
	494	## We really want to return a string here
	495	return """{ char *str_%(name)s = &%(name)s;
	496	PyErr_Clear();
	497	%(result)s = PyString_FromStringAndSize(str_%(name)s, 1);
	498	if(!%(result)s) goto error;
[198]	499	}
[196]	500	""" % dict(result=result, name = name or self.name)
	501
	502	def definition(self, default = '"\\x0"', **kw):
	503	## Shut up unused warnings
	504	return "char %s __attribute__((unused))=0;\nchar *str_%s __attribute__((unused)) = %s;\n" % (
	505	self.name,self.name, default)
	506
	507	def byref(self):
	508	return "&str_%s" % self.name
	509
	510	def pre_call(self, method):
	511	method.error_set = True
	512	return """
	513	if(strlen(str_%(name)s)!=1) {
	514	PyErr_Format(PyExc_RuntimeError,
	515	"You must only provide a single character for arg %(name)r");
	516	goto error;
[198]	517	}
[196]	518
	519	%(name)s = str_%(name)s[0];
	520	""" % dict(name = self.name)
	521
	522	class StringOut(String):
	523	sense = 'OUT'
	524
	525	class IntegerOut(Integer):
	526	sense = 'OUT_DONE'
	527	buildstr = ''
	528
	529	def python_name(self):
	530	return None
	531
	532	def byref(self):
	533	return ''
	534
	535	def call_arg(self):
	536	return "&%s" % self.name
	537
	538	class Integer32Out(Integer32):
	539	sense = 'OUT_DONE'
	540	buildstr = ''
	541
	542	def python_name(self):
	543	return None
	544
	545	def byref(self):
	546	return ''
	547
	548	def call_arg(self):
	549	return "&%s" % self.name
	550
	551	class Char_and_Length_OUT(Char_and_Length):
	552	sense = 'OUT_DONE'
	553	buildstr = 'l'
	554
	555	def definition(self, default = 0, **kw):
	556	return "char *%s=NULL; Py_ssize_t %s=%s;\n" % (
	557	self.name,
	558	self.length, default) + "PyObject *tmp_%s;\n" % self.name
	559
	560	def python_name(self):
	561	return self.length
	562
	563	def byref(self):
	564	return "&%s" % self.length
	565
	566	def pre_call(self, method):
	567	return """PyErr_Clear();
	568	tmp_%s = PyString_FromStringAndSize(NULL, %s);
	569	if(!tmp_%s) goto error;
	570	PyString_AsStringAndSize(tmp_%s, &%s, (Py_ssize_t *)&%s);
	571	""" % (self.name, self.length, self.name, self.name, self.name, self.length)
	572
	573	def to_python_object(self, name=None, result='py_result', sense='in', **kw):
	574	name = name or self.name
	575	if 'results' in kw:
	576	kw['results'].pop(0)
	577
	578	if sense=='proxied':
	579	return "py_%s = PyLong_FromLong(%s);\n" % (self.name, self.length)
	580
	581	return """if(func_return > %(length)s) {
	582	func_return = 0;
[198]	583	}
[196]	584
	585	_PyString_Resize(&tmp_%(name)s, func_return); \n%(result)s = tmp_%(name)s;\n""" % \
	586	dict(name= name, result= result, length=self.length)
	587
	588
	589	def python_proxy_post_call(self, result='py_result'):
	590	return """
	591	{
	592	char *tmp_buff; int tmp_len;
	593	if(-1==PyString_AsStringAndSize(%(result)s, &tmp_buff, &tmp_len)) goto error;
	594
	595	memcpy(%(name)s,tmp_buff, tmp_len);
	596	Py_DECREF(%(result)s);
	597	%(result)s = PyLong_FromLong(tmp_len);
[198]	598	}
[196]	599	""" % dict(result = result, name=self.name)
	600
	601	class TDB_DATA_P(Char_and_Length_OUT):
	602	bare_type = "TDB_DATA"
	603
	604	def __init__(self, name, type):
	605	Type.__init__(self, name, type)
	606
	607	def definition(self, default=None, **kw):
	608	return Type.definition(self)
	609
	610	def byref(self):
	611	return "%s.dptr, &%s.dsize" % (self.name, self.name)
	612
	613	def pre_call(self, method):
	614	return ''
	615
	616	def call_arg(self):
	617	return Type.call_arg(self)
	618
	619	def to_python_object(self, name=None,result='py_result', **kw):
	620	name = name or self.name
	621	return "PyErr_Clear();"\
	622	"%s = PyString_FromStringAndSize((char *)%s->dptr, %s->dsize);"\
	623	"\ntalloc_free(%s);" % (result,
	624	name, name, name)
	625
	626	def from_python_object(self, source, destination, method, **kw):
	627	method.error_set = True
	628	return """
	629	%(destination)s = talloc(self, %(bare_type)s);
	630	{ Py_ssize_t tmp; char *buf;
	631
	632	PyErr_Clear();
	633	if(-1==PyString_AsStringAndSize(%(source)s, &buf, &tmp)) {
	634	goto error;
[198]	635	}
[196]	636
	637	// Take a copy of the python string
	638	%(destination)s->dptr = talloc_memdup(%(destination)s, buf, tmp);
	639	%(destination)s->dsize = tmp;
	640	}
	641	// We no longer need the python object
	642	Py_DECREF(%(source)s);
	643	""" % dict(source = source, destination = destination,
	644	bare_type = self.bare_type)
	645
	646	class TDB_DATA(TDB_DATA_P):
	647	def to_python_object(self, name = None, result='py_result', **kw):
	648	name = name or self.name
	649
	650	return "PyErr_Clear();\n"\
	651	"%s = PyString_FromStringAndSize((char *)%s.dptr, %s.dsize);\n" % (
	652	result,
	653	name, name)
	654
	655	class Void(Type):
	656	buildstr = ''
	657	error_value = "return;"
	658	original_type = ''
	659
	660	def __init__(self, *args):
	661	Type.__init__(self, None, 'void *')
	662
	663	def definition(self, default = None, **kw):
	664	return ''
	665
	666	def to_python_object(self, name=None, result = 'py_result', **kw):
	667	return "Py_INCREF(Py_None); py_result = Py_None;\n"
	668
	669	def call_arg(self):
	670	return "NULL"
	671
	672	def byref(self):
	673	return None
	674
	675	def assign(self, call, method, target=None):
	676	## We dont assign the result to anything
	677	return "Py_BEGIN_ALLOW_THREADS\n%s;\nPy_END_ALLOW_THREADS\n" % call
	678
	679	def return_value(self, value):
	680	return "return;"
	681
	682	class StringArray(String):
	683	interface = 'array'
	684	buildstr = 'O'
	685
	686	def definition(self, default = '""', **kw):
	687	return "char *%s=NULL; PyObject py_%s=NULL;\n" % (
	688	self.name, self.name)
	689
	690	def byref(self):
	691	return "&py_%s" % (self.name)
	692
	693	def from_python_object(self, source, destination, method, context='NULL'):
	694	method.error_set = True
	695	return """{
	696	Py_ssize_t i,size=0;
	697
	698	if(%(source)s) {
	699	if(!PySequence_Check(%(source)s)) {
	700	PyErr_Format(PyExc_ValueError, "%(destination)s must be a sequence");
	701	goto error;
[198]	702	}
[196]	703
	704	size = PySequence_Size(%(source)s);
[198]	705	}
[196]	706
	707	%(destination)s = talloc_zero_array(NULL, char *, size + 1);
	708
	709	for(i=0; i<size;i++) {
	710	PyObject *tmp = PySequence_GetItem(%(source)s, i);
	711	if(!tmp) goto error;
	712	%(destination)s[i] = PyString_AsString(tmp);
	713	if(!%(destination)s[i]) {
	714	Py_DECREF(tmp);
	715	goto error;
[198]	716	}
[196]	717	Py_DECREF(tmp);
[198]	718	}
[196]	719
[198]	720	}""" % dict(source = source, destination = destination, context = context)
[196]	721
	722	def pre_call(self, method):
	723	return self.from_python_object("py_%s" % self.name, self.name, method)
	724
	725	def error_condition(self):
	726	return """if(%s) talloc_free(%s);\n""" % (self.name, self.name)
	727
	728	class Wrapper(Type):
	729	""" This class represents a wrapped C type """
	730	sense = 'IN'
	731	error_value = "return NULL;"
	732
	733	def from_python_object(self, source, destination, method, **kw):
	734	return """
	735	/* First check that the returned value is in fact a Wrapper */
	736	if(!type_check(%(source)s, &%(type)s_Type)) {
	737	PyErr_Format(PyExc_RuntimeError, "function must return an %(type)s instance");
	738	goto error;
[198]	739	}
[196]	740
	741	%(destination)s = ((Gen_wrapper *)%(source)s)->base;
	742	""" % dict(source = source, destination = destination, type = self.type)
	743
	744	def to_python_object(self, **kw):
	745	return ''
	746
	747	def returned_python_definition(self, default = 'NULL', sense='in', **kw):
	748	return "%s %s;\n" % (self.type, self.name)
	749
	750	def definition(self, default = 'NULL', sense='in', **kw):
	751	result = "Gen_wrapper *%s __attribute__((unused)) = %s;\n" % (self.name, default)
	752	if sense == 'in' and not 'OUT' in self.attributes:
	753	result += " %s __attribute__((unused)) call_%s;\n" % (self.type, self.name)
	754
	755	return result
	756
	757	def call_arg(self):
	758	return "call_%s" % self.name
	759
	760	def pre_call(self, method):
	761	if 'OUT' in self.attributes or self.sense == 'OUT':
	762	return ''
	763
	764	return """
	765	if(!%(name)s \|\| (PyObject *)%(name)s==Py_None) {
	766	call_%(name)s = NULL;
	767	} else if(!type_check((PyObject *)%(name)s,&%(type)s_Type)) {
	768	PyErr_Format(PyExc_RuntimeError, "%(name)s must be derived from type %(type)s");
	769	goto error;
	770	} else {
	771	call_%(name)s = %(name)s->base;
[198]	772	}\n""" % self.__dict__
[196]	773
	774	def assign(self, call, method, target=None):
	775	method.error_set = True;
	776	args = dict(name = target or self.name, call = call, type = self.type)
	777
	778	result = """{
	779	Object returned_object;
	780
	781	ClearError();
	782
	783	Py_BEGIN_ALLOW_THREADS
	784	returned_object = (Object)%(call)s;
	785	Py_END_ALLOW_THREADS
	786
	787	CHECK_ERROR;
	788	""" % args
	789
	790	## Is NULL an acceptable return type? In some python code NULL
	791	## can be returned (e.g. in iterators) but usually it should
	792	## be converted to None.
	793	if "NULL_OK" in self.attributes:
	794	result += """if(returned_object == NULL) {
	795	%(name)s = NULL; """ % args
	796	else:
	797	result += """
	798	// A NULL return without errors means we return None
	799	if(!returned_object) {
	800	%(name)s = (Gen_wrapper *)Py_None;
	801	Py_INCREF(Py_None);
	802	""" % args
	803
	804	result += """
	805	} else {
	806	//printf("%%s: Wrapping %%s@%%p\\n", __FUNCTION__, NAMEOF(returned_object), returned_object);
	807	%(name)s = new_class_wrapper(returned_object);
	808	if(!%(name)s) goto error;
	809	""" % args
	810
	811	if "BORROWED" in self.attributes:
	812	result += " talloc_reference(%(name)s->ctx, %(name)s->base);\n" % args
	813
[198]	814	result += """ }
[196]	815	}
	816	"""
	817	return result
	818
	819	def to_python_object(self, name=None, result = 'py_result', sense='in', **kw):
	820	name = name or self.name
	821	args = dict(result=result,
	822	name = name)
	823
	824	if sense=='proxied':
	825	return "%(result)s = (PyObject *)new_class_wrapper((Object)%(name)s);\n" % args
	826
	827	return "%(result)s = (PyObject *)%(name)s;\n" % args
	828
	829	class PointerWrapper(Wrapper):
	830	""" A pointer to a wrapped class """
	831	def __init__(self, name, type):
	832	type = type.split()[0]
	833	Wrapper.__init__(self,name, type)
	834
	835	def definition(self, default = 'NULL', sense='in', **kw):
	836	result = "Gen_wrapper *%s = %s;" % (self.name, default)
	837	if sense == 'in' and not 'OUT' in self.attributes:
	838	result += " %s *call_%s;\n" % (self.type, self.name)
	839
	840	return result
	841
	842	def pre_call(self, method):
	843	if 'OUT' in self.attributes or self.sense == 'OUT':
	844	return ''
	845
	846	return """
	847	if(!%(name)s \|\| (PyObject *)%(name)s==Py_None) {
	848	call_%(name)s = NULL;
	849	} else if(!type_check((PyObject *)%(name)s,&%(type)s_Type)) {
	850	PyErr_Format(PyExc_RuntimeError, "%(name)s must be derived from type %(type)s");
	851	goto error;
	852	} else {
	853	call_%(name)s = (%(type)s *)&%(name)s->base;
[198]	854	}\n""" % self.__dict__
[196]	855
	856	class StructWrapper(Wrapper):
	857	""" A wrapper for struct classes """
	858	def assign(self, call, method, target = None):
	859	args = dict(name = target or self.name, call = call, type = self.type)
	860	result = """
	861	PyErr_Clear();
	862	%(name)s = (Gen_wrapper *)PyObject_New(py%(type)s, &%(type)s_Type);
	863	%(name)s->ctx = talloc_size(NULL, 1);
	864	%(name)s->base = %(call)s;
	865	""" % args
	866
	867	if "NULL_OK" in self.attributes:
[198]	868	result += "if(!%(name)s->base) { Py_DECREF(%(name)s); return NULL; }" % args
[196]	869
	870	result += """
	871	// A NULL object gets translated to a None
	872	if(!%(name)s->base) {
	873	Py_DECREF(%(name)s);
	874	Py_INCREF(Py_None);
	875	%(name)s = (Gen_wrapper *)Py_None;
	876	} else {
	877	""" % args
	878
	879	if "FOREIGN" in self.attributes:
	880	result += '// Not taking references to foreign memory\n'
	881	elif "BORROWED" in self.attributes:
	882	result += "talloc_reference(%(name)s->ctx, %(name)s->base);\n" % args
	883	else:
	884	result += "talloc_steal(%(name)s->ctx, %(name)s->base);\n" % args
	885
	886	result += "}\n"
	887
	888	return result
	889
	890	def byref(self):
	891	return "&%s" % self.name
	892
	893	def definition(self, default = 'NULL', sense='in', **kw):
	894	result = "Gen_wrapper *%s = %s;" % (self.name, default)
	895	if sense == 'in' and not 'OUT' in self.attributes:
	896	result += " %s *call_%s;\n" % (self.type, self.name)
	897
	898	return result;
	899
	900	class PointerStructWrapper(StructWrapper):
	901	def __init__(self, name, type):
	902	type = type.split()[0]
	903	Wrapper.__init__(self,name, type)
	904
	905	class Timeval(Type):
	906	""" handle struct timeval values """
	907	interface = 'numeric'
	908	buildstr = 'f'
	909
	910	def definition(self, default = None, **kw):
	911	return "float %(name)s_flt; struct timeval %(name)s;\n" % self.__dict__
	912
	913	def byref(self):
	914	return "&%s_flt" % self.name
	915
	916	def pre_call(self, method):
	917	return "%(name)s.tv_sec = (int)%(name)s_flt; %(name)s.tv_usec = (%(name)s_flt - %(name)s.tv_sec) * 1e6;\n" % self.__dict__
	918
	919	def to_python_object(self, name=None, result = 'py_result', **kw):
	920	name = name or self.name
	921	return """%(name)s_flt = (double)(%(name)s.tv_sec) + %(name)s.tv_usec;
	922	%(result)s = PyFloat_FromDouble(%(name)s_flt);
	923	""" % dict(name = name, result=result)
	924
	925	class PyObject(Type):
	926	""" Accept an opaque python object """
	927	interface = 'opaque'
	928	buildstr = 'O'
	929	def definition(self, default = 'NULL', **kw):
	930	self.default = default
	931	return 'PyObject *%(name)s = %(default)s;\n' % self.__dict__
	932
	933	def byref(self):
	934	return "&%s" % self.name
	935
	936	type_dispatcher = {
	937	"IN char *": String,
	938	"IN unsigned char *": String,
	939	"unsigned char *": String,
	940	"char *": String,
	941	"ZString": ZString,
	942
	943	"OUT char *": StringOut,
	944	"OUT unsigned char *": StringOut,
	945	"unsigned int": Integer,
	946	'int': Integer,
	947	'OUT uint64_t *': IntegerOut,
	948	'OUT uint32_t *': Integer32Out,
	949	'char': Char,
	950	'void': Void,
	951	'void *': Void,
	952
	953	'TDB_DATA *': TDB_DATA_P,
	954	'TDB_DATA': TDB_DATA,
	955	'uint64_t': Integer,
	956	'uint32_t': Integer32,
	957	'time_t': Integer32,
	958	'uint16_t': Integer,
	959	'uint8_t': Integer,
	960	'int64_t': Integer,
	961	'ssize_t': Integer,
	962	'size_t': Integer,
	963	'unsigned long int': Integer,
	964	'struct timeval': Timeval,
	965	'char **': StringArray,
	966
	967	'PyObject *': PyObject,
	968	}
	969
	970	method_attributes = ['BORROWED', 'DESTRUCTOR','IGNORE']
	971
	972	def dispatch(name, type):
	973	if not type: return Void()
	974
	975	m = re.match("struct ([a-zA-Z0-9]+)_t *", type)
	976	if m:
	977	type = m.group(1)
	978
	979	type_components = type.split()
	980	attributes = set()
	981
	982	if type_components[0] in method_attributes:
	983	attributes.add(type_components.pop(0))
	984
	985	type = " ".join(type_components)
	986	result = type_dispatcher[type](name, type)
	987
	988	result.attributes = attributes
	989
	990	return result
	991
	992	class ResultException:
	993	value = 0
	994	exception = "PyExc_IOError"
	995
	996	def __init__(self, check, exception, message):
	997	self.check = check
	998	self.exception = exception
	999	self.message = message
	1000
	1001	def write(self, out):
	1002	out.write("\n//Handle exceptions\n")
[198]	1003	out.write("if(%s) {\n PyErr_Format(PyExc_%s, %s);\n goto error; \n}\n\n" % (
[196]	1004	self.check, self.exception, self.message))
	1005
	1006	class Method:
	1007	default_re = re.compile("DEFAULT\(([A-Z_a-z0-9]+)\) =(.+)")
	1008	exception_re = re.compile("RAISES\(([^,]+),\s*([^\)]+)\) =(.+)")
	1009	typedefed_re = re.compile(r"struct (.+)_t \*")
	1010
	1011	def __init__(self, class_name, base_class_name, method_name, args, return_type,
	1012	myclass = None):
	1013	self.name = method_name
	1014	## myclass needs to be a class generator
	1015	if not isinstance(myclass, ClassGenerator): raise RuntimeError("myclass must be a class generator")
	1016
	1017	self.myclass = myclass
	1018	self.docstring = ''
	1019	self.defaults = {}
	1020	self.exception = None
	1021	self.error_set = False
	1022	self.class_name = class_name
	1023	self.base_class_name = base_class_name
	1024	self.args = []
	1025	self.definition_class_name = class_name
	1026	for type,name in args:
	1027	self.add_arg(type, name)
	1028
	1029	try:
	1030	self.return_type = dispatch('func_return', return_type)
	1031	self.return_type.attributes.add("OUT")
	1032	self.return_type.original_type = return_type
	1033	except KeyError:
	1034	## Is it a wrapped type?
	1035	if return_type:
	1036	log("Unable to handle return type %s.%s %s" % (self.class_name, self.name, return_type))
	1037	#pdb.set_trace()
	1038	self.return_type = Void()
	1039
	1040	def clone(self, new_class_name):
	1041	self.find_optional_vars()
	1042
	1043	result = self.__class__(new_class_name, self.base_class_name, self.name,
	1044	[], 'void *',
	1045	myclass = self.myclass)
	1046	result.args = self.args
	1047	result.return_type = self.return_type
	1048	result.definition_class_name = self.definition_class_name
	1049	result.defaults = self.defaults
	1050	result.exception = self.exception
	1051
	1052	return result
	1053
	1054	def find_optional_vars(self):
	1055	for line in self.docstring.splitlines():
	1056	m =self.default_re.search(line)
	1057	if m:
	1058	name = m.group(1)
	1059	value = m.group(2)
	1060	log("Setting default value for %s of %s" % (m.group(1),
	1061	m.group(2)))
	1062	self.defaults[name] = value
	1063
	1064	m =self.exception_re.search(line)
	1065	if m:
	1066	self.exception = ResultException(m.group(1), m.group(2), m.group(3))
	1067
	1068	def write_local_vars(self, out):
	1069	self.find_optional_vars()
	1070
	1071	## We do it in two passes - first mandatory then optional
	1072	kwlist = """static char *kwlist[] = {"""
	1073	## Mandatory
	1074	for type in self.args:
	1075	python_name = type.python_name()
	1076	if python_name and python_name not in self.defaults:
	1077	kwlist += '"%s",' % python_name
	1078
	1079	for type in self.args:
	1080	python_name = type.python_name()
	1081	if python_name and python_name in self.defaults:
	1082	kwlist += '"%s",' % python_name
	1083
	1084	kwlist += ' NULL};\n'
	1085
	1086	for type in self.args:
	1087	python_name = type.python_name()
	1088	try:
	1089	out.write(type.definition(default = self.defaults[python_name]))
	1090	except KeyError:
	1091	out.write(type.definition())
	1092
	1093	## Make up the format string for the parse args in two pases
	1094	parse_line = ''
	1095	for type in self.args:
	1096	python_name = type.python_name()
	1097	if type.buildstr and python_name not in self.defaults:
	1098	parse_line += type.buildstr
	1099
	1100	parse_line += '\|'
	1101	for type in self.args:
	1102	python_name = type.python_name()
	1103	if type.buildstr and python_name in self.defaults:
	1104	parse_line += type.buildstr
	1105
	1106	if parse_line != '\|':
	1107	## Now parse the args from python objects
	1108	out.write(kwlist)
	1109	out.write("\nif(!PyArg_ParseTupleAndKeywords(args, kwds, \"%s\", kwlist, " % parse_line)
	1110	tmp = []
	1111	for type in self.args:
	1112	ref = type.byref()
	1113	if ref:
	1114	tmp.append(ref)
	1115
	1116	out.write(",".join(tmp))
	1117	self.error_set = True
	1118	out.write("))\n goto error;\n\n")
	1119
	1120	def error_condition(self):
	1121	result = ""
	1122	if "DESTRUCTOR" in self.return_type.attributes:
	1123	result += "talloc_free(self->ctx); self->base = NULL;\n"
	1124
	1125	return result +"return NULL;\n";
	1126
	1127	def write_definition(self, out):
	1128	args = dict(method = self.name, class_name = self.class_name)
	1129	out.write("\n/********************************************************\nAutogenerated wrapper for function:\n")
	1130	out.write(self.comment())
	1131	out.write("********************************************************/\n")
	1132
	1133	self._prototype(out)
	1134	out.write("""{
	1135	PyObject returned_result, py_result;
	1136	""" % args)
	1137
	1138	out.write(self.return_type.definition())
	1139
	1140	self.write_local_vars( out);
	1141
	1142	out.write("""// Make sure that we have something valid to wrap
	1143	if(!self->base) return PyErr_Format(PyExc_RuntimeError, "%(class_name)s object no longer valid");
	1144	""" % args)
	1145
	1146	## Precall preparations
	1147	out.write("// Precall preparations\n")
	1148	out.write(self.return_type.pre_call(self))
	1149	for type in self.args:
	1150	out.write(type.pre_call(self))
	1151
	1152	out.write("""// Check the function is implemented
	1153	{ void *method = ((%(def_class_name)s)self->base)->%(method)s;
	1154	if(!method \|\| (void )unimplemented == (void )method) {
	1155	PyErr_Format(PyExc_RuntimeError, "%(class_name)s.%(method)s is not implemented");
	1156	goto error;
[198]	1157	}
	1158	}
[196]	1159	""" % dict(def_class_name = self.definition_class_name, method=self.name,
	1160	class_name = self.class_name))
	1161
	1162	out.write("\n// Make the call\n ClearError();")
	1163	call = "((%s)self->base)->%s(((%s)self->base)" % (self.definition_class_name, self.name, self.definition_class_name)
	1164	tmp = ''
	1165	for type in self.args:
	1166	tmp += ", " + type.call_arg()
	1167
	1168	call += "%s)" % tmp
	1169
	1170	## Now call the wrapped function
	1171	out.write(self.return_type.assign(call, self))
	1172	if self.exception:
	1173	self.exception.write(out)
	1174
	1175	self.error_set = True
	1176
	1177	out.write("\n// Postcall preparations\n")
	1178	## Postcall preparations
	1179	out.write(self.return_type.post_call(self))
	1180	for type in self.args:
	1181	out.write(type.post_call(self))
	1182
	1183	## Now assemble the results
	1184	results = [self.return_type.to_python_object()]
	1185	for type in self.args:
	1186	if type.sense == 'OUT_DONE':
	1187	results.append(type.to_python_object(results = results))
	1188
	1189	## If all the results are returned by reference we dont need
	1190	## to prepend the void return value at all.
	1191	if isinstance(self.return_type, Void) and len(results)>1:
	1192	results.pop(0)
	1193
	1194	out.write("\n// prepare results\n")
	1195	## Make a tuple of results and pass them back
	1196	if len(results)>1:
	1197	out.write("returned_result = PyList_New(0);\n")
	1198	for result in results:
	1199	out.write(result)
	1200	out.write("PyList_Append(returned_result, py_result); Py_DECREF(py_result);\n");
	1201	out.write("return returned_result;\n")
	1202	else:
	1203	out.write(results[0])
	1204	## This useless code removes compiler warnings
	1205	out.write("returned_result = py_result;\nreturn returned_result;\n");
	1206
	1207	## Write the error part of the function
	1208	if self.error_set:
	1209	out.write("\n// error conditions:\n")
	1210	out.write("error:\n " + self.error_condition());
	1211
[198]	1212	out.write("\n}\n\n")
[196]	1213
	1214	def add_arg(self, type, name):
	1215	try:
	1216	t = type_dispatcher[type](name, type)
	1217	except KeyError:
	1218	## Sometimes types must be typedefed in advance
	1219	try:
	1220	m = self.typedefed_re.match(type)
	1221	type = m.group(1)
	1222	log( "Trying %s for %s" % (type, m.group(0)))
	1223	t = type_dispatcher[type](name, type)
	1224	except (KeyError, AttributeError):
	1225	log( "Unable to handle type %s.%s %s" % (self.class_name, self.name, type))
	1226	return
	1227
	1228	## Here we collapse char * + int type interfaces into a
	1229	## coherent string like interface.
	1230	try:
	1231	previous = self.args[-1]
	1232	if t.interface == 'integer' and \
	1233	previous.interface == 'string':
	1234
	1235	## We make a distinction between IN variables and OUT
	1236	## variables
	1237	if previous.sense == 'OUT':
	1238	cls = Char_and_Length_OUT
	1239	else:
	1240	cls = Char_and_Length
	1241
	1242
	1243	cls = cls(
	1244	previous.name,
	1245	previous.type,
	1246	name, type)
	1247
	1248	self.args[-1] = cls
	1249
	1250	return
	1251	except IndexError:
	1252	pass
	1253
	1254	self.args.append(t)
	1255
	1256	def comment(self):
	1257	result = self.return_type.original_type+" "+self.class_name+"."+self.name+"("
	1258	args = []
	1259	for type in self.args:
	1260	args.append( type.comment())
	1261
	1262	result += ",".join(args) + ");\n"
	1263
	1264	return result
	1265
	1266	def prototype(self, out):
	1267	self._prototype(out)
	1268	out.write(";\n")
	1269
	1270	def _prototype(self, out):
	1271	out.write("""static PyObject py%(class_name)s_%(method)s(py%(class_name)s self, PyObject args, PyObject kwds) """ % dict(method = self.name, class_name = self.class_name))
	1272
	1273	def __str__(self):
	1274	result = "def %s %s(%s):" % (
	1275	self.return_type,
	1276	self.name, ' , '.join([a.__str__() for a in self.args]))
	1277	return result
	1278
	1279	def PyMethodDef(self, out):
	1280	docstring = self.comment() + "\n\n" + self.docstring
	1281	out.write(' {"%s",(PyCFunction)py%s_%s, METH_VARARGS\|METH_KEYWORDS, "%s"},\n' % (
	1282	self.name,
	1283	self.class_name,
	1284	self.name, escape_for_string(docstring)))
	1285
	1286	class IteratorMethod(Method):
	1287	""" A Method which implements an iterator """
	1288	def __init__(self, args, *kw):
	1289	Method.__init__(self, args, *kw)
	1290
	1291	## Tell the return type that a NULL python return is ok
	1292	self.return_type.attributes.add("NULL_OK")
	1293
	1294	def _prototype(self, out):
	1295	out.write("""static PyObject py%(class_name)s_%(method)s(py%(class_name)s self)""" % dict(method = self.name, class_name = self.class_name))
	1296
	1297	def __str__(self):
	1298	result = "Iterator returning %s." % (
	1299	self.return_type)
	1300	return result
	1301
	1302	def PyMethodDef(self, out):
	1303	## This method should not go in the method table as its linked
	1304	## in directly
	1305	pass
	1306
	1307	class SelfIteratorMethod(IteratorMethod):
	1308	def write_definition(self, out):
	1309	args = dict(method = self.name, class_name = self.class_name)
	1310	out.write("\n/********************************************************\nAutogenerated wrapper for function:\n")
	1311	out.write(self.comment())
	1312	out.write("********************************************************/\n")
	1313
	1314	self._prototype(out)
	1315	out.write("""{
	1316	((%(class_name)s)self->base)->%(method)s((%(class_name)s)self->base);
	1317	return PyObject_SelfIter((PyObject *)self);
[198]	1318	}
[196]	1319	""" % args)
	1320
	1321	class ConstructorMethod(Method):
	1322	## Python constructors are a bit different than regular methods
	1323	def _prototype(self, out):
	1324	out.write("""
	1325	static int py%(class_name)s_init(py%(class_name)s self, PyObject args, PyObject *kwds)
	1326	""" % dict(method = self.name, class_name = self.class_name))
	1327
	1328	def write_destructor(self, out):
	1329	## We make sure that we unlink exactly the reference we need
	1330	## (the object will persist if it has some other
	1331	## references). Note that if we just used talloc_free here it
	1332	## will remove some random reference which may not actually be
	1333	## the reference we own (which is NULL).
	1334	free = """
	1335	if(self->base) {
	1336	//printf("Unlinking %s@%p\\n", NAMEOF(self->base), self->base);
	1337	talloc_free(self->ctx);
	1338	self->base=NULL;
[198]	1339	}
[196]	1340	"""
	1341	out.write("""static void
	1342	%(class_name)s_dealloc(py%(class_name)s *self) {
	1343	%(free)s
	1344	PyObject_Del(self);
[198]	1345	}\n
[196]	1346	""" % dict(class_name = self.class_name, free=free))
	1347
	1348	def error_condition(self):
	1349	return "return -1;";
	1350
	1351	def write_definition(self, out):
	1352	self._prototype(out)
	1353	out.write("""{\n""")
	1354	self.write_local_vars(out)
	1355
	1356	## Precall preparations
	1357	for type in self.args:
	1358	out.write(type.pre_call(self))
	1359
	1360	## Now call the wrapped function
	1361	out.write("\nself->ctx = talloc_strdup(NULL, \"%s\");" % self.class_name)
	1362	out.write("\n ClearError();\nPy_BEGIN_ALLOW_THREADS\nself->base = CONSTRUCT(%s, %s, %s, self->ctx" % (
	1363	self.class_name,
	1364	self.definition_class_name,
	1365	self.name))
	1366	tmp = ''
	1367	for type in self.args:
	1368	tmp += ", " + type.call_arg()
	1369
	1370	self.error_set = True
	1371	out.write("""%s);\nPy_END_ALLOW_THREADS\n
	1372	if(!CheckError(EZero)) {
	1373	char *buffer;
	1374	PyObject *exception = resolve_exception(&buffer);
	1375
	1376	PyErr_Format(exception,
	1377	"%%s", buffer);
	1378	ClearError();
	1379	goto error;
	1380	} else if(!self->base) {
	1381	PyErr_Format(PyExc_IOError, "Unable to construct class %s");
	1382	goto error;
[198]	1383	}
[196]	1384	""" % (tmp, self.class_name))
	1385
	1386	out.write(" return 0;\n");
	1387
	1388	## Write the error part of the function
	1389	if self.error_set:
	1390	out.write("error:\n " + self.error_condition());
	1391
[198]	1392	out.write("\n}\n\n")
[196]	1393
	1394	class GetattrMethod(Method):
	1395	def __init__(self, class_name, base_class_name, myclass):
	1396	self.base_class_name = base_class_name
	1397	self._attributes = []
	1398	self.error_set = True
	1399	self.return_type = Void()
	1400	self.myclass = myclass
	1401	self.rename_class_name(class_name)
	1402
	1403	def add_attribute(self, attr):
	1404	if attr.name:
	1405	self._attributes.append([self.class_name, attr])
	1406
	1407	def rename_class_name(self, new_name):
	1408	""" This allows us to rename the class_name at a later stage.
	1409	Required for late initialization of Structs whose name is not
	1410	know until much later on.
	1411	"""
	1412	self.class_name = new_name
	1413	self.name = "py%s_getattr" % new_name
	1414	for x in self._attributes:
	1415	x[0] = new_name
	1416
	1417	def get_attributes(self):
	1418	for class_name, attr in self._attributes:
	1419	try:
	1420	if not self.myclass.module.classes[attr.type].active:
	1421	continue
	1422	except KeyError: pass
	1423
	1424	yield class_name, attr
	1425
	1426	def __str__(self):
	1427	result = ""
	1428	for class_name, attr in self.get_attributes():
	1429	result += " %s\n" % attr.__str__()
	1430
	1431	return result
	1432
	1433
	1434	def clone(self, class_name):
	1435	result = self.__class__(class_name, self.base_class_name, self.myclass)
	1436	result._attributes = self._attributes[:]
	1437
	1438	return result
	1439
	1440	def prototype(self, out):
	1441	if self.name:
	1442	out.write("""
	1443	static PyObject %(name)s(py%(class_name)s self, PyObject *name);
	1444	""" % self.__dict__)
	1445
	1446	def built_ins(self, out):
	1447	""" check for some built in attributes we need to support """
	1448	out.write(""" if(!strcmp(name, "__members__")) {
	1449	PyObject *result = PyList_New(0);
	1450	PyObject *tmp;
	1451	PyMethodDef *i;
	1452
	1453	if(!result) goto error;
	1454	""")
	1455	## Add attributes
	1456	for class_name, attr in self.get_attributes():
	1457	out.write(""" tmp = PyString_FromString("%(name)s");
	1458	PyList_Append(result, tmp); Py_DECREF(tmp);
	1459	""" % dict(name = attr.name))
	1460
	1461	## Add methods
	1462	out.write("""
	1463
	1464	for(i=%s_methods; i->ml_name; i++) {
	1465	tmp = PyString_FromString(i->ml_name);
	1466	PyList_Append(result, tmp); Py_DECREF(tmp);
[198]	1467	}""" % self.class_name)
[196]	1468
	1469	out.write("""
	1470	return result;
	1471	}\n""")
	1472
	1473	def write_definition(self, out):
	1474	if not self.name: return
	1475	out.write("""
	1476	static PyObject py%(class_name)s_getattr(py%(class_name)s self, PyObject *pyname) {
	1477	char *name;
	1478	// Try to hand it off to the python native handler first
	1479	PyObject result = PyObject_GenericGetAttr((PyObject)self, pyname);
	1480
	1481	if(result) return result;
	1482
	1483	PyErr_Clear();
	1484	// No - nothing interesting was found by python
	1485	name = PyString_AsString(pyname);
	1486
	1487	if(!self->base) return PyErr_Format(PyExc_RuntimeError, "Wrapped object (%(class_name)s.%(name)s) no longer valid");
	1488	if(!name) return NULL;
	1489	""" % self.__dict__)
	1490
	1491	self.built_ins(out)
	1492
	1493	for class_name, attr in self.get_attributes():
	1494	## what we want to assign
	1495	if self.base_class_name:
	1496	call = "(((%s)self->base)->%s)" % (class_name, attr.name)
	1497	else:
	1498	call = "(self->base->%s)" % (attr.name)
	1499
	1500	out.write("""
	1501	if(!strcmp(name, "%(name)s")) {
	1502	PyObject *py_result;
	1503	%(python_def)s
	1504
	1505	%(python_assign)s
	1506	%(python_obj)s
	1507	return py_result;
[198]	1508	}""" % dict(name = attr.name, python_obj = attr.to_python_object(),
[196]	1509	python_assign = attr.assign(call, self),
	1510	python_def = attr.definition(sense='out')))
	1511
	1512	out.write("""
	1513
	1514	return PyObject_GenericGetAttr((PyObject *)self, pyname);
	1515	""" % self.__dict__)
	1516
	1517	## Write the error part of the function
	1518	if self.error_set:
	1519	out.write("error:\n" + self.error_condition());
	1520
	1521	out.write("}\n\n")
	1522
	1523	class ProxiedGetattr(GetattrMethod):
	1524	def built_ins(self,out):
	1525	out.write(""" if(!strcmp(name, "__members__")) {
	1526	PyObject *result;
	1527	PyObject *tmp;
	1528	PyMethodDef *i;
	1529
	1530	PyErr_Clear();
	1531	// Get the list of members from our proxied object
	1532	result = PyObject_GetAttrString(self->base->proxied, name);
	1533	if(!result) goto error;
	1534	""")
	1535	## Add attributes
	1536	for class_name, attr in self.get_attributes():
	1537	out.write(""" tmp = PyString_FromString("%(name)s");
	1538	PyList_Append(result, tmp); Py_DECREF(tmp);
	1539	""" % dict(name = attr.name))
	1540
	1541	## Add methods
	1542	out.write("""
	1543
	1544	for(i=%s_methods; i->ml_name; i++) {
	1545	tmp = PyString_FromString(i->ml_name);
	1546	PyList_Append(result, tmp); Py_DECREF(tmp);
[198]	1547	} """ % self.class_name)
[196]	1548
	1549	out.write("""
	1550	return result;
	1551	}\n""")
	1552
	1553	out.write(""" /** Just try to get the attribute from our proxied object */ {
	1554	PyObject *result = PyObject_GetAttrString(self->base->proxied, name);
	1555	if(result) return result;
[198]	1556	} """)
[196]	1557
	1558	class ProxiedMethod(Method):
	1559	def __init__(self, method, myclass):
	1560	self.name = method.name
	1561	self.method = method
	1562	self.myclass = myclass
	1563	self.class_name = method.class_name
	1564	self.base_class_name = method.base_class_name
	1565	self.args = method.args
	1566	self.definition_class_name = method.definition_class_name
	1567	self.return_type = method.return_type
	1568	self.docstring = "Proxy for %s" % self.name
	1569	self.defaults = {}
	1570	self.exception = None
	1571	self.error_set = False
	1572
	1573	def get_name(self):
	1574	return "py%(class_name)s_%(name)s" % dict(class_name =self.myclass.class_name,
	1575	name = self.name)
	1576
	1577	def _prototype(self, out):
	1578	out.write("""
	1579	static %(return_type)s %(name)s(%(definition_class_name)s self""" % dict(
	1580	return_type = self.return_type.original_type,
	1581	class_name = self.myclass.class_name,
	1582	method = self.name,
	1583	name = self.get_name(),
	1584	definition_class_name = self.definition_class_name))
	1585
	1586	for arg in self.args:
	1587	out.write(", %s" % (arg.comment()))
	1588
	1589	out.write(")")
	1590
	1591	def prototype(self, out):
	1592	self._prototype(out)
	1593	out.write(";\n")
	1594
	1595	def write_definition(self, out):
	1596	self._prototype(out)
	1597	self._write_definition(out)
	1598
	1599	def _write_definition(self, out):
	1600	## We need to grab the GIL before we do anything
	1601	out.write("""{
	1602	//Grab the GIL so we can do python stuff
	1603	PyGILState_STATE gstate;
	1604	gstate = PyGILState_Ensure();
	1605	""")
	1606
	1607	out.write("{\nPyObject *py_result=NULL;\n")
	1608	out.write('PyObject *method_name = PyString_FromString("%s");\n' % self.name)
	1609	out.write(self.return_type.returned_python_definition())
	1610
	1611	for arg in self.args:
	1612	out.write("PyObject *py_%s=NULL;\n" % arg.name)
	1613
	1614	out.write("\n//Obtain python objects for all the args:\n")
	1615	for arg in self.args:
	1616	out.write(arg.to_python_object(result = "py_%s" % arg.name,
	1617	sense='proxied', BORROWED=True))
	1618
[198]	1619	out.write('if(!((%s)self)->proxied) {\n RaiseError(ERuntimeError, "No proxied object in %s"); goto error;\n}\n' % (self.myclass.class_name, self.myclass.class_name))
[196]	1620
	1621	out.write("\n//Now call the method\n")
	1622	out.write("""PyErr_Clear();
	1623	py_result = PyObject_CallMethodObjArgs(((%s)self)->proxied,method_name,""" % self.myclass.class_name)
	1624	for arg in self.args:
	1625	out.write("py_%s," % arg.name)
	1626
	1627	## Sentinal
	1628	self.error_set = True
	1629	out.write("""NULL);
	1630
	1631	/** Check for python errors */
	1632	if(PyErr_Occurred()) {
	1633	PyObject exception_t, exception, *tb;
	1634	PyObject *str;
	1635	char *str_c;
	1636	char *error_str;
	1637	enum _error_type *error_type = aff4_get_current_error(&error_str);
	1638
	1639	// Fetch the exception state and convert it to a string:
	1640	PyErr_Fetch(&exception_t, &exception, &tb);
	1641
	1642	str = PyObject_Repr(exception);
	1643	str_c = PyString_AsString(str);
	1644
	1645	if(str_c) {
	1646	strncpy(error_str, str_c, BUFF_SIZE-1);
	1647	error_str[BUFF_SIZE-1]=0;
	1648	*error_type = ERuntimeError;
[198]	1649	}
[196]	1650	Py_DECREF(str);
	1651	goto error;
[198]	1652	}
[196]	1653
	1654	""");
	1655
	1656	for arg in self.args:
	1657	out.write(arg.python_proxy_post_call())
	1658
	1659	## Now convert the python value back to a value
	1660	out.write(self.return_type.from_python_object('py_result',self.return_type.name, self, context = "self"))
	1661
[198]	1662	out.write("if(py_result) { Py_DECREF(py_result);}\nPy_DECREF(method_name);\n\n");
[196]	1663	out.write("PyGILState_Release(gstate);\n")
	1664
	1665	## Decref all our python objects:
	1666	for arg in self.args:
[198]	1667	out.write("if(py_%s) { Py_DECREF(py_%s);}\n" %( arg.name, arg.name))
[196]	1668
	1669	out.write(self.return_type.return_value('func_return'))
	1670	if self.error_set:
	1671	out.write("\nerror:\n")
[198]	1672	out.write("if(py_result) { Py_DECREF(py_result);}\nPy_DECREF(method_name);\n\n");
[196]	1673	## Decref all our python objects:
	1674	for arg in self.args:
[198]	1675	out.write("if(py_%s) { Py_DECREF(py_%s);}\n" % (arg.name, arg.name))
[196]	1676
	1677	out.write("PyGILState_Release(gstate);\n %s;\n" % self.error_condition())
	1678
[198]	1679	out.write(" }\n}\n")
[196]	1680
	1681	def error_condition(self):
	1682	return self.return_type.error_value
	1683
	1684	class StructConstructor(ConstructorMethod):
	1685	""" A constructor for struct wrappers - basically just allocate
	1686	memory for the struct.
	1687	"""
	1688	def write_definition(self, out):
	1689	out.write("""static int py%(class_name)s_init(py%(class_name)s self, PyObject args, PyObject *kwds) {\n""" % dict(method = self.name, class_name = self.class_name))
	1690	out.write("\nself->ctx = talloc_strdup(NULL, \"%s\");" % self.class_name)
	1691	out.write("\nself->base = talloc(self->ctx, %s);\n" % self.class_name)
[198]	1692	out.write(" return 0;\n}\n\n")
[196]	1693
	1694	def write_destructor(self, out):
	1695	out.write("""static void
	1696	%(class_name)s_dealloc(py%(class_name)s *self) {
	1697	talloc_free(self->ctx);
[198]	1698	}\n
[196]	1699	""" % dict(class_name = self.class_name))
	1700
	1701	class ProxyConstructor(ConstructorMethod):
	1702	def write_destructor(self, out):
	1703	out.write("""static void
	1704	%(class_name)s_dealloc(py%(class_name)s *self) {
	1705	if(self->base) {
	1706	// Release the proxied object
	1707	//Py_DECREF(self->base->proxied);
	1708	talloc_free(self->ctx);
	1709	self->base = NULL;
[198]	1710	}
	1711	}\n
[196]	1712
	1713	static int %(class_name)s_destructor(void *this) {
	1714	py%(class_name)s self = (py%(class_name)s )this;
	1715	Py_DECREF(self->base->proxied);
	1716	return 0;
[198]	1717	}
[196]	1718	""" % dict(class_name = self.class_name))
	1719
	1720	def initialise_attributes(self, out):
	1721	attributes = self.myclass.module.classes[self.base_class_name].attributes.get_attributes()
	1722	for definition_class_name, attribute in attributes:
	1723	out.write("""
	1724	{
	1725	// Converting from %(attribute_name)s
	1726	PyErr_Clear();
	1727	PyObject *py_result = PyObject_GetAttrString(self->base->proxied, "%(name)s");
	1728
	1729	if(py_result) {
	1730	%(type)s tmp;
	1731	%(from_python_object)s;
	1732	((%(definition_class_name)s)self->base)->%(name)s = tmp;
	1733	Py_DECREF(py_result);
[198]	1734	}
[196]	1735	PyErr_Clear();
[198]	1736	}""" % dict(definition = attribute.definition(), name=attribute.name,
[196]	1737	attribute_name = attribute.__class__.__name__,
	1738	type = attribute.type,
	1739	definition_class_name = definition_class_name,
	1740	from_python_object = attribute.from_python_object(
	1741	'py_result',"tmp", method=self,
	1742	context = 'self->base')))
	1743
	1744
	1745	def write_constructor_proxy(self, out):
	1746	## Get the base_class constructor
	1747	self.base_cons_method = ProxiedMethod(self.myclass.module.classes[self.base_class_name].constructor, self.myclass)
	1748
	1749	self.base_cons_method._prototype(out)
	1750	out.write("{\nPyObject *py_result;\n")
	1751	out.write('PyObject *method_name;')
	1752	out.write("%(class_name)s this = (%(class_name)s)self;\n" % self.__dict__)
	1753	out.write("PyGILState_STATE gstate;\ngstate = PyGILState_Ensure();\n")
	1754	out.write('method_name = PyString_FromString("__class__");\n')
	1755	for arg in self.base_cons_method.args:
	1756	out.write("PyObject *py_%s;\n" % arg.name)
	1757
	1758	out.write("\n//Obtain python objects for all the args:\n")
	1759	for arg in self.base_cons_method.args:
	1760	out.write(arg.to_python_object(result = "py_%s" % arg.name,
	1761	sense = 'proxied',
	1762	BORROWED=True))
	1763
[198]	1764	out.write('if(!((%s)self)->proxied) {\n RaiseError(ERuntimeError, "No proxied object in %s"); goto error;\n}\n' % (self.myclass.class_name, self.myclass.class_name))
[196]	1765
	1766	out.write("""
	1767	// Enlarge the object size to accomodate the extended class
	1768	self = talloc_realloc_size(self, self, sizeof(struct %(base_class_name)s_t));
	1769	""" % self.__dict__)
	1770	out.write("\n//Now call the method\n")
	1771	out.write("PyErr_Clear();\npy_result = PyObject_CallMethodObjArgs(((%s)self)->proxied,method_name," % self.myclass.class_name)
	1772
	1773	call = ''
	1774	for arg in self.base_cons_method.args:
	1775	call += "py_%s," % arg.name
	1776
	1777	## Sentinal
	1778	self.error_set = True
	1779	call += """NULL"""
	1780
	1781	out.write(call + ");\n");
	1782	out.write("""
	1783	if(!py_result && PyCallable_Check(this->proxied)) {
	1784	PyErr_Clear();
	1785	py_result = PyObject_CallFunctionObjArgs(((%(name)s)self)->proxied, %(call)s);
[198]	1786	}
[196]	1787
	1788	/** Check for python errors */
	1789	if(PyErr_Occurred()) {
	1790	PyObject exception_t, exception, *tb;
	1791	PyObject *str;
	1792	char *str_c;
	1793	char *error_str;
	1794	enum _error_type *error_type = aff4_get_current_error(&error_str);
	1795
	1796	// Fetch the exception state and convert it to a string:
	1797	PyErr_Fetch(&exception_t, &exception, &tb);
	1798
	1799	str = PyObject_Repr(exception);
	1800	str_c = PyString_AsString(str);
	1801
	1802	if(str_c) {
	1803	strncpy(error_str, str_c, BUFF_SIZE-1);
	1804	error_str[BUFF_SIZE-1]=0;
	1805	*error_type = ERuntimeError;
[198]	1806	}
[196]	1807	Py_DECREF(str);
	1808	goto error;
[198]	1809	}
[196]	1810
	1811	// Take over the proxied object now
	1812	this->proxied = py_result;
	1813	""" % dict(name=self.myclass.class_name, call = call));
	1814
	1815	## Now we try to populate the C struct slots with proxies of
	1816	## the python objects
	1817	for class_name, attr in self.myclass.module.classes[\
	1818	self.base_class_name].attributes.get_attributes():
	1819	out.write("""
	1820	// Converting %(name)s from proxy:
	1821	{
	1822	PyObject *py_result = PyObject_GetAttrString(this->proxied, "%(name)s");
	1823	if(py_result) {
	1824	""" % dict(name = attr.name))
	1825	out.write("{ %s " % attr.definition())
	1826	out.write(attr.from_python_object("py_result",
	1827	"((%s)self)->%s" % (class_name, attr.name),
	1828	self))
[198]	1829	out.write("}\nPy_DECREF(py_result);\n}\n}\n")
[196]	1830
	1831	out.write("PyGILState_Release(gstate);\n")
	1832	out.write("\n\nreturn self;\n")
	1833	if self.error_set:
	1834	out.write("error:\n PyGILState_Release(gstate);\ntalloc_free(self); return NULL;\n")
	1835
[198]	1836	out.write("}\n\n")
[196]	1837
	1838	def write_definition(self, out):
	1839	self.write_constructor_proxy(out)
	1840	out.write("""static int py%(class_name)s_init(py%(class_name)s self, PyObject args, PyObject *kwds) {
	1841	PyGILState_STATE gstate = PyGILState_Ensure();
	1842	""" % dict(method = self.name, class_name = self.class_name))
	1843
	1844	self.write_local_vars(out)
	1845
	1846	## Precall preparations
	1847	for type in self.args:
	1848	out.write(type.pre_call(self))
	1849
	1850	## Make up the call
	1851	self.call = "talloc_memdup(NULL, &__%(class_name)s, sizeof(__%(class_name)s));\n" % self.__dict__
	1852
	1853	## Now call the wrapped function
	1854	out.write("""
	1855	self->base = %(call)s
	1856
	1857	// Take over a copy of the proxied object
	1858	self->base->proxied = proxied;
	1859
	1860	/* We take a reference to the proxied object, and the proxied base
	1861	class takes a reference. This way we (the python object) and the
	1862	proxied C class can be freed independantly and only when both are
	1863	freed the proxied object is freed. */
	1864
	1865	//Py_INCREF(proxied);
	1866	Py_INCREF(proxied);
	1867	talloc_set_destructor((void*)self->base, %(class_name)s_destructor);
	1868	""" % self.__dict__)
	1869
	1870	## Install the handler for the constructor. FIXME - implement
	1871	## shortcut bypassing here so if the proxied class is itself a
	1872	## python binding to a C class and it does not override
	1873	## anything, we call directly into the original C class method
	1874	## instead of converting to python, and back.
	1875	out.write("((%(definition_class_name)s)self->base)->%(name)s = %(func)s;\n" % dict(
	1876	definition_class_name = self.base_cons_method.definition_class_name,
	1877	name = self.base_cons_method.name,
	1878	func = self.base_cons_method.get_name()))
	1879
	1880	## Now iterate over all our methods and install handlers:
	1881	for method in self.myclass.methods:
	1882	out.write("""
	1883	if(1 \|\| PyDict_GetItemString(proxied->ob_type->tp_dict, "%(name)s")) {
	1884	((%(definition_class_name)s)self->base)->%(name)s = py%(class_name)s_%(name)s;
[198]	1885	}
[196]	1886	""" % dict(definition_class_name = method.definition_class_name,
	1887	name = method.name,
	1888	class_name = self.myclass.class_name))
	1889
	1890	## Now fill in all attributes from the proxied object. Since
	1891	## the C struct attribute access is just memory access its
	1892	## difficult to trap it and refill attributes dynamically from
	1893	## the python object. Therefore for now we just read all
	1894	## attributes initially and populate the C struct with them.
	1895	self.initialise_attributes(out)
	1896
	1897	out.write("\n PyGILState_Release(gstate);\n return 0;\n");
	1898
	1899	## Write the error part of the function
	1900	if self.error_set:
	1901	out.write("error:\n PyGILState_Release(gstate);\n " + self.error_condition());
	1902
[198]	1903	out.write("\n}\n\n")
[196]	1904
	1905	class EmptyConstructor(ConstructorMethod):
	1906	def write_definition(self, out):
	1907	out.write("""static int py%(class_name)s_init(py%(class_name)s self, PyObject args, PyObject *kwds) {\n""" % dict(method = self.name, class_name = self.class_name))
[198]	1908	out.write("""return 0;}\n\n""")
[196]	1909
	1910	class ClassGenerator:
	1911	docstring = ''
	1912	def __init__(self, class_name, base_class_name, module):
	1913	self.class_name = class_name
	1914	self.methods = []
	1915	self.module = module
	1916	self.constructor = EmptyConstructor(class_name, base_class_name,
	1917	"Con", [], '', myclass = self)
	1918
	1919	self.base_class_name = base_class_name
	1920	self.attributes = GetattrMethod(self.class_name, self.base_class_name, self)
	1921	self.modifier = set()
	1922	self.active = True
	1923	self.iterator = None
	1924
	1925	def prepare(self):
	1926	""" This method is called just before we need to write the
	1927	output and allows us to do any last minute fixups.
	1928	"""
	1929	pass
	1930
	1931	def __str__(self):
	1932	result = "#%s\n" % self.docstring
	1933
	1934	result += "Class %s(%s):\n" % (self.class_name, self.base_class_name)
	1935	result += " Constructor:%s\n" % self.constructor
	1936	result += " Attributes:\n%s\n" % self.attributes
	1937	result += " Methods:\n"
	1938	for a in self.methods:
	1939	result += " %s\n" % a.__str__()
	1940
	1941	return result
	1942
	1943	def is_active(self):
	1944	""" Returns true if this class is active and should be generated """
	1945	if not self.active or self.modifier and \
	1946	('PRIVATE' in self.modifier or 'ABSTRACT' in self.modifier):
	1947	log("%s is not active %s" % (self.class_name, self.modifier))
	1948	return False
	1949
	1950	return True
	1951
	1952	def clone(self, new_class_name):
	1953	""" Creates a clone of this class - usefull when implementing
	1954	class extensions
	1955	"""
	1956	result = ClassGenerator(new_class_name, self.class_name, self.module)
	1957	result.constructor = self.constructor.clone(new_class_name)
	1958	result.methods = [ x.clone(new_class_name) for x in self.methods ]
	1959	result.attributes = self.attributes.clone(new_class_name)
	1960
	1961	return result
	1962
	1963	def add_attribute(self, attr_name, attr_type, modifier):
	1964	try:
	1965	if not self.module.classes[attr_type].is_active(): return
	1966	except KeyError: pass
	1967
	1968	try:
	1969	## All attribute references are always borrowed - that
	1970	## means we dont want to free them after accessing them
	1971	type_class = dispatch(attr_name, "BORROWED "+attr_type)
	1972	except KeyError:
	1973	log("Unknown attribute type %s for %s.%s" % (attr_type,
	1974	self.class_name,
	1975	attr_name))
	1976	return
	1977
	1978	type_class.attributes.add(modifier)
	1979	self.attributes.add_attribute(type_class)
	1980
	1981	def add_constructor(self, method_name, args, return_type, docstring):
	1982	if method_name.startswith("Con"):
	1983	self.constructor = ConstructorMethod(self.class_name, self.base_class_name,
	1984	method_name, args, return_type,
	1985	myclass = self)
	1986	self.constructor.docstring = docstring
	1987
	1988	def struct(self,out):
	1989	out.write("""\ntypedef struct {
	1990	PyObject_HEAD
	1991	%(class_name)s base;
	1992	void *ctx;
	1993	} py%(class_name)s;\n
	1994	""" % dict(class_name=self.class_name))
	1995
	1996	def code(self, out):
	1997	if not self.constructor:
	1998	raise RuntimeError("No constructor found for class %s" % self.class_name)
	1999
	2000	self.constructor.write_destructor(out)
	2001	self.constructor.write_definition(out)
	2002	if self.attributes:
	2003	self.attributes.write_definition(out)
	2004
	2005	for m in self.methods:
	2006	m.write_definition(out)
	2007
	2008	def initialise(self):
	2009	return "python_wrappers[TOTAL_CLASSES].class_ref = (Object)&__%s;\n" \
	2010	"python_wrappers[TOTAL_CLASSES++].python_type = &%s_Type;\n" % (
	2011	self.class_name, self.class_name)
	2012
	2013	def PyMethodDef(self, out):
	2014	out.write("static PyMethodDef %s_methods[] = {\n" % self.class_name)
	2015	for method in self.methods:
	2016	method.PyMethodDef(out)
	2017
	2018	out.write(" {NULL} /* Sentinel */\n};\n")
	2019
	2020	def prototypes(self, out):
	2021	""" Write prototype suitable for .h file """
	2022	out.write("""staticforward PyTypeObject %s_Type;\n""" % self.class_name)
	2023	self.constructor.prototype(out)
	2024
	2025	if self.attributes:
	2026	self.attributes.prototype(out)
	2027	for method in self.methods:
	2028	method.prototype(out)
	2029
	2030	def numeric_protocol_int(self):
	2031	pass
	2032
	2033	def numeric_protocol_nonzero(self):
	2034	return """
	2035	static int
	2036	%(class_name)s_nonzero(py%(class_name)s *v)
	2037	{
	2038	return v->base != 0;
[198]	2039	}
[196]	2040	""" % self.__dict__
	2041
	2042	def numeric_protocol(self, out):
	2043	args = {'class':self.class_name}
	2044	for type, func in [ ('nonzero', self.numeric_protocol_nonzero),
	2045	('int', self.numeric_protocol_int) ]:
	2046	definition = func()
	2047	if definition:
	2048	out.write(definition)
	2049	args[type] = "%s_%s" % (self.class_name,type)
	2050	else:
	2051	args[type] = '0'
	2052
	2053	out.write("""
	2054	static PyNumberMethods %(class)s_as_number = {
	2055	(binaryfunc) 0, /nb_add/
	2056	(binaryfunc) 0, /nb_subtract/
	2057	(binaryfunc) 0, /nb_multiply/
	2058	0, /nb_divide/
	2059	0, /nb_remainder/
	2060	0, /nb_divmod/
	2061	0, /nb_power/
	2062	(unaryfunc) 0, /nb_negative/
	2063	(unaryfunc) 0, /tp_positive/
	2064	(unaryfunc) 0, /tp_absolute/
	2065	(inquiry) %(nonzero)s, /tp_nonzero/
	2066	(unaryfunc) 0, /nb_invert/
	2067	0, /nb_lshift/
	2068	(binaryfunc) 0, /nb_rshift/
	2069	0, /nb_and/
	2070	0, /nb_xor/
	2071	0, /nb_or/
	2072	0, /nb_coerce/
	2073	(unaryfunc) %(int)s, /nb_int/
	2074	0, /nb_long/
	2075	0, /nb_float/
	2076	0, /nb_oct/
	2077	0, /nb_hex/
	2078	0, /* nb_inplace_add */
	2079	0, /* nb_inplace_subtract */
	2080	0, /* nb_inplace_multiply */
	2081	0, /* nb_inplace_divide */
	2082	0, /* nb_inplace_remainder */
	2083	0, /* nb_inplace_power */
	2084	0, /* nb_inplace_lshift */
	2085	0, /* nb_inplace_rshift */
	2086	0, /* nb_inplace_and */
	2087	0, /* nb_inplace_xor */
	2088	0, /* nb_inplace_or */
	2089	0, /* nb_floor_divide */
	2090	0, /* nb_true_divide */
	2091	0, /* nb_inplace_floor_divide */
	2092	0, /* nb_inplace_true_divide */
	2093	0, /* nb_index */
	2094	};
	2095	""" % args)
	2096	return "&%(class)s_as_number" % args
	2097
	2098	def PyTypeObject(self, out):
	2099	args = {'class':self.class_name, 'module': self.module.name,
	2100	'iterator': 0,
	2101	'iternext': 0,
	2102	'tp_str': 0,
	2103	'getattr_func': 0,
	2104	'docstring': "%s: %s" % (self.class_name,
	2105	escape_for_string(self.docstring))}
	2106
	2107	if self.attributes:
	2108	args['getattr_func'] = self.attributes.name
	2109
	2110	args['numeric_protocol'] = self.numeric_protocol(out)
	2111	if "ITERATOR" in self.modifier:
	2112	args['iterator'] = "PyObject_SelfIter"
	2113	args['iternext'] = "py%s_iternext" % self.class_name
	2114
	2115	if "SELF_ITER" in self.modifier:
	2116	args['iterator'] = 'py%s___iter__' % self.class_name
	2117
	2118	if "TP_STR" in self.modifier:
	2119	args['tp_str'] = 'py%s___str__' % self.class_name
	2120
	2121	out.write("""
	2122	static PyTypeObject %(class)s_Type = {
	2123	PyObject_HEAD_INIT(NULL)
	2124	0, /* ob_size */
	2125	"%(module)s.%(class)s", /* tp_name */
	2126	sizeof(py%(class)s), /* tp_basicsize */
	2127	0, /* tp_itemsize */
	2128	(destructor)%(class)s_dealloc,/* tp_dealloc */
	2129	0, /* tp_print */
	2130	0, /* tp_getattr */
	2131	0, /* tp_setattr */
	2132	0, /* tp_compare */
	2133	0, /* tp_repr */
	2134	%(numeric_protocol)s, /* tp_as_number */
	2135	0, /* tp_as_sequence */
	2136	0, /* tp_as_mapping */
	2137	0, /* tp_hash */
	2138	0, /* tp_call */
	2139	(reprfunc)%(tp_str)s, /* tp_str */
	2140	(getattrofunc)%(getattr_func)s, /* tp_getattro */
	2141	0, /* tp_setattro */
	2142	0, /* tp_as_buffer */
	2143	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
	2144	"%(docstring)s", /* tp_doc */
	2145	0, /* tp_traverse */
	2146	0, /* tp_clear */
	2147	0, /* tp_richcompare */
	2148	0, /* tp_weaklistoffset */
	2149	(getiterfunc)%(iterator)s, /* tp_iter */
	2150	(iternextfunc)%(iternext)s,/* tp_iternext */
	2151	%(class)s_methods, /* tp_methods */
	2152	0, /* tp_members */
	2153	0, /* tp_getset */
	2154	0, /* tp_base */
	2155	0, /* tp_dict */
	2156	0, /* tp_descr_get */
	2157	0, /* tp_descr_set */
	2158	0, /* tp_dictoffset */
	2159	(initproc)py%(class)s_init, /* tp_init */
	2160	0, /* tp_alloc */
	2161	0, /* tp_new */
	2162	};
	2163	""" % args )
	2164
	2165	class StructGenerator(ClassGenerator):
	2166	""" A wrapper generator for structs """
	2167	def __init__(self, class_name, module):
	2168	self.class_name = class_name
	2169	self.methods = []
	2170	self.module = module
	2171	self.base_class_name = None
	2172	self.active = False
	2173	self.modifier = set()
	2174	self.constructor = None
	2175	self.attributes = GetattrMethod(self.class_name, self.base_class_name, self)
	2176
	2177	def prepare(self):
	2178	## This is needed for late stage initialization - sometimes
	2179	## our class_name is not know until now.
	2180	if not self.constructor:
	2181	self.constructor = StructConstructor(self.class_name, self.base_class_name,
	2182	'Con', [], "void", myclass = self)
	2183
	2184	self.attributes.rename_class_name(self.class_name)
	2185	for x in self.attributes._attributes:
	2186	x[1].attributes.add('FOREIGN')
	2187
	2188	def __str__(self):
	2189	result = "#%s\n" % self.docstring
	2190
	2191	result += "Struct %s:\n" % (self.class_name)
	2192	result += "%s\n" % self.attributes
	2193
	2194	return result
	2195
	2196	def struct(self, out):
	2197	out.write("""\ntypedef struct {
	2198	PyObject_HEAD
	2199	%(class_name)s *base;
	2200	void *ctx;
	2201	} py%(class_name)s;\n
	2202	""" % dict(class_name=self.class_name))
	2203
	2204	def initialise(self):
	2205	return ''
	2206
	2207	class ProxyClassGenerator(ClassGenerator):
	2208	def __init__(self, class_name, base_class_name, module, args, *kwargs):
	2209	ClassGenerator.__init__(self, class_name, base_class_name, module, args, *kwargs)
	2210	self.constructor = ProxyConstructor(self.class_name,
	2211	self.base_class_name, '__init__',
	2212	[('PyObject *', 'proxied')],
	2213	'void', myclass = self)
	2214	self.module = module
	2215	self.attributes = ProxiedGetattr(self.class_name, self.base_class_name, self)
	2216
	2217
	2218	def initialise(self):
	2219	return "INIT_CLASS(%(class_name)s);\n" % self.__dict__ + ClassGenerator.initialise(self)
	2220
	2221	def struct(self, out):
	2222	out.write("""
	2223	// The proxied type is an extension of the wrapped type with a pointer
	2224	// to the proxied PyObject.
	2225	CLASS(%(class_name)s, %(base_class_name)s)
	2226	uint32_t magic;
	2227	PyObject *proxied;
	2228	END_CLASS
	2229
	2230	VIRTUAL(%(class_name)s, %(base_class_name)s) {
	2231	} END_VIRTUAL
	2232
	2233	typedef struct {
	2234	PyObject_HEAD
	2235	%(class_name)s base;
	2236	void *ctx;
	2237	} py%(class_name)s;\n
	2238	""" % self.__dict__)
	2239
	2240	def PyMethodDef(self, out):
	2241	out.write("static PyMethodDef %s_methods[] = {\n" % self.class_name)
	2242	## For now no methods
	2243	out.write(" {NULL} /* Sentinel */\n};\n")
	2244
	2245	class parser:
	2246	class_re = re.compile(r"^([A-Z]+)?\sCLASS\(([A-Z_a-z0-9]+)\s,\s*([A-Z_a-z0-9]+)\)")
	2247	method_re = re.compile(r"^\s([0-9A-Z_a-z ]+\s+\?)METHOD\(([A-Z_a-z0-9]+),\s*([A-Z_a-z0-9]+),?")
	2248	enum_start_re = re.compile(r'enum ([0-9A-Z_a-z]+) {')
	2249	enum_re = re.compile(r'([0-9A-Z_a-z]+) = [^,]+,')
	2250	enum_end_re = re.compile('}')
	2251	arg_re = re.compile(r"\s([0-9A-Z a-z_]+\s+\?)([0-9A-Za-z_]+),?")
	2252	constant_re = re.compile(r"#define\s+([A-Z_0-9]+)\s+[^\s]+")
	2253	struct_re = re.compile(r"([A-Z]+)?\s+(typedef )?struct\s+([A-Z_a-z0-9]+)\s+{")
	2254	proxy_class_re = re.compile(r"^([A-Z]+)?\s*PROXY_CLASS\(([A-Za-z0-9]+)\)")
	2255	end_class_re = re.compile("END_CLASS")
	2256	attribute_re = re.compile(r"^\s([0-9A-Z_a-z ]+\s+\?)\s([A-Z_a-z]+)\s;")
	2257	comment_re = re.compile(r"^\s*//")
	2258	comment_start_re = re.compile(r"/\*+")
	2259	comment_end_re = re.compile(r"\*+/")
	2260	blank_line_re = re.compile("\s+")
	2261	typedef_re = re.compile("typedef ([A-Za-z_0-9]+) +([A-Za-z_0-9]+) *;")
	2262	bind_re = re.compile("BIND\(([a-zA-Z_0-9]+)\);")
	2263	current_class = None
	2264
	2265	def __init__(self, module, verbosity=0):
	2266	self.module = module
	2267	self.current_comment = ''
	2268	self.verbosity = verbosity
	2269	self.state = 'DEFAULT'
	2270
	2271	## this is a list of objects which are to be bound
	2272	self.to_bind = []
	2273
	2274	global DEBUG
	2275
	2276	DEBUG = verbosity
	2277
	2278	io = StringIO.StringIO("""
	2279	// Base object
	2280	CLASS(Object, Obj)
	2281	END_CLASS
	2282	""")
	2283	self.parse_fd(io, '')
	2284
	2285	def add_class(self, class_name, base_class_name, class_type, handler, docstring, modifier):
	2286	try:
	2287	self.current_class = self.module.classes[base_class_name].clone(class_name)
	2288	except (KeyError, AttributeError):
	2289	log("Base class %s is not defined !!!!" % base_class_name)
	2290	self.current_class = class_type(class_name, base_class_name, self.module)
	2291
	2292	## Now add the new class to the module object
	2293	self.current_class.docstring = docstring
	2294	self.current_class.modifier = modifier
	2295	self.module.add_class(self.current_class, handler)
	2296
	2297	def parse_filenames(self, filenames):
	2298	## Be quiet for the first pass as many problems will be
	2299	## resolved on the second pass anyway.
	2300	global DEBUG
	2301	DEBUG = 0
	2302	for f in filenames:
	2303	self._parse(f)
	2304
	2305	DEBUG = self.verbosity
	2306	log("Second pass: Consolidating definitions")
	2307	for f in filenames:
	2308	self._parse(f)
	2309
	2310	def _parse(self, filename):
	2311	fd = open(filename)
	2312	self.parse_fd(fd, filename)
	2313	fd.close()
	2314
	2315	if filename not in self.module.files:
	2316	self.module.headers += '#include "%s"\n' % filename
	2317	self.module.files.append(filename)
	2318
	2319	def parse_fd(self, fd, filename):
	2320	self.current_class = None
	2321	self.current_comment = ''
	2322
	2323	while 1:
	2324	line = fd.readline()
	2325	if not line: break
	2326
	2327	## Handle binds
	2328	m= self.bind_re.search(line)
	2329	if m:
	2330	print "Will bind %s" % m.group(1)
	2331	self.to_bind.append(m.group(1))
	2332	continue
	2333
	2334	## Handle enums
	2335	if self.state == 'DEFAULT':
	2336	m = self.enum_start_re.search(line)
	2337	if m:
	2338	self.state = 'enum'
	2339	type_dispatcher[m.group(1)] = type_dispatcher['int']
	2340	continue
	2341
	2342	elif self.state == 'enum':
	2343	m = self.enum_re.search(line)
	2344	if m:
	2345	self.module.add_constant(m.group(1), 'integer')
	2346
	2347	if '}' in line:
	2348	self.state = 'DEFAULT'
	2349	continue
	2350
	2351	## Handle c++ style comments //
	2352	m = self.comment_re.match(line)
	2353	if m:
	2354	self.current_comment = line[m.end():]
	2355	while 1:
	2356	line = fd.readline()
	2357
	2358	m = self.comment_re.match(line)
	2359	if not m:
	2360	break
	2361
	2362	self.current_comment += line[m.end():]
	2363
	2364	## Multiline C style comments
	2365	m = self.comment_start_re.search(line)
	2366	if m:
	2367	line = line[m.end():]
	2368	while 1:
	2369	m = self.comment_end_re.search(line)
	2370	if m:
	2371	self.current_comment += line[:m.start()]
	2372	line = fd.readline()
	2373	break
	2374	else:
	2375	self.current_comment += line
	2376
	2377	line = fd.readline()
	2378	if not line: break
	2379
	2380	## Handle simple typdefs (as if typedef uint64_t my_fancy_type;)
	2381	m = self.typedef_re.search(line)
	2382	if m:
	2383	## We basically add a new type as a copy of the old
	2384	## type
	2385	old, new = m.group(1), m.group(2)
	2386	if old in type_dispatcher:
	2387	type_dispatcher[new] = type_dispatcher[old]
	2388
	2389	## Handle constant #define
	2390	m = self.constant_re.search(line)
	2391	if m:
	2392	## We need to determine if it is a string or integer
	2393	if re.search('"', line):
	2394	## Its a string
	2395	self.module.add_constant(m.group(1), 'string')
	2396	else:
	2397	self.module.add_constant(m.group(1), 'integer')
	2398
	2399	## Wrap structs
	2400	m = self.struct_re.search(line)
	2401	if m:
	2402	modifier = m.group(1)
	2403	class_name = m.group(3)
	2404	base_class_name = None
	2405	## Structs may be refered to as a pointer or absolute
	2406	## - its the same thing ultimatley.
	2407
	2408	## We only wrap structures which are explicitely bound
	2409	if (modifier and 'BOUND' in modifier) or \
	2410	class_name in self.to_bind:
	2411	self.add_class(class_name, base_class_name, StructGenerator, StructWrapper,
	2412	self.current_comment, modifier)
	2413	type_dispatcher["%s *" % class_name] = PointerStructWrapper
	2414
	2415	continue
	2416
	2417	m = self.class_re.search(line)
	2418	if m:
	2419	## We need to make a new class now... We basically
	2420	## need to build on top of previously declared base
	2421	## classes - so we try to find base classes, clone
	2422	## them if possible:
	2423	modifier = m.group(1)
	2424	class_name = m.group(2)
	2425	base_class_name = m.group(3)
	2426	self.add_class(class_name, base_class_name, ClassGenerator, Wrapper,
	2427	self.current_comment, modifier)
	2428	type_dispatcher["%s *" % class_name] = PointerWrapper
	2429
	2430	continue
	2431
	2432	## Make a proxy class for python callbacks
	2433	m = self.proxy_class_re.search(line)
	2434	if m:
	2435	modifier = m.group(1)
	2436	base_class_name = m.group(2)
	2437	class_name = "Proxied%s" % base_class_name
	2438	try:
	2439	proxied_class = self.module.classes[base_class_name]
	2440	except KeyError:
	2441	raise RuntimeError("Need to create a proxy for %s but it has not been defined (yet). You must place the PROXIED_CLASS() instruction after the class definition" % base_class_name)
	2442	self.current_class = ProxyClassGenerator(class_name,
	2443	base_class_name, self.module)
	2444	#self.current_class.constructor.args += proxied_class.constructor.args
	2445	self.current_class.docstring = self.current_comment
	2446
	2447	## Create proxies for all these methods
	2448	for method in proxied_class.methods:
	2449	self.current_class.methods.append(ProxiedMethod(method, self.current_class))
	2450
	2451	self.module.add_class(self.current_class, Wrapper)
	2452
	2453	## Make sure that further lines are not interpreted as part of this class.
	2454	self.current_class = None
	2455
	2456	m = self.method_re.search(line)
	2457	if self.current_class and m:
	2458	args = []
	2459	method_name = m.group(3)
	2460	return_type = m.group(1).strip()
	2461	## Ignore private methods
	2462	if return_type.startswith("PRIVATE"): continue
	2463
	2464	## Now parse the args
	2465	offset = m.end()
	2466	while 1:
	2467	m = self.arg_re.match(line[offset:])
	2468	if not m:
	2469	## Allow multiline definitions if there is \\
	2470	## at the end of the line
	2471	if line.strip().endswith("\\"):
	2472	line = fd.readline()
	2473	offset = 0
	2474	if line:
	2475	continue
	2476
	2477	break
	2478
	2479	offset += m.end()
	2480	args.append([m.group(1).strip(), m.group(2).strip()])
	2481
	2482	if return_type == self.current_class.class_name and \
	2483	method_name.startswith("Con"):
	2484	self.current_class.add_constructor(method_name, args, return_type,
	2485	self.current_comment)
	2486	else:
	2487	self.current_class.add_method(method_name, args, return_type,
	2488	self.current_comment)
	2489
	2490	m = self.attribute_re.search(line)
	2491	if self.current_class and m:
	2492	type = m.group(1)
	2493	name = m.group(2)
	2494	self.current_class.add_attribute(name, type)
	2495
	2496	m = self.end_class_re.search(line)
	2497	if m:
	2498	## Just clear the current class context
	2499	self.current_class = None
	2500
	2501	## If this is a shadow file we do not include it from the
	2502	## main module. A shadow file is a way for us to redefine
	2503	## other C constructs which will be imported from an
	2504	## external header file so we can bind them slightly
	2505	## differently.
	2506	if "this is a shadow file" in self.current_comment \
	2507	and filename not in self.module.files:
	2508	self.module.files.append(filename)
	2509
	2510	## We only care about comment immediately above methods
	2511	## etc as we take them to be documentation. If we get here
	2512	## the comment is not above anything we care about - so we
	2513	## clear it:
	2514	self.current_comment = ''
	2515
	2516	def write(self, out):
	2517	self.module.write(out)
	2518
	2519
	2520	import lexer
	2521
	2522	class EnumConstructor(ConstructorMethod):
	2523	def write_destructor(self, out):
	2524	out.write("""static void
	2525	%(class_name)s_dealloc(py%(class_name)s *self) {
	2526	Py_DECREF(self->value);
	2527	PyObject_Del(self);
[198]	2528	}\n
[196]	2529	""" % dict(class_name = self.class_name))
	2530	def write_definition(self, out):
	2531	self.myclass.modifier.add("TP_STR")
	2532	self._prototype(out)
	2533	out.write("""{
	2534	static char *kwlist[] = {"value", NULL};
	2535
	2536	if(!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &self->value))
	2537	goto error;
	2538
	2539	Py_INCREF(self->value);
	2540
	2541	return 0;
	2542	error:
	2543	return -1;
[198]	2544	}
[196]	2545
	2546	static PyObject py%(class_name)s___str__(py%(class_name)s self) {
	2547	PyObject *result = PyDict_GetItem(%(class_name)s_rev_lookup, self->value);
	2548
	2549	if(result) {
	2550	Py_INCREF(result);
	2551	} else {
	2552	result = PyObject_Str(self->value);
[198]	2553	}
[196]	2554
	2555	return result;
[198]	2556	}
[196]	2557
	2558	""" % self.__dict__)
	2559
	2560	class Enum(StructGenerator):
	2561	def __init__(self, name, module):
	2562	StructGenerator.__init__(self, name, module)
	2563	self.values = []
	2564	self.name = name
	2565	self.attributes = None
	2566	self.active = True
	2567
	2568	def prepare(self):
	2569	self.constructor = EnumConstructor(self.class_name, self.base_class_name,
	2570	'Con', [], "void", myclass = self)
	2571	StructGenerator.prepare(self)
	2572
	2573	def __str__(self):
	2574	result = "Enum %s:\n" % (self.name)
	2575	for attr in self.values:
	2576	result += " %s\n" % attr.__str__()
	2577
	2578	return result
	2579
	2580	def struct(self,out):
	2581	out.write("""\ntypedef struct {
	2582	PyObject_HEAD
	2583	PyObject *value;
	2584	} py%(class_name)s;\n
	2585
	2586
	2587	static PyObject *%(class_name)s_Dict_lookup;
	2588	static PyObject *%(class_name)s_rev_lookup;
	2589	""" % dict(class_name=self.class_name))
	2590
	2591	def PyMethodDef(self, out):
	2592	out.write("static PyMethodDef %s_methods[] = {\n" % self.class_name)
	2593	out.write(" {NULL} /* Sentinel */\n};\n")
	2594
	2595	def numeric_protocol_nonzero(self):
	2596	pass
	2597
	2598	def numeric_protocol_int(self):
	2599	return """
	2600	static PyObject %(class_name)s_int(py%(class_name)s self) {
	2601	Py_INCREF(self->value);
	2602	return self->value;
[198]	2603	}
[196]	2604	""" % self.__dict__
	2605
	2606	def initialise(self):
	2607	result = """
	2608	%(class_name)s_Dict_lookup = PyDict_New();
	2609	%(class_name)s_rev_lookup = PyDict_New();
	2610	""" % self.__dict__
	2611
	2612	if self.values:
	2613	result += "{ PyObject tmp, tmp2;\n"
	2614	for attr in self.values:
	2615	result += ''' tmp = PyLong_FromLong(%(value)s);
	2616	tmp2 = PyString_FromString("%(value)s");
	2617	PyDict_SetItem(%(class_name)s_Dict_lookup, tmp2, tmp);
	2618	PyDict_SetItem(%(class_name)s_rev_lookup, tmp, tmp2);
	2619	Py_DECREF(tmp);
	2620	Py_DECREF(tmp2);
	2621
	2622	''' % dict(value = attr, class_name=self.class_name)
	2623	result += "};\n"
	2624
	2625	return result
	2626
	2627	class EnumType(Integer):
	2628	buildstr = 'i'
	2629
	2630	def __init__(self, name, type):
	2631	Integer.__init__(self, name, type)
	2632	self.type = type
	2633
	2634	def to_python_object(self, name=None, result='py_result', **kw):
	2635	name = name or self.name
	2636	return """PyErr_Clear();
	2637	%s = PyObject_CallMethod(g_module, "%s", "K", (uint64_t)%s);
	2638	""" % (result, self.type, name)
	2639
	2640	def pre_call(self, method):
	2641	method.error_set = True
	2642	return """
	2643	// Check if the integer passed is actually a valid member of the enum
	2644	// Enum value of 0 is always allowed
	2645	if(%(name)s) { PyObject *py_%(name)s = PyLong_FromLong(%(name)s);
	2646	PyObject *tmp = PyDict_GetItem(%(type)s_rev_lookup, py_%(name)s);
	2647
	2648	Py_DECREF(py_%(name)s);
	2649	if(!tmp) {
	2650	PyErr_Format(PyExc_RuntimeError, "value %%lu is not valid for Enum %(type)s of arg '%(name)s'", (unsigned long)%(name)s);
	2651	goto error;
[198]	2652	}
[196]	2653	Py_DECREF(tmp);
[198]	2654	}
[196]	2655	""" % self.__dict__
	2656
	2657	class HeaderParser(lexer.SelfFeederMixIn):
	2658	tokens = [
	2659	[ 'INITIAL', r'#define\s+', 'PUSH_STATE', 'DEFINE' ],
	2660	[ 'DEFINE', r'([A-Za-z_0-9]+)\s+[^\n]+', 'DEFINE,POP_STATE', None ],
	2661	[ 'DEFINE', r'\n', 'POP_STATE', None],
	2662
	2663	## Recognize ansi c comments
	2664	[ '.', r'/\*(.)', 'PUSH_STATE', 'COMMENT' ],
	2665	[ 'COMMENT', r'(.+?)\*/\s+', 'COMMENT_END,POP_STATE', None],
	2666	[ 'COMMENT', r'(.+)', 'COMMENT', None],
	2667
	2668	## And c++ comments
	2669	[ '.', r'//([^\n]+)', 'COMMENT', None],
	2670
	2671	## An empty line clears the current comment
	2672	[ '.', r'\r?\n\r?\n', 'CLEAR_COMMENT', None],
	2673
	2674	## Ignore whitespace
	2675	[ '.', r'\s+', 'SPACE', None ],
	2676	[ '.', r'\\\n', 'SPACE', None ],
	2677
	2678	## Recognize CLASS() definitions
	2679	[ 'INITIAL', r"^([A-Z]+)?\sCLASS\(([A-Z_a-z0-9]+)\s,\s*([A-Z_a-z0-9]+)\)",
	2680	'PUSH_STATE,CLASS_START', 'CLASS'],
	2681
	2682	[ 'CLASS', r"^\s(FOREIGN\|ABSTRACT\|PRIVATE)?([0-9A-Z_a-z ]+( \|\))METHOD\(([A-Z_a-z0-9]+),\s*([A-Z_a-z0-9]+),?",
	2683	"PUSH_STATE,METHOD_START", "METHOD"],
	2684	[ 'METHOD', r"\s([0-9A-Z a-z_]+\s+\?\*?)([0-9A-Za-z_]+),?", "METHOD_ARG", None ],
	2685	[ 'METHOD', r'\);', 'POP_STATE,METHOD_END', None],
	2686
	2687	[ 'CLASS', r"^\s(FOREIGN\|ABSTRACT)?([0-9A-Z_a-z ]+\s+\?)\s([A-Z_a-z0-9]+)\s;",
	2688	'CLASS_ATTRIBUTE', None],
	2689	[ 'CLASS', "END_CLASS", 'END_CLASS,POP_STATE', None],
	2690
	2691	## Recognize struct definitions (With name)
	2692	[ 'INITIAL', "([A-Z_a-z0-9 ]+)?struct\s+([A-Z_a-z0-9]+)\s+{",
	2693	'PUSH_STATE,STRUCT_START', 'STRUCT'],
	2694
	2695	## Without name (using typedef)
	2696	[ 'INITIAL', "typedef\s+struct\s+{",
	2697	'PUSH_STATE,TYPEDEF_STRUCT_START', 'STRUCT'],
	2698
	2699	[ 'STRUCT', r"^\s([0-9A-Z_a-z ]+\s+\?)\s([A-Z_a-z0-9]+)\s;",
	2700	'STRUCT_ATTRIBUTE', None],
	2701
	2702	[ 'STRUCT', r"^\s([0-9A-Z_a-z ]+)\\s+([A-Z_a-z0-9]+)\s*;",
	2703	'STRUCT_ATTRIBUTE_PTR', None],
	2704
	2705	## Struct ended with typedef
	2706	[ 'STRUCT', '}\s+([0-9A-Za-z_]+);', 'POP_STATE,TYPEDEF_STRUCT_END', None],
	2707	[ 'STRUCT', '}', 'POP_STATE,STRUCT_END', None],
	2708
	2709	## Handle recursive struct or union definition (At the moment
	2710	## we cant handle them at all)
	2711	[ '(RECURSIVE_)?STRUCT', '(struct\|union)\s+([_A-Za-z0-9]+)?\s*{', 'PUSH_STATE', 'RECURSIVE_STRUCT'],
	2712	[ 'RECURSIVE_STRUCT', '}\s+[0-9A-Za-z]+', 'POP_STATE', None],
	2713
	2714	## Process enums (2 forms - named and typedefed)
	2715	[ 'INITIAL', r'enum\s+([0-9A-Za-z_]+)\s+{', 'PUSH_STATE,ENUM_START', 'ENUM' ],
	2716	## Unnamed
	2717	[ 'INITIAL', r'typedef\s+enum\s+{', 'PUSH_STATE,TYPEDEF_ENUM_START', 'ENUM' ],
	2718	[ 'ENUM', r'([0-9A-Za-z_]+)\s+=[^\n]+', 'ENUM_VALUE', None],
	2719
	2720	## Typedefed ending
	2721	[ 'ENUM', r'}\s+([0-9A-Za-z_]+);', 'POP_STATE,TYPEDEFED_ENUM_END', None],
	2722	[ 'ENUM', r'}', 'POP_STATE,ENUM_END', None],
	2723
	2724	[ 'INITIAL', r'BIND_STRUCT\(([0-9A-Za-z_ \*]+)\)', 'BIND_STRUCT', None],
	2725
	2726	## A simple typedef of one type for another type:
	2727	[ 'INITIAL', r"typedef ([A-Za-z_0-9]+) +([^;]+);", 'SIMPLE_TYPEDEF', None],
	2728
	2729	## Handle proxied directives
	2730	[ 'INITIAL', r"PROXY_CLASS\(([A-Za-z0-9]+)\);", 'PROXY_CLASS', None],
	2731
	2732	]
	2733
	2734	def __init__(self, name, verbose = 1):
	2735	self.module = Module(name)
	2736	lexer.SelfFeederMixIn.__init__(self, verbose = 0)
	2737
	2738	io = StringIO.StringIO("""
	2739	// Base object
	2740	CLASS(Object, Obj)
	2741	END_CLASS
	2742	""")
	2743	self.parse_fd(io)
	2744
	2745	current_comment = ''
	2746	def COMMENT(self, t, m):
	2747	self.current_comment += m.group(1) + "\n"
	2748
	2749	def COMMENT_END(self, t, m):
	2750	self.current_comment += m.group(1)
	2751
	2752	def CLEAR_COMMENT(self, t, m):
	2753	self.current_comment = ''
	2754
	2755	def DEFINE(self, t, m):
	2756	line = m.group(0)
	2757	line = line.split('/*')[0]
	2758	if '"' in line:
	2759	type = 'string'
	2760	else:
	2761	type = 'integer'
	2762
	2763	name = m.group(1).strip()
	2764	if len(name)>3 and name[0]!='_' and name==name.upper():
	2765	self.module.add_constant(name, type)
	2766
	2767	current_class = None
	2768	def CLASS_START(self, t, m):
	2769	class_name = m.group(2).strip()
	2770	base_class_name = m.group(3).strip()
	2771
	2772	try:
	2773	self.current_class = self.module.classes[base_class_name].clone(class_name)
	2774	except (KeyError, AttributeError):
	2775	log("Base class %s is not defined !!!!" % base_class_name)
	2776	self.current_class = ClassGenerator(class_name, base_class_name, self.module)
	2777
	2778	self.current_class.docstring = self.current_comment
	2779	self.current_class.modifier.add(m.group(1))
	2780	self.module.add_class(self.current_class, Wrapper)
	2781	type_dispatcher["%s *" % class_name] = PointerWrapper
	2782
	2783	current_method = None
	2784	def METHOD_START(self, t, m):
	2785	return_type = m.group(2).strip()
	2786	method_name = m.group(5).strip()
	2787	modifier = m.group(1) or ''
	2788
	2789	if 'PRIVATE' in modifier: return
	2790
	2791	## Is it a regular method or a constructor?
	2792	self.current_method = Method
	2793	if return_type == self.current_class.class_name and \
	2794	method_name.startswith("Con"):
	2795	self.current_method = ConstructorMethod
	2796	elif method_name == 'iternext':
	2797	self.current_method = IteratorMethod
	2798	self.current_class.modifier.add("ITERATOR")
	2799	elif method_name == '__iter__':
	2800	self.current_method = SelfIteratorMethod
	2801	self.current_class.modifier.add("SELF_ITER")
	2802	elif method_name == '__str__':
	2803	self.current_class.modifier.add("TP_STR")
	2804
	2805	self.current_method = self.current_method(self.current_class.class_name,
	2806	self.current_class.base_class_name,
	2807	method_name, [], return_type,
	2808	myclass = self.current_class)
	2809	self.current_method.docstring = self.current_comment
	2810	self.current_method.modifier = modifier
	2811
	2812	def METHOD_ARG(self, t, m):
	2813	name = m.group(2).strip()
	2814	type = m.group(1).strip()
	2815	if self.current_method:
	2816	self.current_method.add_arg(type, name)
	2817
	2818	def METHOD_END(self, t, m):
	2819	if not self.current_method: return
	2820
	2821	if isinstance(self.current_method, ConstructorMethod):
	2822	self.current_class.constructor = self.current_method
	2823	else:
	2824	found = False
	2825	for i in range(len(self.current_class.methods)):
	2826	## Try to replace existing methods with this new method
	2827	method = self.current_class.methods[i]
	2828	if method.name == self.current_method.name:
	2829	self.current_class.methods[i] = self.current_method
	2830	self.current_method = None
	2831	return
	2832
	2833	## Method does not exist, just add to the end
	2834	self.current_class.methods.append(self.current_method)
	2835
	2836	self.current_method = None
	2837
	2838	def CLASS_ATTRIBUTE(self, t, m):
	2839	modifier = m.group(1) or ''
	2840	type = m.group(2).strip()
	2841	name = m.group(3).strip()
	2842	self.current_class.add_attribute(name, type, modifier)
	2843
	2844	def END_CLASS(self, t, m):
	2845	self.current_class = None
	2846
	2847	current_struct = None
	2848	def STRUCT_START(self, t, m):
	2849	self.current_struct = StructGenerator(m.group(2).strip(), self.module)
	2850	self.current_struct.docstring = self.current_comment
	2851	self.current_struct.modifier.add(m.group(1))
	2852
	2853	def TYPEDEF_STRUCT_START(self, t, m):
	2854	self.current_struct = StructGenerator(None, self.module)
	2855	self.current_struct.docstring = self.current_comment
	2856
	2857	def STRUCT_ATTRIBUTE(self, t, m):
	2858	name = m.group(2).strip()
	2859	type = m.group(1).strip()
	2860	self.current_struct.add_attribute(name, type, '')
	2861
	2862	def STRUCT_ATTRIBUTE_PTR(self, t, m):
	2863	type = "%s *" % m.group(1).strip()
	2864	name = m.group(2).strip()
	2865	self.current_struct.add_attribute(name, type, '')
	2866
	2867	def STRUCT_END(self, t, m):
	2868	self.module.add_class(self.current_struct, StructWrapper)
	2869	type_dispatcher["%s *" % self.current_struct.class_name] = PointerStructWrapper
	2870	self.current_struct = None
	2871
	2872	def TYPEDEF_STRUCT_END(self, t, m):
	2873	self.current_struct.class_name = m.group(1).strip()
	2874
	2875	self.STRUCT_END(t, m)
	2876
	2877	current_enum = None
	2878	def ENUM_START(self, t, m):
	2879	self.current_enum = Enum(m.group(1).strip(), self.module)
	2880
	2881	def TYPEDEF_ENUM_START(self, t, m):
	2882	self.current_enum = Enum(None, self.module)
	2883
	2884	def ENUM_VALUE(self, t, m):
	2885	self.current_enum.values.append(m.group(1).strip())
	2886
	2887	def ENUM_END(self, t, m):
	2888	self.module.classes[self.current_enum.name] = self.current_enum
	2889
	2890	## For now we just treat enums as an integer, and also add
	2891	## them to the constant table. In future it would be nice to
	2892	## have them as a proper python object so we can override
	2893	## __str__ and __int__.
	2894	for attr in self.current_enum.values:
	2895	self.module.add_constant(attr, 'integer')
	2896
	2897	#type_dispatcher[self.current_enum.name] = Integer
	2898	type_dispatcher[self.current_enum.name] = EnumType
	2899	self.current_enum = None
	2900
	2901	def TYPEDEFED_ENUM_END(self, t, m):
	2902	self.current_enum.name = self.current_enum.class_name = m.group(1)
	2903	self.ENUM_END(t, m)
	2904
	2905	def BIND_STRUCT(self, t, m):
	2906	self.module.classes[m.group(1)].active = True
	2907
	2908	def SIMPLE_TYPEDEF(self, t, m):
	2909	## We basically add a new type as a copy of the old
	2910	## type
	2911	old, new = m.group(1).strip(), m.group(2).strip()
	2912	if old in type_dispatcher:
	2913	type_dispatcher[new] = type_dispatcher[old]
	2914
	2915	def PROXY_CLASS(self, t, m):
	2916	base_class_name = m.group(1).strip()
	2917	class_name = "Proxied%s" % base_class_name
	2918	try:
	2919	proxied_class = self.module.classes[base_class_name]
	2920	except KeyError:
	2921	raise RuntimeError("Need to create a proxy for %s but it has not been defined (yet). You must place the PROXIED_CLASS() instruction after the class definition" % base_class_name)
	2922	current_class = ProxyClassGenerator(class_name,
	2923	base_class_name, self.module)
	2924	#self.current_class.constructor.args += proxied_class.constructor.args
	2925	current_class.docstring = self.current_comment
	2926
	2927	## Create proxies for all these methods
	2928	for method in proxied_class.methods:
	2929	current_class.methods.append(ProxiedMethod(method, current_class))
	2930
	2931	self.module.add_class(current_class, Wrapper)
	2932
	2933	def parse_filenames(self, filenames):
	2934	for f in filenames:
	2935	self._parse(f)
	2936
	2937	## Second pass
	2938	for f in filenames:
	2939	self._parse(f)
	2940
	2941	def _parse(self, filename):
	2942	fd = open(filename)
	2943	self.parse_fd(fd)
	2944	fd.close()
	2945
	2946	if filename not in self.module.files:
	2947	self.module.headers += '#include "%s"\n' % filename
	2948	self.module.files.append(filename)
	2949
	2950	def write(self, out):
	2951	self.module.write(out)
	2952
	2953
	2954	if __name__ == '__main__':
	2955	p = HeaderParser('pyaff4', verbose = 1)
	2956	for arg in sys.argv[1:]:
	2957	p.parse_fd(open(arg))
	2958
	2959	log("second parse")
	2960	for arg in sys.argv[1:]:
	2961	p.parse_fd(open(arg))
	2962
	2963	pdb.set_trace()
	2964	p.write(sys.stdout)
	2965
	2966	# p = parser(Module("pyaff4"))
	2967	# for arg in sys.argv[1:]:
	2968	# p.parse(arg)
	2969	# log("second parse")
	2970	# p.parse(arg)
	2971
	2972	# p.write(sys.stdout)
	2973

Note: See TracBrowser for help on using the repository browser.

Download in other formats: