self->lineno = PyTuple_GET_ITEM(info, 1);        Py_INCREF(self->lineno);         Py_CLEAR(self->offset);        self->offset = PyTuple_GET_ITEM(info, 2);        Py_INCREF(self->offset);         Py_CLEAR(self->text);        self->text = PyTuple_GET_ITEM(info, 3);        Py_INCREF(self->text);         Py_DECREF(info);    }    return 0;} static intSyntaxError_clear(PySyntaxErrorObject *self){    Py_CLEAR(self->msg);    Py_CLEAR(self->filename);    Py_CLEAR(self->lineno);    Py_CLEAR(self->offset);    Py_CLEAR(self->text);    Py_CLEAR(self->print_file_and_line);    return BaseException_clear((PyBaseExceptionObject *)self);} static voidSyntaxError_dealloc(PySyntaxErrorObject *self){    _PyObject_GC_UNTRACK(self);    SyntaxError_clear(self);    self->ob_type->tp_free((PyObject *)self);} static intSyntaxError_traverse(PySyntaxErrorObject *self, visitproc visit, void *arg){    Py_VISIT(self->msg);    Py_VISIT(self->filename);    Py_VISIT(self->lineno);    Py_VISIT(self->offset);    Py_VISIT(self->text);    Py_VISIT(self->print_file_and_line);    return BaseException_traverse((PyBaseExceptionObject *)self, visit, arg);} /* This is called "my_basename" instead of just "basename" to avoid name   conflicts with glibc; basename is already prototyped if _GNU_SOURCE is   defined, and Python does define that. */static char *my_basename(char *name){    char *cp = name;    char *result = name;     if (name == NULL)        return "???";    while (*cp != '\0') {        if (*cp == SEP)            result = cp + 1;        ++cp;    }    return result;}  static PyObject *SyntaxError_str(PySyntaxErrorObject *self){    PyObject *str;    PyObject *result;    int have_filename = 0;    int have_lineno = 0;    char *buffer = NULL;    Py_ssize_t bufsize;     if (self->msg)        str = PyObject_Str(self->msg);    else        str = PyObject_Str(Py_None);    if (!str) return NULL;    /* Don't fiddle with non-string return (shouldn't happen anyway) */    if (!PyString_Check(str)) return str;     /* XXX -- do all the additional formatting with filename and       lineno here */     have_filename = (self->filename != NULL) &&        PyString_Check(self->filename);    have_lineno = (self->lineno != NULL) && PyInt_Check(self->lineno);     if (!have_filename && !have_lineno)        return str;     bufsize = PyString_GET_SIZE(str) + 64;    if (have_filename)        bufsize += PyString_GET_SIZE(self->filename);     buffer = PyMem_MALLOC(bufsize);    if (buffer == NULL)        return str;     if (have_filename && have_lineno)        PyOS_snprintf(buffer, bufsize, "%s (%s, line %ld)",            PyString_AS_STRING(str),            my_basename(PyString_AS_STRING(self->filename)),            PyInt_AsLong(self->lineno));    else if (have_filename)        PyOS_snprintf(buffer, bufsize, "%s (%s)",            PyString_AS_STRING(str),            my_basename(PyString_AS_STRING(self->filename)));    else /* only have_lineno */        PyOS_snprintf(buffer, bufsize, "%s (line %ld)",            PyString_AS_STRING(str),            PyInt_AsLong(self->lineno));     result = PyString_FromString(buffer);    PyMem_FREE(buffer);     if (result == NULL)        result = str;    else        Py_DECREF(str);    return result;} static PyMemberDef SyntaxError_members[] = {    {"message", T_OBJECT, offsetof(PySyntaxErrorObject, message), 0,        PyDoc_STR("exception message")},    {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0,        PyDoc_STR("exception msg")},    {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0,        PyDoc_STR("exception filename")},    {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0,        PyDoc_STR("exception lineno")},    {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0,        PyDoc_STR("exception offset")},    {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0,        PyDoc_STR("exception text")},    {"print_file_and_line", T_OBJECT,        offsetof(PySyntaxErrorObject, print_file_and_line), 0,        PyDoc_STR("exception print_file_and_line")},    {NULL}  /* Sentinel */}; ComplexExtendsException(PyExc_StandardError, SyntaxError, SyntaxError,                        SyntaxError_dealloc, 0, SyntaxError_members,                        SyntaxError_str, "Invalid syntax.");  /* *    IndentationError extends SyntaxError */MiddlingExtendsException(PyExc_SyntaxError, IndentationError, SyntaxError,                         "Improper indentation.");  /* *    TabError extends IndentationError */MiddlingExtendsException(PyExc_IndentationError, TabError, SyntaxError,                         "Improper mixture of spaces and tabs.");  /* *    LookupError extends StandardError */SimpleExtendsException(PyExc_StandardError, LookupError,                       "Base class for lookup errors.");  /* *    IndexError extends LookupError */SimpleExtendsException(PyExc_LookupError, IndexError,                       "Sequence index out of range.");  /* *    KeyError extends LookupError */static PyObject *KeyError_str(PyBaseExceptionObject *self){    /* If args is a tuple of exactly one item, apply repr to args[0].       This is done so that e.g. the exception raised by {}[''] prints         KeyError: ''       rather than the confusing         KeyError       alone.  The downside is that if KeyError is raised with an explanatory       string, that string will be displayed in quotes.  Too bad.       If args is anything else, use the default BaseException__str__().    */    if (PyTuple_GET_SIZE(self->args) == 1) {        return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));    }    return BaseException_str(self);} ComplexExtendsException(PyExc_LookupError, KeyError, BaseException,                        0, 0, 0, KeyError_str, "Mapping key not found.");  /* *    ValueError extends StandardError */SimpleExtendsException(PyExc_StandardError, ValueError,                       "Inappropriate argument value (of correct type)."); /* *    UnicodeError extends ValueError */ SimpleExtendsException(PyExc_ValueError, UnicodeError,                       "Unicode related error."); #ifdef Py_USING_UNICODEstatic intget_int(PyObject *attr, Py_ssize_t *value, const char *name){    if (!attr) {        PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);        return -1;    }     if (PyInt_Check(attr)) {        *value = PyInt_AS_LONG(attr);    } else if (PyLong_Check(attr)) {        *value = _PyLong_AsSsize_t(attr);        if (*value == -1 && PyErr_Occurred())            return -1;    } else {        PyErr_Format(PyExc_TypeError, "%.200s attribute must be int", name);        return -1;    }    return 0;} static intset_ssize_t(PyObject **attr, Py_ssize_t value){    PyObject *obj = PyInt_FromSsize_t(value);    if (!obj)        return -1;    Py_CLEAR(*attr);    *attr = obj;    return 0;} static PyObject *get_string(PyObject *attr, const char *name){    if (!attr) {        PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);        return NULL;    }     if (!PyString_Check(attr)) {        PyErr_Format(PyExc_TypeError, "%.200s attribute must be str", name);        return NULL;    }    Py_INCREF(attr);    return attr;}  static intset_string(PyObject **attr, const char *value){    PyObject *obj = PyString_FromString(value);    if (!obj)        return -1;    Py_CLEAR(*attr);    *attr = obj;    return 0;}  static PyObject *get_unicode(PyObject *attr, const char *name){    if (!attr) {        PyErr_Format(PyExc_TypeError, "%.200s attribute not set", name);        return NULL;    }     if (!PyUnicode_Check(attr)) {        PyErr_Format(PyExc_TypeError,                     "%.200s attribute must be unicode", name);        return NULL;    }    Py_INCREF(attr);    return attr;} PyObject *PyUnicodeEncodeError_GetEncoding(PyObject *exc){    return get_string(((PyUnicodeErrorObject *)exc)->encoding, "encoding");} PyObject *PyUnicodeDecodeError_GetEncoding(PyObject *exc){    return get_string(((PyUnicodeErrorObject *)exc)->encoding, "encoding");} PyObject *PyUnicodeEncodeError_GetObject(PyObject *exc){    return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");} PyObject *PyUnicodeDecodeError_GetObject(PyObject *exc){    return get_string(((PyUnicodeErrorObject *)exc)->object, "object");} PyObject *PyUnicodeTranslateError_GetObject(PyObject *exc){    return get_unicode(((PyUnicodeErrorObject *)exc)->object, "object");} intPyUnicodeEncodeError_GetStart(PyObject *exc, Py_ssize_t *start){    if (!get_int(((PyUnicodeErrorObject *)exc)->start, start, "start")) {        Py_ssize_t size;        PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,                                    "object");        if (!obj) return -1;        size = PyUnicode_GET_SIZE(obj);        if (*start<0)            *start = 0; /*XXX check for values <0*/        if (*start>=size)            *start = size-1;        Py_DECREF(obj);        return 0;    }    return -1;}  intPyUnicodeDecodeError_GetStart(PyObject *exc, Py_ssize_t *start){    if (!get_int(((PyUnicodeErrorObject *)exc)->start, start, "start")) {        Py_ssize_t size;        PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object,                                   "object");        if (!obj) return -1;        size = PyString_GET_SIZE(obj);        if (*start<0)            *start = 0;        if (*start>=size)            *start = size-1;        Py_DECREF(obj);        return 0;    }    return -1;}  intPyUnicodeTranslateError_GetStart(PyObject *exc, Py_ssize_t *start){    return PyUnicodeEncodeError_GetStart(exc, start);}  intPyUnicodeEncodeError_SetStart(PyObject *exc, Py_ssize_t start){    return set_ssize_t(&((PyUnicodeErrorObject *)exc)->start, start);}  intPyUnicodeDecodeError_SetStart(PyObject *exc, Py_ssize_t start){    return set_ssize_t(&((PyUnicodeErrorObject *)exc)->start, start);}  intPyUnicodeTranslateError_SetStart(PyObject *exc, Py_ssize_t start){    return set_ssize_t(&((PyUnicodeErrorObject *)exc)->start, start);}  intPyUnicodeEncodeError_GetEnd(PyObject *exc, Py_ssize_t *end){    if (!get_int(((PyUnicodeErrorObject *)exc)->end, end, "end")) {        Py_ssize_t size;        PyObject *obj = get_unicode(((PyUnicodeErrorObject *)exc)->object,                                    "object");        if (!obj) return -1;        size = PyUnicode_GET_SIZE(obj);        if (*end<1)            *end = 1;        if (*end>size)            *end = size;        Py_DECREF(obj);        return 0;    }    return -1;}  intPyUnicodeDecodeError_GetEnd(PyObject *exc, Py_ssize_t *end){    if (!get_int(((PyUnicodeErrorObject *)exc)->end, end, "end")) {        Py_ssize_t size;        PyObject *obj = get_string(((PyUnicodeErrorObject *)exc)->object,                                   "object");        if (!obj) return -1;        size = PyString_GET_SIZE(obj);        if (*end<1)            *end = 1;        if (*end>size)            *end = size;        Py_DECREF(obj);        return 0;    }    return -1;}  intPyUnicodeTranslateError_GetEnd(PyObject *exc, Py_ssize_t *start){    return PyUnicodeEncodeError_GetEnd(exc, start);}  intPyUnicodeEncodeError_SetEnd(PyObject *exc, Py_ssize_t end){    return set_ssize_t(&((PyUnicodeErrorObject *)exc)->end, end);}  intPyUnicodeDecodeError_SetEnd(PyObject *exc, Py_ssize_t end){    return set_ssize_t(&((PyUnicodeErrorObject *)exc)->end, end);}  intPyUnicodeTranslateError_SetEnd(PyObject *exc, Py_ssize_t end){    return set_ssize_t(&((PyUnicodeErrorObject *)exc)->end, end);} PyObject *PyUnicodeEncodeError_GetReason(PyObject *exc){    return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");}  PyObject *PyUnicodeDecodeError_GetReason(PyObject *exc){    return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");}  PyObject *PyUnicodeTranslateError_GetReason(PyObject *exc){    return get_string(((PyUnicodeErrorObject *)exc)->reason, "reason");}  intPyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason){    return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);}  intPyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason){    return set_string(&((PyUnicodeErrorObject *)exc)->reason, reason);}  intPyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason){

Lines 1001–1500 of 2147. Previous lines Load more