Esempio n. 1
0
PyObject *KX_PythonComponent::py_component_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
	KX_PythonComponent *comp = new KX_PythonComponent(type->tp_name);

	PyObject *proxy = py_base_new(type, PyTuple_Pack(1, comp->GetProxy()), kwds);
	if (!proxy) {
		delete comp;
		return NULL;
	}

	return proxy;
}
Esempio n. 2
0
static long umpyew_utime(char *path, struct utimbuf *buf)
{
	PYINSYS(utime, 2);
	PYARG(0, PyString_FromString(path));
	if (buf)
		PYARG(1, PyTuple_Pack(2, PyInt_FromLong(buf->actime), PyInt_FromLong(buf->modtime)));
	else
		PYARG(1, Py_None);
	PYCALL;
	PYOUT;
	return retval;
}
Esempio n. 3
0
static PyObject *
create_filter(PyObject *category, _Py_Identifier *id)
{
    PyObject *action_str = _PyUnicode_FromId(id);
    if (action_str == NULL) {
        return NULL;
    }

    /* This assumes the line number is zero for now. */
    return PyTuple_Pack(5, action_str, Py_None,
                        category, Py_None, _PyLong_Zero);
}
Esempio n. 4
0
static int
update_registry(PyObject *registry, PyObject *text, PyObject *category,
                int add_zero)
{
    PyObject *altkey, *zero = NULL;
    int rc;

    if (add_zero) {
        zero = PyInt_FromLong(0);
        if (zero == NULL)
            return -1;
        altkey = PyTuple_Pack(3, text, category, zero);
    }
    else
        altkey = PyTuple_Pack(2, text, category);

    rc = already_warned(registry, altkey, 1);
    Py_XDECREF(zero);
    Py_XDECREF(altkey);
    return rc;
}
static PyObject *
KyotoDB_iteritems(KyotoDB *self)
{
    KyotoCursor *cursor = PyObject_New(KyotoCursor, &yakc_CursorType);
    APR type(PyInt_FromLong((long)KYOTO_ITEMS));
    APR tuple(PyTuple_Pack(2, self, type.get()));
    int re = Cursor_init(cursor, tuple.get(), NULL);
    if (re == 0)
        return (PyObject *)cursor;
    PyErr_SetString(PyExc_RuntimeError, "Cannot create cursor");
    return NULL;
}
static PyObject *PyKAdminPrincipal_get_keys(PyKAdminPrincipalObject *self, void *closure) { 

    /*

    key structure:

        {
            kvno: [("enctype", "salt"), ("enctype", "salt")],
            kvno: ...
        }

    */

    PyObject *kvno     = NULL;
    PyObject *enctype  = NULL;
    PyObject *salttype = NULL;
    PyObject *tuple    = NULL;
    PyObject *list     = NULL;

    PyObject *keys = PyDict_New();

    ssize_t index = 0; 

    for (; index < self->entry.n_key_data; index++) {

        krb5_key_data *key_data = &self->entry.key_data[index];

        kvno = PyUnifiedLongInt_FromLong(key_data->key_data_kvno);

        enctype  = pykadmin_key_enctype_name(key_data);
        salttype = pykadmin_key_salttype_name(key_data);

        tuple = PyTuple_Pack(2, enctype, salttype);


        if (kvno) {
            if (PyDict_Contains(keys, kvno)) {
                list = PyDict_GetItem(keys, kvno);
            } else {
                list = PyList_New(0);
                PyDict_SetItem(keys, kvno, list);
            }
        }

        if (list && tuple) {
            PyList_Append(list, tuple);
        }

    }

    return keys;
}
Esempio n. 7
0
PyObject* objToJSONFile(PyObject* self, PyObject *args)
{
	PyObject *data;
	PyObject *file;
	PyObject *string;
	PyObject *write;
	PyObject *argtuple;

	if (!PyArg_ParseTuple (args, "OO", &data, &file)) {
		return NULL;
	}

	if (!PyObject_HasAttrString (file, "write"))
	{
		PyErr_Format (PyExc_TypeError, "expected file");
		return NULL;
	}

	write = PyObject_GetAttrString (file, "write");

	if (!PyCallable_Check (write)) {
		Py_XDECREF(write);
		PyErr_Format (PyExc_TypeError, "expected file");
		return NULL;
	}

	string = objToJSON (self, data);

	if (string == NULL)
	{
		Py_XDECREF(write);
		return NULL;
	}

	argtuple = PyTuple_Pack (1, string);
	if (argtuple == NULL)
	{
		Py_XDECREF(write);
		return NULL;
	}
	if (PyObject_CallObject (write, argtuple) == NULL)
	{
		Py_XDECREF(write);
		Py_XDECREF(argtuple);
		return NULL;
	}

	Py_XDECREF(write);
	Py_XDECREF(argtuple);
	Py_XDECREF(string);
	Py_RETURN_NONE;
}
Esempio n. 8
0
File: foo.c Progetto: mozillazg/pypy
int prop_descr_set(PyObject *self, PyObject *obj, PyObject *value)
{
    int res;
    if (value != NULL) {
	PyObject *result = PyTuple_Pack(2, self, value);
	res = PyObject_SetAttrString(obj, "y", result);
	Py_DECREF(result);
    }
    else {
	res = PyObject_SetAttrString(obj, "z", self);
    }
    return res;
}
Esempio n. 9
0
static PyObject* set_reduce(BoxedSet* so) noexcept {
    PyObject* keys = NULL, * args = NULL, * result = NULL, * dict = NULL;

    keys = PySequence_List((PyObject*)so);
    if (keys == NULL)
        goto done;
    args = PyTuple_Pack(1, keys);
    if (args == NULL)
        goto done;
    dict = PyObject_GetAttrString((PyObject*)so, "__dict__");
    if (dict == NULL) {
        PyErr_Clear();
        dict = Py_None;
        Py_INCREF(dict);
    }
    result = PyTuple_Pack(3, Py_TYPE(so), args, dict);
done:
    Py_XDECREF(args);
    Py_XDECREF(keys);
    Py_XDECREF(dict);
    return result;
}
PyObject* __pycomps_dict_pair_out(COMPS_HSListItem *hsit) {
    PyObject *key, *val, *tuple;
    char *x;

    key = PyUnicode_FromString((char*) ((COMPS_ObjRTreePair*)hsit->data)->key);
    x = comps_object_tostr(((COMPS_ObjRTreePair*)hsit->data)->data);
    val = PyUnicode_FromString(x);
    free(x);
    tuple = PyTuple_Pack(2, key, val);
    Py_DECREF(key);
    Py_DECREF(val);
    return tuple;
}
Esempio n. 11
0
static PyObject *t_descriptor_isValueRequired(t_descriptor *self, t_item *item)
{
    t_attribute *attr = self->attr;

    if (!PyObject_TypeCheck(item, CItem))
    {
        PyErr_SetObject(PyExc_TypeError, (PyObject *) item);
        return NULL;
    }

    if (attr)
    {
        int flags = attr->flags;
        t_values *attrDict = get_attrdict(item, flags);

        return PyTuple_Pack(2,
                            attrDict ? (PyObject *) attrDict : Py_None,
                            attrDict && flags & A_REQUIRED ? Py_True : Py_False);
    }
    else
        return PyTuple_Pack(2, Py_None, Py_False);
}
Esempio n. 12
0
static PyObject *
math_log(PyObject *self, PyObject *args)
{
    PyObject *arg;
    PyObject *base = NULL;
    PyObject *num, *den;
    PyObject *ans;
    PyObject *newargs;

    if (!PyArg_UnpackTuple(args, "log", 1, 2, &arg, &base))
        return NULL;
    if (base == NULL)
        return loghelper(args, log, "d:log", arg);

    newargs = PyTuple_Pack(1, arg);
    if (newargs == NULL)
        return NULL;
    num = loghelper(newargs, log, "d:log", arg);
    Py_DECREF(newargs);
    if (num == NULL)
        return NULL;

    newargs = PyTuple_Pack(1, base);
    if (newargs == NULL) {
        Py_DECREF(num);
        return NULL;
    }
    den = loghelper(newargs, log, "d:log", base);
    Py_DECREF(newargs);
    if (den == NULL) {
        Py_DECREF(num);
        return NULL;
    }

    ans = PyNumber_Divide(num, den);
    Py_DECREF(num);
    Py_DECREF(den);
    return ans;
}
Esempio n. 13
0
static bool HasOwnership(PyObject* obj) {
    PyObject* addr = GetPointer(obj);
    PyObject* name = GetName(obj);
    auto_pyobject nameaddr = PyTuple_Pack(2, name, addr);
    Py_DECREF(name);
    Py_DECREF(addr);
    PyObject* dtor = PyDict_GetItem(GetAddrDtorDict(), *nameaddr);
    if (!dtor || dtor == Py_None) {
        return false;
    } else {
        return true;
    }
}
static PyObject *
KyotoDB_array(KyotoDB *self, int type)
{
    PyObject *result = PyList_New(self->m_db->count());
    Py_ssize_t i = 0;

    kyotocabinet::BasicDB::Cursor *cursor = self->m_db->cursor();
    cursor->jump();
    std::string key;
    std::string value;
    while (cursor->get(&key, &value, true)) {
        switch (type) {
        case 0: {
            PyObject *pkey = KyotoDB_load(key, self->use_pickle);
            if (pkey == NULL)
                goto onerror;
            PyList_SetItem(result, i++, pkey);
            break;
        }
        case 1: {
            PyObject *pvalue = KyotoDB_load(value, self->use_pickle);
            if (pvalue == NULL)
                goto onerror;
            PyList_SetItem(result, i++, pvalue);
            break;
        }
        case 2: {
            APR pkey(KyotoDB_load(key, self->use_pickle));
            if (pkey == NULL)
                goto onerror;

            APR pvalue(KyotoDB_load(value, self->use_pickle));
            if (pvalue == NULL)
                goto onerror;

            PyList_SetItem(result, i++,
                           PyTuple_Pack(2, (PyObject *)pkey, (PyObject *)pvalue));
            break;
        }
        }
    }
    delete cursor;
    return result;
  onerror:
    for (Py_ssize_t j = 0; j < i; j++) {
        PyObject *obj = PyList_GetItem(result, j);
        Py_DECREF(obj);
    }
    delete cursor;
    return NULL;
}
Esempio n. 15
0
static PyObject *
range_index(rangeobject *r, PyObject *ob)
{
    PyObject *idx, *tmp;
    int contains;
    PyObject *format_tuple, *err_string;
    static PyObject *err_format = NULL;

    if (!PyLong_CheckExact(ob) && !PyBool_Check(ob)) {
        Py_ssize_t index;
        index = _PySequence_IterSearch((PyObject*)r, ob, PY_ITERSEARCH_INDEX);
        if (index == -1)
            return NULL;
        return PyLong_FromSsize_t(index);
    }

    contains = range_contains_long(r, ob);
    if (contains == -1)
        return NULL;

    if (!contains)
        goto value_error;

    tmp = PyNumber_Subtract(ob, r->start);
    if (tmp == NULL)
        return NULL;

    /* idx = (ob - r.start) // r.step */
    idx = PyNumber_FloorDivide(tmp, r->step);
    Py_DECREF(tmp);
    return idx;

value_error:

    /* object is not in the range */
    if (err_format == NULL) {
        err_format = PyUnicode_FromString("%r is not in range");
        if (err_format == NULL)
            return NULL;
    }
    format_tuple = PyTuple_Pack(1, ob);
    if (format_tuple == NULL)
        return NULL;
    err_string = PyUnicode_Format(err_format, format_tuple);
    Py_DECREF(format_tuple);
    if (err_string == NULL)
        return NULL;
    PyErr_SetObject(PyExc_ValueError, err_string);
    Py_DECREF(err_string);
    return NULL;
}
Esempio n. 16
0
static PyObject *
pyrapidjson_dump(PyObject *self, PyObject *args, PyObject *kwargs)
{
    // TODO: not support kwargs like json.dump() (encoding, etc...)
    static char *kwlist[] = {(char *)"obj", (char *)"fp", NULL};
    PyObject *py_file, *py_json, *py_string, *write_method, *write_arg, *write_ret;
    rapidjson::Document doc;

    /* Parse arguments */
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO", kwlist, &py_json, &py_file))
        return NULL;

    if (!PyObject_HasAttrString(py_file, "write")) {
        PyErr_Format(PyExc_TypeError, "expected file object. has not write() method.");
        return NULL;
    }
    write_method = PyObject_GetAttrString(py_file, "write");
    if (!PyCallable_Check(write_method)) {
        Py_XDECREF(write_method);
        PyErr_Format(PyExc_TypeError, "expected file object. write() method is not callable.");
        return NULL;
    }

    py_string = pyobj2pystring(py_json);
    if (py_string == NULL) {
        Py_XDECREF(write_method);
        PyErr_SetString(PyExc_RuntimeError, "pyobj2pystring() error.");
        return NULL;
    }

    write_arg = PyTuple_Pack(1, py_string);
    if (write_arg == NULL) {
        Py_XDECREF(write_method);
        return NULL;
    }

    write_ret = PyObject_CallObject(write_method, write_arg);
    if (write_ret == NULL) {
        Py_XDECREF(write_method);
        Py_XDECREF(write_arg);
        Py_XDECREF(py_string);
        return NULL;
    }

    Py_XDECREF(write_method);
    Py_XDECREF(write_arg);
    Py_XDECREF(write_ret);
    Py_XDECREF(py_string);

    Py_RETURN_NONE;
}
Esempio n. 17
0
PyMODINIT_FUNC init_pyjava(void)
{
    PyObject *mod;

    mod = Py_InitModule("_pyjava", methods);
    if(mod == NULL)
        return ;

    Err_Base = PyErr_NewException("pyjava.Error", NULL, NULL);
    Py_INCREF(Err_Base);
    PyModule_AddObject(mod, "Error", Err_Base);

    Err_ClassNotFound = PyErr_NewException(
            "pyjava.ClassNotFound", Err_Base, NULL);
    Py_INCREF(Err_ClassNotFound);
    PyModule_AddObject(mod, "ClassNotFound", Err_ClassNotFound);

    {
        PyObject *bases = PyTuple_Pack(2, Err_Base, PyExc_TypeError);
        Err_NoMatchingOverload = PyErr_NewException(
                "pyjava.NoMatchingOverload", bases, NULL);
        Py_INCREF(Err_NoMatchingOverload);
        PyModule_AddObject(mod, "NoMatchingOverload", Err_NoMatchingOverload);
        Py_DECREF(bases);
    }

    {
        PyObject *bases = PyTuple_Pack(3, Err_Base,
                                       PyExc_TypeError, PyExc_AttributeError);
        Err_FieldTypeError = PyErr_NewException(
                "pyjava.NoMatchingOverload", bases, NULL);
        Py_INCREF(Err_FieldTypeError);
        PyModule_AddObject(mod, "FieldTypeError", Err_FieldTypeError);
        Py_DECREF(bases);
    }

    javawrapper_init(mod);
}
Esempio n. 18
0
NPY_NO_EXPORT void
dot_alignment_error(PyArrayObject *a, int i, PyArrayObject *b, int j)
{
    PyObject *errmsg = NULL, *format = NULL, *fmt_args = NULL,
             *i_obj = NULL, *j_obj = NULL,
             *shape1 = NULL, *shape2 = NULL,
             *shape1_i = NULL, *shape2_j = NULL;

    format = PyUString_FromString("shapes %s and %s not aligned:"
                                  " %d (dim %d) != %d (dim %d)");

    shape1 = convert_shape_to_string(PyArray_NDIM(a), PyArray_DIMS(a), "");
    shape2 = convert_shape_to_string(PyArray_NDIM(b), PyArray_DIMS(b), "");

    i_obj = PyLong_FromLong(i);
    j_obj = PyLong_FromLong(j);

    shape1_i = PyLong_FromSsize_t(PyArray_DIM(a, i));
    shape2_j = PyLong_FromSsize_t(PyArray_DIM(b, j));

    if (!format || !shape1 || !shape2 || !i_obj || !j_obj ||
            !shape1_i || !shape2_j) {
        goto end;
    }

    fmt_args = PyTuple_Pack(6, shape1, shape2,
                            shape1_i, i_obj, shape2_j, j_obj);
    if (fmt_args == NULL) {
        goto end;
    }

    errmsg = PyUString_Format(format, fmt_args);
    if (errmsg != NULL) {
        PyErr_SetObject(PyExc_ValueError, errmsg);
    }
    else {
        PyErr_SetString(PyExc_ValueError, "shapes are not aligned");
    }

end:
    Py_XDECREF(errmsg);
    Py_XDECREF(fmt_args);
    Py_XDECREF(format);
    Py_XDECREF(i_obj);
    Py_XDECREF(j_obj);
    Py_XDECREF(shape1);
    Py_XDECREF(shape2);
    Py_XDECREF(shape1_i);
    Py_XDECREF(shape2_j);
}
Esempio n. 19
0
static PyObject *
forms_do_or_check_forms(PyObject *dummy, FL_OBJECT *(*func)(void))
{
	FL_OBJECT *generic;
	genericobject *g;
	PyObject *arg, *res;

	for (;;) {
		Py_BEGIN_ALLOW_THREADS
		generic = (*func)();
		Py_END_ALLOW_THREADS
		if (generic == NULL) {
			Py_INCREF(Py_None);
			return Py_None;
		}
		if (generic == FL_EVENT) {
			int dev;
			short val;
			if (my_event_callback == NULL)
				return PyInt_FromLong(-1L);
			dev = fl_qread(&val);
			arg = Py_BuildValue("(ih)", dev, val);
			if (arg == NULL)
				return NULL;
			res = PyEval_CallObject(my_event_callback, arg);
			Py_XDECREF(res);
			Py_DECREF(arg);
			if (res == NULL)
				return NULL; /* Callback raised exception */
			continue;
		}
		g = findgeneric(generic);
		if (g == NULL) {
			/* Object not known to us (some dialogs cause this) */
			continue; /* Ignore it */
		}
		if (g->ob_callback == NULL) {
			Py_INCREF(g);
			return ((PyObject *) g);
		}
		arg = PyTuple_Pack(2, (PyObject *)g, g->ob_callback_arg);
		if (arg == NULL)
			return NULL;
		res = PyEval_CallObject(g->ob_callback, arg);
		Py_XDECREF(res);
		Py_DECREF(arg);
		if (res == NULL)
			return NULL; /* Callback raised exception */
	}
}
Esempio n. 20
0
static PyObject*
Snmp_oid2string(PyObject *resultvalue)
{
	PyObject *dot, *tmp, *tmp2, *list;
	int i;
	if ((list = PyTuple_New(PyTuple_Size(resultvalue))) == NULL)
		return NULL;
	for (i = 0; i < PyTuple_Size(resultvalue); i++) {
		if ((tmp = PyTuple_GetItem(resultvalue, i)) == NULL) {
			Py_DECREF(list);
			return NULL;
		}
		if ((tmp2 = PyObject_Str(tmp)) == NULL) {
			Py_DECREF(list);
			return NULL;
		}
		PyTuple_SetItem(list, i, tmp2);
		if (PyErr_Occurred()) {
			Py_DECREF(tmp2);
			Py_DECREF(list);
			return NULL;
		}
	}
	Py_DECREF(resultvalue);
	resultvalue = list;
	if ((dot = PyString_FromString(".")) == NULL)
		return NULL;
	if ((tmp = PyObject_CallMethod(dot,
		    "join", "(O)", resultvalue)) == NULL) {
		Py_DECREF(dot);
		return NULL;
	}
	Py_DECREF(resultvalue);
	Py_DECREF(dot);
	resultvalue = tmp;
	if ((tmp = PyTuple_Pack(1, resultvalue)) == NULL)
		return NULL;
	Py_DECREF(resultvalue);
	resultvalue = tmp;
	if ((tmp2 = PyString_FromString(".%s")) == NULL)
		return NULL;
	if ((tmp = PyString_Format(tmp2,
		    resultvalue)) == NULL) {
		Py_DECREF(tmp2);
		return NULL;
	}
	Py_DECREF(tmp2);
	Py_DECREF(resultvalue);
	return tmp;
}
Esempio n. 21
0
PyObject *
PyErr_NewException(const char *name, PyObject *base, PyObject *dict)
{
    const char *dot;
    PyObject *modulename = NULL;
    PyObject *classname = NULL;
    PyObject *mydict = NULL;
    PyObject *bases = NULL;
    PyObject *result = NULL;
    dot = strrchr(name, '.');
    if (dot == NULL) {
        PyErr_SetString(PyExc_SystemError,
            "PyErr_NewException: name must be module.class");
        return NULL;
    }
    if (base == NULL)
        base = PyExc_Exception;
    if (dict == NULL) {
        dict = mydict = PyDict_New();
        if (dict == NULL)
            goto failure;
    }
    if (PyDict_GetItemString(dict, "__module__") == NULL) {
        modulename = PyUnicode_FromStringAndSize(name,
                                             (Py_ssize_t)(dot-name));
        if (modulename == NULL)
            goto failure;
        if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
            goto failure;
    }
    if (PyTuple_Check(base)) {
        bases = base;
        /* INCREF as we create a new ref in the else branch */
        Py_INCREF(bases);
    } else {
        bases = PyTuple_Pack(1, base);
        if (bases == NULL)
            goto failure;
    }
    /* Create a real class. */
    result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO",
                                   dot+1, bases, dict);
  failure:
    Py_XDECREF(bases);
    Py_XDECREF(mydict);
    Py_XDECREF(classname);
    Py_XDECREF(modulename);
    return result;
}
Esempio n. 22
0
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred()) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args))
                PyErr_SetObject(PyExc_KeyError, args);
            Py_XDECREF(args);
        }
        return NULL;
    }
    Py_INCREF(value);
    return value;
}
Esempio n. 23
0
static PyObject* factorize(PyObject* self, PyObject* args){
    Py_ssize_t n = 0;
    if (!PyArg_ParseTuple(args, "n:factorize", &n)) return NULL;
    PyObject* prime_factorization = PyList_New(0);
    if (n < 2) return prime_factorization;
    size_t i = 0;
    while (!(n & 1)){
        n /= 2;
        i++;
    }
    if (i > 0){
        PyObject* tuple = PyTuple_Pack(2, PyInt_FromLong(2), PyInt_FromSize_t(i));
        PyList_Append(prime_factorization, tuple);
        Py_DECREF(tuple);
    }
    Py_ssize_t p = 3;
    while (p*p <= n){
        i = 0;
        while (n % p == 0){
            n /= p;
            i++;
        }
        if (i > 0){
            PyObject* tuple = PyTuple_Pack(2, PyInt_FromSsize_t(p), PyInt_FromSize_t(i));
            PyList_Append(prime_factorization, tuple);
            Py_DECREF(tuple);
        }
        p += 2;
    }
    if (n > 1){
        PyObject* tuple = PyTuple_Pack(2, PyInt_FromSsize_t(n), PyInt_FromLong(1));
        PyList_Append(prime_factorization, tuple);
        Py_DECREF(tuple);
    }
    return prime_factorization;
}
Esempio n. 24
0
int
microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast)
{
    PyObject *key;

    if (proto == NULL) proto = (PyObject*)&isqlquoteType;

    Dprintf("microprotocols_add: cast %p for (%s, ?)", cast, type->tp_name);

    key = PyTuple_Pack(2, (PyObject*)type, proto);
    PyDict_SetItem(psyco_adapters, key, cast);
    Py_DECREF(key);

    return 0;
}
Esempio n. 25
0
CValue *KX_PythonComponent::GetReplica()
{
	KX_PythonComponent *replica = new KX_PythonComponent(*this);
	replica->ProcessReplica();

	// Subclass the python component.
	PyTypeObject *type = Py_TYPE(GetProxy());
	if (!py_base_new(type, PyTuple_Pack(1, replica->GetProxy()), NULL)) {
		CM_Error("failed replicate component: \"" << m_name << "\"");
		delete replica;
		return NULL;
	}

	return replica;
}
Esempio n. 26
0
File: lists.c Progetto: rhn/snakeoil
static PyObject *
snakeoil_iflatten_instance_new(PyTypeObject *type,
							   PyObject *args, PyObject *kwargs)
{
	snakeoil_iflatten_instance *self;
	PyObject *l=NULL, *skip_flattening=(PyObject*)&PyBaseString_Type;
	int res;

	if (kwargs && PyDict_Size(kwargs)) {
		PyErr_SetString(PyExc_TypeError,
						"iflatten_instance takes no keyword arguments");
		return NULL;
	}
	if (!PyArg_UnpackTuple(args, "iflatten_instance", 1, 2,
						   &l, &skip_flattening)) {
		return NULL;
	}

	/* Check if we got a single argument that should be skipped. */
	res = PyObject_IsInstance(l, skip_flattening);
	if (res == -1) {
		return NULL;
	} else if (res) {
		PyObject *tuple = PyTuple_Pack(1, l);
		if (!tuple) {
			return NULL;
		}
		PyObject *iter = PyObject_GetIter(tuple);
		Py_DECREF(tuple);
		return iter;
	}

	self = (snakeoil_iflatten_instance *)type->tp_alloc(type, 0);
	if (!self)
		return NULL;

	self->in_iternext = 0;

	if (!(self->iterables = build_initial_iterables(l))) {
		Py_DECREF(self);
		return NULL;
	}

	Py_INCREF(skip_flattening);
	self->skip_flattening = skip_flattening;

	return (PyObject *)self;
}
Esempio n. 27
0
PyObject* JSONFileToObj(PyObject* self, PyObject *args, PyObject *kwargs)
{
  PyObject *read;
  PyObject *string;
  PyObject *result;
  PyObject *file = NULL;
  PyObject *argtuple;

  if (!PyArg_ParseTuple (args, "O", &file))
  {
    return NULL;
  }

  if (!PyObject_HasAttrString (file, "read"))
  {
    PyErr_Format (PyExc_TypeError, "expected file");
    return NULL;
  }

  read = PyObject_GetAttrString (file, "read");

  if (!PyCallable_Check (read)) {
    Py_XDECREF(read);
    PyErr_Format (PyExc_TypeError, "expected file");
    return NULL;
  }

  string = PyObject_CallObject (read, NULL);
  Py_XDECREF(read);

  if (string == NULL)
  {
    return NULL;
  }

  argtuple = PyTuple_Pack(1, string);

  result = JSONToObj (self, argtuple, kwargs);

  Py_XDECREF(argtuple);
  Py_XDECREF(string);

  if (result == NULL) {
    return NULL;
  }

  return result;
}
Esempio n. 28
0
static PyObject *ffi_list_types(FFIObject *self, PyObject *noargs)
{
    Py_ssize_t i, n1 = self->types_builder.ctx.num_typenames;
    Py_ssize_t n23 = self->types_builder.ctx.num_struct_unions;
    PyObject *o, *lst[3] = {NULL, NULL, NULL}, *result = NULL;

    lst[0] = PyList_New(n1);
    if (lst[0] == NULL)
        goto error;
    lst[1] = PyList_New(0);
    if (lst[1] == NULL)
        goto error;
    lst[2] = PyList_New(0);
    if (lst[2] == NULL)
        goto error;

    for (i = 0; i < n1; i++) {
        o = PyText_FromString(self->types_builder.ctx.typenames[i].name);
        if (o == NULL)
            goto error;
        PyList_SET_ITEM(lst[0], i, o);
    }

    for (i = 0; i < n23; i++) {
        const struct _cffi_struct_union_s *s;
        int err, index;

        s = &self->types_builder.ctx.struct_unions[i];
        if (s->name[0] == '$')
            continue;

        o = PyText_FromString(s->name);
        if (o == NULL)
            goto error;
        index = (s->flags & _CFFI_F_UNION) ? 2 : 1;
        err = PyList_Append(lst[index], o);
        Py_DECREF(o);
        if (err < 0)
            goto error;
    }
    result = PyTuple_Pack(3, lst[0], lst[1], lst[2]);
    /* fall-through */
 error:
    Py_XDECREF(lst[2]);
    Py_XDECREF(lst[1]);
    Py_XDECREF(lst[0]);
    return result;
}
Esempio n. 29
0
static PyObject *
create_filter(PyObject *category, const char *action)
{
    static PyObject *ignore_str = NULL;
    static PyObject *error_str = NULL;
    static PyObject *default_str = NULL;
    static PyObject *always_str = NULL;
    PyObject *action_obj = NULL;

    if (!strcmp(action, "ignore")) {
        if (ignore_str == NULL) {
            ignore_str = PyUnicode_InternFromString("ignore");
            if (ignore_str == NULL)
                return NULL;
        }
        action_obj = ignore_str;
    }
    else if (!strcmp(action, "error")) {
        if (error_str == NULL) {
            error_str = PyUnicode_InternFromString("error");
            if (error_str == NULL)
                return NULL;
        }
        action_obj = error_str;
    }
    else if (!strcmp(action, "default")) {
        if (default_str == NULL) {
            default_str = PyUnicode_InternFromString("default");
            if (default_str == NULL)
                return NULL;
        }
        action_obj = default_str;
    }
    else if (!strcmp(action, "always")) {
        if (always_str == NULL) {
            always_str = PyUnicode_InternFromString("always");
            if (always_str == NULL)
                return NULL;
        }
        action_obj = always_str;
    }
    else {
        Py_FatalError("unknown action");
    }

    /* This assumes the line number is zero for now. */
    return PyTuple_Pack(5, action_obj, Py_None, category, Py_None, _PyLong_Zero);
}
Esempio n. 30
0
// keep this simple so that print(x) and str(x) are concise if x is NA
static PyObject *
NA_repr(SlopNAObject *self)
{
  PyObject* type_repr = PyObject_Repr(self->exc_type);

  PyObject* repr = PyTuple_Pack(1, type_repr);

  PyObject* fmt = PyString_FromString("<NA %s>");
  PyObject* ret = PyString_Format(fmt, repr);
  Py_DECREF(fmt);

  Py_DECREF(repr);
  Py_DECREF(type_repr);

  return ret;
}