jobject JySync_Init_JyList_From_PyList(PyObject* src, jclass subtype)
{
//jputs(__FUNCTION__);
//Since it is likely that src was created by an extension, we
//explicitly explore it here:
JyNI_GC_ExploreObject(src);
//JyNI_GC_ExploreObject should have initialized JyGCHead to a JyList-object.
env(NULL);
jobject jyList = (*env)->NewLocalRef(env, (jobject) JyObject_GetJyGCHead(src, AS_JY_WITH_GC(src)));
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);
}
// jobject jylist = (*env)->NewObject(env, JyListClass, JyListFromBackendHandleConstructor, (jlong) src);
// if ((*env)->ExceptionCheck(env)) {
// jputs("Exception happened converting list:");
// (*env)->ExceptionDescribe(env);
// }
return (*env)->CallStaticObjectMethod(env, pyListClass, pyList_fromList, jyList);
}
static void
tupledealloc(register PyTupleObject *op)
{
JyNIDebugOp(JY_NATIVE_FINALIZE, op, -1);
register Py_ssize_t i;
register Py_ssize_t len = Py_SIZE(op);
_JyNI_GC_UNTRACK(op);
Py_TRASHCAN_SAFE_BEGIN(op)
if (len > 0) {
i = len;
while (--i >= 0)
Py_XDECREF(op->ob_item[i]);
#if PyTuple_MAXSAVESIZE > 0
if (len < PyTuple_MAXSAVESIZE &&
numfree[len] < PyTuple_MAXFREELIST &&
Py_TYPE(op) == &PyTuple_Type)
{
JyNIDebugOp(JY_NATIVE_FREE | JY_INLINE_MASK, op, -1);
JyNI_CleanUp_JyObject(AS_JY_WITH_GC(op));
op->ob_item[0] = (PyObject *) free_list[len];
numfree[len]++;
free_list[len] = op;
// jputs("Release tuple to free_list");
// jputsLong(len);
// jputsLong((jlong) op);
goto done; /* return */
}
#endif
}
JyNI_CleanUp_JyObject(AS_JY_WITH_GC(op));
Py_TYPE(op)->tp_free((PyObject *)op);
done:
Py_TRASHCAN_SAFE_END(op)
}
static int
func_set_defaults(PyFunctionObject *op, PyObject *value)
{
PyObject *tmp;
if (restricted())
return -1;
/* Legal to del f.func_defaults.
* Can only set func_defaults to NULL or a tuple. */
if (value == Py_None)
value = NULL;
if (value != NULL && !PyTuple_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__defaults__ must be set to a tuple object");
return -1;
}
env(-1);
jobject jFunc = JyNI_JythonPyObject_FromPyObject(op);
jobject jDefaults = JyNI_JythonPyObject_FromPyObject(value);
(*env)->CallObjectMethod(env, jFunc, pyFunctionSetFuncDefaults, jDefaults);
if ((*env)->ExceptionCheck(env))
{
jputs("Exception in func_set_defaults");
(*env)->ExceptionClear(env);
return -1;
}
tmp = op->func_defaults;
Py_XINCREF(value);
op->func_defaults = value;
updateJyGCHeadLink(op, AS_JY_WITH_GC(op), func_defaults_gcindex,
value, AS_JY_WITH_GC(value));
Py_XDECREF(tmp);
return 0;
}
int
PyCell_Set(PyObject *op, PyObject *obj)
{
if (!PyCell_Check(op)) {
PyErr_BadInternalCall();
return -1;
} else {
PyObject* oldobj;
JyObject* jy;
oldobj = PyCell_GET(op);
Py_XINCREF(obj);
PyCell_SET(op, obj);
updateJyGCHeadLink(op, AS_JY_WITH_GC(op), 0,
obj, obj ? AS_JY(obj) : NULL);
Py_XDECREF(oldobj);
jy = AS_JY_WITH_GC(op);
if (JyObject_IS_INITIALIZED(jy))
{
env(-1);
(*env)->SetObjectField(env, jy->jy, pyCell_ob_refField,
JyNI_JythonPyObject_FromPyObject(obj));
}
return 0;
}
}
int
PyFunction_SetClosure(PyObject *op, PyObject *closure)
{
if (!PyFunction_Check(op)) {
PyErr_BadInternalCall();
return -1;
}
if (closure == Py_None)
closure = NULL;
else if (PyTuple_Check(closure)) {
Py_INCREF(closure);
}
else {
PyErr_Format(PyExc_SystemError,
"expected tuple for closure, got '%.100s'",
closure->ob_type->tp_name);
return -1;
}
Py_XDECREF(((PyFunctionObject *) op) -> func_closure);
((PyFunctionObject *) op) -> func_closure = closure;
updateJyGCHeadLink(op, AS_JY_WITH_GC(op), func_closure_gcindex,
closure, AS_JY_WITH_GC(closure));
env(-1);
jobject jOp = JyNI_JythonPyObject_FromPyObject(op);
jobject jClosure = JyNI_JythonPyObject_FromPyObject(closure);
(*env)->SetObjectField(env, jOp, pyFunctionFuncClosure, jClosure);
return 0;
}
int
PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
{
if (!PyFunction_Check(op)) {
PyErr_BadInternalCall();
return -1;
}
if (defaults == Py_None)
defaults = NULL;
else if (defaults && PyTuple_Check(defaults)) {
Py_INCREF(defaults);
}
else {
PyErr_SetString(PyExc_SystemError, "non-tuple default args");
return -1;
}
Py_XDECREF(((PyFunctionObject *) op) -> func_defaults);
((PyFunctionObject *) op) -> func_defaults = defaults;
updateJyGCHeadLink(op, AS_JY_WITH_GC(op), func_defaults_gcindex,
defaults, AS_JY_WITH_GC(defaults));
env(-1);
jobject jOp = JyNI_JythonPyObject_FromPyObject(op);
jobject jDefaults = JyNI_JythonPyObject_FromPyObject(defaults);
(*env)->CallVoidMethod(env, jOp, pyFunctionSetFuncDefaults, jDefaults);
return 0;
}
/*
* 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;
}
/*
* JyNI Warning: The returned pointer is only valid until the value
* in the dict is changed! (Should usually not happen.)
*/
char *
PyModule_GetFilename(PyObject *m)
{
if (!PyModule_Check(m)) {
PyErr_BadArgument();
return NULL;
}
//stringIntern
env(NULL);
//puts("bis hier...");
jobject pyStr = (*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject(m), pyObject__getattr__,
(*env)->CallObjectMethod(env, (*env)->NewStringUTF(env, "__file__"), stringIntern));
//puts("und noch etwas weiter");
if (pyStr == NULL)
{
puts("module filename missing");
//printf("PyExc_SystemError isException? %i\n", PyExceptionClass_Check2(PyExc_SystemError));
//printf("PyExc_SystemError isType? %i\n", PyType_Check(PyExc_SystemError));
//puts("hier nicht");
//todo: fix this later
//PyErr_SetString(PyExc_SystemError, "module filename missing");
//puts("und hier0?");
return NULL;
}
//puts("und hier?");
jstring er = (*env)->CallObjectMethod(env, pyStr, pyStringAsString);
global_cstr_from_jstring(cstr, er);
//puts("fast fertig...");
JyNI_AddOrSetJyAttributeWithFlags(AS_JY_WITH_GC(m), JyAttributeModuleFile, cstr, JY_ATTR_OWNS_VALUE_FLAG_MASK);
return cstr;
/*
PyObject *d;
PyObject *fileobj;
if (!PyModule_Check(m)) {
PyErr_BadArgument();
return NULL;
}
d = ((PyModuleObject *)m)->md_dict;
if (d == NULL ||
(fileobj = PyDict_GetItemString(d, "__file__")) == NULL ||
!PyString_Check(fileobj))
{
PyErr_SetString(PyExc_SystemError, "module filename missing");
return NULL;
}
return PyString_AsString(fileobj);
*/
}
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;
}
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;
}
jobject JySync_Init_JyCFunction_From_PyCFunction(PyObject* src, jclass subtype)
{
// jputs(__FUNCTION__);
if (JyNI_HasJyAttribute(AS_JY(src), JyAttributeMethodDef))
{
jputs("JyNI-warning: JySync_Init_JyCFunction_From_PyCFunction shouldn't be called with non-native PyCFunction.");
}
JyObject* srcJy = AS_JY_WITH_GC(src);
// Note that JyNI.PyCFunction implements CPeerInterface, so we must set the CPeer-flag:
srcJy->flags |= JY_CPEER_FLAG_MASK;
Py_INCREF(src);
//JyNI_GC_ExploreObject(src);
// jboolean dbg = strcmp(((PyCFunctionObject*) src)->m_ml->ml_name, "in_dll") == 0;
// jputs(Py_TYPE(src)->tp_name);
//if (_PyThreadState_Current) jputsPy(PyObject_GetAttrString(src, "__class__"));
PyCFunctionObject* func = (PyCFunctionObject*) src;
// jputs(func->m_ml->ml_name);
// jputsLong(func->m_self);
//putsPy(func->m_self);
// jputsLong(func->m_module);
env(NULL);
jstring name = (*env)->NewStringUTF(env, func->m_ml->ml_name);
jstring doc = (*env)->NewStringUTF(env, func->m_ml->ml_doc);
jobject jtype = JyNI_JythonPyObject_FromPyObject(Py_TYPE(src));
//JyNI_jprintJ(jtype); //builtinTypes[TME_INDEX_CFunction].jy_class
//jobject test = _JyNI_JythonPyTypeObject_FromPyTypeObject(Py_TYPE(src), NULL);
jobject result = (*env)->NewObject(env, pyCFunctionClass, pyCFunction_Constructor,
(jlong) src, jtype,
name, func->m_ml->ml_flags & METH_NOARGS, doc);
// if (dbg) {
// jputs(__FUNCTION__);
// jputs(((PyCFunctionObject*) src)->m_ml->ml_name);
// jputsPy(((PyCFunctionObject*) src)->m_self);
// jputsLong(((PyCFunctionObject*) src));
// jputsLong(((PyCFunctionObject*) src)->m_ml);
// jputsLong(((PyCFunctionObject*) src)->m_self);
// jPrintCStackTrace();
// }
// jputs("result:");
// JyNI_jprintJ(result);
// if ((*env)->IsSameObject(env, result, NULL)) jputs("result is null");
// JyNI_printJInfo(result);
// JyNI_jprintHash(result);
return result;
}
static int
func_set_code(PyFunctionObject *op, PyObject *value)
{
PyObject *tmp;
Py_ssize_t nfree, nclosure;
if (restricted())
return -1;
/* Not legal to del f.func_code or to set it to anything
* other than a code object. */
if (value == NULL || !PyCode_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__code__ must be set to a code object");
return -1;
}
nfree = PyCode_GetNumFree((PyCodeObject *)value);
nclosure = (op->func_closure == NULL ? 0 :
PyTuple_GET_SIZE(op->func_closure));
if (nclosure != nfree) {
PyErr_Format(PyExc_ValueError,
"%s() requires a code object with %zd free vars,"
" not %zd",
PyString_AsString(op->func_name),
nclosure, nfree);
return -1;
}
env(-1);
jobject jFunc = JyNI_JythonPyObject_FromPyObject(op);
jobject jCode = JyNI_JythonPyObject_FromPyObject(value);
(*env)->CallObjectMethod(env, jFunc, pyFunctionSetCode, jCode);
if ((*env)->ExceptionCheck(env))
{
jputs("Exception in func_set_code");
(*env)->ExceptionClear(env);
return -1;
}
tmp = op->func_code;
Py_INCREF(value);
op->func_code = value;
updateJyGCHeadLink(op, AS_JY_WITH_GC(op), func_code_gcindex,
value, AS_JY_NO_GC(value));
Py_DECREF(tmp);
return 0;
}
/*
* JyNI Warning: The returned pointer is only valid until the value
* in the dict is changed! (Should usually not happen.)
*/
char *
PyModule_GetName(PyObject *m)
{
if (!PyModule_Check(m)) {
PyErr_BadArgument();
return NULL;
}
//stringIntern
env(NULL);
jobject pyStr = (*env)->CallObjectMethod(env, JyNI_JythonPyObject_FromPyObject(m), pyObject__getattr__,
(*env)->CallObjectMethod(env, (*env)->NewStringUTF(env, "__name__"), stringIntern));
if (pyStr == NULL)
{
PyErr_SetString(PyExc_SystemError, "nameless module");
return NULL;
}
jstring er = (*env)->CallObjectMethod(env, pyStr, pyStringAsString);
global_cstr_from_jstring(cstr, er);
JyNI_AddOrSetJyAttributeWithFlags(AS_JY_WITH_GC(m), JyAttributeModuleName, cstr, JY_ATTR_OWNS_VALUE_FLAG_MASK);
return cstr;
/*
PyObject *d;
PyObject *nameobj;
if (!PyModule_Check(m)) {
PyErr_BadArgument();
return NULL;
}
d = ((PyModuleObject *)m)->md_dict;
if (d == NULL ||
(nameobj = PyDict_GetItemString(d, "__name__")) == NULL ||
!PyString_Check(nameobj))
{
PyErr_SetString(PyExc_SystemError, "nameless module");
return NULL;
}
return PyString_AsString(nameobj);*/
}
/*
* 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;
}
void JySync_PyType_From_JyType(jobject src, PyObject* dest)
{
// jputs(__FUNCTION__);
// JyNI_jprintJ(src);
PyTypeObject* tp = (PyTypeObject*) dest;
env();
//name:
jobject jtmp = (*env)->CallObjectMethod(env, src, pyType_getName);
//jobject jtmp = (*env)->GetObjectField(env, src, pyTypeNameField);
//if (!jtmp) jputs("JySync_PyType_From_JyType: type with NULL-name!");
//cstr_from_jstring(cname, jname);
char* utf_string = (*env)->GetStringUTFChars(env, jtmp, NULL);
char* cname = malloc(strlen(utf_string)+1);
strcpy(cname, utf_string);
(*env)->ReleaseStringUTFChars(env, jtmp, utf_string);
// jboolean dbg = strcmp(cname, "Class") == 0;
// if (dbg) {
// jputs(__FUNCTION__);
// jputs(cname);
// jputsLong(dest);
// jPrintCStackTrace();
// }
JyNI_AddOrSetJyAttributeWithFlags(AS_JY(dest), JyAttributeTypeName, cname, JY_ATTR_OWNS_VALUE_FLAG_MASK);
tp->tp_name = cname;
//SyncFunctions* sync = (SyncFunctions*) JyNI_GetJyAttribute(AS_JY_WITH_GC(dest), JyAttributeSyncFunctions);
//dict:
jtmp = (*env)->CallObjectMethod(env, src, pyObject_fastGetDict);
tp->tp_dict = JyNI_PyObject_FromJythonPyObject(jtmp);
//base:
jtmp = (*env)->CallObjectMethod(env, src, pyType_getBase);
tp->tp_base = (PyTypeObject*) JyNI_PyObject_FromJythonPyObject(jtmp);
// Note that basicsize must be set before bases, because some bases access basicsize
// during convertion to native objects.
//basicsize:
tp->tp_basicsize = tp->tp_base == Py_None ? sizeof(PyObject) : tp->tp_base->tp_basicsize;
//bases:
jtmp = (*env)->CallObjectMethod(env, src, pyType_getBases);
tp->tp_bases = JyNI_PyObject_FromJythonPyObject(jtmp);
//We try to get away with just setting this to default for now:
tp->tp_flags |= Py_TPFLAGS_DEFAULT;
// jputsLong(tp->tp_flags);// & Py_TPFLAGS_HAVE_CLASS);
//jputsLong(tp->tp_mro);
//if (!tp->tp_alloc)
if (!(tp->tp_flags & Py_TPFLAGS_READY))
{
if (tp->tp_base == Py_None)
tp->tp_base = NULL;
PyType_Ready(tp);
//tp->tp_flags = (tp->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY;
// JyNI_GC_ExploreObject(tp);
} //else puts("already ready");
// jputs("sync mro...");
// jputsLong(tp);
//mro:
if (!tp->tp_mro)
{
jtmp = (*env)->CallObjectMethod(env, src, pyType_getMro);
PyObject* mro = JySync_Init_PyTuple_From_JyTupleForMRO(jtmp);
PyTuple_SET_ITEM(mro, 0, tp);
tp->tp_mro = mro;
// Currently tp_traverse is out-commented.
// Once we tested and stabilized heap-type exploration
// the following section must be included here, because
// we changed mro after initial exploration in PyType_Ready.
/* tp_traverse visits type members in this order:
* Py_VISIT(type->tp_dict);
* Py_VISIT(type->tp_cache);
* Py_VISIT(type->tp_mro);
* Py_VISIT(type->tp_bases);
* Py_VISIT(type->tp_base);
* so mro-index is 2.
*/
if (!IS_UNEXPLORED(tp))
updateJyGCHeadLink(tp, AS_JY_WITH_GC(tp), 2 /* mro-index */,
tp->tp_mro, AS_JY_WITH_GC(tp->tp_mro));
}
// jputs("type-sync done");
}
PyObject *
PyTuple_New(register Py_ssize_t size)
{
register PyTupleObject *op;
Py_ssize_t i;
if (size < 0) {
PyErr_BadInternalCall();
return NULL;
}
#if PyTuple_MAXSAVESIZE > 0
if (size == 0 && free_list[0]) {
//jputs("EmptyTuple!");
//jputsLong(free_list[0]);
op = free_list[0];
Py_INCREF(op);
#ifdef COUNT_ALLOCS
tuple_zero_allocs++;
#endif
return (PyObject *) op;
}
if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
free_list[size] = (PyTupleObject *) op->ob_item[0];
numfree[size]--;
#ifdef COUNT_ALLOCS
fast_tuple_allocs++;
#endif
/* Inline PyObject_InitVar */
#ifdef Py_TRACE_REFS
Py_SIZE(op) = size;
Py_TYPE(op) = &PyTuple_Type;
#endif
_PyObject_GC_InitJy(op, &(builtinTypes[TME_INDEX_Tuple]));
_Py_NewReference((PyObject *)op);
// jputs(__FUNCTION__);
// jputsLong(__LINE__);
// jputsLong(size);
// jputsLong((jlong) op);
//jputsLong(Py_TYPE(op));
//jputsLong(&PyTuple_Type);
JyNIDebug(JY_NATIVE_ALLOC_GC | JY_INLINE_MASK, op, AS_JY_WITH_GC(op), size, PyTuple_Type.tp_name);
}
else
#endif
{
Py_ssize_t nbytes = size * sizeof(PyObject *);
/* Check for overflow */
if (nbytes / sizeof(PyObject *) != (size_t)size ||
(nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *)))
{
return PyErr_NoMemory();
}
op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
if (op == NULL)
return NULL;
}
for (i=0; i < size; i++)
op->ob_item[i] = NULL;
#if PyTuple_MAXSAVESIZE > 0
if (size == 0) {
free_list[0] = op;
++numfree[0];
JyNIDebug(JY_NATIVE_INCREF | JY_IMMORTAL_MASK | JY_PRE_MASK,
op, AS_JY_WITH_GC(op), size, PyTuple_Type.tp_name);
Py_INCREF(op); /* extra INCREF so that this is never freed */
}
#endif
#ifdef SHOW_TRACK_COUNT
count_tracked++;
#endif
//_JyNI_GC_TRACK_NoExplore(op);
_JyNI_GC_TRACK(op);
return (PyObject *) op;
}
