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 jsig(void){
tostdout=1; suspend=1;
if(debugb&&!spc()){
dhead(); jputs("ws full (can not debug suspend)"); jputc(CNL);
debugb=0;
}
dhead(); jputs(AV(*(jerr+AAV(qevm)))); jputc(CNL);
}
/*
* 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;
}
static void dwrq(A w){
if(all1(match(alp,w)))jputs(nflag?" a.":"a.");
else{C q=CQUOTE;
jputc(q);
if(w){C*p=CAV(w); DO(AN(w), if(q==p[i])jputc(q); jputc(p[i]));}
jputc(q);
}}
/* 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;
}
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;
}
static int
func_set_name(PyFunctionObject *op, PyObject *value)
{
// PyObject *tmp;
//
// if (restricted())
// return -1;
/* Not legal to del f.func_name or to set it to anything
* other than a string object. */
if (value == NULL || !PyString_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"__name__ must be set to a string object");
return -1;
}
env(-1);
jobject jFunc = JyNI_JythonPyObject_FromPyObject(op);
jobject jName = JyNI_JythonPyObject_FromPyObject(value);
(*env)->CallObjectMethod(env, jFunc, pyFunctionSetCode, jName);
if ((*env)->ExceptionCheck(env))
{
jputs("Exception in func_set_name");
(*env)->ExceptionClear(env);
return -1;
}
// tmp = op->func_name;
// Py_INCREF(value);
// op->func_name = value;
// Py_DECREF(tmp);
return 0;
}
static int
func_set_dict(PyFunctionObject *op, PyObject *value)
{
// PyObject *tmp;
//
// if (restricted())
// return -1;
/* It is illegal to del f.func_dict */
if (value == NULL) {
PyErr_SetString(PyExc_TypeError,
"function's dictionary may not be deleted");
return -1;
}
/* Can only set func_dict to a dictionary */
if (!PyDict_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"setting function's dictionary to a non-dict");
return -1;
}
env(-1);
jobject jFunc = JyNI_JythonPyObject_FromPyObject(op);
jobject jDict = JyNI_JythonPyObject_FromPyObject(value);
(*env)->CallObjectMethod(env, jFunc, pyObjectSetDict, jDict);
if ((*env)->ExceptionCheck(env))
{
jputs("Exception in func_set_dict");
(*env)->ExceptionClear(env);
return -1;
}
// tmp = op->func_dict;
// Py_INCREF(value);
// op->func_dict = value;
// Py_XDECREF(tmp);
return 0;
}
static PyObject* jyBuiltinCallWithKeywords(PyObject* self, PyObject* args, PyObject* kw)
{
//jputs(__FUNCTION__);
jputs("JyNI-warning: Native caller ignored Jython-flag.");
// jobject jself = self ? JyNI_JythonPyObject_FromPyObject(self) : JyNone;
jobject jself = JyNI_JythonPyObject_FromPyObject(self);
return JyNI_PyObject_Call(jself, args, kw);
}
static DCF(seeparse){A*s;I m,n,*sp;
n=si->ln; /* # of tokens in token array */
m=si->n;
s=DSZX+(A*)si;
sp=n+(I*)s; /* address i.#tokens to track location for error */
m=*(sp+m);
nflag=0; DO(n, if(i==m)jputs(" "); disp(s[i]));
} /* display error line */
/*static*/ void disp(A w){C err;I t;
t=AT(w);
switch(t){
case BOOL:
case INT:
case FL:
case CMPX:
if(nflag)jputc(' ');
err=jerr; jerr=0; w=thorn1(w); jerr=err;
if(w)dwr(w); else jputs(" (ws full in numeric display) ");
break;
case NAME: dname(w); break;
case CHAR: dwrq(w); break;
case LPAR: jputc('('); break;
case RPAR: jputc(')'); break;
case ASGN: jputs(*AV(w)?"=.":"=:"); break;
case MARK: break;
default: dspell(VAV(w)->id);
}
nflag=t&NAME+NUMERIC?1:0;
}
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;
}
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;
}
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;
}
static DCF(seedebug){A t=*(si->ln+AAV(qevm)); jputs(AV(t));}
static void dspell(C id){C c,s[3];
s[2]=0;
spellit(id,s);
c=s[0]; if(c==CESC1||c==CESC2||nflag&&CA==ctype[c])jputc(' ');
jputs(s);
}
static void dname(A w){C c=*CAV(w);
if(nflag)jputc(' ');
if(c==CALPHA)jputs("x");
else if(c==COMEGA)jputs("y");
else dwr(w);
}
PyObject *
PyErr_NewException(char *name, PyObject *base, PyObject *dict)
{
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 = PyString_FromStringAndSize(name,
(Py_ssize_t)(dot-name));
if (modulename == NULL)
goto failure;
if (PyDict_SetItemString(dict, "__module__", modulename) != 0)
goto failure;
}
//JyNI note: if ob_type is NULL, we assume that base is a Type object that was
//not initialized because of our use-on-demand philosophy regarding PyType_Ready.
if (base->ob_type == NULL)// && PyType_Check(base))
PyType_Ready((PyTypeObject*) base);
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;
}
//puts("enter JNI part of exception creation...");
/* Create a real new-style class. */
//TODO clean this up. There should be a method to create objects like is done below.
env(NULL);
jobject jbases = (*env)->NewObjectArray(env,
PyTuple_GET_SIZE(bases),
pyObjectClass, NULL);
if ((*env)->ExceptionCheck(env))
{
jputs("Exception on creating jbases call:");
jobject exc = (*env)->ExceptionOccurred(env);
JyNI_jprintJ(exc);
(*env)->ExceptionClear(env);
}
int i;
for (i = 0; i < PyTuple_GET_SIZE(bases); ++i)
(*env)->SetObjectArrayElement(env, jbases, i, JyNI_JythonPyObject_FromPyObject(PyTuple_GET_ITEM(bases, i)));
if ((*env)->ExceptionCheck(env))
{
jputs("Exception on storing in jbases call:");
jobject exc = (*env)->ExceptionOccurred(env);
JyNI_jprintJ(exc);
(*env)->ExceptionClear(env);
}
// jputs("PyErrNewException:");
// if (name) jputs(name);
// else jputs("name is NULL");
jobject jres = (*env)->CallStaticObjectMethod(env, pyPyClass, pyPyMakeClass,
(*env)->NewStringUTF(env, name), jbases, JyNI_JythonPyObject_FromPyObject(dict));
if ((*env)->ExceptionCheck(env))
{
jputs("Exception on makeClass call:");
jobject exc = (*env)->ExceptionOccurred(env);
JyNI_jprintJ(exc);
(*env)->ExceptionClear(env);
}
//result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO", dot+1, bases, dict);
result = JyNI_PyObject_FromJythonPyObject(jres);
// jputs("control name");
// jputs(((PyTypeObject*) result)->tp_name);
failure:
Py_XDECREF(bases);
Py_XDECREF(mydict);
Py_XDECREF(classname);
Py_XDECREF(modulename);
// if (result == NULL) puts("exception result is NULL");
// else puts("exception result is not NULL");
return result;
}
static void dheadp(void){dhead(); jputs(" ");}
jobject _PyImport_LoadDynamicModuleJy(char *name, char *pathname, FILE *fp)
{
//PyObject *m;
jobject m;
char *lastdot, *shortname, *packagecontext, *oldcontext;
dl_funcptr p;
//The following case is covered on java-side now:
/*if ((m = _PyImport_FindExtension(name, pathname)) != NULL) {
Py_INCREF(m);
return m;
}*/
lastdot = strrchr(name, '.');
if (lastdot == NULL) {
packagecontext = NULL;
shortname = name;
}
else {
packagecontext = name;
shortname = lastdot+1;
}
//PyErr_Clear(); //added temporarily by JyNI to focus on further development until the exception thing is solved.
p = _PyImport_GetDynLoadFunc(name, shortname, pathname, fp);
//jputs("got dyn load func");
if (PyErr_Occurred())
{
jputs("PyErrOccured00");
return NULL;
}
//jputs("error check done");
if (p == NULL) {
//jputs("no init function");
//JyNI_JyErr_Format((*env)->GetStaticObjectField(env, pyPyClass, pyPyImportError),
PyErr_Format(PyExc_ImportError,
"dynamic module does not define init function (init%.200s)",
shortname);
return NULL;
}
//jputs("dyn load func is not NULL");
oldcontext = _Py_PackageContext;
_Py_PackageContext = packagecontext;
//jputs("run dyn load func...");
(*p)();
//jputs("run dyn load func done");
_Py_PackageContext = oldcontext;
if (PyErr_Occurred())
{
//puts("return NULL because PyErr_Occurred");
return NULL;
}
//m = PyDict_GetItemString(PyImport_GetModuleDict(), name);
//jputs("retrieving module...");
//jputs(name);
//the following somehow goes wrong, probaby because we didn't call String.intern...
/*jobject mName = (*env)->CallStaticObjectMethod(env, pyPyClass, pyPyNewString, (*env)->NewStringUTF(env, name));
m = (*env)->CallObjectMethod(env,
(*env)->CallStaticObjectMethod(env, JyNIClass, JyNIPyImport_GetModuleDict),
pyDictGet_PyObject,
mName
);*/
env(NULL);
m = (*env)->CallStaticObjectMethod(env, JyNIClass, JyNIJyNI_GetModule, (*env)->NewStringUTF(env, name));
//puts("retrieved module");
if (m == NULL) {
//puts("m = NULL");
PyErr_SetString(PyExc_SystemError,
"dynamic module not initialized properly");
return NULL;
}
//puts("name:");
//puts(PyModule_GetName(JyNI_PyObject_FromJythonPyObject(m)));
// Remember the filename as the __file__ attribute
//if (PyModule_AddStringConstant(m, "__file__", pathname) < 0)
//puts("adding filename...");
if (PyModule_AddStringConstantJy(m, "__file__", pathname) < 0)
PyErr_Clear(); // Not important enough to report
//puts("filename added:");
//puts(PyModule_GetFilename(JyNI_PyObject_FromJythonPyObject(m)));
//provide FixupExtension later...
//if (_PyImport_FixupExtension(name, pathname) == NULL)
// return NULL;
//if (Py_VerboseFlag)
if ((*env)->CallStaticIntMethod(env, JyNIClass, JyNIGetDLVerbose))
PySys_WriteStderr(
"import %s # dynamically loaded from %s\n",
name, pathname);
//Py_INCREF(m);
//jputs("module loaded:");
//jputs(name);
//jputsLong(m);
return m;
}
static int
vgetargs1(PyObject *args, const char *format, va_list *p_va, int flags)
{
//puts("vgetargs1");
//puts(format);
char msgbuf[256];
int levels[32];
const char *fname = NULL;
const char *message = NULL;
int min = -1;
int max = 0;
int level = 0;
int endfmt = 0;
const char *formatsave = format;
Py_ssize_t i, len;
char *msg;
PyObject *freelist = NULL;
int compat = flags & FLAG_COMPAT;
if (args == (PyObject*)NULL) jputs("vgetargs1 call with NULL-args");
assert(compat || (args != (PyObject*)NULL));
flags = flags & ~FLAG_COMPAT;
while (endfmt == 0) {
int c = *format++;
//printf("process char: %c\n", c);
switch (c) {
case '(':
if (level == 0)
max++;
level++;
if (level >= 30)
Py_FatalError("too many tuple nesting levels "
"in argument format string");
break;
case ')':
if (level == 0)
Py_FatalError("excess ')' in getargs format");
else
level--;
break;
case '\0':
endfmt = 1;
break;
case ':':
fname = format;
//puts("fname:");
//puts(fname);
endfmt = 1;
break;
case ';':
message = format;
endfmt = 1;
break;
default:
if (level == 0) {
if (c == 'O')
max++;
else if (isalpha(Py_CHARMASK(c))) {
if (c != 'e') /* skip encoded */
max++;
} else if (c == '|')
min = max;
}
break;
}
}
//puts("format processed");
if (level != 0)
Py_FatalError(/* '(' */ "missing ')' in getargs format");
//puts("a");
if (min < 0)
min = max;
format = formatsave;
if (compat) {
//puts("compat");
if (max == 0) {
if (args == NULL)
return 1;
PyOS_snprintf(msgbuf, sizeof(msgbuf),
"%.200s%s takes no arguments",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()");
PyErr_SetString(PyExc_TypeError, msgbuf);
return 0;
}
else if (min == 1 && max == 1) {
if (args == NULL) {
PyOS_snprintf(msgbuf, sizeof(msgbuf),
"%.200s%s takes at least one argument",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()");
PyErr_SetString(PyExc_TypeError, msgbuf);
return 0;
}
msg = convertitem(args, &format, p_va, flags, levels,
msgbuf, sizeof(msgbuf), &freelist);
if (msg == NULL)
return cleanreturn(1, freelist);
seterror(levels[0], msg, levels+1, fname, message);
return cleanreturn(0, freelist);
}
else {
PyErr_SetString(PyExc_SystemError,
"old style getargs format uses new features");
return 0;
}
}
//puts("compat done");
if (!PyTuple_Check(args)) {
PyErr_SetString(PyExc_SystemError,
"new style getargs format but argument is not a tuple");
return 0;
}
len = PyTuple_GET_SIZE(args);
if (len < min || max < len) {
if (message == NULL) {
PyOS_snprintf(msgbuf, sizeof(msgbuf),
"%.150s%s takes %s %d argument%s "
"(%ld given)",
fname==NULL ? "function" : fname,
fname==NULL ? "" : "()",
min==max ? "exactly"
: len < min ? "at least" : "at most",
len < min ? min : max,
(len < min ? min : max) == 1 ? "" : "s",
Py_SAFE_DOWNCAST(len, Py_ssize_t, long));
message = msgbuf;
}
PyErr_SetString(PyExc_TypeError, message);
return 0;
}
