/* Built-in functions */

#include "Python.h"

#include "node.h"

#include "compile.h"

#include "eval.h"

#include <ctype.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

/* Forward */

static PyObject *filterstring(PyObject *, PyObject *);

static PyObject *filtertuple (PyObject *, PyObject *);

static PyObject *

builtin___import__(PyObject *self, PyObject *args)

{

char *name;

PyObject *globals = NULL;

PyObject *locals = NULL;

PyObject *fromlist = NULL;

if (!PyArg_ParseTuple(args, "s|OOO:__import__",

&name, &globals, &locals, &fromlist))

return NULL;

return PyImport_ImportModuleEx(name, globals, locals, fromlist);

}

static char import_doc[] =

"__import__(name, globals, locals, fromlist) -> module\n\

\n\

Import a module. The globals are only used to determine the context;\n\

they are not modified. The locals are currently unused. The fromlist\n\

should be a list of names to emulate ``from name import ...'', or an\n\

empty list to emulate ``import name''.\n\

When importing a module from a package, note that __import__('A.B', ...)\n\

returns package A when fromlist is empty, but its submodule B when\n\

fromlist is not empty.";

static PyObject *

builtin_abs(PyObject *self, PyObject *args)

{

PyObject *v;

if (!PyArg_ParseTuple(args, "O:abs", &v))

return NULL;

return PyNumber_Absolute(v);

}

static char abs_doc[] =

"abs(number) -> number\n\

\n\

Return the absolute value of the argument.";

static PyObject *

builtin_apply(PyObject *self, PyObject *args)

{

PyObject *func, *alist = NULL, *kwdict = NULL;

PyObject *t = NULL, *retval = NULL;

if (!PyArg_ParseTuple(args, "O|OO:apply", &func, &alist, &kwdict))

return NULL;

if (alist != NULL) {

if (!PyTuple_Check(alist)) {

if (!PySequence_Check(alist)) {

PyErr_SetString(PyExc_TypeError,

"apply() 2nd argument must be a sequence");

return NULL;

}

t = PySequence_Tuple(alist);

if (t == NULL)

return NULL;

alist = t;

}

}

if (kwdict != NULL && !PyDict_Check(kwdict)) {

PyErr_SetString(PyExc_TypeError,

"apply() 3rd argument must be dictionary");

goto finally;

}

retval = PyEval_CallObjectWithKeywords(func, alist, kwdict);

finally:

Py_XDECREF(t);

return retval;

}

static char apply_doc[] =

"apply(object, args[, kwargs]) -> value\n\

\n\

Call a callable object with positional arguments taken from the tuple args,\n\

and keyword arguments taken from the optional dictionary kwargs.\n\

Note that classes are callable, as are instances with a __call__() method.";

static PyObject *

builtin_buffer(PyObject *self, PyObject *args)

{

PyObject *ob;

int offset = 0;

int size = Py_END_OF_BUFFER;

if ( !PyArg_ParseTuple(args, "O|ii:buffer", &ob, &offset, &size) )

return NULL;

return PyBuffer_FromObject(ob, offset, size);

}

static char buffer_doc[] =

"buffer(object [, offset[, size]]) -> object\n\

\n\

Creates a new buffer object which references the given object.\n\

The buffer will reference a slice of the target object from the\n\

start of the object (or at the specified offset). The slice will\n\

extend to the end of the target object (or with the specified size).";

static PyObject *

builtin_unicode(PyObject *self, PyObject *args)

{

PyObject *v;

char *encoding = NULL;

char *errors = NULL;

if ( !PyArg_ParseTuple(args, "O|ss:unicode", &v, &encoding, &errors) )

return NULL;

return PyUnicode_FromEncodedObject(v, encoding, errors);

}

static char unicode_doc[] =

"unicode(string [, encoding[, errors]]) -> object\n\

\n\

Creates a new Unicode object from the given encoded string.\n\

encoding defaults to the current default string encoding and \n\

errors, defining the error handling, to 'strict'.";

static PyObject *

builtin_callable(PyObject *self, PyObject *args)

{

PyObject *v;

if (!PyArg_ParseTuple(args, "O:callable", &v))

return NULL;

return PyInt_FromLong((long)PyCallable_Check(v));

}

static char callable_doc[] =

"callable(object) -> Boolean\n\

\n\

