Added Python (Thanks to Beholder) - it fails to build properly using my build system,

so there's a precompiled binary included, with a hack in Android.mk to make it work on NDK r4b

project/jni/python/src/Demo/embed/Makefile

@@ -0,0 +1,57 @@
+# Makefile for embedded Python use demo.
+# (This version tailored for my Red Hat Linux 6.1 setup;
+# edit lines marked with XXX.)
+
+# XXX The compiler you are using
+CC=	 	gcc
+
+# XXX Top of the build tree and source tree
+blddir=		../..
+srcdir=		../..
+
+# Python version
+VERSION=	2.6
+
+# Compiler flags
+OPT=		-g
+INCLUDES=	-I$(srcdir)/Include -I$(blddir)
+CFLAGS=		$(OPT)
+CPPFLAGS=	$(INCLUDES)
+
+# The Python library
+LIBPYTHON=	$(blddir)/libpython$(VERSION).a
+
+# XXX edit LIBS (in particular) to match $(blddir)/Modules/Makefile
+LIBS=		-lnsl -ldl -lreadline -ltermcap -lieee -lpthread -lutil
+LDFLAGS=	-Xlinker -export-dynamic
+SYSLIBS=	-lm
+MODLIBS=	
+ALLLIBS=	$(LIBPYTHON) $(MODLIBS) $(LIBS) $(SYSLIBS)
+
+# Build the demo applications
+all:		demo loop importexc
+demo:		demo.o
+		$(CC) $(LDFLAGS) demo.o $(ALLLIBS) -o demo
+
+loop:		loop.o
+		$(CC) $(LDFLAGS) loop.o $(ALLLIBS) -o loop
+
+importexc:	importexc.o
+		$(CC) $(LDFLAGS) importexc.o $(ALLLIBS) -o importexc
+
+# Administrative targets
+
+test:		demo
+		./demo
+
+COMMAND="print 'hello world'"
+looptest:	loop
+		./loop $(COMMAND)
+
+clean:
+		-rm -f *.o core
+
+clobber:	clean
+		-rm -f *~ @* '#'* demo loop importexc
+
+realclean:	clobber

project/jni/python/src/Demo/embed/README

@@ -0,0 +1,19 @@
+This directory show how to embed the Python interpreter in your own
+application.  The file demo.c shows you all that is needed in your C
+code.
+
+To build it, you may have to edit the Makefile:
+
+1) set blddir to the directory where you built Python, if it isn't in
+the source directory (../..)
+
+2) change the variables that together define the list of libraries
+(MODLIBS, LIBS, SYSLIBS) to link with, to match their definitions in
+$(blddir)/Modules/Makefile
+
+An additional test program, loop.c, is used to experiment with memory
+leakage caused by repeated initialization and finalization of the
+interpreter.  It can be build by saying "make loop" and tested with
+"make looptest".  Command line usage is "./loop <python-command>",
+e.g. "./loop 'print 2+2'" should spit out an endless number of lines
+containing the number 4.

project/jni/python/src/Demo/embed/demo.c

@@ -0,0 +1,65 @@
+/* Example of embedding Python in another program */
+
+#include "Python.h"
+
+void initxyzzy(void); /* Forward */
+
+main(int argc, char **argv)
+{
+	/* Pass argv[0] to the Python interpreter */
+	Py_SetProgramName(argv[0]);
+
+	/* Initialize the Python interpreter.  Required. */
+	Py_Initialize();
+
+	/* Add a static module */
+	initxyzzy();
+
+	/* Define sys.argv.  It is up to the application if you
+	   want this; you can also let it undefined (since the Python 
+	   code is generally not a main program it has no business
+	   touching sys.argv...) */
+	PySys_SetArgv(argc, argv);
+
+	/* Do some application specific code */
+	printf("Hello, brave new world\n\n");
+
+	/* Execute some Python statements (in module __main__) */
+	PyRun_SimpleString("import sys\n");
+	PyRun_SimpleString("print sys.builtin_module_names\n");
+	PyRun_SimpleString("print sys.modules.keys()\n");
+	PyRun_SimpleString("print sys.executable\n");
+	PyRun_SimpleString("print sys.argv\n");
+
+	/* Note that you can call any public function of the Python
+	   interpreter here, e.g. call_object(). */
+
+	/* Some more application specific code */
+	printf("\nGoodbye, cruel world\n");
+
+	/* Exit, cleaning up the interpreter */
+	Py_Exit(0);
+	/*NOTREACHED*/
+}
+
+/* A static module */
+
+/* 'self' is not used */
+static PyObject *
+xyzzy_foo(PyObject *self, PyObject* args)
+{
+	return PyInt_FromLong(42L);
+}
+
+static PyMethodDef xyzzy_methods[] = {
+	{"foo",		xyzzy_foo,	METH_NOARGS,
+	 "Return the meaning of everything."},
+	{NULL,		NULL}		/* sentinel */
+};
+
+void
+initxyzzy(void)
+{
+	PyImport_AddModule("xyzzy");
+	Py_InitModule("xyzzy", xyzzy_methods);
+}

project/jni/python/src/Demo/embed/importexc.c

@@ -0,0 +1,17 @@
+#include <Python.h>
+
+char* cmd = "import exceptions";
+
+int main()
+{
+	Py_Initialize();
+	PyEval_InitThreads();
+	PyRun_SimpleString(cmd);
+	Py_EndInterpreter(PyThreadState_Get());
+
+	Py_NewInterpreter();
+	PyRun_SimpleString(cmd);
+	Py_Finalize();
+
+	return 0;
+}

project/jni/python/src/Demo/embed/loop.c

@@ -0,0 +1,33 @@
+/* Simple program that repeatedly calls Py_Initialize(), does something, and
+   then calls Py_Finalize().  This should help finding leaks related to
+   initialization. */
+
+#include "Python.h"
+
+main(int argc, char **argv)
+{
+	int count = -1;
+	char *command;
+
+	if (argc < 2 || argc > 3) {
+		fprintf(stderr, "usage: loop <python-command> [count]\n");
+		exit(2);
+	}
+	command = argv[1];
+
+	if (argc == 3) {
+		count = atoi(argv[2]);
+	}
+
+	Py_SetProgramName(argv[0]);
+
+	/* uncomment this if you don't want to load site.py */
+	/* Py_NoSiteFlag = 1; */
+
+	while (count == -1 || --count >= 0 ) {
+		Py_Initialize();
+		PyRun_SimpleString(command);
+		Py_Finalize();
+	}
+	return 0;
+}