gistfile1.h

#include <Python.h>

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

static PyObject *typesModule = NULL;

static PyObject *_errorMessage(char *arg, char *legalTypes, char *extra)
{
    return PyString_FromFormat("Argument '%s' must be %s\n", arg, legalTypes);
}

static PyObject *py_verifytype(PyObject *self, PyObject *args, PyObject *kwargs)
{
    PyObject *argument, *legalTypes;
    char *arg_string, *types_string, *extra;
    PyObject *iterator, *item;
    bool rc = false;
    char *kwlist[] = {"argument", "argument_name", "legalType",
                "types_string", "errmsgExtra", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsOs|s", kwlist, &argument, 
                &arg_string, &legalTypes, &types_string, &extra)) {
        fprintf(stderr, "verifyType parse args failed\n");
        return NULL;
    }

    iterator = PyObject_GetIter(legalTypes);
    if (iterator == NULL) {
        Py_RETURN_FALSE;
    }

    while (item = PyIter_Next(iterator)) {
        if (argument->ob_type == item) {
            rc = true;
            Py_DECREF(item);
            break;
        }
        Py_DECREF(item);
    }
    Py_DECREF(iterator);

    if (rc)
        Py_RETURN_TRUE;

    PyErr_SetObject(PyExc_TypeError, _errorMessage(arg_string,
            types_string, extra));
    return NULL;
}

static PyObject *py_verifytypeclass(PyObject *self, PyObject *args, PyObject *kwargs) 
{
    PyObject *argument, *legalTypes, *klass, *classType;
    PyObject *verifyTypeArgs, *verifyTypeKwargs;
    char *arg_string, *types_string, *extra;
    bool rc = false;

    char *kwlist = {"argument", "argument_name", "legalTypes", 
           "types_string", "klass", "errmsgExtra", NULL};

    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OsOsO|s", kwlist, &argument,
                &arg_string, &legalTypes, &types_string, &klass, &extra)) {
        fprintf(stderr, "verifytypeclass parse args failed \n");
        return NULL;
    }

    verifyTypeArgs = Py_BuildValue("OsOs", argument, arg_string, legalTypes, 
            types_string);
    verifyTypeKwargs = Py_BuildValue("s", extra);
    PyObject *v = py_verifytype(self, verifyTypeArgs, verifyTypeKwargs);

    if (PyErr_Occurred()) {
        fprintf(stderr, "verify_type failed\n");
        return NULL;
    }


    classType = PyObject_GetAttrString(typesModule, "ClassType");
    if (classType == NULL)
        return NULL;

    fprintf(stderr, "FOOOOO\n");
    return NULL;
}

static const char _verifytypedoc[] = "\
\n\
";
static struct PyMethodDef _verifytype_methods[] = {
    {"verifyType", py_verifytype, METH_VARARGS | METH_KEYWORDS, NULL},
    {"verifyTypeClass", py_verifytypeclass, METH_VARARGS | METH_KEYWORDS, NULL},
    {NULL}
};

PyMODINIT_FUNC init_verifytype()
{
    PyObject *module = Py_InitModule3("_verifytype", _verifytype_methods,
            _verifytypedoc);
    typesModule = PyImport_ImportModule("types");
}

#ifdef __cplusplus
}
#endif