Return whether the object is callable (i.e., some kind of function).\n\

Note that classes are callable, as are instances with a __call__() method.";

static PyObject *

builtin_filter(PyObject *self, PyObject *args)

{

PyObject *func, *seq, *result;

PySequenceMethods *sqf;

int len;

register int i, j;

if (!PyArg_ParseTuple(args, "OO:filter", &func, &seq))

return NULL;

if (PyString_Check(seq)) {

PyObject *r = filterstring(func, seq);

return r;

}

if (PyTuple_Check(seq)) {

PyObject *r = filtertuple(func, seq);

return r;

}

sqf = seq->ob_type->tp_as_sequence;

if (sqf == NULL || sqf->sq_length == NULL || sqf->sq_item == NULL) {

PyErr_SetString(PyExc_TypeError,

"argument 2 to filter() must be a sequence type");

goto Fail_2;

}

if ((len = (*sqf->sq_length)(seq)) < 0)

goto Fail_2;

if (PyList_Check(seq) && seq->ob_refcnt == 1) {

Py_INCREF(seq);

result = seq;

}

else {

if ((result = PyList_New(len)) == NULL)

goto Fail_2;

}

for (i = j = 0; ; ++i) {

PyObject *item, *good;

int ok;

if ((item = (*sqf->sq_item)(seq, i)) == NULL) {

if (PyErr_ExceptionMatches(PyExc_IndexError)) {

PyErr_Clear();

break;

}

goto Fail_1;

}

if (func == Py_None) {

good = item;

Py_INCREF(good);

}

else {

PyObject *arg = Py_BuildValue("(O)", item);

if (arg == NULL)

goto Fail_1;

good = PyEval_CallObject(func, arg);

Py_DECREF(arg);

if (good == NULL) {

Py_DECREF(item);

goto Fail_1;

}

}

ok = PyObject_IsTrue(good);

Py_DECREF(good);

if (ok) {

if (j < len) {

if (PyList_SetItem(result, j++, item) < 0)

goto Fail_1;

}

else {

int status = PyList_Append(result, item);

j++;

Py_DECREF(item);

if (status < 0)

goto Fail_1;

}

} else {

Py_DECREF(item);

}

}

if (j < len && PyList_SetSlice(result, j, len, NULL) < 0)

goto Fail_1;

return result;

Fail_1:

Py_DECREF(result);

Fail_2:

return NULL;

}

static char filter_doc[] =

"filter(function, sequence) -> list\n\

\n\

Return a list containing those items of sequence for which function(item)\n\

is true. If function is None, return a list of items that are true.";

static PyObject *

builtin_chr(PyObject *self, PyObject *args)

{

long x;

char s[1];

if (!PyArg_ParseTuple(args, "l:chr", &x))

return NULL;

if (x < 0 || x >= 256) {

PyErr_SetString(PyExc_ValueError,

"chr() arg not in range(256)");

return NULL;

}

s[0] = (char)x;

return PyString_FromStringAndSize(s, 1);

}

static char chr_doc[] =

"chr(i) -> character\n\

\n\

Return a string of one character with ordinal i; 0 <= i < 256.";

static PyObject *

builtin_unichr(PyObject *self, PyObject *args)

{

long x;

Py_UNICODE s[1];

if (!PyArg_ParseTuple(args, "l:unichr", &x))

return NULL;

if (x < 0 || x >= 65536) {

PyErr_SetString(PyExc_ValueError,

"unichr() arg not in range(65536)");

return NULL;

}

s[0] = (Py_UNICODE)x;

return PyUnicode_FromUnicode(s, 1);

}

static char unichr_doc[] =

"unichr(i) -> Unicode character\n\

\n\

Return a Unicode string of one character with ordinal i; 0 <= i < 65536.";

static PyObject *

builtin_cmp(PyObject *self, PyObject *args)

{

PyObject *a, *b;

int c;

if (!PyArg_ParseTuple(args, "OO:cmp", &a, &b))

return NULL;

if (PyObject_Cmp(a, b, &c) < 0)

return NULL;

return PyInt_FromLong((long)c);

}

static char cmp_doc[] =

"cmp(x, y) -> integer\n\

\n\

Return negative if x<y, zero if x==y, positive if x>y.";

static PyObject *

builtin_coerce(PyObject *self, PyObject *args)

