Merged

https://svn.blender.org/svnroot/bf-blender/branches/soc-2008-mxcurioni (r22789) and
https://svn.blender.org/svnroot/bf-blender/trunk/blender (r23338)
with the "Ignore ancestry" and "Ignore line endings" options enabled (using
TortoiseSVN on Windows).

After the merge operation, all changes (i.e., deletion) in source/blender/freestyle/
were reverted in order to keep the primary source tree of the Freestyle renderer.

source/blender/python/intern/Makefile

@@ -0,0 +1,66 @@
+#
+# $Id$
+#
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL LICENSE BLOCK *****
+#
+#
+
+LIBNAME = python
+DIR = $(OCGDIR)/blender/$(LIBNAME)
+
+include nan_compile.mk
+
+CFLAGS += $(LEVEL_1_C_WARNINGS)
+
+# OpenGL and Python
+CPPFLAGS += $(OGL_CPPFLAGS)
+CPPFLAGS += -I$(NAN_GLEW)/include
+CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION)
+
+# PreProcessor stuff 
+
+CPPFLAGS += -I$(NAN_GHOST)/include
+CPPFLAGS += $(NAN_SDLCFLAGS)
+
+# modules
+CPPFLAGS += -I../../editors/include
+CPPFLAGS += -I../../python
+CPPFLAGS += -I../../makesdna
+CPPFLAGS += -I../../makesrna
+CPPFLAGS += -I../../blenlib
+CPPFLAGS += -I../../blenkernel
+CPPFLAGS += -I../../nodes
+CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../blenloader
+CPPFLAGS += -I../../windowmanager
+CPPFLAGS += -I../../render/extern/include
+
+# path to the guarded memory allocator
+CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
+CPPFLAGS += -I$(NAN_MEMUTIL)/include
+
+# path to our own headerfiles
+CPPFLAGS += -I..

source/blender/python/intern/bpy_array.c

@@ -0,0 +1,515 @@
+/**
+ * 
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Arystanbek Dyussenov
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "Python.h"
+
+#include "bpy_rna.h"
+
+#include "RNA_access.h"
+
+#include "BLI_string.h"
+
+#include "BKE_global.h"
+
+#include "MEM_guardedalloc.h"
+
+#define MAX_ARRAY_DIMENSION 10
+
+typedef void (*ItemConvertFunc)(PyObject *, char *);
+typedef int  (*ItemTypeCheckFunc)(PyObject *);
+typedef void (*RNA_SetArrayFunc)(PointerRNA *, PropertyRNA *, const char *);
+typedef void (*RNA_SetIndexFunc)(PointerRNA *, PropertyRNA *, int index, void *);
+
+/*
+  arr[3][4][5]
+      0  1  2  <- dimension index
+*/
+
+/*
+  arr[2] = x
+
+  py_to_array_index(arraydim=0, arrayoffset=0, index=2)
+    validate_array(lvalue_dim=0)
+    ... make real index ...
+*/
+
+/* arr[3]=x, self->arraydim is 0, lvalue_dim is 1 */
+/* Ensures that a python sequence has expected number of items/sub-items and items are of desired type. */
+static int validate_array_type(PyObject *seq, int dim, int totdim, int dimsize[],
+							   ItemTypeCheckFunc check_item_type, const char *item_type_str, const char *error_prefix)
+{
+	int i;
+
+	/* not the last dimension */
+	if (dim + 1 < totdim) {
+		/* check that a sequence contains dimsize[dim] items */
+
+		for (i= 0; i < PySequence_Length(seq); i++) {
+			PyObject *item;
+			int ok= 1;
+			item= PySequence_GetItem(seq, i);
+
+			if (!PySequence_Check(item)) {
+				/* BLI_snprintf(error_str, error_str_size, "expected a sequence of %s", item_type_str); */
+				PyErr_Format(PyExc_TypeError, "%s expected a sequence of %s", error_prefix, item_type_str);
+				ok= 0;
+			}
+			/* arr[3][4][5]
+			   dimsize[1]=4
+			   dimsize[2]=5
+		   
+			   dim=0 */
+			else if (PySequence_Length(item) != dimsize[dim + 1]) {
+				/* BLI_snprintf(error_str, error_str_size, "sequences of dimension %d should contain %d items", (int)dim + 1, (int)dimsize[dim + 1]); */
+				PyErr_Format(PyExc_ValueError, "%s sequences of dimension %d should contain %d items", error_prefix, (int)dim + 1, (int)dimsize[dim + 1]);
+				ok= 0;
+			}
+			else if (!validate_array_type(item, dim + 1, totdim, dimsize, check_item_type, item_type_str, error_prefix)) {
+				ok= 0;
+			}
+
+			Py_DECREF(item);
+
+			if (!ok)
+				return 0;
+		}
+	}
+	else {
+		/* check that items are of correct type */
+		for (i= 0; i < PySequence_Length(seq); i++) {
+			PyObject *item= PySequence_GetItem(seq, i);
+
+			if (!check_item_type(item)) {
+				Py_DECREF(item);
+
+				/* BLI_snprintf(error_str, error_str_size, "sequence items should be of type %s", item_type_str); */
+				PyErr_Format(PyExc_TypeError, "sequence items should be of type %s", item_type_str);
+				return 0;
+			}
+
+			Py_DECREF(item);
+		}
+	}
+
+	return 1;
+}
+
+/* Returns the number of items in a single- or multi-dimensional sequence. */
+static int count_items(PyObject *seq)
+{
+	int totitem= 0;
+
+	if (PySequence_Check(seq)) {
+		int i;
+		for (i= 0; i < PySequence_Length(seq); i++) {
+			PyObject *item= PySequence_GetItem(seq, i);
+			totitem += count_items(item);
+			Py_DECREF(item);
+		}
+	}
+	else
+		totitem= 1;
+
+	return totitem;
+}
+
+/* Modifies property array length if needed and PROP_DYNAMIC flag is set. */
+static int validate_array_length(PyObject *rvalue, PointerRNA *ptr, PropertyRNA *prop, int lvalue_dim, int *totitem, const char *error_prefix)
+{
+	int dimsize[MAX_ARRAY_DIMENSION];
+	int tot, totdim, len;
+
+	tot= count_items(rvalue);
+	totdim= RNA_property_array_dimension(ptr, prop, dimsize);
+
+	if ((RNA_property_flag(prop) & PROP_DYNAMIC) && lvalue_dim == 0) {
+		if (RNA_property_array_length(ptr, prop) != tot) {
+#if 0
+			/* length is flexible */
+			if (!RNA_property_dynamic_array_set_length(ptr, prop, tot)) {
+				/* BLI_snprintf(error_str, error_str_size, "%s.%s: array length cannot be changed to %d", RNA_struct_identifier(ptr->type), RNA_property_identifier(prop), tot); */
+				PyErr_Format(PyExc_ValueError, "%s %s.%s: array length cannot be changed to %d", error_prefix, RNA_struct_identifier(ptr->type), RNA_property_identifier(prop), tot);
+				return 0;
+			}
+#else
+			PyErr_Format(PyExc_ValueError, "%s %s.%s: array length cannot be changed to %d", error_prefix, RNA_struct_identifier(ptr->type), RNA_property_identifier(prop), tot);
+			return 0;
+#endif
+		}
+
+		len= tot;
+	}
+	else {
+		/* length is a constraint */
+		if (!lvalue_dim) {
+			len= RNA_property_array_length(ptr, prop);
+		}
+		/* array item assignment */
+		else {
+			int i;
+
+			len= 1;
+
+			/* arr[3][4][5]
+
+			   arr[2] = x
+			   dimsize={4, 5}
+			   dimsize[1] = 4
+			   dimsize[2] = 5
+			   lvalue_dim=0, totdim=3
+
+			   arr[2][3] = x
+			   lvalue_dim=1
+
+			   arr[2][3][4] = x
+			   lvalue_dim=2 */
+			for (i= lvalue_dim; i < totdim; i++)
+				len *= dimsize[i];
+		}
+
+		if (tot != len) {
+			/* BLI_snprintf(error_str, error_str_size, "sequence must have length of %d", len); */
+			PyErr_Format(PyExc_ValueError, "%s sequence must have %d items total", error_prefix, len);
+			return 0;
+		}
+	}
+
+	*totitem= len;
+
+	return 1;
+}
+
+static int validate_array(PyObject *rvalue, PointerRNA *ptr, PropertyRNA *prop, int lvalue_dim, ItemTypeCheckFunc check_item_type, const char *item_type_str, int *totitem, const char *error_prefix)
+{
+	int dimsize[MAX_ARRAY_DIMENSION];
+	int totdim= RNA_property_array_dimension(ptr, prop, dimsize);
+
+	/* validate type first because length validation may modify property array length */
+
+	if (!validate_array_type(rvalue, lvalue_dim, totdim, dimsize, check_item_type, item_type_str, error_prefix))
+		return 0;
+
+	return validate_array_length(rvalue, ptr, prop, lvalue_dim, totitem, error_prefix);
+}
+
+static char *copy_values(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop, int dim, char *data, unsigned int item_size, int *index, ItemConvertFunc convert_item, RNA_SetIndexFunc rna_set_index)
+{
+	unsigned int i;
+	int totdim= RNA_property_array_dimension(ptr, prop, NULL);
+
+	for (i= 0; i < PySequence_Length(seq); i++) {
+		PyObject *item= PySequence_GetItem(seq, i);
+
+		if (dim + 1 < totdim) {
+			data= copy_values(item, ptr, prop, dim + 1, data, item_size, index, convert_item, rna_set_index);
+		}
+		else {
+			if (!data) {
+				char value[sizeof(int)];
+
+				convert_item(item, value);
+				rna_set_index(ptr, prop, *index, value);
+				*index = *index + 1;
+			}
+			else {
+				convert_item(item, data);
+				data += item_size;
+			}
+		}
+			
+		Py_DECREF(item);
+	}
+
+	return data;
+}
+
+static int py_to_array(PyObject *py, PointerRNA *ptr, PropertyRNA *prop, char *param_data, ItemTypeCheckFunc check_item_type, const char *item_type_str, int item_size, ItemConvertFunc convert_item, RNA_SetArrayFunc rna_set_array, const char *error_prefix)
+{
+	int totdim, dim_size[MAX_ARRAY_DIMENSION];
+	int totitem;
+	char *data= NULL;
+
+	totdim= RNA_property_array_dimension(ptr, prop, dim_size);
+
+	if (!validate_array(py, ptr, prop, 0, check_item_type, item_type_str, &totitem, error_prefix)) {
+		return 0;
+	}
+
+	if (totitem) {
+		if (!param_data || RNA_property_flag(prop) & PROP_DYNAMIC)
+			data= MEM_callocN(item_size * totitem, "pyrna primitive type array");
+		else
+			data= param_data;
+
+		copy_values(py, ptr, prop, 0, data, item_size, NULL, convert_item, NULL);
+
+		if (param_data) {
+			if (RNA_property_flag(prop) & PROP_DYNAMIC) {
+				/* not freeing allocated mem, RNA_parameter_list_free will do this */
+				*(char**)param_data= data;
+			}
+		}
+		else {
+			/* NULL can only pass through in case RNA property arraylength is 0 (impossible?) */
+			rna_set_array(ptr, prop, data);
+			MEM_freeN(data);
+		}
+	}
+
+	return 1;
+}
+
+static int py_to_array_index(PyObject *py, PointerRNA *ptr, PropertyRNA *prop, int lvalue_dim, int arrayoffset, int index, ItemTypeCheckFunc check_item_type, const char *item_type_str, ItemConvertFunc convert_item, RNA_SetIndexFunc rna_set_index, const char *error_prefix)
+{
+	int totdim, dimsize[MAX_ARRAY_DIMENSION];
+	int totitem, i;
+
+	totdim= RNA_property_array_dimension(ptr, prop, dimsize);
+
+	/* convert index */
+
+	/* arr[3][4][5]
+
+	   arr[2] = x
+	   lvalue_dim=0, index = 0 + 2 * 4 * 5
+
+	   arr[2][3] = x
+	   lvalue_dim=1, index = 40 + 3 * 5 */
+
+	lvalue_dim++;
+
+	for (i= lvalue_dim; i < totdim; i++)
+		index *= dimsize[i];
+
+	index += arrayoffset;
+
+	if (!validate_array(py, ptr, prop, lvalue_dim, check_item_type, item_type_str, &totitem, error_prefix))
+		return 0;
+
+	if (totitem)
+		copy_values(py, ptr, prop, lvalue_dim, NULL, 0, &index, convert_item, rna_set_index);
+
+	return 1;
+}
+
+static void py_to_float(PyObject *py, char *data)
+{
+	*(float*)data= (float)PyFloat_AsDouble(py);
+}
+
+static void py_to_int(PyObject *py, char *data)
+{
+	*(int*)data= (int)PyLong_AsSsize_t(py);
+}
+
+static void py_to_bool(PyObject *py, char *data)
+{
+	*(int*)data= (int)PyObject_IsTrue(py);
+}
+
+static int py_float_check(PyObject *py)
+{
+	/* accept both floats and integers */
+	return PyFloat_Check(py) || PyLong_Check(py);
+}
+
+static int py_int_check(PyObject *py)
+{
+	/* accept only integers */
+	return PyLong_Check(py);
+}
+
+static int py_bool_check(PyObject *py)
+{
+	return PyBool_Check(py);
+}
+
+static void float_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, void *value)
+{
+	RNA_property_float_set_index(ptr, prop, index, *(float*)value);
+}
+
+static void int_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, void *value)
+{
+	RNA_property_int_set_index(ptr, prop, index, *(int*)value);
+}
+
+static void bool_set_index(PointerRNA *ptr, PropertyRNA *prop, int index, void *value)
+{
+	RNA_property_boolean_set_index(ptr, prop, index, *(int*)value);
+}
+
+int pyrna_py_to_array(PointerRNA *ptr, PropertyRNA *prop, char *param_data, PyObject *py, const char *error_prefix)
+{
+	int ret;
+	switch (RNA_property_type(prop)) {
+	case PROP_FLOAT:
+		ret= py_to_array(py, ptr, prop, param_data, py_float_check, "float", sizeof(float), py_to_float, (RNA_SetArrayFunc)RNA_property_float_set_array, error_prefix);
+		break;
+	case PROP_INT:
+		ret= py_to_array(py, ptr, prop, param_data, py_int_check, "int", sizeof(int), py_to_int, (RNA_SetArrayFunc)RNA_property_int_set_array, error_prefix);
+		break;
+	case PROP_BOOLEAN:
+		ret= py_to_array(py, ptr, prop, param_data, py_bool_check, "boolean", sizeof(int), py_to_bool, (RNA_SetArrayFunc)RNA_property_boolean_set_array, error_prefix);
+		break;
+	default:
+		PyErr_SetString(PyExc_TypeError, "not an array type");
+		ret= 0;
+	}
+
+	return ret;
+}
+
+int pyrna_py_to_array_index(PointerRNA *ptr, PropertyRNA *prop, int arraydim, int arrayoffset, int index, PyObject *py, const char *error_prefix)
+{
+	int ret;
+	switch (RNA_property_type(prop)) {
+	case PROP_FLOAT:
+		ret= py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index, py_float_check, "float", py_to_float, float_set_index, error_prefix);
+		break;
+	case PROP_INT:
+		ret= py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index, py_int_check, "int", py_to_int, int_set_index, error_prefix);
+		break;
+	case PROP_BOOLEAN:
+		ret= py_to_array_index(py, ptr, prop, arraydim, arrayoffset, index, py_bool_check, "boolean", py_to_bool, bool_set_index, error_prefix);
+		break;
+	default:
+		PyErr_SetString(PyExc_TypeError, "not an array type");
+		ret= 0;
+	}
+
+	return ret;
+}
+
+static PyObject *pyrna_array_item(PointerRNA *ptr, PropertyRNA *prop, int index)
+{
+	PyObject *item;
+
+	switch (RNA_property_type(prop)) {
+	case PROP_FLOAT:
+		item= PyFloat_FromDouble(RNA_property_float_get_index(ptr, prop, index));
+		break;
+	case PROP_BOOLEAN:
+		item= PyBool_FromLong(RNA_property_boolean_get_index(ptr, prop, index));
+		break;
+	case PROP_INT:
+		item= PyLong_FromSsize_t(RNA_property_int_get_index(ptr, prop, index));
+		break;
+	default:
+		PyErr_SetString(PyExc_TypeError, "not an array type");
+		item= NULL;
+	}
+
+	return item;
+}
+
+#if 0
+/* XXX this is not used (and never will?) */
+/* Given an array property, creates an N-dimensional tuple of values. */
+static PyObject *pyrna_py_from_array_internal(PointerRNA *ptr, PropertyRNA *prop, int dim, int *index)
+{
+	PyObject *tuple;
+	int i, len;
+	int totdim= RNA_property_array_dimension(ptr, prop, NULL);
+
+	len= RNA_property_multi_array_length(ptr, prop, dim);
+
+	tuple= PyTuple_New(len);
+
+	for (i= 0; i < len; i++) {
+		PyObject *item;
+
+		if (dim + 1 < totdim)
+			item= pyrna_py_from_array_internal(ptr, prop, dim + 1, index);
+		else {
+			item= pyrna_array_item(ptr, prop, *index);
+			*index= *index + 1;
+		}
+
+		if (!item) {
+			Py_DECREF(tuple);
+			return NULL;
+		}
+
+		PyTuple_SetItem(tuple, i, item);
+	}
+
+	return tuple;
+}
+#endif
+
+PyObject *pyrna_py_from_array_index(BPy_PropertyRNA *self, int index)
+{
+	int totdim, i, len;
+	int dimsize[MAX_ARRAY_DIMENSION];
+	BPy_PropertyRNA *ret= NULL;
+
+	/* just in case check */
+	len= RNA_property_multi_array_length(&self->ptr, self->prop, self->arraydim);
+	if (index >= len || index < 0) {
+		/* this shouldn't happen because higher level funcs must check for invalid index */
+		if (G.f & G_DEBUG) printf("pyrna_py_from_array_index: invalid index %d for array with length=%d\n", index, len);
+
+		PyErr_SetString(PyExc_IndexError, "out of range");
+		return NULL;
+	}
+
+	totdim= RNA_property_array_dimension(&self->ptr, self->prop, dimsize);
+
+	if (self->arraydim + 1 < totdim) {
+		ret= (BPy_PropertyRNA*)pyrna_prop_CreatePyObject(&self->ptr, self->prop);
+		ret->arraydim= self->arraydim + 1;
+
+		/* arr[3][4][5]
+
+		   x = arr[2]
+		   index = 0 + 2 * 4 * 5
+
+		   x = arr[2][3]
+		   index = offset + 3 * 5 */
+
+		for (i= self->arraydim + 1; i < totdim; i++)
+			index *= dimsize[i];
+
+		ret->arrayoffset= self->arrayoffset + index;
+	}
+	else {
+		index = self->arrayoffset + index;
+		ret= (BPy_PropertyRNA*)pyrna_array_item(&self->ptr, self->prop, index);
+	}
+
+	return (PyObject*)ret;
+}
+
+PyObject *pyrna_py_from_array(PointerRNA *ptr, PropertyRNA *prop)
+{
+	PyObject *ret;
+
+	ret= pyrna_math_object_from_array(ptr, prop);
+
+	/* is this a maths object? */
+	if (ret) return ret;
+
+	return pyrna_prop_CreatePyObject(ptr, prop);
+}

