/* Sentinel object implementation */

#include "Python.h"

#include "descrobject.h"          // PyMemberDef

#include "pycore_ceval.h"         // _PyThreadState_GET()

#include "pycore_interpframe.h"   // _PyFrame_IsIncomplete()

#include "pycore_object.h"        // _PyObject_GC_TRACK/UNTRACK()

#include "pycore_stackref.h"      // PyStackRef_AsPyObjectBorrow()

#include "pycore_tuple.h"         // _PyTuple_FromPair

#include "pycore_typeobject.h"    // _Py_BaseObject_RichCompare()

#include "pycore_unionobject.h"   // _Py_union_type_or()

typedef struct {

    PyObject_HEAD

    PyObject *name;

    PyObject *module;

    PyObject *repr;

} sentinelobject;

#define sentinelobject_CAST(op) \

    (assert(PySentinel_Check(op)), _Py_CAST(sentinelobject *, (op)))

/*[clinic input]

class sentinel "sentinelobject *" "&PySentinel_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=8b88f8268d3b5775]*/

#include "clinic/sentinelobject.c.h"

static PyObject *

caller(void)

{

    _PyInterpreterFrame *f = _PyThreadState_GET()->current_frame;

    if (f == NULL || PyStackRef_IsNull(f->f_funcobj)) {

        assert(!PyErr_Occurred());

        Py_RETURN_NONE;

    }

    PyFunctionObject *func = _PyFrame_GetFunction(f);

    assert(PyFunction_Check(func));

    PyObject *r = PyFunction_GetModule((PyObject *)func);

    if (!r) {

        assert(!PyErr_Occurred());

        Py_RETURN_NONE;

    }

    return Py_NewRef(r);

}

static PyObject *

sentinel_new_with_module(PyTypeObject *type, PyObject *name, PyObject *module, PyObject *repr)

{

    assert(PyUnicode_Check(name));

    sentinelobject *self = PyObject_GC_New(sentinelobject, type);

    if (self == NULL) {

        return NULL;

    }

    self->name = Py_NewRef(name);

    self->module = Py_NewRef(module);

    self->repr = Py_XNewRef(repr);

    _PyObject_GC_TRACK(self);

    return (PyObject *)self;

}

/*[clinic input]

@classmethod

sentinel.__new__ as sentinel_new

    name: object(subclass_of='&PyUnicode_Type')

    /

    *

    repr: object = None

[clinic start generated code]*/

static PyObject *

sentinel_new_impl(PyTypeObject *type, PyObject *name, PyObject *repr)

/*[clinic end generated code: output=1eb7fab52e57d8c8 input=28cab6c468997b35]*/

{

    if (repr == Py_None) {

        repr = NULL;

    }

    else if (!PyUnicode_Check(repr)) {

        _PyArg_BadArgument("sentinel", "argument 'repr'", "str or None", repr);

        return NULL;

    }

    PyObject *module = caller();

    PyObject *self = sentinel_new_with_module(type, name, module, repr);

    Py_DECREF(module);

    return self;

}

PyObject *

PySentinel_New(const char *name, const char *module_name, const char *repr)

{

    PyObject *name_obj = PyUnicode_FromString(name);

    if (name_obj == NULL) {

        return NULL;

    }

    PyObject *repr_obj = NULL;

    if (repr != NULL) {

        repr_obj = PyUnicode_FromString(repr);

        if (repr_obj == NULL) {

            Py_DECREF(name_obj);

            return NULL;

        }

    }

    PyObject *module_obj = module_name == NULL

        ? Py_None

        : PyUnicode_FromString(module_name);

    if (module_obj == NULL) {

        Py_DECREF(name_obj);

        Py_XDECREF(repr_obj);

        return NULL;

    }

    PyObject *sentinel = sentinel_new_with_module(

        &PySentinel_Type, name_obj, module_obj, repr_obj);

    Py_DECREF(module_obj);

    Py_DECREF(name_obj);

    Py_XDECREF(repr_obj);

    return sentinel;

}

static int

sentinel_clear(PyObject *op)

{

    sentinelobject *self = sentinelobject_CAST(op);

    Py_CLEAR(self->name);

    Py_CLEAR(self->module);

    Py_CLEAR(self->repr);

    return 0;

}

static void

sentinel_dealloc(PyObject *op)

{

    _PyObject_GC_UNTRACK(op);

    (void)sentinel_clear(op);

    Py_TYPE(op)->tp_free(op);

}

static int

sentinel_traverse(PyObject *op, visitproc visit, void *arg)

{

    sentinelobject *self = sentinelobject_CAST(op);

    Py_VISIT(self->name);

    Py_VISIT(self->module);

    Py_VISIT(self->repr);

    return 0;

}

static PyObject *

sentinel_repr(PyObject *op)

{

    sentinelobject *self = sentinelobject_CAST(op);

    if (self->repr != NULL) {

        return Py_NewRef(self->repr);

    }

    return Py_NewRef(self->name);

}

static PyObject *

sentinel_copy(PyObject *self, PyObject *Py_UNUSED(ignored))

{

    return Py_NewRef(self);

}

static PyObject *

sentinel_deepcopy(PyObject *self, PyObject *Py_UNUSED(memo))

{

    return Py_NewRef(self);

}

static PyObject *

sentinel_reduce(PyObject *op, PyObject *Py_UNUSED(ignored))

{

    sentinelobject *self = sentinelobject_CAST(op);

    return Py_NewRef(self->name);

}

static PyMethodDef sentinel_methods[] = {

    {"__copy__", sentinel_copy, METH_NOARGS, NULL},

    {"__deepcopy__", sentinel_deepcopy, METH_O, NULL},

    {"__reduce__", sentinel_reduce, METH_NOARGS, NULL},

    {NULL, NULL}

};

static PyMemberDef sentinel_members[] = {

    {"__name__", Py_T_OBJECT_EX, offsetof(sentinelobject, name), Py_READONLY},

    {"__module__", Py_T_OBJECT_EX, offsetof(sentinelobject, module), 0},

    {NULL}

};

static PyNumberMethods sentinel_as_number = {

    .nb_or = _Py_union_type_or,

};

PyDoc_STRVAR(sentinel_doc,

"sentinel(name, /, *, repr=None)\n"

"--\n\n"

"Create a unique sentinel object with the given name.");

PyTypeObject PySentinel_Type = {

    PyVarObject_HEAD_INIT(&PyType_Type, 0)

    .tp_name = "sentinel",

    .tp_basicsize = sizeof(sentinelobject),

    .tp_dealloc = sentinel_dealloc,

    .tp_repr = sentinel_repr,

    .tp_as_number = &sentinel_as_number,

    .tp_hash = PyObject_GenericHash,

    .tp_getattro = PyObject_GenericGetAttr,

    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE

                | Py_TPFLAGS_HAVE_GC,

    .tp_doc = sentinel_doc,

    .tp_traverse = sentinel_traverse,

    .tp_clear = sentinel_clear,

    .tp_richcompare = _Py_BaseObject_RichCompare,

    .tp_methods = sentinel_methods,

    .tp_members = sentinel_members,

    .tp_new = sentinel_new,

    .tp_free = PyObject_GC_Del,

};