EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.10 / Objects / genobject.c

/* Generator object implementation */\r
\r
#include "Python.h"\r
#include "frameobject.h"\r
#include "genobject.h"\r
#include "ceval.h"\r
#include "structmember.h"\r
#include "opcode.h"\r
\r
static int\r
gen_traverse(PyGenObject *gen, visitproc visit, void *arg)\r
{\r
    Py_VISIT((PyObject *)gen->gi_frame);\r
    Py_VISIT(gen->gi_code);\r
    return 0;\r
}\r
\r
static void\r
gen_dealloc(PyGenObject *gen)\r
{\r
    PyObject *self = (PyObject *) gen;\r
\r
    _PyObject_GC_UNTRACK(gen);\r
\r
    if (gen->gi_weakreflist != NULL)\r
        PyObject_ClearWeakRefs(self);\r
\r
    _PyObject_GC_TRACK(self);\r
\r
    if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {\r
        /* Generator is paused, so we need to close */\r
        Py_TYPE(gen)->tp_del(self);\r
        if (self->ob_refcnt > 0)\r
            return;                     /* resurrected.  :( */\r
    }\r
\r
    _PyObject_GC_UNTRACK(self);\r
    Py_CLEAR(gen->gi_frame);\r
    Py_CLEAR(gen->gi_code);\r
    PyObject_GC_Del(gen);\r
}\r
\r
\r
static PyObject *\r
gen_send_ex(PyGenObject *gen, PyObject *arg, int exc)\r
{\r
    PyThreadState *tstate = PyThreadState_GET();\r
    PyFrameObject *f = gen->gi_frame;\r
    PyObject *result;\r
\r
    if (gen->gi_running) {\r
        PyErr_SetString(PyExc_ValueError,\r
                        "generator already executing");\r
        return NULL;\r
    }\r
    if (f==NULL || f->f_stacktop == NULL) {\r
        /* Only set exception if called from send() */\r
        if (arg && !exc)\r
            PyErr_SetNone(PyExc_StopIteration);\r
        return NULL;\r
    }\r
\r
    if (f->f_lasti == -1) {\r
        if (arg && arg != Py_None) {\r
            PyErr_SetString(PyExc_TypeError,\r
                            "can't send non-None value to a "\r
                            "just-started generator");\r
            return NULL;\r
        }\r
    } else {\r
        /* Push arg onto the frame's value stack */\r
        result = arg ? arg : Py_None;\r
        Py_INCREF(result);\r
        *(f->f_stacktop++) = result;\r
    }\r
\r
    /* Generators always return to their most recent caller, not\r
     * necessarily their creator. */\r
    f->f_tstate = tstate;\r
    Py_XINCREF(tstate->frame);\r
    assert(f->f_back == NULL);\r
    f->f_back = tstate->frame;\r
\r
    gen->gi_running = 1;\r
    result = PyEval_EvalFrameEx(f, exc);\r
    gen->gi_running = 0;\r
\r
    /* Don't keep the reference to f_back any longer than necessary.  It\r
     * may keep a chain of frames alive or it could create a reference\r
     * cycle. */\r
    assert(f->f_back == tstate->frame);\r
    Py_CLEAR(f->f_back);\r
    /* Clear the borrowed reference to the thread state */\r
    f->f_tstate = NULL;\r
\r
    /* If the generator just returned (as opposed to yielding), signal\r
     * that the generator is exhausted. */\r
    if (result == Py_None && f->f_stacktop == NULL) {\r
        Py_DECREF(result);\r
        result = NULL;\r
        /* Set exception if not called by gen_iternext() */\r
        if (arg)\r
            PyErr_SetNone(PyExc_StopIteration);\r
    }\r
\r
    if (!result || f->f_stacktop == NULL) {\r
        /* generator can't be rerun, so release the frame */\r
        Py_DECREF(f);\r
        gen->gi_frame = NULL;\r
    }\r
\r
    return result;\r
}\r
\r
PyDoc_STRVAR(send_doc,\r
"send(arg) -> send 'arg' into generator,\n\\r
return next yielded value or raise StopIteration.");\r
\r
static PyObject *\r
gen_send(PyGenObject *gen, PyObject *arg)\r
{\r
    return gen_send_ex(gen, arg, 0);\r
}\r
\r
PyDoc_STRVAR(close_doc,\r
"close() -> raise GeneratorExit inside generator.");\r
\r
static PyObject *\r
gen_close(PyGenObject *gen, PyObject *args)\r
{\r
    PyObject *retval;\r
    PyErr_SetNone(PyExc_GeneratorExit);\r
    retval = gen_send_ex(gen, Py_None, 1);\r
    if (retval) {\r
        Py_DECREF(retval);\r
        PyErr_SetString(PyExc_RuntimeError,\r
                        "generator ignored GeneratorExit");\r
        return NULL;\r
    }\r
    if (PyErr_ExceptionMatches(PyExc_StopIteration)\r
        || PyErr_ExceptionMatches(PyExc_GeneratorExit))\r
    {\r
        PyErr_Clear();          /* ignore these errors */\r
        Py_INCREF(Py_None);\r
        return Py_None;\r
    }\r
    return NULL;\r
}\r
\r
static void\r
gen_del(PyObject *self)\r
{\r
    PyObject *res;\r
    PyObject *error_type, *error_value, *error_traceback;\r
    PyGenObject *gen = (PyGenObject *)self;\r
\r
    if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL)\r
        /* Generator isn't paused, so no need to close */\r
        return;\r
\r
    /* Temporarily resurrect the object. */\r
    assert(self->ob_refcnt == 0);\r
    self->ob_refcnt = 1;\r
\r
    /* Save the current exception, if any. */\r
    PyErr_Fetch(&error_type, &error_value, &error_traceback);\r
\r
    res = gen_close(gen, NULL);\r
\r
    if (res == NULL)\r
        PyErr_WriteUnraisable(self);\r
    else\r
        Py_DECREF(res);\r
\r
    /* Restore the saved exception. */\r
    PyErr_Restore(error_type, error_value, error_traceback);\r
\r
    /* Undo the temporary resurrection; can't use DECREF here, it would\r
     * cause a recursive call.\r
     */\r
    assert(self->ob_refcnt > 0);\r
    if (--self->ob_refcnt == 0)\r
        return; /* this is the normal path out */\r
\r
    /* close() resurrected it!  Make it look like the original Py_DECREF\r
     * never happened.\r
     */\r
    {\r
        Py_ssize_t refcnt = self->ob_refcnt;\r
        _Py_NewReference(self);\r
        self->ob_refcnt = refcnt;\r
    }\r
    assert(PyType_IS_GC(self->ob_type) &&\r
           _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);\r
\r
    /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so\r
     * we need to undo that. */\r
    _Py_DEC_REFTOTAL;\r
    /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object\r
     * chain, so no more to do there.\r
     * If COUNT_ALLOCS, the original decref bumped tp_frees, and\r
     * _Py_NewReference bumped tp_allocs:  both of those need to be\r
     * undone.\r
     */\r
#ifdef COUNT_ALLOCS\r
    --self->ob_type->tp_frees;\r
    --self->ob_type->tp_allocs;\r
#endif\r
}\r
\r
\r
\r
PyDoc_STRVAR(throw_doc,\r
"throw(typ[,val[,tb]]) -> raise exception in generator,\n\\r
return next yielded value or raise StopIteration.");\r
\r
static PyObject *\r
gen_throw(PyGenObject *gen, PyObject *args)\r
{\r
    PyObject *typ;\r
    PyObject *tb = NULL;\r
    PyObject *val = NULL;\r
\r
    if (!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))\r
        return NULL;\r
\r
    /* First, check the traceback argument, replacing None with\r
       NULL. */\r
    if (tb == Py_None)\r
        tb = NULL;\r
    else if (tb != NULL && !PyTraceBack_Check(tb)) {\r
        PyErr_SetString(PyExc_TypeError,\r
            "throw() third argument must be a traceback object");\r
        return NULL;\r
    }\r
\r
    Py_INCREF(typ);\r
    Py_XINCREF(val);\r
    Py_XINCREF(tb);\r
\r
    if (PyExceptionClass_Check(typ)) {\r
        PyErr_NormalizeException(&typ, &val, &tb);\r
    }\r
\r
    else if (PyExceptionInstance_Check(typ)) {\r
        /* Raising an instance.  The value should be a dummy. */\r
        if (val && val != Py_None) {\r
            PyErr_SetString(PyExc_TypeError,\r
              "instance exception may not have a separate value");\r
            goto failed_throw;\r
        }\r
        else {\r
            /* Normalize to raise <class>, <instance> */\r
            Py_XDECREF(val);\r
            val = typ;\r
            typ = PyExceptionInstance_Class(typ);\r
            Py_INCREF(typ);\r
        }\r
    }\r
    else {\r
        /* Not something you can raise.  throw() fails. */\r
        PyErr_Format(PyExc_TypeError,\r
                     "exceptions must be classes, or instances, not %s",\r
                     typ->ob_type->tp_name);\r
            goto failed_throw;\r
    }\r
\r
    PyErr_Restore(typ, val, tb);\r
    return gen_send_ex(gen, Py_None, 1);\r
\r
failed_throw:\r
    /* Didn't use our arguments, so restore their original refcounts */\r
    Py_DECREF(typ);\r
    Py_XDECREF(val);\r
    Py_XDECREF(tb);\r
    return NULL;\r
}\r
\r
\r
static PyObject *\r
gen_iternext(PyGenObject *gen)\r
{\r
    return gen_send_ex(gen, NULL, 0);\r
}\r
\r
\r
static PyObject *\r
gen_repr(PyGenObject *gen)\r
{\r
    char *code_name;\r
    code_name = PyString_AsString(((PyCodeObject *)gen->gi_code)->co_name);\r
    if (code_name == NULL)\r
        return NULL;\r
    return PyString_FromFormat("<generator object %.200s at %p>",\r
                               code_name, gen);\r
}\r
\r
\r
static PyObject *\r
gen_get_name(PyGenObject *gen)\r
{\r
    PyObject *name = ((PyCodeObject *)gen->gi_code)->co_name;\r
    Py_INCREF(name);\r
    return name;\r
}\r
\r
\r
PyDoc_STRVAR(gen__name__doc__,\r
"Return the name of the generator's associated code object.");\r
\r
static PyGetSetDef gen_getsetlist[] = {\r
    {"__name__", (getter)gen_get_name, NULL, gen__name__doc__},\r
    {NULL}\r
};\r
\r
\r
static PyMemberDef gen_memberlist[] = {\r
    {"gi_frame",        T_OBJECT, offsetof(PyGenObject, gi_frame),      RO},\r
    {"gi_running",      T_INT,    offsetof(PyGenObject, gi_running),    RO},\r
    {"gi_code",     T_OBJECT, offsetof(PyGenObject, gi_code),  RO},\r
    {NULL}      /* Sentinel */\r
};\r
\r
static PyMethodDef gen_methods[] = {\r
    {"send",(PyCFunction)gen_send, METH_O, send_doc},\r
    {"throw",(PyCFunction)gen_throw, METH_VARARGS, throw_doc},\r
    {"close",(PyCFunction)gen_close, METH_NOARGS, close_doc},\r
    {NULL, NULL}        /* Sentinel */\r
};\r
\r
PyTypeObject PyGen_Type = {\r
    PyVarObject_HEAD_INIT(&PyType_Type, 0)\r
    "generator",                                /* tp_name */\r
    sizeof(PyGenObject),                        /* tp_basicsize */\r
    0,                                          /* tp_itemsize */\r
    /* methods */\r
    (destructor)gen_dealloc,                    /* tp_dealloc */\r
    0,                                          /* tp_print */\r
    0,                                          /* tp_getattr */\r
    0,                                          /* tp_setattr */\r
    0,                                          /* tp_compare */\r
    (reprfunc)gen_repr,                         /* tp_repr */\r
    0,                                          /* tp_as_number */\r
    0,                                          /* tp_as_sequence */\r
    0,                                          /* tp_as_mapping */\r
    0,                                          /* tp_hash */\r
    0,                                          /* tp_call */\r
    0,                                          /* tp_str */\r
    PyObject_GenericGetAttr,                    /* tp_getattro */\r
    0,                                          /* tp_setattro */\r
    0,                                          /* tp_as_buffer */\r
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */\r
    0,                                          /* tp_doc */\r
    (traverseproc)gen_traverse,                 /* tp_traverse */\r
    0,                                          /* tp_clear */\r
    0,                                          /* tp_richcompare */\r
    offsetof(PyGenObject, gi_weakreflist),      /* tp_weaklistoffset */\r
    PyObject_SelfIter,                          /* tp_iter */\r
    (iternextfunc)gen_iternext,                 /* tp_iternext */\r
    gen_methods,                                /* tp_methods */\r
    gen_memberlist,                             /* tp_members */\r
    gen_getsetlist,                             /* tp_getset */\r
    0,                                          /* tp_base */\r
    0,                                          /* tp_dict */\r
\r
    0,                                          /* tp_descr_get */\r
    0,                                          /* tp_descr_set */\r
    0,                                          /* tp_dictoffset */\r
    0,                                          /* tp_init */\r
    0,                                          /* tp_alloc */\r
    0,                                          /* tp_new */\r
    0,                                          /* tp_free */\r
    0,                                          /* tp_is_gc */\r
    0,                                          /* tp_bases */\r
    0,                                          /* tp_mro */\r
    0,                                          /* tp_cache */\r
    0,                                          /* tp_subclasses */\r
    0,                                          /* tp_weaklist */\r
    gen_del,                                    /* tp_del */\r
};\r
\r
PyObject *\r
PyGen_New(PyFrameObject *f)\r
{\r
    PyGenObject *gen = PyObject_GC_New(PyGenObject, &PyGen_Type);\r
    if (gen == NULL) {\r
        Py_DECREF(f);\r
        return NULL;\r
    }\r
    gen->gi_frame = f;\r
    Py_INCREF(f->f_code);\r
    gen->gi_code = (PyObject *)(f->f_code);\r
    gen->gi_running = 0;\r
    gen->gi_weakreflist = NULL;\r
    _PyObject_GC_TRACK(gen);\r
    return (PyObject *)gen;\r
}\r
\r
int\r
PyGen_NeedsFinalizing(PyGenObject *gen)\r
{\r
    int i;\r
    PyFrameObject *f = gen->gi_frame;\r
\r
    if (f == NULL || f->f_stacktop == NULL || f->f_iblock <= 0)\r
        return 0; /* no frame or empty blockstack == no finalization */\r
\r
    /* Any block type besides a loop requires cleanup. */\r
    i = f->f_iblock;\r
    while (--i >= 0) {\r
        if (f->f_blockstack[i].b_type != SETUP_LOOP)\r
            return 1;\r
    }\r
\r
    /* No blocks except loops, it's safe to skip finalization. */\r
    return 0;\r
}\r