/* * This function returns a NEW reference, i.e. caller must decref it in the end. */ PyObject* JySync_Init_PyMethod_From_JyMethod(jobject src, PyTypeObject* nonNativeSubtype) { env(NULL); return PyMethod_New( JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyMethod___func__Field)), JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyMethod___self__Field)), JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyMethod_im_classField))); }
/* * This function returns a NEW reference, i.e. caller must decref it in the end. */ PyObject* JySync_Init_PyInstance_From_JyInstance(jobject src, PyTypeObject* nonNativeSubtype) { env(NULL); (*env)->CallStaticVoidMethod(env, JyNIClass, JyNI_suspendPyInstanceFinalizer, src); PyObject* er = PyInstance_NewRaw( JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyInstance_instclassField)), JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyInstance___dict__Field))); return er; }
static PyObject * slice_reduce(PySliceObject* self) { env(NULL); return Py_BuildValue("O(OOO)", Py_TYPE(self), //self->start, self->stop, self->step); JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject((PyObject*) self), pySliceGetStart)), JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject((PyObject*) self), pySliceGetStop)), JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject((PyObject*) self), pySliceGetStep))); }
/* * This function returns a NEW reference, i.e. caller must decref it in the end. */ PyObject* JySync_Init_PyClass_From_JyClass(jobject src, PyTypeObject* nonNativeSubtype) { env(NULL); jstring nm = (*env)->GetObjectField(env, src, pyClass___name__Field); cstr_from_jstring(cnm, nm); // jputs("Sync-Class:"); // jputs(cnm); return PyClass_New( JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyClass___bases__Field)), JyNI_PyObject_FromJythonPyObject((*env)->GetObjectField(env, src, pyClass___dict__Field)), PyString_FromString(cnm)); }
PyObject * _PyImport_LoadDynamicModule(char *name, char *pathname, FILE *fp) { PyObject* m = JyNI_PyObject_FromJythonPyObject(_PyImport_LoadDynamicModuleJy(name, pathname, fp)); Py_INCREF(m); return m; }
PyObject* PyCode_Get_co_code(PyObject* code) { env(NULL); jobject jCode = JyNI_JythonPyObject_FromPyObject(code); jobject result = (*env)->CallStaticObjectMethod(env, JyNIClass, JyNI_pyCode_co_code, jCode); return JyNI_PyObject_FromJythonPyObject(result); }
PyObject * PySys_GetObject(char *name) { JNIEnv *env; if ((*java)->GetEnv(java, (void **)&env, JNI_VERSION_1_2)) { return NULL; // JNI version not supported } jobject nameStr = (*env)->NewStringUTF(env, name); PyObject* er = (PyObject*) (*env)->CallStaticLongMethod(env, JyNIClass, JyNIGetJyObjectByName, nameStr); if (er != NULL) return er; else { jobject result = (*env)->CallStaticObjectMethod(env, JyNIClass, JyNIGetPyObjectByName, nameStr); if (result == NULL) return NULL; else { //puts("PySys_GetObject creates new object:"); //puts(name); return JyNI_PyObject_FromJythonPyObject(result); } } /*PyThreadState *tstate = PyThreadState_GET(); PyObject *sd = tstate->interp->sysdict; if (sd == NULL) return NULL; return PyDict_GetItemString(sd, name);*/ }
PyObject * PyModule_New(const char *name) { env(NULL); return JyNI_PyObject_FromJythonPyObject( (*env)->NewObject(env, pyModuleClass, pyModule_byStringConstructor, (*env)->CallObjectMethod(env, (*env)->NewStringUTF(env, name), string_intern))); /*PyModuleObject *m; PyObject *nameobj; m = PyObject_GC_New(PyModuleObject, &PyModule_Type); if (m == NULL) return NULL; nameobj = PyString_FromString(name); m->md_dict = PyDict_New(); if (m->md_dict == NULL || nameobj == NULL) goto fail; if (PyDict_SetItemString(m->md_dict, "__name__", nameobj) != 0) goto fail; if (PyDict_SetItemString(m->md_dict, "__doc__", Py_None) != 0) goto fail; if (PyDict_SetItemString(m->md_dict, "__package__", Py_None) != 0) goto fail; Py_DECREF(nameobj); PyObject_GC_Track(m); return (PyObject *)m; fail: Py_XDECREF(nameobj); Py_DECREF(m); return NULL;*/ }
static PyObject * slice_get_step(PySliceObject *m, void *closure) { env(NULL); return JyNI_PyObject_FromJythonPyObject( (*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject((PyObject*) m), pySliceGetStep)); }
/* Lookup the error handling callback function registered under the name error. As a special case NULL can be passed, in which case the error handling callback for strict encoding will be returned. */ PyObject *PyCodec_LookupError(const char *name) { env(NULL); jobject er = (*env)->CallStaticObjectMethod(env, pyCodecsClass, pyCodecsLookupError, (*env)->NewStringUTF(env, name)); jstring tpName = (*env)->CallObjectMethod(env, (*env)->CallObjectMethod(env, er, pyObjectGetType), pyTypeGetName); //puts("tp name obtained:"); jputsLong(__LINE__); cstr_from_jstring(cName, tpName); jputs(cName); return JyNI_PyObject_FromJythonPyObject(er); // PyObject *handler = NULL; // // PyInterpreterState *interp = PyThreadState_GET()->interp; // if (interp->codec_search_path == NULL && _PyCodecRegistry_Init()) // return NULL; // // if (name==NULL) // name = "strict"; // handler = PyDict_GetItemString(interp->codec_error_registry, (char *)name); // if (!handler) // PyErr_Format(PyExc_LookupError, "unknown error handler name '%.400s'", name); // else // Py_INCREF(handler); // return handler; }
PyObject * PyFunction_New(PyObject *code, PyObject *globals) { env(NULL); jobject jCode = JyNI_JythonPyObject_FromPyObject(code); jobject jGlobals = JyNI_JythonPyObject_FromPyObject(globals); jobject result = (*env)->NewObject(env, pyFunctionClass, pyFunctionConstructor, jGlobals, NULL, jCode); return JyNI_PyObject_FromJythonPyObject(result); // PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, // &PyFunction_Type); // static PyObject *__name__ = 0; // if (op != NULL) { // PyObject *doc; // PyObject *consts; // PyObject *module; // op->func_weakreflist = NULL; // Py_INCREF(code); // op->func_code = code; // Py_INCREF(globals); // op->func_globals = globals; // op->func_name = ((PyCodeObject *)code)->co_name; // Py_INCREF(op->func_name); // op->func_defaults = NULL; /* No default arguments */ // op->func_closure = NULL; // consts = ((PyCodeObject *)code)->co_consts; // if (PyTuple_Size(consts) >= 1) { // doc = PyTuple_GetItem(consts, 0); // if (!PyString_Check(doc) && !PyUnicode_Check(doc)) // doc = Py_None; // } // else // doc = Py_None; // Py_INCREF(doc); // op->func_doc = doc; // op->func_dict = NULL; // op->func_module = NULL; // // /* __module__: If module name is in globals, use it. // Otherwise, use None. // */ // if (!__name__) { // __name__ = PyString_InternFromString("__name__"); // if (!__name__) { // Py_DECREF(op); // return NULL; // } // } // module = PyDict_GetItem(globals, __name__); // if (module) { // Py_INCREF(module); // op->func_module = module; // } // } // else // return NULL; // _JyNI_GC_TRACK(op); // return (PyObject *)op; }
PyObject* JySync_Init_PyCFunction_From_JyBuiltinCallable(jobject src, PyTypeObject* nonNativeSubtype) { // jputs(__FUNCTION__); env(NULL); if ((*env)->IsInstanceOf(env, src, pyCFunctionClass)) { jputs("JyNI-warning: JySync_Init_PyCFunction_From_JyBuiltinCallable shouldn't be called with PyCFunction."); } PyMethodDef* mdef = malloc(sizeof(PyMethodDef)); jobject info = (*env)->GetObjectField(env, src, pyBuiltinCallable_infoField); jint max = (*env)->CallIntMethod(env, info, pyBuiltinCallableInfo_getMaxargs); mdef->ml_flags = (max ? (METH_KEYWORDS | METH_VARARGS) : METH_NOARGS) | METH_JYTHON; jstring jtmp = (*env)->CallObjectMethod(env, info, pyBuiltinCallableInfo_getName); global_cstr_from_jstring(cName, jtmp); mdef->ml_name = cName; // puts(cName); jtmp = (*env)->CallObjectMethod(env, src, pyBuiltinCallable_getDoc); if (jtmp) { global_cstr_from_jstring2(cDoc, jtmp); mdef->ml_doc = cDoc; } else mdef->ml_doc = NULL; mdef->ml_meth = (PyCFunctionWithKeywords) jyBuiltinCallWithKeywords; jobject jmodule = (*env)->CallObjectMethod(env, src, pyBuiltinCallable_getModule); jobject jself = (*env)->CallObjectMethod(env, src, pyBuiltinCallable_getSelf); // Account for incompatible behavior: // In Jython an unbound method has self = None while in CPython self = NULL PyObject* mself = (*env)->IsSameObject(env, jself, JyNone) ? NULL : JyNI_PyObject_FromJythonPyObject(jself); // putsPy(mself); PyCFunctionObject* res = PyCFunction_NewEx(mdef, mself, JyNI_PyObject_FromJythonPyObject(jmodule)); JyNI_AddOrSetJyAttributeWithFlags(AS_JY(res), JyAttributeMethodName, cName, JY_ATTR_OWNS_VALUE_FLAG_MASK); if (mdef->ml_doc) JyNI_AddOrSetJyAttributeWithFlags(AS_JY(res), JyAttributeMethodDoc, mdef->ml_doc, JY_ATTR_OWNS_VALUE_FLAG_MASK); JyNI_AddOrSetJyAttributeWithFlags(AS_JY(res), JyAttributeMethodDef, mdef, JY_ATTR_OWNS_VALUE_FLAG_MASK); return (PyObject*) res; }
PyObject* JySync_Init_PyProperty_From_JyProperty(jobject src, PyTypeObject* nonNativeSubtype) { env(NULL); propertyobject* result = PyObject_GC_New(propertyobject, &PyProperty_Type); if (result != NULL) { result->prop_get = JyNI_PyObject_FromJythonPyObject( (*env)->GetObjectField(env, src, pyProperty_fgetField)); result->prop_set = JyNI_PyObject_FromJythonPyObject( (*env)->GetObjectField(env, src, pyProperty_fsetField)); result->prop_del = JyNI_PyObject_FromJythonPyObject( (*env)->GetObjectField(env, src, pyProperty_fdelField)); result->prop_doc = JyNI_PyObject_FromJythonPyObject( (*env)->GetObjectField(env, src, pyProperty_docField)); result->getter_doc = (*env)->GetBooleanField(env, src, pyProperty_docFromGetterField); _JyNI_GC_TRACK(result); } return (PyObject *) result; }
static PyObject * func_get_name(PyFunctionObject *op) { env(NULL); jobject jFunc = JyNI_JythonPyObject_FromPyObject(op); jobject result = (*env)->GetObjectField(env, jFunc, pyFunction__name__); return JyNI_PyObject_FromJythonPyObject(result); // Py_INCREF(op->func_name); // return op->func_name; }
static void slice_dealloc(PySliceObject *r) { JyObject* jy = AS_JY_NO_GC(r); if (JyObject_IS_INITIALIZED(jy)) { env(); Py_DECREF(JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, jy->jy, pySliceGetStart))); Py_DECREF(JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, jy->jy, pySliceGetStop))); Py_DECREF(JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, jy->jy, pySliceGetStep))); // Py_DECREF(r->step); // Py_DECREF(r->start); // Py_DECREF(r->stop); // PyObject_Del(r); } JyNI_CleanUp_JyObject(jy); //PyObject_Del(jy); PyObject_RawFree(jy); }
//PyObject* JySync_Init_PyFunction_From_JyFunction(jobject src) void JySync_PyFunction_From_JyFunction(jobject src, PyObject* dest) { //Need to sync: //func_code, func_globals, func_module, func_defaults, func_closure env(); jobject jCode = (*env)->GetObjectField(env, src, pyFunction___code__Field); PyObject* pt = JyNI_PyObject_FromJythonPyObject(jCode); ((PyFunctionObject*) dest)->func_code = pt; jobject jGlobals = (*env)->CallObjectMethod(env, src, pyFunction_getFuncGlobals); ((PyFunctionObject*) dest)->func_globals = JyNI_PyObject_FromJythonPyObject(jGlobals); jobject jModule = (*env)->GetObjectField(env, src, pyFunction___module__Field); ((PyFunctionObject*) dest)->func_module = JyNI_PyObject_FromJythonPyObject(jModule); jobject jDefaults = (*env)->CallObjectMethod(env, src, pyFunction_getFuncDefaults); ((PyFunctionObject*) dest)->func_defaults = JyNI_PyObject_FromJythonPyObject(jDefaults); jobject jClosure = (*env)->GetObjectField(env, src, pyFunction___closure__Field); ((PyFunctionObject*) dest)->func_closure = JyNI_PyObject_FromJythonPyObject(jClosure); jstring jName = (*env)->GetObjectField(env, src, pyFunction___name__Field); cstr_from_jstring(cName, jName); ((PyFunctionObject*) dest)->func_name = PyString_FromString(cName); }
static PyObject* func_repr(PyFunctionObject *op) { env(NULL); jobject jFunc = JyNI_JythonPyObject_FromPyObject(op); jobject result = (*env)->CallObjectMethod(env, jFunc, pyObject__repr__); return JyNI_PyObject_FromJythonPyObject(result); // return PyString_FromFormat("<function %s at %p>", // PyString_AsString(op->func_name), // op); }
/* * This function returns a NEW reference, i.e. caller must decref it in the end. */ PyObject* JySync_Init_PyList_From_JyList(jobject src, PyTypeObject* nonNativeSubtype) { env(NULL); //maybe optimize a bit more here: //if most objects in the list have not yet been converted, //much lookup is done twice here. jarray handles = (*env)->CallStaticObjectMethod(env, JyNIClass, JyNI_lookupNativeHandles, src); jsize size = (*env)->GetArrayLength(env, handles); PyObject* op = PyList_New((Py_ssize_t) size); (*env)->CallStaticObjectMethod(env, JyNIClass, JyNI_setNativeHandle, src, (jlong) op);//, JNI_FALSE); AS_JY_WITH_GC(op)->flags |= JY_HAS_JHANDLE_FLAG_MASK; jsize i; PyObject* v; jlong* arr = (*env)->GetLongArrayElements(env, handles, NULL); for (i = 0; i < size; ++i) { v = (PyObject*) arr[i]; if (!v) v = JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, src, pySequence_pyget, i)); else Py_INCREF(v); // if (!v) v = _JyNI_PyObject_FromJythonPyObject( // (*env)->CallObjectMethod(env, src, pyListPyGet, i), JNI_FALSE, JNI_FALSE, JNI_TRUE); //JyNI_PyObject_FromJythonPyObject(jobject jythonPyObject, jboolean lookupNative, jboolean checkCPeer, jboolean checkForType) PyList_SET_ITEM(op, i, v); } //jputsLong(__LINE__); (*env)->ReleaseLongArrayElements(env, handles, arr, JNI_ABORT); JyNI_GC_ExploreObject(op); //JyNI_GC_ExploreObject should have initialized JyGCHead to a JyList-object. jobject jyList = (*env)->NewLocalRef(env, (jobject) JyObject_GetJyGCHead(op, AS_JY_WITH_GC(op))); if (!jyList || (*env)->IsSameObject(env, jyList, NULL)) { jputs("This should not happen! JyList gc-head was deleted after explore."); jputs(__FUNCTION__); if (!jyList) jputs("truely NULL"); else (*env)->DeleteWeakGlobalRef(env, jyList); jputs("Restore it..."); jyList = (*env)->NewObject(env, JyListClass, JyList_fromBackendHandleConstructor, (jlong) src); JyObject_AddOrSetJyGCHead(src, AS_JY_WITH_GC(src), (*env)->NewWeakGlobalRef(env, jyList)); JyNI_GC_ExploreObject(src); } //(*env)->CallVoidMethod(env, jyList, JyListInstallToPyList, src); (*env)->SetObjectField(env, src, pyList_listField, jyList); // jputsLong(__LINE__); (*env)->CallObjectMethod(env, jyList, pyObjectGCHead_setPyObject, src); (*env)->DeleteLocalRef(env, jyList); //Py_INCREF(op); //For now we make the list immortal here. Later GC will take care of it. //(should now work without this) //jputsLong(__LINE__); return op; }
PyObject* PyCode_Get_co_consts(PyObject* code) { env(NULL); jobject jCode = JyNI_JythonPyObject_FromPyObject(code); jobject jArray = (*env)->GetObjectField(env, jCode, pyBytecode_co_consts); Py_ssize_t size = 0; if (jArray) size = (*env)->GetArrayLength(env, jArray); PyTupleObject* result = PyTuple_New(size); Py_ssize_t i; for (i = 0; i < size; ++i) PyTuple_SET_ITEM(result, i, JyNI_PyObject_FromJythonPyObject( (*env)->GetObjectArrayElement(env, jArray, i))); return result; }
PyObject* JySync_Init_PyTuple_From_JyTupleForMRO(jobject src) { env(NULL); jint srcSize = (*env)->CallIntMethod(env, src, collection_size); PyObject* er = PyTuple_New(srcSize); (*env)->CallStaticObjectMethod(env, JyNIClass, JyNI_setNativeHandle, src, (jlong) er); AS_JY_WITH_GC(er)->flags |= JY_HAS_JHANDLE_FLAG_MASK; int i; for (i = 1; i < srcSize; ++i) { PyObject* item = JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, src, pySequence_pyget, i)); PyTuple_SET_ITEM(er, i, item); } return er; }
PyObject *PyCodec_Encode(PyObject *object, const char *encoding, const char *errors) { env(NULL); jstring enc = (*env)->NewStringUTF(env, encoding); jstring err = (*env)->NewStringUTF(env, errors); return JyNI_PyObject_FromJythonPyObject( //todo: Type check of object - must be PyString or PyUnicode or a subtype of any of these (*env)->CallStaticObjectMethod(env, pyCodecsClass, pyCodecsEncode, JyNI_JythonPyObject_FromPyObject(object), enc, err)); // PyObject *encoder = NULL; // PyObject *args = NULL, *result = NULL; // PyObject *v; // // encoder = PyCodec_Encoder(encoding); // if (encoder == NULL) // goto onError; // // args = args_tuple(object, errors); // if (args == NULL) // goto onError; // // result = PyEval_CallObject(encoder,args); // if (result == NULL) // goto onError; // // if (!PyTuple_Check(result) || // PyTuple_GET_SIZE(result) != 2) { // PyErr_SetString(PyExc_TypeError, // "encoder must return a tuple (object,integer)"); // goto onError; // } // v = PyTuple_GET_ITEM(result,0); // Py_INCREF(v); // /* We don't check or use the second (integer) entry. */ // // Py_DECREF(args); // Py_DECREF(encoder); // Py_DECREF(result); // return v; // // onError: // Py_XDECREF(result); // Py_XDECREF(args); // Py_XDECREF(encoder); // return NULL; }
static PyObject * func_get_dict(PyFunctionObject *op) { env(NULL); jobject jFunc = JyNI_JythonPyObject_FromPyObject(op); jobject result = (*env)->CallObjectMethod(env, jFunc, pyObjectGetDict); return JyNI_PyObject_FromJythonPyObject(result); // if (restricted()) // return NULL; // if (op->func_dict == NULL) { // op->func_dict = PyDict_New(); // if (op->func_dict == NULL) // return NULL; // } // Py_INCREF(op->func_dict); // return op->func_dict; }
/* * This function returns a NEW reference, i.e. caller must decref it in the end. */ PyObject* JySync_Init_PyWeakCallableProxy_From_JyWeakCallableProxy(jobject src, PyTypeObject* nonNativeSubtype) { // Todo: Handle case that the native counterpart of the Java-referent is // not weakly referenceable in CPython-terms. // See PyType_SUPPORTS_WEAKREFS(Py_TYPE(ob)) env(NULL); jobject jReferent = (*env)->CallObjectMethod(env, src, AbstractReference_get); PyObject* referent = JyNI_PyObject_FromJythonPyObject(jReferent); /* Note that an extra Py_INCREF is not necessary since the conversion method * returns a new reference. * JyNI-note: It is okay to hold a refcount for the weakly referenced object. * This will be decreffed when the Java-side GlobalRef is released. */ PyObject* result = PyWeakref_NewProxy(referent, NULL); // Todo: Support callback. return result; }
static PyObject * module_repr(PyModuleObject *m) { env(NULL); return JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject((PyObject*) m), pyObject___repr__)); // char *name; // char *filename; // // name = PyModule_GetName((PyObject *)m); // if (name == NULL) { // PyErr_Clear(); // name = "?"; // } // filename = PyModule_GetFilename((PyObject *)m); // if (filename == NULL) { // PyErr_Clear(); // return PyString_FromFormat("<module '%s' (built-in)>", name); // } // return PyString_FromFormat("<module '%s' from '%s'>", name, filename); }
static PyObject * slice_repr(PySliceObject *r) { env(NULL); return JyNI_PyObject_FromJythonPyObject( (*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject((PyObject*) r), pySliceToString)); // PyObject *s, *comma; // // s = PyString_FromString("slice("); // comma = PyString_FromString(", "); // PyString_ConcatAndDel(&s, PyObject_Repr(r->start)); // PyString_Concat(&s, comma); // PyString_ConcatAndDel(&s, PyObject_Repr(r->stop)); // PyString_Concat(&s, comma); // PyString_ConcatAndDel(&s, PyObject_Repr(r->step)); // PyString_ConcatAndDel(&s, PyString_FromString(")")); // Py_DECREF(comma); // return s; }
PyObject * PyModule_GetDict(PyObject *m) { //puts("PyModule_GetDict"); if (!PyModule_Check(m)) { PyErr_BadInternalCall(); return NULL; } env(NULL); //jobject jm = (*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject(m), pyModuleGetDict); PyObject* er = JyNI_PyObject_FromJythonPyObject( (*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject(m), pyModule_getDict)); return er; /*PyObject *d; if (!PyModule_Check(m)) { PyErr_BadInternalCall(); return NULL; } d = ((PyModuleObject *)m) -> md_dict; if (d == NULL) ((PyModuleObject *)m) -> md_dict = d = PyDict_New(); return d;*/ }
static PyObject * code_repr(PyCodeObject *co) { env(NULL); jobject jCode = JyNI_JythonPyObject_FromPyObject(co); jobject repr_str = (*env)->CallObjectMethod(env, jCode, pyObject__repr__); return JyNI_PyObject_FromJythonPyObject(repr_str); // char buf[500]; // int lineno = -1; // char *filename = "???"; // char *name = "???"; // // if (co->co_firstlineno != 0) // lineno = co->co_firstlineno; // if (co->co_filename && PyString_Check(co->co_filename)) // filename = PyString_AS_STRING(co->co_filename); // if (co->co_name && PyString_Check(co->co_name)) // name = PyString_AS_STRING(co->co_name); // PyOS_snprintf(buf, sizeof(buf), // "<code object %.100s at %p, file \"%.300s\", line %d>", // name, co, filename, lineno); // return PyString_FromString(buf); }
/* * This function returns a NEW reference, i.e. caller must decref it in the end. * For every item in the tuple also a new reference is created. However the tuple * deallocator will take care of these. */ PyObject* JySync_Init_PyTuple_From_JyTuple(jobject src, PyTypeObject* nonNativeSubtype) { //jputs("JySync_Init_PyTuple_From_JyTuple"); env(NULL); //jarray back = (*env)->CallObjectMethod(env, src, pyTupleGetArray); jint srcSize = (*env)->CallIntMethod(env, src, collection_size); //jputs("### creating tuple..."); PyObject* er = PyTuple_New(srcSize); (*env)->CallStaticObjectMethod(env, JyNIClass, JyNI_setNativeHandle, src, (jlong) er);//, JNI_FALSE); AS_JY_WITH_GC(er)->flags |= JY_HAS_JHANDLE_FLAG_MASK; //jputs("### created tuple..."); //Py_XINCREF(er); //if (srcSize != PyTuple_GET_SIZE(dest)) //...throw exception since tuple is immutable int i; for (i = 0; i < srcSize; ++i) { //jputsLong(i); PyObject* item = JyNI_PyObject_FromJythonPyObject((*env)->CallObjectMethod(env, src, pySequence_pyget, i)); //Py_XINCREF(item); //PyTuple_SetItem(er, i, item); PyTuple_SET_ITEM(er, i, item); // if (!item) { // jputs("Add null-item to tuple:"); // jputsLong(er); // jobject jNull = (*env)->CallObjectMethod(env, src, pyTuplePyGet, i); // if (!jNull) jputs("j also null"); // else if ((*env)->IsSameObject(env, jNull, NULL)) jputs("j equal null"); // else { // jputs("j not null:"); // JyNI_printJInfo(jNull); // } // } } //JYNI_GC_TUPLE_EXPLORE(er); return er; }
PyObject* JySync_Init_PyMethodDescr_From_JyMethodDescr(jobject src, PyTypeObject* nonNativeSubtype) { // jputs(__FUNCTION__); env(NULL); jint max = (*env)->CallIntMethod(env, src, pyBuiltinCallableInfo_getMaxargs); //mdef->ml_flags = (max ? (METH_KEYWORDS | METH_VARARGS) : METH_NOARGS) | METH_JYTHON; jstring jtmp = (*env)->CallObjectMethod(env, src, pyBuiltinCallableInfo_getName); global_cstr_from_jstring(cName, jtmp); //mdef->ml_name = cName; jobject dtype = (*env)->GetObjectField(env, src, pyDescr_dtypeField); PyMethodDef* mdef = malloc(sizeof(PyMethodDef)); mdef->ml_flags = (max ? (METH_KEYWORDS | METH_VARARGS) : METH_NOARGS) | METH_JYTHON | METH_JYTHON_CDEF; mdef->ml_name = cName; jtmp = (*env)->CallObjectMethod(env, src, pyMethodDescr_getDoc); if (jtmp) { global_cstr_from_jstring2(cDoc, jtmp); mdef->ml_doc = cDoc; } else mdef->ml_doc = NULL; mdef->ml_meth = (PyCFunctionWithKeywords) jyBuiltinCallWithKeywords; PyObject* result = PyDescr_NewMethod(JyNI_PyObject_FromJythonPyObject(dtype), mdef); JyNI_AddOrSetJyAttributeWithFlags(AS_JY_WITH_GC(result), JyAttributeMethodName, cName, JY_ATTR_OWNS_VALUE_FLAG_MASK); if (mdef->ml_doc) JyNI_AddOrSetJyAttributeWithFlags(AS_JY_WITH_GC(result), JyAttributeMethodDoc, mdef->ml_doc, JY_ATTR_OWNS_VALUE_FLAG_MASK); JyNI_AddOrSetJyAttributeWithFlags(AS_JY_WITH_GC(result), JyAttributeMethodDef, mdef, JY_ATTR_OWNS_VALUE_FLAG_MASK); return result; }
PyCodeObject * PyCode_New(int argcount, int nlocals, int stacksize, int flags, PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames, PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name, int firstlineno, PyObject *lnotab) { // Types: // PyObject *code something supporting buffer // PyObject *consts Tuple of PyObject // PyObject *names Tuple of PyString // PyObject *varnames Tuple of PyString // PyObject *freevars Tuple of PyString // PyObject *cellvars Tuple of PyString // PyObject *filename PyString // PyObject *name PyString // PyObject *lnotab PyString // PyCodeObject *co; /* Check argument types */ if (argcount < 0 || nlocals < 0 || code == NULL || consts == NULL || !PyTuple_Check(consts) || names == NULL || !PyTuple_Check(names) || varnames == NULL || !PyTuple_Check(varnames) || freevars == NULL || !PyTuple_Check(freevars) || cellvars == NULL || !PyTuple_Check(cellvars) || name == NULL || !PyString_Check(name) || filename == NULL || !PyString_Check(filename) || lnotab == NULL || !PyString_Check(lnotab) || !PyObject_CheckReadBuffer(code)) { PyErr_BadInternalCall(); return NULL; } env(NULL); //Try to get code from a buffer into a jstring... char* code_cstr; Py_ssize_t i; jstring code_jstr; if (PyObject_AsCharBuffer(code, &code_cstr, &i) == 0) { char code_cstr0[i+1]; //code_cstr might not be null-terminated strcpy(code_cstr0, code_cstr); code_jstr = (*env)->NewStringUTF(env, code_cstr0); } else { PyErr_BadInternalCall(); return NULL; } // jobject jConsts = NULL; // if (PyTuple_GET_SIZE(consts)) // { // (*env)->NewObjectArray(env, PyTuple_GET_SIZE(consts), pyObjectClass, NULL); // for (i = 0; i < PyTuple_GET_SIZE(consts); ++i) // (*env)->SetObjectArrayElement(env, jConsts, i, // JyNI_JythonPyObject_FromPyObject(PyTuple_GET_ITEM(consts, i))); // } pyTuple2jArray(consts, pyObjectClass, jConsts); // jobject jNames = (*env)->NewObjectArray(env, PyTuple_GET_SIZE(names), pyStringClass, NULL); // for (i = 0; i < PyTuple_GET_SIZE(names); ++i) // (*env)->SetObjectArrayElement(env, jNames, i, // JyNI_JythonPyObject_FromPyObject(PyTuple_GET_ITEM(names, i))); pyTuple2jArray(names, pyStringClass, jNames); // jobject jVarnames = (*env)->NewObjectArray(env, PyTuple_GET_SIZE(varnames), pyStringClass, NULL); // for (i = 0; i < PyTuple_GET_SIZE(varnames); ++i) // (*env)->SetObjectArrayElement(env, jVarnames, i, // JyNI_JythonPyObject_FromPyObject(PyTuple_GET_ITEM(varnames, i))); pyTuple2jArray(varnames, pyStringClass, jVarnames); // jobject jFreevars = (*env)->NewObjectArray(env, PyTuple_GET_SIZE(freevars), pyStringClass, NULL); // for (i = 0; i < PyTuple_GET_SIZE(freevars); ++i) // (*env)->SetObjectArrayElement(env, jFreevars, i, // JyNI_JythonPyObject_FromPyObject(PyTuple_GET_ITEM(freevars, i))); pyTuple2jArray(freevars, pyStringClass, jFreevars); // jobject jCellvars = (*env)->NewObjectArray(env, PyTuple_GET_SIZE(cellvars), pyStringClass, NULL); // for (i = 0; i < PyTuple_GET_SIZE(cellvars); ++i) // (*env)->SetObjectArrayElement(env, jCellvars, i, // JyNI_JythonPyObject_FromPyObject(PyTuple_GET_ITEM(cellvars, i))); pyTuple2jArray(cellvars, pyStringClass, jCellvars); jobject jFilename = JyNI_JythonPyObject_FromPyObject(filename); jobject jName = JyNI_JythonPyObject_FromPyObject(name); jobject jLnotab = JyNI_JythonPyObject_FromPyObject(lnotab); jobject result = (*env)->NewObject(env, pyBytecodeClass, pyBytecodeConstructor, argcount, nlocals, stacksize, flags, code_jstr, jConsts, jNames, jVarnames, jFilename, jName, firstlineno, jLnotab, jCellvars, jFreevars); return (PyCodeObject*) JyNI_PyObject_FromJythonPyObject(result); // intern_strings(names); // intern_strings(varnames); // intern_strings(freevars); // intern_strings(cellvars); /* Intern selected string constants */ // for (i = PyTuple_Size(consts); --i >= 0; ) { // PyObject *v = PyTuple_GetItem(consts, i); // if (!PyString_Check(v)) // continue; // if (!all_name_chars((unsigned char *)PyString_AS_STRING(v))) // continue; // PyString_InternInPlace(&PyTuple_GET_ITEM(consts, i)); // } // co = PyObject_NEW(PyCodeObject, &PyCode_Type); // if (co != NULL) { // co->co_argcount = argcount; // co->co_nlocals = nlocals; // co->co_stacksize = stacksize; // co->co_flags = flags; // Py_INCREF(code); // co->co_code = code; // Py_INCREF(consts); // co->co_consts = consts; // Py_INCREF(names); // co->co_names = names; // Py_INCREF(varnames); // co->co_varnames = varnames; // Py_INCREF(freevars); // co->co_freevars = freevars; // Py_INCREF(cellvars); // co->co_cellvars = cellvars; // Py_INCREF(filename); // co->co_filename = filename; // Py_INCREF(name); // co->co_name = name; // co->co_firstlineno = firstlineno; // Py_INCREF(lnotab); // co->co_lnotab = lnotab; // co->co_zombieframe = NULL; // co->co_weakreflist = NULL; // } // return co; }