source/blender/python/intern/bpy_interface.c

@@ -0,0 +1,913 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Michel Selten, Willian P. Germano, Stephen Swaney,
+ * Chris Keith, Chris Want, Ken Hughes, Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+ 
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+
+/* grr, python redefines */
+#ifdef _POSIX_C_SOURCE
+#undef _POSIX_C_SOURCE
+#endif
+
+#include <Python.h>
+#include "compile.h"		/* for the PyCodeObject */
+#include "eval.h"		/* for PyEval_EvalCode */
+
+#include "bpy_rna.h"
+#include "bpy_operator.h"
+#include "bpy_ui.h"
+#include "bpy_util.h"
+
+#ifndef WIN32
+#include <dirent.h>
+#else
+#include "BLI_winstuff.h"
+#endif
+
+#include "DNA_anim_types.h"
+#include "DNA_space_types.h"
+#include "DNA_text_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_util.h"
+#include "BLI_storage.h"
+#include "BLI_fileops.h"
+#include "BLI_string.h"
+
+#include "BKE_context.h"
+#include "BKE_fcurve.h"
+#include "BKE_text.h"
+
+#include "BPY_extern.h"
+
+#include "../generic/bpy_internal_import.h" // our own imports
+/* external util modules */
+
+#include "../generic/Mathutils.h"
+#include "../generic/Geometry.h"
+#include "../generic/BGL.h"
+
+
+/* for internal use, when starting and ending python scripts */
+
+/* incase a python script triggers another python call, stop bpy_context_clear from invalidating */
+static int py_call_level= 0;
+
+
+// only for tests
+#define TIME_PY_RUN
+
+#ifdef TIME_PY_RUN
+#include "PIL_time.h"
+static int		bpy_timer_count = 0;
+static double	bpy_timer; /* time since python starts */
+static double	bpy_timer_run; /* time for each python script run */
+static double	bpy_timer_run_tot; /* accumulate python runs */
+#endif
+
+void bpy_context_set(bContext *C, PyGILState_STATE *gilstate)
+{
+	py_call_level++;
+
+	if(gilstate)
+		*gilstate = PyGILState_Ensure();
+
+	if(py_call_level==1) {
+
+		BPY_update_modules(); /* can give really bad results if this isnt here */
+
+		if(C) { // XXX - should always be true.
+			BPy_SetContext(C);
+			bpy_import_main_set(CTX_data_main(C));
+		}
+		else {
+			fprintf(stderr, "ERROR: Python context called with a NULL Context. this should not happen!\n");
+		}
+
+#ifdef TIME_PY_RUN
+		if(bpy_timer_count==0) {
+			/* record time from the beginning */
+			bpy_timer= PIL_check_seconds_timer();
+			bpy_timer_run = bpy_timer_run_tot = 0.0;
+		}
+		bpy_timer_run= PIL_check_seconds_timer();
+
+
+		bpy_timer_count++;
+#endif
+	}
+}
+
+void bpy_context_clear(bContext *C, PyGILState_STATE *gilstate)
+{
+	py_call_level--;
+
+	if(gilstate)
+		PyGILState_Release(*gilstate);
+
+	if(py_call_level < 0) {
+		fprintf(stderr, "ERROR: Python context internal state bug. this should not happen!\n");
+	}
+	else if(py_call_level==0) {
+		// XXX - Calling classes currently wont store the context :\, cant set NULL because of this. but this is very flakey still.
+		//BPy_SetContext(NULL);
+		//bpy_import_main_set(NULL);
+
+#ifdef TIME_PY_RUN
+		bpy_timer_run_tot += PIL_check_seconds_timer() - bpy_timer_run;
+		bpy_timer_count++;
+#endif
+
+	}
+}
+
+
+void BPY_free_compiled_text( struct Text *text )
+{
+	if( text->compiled ) {
+		Py_DECREF( ( PyObject * ) text->compiled );
+		text->compiled = NULL;
+	}
+}
+
+/*****************************************************************************
+* Description: Creates the bpy module and adds it to sys.modules for importing
+*****************************************************************************/
+static void bpy_init_modules( void )
+{
+	PyObject *mod;
+	
+	mod = PyModule_New("bpy");
+	
+	PyModule_AddObject( mod, "data", BPY_rna_module() );
+	/* PyModule_AddObject( mod, "doc", BPY_rna_doc() ); */
+	PyModule_AddObject( mod, "types", BPY_rna_types() );
+	PyModule_AddObject( mod, "props", BPY_rna_props() );
+	PyModule_AddObject( mod, "__ops__", BPY_operator_module() ); /* ops is now a python module that does the conversion from SOME_OT_foo -> some.foo */
+	PyModule_AddObject( mod, "ui", BPY_ui_module() ); // XXX very experimental, consider this a test, especially PyCObject is not meant to be permanent
+	
+	/* add the module so we can import it */
+	PyDict_SetItemString(PySys_GetObject("modules"), "bpy", mod);
+	Py_DECREF(mod);
+
+
+	/* stand alone utility modules not related to blender directly */
+	Geometry_Init();
+	Mathutils_Init();
+	BGL_Init();
+}
+
+void BPY_update_modules( void )
+{
+#if 0 // slow, this runs all the time poll, draw etc 100's of time a sec.
+	PyObject *mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
+	PyModule_AddObject( mod, "data", BPY_rna_module() );
+	PyModule_AddObject( mod, "types", BPY_rna_types() ); // atm this does not need updating
+#endif
+
+	/* refreshes the main struct */
+	BPY_update_rna_module();
+
+}
+
+/*****************************************************************************
+* Description: This function creates a new Python dictionary object.
+*****************************************************************************/
+static PyObject *CreateGlobalDictionary( bContext *C )
+{
+	PyObject *mod;
+	PyObject *dict = PyDict_New(  );
+	PyObject *item = PyUnicode_FromString( "__main__" );
+	PyDict_SetItemString( dict, "__builtins__", PyEval_GetBuiltins(  ) );
+	PyDict_SetItemString( dict, "__name__", item );
+	Py_DECREF(item);
+	
+	// XXX - put somewhere more logical
+	{
+		PyMethodDef *ml;
+		static PyMethodDef bpy_prop_meths[] = {
+			{"FloatProperty", (PyCFunction)BPy_FloatProperty, METH_VARARGS|METH_KEYWORDS, ""},
+			{"IntProperty", (PyCFunction)BPy_IntProperty, METH_VARARGS|METH_KEYWORDS, ""},
+			{"BoolProperty", (PyCFunction)BPy_BoolProperty, METH_VARARGS|METH_KEYWORDS, ""},
+			{"StringProperty", (PyCFunction)BPy_StringProperty, METH_VARARGS|METH_KEYWORDS, ""},
+			{NULL, NULL, 0, NULL}
+		};
+		
+		for(ml = bpy_prop_meths; ml->ml_name; ml++) {
+			PyDict_SetItemString( dict, ml->ml_name, PyCFunction_New(ml, NULL));
+		}
+	}
+	
+	/* add bpy to global namespace */
+	mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
+	PyDict_SetItemString( dict, "bpy", mod );
+	Py_DECREF(mod);
+	
+	return dict;
+}
+
+/* Use this so we can include our own python bundle */
+#if 0
+wchar_t* Py_GetPath(void)
+{
+	int i;
+	static wchar_t py_path[FILE_MAXDIR] = L"";
+	char *dirname= BLI_gethome_folder("python");
+	if(dirname) {
+		i= mbstowcs(py_path, dirname, FILE_MAXDIR);
+		printf("py path %s, %d\n", dirname, i);
+	}
+	return py_path;
+}
+#endif
+
+
+/* must be called before Py_Initialize */
+void BPY_start_python_path(void)
+{
+	char *py_path_bundle= BLI_gethome_folder("python");
+
+	if(py_path_bundle==NULL)
+		return;
+
+	/* set the environment path */
+	printf("found bundled python: %s\n", py_path_bundle);
+
+#if 0
+	BLI_setenv("PYTHONHOME", py_path_bundle);
+	BLI_setenv("PYTHONPATH", py_path_bundle);
+#endif
+
+	{
+		static wchar_t py_path_bundle_wchar[FILE_MAXDIR];
+
+		mbstowcs(py_path_bundle_wchar, py_path_bundle, FILE_MAXDIR);
+		Py_SetPythonHome(py_path_bundle_wchar);
+	}
+}
+
+
+void BPY_start_python( int argc, char **argv )
+{
+	PyThreadState *py_tstate = NULL;
+	
+	BPY_start_python_path(); /* allow to use our own included python */
+
+	Py_Initialize(  );
+	
+	// PySys_SetArgv( argc, argv); // broken in py3, not a huge deal
+	/* sigh, why do python guys not have a char** version anymore? :( */
+	{
+		int i;
+		PyObject *py_argv= PyList_New(argc);
+
+		for (i=0; i<argc; i++)
+			PyList_SET_ITEM(py_argv, i, PyUnicode_FromString(argv[i]));
+
+		PySys_SetObject("argv", py_argv);
+		Py_DECREF(py_argv);
+	}
+	
+	/* Initialize thread support (also acquires lock) */
+	PyEval_InitThreads();
+	
+	
+	/* bpy.* and lets us import it */
+	bpy_init_modules(); 
+
+	{ /* our own import and reload functions */
+		PyObject *item;
+		//PyObject *m = PyImport_AddModule("__builtin__");
+		//PyObject *d = PyModule_GetDict(m);
+		PyObject *d = PyEval_GetBuiltins(  );
+		PyDict_SetItemString(d, "reload",		item=PyCFunction_New(bpy_reload_meth, NULL));	Py_DECREF(item);
+		PyDict_SetItemString(d, "__import__",	item=PyCFunction_New(bpy_import_meth, NULL));	Py_DECREF(item);
+	}
+	
+	pyrna_alloc_types();
+
+	py_tstate = PyGILState_GetThisThreadState();
+	PyEval_ReleaseThread(py_tstate);
+}
+
+void BPY_end_python( void )
+{
+	// fprintf(stderr, "Ending Python!\n");
+
+	PyGILState_Ensure(); /* finalizing, no need to grab the state */
+	
+	// free other python data.
+	pyrna_free_types();
+
+	/* clear all python data from structs */
+	
+	Py_Finalize(  );
+	
+#ifdef TIME_PY_RUN
+	// measure time since py started
+	bpy_timer = PIL_check_seconds_timer() - bpy_timer;
+
+	printf("*bpy stats* - ");
+	printf("tot exec: %d,  ", bpy_timer_count);
+	printf("tot run: %.4fsec,  ", bpy_timer_run_tot);
+	if(bpy_timer_count>0)
+		printf("average run: %.6fsec,  ", (bpy_timer_run_tot/bpy_timer_count));
+
+	if(bpy_timer>0.0)
+		printf("tot usage %.4f%%", (bpy_timer_run_tot/bpy_timer)*100.0);
+
+	printf("\n");
+
+	// fprintf(stderr, "Ending Python Done!\n");
+
+#endif
+
+}
+
+/* Can run a file or text block */
+int BPY_run_python_script( bContext *C, const char *fn, struct Text *text, struct ReportList *reports)
+{
+	PyObject *py_dict, *py_result= NULL;
+	PyGILState_STATE gilstate;
+	
+	if (fn==NULL && text==NULL) {
+		return 0;
+	}
+	
+	bpy_context_set(C, &gilstate);
+	
+	py_dict = CreateGlobalDictionary(C);
+
+	if (text) {
+		
+		if( !text->compiled ) {	/* if it wasn't already compiled, do it now */
+			char *buf = txt_to_buf( text );
+
+			text->compiled =
+				Py_CompileString( buf, text->id.name+2, Py_file_input );
+
+			MEM_freeN( buf );
+
+			if( PyErr_Occurred(  ) ) {
+				BPY_free_compiled_text( text );
+			}
+		}
+		if(text->compiled)
+			py_result =  PyEval_EvalCode( text->compiled, py_dict, py_dict );
+		
+	} else {
+#if 0
+		char *pystring;
+		pystring= malloc(strlen(fn) + 32);
+		pystring[0]= '\0';
+		sprintf(pystring, "exec(open(r'%s').read())", fn);
+		py_result = PyRun_String( pystring, Py_file_input, py_dict, py_dict );
+		free(pystring);
+#else
+		FILE *fp= fopen(fn, "r");		
+		if(fp) {
+			py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);
+			fclose(fp);
+		}
+		else {
+			PyErr_Format(PyExc_SystemError, "Python file \"%s\" could not be opened: %s", fn, strerror(errno));
+			py_result= NULL;
+		}
+#endif
+	}
+	
+	if (!py_result) {
+		BPy_errors_to_report(reports);
+	} else {
+		Py_DECREF( py_result );
+	}
+	
+	Py_DECREF(py_dict);
+	
+	bpy_context_clear(C, &gilstate);
+
+	return py_result ? 1:0;
+}
+
+
+/* TODO - move into bpy_space.c ? */
+/* GUI interface routines */
+
+/* Copied from Draw.c */
+static void exit_pydraw( SpaceScript * sc, short err )
+{
+	Script *script = NULL;
+
+	if( !sc || !sc->script )
+		return;
+
+	script = sc->script;
+
+	if( err ) {
+		BPy_errors_to_report(NULL); // TODO, reports
+		script->flags = 0;	/* mark script struct for deletion */
+		SCRIPT_SET_NULL(script);
+		script->scriptname[0] = '\0';
+		script->scriptarg[0] = '\0';
+// XXX 2.5		error_pyscript();
+// XXX 2.5		scrarea_queue_redraw( sc->area );
+	}
+
+#if 0 // XXX 2.5
+	BPy_Set_DrawButtonsList(sc->but_refs);
+	BPy_Free_DrawButtonsList(); /*clear all temp button references*/
+#endif
+
+	sc->but_refs = NULL;
+	
+	Py_XDECREF( ( PyObject * ) script->py_draw );
+	Py_XDECREF( ( PyObject * ) script->py_event );
+	Py_XDECREF( ( PyObject * ) script->py_button );
+
+	script->py_draw = script->py_event = script->py_button = NULL;
+}
+
+static int bpy_run_script_init(bContext *C, SpaceScript * sc)
+{
+	if (sc->script==NULL) 
+		return 0;
+	
+	if (sc->script->py_draw==NULL && sc->script->scriptname[0] != '\0')
+		BPY_run_python_script(C, sc->script->scriptname, NULL, NULL);
+		
+	if (sc->script->py_draw==NULL)
+		return 0;
+	
+	return 1;
+}
+
+int BPY_run_script_space_draw(const struct bContext *C, SpaceScript * sc)
+{
+	if (bpy_run_script_init( (bContext *)C, sc)) {
+		PyGILState_STATE gilstate = PyGILState_Ensure();
+		PyObject *result = PyObject_CallObject( sc->script->py_draw, NULL );
+		
+		if (result==NULL)
+			exit_pydraw(sc, 1);
+			
+		PyGILState_Release(gilstate);
+	}
+	return 1;
+}
+
+// XXX - not used yet, listeners dont get a context
+int BPY_run_script_space_listener(bContext *C, SpaceScript * sc)
+{
+	if (bpy_run_script_init(C, sc)) {
+		PyGILState_STATE gilstate = PyGILState_Ensure();
+		
+		PyObject *result = PyObject_CallObject( sc->script->py_draw, NULL );
+		
+		if (result==NULL)
+			exit_pydraw(sc, 1);
+			
+		PyGILState_Release(gilstate);
+	}
+	return 1;
+}
+
+void BPY_DECREF(void *pyob_ptr)
+{
+	Py_DECREF((PyObject *)pyob_ptr);
+}
+
+#if 0
+/* called from the the scripts window, assume context is ok */
+int BPY_run_python_script_space(const char *modulename, const char *func)
+{
+	PyObject *py_dict, *py_result= NULL;
+	char pystring[512];
+	PyGILState_STATE gilstate;
+	
+	/* for calling the module function */
+	PyObject *py_func, 
+	
+	gilstate = PyGILState_Ensure();
+	
+	py_dict = CreateGlobalDictionary(C);
+	
+	PyObject *module = PyImport_ImportModule(scpt->script.filename);
+	if (module==NULL) {
+		PyErr_SetFormat(PyExc_SystemError, "could not import '%s'", scpt->script.filename);
+	}
+	else {
+		py_func = PyObject_GetAttrString(modulename, func);
+		if (py_func==NULL) {
+			PyErr_SetFormat(PyExc_SystemError, "module has no function '%s.%s'\n", scpt->script.filename, func);
+		}
+		else {
+			Py_DECREF(py_func);
+			if (!PyCallable_Check(py_func)) {
+				PyErr_SetFormat(PyExc_SystemError, "module item is not callable '%s.%s'\n", scpt->script.filename, func);
+			}
+			else {
+				py_result= PyObject_CallObject(py_func, NULL); // XXX will need args eventually
+			}
+		}
+	}
+	
+	if (!py_result) {
+		BPy_errors_to_report(NULL); // TODO - reports
+	} else
+		Py_DECREF( py_result );
+	
+	Py_XDECREF(module);
+	
+	Py_DECREF(py_dict);
+	
+	PyGILState_Release(gilstate);
+	return 1;
+}
+#endif
+
+// #define TIME_REGISTRATION
+
+#ifdef TIME_REGISTRATION
+#include "PIL_time.h"
+#endif
+
+/* for use by BPY_run_ui_scripts only */
+static int bpy_import_module(char *modname, int reload)
+{
+	PyObject *mod= PyImport_ImportModuleLevel(modname, NULL, NULL, NULL, 0);
+	if (mod) {
+		if (reload) {
+			PyObject *mod_orig= mod;
+			mod= PyImport_ReloadModule(mod);
+			Py_DECREF(mod_orig);
+		}
+	}
+
+	if(mod) {
+		Py_DECREF(mod); /* could be NULL from reloading */
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+/* XXX this is temporary, need a proper script registration system for 2.5 */
+void BPY_run_ui_scripts(bContext *C, int reload)
+{
+#ifdef TIME_REGISTRATION
+	double time = PIL_check_seconds_timer();
+#endif
+	DIR *dir; 
+	struct dirent *de;
+	char *file_extension;
+	char *dirname;
+	char path[FILE_MAX];
+	char *dirs[] = {"ui", "io", NULL};
+	int a, err;
+	
+	PyGILState_STATE gilstate;
+	PyObject *sys_path;
+
+	bpy_context_set(C, &gilstate);
+
+	sys_path= PySys_GetObject("path"); /* borrow */
+	PyList_Insert(sys_path, 0, Py_None); /* place holder, resizes the list */
+
+	for(a=0; dirs[a]; a++) {
+		dirname= BLI_gethome_folder(dirs[a]);
+
+		if(!dirname)
+			continue;
+
+		dir = opendir(dirname);
+
+		if(!dir)
+			continue;
+		
+		/* set the first dir in the sys.path for fast importing of modules */
+		PyList_SetItem(sys_path, 0, PyUnicode_FromString(dirname)); /* steals the ref */
+			
+		while((de = readdir(dir)) != NULL) {
+			/* We could stat the file but easier just to let python
+			 * import it and complain if theres a problem */
+			err = 0;
+
+			if (de->d_name[0] == '.') {
+				/* do nothing, probably .svn */
+			}
+			else if ((file_extension = strstr(de->d_name, ".py"))) {
+				/* normal py files? */
+				if(file_extension && file_extension[3] == '\0') {
+					de->d_name[(file_extension - de->d_name)] = '\0';
+					err= bpy_import_module(de->d_name, reload);
+				}
+			}
+#ifndef __linux__
+			else if( BLI_join_dirfile(path, dirname, de->d_name), S_ISDIR(BLI_exist(path))) {
+#else
+			else if(de->d_type==DT_DIR) {
+				BLI_join_dirfile(path, dirname, de->d_name);
+#endif
+				/* support packages */
+				BLI_join_dirfile(path, path, "__init__.py");
+
+				if(BLI_exists(path)) {
+					err= bpy_import_module(de->d_name, reload);
+				}
+			}
+
+			if(err==-1) {
+				BPy_errors_to_report(NULL);
+				fprintf(stderr, "unable to import %s/%s\n", dirname, de->d_name);
+			}
+		}
+
+		closedir(dir);
+	}
+	
+	PyList_SetSlice(sys_path, 0, 1, NULL); /* remove the first item */
+
+	bpy_context_clear(C, &gilstate);
+	
+#ifdef TIME_REGISTRATION
+	printf("script time %f\n", (PIL_check_seconds_timer()-time));
+#endif
+
+	/* reset the timer so as not to take loading into the stats */
+	bpy_timer_count = 0;
+}
+
+/* ****************************************** */
+/* Drivers - PyExpression Evaluation */
+
+/* for pydrivers (drivers using one-line Python expressions to express relationships between targets) */
+PyObject *bpy_pydriver_Dict = NULL;
+
+/* For faster execution we keep a special dictionary for pydrivers, with
+ * the needed modules and aliases. 
+ */
+static int bpy_pydriver_create_dict(void)
+{
+	PyObject *d, *mod;
+	
+	/* validate namespace for driver evaluation */
+	if (bpy_pydriver_Dict) return -1;
+
+	d = PyDict_New();
+	if (d == NULL) 
+		return -1;
+	else
+		bpy_pydriver_Dict = d;
+
+	/* import some modules: builtins, bpy, math, (Blender.noise )*/
+	PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins());
+
+	mod = PyImport_ImportModule("math");
+	if (mod) {
+		PyDict_Merge(d, PyModule_GetDict(mod), 0); /* 0 - dont overwrite existing values */
+		
+		/* Only keep for backwards compat! - just import all math into root, they are standard */
+		PyDict_SetItemString(d, "math", mod);
+		PyDict_SetItemString(d, "m", mod);
+		Py_DECREF(mod);
+	} 
+	
+	/* add bpy to global namespace */
+	mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
+	if (mod) {
+		PyDict_SetItemString(bpy_pydriver_Dict, "bpy", mod);
+		Py_DECREF(mod);
+	}
+	
+	
+#if 0 // non existant yet
+	mod = PyImport_ImportModule("Blender.Noise");
+	if (mod) {
+		PyDict_SetItemString(d, "noise", mod);
+		PyDict_SetItemString(d, "n", mod);
+		Py_DECREF(mod);
+	} else {
+		PyErr_Clear();
+	}
+	
+	/* If there's a Blender text called pydrivers.py, import it.
+	 * Users can add their own functions to this module. 
+	 */
+	if (G.f & G_DOSCRIPTLINKS) {
+		mod = importText("pydrivers"); /* can also use PyImport_Import() */
+		if (mod) {
+			PyDict_SetItemString(d, "pydrivers", mod);
+			PyDict_SetItemString(d, "p", mod);
+			Py_DECREF(mod);
+		} else {
+			PyErr_Clear();
+		}
+	}
+#endif // non existant yet
+	
+	return 0;
+}
+
+/* Update function, it gets rid of pydrivers global dictionary, forcing
+ * BPY_pydriver_eval to recreate it. This function is used to force
+ * reloading the Blender text module "pydrivers.py", if available, so
+ * updates in it reach pydriver evaluation. 
+ */
+void BPY_pydriver_update(void)
+{
+	PyGILState_STATE gilstate = PyGILState_Ensure();
+
+	if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
+		PyDict_Clear(bpy_pydriver_Dict);
+		Py_DECREF(bpy_pydriver_Dict);
+		bpy_pydriver_Dict = NULL;
+	}
+
+	PyGILState_Release(gilstate);
+
+	return;
+}
+
+/* error return function for BPY_eval_pydriver */
+static float pydriver_error(ChannelDriver *driver) 
+{
+	if (bpy_pydriver_Dict) { /* free the global dict used by pydrivers */
+		PyDict_Clear(bpy_pydriver_Dict);
+		Py_DECREF(bpy_pydriver_Dict);
+		bpy_pydriver_Dict = NULL;
+	}
+
+	driver->flag |= DRIVER_FLAG_INVALID; /* py expression failed */
+	fprintf(stderr, "\nError in Driver: The following Python expression failed:\n\t'%s'\n\n", driver->expression);
+	
+	BPy_errors_to_report(NULL); // TODO - reports
+
+	return 0.0f;
+}
+
+/* This evals py driver expressions, 'expr' is a Python expression that
+ * should evaluate to a float number, which is returned. 
+ */
+float BPY_pydriver_eval (ChannelDriver *driver)
+{
+	PyObject *driver_vars=NULL;
+	PyObject *retval;
+	PyGILState_STATE gilstate;
+	
+	DriverTarget *dtar;
+	float result = 0.0f; /* default return */
+	char *expr = NULL;
+	short targets_ok= 1;
+	
+	/* sanity checks - should driver be executed? */
+	if ((driver == NULL) /*|| (G.f & G_DOSCRIPTLINKS)==0*/) 
+		return result;
+	
+	/* get the py expression to be evaluated */
+	expr = driver->expression; 
+	if ((expr == NULL) || (expr[0]=='\0')) 
+		return result;
+
+	gilstate = PyGILState_Ensure();
+	
+	/* init global dictionary for py-driver evaluation settings */
+	if (!bpy_pydriver_Dict) {
+		if (bpy_pydriver_create_dict() != 0) {
+			fprintf(stderr, "Pydriver error: couldn't create Python dictionary");
+			PyGILState_Release(gilstate);
+			return result;
+		}
+	}
+	
+	/* add target values to a dict that will be used as '__locals__' dict */
+	driver_vars = PyDict_New(); // XXX do we need to decref this?
+	for (dtar= driver->targets.first; dtar; dtar= dtar->next) {
+		PyObject *driver_arg = NULL;
+		float tval = 0.0f;
+		
+		/* try to get variable value */
+		tval= driver_get_target_value(driver, dtar);
+		driver_arg= PyFloat_FromDouble((double)tval);
+		
+		/* try to add to dictionary */
+		if (PyDict_SetItemString(driver_vars, dtar->name, driver_arg)) {
+			/* this target failed - bad name */
+			if (targets_ok) {
+				/* first one - print some extra info for easier identification */
+				fprintf(stderr, "\nBPY_pydriver_eval() - Error while evaluating PyDriver:\n");
+				targets_ok= 0;
+			}
+			
+			fprintf(stderr, "\tBPY_pydriver_eval() - couldn't add variable '%s' to namespace \n", dtar->name);
+			BPy_errors_to_report(NULL); // TODO - reports
+		}
+	}
+	
+	/* execute expression to get a value */
+	retval = PyRun_String(expr, Py_eval_input, bpy_pydriver_Dict, driver_vars);
+	
+	/* decref the driver vars first...  */
+	Py_DECREF(driver_vars);
+	
+	/* process the result */
+	if (retval == NULL) {
+		result = pydriver_error(driver);
+		PyGILState_Release(gilstate);
+		return result;
+	}
+
+	result = (float)PyFloat_AsDouble(retval);
+	Py_DECREF(retval);
+	
+	if ((result == -1) && PyErr_Occurred()) {
+		result = pydriver_error(driver);
+		PyGILState_Release(gilstate);
+		return result;
+	}
+	
+	/* all fine, make sure the "invalid expression" flag is cleared */
+	driver->flag &= ~DRIVER_FLAG_INVALID;
+
+	PyGILState_Release(gilstate);
+
+	return result;
+}
+
+int BPY_button_eval(bContext *C, char *expr, double *value)
+{
+	PyGILState_STATE gilstate;
+	PyObject *dict, *retval;
+	int error_ret = 0;
+	
+	if (!value || !expr || expr[0]=='\0') return -1;
+	
+	bpy_context_set(C, &gilstate);
+	
+	dict= CreateGlobalDictionary(C);
+	retval = PyRun_String(expr, Py_eval_input, dict, dict);
+	
+	if (retval == NULL) {
+		error_ret= -1;
+	}
+	else {
+		double val;
+
+		if(PyTuple_Check(retval)) {
+			/* Users my have typed in 10km, 2m
+			 * add up all values */
+			int i;
+			val= 0.0;
+
+			for(i=0; i<PyTuple_GET_SIZE(retval); i++) {
+				val+= PyFloat_AsDouble(PyTuple_GET_ITEM(retval, i));
+			}
+		}
+		else {
+			val = PyFloat_AsDouble(retval);
+		}
+		Py_DECREF(retval);
+		
+		if(val==-1 && PyErr_Occurred()) {
+			error_ret= -1;
+		}
+		else {
+			*value= val;
+		}
+	}
+	
+	if(error_ret) {
+		BPy_errors_to_report(CTX_wm_reports(C));
+	}
+	
+	Py_DECREF(dict);
+	bpy_context_clear(C, &gilstate);
+	
+	return error_ret;
+}
+

source/blender/python/intern/bpy_operator.c

@@ -0,0 +1,234 @@
+
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/* Note, this module is not to be used directly by the user.
+ * its accessed from blender with bpy.__ops__
+ * */
+
+#include "bpy_operator.h"
+#include "bpy_operator_wrap.h"
+#include "bpy_rna.h" /* for setting arg props only - pyrna_py_to_prop() */
+#include "bpy_util.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "MEM_guardedalloc.h"
+#include "BKE_report.h"
+#include "BKE_utildefines.h"
+
+
+static PyObject *pyop_call( PyObject * self, PyObject * args)
+{
+	wmOperatorType *ot;
+	int error_val = 0;
+	PointerRNA ptr;
+	
+	char		*opname;
+	PyObject	*kw= NULL; /* optional args */
+
+	/* note that context is an int, python does the conversion in this case */
+	int context= WM_OP_EXEC_DEFAULT;
+
+	// XXX Todo, work out a better solution for passing on context, could make a tuple from self and pack the name and Context into it...
+	bContext *C = BPy_GetContext();
+	
+	if (!PyArg_ParseTuple(args, "s|O!i:bpy.__ops__.call", &opname, &PyDict_Type, &kw, &context))
+		return NULL;
+
+	ot= WM_operatortype_find(opname, TRUE);
+
+	if (ot == NULL) {
+		PyErr_Format( PyExc_SystemError, "bpy.__ops__.call: operator \"%s\"could not be found", opname);
+		return NULL;
+	}
+	
+	if(WM_operator_poll((bContext*)C, ot) == FALSE) {
+		PyErr_SetString( PyExc_SystemError, "bpy.__ops__.call: operator poll() function failed, context is incorrect");
+		return NULL;
+	}
+
+	/* WM_operator_properties_create(&ptr, opname); */
+	/* Save another lookup */
+	RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
+	
+	if(kw && PyDict_Size(kw))
+		error_val= pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
+
+	
+	if (error_val==0) {
+		ReportList *reports;
+
+		reports= MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");
+		BKE_reports_init(reports, RPT_STORE);
+
+		WM_operator_call_py(C, ot, context, &ptr, reports);
+
+		if(BPy_reports_to_error(reports))
+			error_val = -1;
+
+		BKE_reports_clear(reports);
+		if ((reports->flag & RPT_FREE) == 0)
+		{
+			MEM_freeN(reports);
+		}
+	}
+
+	WM_operator_properties_free(&ptr);
+
+#if 0
+	/* if there is some way to know an operator takes args we should use this */
+	{
+		/* no props */
+		if (kw != NULL) {
+			PyErr_Format(PyExc_AttributeError, "Operator \"%s\" does not take any args", opname);
+			return NULL;
+		}
+
+		WM_operator_name_call(C, opname, WM_OP_EXEC_DEFAULT, NULL);
+	}
+#endif
+
+	if (error_val==-1) {
+		return NULL;
+	}
+
+	Py_RETURN_NONE;
+}
+
+static PyObject *pyop_as_string( PyObject * self, PyObject * args)
+{
+	wmOperatorType *ot;
+	PointerRNA ptr;
+
+	char		*opname;
+	PyObject	*kw= NULL; /* optional args */
+	int all_args = 1;
+	int error_val= 0;
+
+	char *buf;
+	PyObject *pybuf;
+
+	bContext *C = BPy_GetContext();
+
+	if (!PyArg_ParseTuple(args, "s|O!i:bpy.__ops__.as_string", &opname, &PyDict_Type, &kw, &all_args))
+		return NULL;
+
+	ot= WM_operatortype_find(opname, TRUE);
+
+	if (ot == NULL) {
+		PyErr_Format( PyExc_SystemError, "bpy.__ops__.as_string: operator \"%s\"could not be found", opname);
+		return NULL;
+	}
+
+	/* WM_operator_properties_create(&ptr, opname); */
+	/* Save another lookup */
+	RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
+
+	if(kw && PyDict_Size(kw))
+		error_val= pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");
+
+	if (error_val==0)
+		buf= WM_operator_pystring(C, ot, &ptr, all_args);
+
+	WM_operator_properties_free(&ptr);
+
+	if (error_val==-1) {
+		return NULL;
+	}
+
+	if(buf) {
+		pybuf= PyUnicode_FromString(buf);
+		MEM_freeN(buf);
+	}
+	else {
+		pybuf= PyUnicode_FromString("");
+	}
+
+	return pybuf;
+}
+
+static PyObject *pyop_dir(PyObject *self)
+{
+	PyObject *list = PyList_New(0), *name;
+	wmOperatorType *ot;
+	
+	for(ot= WM_operatortype_first(); ot; ot= ot->next) {
+		name = PyUnicode_FromString(ot->idname);
+		PyList_Append(list, name);
+		Py_DECREF(name);
+	}
+	
+	return list;
+}
+
+static PyObject *pyop_getrna(PyObject *self, PyObject *value)
+{
+	wmOperatorType *ot;
+	PointerRNA ptr;
+	char *opname= _PyUnicode_AsString(value);
+	BPy_StructRNA *pyrna= NULL;
+	
+	if(opname==NULL) {
+		PyErr_SetString(PyExc_TypeError, "bpy.__ops__.get_rna() expects a string argument");
+		return NULL;
+	}
+	ot= WM_operatortype_find(opname, TRUE);
+	if(ot==NULL) {
+		PyErr_Format(PyExc_KeyError, "bpy.__ops__.get_rna(\"%s\") not found", opname);
+		return NULL;
+	}
+	
+	/* type */
+	//RNA_pointer_create(NULL, &RNA_Struct, ot->srna, &ptr);
+
+	/* XXX - should call WM_operator_properties_free */
+	WM_operator_properties_create(&ptr, ot->idname);
+	pyrna= (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr);
+	pyrna->freeptr= TRUE;
+	return (PyObject *)pyrna;
+}
+
+PyObject *BPY_operator_module( void )
+{
+	static PyMethodDef pyop_call_meth =		{"call", (PyCFunction) pyop_call, METH_VARARGS, NULL};
+	static PyMethodDef pyop_as_string_meth ={"as_string", (PyCFunction) pyop_as_string, METH_VARARGS, NULL};
+	static PyMethodDef pyop_dir_meth =		{"dir", (PyCFunction) pyop_dir, METH_NOARGS, NULL};
+	static PyMethodDef pyop_getrna_meth =	{"get_rna", (PyCFunction) pyop_getrna, METH_O, NULL};
+	static PyMethodDef pyop_add_meth =		{"add", (PyCFunction) PYOP_wrap_add, METH_O, NULL};
+	static PyMethodDef pyop_remove_meth =	{"remove", (PyCFunction) PYOP_wrap_remove, METH_O, NULL};
+
+	PyObject *submodule = PyModule_New("bpy.__ops__");
+	PyDict_SetItemString(PySys_GetObject("modules"), "bpy.__ops__", submodule);
+
+	PyModule_AddObject( submodule, "call",	PyCFunction_New(&pyop_call_meth,	NULL) );
+	PyModule_AddObject( submodule, "as_string",PyCFunction_New(&pyop_as_string_meth,NULL) );
+	PyModule_AddObject( submodule, "dir",		PyCFunction_New(&pyop_dir_meth,		NULL) );
+	PyModule_AddObject( submodule, "get_rna",	PyCFunction_New(&pyop_getrna_meth,	NULL) );
+	PyModule_AddObject( submodule, "add",		PyCFunction_New(&pyop_add_meth,		NULL) );
+	PyModule_AddObject( submodule, "remove",	PyCFunction_New(&pyop_remove_meth,	NULL) );
+
+	return submodule;
+}

source/blender/python/intern/bpy_operator.h

@@ -0,0 +1,45 @@
+
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BPY_OPERATOR_H
+#define BPY_OPERATOR_H
+
+#include <Python.h>
+
+#include "RNA_access.h"
+#include "RNA_types.h"
+#include "DNA_windowmanager_types.h"
+#include "BKE_context.h"
+
+extern PyTypeObject pyop_base_Type;
+
+#define BPy_OperatorBase_Check(v)	(PyObject_TypeCheck(v, &pyop_base_Type))
+
+typedef struct {
+	PyObject_HEAD /* required python macro   */
+} BPy_OperatorBase;
+
+PyObject *BPY_operator_module(void);
+
+#endif

source/blender/python/intern/bpy_operator_wrap.c

@@ -0,0 +1,450 @@
+
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+
+#include "bpy_operator_wrap.h"
+#include "BLI_listbase.h"
+#include "BKE_context.h"
+#include "BKE_report.h"
+#include "DNA_windowmanager_types.h"
+#include "MEM_guardedalloc.h"
+#include "WM_api.h"
+#include "WM_types.h"
+#include "ED_screen.h"
+
+#include "RNA_define.h"
+
+#include "bpy_rna.h"
+#include "bpy_util.h"
+
+#include "../generic/bpy_internal_import.h" // our own imports
+
+#define PYOP_ATTR_PROP			"__props__"
+#define PYOP_ATTR_UINAME		"__label__"
+#define PYOP_ATTR_IDNAME		"__idname__"	/* the name given by python */
+#define PYOP_ATTR_IDNAME_BL		"__idname_bl__"	/* our own name converted into blender syntax, users wont see this */
+#define PYOP_ATTR_DESCRIPTION	"__doc__"	/* use pythons docstring */
+#define PYOP_ATTR_REGISTER		"__register__"	/* True/False. if this python operator should be registered */
+
+static struct BPY_flag_def pyop_ret_flags[] = {
+	{"RUNNING_MODAL", OPERATOR_RUNNING_MODAL},
+	{"CANCELLED", OPERATOR_CANCELLED},
+	{"FINISHED", OPERATOR_FINISHED},
+	{"PASS_THROUGH", OPERATOR_PASS_THROUGH},
+	{NULL, 0}
+};
+
+/* This invoke function can take events and
+ *
+ * It is up to the pyot->py_invoke() python func to run pyot->py_exec()
+ * the invoke function gets the keyword props as a dict, but can parse them
+ * to py_exec like this...
+ *
+ * def op_exec(x=-1, y=-1, text=""):
+ *     ...
+ *
+ * def op_invoke(event, prop_defs):
+ *     prop_defs['x'] = event['x']
+ *     ...
+ *     op_exec(**prop_defs)
+ *
+ * when there is no invoke function, C calls exec and sets the props.
+ * python class instance is stored in op->customdata so exec() can access
+ */
+
+
+#define PYOP_EXEC 1
+#define PYOP_INVOKE 2
+#define PYOP_POLL 3
+	
+extern void BPY_update_modules( void ); //XXX temp solution
+
+static int PYTHON_OT_generic(int mode, bContext *C, wmOperatorType *ot, wmOperator *op, wmEvent *event)
+{
+	PyObject *py_class = ot->pyop_data;
+	PyObject *args;
+	PyObject *ret= NULL, *py_class_instance, *item= NULL;
+	int ret_flag= (mode==PYOP_POLL ? 0:OPERATOR_CANCELLED);
+	PointerRNA ptr_context;
+	PointerRNA ptr_operator;
+	PointerRNA ptr_event;
+	PyObject *py_operator;
+
+	PyGILState_STATE gilstate;
+
+	bpy_context_set(C, &gilstate);
+
+	args = PyTuple_New(1);
+	PyTuple_SET_ITEM(args, 0, PyObject_GetAttrString(py_class, "__rna__")); // need to use an rna instance as the first arg
+	py_class_instance = PyObject_Call(py_class, args, NULL);
+	Py_DECREF(args);
+	
+	if (py_class_instance) { /* Initializing the class worked, now run its invoke function */
+		
+		
+		/* Assign instance attributes from operator properties */
+		if(op) {
+			const char *arg_name;
+
+			RNA_STRUCT_BEGIN(op->ptr, prop) {
+				arg_name= RNA_property_identifier(prop);
+
+				if (strcmp(arg_name, "rna_type")==0) continue;
+
+				item = pyrna_prop_to_py(op->ptr, prop);
+				PyObject_SetAttrString(py_class_instance, arg_name, item);
+				Py_DECREF(item);
+			}
+			RNA_STRUCT_END;
+		}
+
+		/* set operator pointer RNA as instance "__operator__" attribute */
+		if(op) {
+			RNA_pointer_create(NULL, &RNA_Operator, op, &ptr_operator);
+			py_operator= pyrna_struct_CreatePyObject(&ptr_operator);
+			PyObject_SetAttrString(py_class_instance, "__operator__", py_operator);
+			Py_DECREF(py_operator);
+		}
+
+		RNA_pointer_create(NULL, &RNA_Context, C, &ptr_context);
+		
+		if (mode==PYOP_INVOKE) {
+			item= PyObject_GetAttrString(py_class, "invoke");
+			args = PyTuple_New(3);
+			
+			RNA_pointer_create(NULL, &RNA_Event, event, &ptr_event);
+
+			// PyTuple_SET_ITEM "steals" object reference, it is
+			// an object passed shouldn't be DECREF'ed
+			PyTuple_SET_ITEM(args, 1, pyrna_struct_CreatePyObject(&ptr_context));
+			PyTuple_SET_ITEM(args, 2, pyrna_struct_CreatePyObject(&ptr_event));
+		}
+		else if (mode==PYOP_EXEC) {
+			item= PyObject_GetAttrString(py_class, "execute");
+			args = PyTuple_New(2);
+			
+			PyTuple_SET_ITEM(args, 1, pyrna_struct_CreatePyObject(&ptr_context));
+		}
+		else if (mode==PYOP_POLL) {
+			item= PyObject_GetAttrString(py_class, "poll");
+			args = PyTuple_New(2);
+			PyTuple_SET_ITEM(args, 1, pyrna_struct_CreatePyObject(&ptr_context));
+		}
+		PyTuple_SET_ITEM(args, 0, py_class_instance);
+	
+		ret = PyObject_Call(item, args, NULL);
+		
+		Py_DECREF(args);
+		Py_DECREF(item);
+	}
+	
+	if (ret == NULL) { /* covers py_class_instance failing too */
+		if(op)
+			BPy_errors_to_report(op->reports);
+	}
+	else {
+		if (mode==PYOP_POLL) {
+			if (PyBool_Check(ret) == 0) {
+				PyErr_SetString(PyExc_ValueError, "Python poll function return value ");
+				if(op)
+					BPy_errors_to_report(op->reports);
+			}
+			else {
+				ret_flag= ret==Py_True ? 1:0;
+			}
+			
+		} else if (BPY_flag_from_seq(pyop_ret_flags, ret, &ret_flag) == -1) {
+			/* the returned value could not be converted into a flag */
+			if(op)
+				BPy_errors_to_report(op->reports);
+
+			ret_flag = OPERATOR_CANCELLED;
+		}
+		/* there is no need to copy the py keyword dict modified by
+		 * pyot->py_invoke(), back to the operator props since they are just
+		 * thrown away anyway
+		 *
+		 * If we ever want to do this and use the props again,
+		 * it can be done with - pyrna_pydict_to_props(op->ptr, kw, "")
+		 */
+		
+		Py_DECREF(ret);
+	}
+
+#if 0 /* only for testing */
+
+	/* print operator return value */
+	if (mode != PYOP_POLL) {
+		char flag_str[100];
+		char class_name[100];
+		BPY_flag_def *flag_def = pyop_ret_flags;
+
+		strcpy(flag_str, "");
+		
+		while(flag_def->name) {
+			if (ret_flag & flag_def->flag) {
+				if(flag_str[1])
+					sprintf(flag_str, "%s | %s", flag_str, flag_def->name);
+				else
+					strcpy(flag_str, flag_def->name);
+			}
+			flag_def++;
+		}
+
+		/* get class name */
+		item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME);
+		strcpy(class_name, _PyUnicode_AsString(item));
+		Py_DECREF(item);
+
+		fprintf(stderr, "%s's %s returned %s\n", class_name, mode == PYOP_EXEC ? "execute" : "invoke", flag_str);
+	}
+#endif
+
+	bpy_context_clear(C, &gilstate);
+
+	return ret_flag;
+}
+
+static int PYTHON_OT_invoke(bContext *C, wmOperator *op, wmEvent *event)
+{
+	return PYTHON_OT_generic(PYOP_INVOKE, C, op->type, op, event);	
+}
+
+static int PYTHON_OT_execute(bContext *C, wmOperator *op)
+{
+	return PYTHON_OT_generic(PYOP_EXEC, C, op->type, op, NULL);
+}
+
+static int PYTHON_OT_poll(bContext *C, wmOperatorType *ot)
+{
+	return PYTHON_OT_generic(PYOP_POLL, C, ot, NULL, NULL);
+}
+
+void PYTHON_OT_wrapper(wmOperatorType *ot, void *userdata)
+{
+	PyObject *py_class = (PyObject *)userdata;
+	PyObject *props, *item;
+
+	/* identifiers */
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME_BL);
+	ot->idname= _PyUnicode_AsString(item);
+	Py_DECREF(item);
+
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_UINAME);
+	if (item) {
+		ot->name= _PyUnicode_AsString(item);
+		Py_DECREF(item);
+	}
+	else {
+		ot->name= ot->idname;
+		PyErr_Clear();
+	}
+
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_DESCRIPTION);
+	ot->description= (item && PyUnicode_Check(item)) ? _PyUnicode_AsString(item):"undocumented python operator";
+	Py_XDECREF(item);
+	
+	/* api callbacks, detailed checks dont on adding */ 
+	if (PyObject_HasAttrString(py_class, "invoke"))
+		ot->invoke= PYTHON_OT_invoke;
+	if (PyObject_HasAttrString(py_class, "execute"))
+		ot->exec= PYTHON_OT_execute;
+	if (PyObject_HasAttrString(py_class, "poll"))
+		ot->pyop_poll= PYTHON_OT_poll;
+	
+	ot->pyop_data= userdata;
+	
+	/* flags */
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_REGISTER);
+	if (item) {
+		ot->flag= PyObject_IsTrue(item)!=0 ? OPTYPE_REGISTER:0;
+		Py_DECREF(item);
+	}
+	else {
+		ot->flag= OPTYPE_REGISTER; /* unspesified, leave on for now to help debug */
+		PyErr_Clear();
+	}
+	
+	props= PyObject_GetAttrString(py_class, PYOP_ATTR_PROP);
+	
+	if (props) {
+		PyObject *dummy_args = PyTuple_New(0);
+		int i;
+
+		for(i=0; i<PyList_Size(props); i++) {
+			PyObject *py_func_ptr, *py_kw, *py_srna_cobject, *py_ret;
+			item = PyList_GET_ITEM(props, i);
+			
+			if (PyArg_ParseTuple(item, "O!O!:PYTHON_OT_wrapper", &PyCObject_Type, &py_func_ptr, &PyDict_Type, &py_kw)) {
+				
+				PyObject *(*pyfunc)(PyObject *, PyObject *, PyObject *);
+				pyfunc = PyCObject_AsVoidPtr(py_func_ptr);
+				py_srna_cobject = PyCObject_FromVoidPtr(ot->srna, NULL);
+				
+				py_ret = pyfunc(py_srna_cobject, dummy_args, py_kw);
+				if (py_ret) {
+					Py_DECREF(py_ret);
+				} else {
+					fprintf(stderr, "BPy Operator \"%s\" registration error: %s item %d could not run\n", ot->idname, PYOP_ATTR_PROP, i);
+					PyLineSpit();
+					PyErr_Print();
+					PyErr_Clear();
+				}
+				Py_DECREF(py_srna_cobject);
+				
+			} else {
+				/* cant return NULL from here */ // XXX a bit ugly
+				PyErr_Print();
+				PyErr_Clear();
+			}
+			
+			// expect a tuple with a CObject and a dict
+		}
+		Py_DECREF(dummy_args);
+		Py_DECREF(props);
+	} else {
+		PyErr_Clear();
+	}
+}
+
+
+/* pyOperators - Operators defined IN Python */
+PyObject *PYOP_wrap_add(PyObject *self, PyObject *py_class)
+{	
+	PyObject *base_class, *item;
+	wmOperatorType *ot;
+	
+	
+	char *idname= NULL;
+	char idname_bl[OP_MAX_TYPENAME]; /* converted to blender syntax */
+	int i;
+
+	static struct BPY_class_attr_check pyop_class_attr_values[]= {
+		{PYOP_ATTR_IDNAME,		's', -1, OP_MAX_TYPENAME-3,	0}, /* -3 because a.b -> A_OT_b */
+		{PYOP_ATTR_UINAME,		's', -1,-1,	BPY_CLASS_ATTR_OPTIONAL},
+		{PYOP_ATTR_PROP,		'l', -1,-1,	BPY_CLASS_ATTR_OPTIONAL},
+		{PYOP_ATTR_DESCRIPTION,	's', -1,-1,	BPY_CLASS_ATTR_NONE_OK},
+		{"execute",				'f', 2,	-1, BPY_CLASS_ATTR_OPTIONAL},
+		{"invoke",				'f', 3,	-1, BPY_CLASS_ATTR_OPTIONAL},
+		{"poll",				'f', 2,	-1, BPY_CLASS_ATTR_OPTIONAL},
+		{NULL, 0, 0, 0}
+	};
+
+	// in python would be...
+	//PyObject *optype = PyObject_GetAttrString(PyObject_GetAttrString(PyDict_GetItemString(PyEval_GetGlobals(), "bpy"), "types"), "Operator");
+	base_class = PyObject_GetAttrStringArgs(PyDict_GetItemString(PyEval_GetGlobals(), "bpy"), 2, "types", "Operator");
+
+	if(BPY_class_validate("Operator", py_class, base_class, pyop_class_attr_values, NULL) < 0) {
+		return NULL; /* BPY_class_validate sets the error */
+	}
+	Py_DECREF(base_class);
+
+	/* class name is used for operator ID - this can be changed later if we want */
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME);
+	idname =  _PyUnicode_AsString(item);
+
+
+	/* annoying conversion! */
+	WM_operator_bl_idname(idname_bl, idname);
+	Py_DECREF(item);
+
+	item= PyUnicode_FromString(idname_bl);
+	PyObject_SetAttrString(py_class, PYOP_ATTR_IDNAME_BL, item);
+	idname =  _PyUnicode_AsString(item);
+	Py_DECREF(item);
+	/* end annoying conversion! */
+
+	
+	/* remove if it already exists */
+	if ((ot=WM_operatortype_exists(idname))) {
+		if(ot->pyop_data) {
+			Py_XDECREF((PyObject*)ot->pyop_data);
+		}
+		WM_operatortype_remove(idname);
+	}
+	
+	/* If we have properties set, check its a list of dicts */
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_PROP);
+	if (item) {
+		for(i=0; i<PyList_Size(item); i++) {
+			PyObject *py_args = PyList_GET_ITEM(item, i);
+			PyObject *py_func_ptr, *py_kw; /* place holders */
+			
+			if (!PyArg_ParseTuple(py_args, "O!O!", &PyCObject_Type, &py_func_ptr, &PyDict_Type, &py_kw)) {
+				PyErr_Format(PyExc_ValueError, "Cant register operator class - %s.properties must contain values from FloatProperty", idname);
+				return NULL;				
+			}
+		}
+		Py_DECREF(item);
+	}
+	else {
+		PyErr_Clear();
+	}
+	
+	Py_INCREF(py_class);
+	WM_operatortype_append_ptr(PYTHON_OT_wrapper, py_class);
+
+	Py_RETURN_NONE;
+}
+
+PyObject *PYOP_wrap_remove(PyObject *self, PyObject *value)
+{
+	PyObject *py_class;
+	char *idname= NULL;
+	wmOperatorType *ot;
+	
+
+	if (PyUnicode_Check(value))
+		idname = _PyUnicode_AsString(value);
+	else if (PyCFunction_Check(value)) {
+		PyObject *cfunc_self = PyCFunction_GetSelf(value);
+		if (cfunc_self)
+			idname = _PyUnicode_AsString(cfunc_self);
+	}
+	
+	if (idname==NULL) {
+		PyErr_SetString( PyExc_ValueError, "Expected the operator name as a string or the operator function");
+		return NULL;
+	}
+
+	if (!(ot= WM_operatortype_exists(idname))) {
+		PyErr_Format( PyExc_AttributeError, "Operator \"%s\" does not exists, cant remove", idname);
+		return NULL;
+	}
+	
+	if (!(py_class= (PyObject *)ot->pyop_data)) {
+		PyErr_Format( PyExc_AttributeError, "Operator \"%s\" was not created by python", idname);
+		return NULL;
+	}
+	
+	Py_XDECREF(py_class);
+
+	WM_operatortype_remove(idname);
+
+	Py_RETURN_NONE;
+}
+
+
+