{

PyObject *v, *w;

PyObject *res;

if (!PyArg_ParseTuple(args, "OO:coerce", &v, &w))

return NULL;

if (PyNumber_Coerce(&v, &w) < 0)

return NULL;

res = Py_BuildValue("(OO)", v, w);

Py_DECREF(v);

Py_DECREF(w);

return res;

}

static char coerce_doc[] =

"coerce(x, y) -> None or (x1, y1)\n\

\n\

When x and y can be coerced to values of the same type, return a tuple\n\

containing the coerced values. When they can't be coerced, return None.";

static PyObject *

builtin_compile(PyObject *self, PyObject *args)

{

char *str;

char *filename;

char *startstr;

int start;

if (!PyArg_ParseTuple(args, "sss:compile", &str, &filename, &startstr))

return NULL;

if (strcmp(startstr, "exec") == 0)

start = Py_file_input;

else if (strcmp(startstr, "eval") == 0)

start = Py_eval_input;

else if (strcmp(startstr, "single") == 0)

start = Py_single_input;

else {

PyErr_SetString(PyExc_ValueError,

"compile() mode must be 'exec' or 'eval' or 'single'");

return NULL;

}

return Py_CompileString(str, filename, start);

}

static char compile_doc[] =

"compile(source, filename, mode) -> code object\n\

\n\

Compile the source string (a Python module, statement or expression)\n\

into a code object that can be executed by the exec statement or eval().\n\

The filename will be used for run-time error messages.\n\

The mode must be 'exec' to compile a module, 'single' to compile a\n\

single (interactive) statement, or 'eval' to compile an expression.";

#ifndef WITHOUT_COMPLEX

static PyObject *

complex_from_string(PyObject *v)

{

extern double strtod(const char *, char **);

const char *s, *start;

char *end;

double x=0.0, y=0.0, z;

int got_re=0, got_im=0, done=0;

int digit_or_dot;

int sw_error=0;

int sign;

char buffer[256]; /* For errors */

char s_buffer[256];

int len;

if (PyString_Check(v)) {

s = PyString_AS_STRING(v);

len = PyString_GET_SIZE(v);

}

else if (PyUnicode_Check(v)) {

if (PyUnicode_GET_SIZE(v) >= sizeof(s_buffer)) {

PyErr_SetString(PyExc_ValueError,

"complex() literal too large to convert");

return NULL;

}

if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),

PyUnicode_GET_SIZE(v),

s_buffer,

NULL))

return NULL;

s = s_buffer;

len = (int)strlen(s);

}

else if (PyObject_AsCharBuffer(v, &s, &len)) {

PyErr_SetString(PyExc_TypeError,

"complex() needs a string first argument");

return NULL;

}

/* position on first nonblank */

start = s;

while (*s && isspace(Py_CHARMASK(*s)))

s++;

if (s[0] == '\0') {

PyErr_SetString(PyExc_ValueError,

"empty string for complex()");

return NULL;

}

z = -1.0;

sign = 1;

do {

switch (*s) {

case '\0':

if (s-start != len) {

PyErr_SetString(

PyExc_ValueError,

"null byte in argument for complex()");

return NULL;

}

if(!done) sw_error=1;

break;

case '-':

sign = -1;

/* Fallthrough */

case '+':

if (done) sw_error=1;

s++;

if ( *s=='\0'||*s=='+'||*s=='-' ||

isspace(Py_CHARMASK(*s)) ) sw_error=1;

break;

case 'J':

case 'j':

if (got_im || done) {

sw_error = 1;

break;

}

if (z<0.0) {

y=sign;

}

else{

y=sign*z;

}

got_im=1;

s++;

if (*s!='+' && *s!='-' )

done=1;

break;

default:

if (isspace(Py_CHARMASK(*s))) {

while (*s && isspace(Py_CHARMASK(*s)))

s++;

if (s[0] != '\0')

sw_error=1;

else

done = 1;

break;

}

digit_or_dot =

(*s=='.' || isdigit(Py_CHARMASK(*s)));

if (done||!digit_or_dot) {

sw_error=1;

break;

}

errno = 0;

PyFPE_START_PROTECT("strtod", return 0)

z = strtod(s, &end) ;

PyFPE_END_PROTECT(z)

if (errno != 0) {

sprintf(buffer,

"float() out of range: %.150s", s);

PyErr_SetString(

PyExc_ValueError,

buffer);

return NULL;

}

s=end;

if (*s=='J' || *s=='j') {

break;

}

if (got_re) {

sw_error=1;

break;

}

/* accept a real part */

x=sign*z;

got_re=1;

if (got_im) done=1;

z = -1.0;

sign = 1;

break;

} /* end of switch */

} while (*s!='\0' && !sw_error);

