Initial revision

1 files changed, 651 insertions, 0 deletions

diff --git a/Modules/objc.c b/Modules/objc.c
new file mode 100644
index 0000000..9e70912
--- /dev/null
+++ b/Modules/objc.c
@@ -0,0 +1,651 @@
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* Objective-C interface for NeXTStep */
+/* Tested with NeXTStep 3.3 on Intel and Sparc architectures */
+
+/* Original author: Jon M. Kutemeier */
+/* Revamped and maintained by: Guido van Rossum */
+
+/* XXX To do:
+   - bug??? x.send('name', []) gives weird error
+   - rename functions from objc_* to ObjC_*
+   - change send(sel, [a, b, c]) to send(self, a, b, c)
+   - call back to Python from Objective-C
+ */
+
+/* Python header file */
+#include "Python.h"
+
+/* NeXT headers */
+#include <sys/param.h>
+#include <mach-o/rld.h>
+#include <objc/objc.h>
+#include <objc/objc-runtime.h>
+#import <remote/NXProxy.h>
+
+/* Distinguish between ObjC classes and instances */
+typedef enum {
+    OBJC_CLASS,
+    OBJC_INSTANCE,
+} ObjC_Typecode;
+
+/* Exception raised for ObjC specific errors */
+static PyObject *ObjC_Error;
+
+/* Python wrapper about ObjC id (instance or class) */
+typedef struct {
+    PyObject_HEAD
+    id             obj;
+    ObjC_Typecode  type;
+    int            owned;
+} ObjCObject;
+
+/* Corresponding Python type object */
+staticforward PyTypeObject ObjC_Type;
+
+/* Corresponding Python type check macro */
+#define ObjC_Check(o) ((o)->ob_type == &ObjC_Type)
+
+/* Create a new ObjCObject */
+static ObjCObject *
+newObjCObject(obj, type, owned)
+    id obj;
+    ObjC_Typecode type;
+    int owned;
+{
+    ObjCObject *self;
+
+    self = PyObject_NEW(ObjCObject, &ObjC_Type);
+    if (self == NULL)
+	return NULL;
+
+    self->obj = obj;
+    self->type = type;
+    self->owned = owned;
+
+    return self;
+}
+
+static void
+objc_sendfree(self)
+    ObjCObject *self;
+{
+    if (self->obj)
+	self->obj = (id)objc_msgSend(self->obj, SELUID("free"));
+}
+
+/* Deallocate an ObjCObject */
+static void
+objc_dealloc(self)
+    ObjCObject *self;
+{
+    if (self->owned)
+	objc_sendfree(self);
+    PyMem_DEL(self);
+}
+
+/* Return a string representation of an ObjCObject */
+static PyObject *
+objc_repr(self)
+    ObjCObject *self;
+{
+    char buffer[512];
+    char *p = buffer;
+    if (self->obj == nil)
+	p = "<Objective-C nil>";
+    else {
+	char *t;
+	switch (self->type) {
+	case OBJC_CLASS: t = "class"; break;
+	case OBJC_INSTANCE: t = "instance"; break;
+	default: t = "???"; break;
+	}
+	sprintf(buffer, "<Objective-C %s %s at %lx>",
+		NAMEOF(self->obj), t, (long)(self->obj));
+    }
+    return PyString_FromString(p);
+}
+
+/*** ObjCObject methods ***/
+
+/* Call an object's free method */
+static PyObject *
+objc_free(self, args)
+    ObjCObject *self;
+    PyObject *args;
+{
+    if (!PyArg_ParseTuple(args, ""))
+	return NULL;
+    objc_sendfree(self);
+}
+
+/* Send a message to an ObjCObject.
+   The Python call looks like e.g. obj.send('moveTo::', [arg1, arg2])
+   which translates into Objective-C as [obj moveTo: arg1 : arg2] */
+static PyObject *
+objc_send(self, args)
+    ObjCObject *self;
+    PyObject *args;
+{
+    char *methodname;
+    char *margBuff = NULL;
+    PyObject *retobject = NULL;
+    PyObject *arglist;
+    id receiver, obj;
+    char *type;
+    SEL sel;
+    Method meth;
+    unsigned int margCount, margSize;
+    int offset, i;
+
+    if (!PyArg_ParseTuple(args, "sO!", &methodname, &PyList_Type, &arglist))
+	return NULL;
+
+    /* Get the method descriptor from the object */
+
+    receiver = self->obj;
+    sel = SELUID(methodname);
+
+    switch(self->type) {
+    case OBJC_CLASS:
+	meth = class_getClassMethod(receiver->isa, sel);
+	break;
+    case OBJC_INSTANCE:
+	meth = class_getInstanceMethod(receiver->isa, sel);
+	break;
+    default:
+	PyErr_SetString(ObjC_Error,
+			"receiver's type is neither instance not class!?!?");
+	return NULL;
+    }
+
+    if (!meth) {
+	PyErr_SetString(ObjC_Error, "receiver has no method by that name");
+	return NULL;
+    }
+
+    /* Fill in the argument list, type-checking the arguments */
+
+    margCount = method_getNumberOfArguments(meth);
+
+    if (PyList_Size(arglist) + 2 != margCount) {
+	PyErr_SetString(ObjC_Error,
+			"wrong number of arguments for this method");
+	    return NULL;
+    }
+
+    margSize = method_getSizeOfArguments(meth);
+    margBuff = PyMem_NEW(char, margSize+1);
+    if (margBuff == NULL)
+	return PyErr_NoMemory();
+
+    method_getArgumentInfo(meth, 0, &type, &offset);
+    marg_setValue(margBuff, offset, id, receiver);
+
+    method_getArgumentInfo(meth, 1, &type, &offset);
+    marg_setValue(margBuff, offset, SEL, sel);
+
+    for (i = 2; i < margCount; i++) {
+	PyObject *argument;
+	method_getArgumentInfo(meth, i, &type, &offset);
+
+	argument = PyList_GetItem(arglist, i-2);
+
+	/* scan past protocol-type modifiers */
+	while (strchr("rnNoOV", *type) != 0)
+	    type++;
+
+	/* common type checks */
+	switch(*type) {
+
+	    /* XXX The errors here should point out which argument */
+
+	case 'c':
+	case '*':
+	case 'C':
+	    if (!PyString_Check(argument)) {
+		PyErr_SetString(ObjC_Error, "string argument expected");
+		goto error;
+	    }
+	    break;
+
+	case 'i':
+	case 's':
+	case 'I':
+	case 'S':
+	case 'l':
+	case 'L':
+	case '^':
+	    if (!PyInt_Check(argument)) {
+		PyErr_SetString(ObjC_Error, "integer argument expected");
+		goto error;
+	    }
+	    break;
+
+	case 'f':
+	case 'd':
+	    if (!PyFloat_Check(argument)) {
+		PyErr_SetString(ObjC_Error, "float argument expected");
+		goto error;
+	    }
+	    break;
+
+	}
+
+	/* convert and store the argument */
+	switch (*type) {
+
+	case 'c': /* char */
+	    marg_setValue(margBuff, offset, char,
+			  PyString_AsString(argument)[0]);
+	    break;
+
+	case 'C': /* unsigned char */
+	    marg_setValue(margBuff, offset, unsigned char,
+			  PyString_AsString(argument)[0]);
+	    break;
+
+	case '*': /* string */
+	    marg_setValue(margBuff, offset, char *,
+			  PyString_AsString(argument));
+	    break;
+
+	case 'i': /* int */
+	    marg_setValue(margBuff, offset, int,
+			  PyInt_AsLong(argument));
+	    break;
+
+	case 'I': /* unsigned int */
+	    marg_setValue(margBuff, offset, unsigned int,
+			  PyInt_AsLong(argument));
+	    break;
+
+	case 's': /* short */
+	    marg_setValue(margBuff, offset, short,
+			  PyInt_AsLong(argument));
+	    break;
+
+	case 'S': /* unsigned short */
+	    marg_setValue(margBuff, offset, unsigned short,
+			  PyInt_AsLong(argument));
+	    break;
+
+	case 'l': /* long */
+	    marg_setValue(margBuff, offset, long,
+			  PyInt_AsLong(argument));
+	    break;
+
+	case 'L': /* unsigned long */
+	    marg_setValue(margBuff, offset, unsigned long,
+			  PyInt_AsLong(argument));
+	    break;
+
+	case 'f': /* float */
+	    marg_setValue(margBuff, offset, float,
+			  (float)PyFloat_AsDouble(argument));
+	    break;
+
+	case 'd': /* double */
+	    marg_setValue(margBuff, offset, double,
+			  PyFloat_AsDouble(argument));
+	    break;
+
+	case '@': /* id (or None) */
+	    if (ObjC_Check(argument))
+		marg_setValue(margBuff, offset, id,
+			      ((ObjCObject *)(argument))->obj);
+	    else if (argument == Py_None)
+		marg_setValue(margBuff, offset, id, nil);
+	    else {
+		PyErr_SetString(ObjC_Error, "id or None argument expected");
+		goto error;
+	    }
+	    break;
+
+	case '^': /* void * (use int) */
+	    marg_setValue(margBuff, offset, void *,
+			  (void *)PyInt_AsLong(argument));
+	    break;
+
+	case ':': /* SEL (use string or int) */
+	    if (PyInt_Check(argument))
+		marg_setValue(margBuff, offset, SEL,
+			      (SEL)PyInt_AsLong(argument));
+	    else if (PyString_Check(argument))
+		marg_setValue(margBuff, offset, SEL,
+			      SELUID(PyString_AsString(argument)));
+	    else {
+		PyErr_SetString(ObjC_Error,
+				"selector string or int argument expected");
+		goto error;
+	    }
+	    break;
+
+	case '#': /* Class (may also use int) */
+	    if (ObjC_Check(argument) &&
+		((ObjCObject *)argument)->type == OBJC_INSTANCE)
+		marg_setValue(margBuff, offset, Class *,
+			      (Class *)((ObjCObject *)argument)->obj);
+	    else if (PyInt_Check(argument))
+		marg_setValue(margBuff, offset, Class *,
+			      (Class *)PyInt_AsLong(argument));
+	    else {
+		PyErr_SetString(ObjC_Error,
+				"ObjC class object required");
+		goto error;
+	    }
+	    break;
+
+	default:
+	    PyErr_SetString(ObjC_Error, "unknown argument type");
+	    goto error;
+
+	}
+    }
+
+    /* Call the method and set the return value */
+
+    type = meth->method_types;
+
+    while (strchr("rnNoOV", *type))
+	type++;
+
+    switch(*type) {
+
+/* Cast objc_msgSendv to a function returning the right thing */
+#define MS_CAST(type) ((type (*)())objc_msgSendv)
+
+    case 'c':
+    case '*':
+    case 'C':
+	retobject = (PyObject *)PyString_FromString(
+	    MS_CAST(char *)(receiver, sel, margSize, margBuff));
+	break;
+
+    case 'i':
+    case 's':
+    case 'I':
+    case 'S':
+	retobject = (PyObject *)PyInt_FromLong(
+	    MS_CAST(int)(receiver, sel, margSize, margBuff));
+	break;
+
+    case 'l':
+    case 'L':
+    case '^':
+	retobject = (PyObject *)PyInt_FromLong(
+	    MS_CAST(long)(receiver, sel, margSize, margBuff));
+	break;
+
+    case 'f':
+	retobject = (PyObject *)PyFloat_FromDouble(
+	    MS_CAST(float)(receiver, sel, margSize, margBuff));
+	break;
+
+    case 'd':
+	retobject = (PyObject *)PyFloat_FromDouble(
+	    MS_CAST(double)(receiver, sel, margSize, margBuff));
+	break;
+
+    case '@':
+	obj = MS_CAST(id)(receiver, sel, margSize, margBuff);
+	if (obj == nil) {
+	    retobject = Py_None;
+	    Py_INCREF(retobject);
+	}
+	else if (obj != receiver)
+	    retobject = (PyObject *)newObjCObject(obj, OBJC_INSTANCE, 0);
+	else {
+	    retobject = (PyObject *)self;
+	    Py_INCREF(retobject);
+	}
+	break;
+
+    case ':':
+	retobject = (PyObject *)PyInt_FromLong(
+	    (long)MS_CAST(SEL)(receiver, sel, margSize, margBuff));
+	break;
+
+    case '#':
+	retobject = (PyObject *)PyInt_FromLong(
+	    (long)MS_CAST(Class *)(receiver, sel, margSize, margBuff));
+	break;
+
+#undef MS_CAST
+
+    }
+
+  error:
+    PyMem_XDEL(margBuff);
+    return retobject;
+}
+
+/* List of methods for ObjCObject */
+static PyMethodDef objc_methods[] = {
+    {"send",	(PyCFunction)objc_send, 1},
+    {"free",	(PyCFunction)objc_free, 1},
+    {NULL,	NULL}		/* sentinel */
+};
+
+/* Get an attribute of an ObjCObject */
+static PyObject *
+objc_getattr(self, name)
+    ObjCObject *self;
+    char *name;
+{
+    PyObject *method;
+
+    /* Try a function method */
+    method = Py_FindMethod(objc_methods, (PyObject *)self, name);
+    if (method != NULL)
+	return method;
+    PyErr_Clear();
+
+    /* Try an instance variable */
+    if (strcmp(name, "obj") == 0)
+	return PyInt_FromLong((long)self->obj);
+    if (strcmp(name, "type") == 0)
+	return PyInt_FromLong((long)self->type);
+    if (strcmp(name, "owned") == 0)
+	return PyInt_FromLong((long)self->owned);
+    if (strcmp(name, "name") == 0)
+	return PyString_FromString(NAMEOF(self->obj));
+    if (strcmp(name, "__members__") == 0)
+	return Py_BuildValue("[sss]", "name", "obj", "owned", "type");
+
+    PyErr_SetString(PyExc_AttributeError, name);
+    return NULL;
+}
+
+/* The type object */
+static PyTypeObject ObjC_Type = {
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,                                  /*ob_size*/
+    "objc",                             /*tp_name*/
+    sizeof(ObjCObject),                 /*tp_basicsize*/
+    0,                                  /*tp_itemsize*/
+    /* methods */
+    (destructor)objc_dealloc,           /*tp_dealloc*/
+    0,                         		/*tp_print*/
+    (getattrfunc)objc_getattr,          /*tp_getattr*/
+    0,                       		/*tp_setattr*/
+    0,                         		/*tp_compare*/
+    (reprfunc)objc_repr,		/*tp_repr*/
+    0,                                  /*tp_as_number*/
+    0,                                  /*tp_as_sequence*/
+    0,                                  /*tp_as_mapping*/
+    0,     		                /*tp_hash*/
+    0,					/*tp_call*/
+    0,					/*tp_str*/
+    0, 0, 0, 0,				/*xxx1-4*/
+    "Objective-C id wrapper",		/*tp_doc*/
+};
+
+
+
+/*** Top-level functions ***/
+
+/* Max #files passed to loadobjectfile() */
+#define MAXRLD 128
+
+/* Load a list of object files */
+static PyObject *
+objc_loadobjectfiles(self, args)
+PyObject *self;   /* Not used */
+PyObject *args;
+{
+    NXStream *errorStream;
+    struct mach_header *new_header;
+    const char *filenames[MAXRLD+1];
+    long ret;
+    char *streamBuf;
+    PyObject *filelist, *file;
+    int listsize, len, maxLen, i;
+
+    if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &filelist))
+	return NULL;
+
+    listsize = PyList_Size(filelist);
+
+    if (listsize > MAXRLD) {
+	PyErr_SetString(ObjC_Error, "more than 128 files in list");
+	return NULL;
+    }
+
+    errorStream = NXOpenMemory(NULL, 0, NX_WRITEONLY);
+
+    for (i = 0; i < listsize; i++) {
+	file = PyList_GetItem(filelist, i);
+
+	if (!PyString_Check(file))
+	    {
+		PyErr_SetString(ObjC_Error,
+				"all list items must be strings");
+		return NULL;
+	    }
+
+	filenames[i] = PyString_AsString(file);
+    }
+
+    filenames[listsize] = NULL;
+
+    ret = objc_loadModules(filenames, errorStream, NULL, &new_header, NULL);
+
+    /* extract the error messages for the exception */
+
+    if(ret) {
+	NXPutc(errorStream, (char)0);
+
+	NXGetMemoryBuffer(errorStream, &streamBuf, &len, &maxLen);
+	PyErr_SetString(ObjC_Error, streamBuf);
+    }
+
+    NXCloseMemory(errorStream, NX_FREEBUFFER);
+
+    if(ret)
+	return NULL;
+
+    Py_XINCREF(Py_None);
+    return Py_None;
+}
+
+static PyObject *
+objc_lookupclass(self, args)
+PyObject *self;   /* Not used */
+PyObject *args;
+{
+    char *classname;
+    id    class;
+
+    if (!PyArg_ParseTuple(args, "s", &classname))
+	return NULL;
+
+    if (!(class = objc_lookUpClass(classname)))
+	{
+	    PyErr_SetString(ObjC_Error, "unknown ObjC class");
+	    return NULL;
+	}
+
+    return (PyObject *)newObjCObject(class, OBJC_CLASS, 0);
+}
+
+/* List all classes */
+static PyObject *
+objc_listclasses(self, args)
+    ObjCObject *self;
+    PyObject *args;
+{
+    NXHashTable *class_hash = objc_getClasses();
+    NXHashState state = NXInitHashState(class_hash);
+    Class classid;
+    PyObject *list;
+
+    if (!PyArg_ParseTuple(args, ""))
+	return NULL;
+
+    list = PyList_New(0);
+    if (list == NULL)
+	return NULL;
+  
+    while (NXNextHashState(class_hash, &state, (void**)&classid)) {
+	ObjCObject *item = newObjCObject(classid, OBJC_CLASS, 0);
+	if (item == NULL || PyList_Append(list, (PyObject *)item) < 0) {
+	    Py_XDECREF(item);
+	    Py_DECREF(list);
+	    return NULL;
+	}
+	Py_INCREF(item);
+    }
+
+    return list;
+}
+
+/* List of top-level functions */
+static PyMethodDef objc_class_methods[] = {
+    {"loadobjectfiles",	objc_loadobjectfiles, 1},
+    {"lookupclass", 	objc_lookupclass, 1},
+    {"listclasses",	objc_listclasses, 1},
+    {NULL, 		NULL}		/* sentinel */
+};
+
+/* Initialize for the module */
+void
+initobjc()
+{
+    PyObject *m, *d;
+
+    m = Py_InitModule("objc", objc_class_methods);
+    d = PyModule_GetDict(m);
+
+    ObjC_Error = PyString_FromString("objc.error");
+    PyDict_SetItemString(d, "error", ObjC_Error);
+
+    if (PyErr_Occurred())
+	Py_FatalError("can't initialize module objc");
+
+#ifdef WITH_THREAD
+    objc_setMultithreaded(1);
+#endif
+}