source/blender/python/intern/bpy_operator_wrap.h

@@ -0,0 +1,34 @@
+
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BPY_OPERATOR_WRAP_H
+#define BPY_OPERATOR_WRAP_H
+
+#include <Python.h>
+
+/* these are used for operator methods, used by bpy_operator.c */
+PyObject *PYOP_wrap_add(PyObject *self, PyObject *args);
+PyObject *PYOP_wrap_remove(PyObject *self, PyObject *args);
+
+#endif

source/blender/python/intern/bpy_rna.h

@@ -0,0 +1,106 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BPY_RNA_H
+#define BPY_RNA_H
+
+#include <Python.h>
+
+#include "RNA_access.h"
+#include "RNA_types.h"
+#include "BKE_idprop.h"
+
+extern PyTypeObject pyrna_struct_Type;
+extern PyTypeObject pyrna_prop_Type;
+
+#define BPy_StructRNA_Check(v)			(PyObject_TypeCheck(v, &pyrna_struct_Type))
+#define BPy_StructRNA_CheckExact(v)		(Py_TYPE(v) == &pyrna_struct_Type)
+#define BPy_PropertyRNA_Check(v)		(PyObject_TypeCheck(v, &pyrna_prop_Type))
+#define BPy_PropertyRNA_CheckExact(v)	(Py_TYPE(v) == &pyrna_prop_Type)
+
+typedef struct {
+	void * _a;
+	void * _b;
+	PyTypeObject *py_type;
+} BPy_StructFakeType;
+
+
+typedef struct {
+	PyObject_HEAD /* required python macro   */
+	PointerRNA ptr;
+	int freeptr; /* needed in some cases if ptr.data is created on the fly, free when deallocing */
+} BPy_StructRNA;
+
+typedef struct {
+	PyObject_HEAD /* required python macro   */
+	PointerRNA ptr;
+	PropertyRNA *prop;
+
+	/* Arystan: this is a hack to allow sub-item r/w access like: face.uv[n][m] */
+	int arraydim; /* array dimension, e.g: 0 for face.uv, 2 for face.uv[n][m], etc. */
+	int arrayoffset; /* array first item offset, e.g. if face.uv is [4][2], arrayoffset for face.uv[n] is 2n */
+} BPy_PropertyRNA;
+
+/* cheap trick */
+#define BPy_BaseTypeRNA BPy_PropertyRNA
+
+PyObject *BPY_rna_module( void );
+void	  BPY_update_rna_module( void );
+/*PyObject *BPY_rna_doc( void );*/
+PyObject *BPY_rna_types( void );
+PyObject *BPY_rna_props( void );
+
+PyObject *pyrna_struct_CreatePyObject( PointerRNA *ptr );
+PyObject *pyrna_prop_CreatePyObject( PointerRNA *ptr, PropertyRNA *prop );
+
+/* operators also need this to set args */
+int pyrna_py_to_prop(PointerRNA *ptr, PropertyRNA *prop, void *data, PyObject *value, const char *error_prefix);
+int pyrna_pydict_to_props(PointerRNA *ptr, PyObject *kw, int all_args, const char *error_prefix);
+PyObject * pyrna_prop_to_py(PointerRNA *ptr, PropertyRNA *prop);
+
+/* functions for setting up new props - experemental */
+PyObject *BPy_BoolProperty(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *BPy_IntProperty(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *BPy_FloatProperty(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *BPy_StringProperty(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *BPy_PointerProperty(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *BPy_CollectionProperty(PyObject *self, PyObject *args, PyObject *kw);
+
+/* function for registering types */
+PyObject *pyrna_basetype_register(PyObject *self, PyObject *args);
+PyObject *pyrna_basetype_unregister(PyObject *self, PyObject *args);
+
+/* called before stopping python */
+void pyrna_alloc_types(void);
+void pyrna_free_types(void);
+
+/* primitive type conversion */
+int pyrna_py_to_array(PointerRNA *ptr, PropertyRNA *prop, char *param_data, PyObject *py, const char *error_prefix);
+int pyrna_py_to_array_index(PointerRNA *ptr, PropertyRNA *prop, int arraydim, int arrayoffset, int index, PyObject *py, const char *error_prefix);
+
+PyObject *pyrna_py_from_array(PointerRNA *ptr, PropertyRNA *prop);
+PyObject *pyrna_py_from_array_index(BPy_PropertyRNA *self, int index);
+PyObject *pyrna_math_object_from_array(PointerRNA *ptr, PropertyRNA *prop);
+
+#endif

source/blender/python/intern/bpy_ui.c

@@ -0,0 +1,69 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "bpy_ui.h"
+#include "bpy_util.h"
+#include "bpy_rna.h" /* for rna buttons */
+#include "bpy_operator.h" /* for setting button operator properties */
+
+#include "WM_types.h" /* for WM_OP_INVOKE_DEFAULT & friends */
+
+#include "BLI_dynstr.h"
+
+#include "MEM_guardedalloc.h"
+#include "BKE_global.h" /* evil G.* */
+#include "BKE_context.h"
+
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h" /* only for SpaceLink */
+#include "UI_interface.h"
+#include "WM_api.h"
+
+/* Dummy Module, may want to include non RNA UI functions here, else it can be removed */
+
+static struct PyMethodDef ui_methods[] = {
+	{NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef ui_module = {
+	PyModuleDef_HEAD_INIT,
+	"bpy.ui",
+	"",
+	-1,/* multiple "initialization" just copies the module dict. */
+	ui_methods,
+	NULL, NULL, NULL, NULL
+};
+
+PyObject *BPY_ui_module( void )
+{
+	PyObject *submodule;
+	submodule= PyModule_Create(&ui_module);
+	
+	/* INCREF since its its assumed that all these functions return the
+	 * module with a new ref like PyDict_New, since they are passed to
+	  * PyModule_AddObject which steals a ref */
+	Py_INCREF(submodule);
+	
+	return submodule;
+}

source/blender/python/intern/bpy_ui.h

@@ -0,0 +1,31 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BPY_UI_H__
+#define BPY_UI_H__
+
+#include <Python.h>
+
+PyObject *BPY_ui_module( void );
+
+#endif

source/blender/python/intern/bpy_util.c

@@ -0,0 +1,441 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "DNA_listBase.h"
+#include "RNA_access.h"
+#include "bpy_util.h"
+#include "BLI_dynstr.h"
+#include "MEM_guardedalloc.h"
+#include "BKE_report.h"
+
+
+#include "BKE_context.h"
+bContext*	__py_context = NULL;
+bContext*	BPy_GetContext(void) { return __py_context; };
+void		BPy_SetContext(bContext *C) { __py_context= C; };
+
+
+PyObject *BPY_flag_to_list(struct BPY_flag_def *flagdef, int flag)
+{
+	PyObject *list = PyList_New(0);
+	
+	PyObject *item;
+	BPY_flag_def *fd;
+
+	fd= flagdef;
+	while(fd->name) {
+		if (fd->flag & flag) {
+			item = PyUnicode_FromString(fd->name);
+			PyList_Append(list, item);
+			Py_DECREF(item);
+		}
+		fd++;
+	}
+	
+	return list;
+
+}
+
+static char *bpy_flag_error_str(BPY_flag_def *flagdef)
+{
+	BPY_flag_def *fd= flagdef;
+	DynStr *dynstr= BLI_dynstr_new();
+	char *cstring;
+
+	BLI_dynstr_append(dynstr, "Error converting a sequence of strings into a flag.\n\tExpected only these strings...\n\t");
+
+	while(fd->name) {
+		BLI_dynstr_appendf(dynstr, fd!=flagdef?", '%s'":"'%s'", fd->name);
+		fd++;
+	}
+	
+	cstring = BLI_dynstr_get_cstring(dynstr);
+	BLI_dynstr_free(dynstr);
+	return cstring;
+}
+
+int BPY_flag_from_seq(BPY_flag_def *flagdef, PyObject *seq, int *flag)
+{
+	int i, error_val= 0;
+	char *cstring;
+	PyObject *item;
+	BPY_flag_def *fd;
+	*flag = 0;
+
+	if (PySequence_Check(seq)) {
+		i= PySequence_Length(seq);
+
+		while(i--) {
+			item = PySequence_ITEM(seq, i);
+			cstring= _PyUnicode_AsString(item);
+			if(cstring) {
+				fd= flagdef;
+				while(fd->name) {
+					if (strcmp(cstring, fd->name) == 0)
+						(*flag) |= fd->flag;
+					fd++;
+				}
+				if (fd==NULL) { /* could not find a match */
+					error_val= 1;
+				}
+			} else {
+				error_val= 1;
+			}
+			Py_DECREF(item);
+		}
+	}
+	else {
+		error_val= 1;
+	}
+
+	if (*flag == 0)
+		error_val = 1;
+
+	if (error_val) {
+		char *buf = bpy_flag_error_str(flagdef);
+		PyErr_SetString(PyExc_AttributeError, buf);
+		MEM_freeN(buf);
+		return -1; /* error value */
+	}
+
+	return 0; /* ok */
+}
+
+/* for debugging */
+void PyObSpit(char *name, PyObject *var) {
+	fprintf(stderr, "<%s> : ", name);
+	if (var==NULL) {
+		fprintf(stderr, "<NIL>");
+	}
+	else {
+		PyObject_Print(var, stderr, 0);
+		fprintf(stderr, " ref:%d ", (int)var->ob_refcnt);
+		fprintf(stderr, " ptr:%p", (void *)var);
+		
+		fprintf(stderr, " type:");
+		if(Py_TYPE(var))
+			fprintf(stderr, "%s", Py_TYPE(var)->tp_name);
+		else
+			fprintf(stderr, "<NIL>");
+	}
+	fprintf(stderr, "\n");
+}
+
+void PyLineSpit(void) {
+	char *filename;
+	int lineno;
+
+	PyErr_Clear();
+	BPY_getFileAndNum(&filename, &lineno);
+	
+	fprintf(stderr, "%s:%d\n", filename, lineno);
+}
+
+void BPY_getFileAndNum(char **filename, int *lineno)
+{
+	PyObject *getframe, *frame;
+	PyObject *f_lineno= NULL, *co_filename= NULL;
+	
+	if (filename)	*filename= NULL;
+	if (lineno)		*lineno = -1;
+	
+	getframe = PySys_GetObject("_getframe"); // borrowed
+	if (getframe==NULL) {
+		return;
+	}
+	
+	frame = PyObject_CallObject(getframe, NULL);
+	if (frame==NULL)
+		return;
+	
+	if (filename) {
+		co_filename= PyObject_GetAttrStringArgs(frame, 1, "f_code", "co_filename");
+		if (co_filename==NULL) {
+			PyErr_SetString(PyExc_SystemError, "Could not access sys._getframe().f_code.co_filename");
+			Py_DECREF(frame);
+			return;
+		}
+		
+		*filename = _PyUnicode_AsString(co_filename);
+		Py_DECREF(co_filename);
+	}
+	
+	if (lineno) {
+		f_lineno= PyObject_GetAttrString(frame, "f_lineno");
+		if (f_lineno==NULL) {
+			PyErr_SetString(PyExc_SystemError, "Could not access sys._getframe().f_lineno");
+			Py_DECREF(frame);
+			return;
+		}
+		
+		*lineno = (int)PyLong_AsSsize_t(f_lineno);
+		Py_DECREF(f_lineno);
+	}
+
+	Py_DECREF(frame);
+}
+
+/* Would be nice if python had this built in */
+PyObject *PyObject_GetAttrStringArgs(PyObject *o, Py_ssize_t n, ...)
+{
+	Py_ssize_t i;
+	PyObject *item= o;
+	char *attr;
+	
+	va_list vargs;
+
+	va_start(vargs, n);
+	for (i=0; i<n; i++) {
+		attr = va_arg(vargs, char *);
+		item = PyObject_GetAttrString(item, attr);
+		
+		if (item) 
+			Py_DECREF(item);
+		else /* python will set the error value here */
+			break;
+		
+	}
+	va_end(vargs);
+	
+	Py_XINCREF(item); /* final value has is increfed, to match PyObject_GetAttrString */
+	return item;
+}
+
+int BPY_class_validate(const char *class_type, PyObject *class, PyObject *base_class, BPY_class_attr_check* class_attrs, PyObject **py_class_attrs)
+{
+	PyObject *item, *fitem;
+	PyObject *py_arg_count;
+	int i, arg_count;
+
+	if (base_class) {
+		if (!PyObject_IsSubclass(class, base_class)) {
+			PyObject *name= PyObject_GetAttrString(base_class, "__name__");
+			PyErr_Format( PyExc_AttributeError, "expected %s subclass of class \"%s\"", class_type, name ? _PyUnicode_AsString(name):"<UNKNOWN>");
+			Py_XDECREF(name);
+			return -1;
+		}
+	}
+	
+	for(i= 0;class_attrs->name; class_attrs++, i++) {
+		item = PyObject_GetAttrString(class, class_attrs->name);
+
+		if (py_class_attrs)
+			py_class_attrs[i]= item;
+		
+		if (item==NULL) {
+			if ((class_attrs->flag & BPY_CLASS_ATTR_OPTIONAL)==0) {
+				PyErr_Format( PyExc_AttributeError, "expected %s class to have an \"%s\" attribute", class_type, class_attrs->name);
+				return -1;
+			}
+
+			PyErr_Clear();
+		}
+		else {
+			Py_DECREF(item); /* no need to keep a ref, the class owns it */
+
+			if((item==Py_None) && (class_attrs->flag & BPY_CLASS_ATTR_NONE_OK)) {
+				/* dont do anything, this is ok, dont bother checking other types */
+			}
+			else {
+				switch(class_attrs->type) {
+				case 's':
+					if (PyUnicode_Check(item)==0) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a string", class_type, class_attrs->name);
+						return -1;
+					}
+					if(class_attrs->len != -1 && class_attrs->len < PyUnicode_GetSize(item)) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute string to be shorter then %d", class_type, class_attrs->name, class_attrs->len);
+						return -1;
+					}
+
+					break;
+				case 'l':
+					if (PyList_Check(item)==0) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a list", class_type, class_attrs->name);
+						return -1;
+					}
+					if(class_attrs->len != -1 && class_attrs->len < PyList_GET_SIZE(item)) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute list to be shorter then %d", class_type, class_attrs->name, class_attrs->len);
+						return -1;
+					}
+					break;
+				case 'f':
+					if (PyMethod_Check(item))
+						fitem= PyMethod_Function(item); /* py 2.x */
+					else
+						fitem= item; /* py 3.x */
+
+					if (PyFunction_Check(fitem)==0) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a function", class_type, class_attrs->name);
+						return -1;
+					}
+					if (class_attrs->arg_count >= 0) { /* -1 if we dont care*/
+						py_arg_count = PyObject_GetAttrString(PyFunction_GET_CODE(fitem), "co_argcount");
+						arg_count = PyLong_AsSsize_t(py_arg_count);
+						Py_DECREF(py_arg_count);
+
+						if (arg_count != class_attrs->arg_count) {
+							PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" function to have %d args", class_type, class_attrs->name, class_attrs->arg_count);
+							return -1;
+						}
+					}
+					break;
+				}
+			}
+		}
+	}
+	return 0;
+}
+
+
+
+/* returns the exception string as a new PyUnicode object, depends on external StringIO module */
+PyObject *BPY_exception_buffer(void)
+{
+	PyObject *stdout_backup = PySys_GetObject("stdout"); /* borrowed */
+	PyObject *stderr_backup = PySys_GetObject("stderr"); /* borrowed */
+	PyObject *string_io = NULL;
+	PyObject *string_io_buf = NULL;
+	PyObject *string_io_mod= NULL;
+	PyObject *string_io_getvalue= NULL;
+	
+	PyObject *error_type, *error_value, *error_traceback;
+	
+	if (!PyErr_Occurred())
+		return NULL;
+	
+	PyErr_Fetch(&error_type, &error_value, &error_traceback);
+	
+	PyErr_Clear();
+	
+	/* import StringIO / io
+	 * string_io = StringIO.StringIO()
+	 */
+	
+	if(! (string_io_mod= PyImport_ImportModule("io")) ) {
+		goto error_cleanup;
+	} else if (! (string_io = PyObject_CallMethod(string_io_mod, "StringIO", NULL))) {
+		goto error_cleanup;
+	} else if (! (string_io_getvalue= PyObject_GetAttrString(string_io, "getvalue"))) {
+		goto error_cleanup;
+	}
+	
+	Py_INCREF(stdout_backup); // since these were borrowed we dont want them freed when replaced.
+	Py_INCREF(stderr_backup);
+	
+	PySys_SetObject("stdout", string_io); // both of these are free'd when restoring
+	PySys_SetObject("stderr", string_io);
+	
+	PyErr_Restore(error_type, error_value, error_traceback);
+	PyErr_Print(); /* print the error */
+	PyErr_Clear();
+	
+	string_io_buf = PyObject_CallObject(string_io_getvalue, NULL);
+	
+	PySys_SetObject("stdout", stdout_backup);
+	PySys_SetObject("stderr", stderr_backup);
+	
+	Py_DECREF(stdout_backup); /* now sys owns the ref again */
+	Py_DECREF(stderr_backup);
+	
+	Py_DECREF(string_io_mod);
+	Py_DECREF(string_io_getvalue);
+	Py_DECREF(string_io); /* free the original reference */
+	
+	PyErr_Clear();
+	return string_io_buf;
+	
+	
+error_cleanup:
+	/* could not import the module so print the error and close */
+	Py_XDECREF(string_io_mod);
+	Py_XDECREF(string_io);
+	
+	PyErr_Restore(error_type, error_value, error_traceback);
+	PyErr_Print(); /* print the error */
+	PyErr_Clear();
+	
+	return NULL;
+}
+
+char *BPy_enum_as_string(EnumPropertyItem *item)
+{
+	DynStr *dynstr= BLI_dynstr_new();
+	EnumPropertyItem *e;
+	char *cstring;
+
+	for (e= item; item->identifier; item++) {
+		if(item->identifier[0])
+			BLI_dynstr_appendf(dynstr, (e==item)?"'%s'":", '%s'", item->identifier);
+	}
+
+	cstring = BLI_dynstr_get_cstring(dynstr);
+	BLI_dynstr_free(dynstr);
+	return cstring;
+}
+
+int BPy_reports_to_error(ReportList *reports)
+{
+	char *report_str;
+
+	report_str= BKE_reports_string(reports, RPT_ERROR);
+
+	if(report_str) {
+		PyErr_SetString(PyExc_SystemError, report_str);
+		MEM_freeN(report_str);
+	}
+
+	return (report_str != NULL);
+}
+
+
+int BPy_errors_to_report(ReportList *reports)
+{
+	PyObject *pystring;
+	char *cstring;
+	
+	if (!PyErr_Occurred())
+		return 1;
+	
+	/* less hassle if we allow NULL */
+	if(reports==NULL) {
+		PyErr_Print();
+		PyErr_Clear();
+		return 1;
+	}
+	
+	pystring= BPY_exception_buffer();
+	
+	if(pystring==NULL) {
+		BKE_report(reports, RPT_ERROR, "unknown py-exception, could not convert");
+		return 0;
+	}
+	
+	cstring= _PyUnicode_AsString(pystring);
+	
+	BKE_report(reports, RPT_ERROR, cstring);
+	fprintf(stderr, "%s\n", cstring); // not exactly needed. just for testing
+	Py_DECREF(pystring);
+	return 1;
+}

source/blender/python/intern/bpy_util.h

@@ -0,0 +1,92 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Campbell Barton
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <Python.h>
+
+#ifndef BPY_UTIL_H
+#define BPY_UTIL_H
+
+#if PY_VERSION_HEX <  0x03010000
+#error "Python versions below 3.1 are not supported anymore, you'll need to update your python."
+#endif
+
+#include "RNA_types.h" /* for EnumPropertyItem only */
+
+struct EnumPropertyItem;
+struct ReportList;
+
+/* for internal use only, so python can interchange a sequence of strings with flags */
+typedef struct BPY_flag_def {
+    const char	*name;
+    int			flag;
+} BPY_flag_def;
+
+
+PyObject *BPY_flag_to_list(BPY_flag_def *flagdef, int flag);
+int BPY_flag_from_seq(BPY_flag_def *flagdef, PyObject *seq, int *flag);
+
+void PyObSpit(char *name, PyObject *var);
+void PyLineSpit(void);
+void BPY_getFileAndNum(char **filename, int *lineno);
+
+PyObject *BPY_exception_buffer(void);
+
+/* own python like utility function */
+PyObject *PyObject_GetAttrStringArgs(PyObject *o, Py_ssize_t n, ...);
+
+
+
+/* Class type checking, use for checking classes can be added as operators, panels etc */
+typedef struct BPY_class_attr_check {
+	const char	*name;		/* name of the class attribute */
+    char		type;		/* 's' = string, 'f' = function, 'l' = list, (add as needed) */
+    int			arg_count;	/* only for function types, -1 for undefined, includes self arg */
+    int 		len;		/* only for string types currently */
+	int			flag;		/* other options */
+} BPY_class_attr_check;
+
+/* BPY_class_attr_check, flag */
+#define BPY_CLASS_ATTR_OPTIONAL 1
+#define BPY_CLASS_ATTR_NONE_OK	2
+
+int BPY_class_validate(const char *class_type, PyObject *class, PyObject *base_class, BPY_class_attr_check* class_attrs, PyObject **py_class_attrs);
+
+char *BPy_enum_as_string(struct EnumPropertyItem *item);
+
+
+#define BLANK_PYTHON_TYPE {PyVarObject_HEAD_INIT(NULL, 0) 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
+
+/* error reporting */
+int BPy_reports_to_error(struct ReportList *reports);
+int BPy_errors_to_report(struct ReportList *reports);
+
+/* TODO - find a better solution! */
+struct bContext *BPy_GetContext(void);
+void BPy_SetContext(struct bContext *C);
+
+extern void bpy_context_set(struct bContext *C, PyGILState_STATE *gilstate);
+extern void bpy_context_clear(struct bContext *C, PyGILState_STATE *gilstate);
+
+
+#endif

source/blender/python/intern/stubs.c

@@ -0,0 +1,39 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2007 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/* python, will come back */
+void BPY_post_start_python() {}
+//void BPY_run_python_script() {}
+//void BPY_start_python() {}
+void BPY_call_importloader() {}
+void BPY_clear_script() {}
+//void BPY_free_compiled_text() {}
+void BPY_pyconstraint_eval() {}
+void BPY_pyconstraint_target() {}
+int BPY_is_pyconstraint() {return 0;}
+void BPY_pyconstraint_update() {}