if (sw_error) {

PyErr_SetString(PyExc_ValueError,

"malformed string for complex()");

return NULL;

}

return PyComplex_FromDoubles(x,y);

}

static PyObject *

builtin_complex(PyObject *self, PyObject *args)

{

PyObject *r, *i, *tmp;

PyNumberMethods *nbr, *nbi = NULL;

Py_complex cr, ci;

int own_r = 0;

i = NULL;

if (!PyArg_ParseTuple(args, "O|O:complex", &r, &i))

return NULL;

if (PyString_Check(r) || PyUnicode_Check(r))

return complex_from_string(r);

if ((nbr = r->ob_type->tp_as_number) == NULL ||

nbr->nb_float == NULL ||

(i != NULL &&

((nbi = i->ob_type->tp_as_number) == NULL ||

nbi->nb_float == NULL))) {

PyErr_SetString(PyExc_TypeError,

"complex() argument can't be converted to complex");

return NULL;

}

/* XXX Hack to support classes with __complex__ method */

if (PyInstance_Check(r)) {

static PyObject *complexstr;

PyObject *f;

if (complexstr == NULL) {

complexstr = PyString_InternFromString("__complex__");

if (complexstr == NULL)

return NULL;

}

f = PyObject_GetAttr(r, complexstr);

if (f == NULL)

PyErr_Clear();

else {

PyObject *args = Py_BuildValue("()");

if (args == NULL)

return NULL;

r = PyEval_CallObject(f, args);

Py_DECREF(args);

Py_DECREF(f);

if (r == NULL)

return NULL;

own_r = 1;

}

}

if (PyComplex_Check(r)) {

cr = ((PyComplexObject*)r)->cval;

if (own_r) {

Py_DECREF(r);

}

}

else {

tmp = PyNumber_Float(r);

if (own_r) {

Py_DECREF(r);

}

if (tmp == NULL)

return NULL;

if (!PyFloat_Check(tmp)) {

PyErr_SetString(PyExc_TypeError,

"float(r) didn't return a float");

Py_DECREF(tmp);

return NULL;

}

cr.real = PyFloat_AsDouble(tmp);

Py_DECREF(tmp);

cr.imag = 0.0;

}

if (i == NULL) {

ci.real = 0.0;

ci.imag = 0.0;

}

else if (PyComplex_Check(i))

ci = ((PyComplexObject*)i)->cval;

else {

tmp = (*nbi->nb_float)(i);

if (tmp == NULL)

return NULL;

ci.real = PyFloat_AsDouble(tmp);

Py_DECREF(tmp);

ci.imag = 0.;

}

cr.real -= ci.imag;

cr.imag += ci.real;

return PyComplex_FromCComplex(cr);

}

static char complex_doc[] =

"complex(real[, imag]) -> complex number\n\

\n\

Create a complex number from a real part and an optional imaginary part.\n\

This is equivalent to (real + imag*1j) where imag defaults to 0.";

#endif

static PyObject *

builtin_dir(PyObject *self, PyObject *args)

{

static char *attrlist[] = {"__members__", "__methods__", NULL};

PyObject *v = NULL, *l = NULL, *m = NULL;

PyObject *d, *x;

int i;

char **s;

if (!PyArg_ParseTuple(args, "|O:dir", &v))

return NULL;

if (v == NULL) {

x = PyEval_GetLocals();

if (x == NULL)

goto error;

l = PyMapping_Keys(x);

if (l == NULL)

goto error;

}

else {

d = PyObject_GetAttrString(v, "__dict__");

if (d == NULL)

PyErr_Clear();

else {

l = PyMapping_Keys(d);

if (l == NULL)

PyErr_Clear();

Py_DECREF(d);

}

if (l == NULL) {

l = PyList_New(0);

if (l == NULL)

goto error;

}

for (s = attrlist; *s != NULL; s++) {

m = PyObject_GetAttrString(v, *s);

if (m == NULL) {

PyErr_Clear();

continue;

}

for (i = 0; ; i++) {

x = PySequence_GetItem(m, i);

if (x == NULL) {

PyErr_Clear();

break;

}

if (PyList_Append(l, x) != 0) {

Py_DECREF(x);

Py_DECREF(m);

goto error;

}

Py_DECREF(x);

}

Py_DECREF(m);

}

}

if (PyList_Sort(l) != 0)

goto error;

return l;

error:

Py_XDECREF(l);

return NULL;

}

static char dir_doc[] =

"dir([object]) -> list of strings\n\

\n\

Return an alphabetized list of names comprising (some of) the attributes\n\

of the given object. Without an argument, the names in the current scope\n\

are listed. With an instance argument, only the instance attributes are\n\

returned. With a class argument, attributes of the base class are not\n\

returned. For other types or arguments, this may list members or methods.";

static PyObject *

builtin_divmod(PyObject *self, PyObject *args)

{

PyObject *v, *w;

if (!PyArg_ParseTuple(args, "OO:divmod", &v, &w))

return NULL;

return PyNumber_Divmod(v, w);

}

static char divmod_doc[] =

"divmod(x, y) -> (div, mod)\n\

\n\

Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.";

static PyObject *

builtin_eval(PyObject *self, PyObject *args)

{

PyObject *cmd;

PyObject *globals = Py_None, *locals = Py_None;

char *str;

if (!PyArg_ParseTuple(args, "O|O!O!:eval",

&cmd,

&PyDict_Type, &globals,

&PyDict_Type, &locals))

return NULL;

if (globals == Py_None) {

globals = PyEval_GetGlobals();

if (locals == Py_None)

locals = PyEval_GetLocals();

}

else if (locals == Py_None)

locals = globals;

if (PyDict_GetItemString(globals, "__builtins__") == NULL) {

if (PyDict_SetItemString(globals, "__builtins__",

PyEval_GetBuiltins()) != 0)

return NULL;

}

if (PyCode_Check(cmd))

return PyEval_EvalCode((PyCodeObject *) cmd, globals, locals);

if (!PyString_Check(cmd) &&

!PyUnicode_Check(cmd)) {

PyErr_SetString(PyExc_TypeError,

"eval() argument 1 must be string or code object");

return NULL;

}

if (PyString_AsStringAndSize(cmd, &str, NULL))

return NULL;

while (*str == ' ' || *str == '\t')

str++;

return PyRun_String(str, Py_eval_input, globals, locals);

}

static char eval_doc[] =

"eval(source[, globals[, locals]]) -> value\n\

\n\

Evaluate the source in the context of globals and locals.\n\

The source may be a string representing a Python expression\n\

or a code object as returned by compile().\n\

The globals and locals are dictionaries, defaulting to the current\n\

globals and locals. If only globals is given, locals defaults to it.";

static PyObject *

builtin_execfile(PyObject *self, PyObject *args)

{

char *filename;

PyObject *globals = Py_None, *locals = Py_None;

PyObject *res;

FILE* fp;

if (!PyArg_ParseTuple(args, "s|O!O!:execfile",

&filename,

&PyDict_Type, &globals,

&PyDict_Type, &locals))

return NULL;

if (globals == Py_None) {

globals = PyEval_GetGlobals();

if (locals == Py_None)

locals = PyEval_GetLocals();

}

else if (locals == Py_None)

locals = globals;

if (PyDict_GetItemString(globals, "__builtins__") == NULL) {

if (PyDict_SetItemString(globals, "__builtins__",

PyEval_GetBuiltins()) != 0)

return NULL;

}

Py_BEGIN_ALLOW_THREADS

fp = fopen(filename, "r");

Py_END_ALLOW_THREADS

if (fp == NULL) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

res = PyRun_FileEx(fp, filename, Py_file_input, globals, locals, 1);

return res;

}

static char execfile_doc[] =

"execfile(filename[, globals[, locals]])\n\

\n\

Read and execute a Python script from a file.\n\

The globals and locals are dictionaries, defaulting to the current\n\

globals and locals. If only globals is given, locals defaults to it.";

static PyObject *

builtin_getattr(PyObject *self, PyObject *args)

{

PyObject *v, *result, *dflt = NULL;

PyObject *name;

if (!PyArg_ParseTuple(args, "OO|O:getattr", &v, &name, &dflt))

return NULL;

result = PyObject_GetAttr(v, name);

if (result == NULL && dflt != NULL) {

PyErr_Clear();

Py_INCREF(dflt);

result = dflt;

}

return result;

}

static char getattr_doc[] =

"getattr(object, name[, default]) -> value\n\

\n\

Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\n\

When a default argument is given, it is returned when the attribute doesn't\n\

exist; without it, an exception is raised in that case.";

static PyObject *

builtin_globals(PyObject *self, PyObject *args)

{

PyObject *d;

if (!PyArg_ParseTuple(args, ":globals"))

return NULL;

d = PyEval_GetGlobals();

Py_INCREF(d);

return d;

}

static char globals_doc[] =

"globals() -> dictionary\n\

\n\

Return the dictionary containing the current scope's global variables.";

static PyObject *

builtin_hasattr(PyObject *self, PyObject *args)

{

PyObject *v;

PyObject *name;

if (!PyArg_ParseTuple(args, "OO:hasattr", &v, &name))

return NULL;

v = PyObject_GetAttr(v, name);

if (v == NULL) {

PyErr_Clear();

Py_INCREF(Py_False);

return Py_False;

}

Py_DECREF(v);

Py_INCREF(Py_True);

return Py_True;

}

static char hasattr_doc[] =

"hasattr(object, name) -> Boolean\n\

\n\

Return whether the object has an attribute with the given name.\n\

(This is done by calling getattr(object, name) and catching exceptions.)";

static PyObject *

builtin_id(PyObject *self, PyObject *args)

{

PyObject *v;

if (!PyArg_ParseTuple(args, "O:id", &v))

return NULL;

return PyLong_FromVoidPtr(v);

}

static char id_doc[] =

"id(object) -> integer\n\

\n\

Return the identity of an object. This is guaranteed to be unique among\n\

simultaneously existing objects. (Hint: it's the object's memory address.)";

static PyObject *

builtin_map(PyObject *self, PyObject *args)

{

typedef struct {

PyObject *seq;

PySequenceMethods *sqf;

int len;

} sequence;

PyObject *func, *result;

sequence *seqs = NULL, *sqp;

int n, len;

register int i, j;

n = PyTuple_Size(args);

if (n < 2) {

PyErr_SetString(PyExc_TypeError,

"map() requires at least two args");

return NULL;

}

func = PyTuple_GetItem(args, 0);

n--;

if (func == Py_None && n == 1) {

/* map(None, S) is the same as list(S). */

return PySequence_List(PyTuple_GetItem(args, 1));

}

if ((seqs = PyMem_NEW(sequence, n)) == NULL) {

PyErr_NoMemory();

goto Fail_2;

}

for (len = 0, i = 0, sqp = seqs; i < n; ++i, ++sqp) {

int curlen;

PySequenceMethods *sqf;

if ((sqp->seq = PyTuple_GetItem(args, i + 1)) == NULL)

goto Fail_2;

sqp->sqf = sqf = sqp->seq->ob_type->tp_as_sequence;

if (sqf == NULL ||

sqf->sq_length == NULL ||

sqf->sq_item == NULL)

{

static char errmsg[] =

"argument %d to map() must be a sequence object";

char errbuf[sizeof(errmsg) + 25];

sprintf(errbuf, errmsg, i+2);

PyErr_SetString(PyExc_TypeError, errbuf);

goto Fail_2;

}

if ((curlen = sqp->len = (*sqp->sqf->sq_length)(sqp->seq)) < 0)

goto Fail_2;

if (curlen > len)

len = curlen;

}

if ((result = (PyObject *) PyList_New(len)) == NULL)

goto Fail_2;

for (i = 0; ; ++i) {

PyObject *alist, *item=NULL, *value;

int any = 0;

if (func == Py_None && n == 1)

alist = NULL;

else {

if ((alist = PyTuple_New(n)) == NULL)

goto Fail_1;

}

for (j = 0, sqp = seqs; j < n; ++j, ++sqp) {

if (sqp->len < 0) {

Py_INCREF(Py_None);

item = Py_None;

}

else {

item = (*sqp->sqf->sq_item)(sqp->seq, i);

if (item == NULL) {

if (PyErr_ExceptionMatches(

PyExc_IndexError))

{

PyErr_Clear();

Py_INCREF(Py_None);

item = Py_None;

sqp->len = -1;

}

else {

goto Fail_0;