@plone/volto 14.0.2 → 14.1.0

package/include/python3.8/pytime.h

@@ -1,246 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_PYTIME_H
-#define Py_PYTIME_H
-
-#include "pyconfig.h" /* include for defines */
-#include "object.h"
-
-/**************************************************************************
-Symbols and macros to supply platform-independent interfaces to time related
-functions and constants
-**************************************************************************/
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* _PyTime_t: Python timestamp with subsecond precision. It can be used to
-   store a duration, and so indirectly a date (related to another date, like
-   UNIX epoch). */
-typedef int64_t _PyTime_t;
-#define _PyTime_MIN INT64_MIN
-#define _PyTime_MAX INT64_MAX
-
-typedef enum {
-    /* Round towards minus infinity (-inf).
-       For example, used to read a clock. */
-    _PyTime_ROUND_FLOOR=0,
-    /* Round towards infinity (+inf).
-       For example, used for timeout to wait "at least" N seconds. */
-    _PyTime_ROUND_CEILING=1,
-    /* Round to nearest with ties going to nearest even integer.
-       For example, used to round from a Python float. */
-    _PyTime_ROUND_HALF_EVEN=2,
-    /* Round away from zero
-       For example, used for timeout. _PyTime_ROUND_CEILING rounds
-       -1e-9 to 0 milliseconds which causes bpo-31786 issue.
-       _PyTime_ROUND_UP rounds -1e-9 to -1 millisecond which keeps
-       the timeout sign as expected. select.poll(timeout) must block
-       for negative values." */
-    _PyTime_ROUND_UP=3,
-    /* _PyTime_ROUND_TIMEOUT (an alias for _PyTime_ROUND_UP) should be
-       used for timeouts. */
-    _PyTime_ROUND_TIMEOUT = _PyTime_ROUND_UP
-} _PyTime_round_t;
-
-
-/* Convert a time_t to a PyLong. */
-PyAPI_FUNC(PyObject *) _PyLong_FromTime_t(
-    time_t sec);
-
-/* Convert a PyLong to a time_t. */
-PyAPI_FUNC(time_t) _PyLong_AsTime_t(
-    PyObject *obj);
-
-/* Convert a number of seconds, int or float, to time_t. */
-PyAPI_FUNC(int) _PyTime_ObjectToTime_t(
-    PyObject *obj,
-    time_t *sec,
-    _PyTime_round_t);
-
-/* Convert a number of seconds, int or float, to a timeval structure.
-   usec is in the range [0; 999999] and rounded towards zero.
-   For example, -1.2 is converted to (-2, 800000). */
-PyAPI_FUNC(int) _PyTime_ObjectToTimeval(
-    PyObject *obj,
-    time_t *sec,
-    long *usec,
-    _PyTime_round_t);
-
-/* Convert a number of seconds, int or float, to a timespec structure.
-   nsec is in the range [0; 999999999] and rounded towards zero.
-   For example, -1.2 is converted to (-2, 800000000). */
-PyAPI_FUNC(int) _PyTime_ObjectToTimespec(
-    PyObject *obj,
-    time_t *sec,
-    long *nsec,
-    _PyTime_round_t);
-
-
-/* Create a timestamp from a number of seconds. */
-PyAPI_FUNC(_PyTime_t) _PyTime_FromSeconds(int seconds);
-
-/* Macro to create a timestamp from a number of seconds, no integer overflow.
-   Only use the macro for small values, prefer _PyTime_FromSeconds(). */
-#define _PYTIME_FROMSECONDS(seconds) \
-            ((_PyTime_t)(seconds) * (1000 * 1000 * 1000))
-
-/* Create a timestamp from a number of nanoseconds. */
-PyAPI_FUNC(_PyTime_t) _PyTime_FromNanoseconds(_PyTime_t ns);
-
-/* Create a timestamp from nanoseconds (Python int). */
-PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(_PyTime_t *t,
-    PyObject *obj);
-
-/* Convert a number of seconds (Python float or int) to a timetamp.
-   Raise an exception and return -1 on error, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromSecondsObject(_PyTime_t *t,
-    PyObject *obj,
-    _PyTime_round_t round);
-
-/* Convert a number of milliseconds (Python float or int, 10^-3) to a timetamp.
-   Raise an exception and return -1 on error, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(_PyTime_t *t,
-    PyObject *obj,
-    _PyTime_round_t round);
-
-/* Convert a timestamp to a number of seconds as a C double. */
-PyAPI_FUNC(double) _PyTime_AsSecondsDouble(_PyTime_t t);
-
-/* Convert timestamp to a number of milliseconds (10^-3 seconds). */
-PyAPI_FUNC(_PyTime_t) _PyTime_AsMilliseconds(_PyTime_t t,
-    _PyTime_round_t round);
-
-/* Convert timestamp to a number of microseconds (10^-6 seconds). */
-PyAPI_FUNC(_PyTime_t) _PyTime_AsMicroseconds(_PyTime_t t,
-    _PyTime_round_t round);
-
-/* Convert timestamp to a number of nanoseconds (10^-9 seconds) as a Python int
-   object. */
-PyAPI_FUNC(PyObject *) _PyTime_AsNanosecondsObject(_PyTime_t t);
-
-/* Create a timestamp from a timeval structure.
-   Raise an exception and return -1 on overflow, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromTimeval(_PyTime_t *tp, struct timeval *tv);
-
-/* Convert a timestamp to a timeval structure (microsecond resolution).
-   tv_usec is always positive.
-   Raise an exception and return -1 if the conversion overflowed,
-   return 0 on success. */
-PyAPI_FUNC(int) _PyTime_AsTimeval(_PyTime_t t,
-    struct timeval *tv,
-    _PyTime_round_t round);
-
-/* Similar to _PyTime_AsTimeval(), but don't raise an exception on error. */
-PyAPI_FUNC(int) _PyTime_AsTimeval_noraise(_PyTime_t t,
-    struct timeval *tv,
-    _PyTime_round_t round);
-
-/* Convert a timestamp to a number of seconds (secs) and microseconds (us).
-   us is always positive. This function is similar to _PyTime_AsTimeval()
-   except that secs is always a time_t type, whereas the timeval structure
-   uses a C long for tv_sec on Windows.
-   Raise an exception and return -1 if the conversion overflowed,
-   return 0 on success. */
-PyAPI_FUNC(int) _PyTime_AsTimevalTime_t(
-    _PyTime_t t,
-    time_t *secs,
-    int *us,
-    _PyTime_round_t round);
-
-#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_KQUEUE)
-/* Create a timestamp from a timespec structure.
-   Raise an exception and return -1 on overflow, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_FromTimespec(_PyTime_t *tp, struct timespec *ts);
-
-/* Convert a timestamp to a timespec structure (nanosecond resolution).
-   tv_nsec is always positive.
-   Raise an exception and return -1 on error, return 0 on success. */
-PyAPI_FUNC(int) _PyTime_AsTimespec(_PyTime_t t, struct timespec *ts);
-#endif
-
-/* Compute ticks * mul / div.
-   The caller must ensure that ((div - 1) * mul) cannot overflow. */
-PyAPI_FUNC(_PyTime_t) _PyTime_MulDiv(_PyTime_t ticks,
-    _PyTime_t mul,
-    _PyTime_t div);
-
-/* Get the current time from the system clock.
-
-   The function cannot fail. _PyTime_Init() ensures that the system clock
-   works. */
-PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void);
-
-/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
-   The clock is not affected by system clock updates. The reference point of
-   the returned value is undefined, so that only the difference between the
-   results of consecutive calls is valid.
-
-   The function cannot fail. _PyTime_Init() ensures that a monotonic clock
-   is available and works. */
-PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void);
-
-
-/* Structure used by time.get_clock_info() */
-typedef struct {
-    const char *implementation;
-    int monotonic;
-    int adjustable;
-    double resolution;
-} _Py_clock_info_t;
-
-/* Get the current time from the system clock.
- * Fill clock information if info is not NULL.
- * Raise an exception and return -1 on error, return 0 on success.
- */
-PyAPI_FUNC(int) _PyTime_GetSystemClockWithInfo(
-    _PyTime_t *t,
-    _Py_clock_info_t *info);
-
-/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards.
-   The clock is not affected by system clock updates. The reference point of
-   the returned value is undefined, so that only the difference between the
-   results of consecutive calls is valid.
-
-   Fill info (if set) with information of the function used to get the time.
-
-   Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_GetMonotonicClockWithInfo(
-    _PyTime_t *t,
-    _Py_clock_info_t *info);
-
-
-/* Initialize time.
-   Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_Init(void);
-
-/* Converts a timestamp to the Gregorian time, using the local time zone.
-   Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_localtime(time_t t, struct tm *tm);
-
-/* Converts a timestamp to the Gregorian time, assuming UTC.
-   Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_gmtime(time_t t, struct tm *tm);
-
-/* Get the performance counter: clock with the highest available resolution to
-   measure a short duration.
-
-   The function cannot fail. _PyTime_Init() ensures that the system clock
-   works. */
-PyAPI_FUNC(_PyTime_t) _PyTime_GetPerfCounter(void);
-
-/* Get the performance counter: clock with the highest available resolution to
-   measure a short duration.
-
-   Fill info (if set) with information of the function used to get the time.
-
-   Return 0 on success, raise an exception and return -1 on error. */
-PyAPI_FUNC(int) _PyTime_GetPerfCounterWithInfo(
-    _PyTime_t *t,
-    _Py_clock_info_t *info);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* Py_PYTIME_H */
-#endif /* Py_LIMITED_API */

package/include/python3.8/rangeobject.h

@@ -1,27 +0,0 @@
-
-/* Range object interface */
-
-#ifndef Py_RANGEOBJECT_H
-#define Py_RANGEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
-A range object represents an integer range.  This is an immutable object;
-a range cannot change its value after creation.
-
-Range objects behave like the corresponding tuple objects except that
-they are represented by a start, stop, and step datamembers.
-*/
-
-PyAPI_DATA(PyTypeObject) PyRange_Type;
-PyAPI_DATA(PyTypeObject) PyRangeIter_Type;
-PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type;
-
-#define PyRange_Check(op) (Py_TYPE(op) == &PyRange_Type)
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_RANGEOBJECT_H */

package/include/python3.8/setobject.h

@@ -1,108 +0,0 @@
-/* Set object interface */
-
-#ifndef Py_SETOBJECT_H
-#define Py_SETOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-
-/* There are three kinds of entries in the table:
-
-1. Unused:  key == NULL and hash == 0
-2. Dummy:   key == dummy and hash == -1
-3. Active:  key != NULL and key != dummy and hash != -1
-
-The hash field of Unused slots is always zero.
-
-The hash field of Dummy slots are set to -1
-meaning that dummy entries can be detected by
-either entry->key==dummy or by entry->hash==-1.
-*/
-
-#define PySet_MINSIZE 8
-
-typedef struct {
-    PyObject *key;
-    Py_hash_t hash;             /* Cached hash code of the key */
-} setentry;
-
-/* The SetObject data structure is shared by set and frozenset objects.
-
-Invariant for sets:
- - hash is -1
-
-Invariants for frozensets:
- - data is immutable.
- - hash is the hash of the frozenset or -1 if not computed yet.
-
-*/
-
-typedef struct {
-    PyObject_HEAD
-
-    Py_ssize_t fill;            /* Number active and dummy entries*/
-    Py_ssize_t used;            /* Number active entries */
-
-    /* The table contains mask + 1 slots, and that's a power of 2.
-     * We store the mask instead of the size because the mask is more
-     * frequently needed.
-     */
-    Py_ssize_t mask;
-
-    /* The table points to a fixed-size smalltable for small tables
-     * or to additional malloc'ed memory for bigger tables.
-     * The table pointer is never NULL which saves us from repeated
-     * runtime null-tests.
-     */
-    setentry *table;
-    Py_hash_t hash;             /* Only used by frozenset objects */
-    Py_ssize_t finger;          /* Search finger for pop() */
-
-    setentry smalltable[PySet_MINSIZE];
-    PyObject *weakreflist;      /* List of weak references */
-} PySetObject;
-
-#define PySet_GET_SIZE(so) (assert(PyAnySet_Check(so)),(((PySetObject *)(so))->used))
-
-PyAPI_DATA(PyObject *) _PySet_Dummy;
-
-PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash);
-PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable);
-PyAPI_FUNC(int) PySet_ClearFreeList(void);
-
-#endif /* Section excluded by Py_LIMITED_API */
-
-PyAPI_DATA(PyTypeObject) PySet_Type;
-PyAPI_DATA(PyTypeObject) PyFrozenSet_Type;
-PyAPI_DATA(PyTypeObject) PySetIter_Type;
-
-PyAPI_FUNC(PyObject *) PySet_New(PyObject *);
-PyAPI_FUNC(PyObject *) PyFrozenSet_New(PyObject *);
-
-PyAPI_FUNC(int) PySet_Add(PyObject *set, PyObject *key);
-PyAPI_FUNC(int) PySet_Clear(PyObject *set);
-PyAPI_FUNC(int) PySet_Contains(PyObject *anyset, PyObject *key);
-PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key);
-PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set);
-PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset);
-
-#define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type)
-#define PyAnySet_CheckExact(ob) \
-    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type)
-#define PyAnySet_Check(ob) \
-    (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \
-      PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \
-      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
-#define PySet_Check(ob) \
-    (Py_TYPE(ob) == &PySet_Type || \
-    PyType_IsSubtype(Py_TYPE(ob), &PySet_Type))
-#define   PyFrozenSet_Check(ob) \
-    (Py_TYPE(ob) == &PyFrozenSet_Type || \
-      PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type))
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SETOBJECT_H */

package/include/python3.8/sliceobject.h

@@ -1,65 +0,0 @@
-#ifndef Py_SLICEOBJECT_H
-#define Py_SLICEOBJECT_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* The unique ellipsis object "..." */
-
-PyAPI_DATA(PyObject) _Py_EllipsisObject; /* Don't use this directly */
-
-#define Py_Ellipsis (&_Py_EllipsisObject)
-
-/* Slice object interface */
-
-/*
-
-A slice object containing start, stop, and step data members (the
-names are from range).  After much talk with Guido, it was decided to
-let these be any arbitrary python type.  Py_None stands for omitted values.
-*/
-#ifndef Py_LIMITED_API
-typedef struct {
-    PyObject_HEAD
-    PyObject *start, *stop, *step;      /* not NULL */
-} PySliceObject;
-#endif
-
-PyAPI_DATA(PyTypeObject) PySlice_Type;
-PyAPI_DATA(PyTypeObject) PyEllipsis_Type;
-
-#define PySlice_Check(op) (Py_TYPE(op) == &PySlice_Type)
-
-PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop,
-                                  PyObject* step);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop);
-PyAPI_FUNC(int) _PySlice_GetLongIndices(PySliceObject *self, PyObject *length,
-                                 PyObject **start_ptr, PyObject **stop_ptr,
-                                 PyObject **step_ptr);
-#endif
-PyAPI_FUNC(int) PySlice_GetIndices(PyObject *r, Py_ssize_t length,
-                                  Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
-Py_DEPRECATED(3.7)
-PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject *r, Py_ssize_t length,
-                                     Py_ssize_t *start, Py_ssize_t *stop,
-                                     Py_ssize_t *step,
-                                     Py_ssize_t *slicelength);
-
-#if !defined(Py_LIMITED_API) || (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) || Py_LIMITED_API+0 >= 0x03060100
-#define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) (  \
-    PySlice_Unpack((slice), (start), (stop), (step)) < 0 ?                  \
-    ((*(slicelen) = 0), -1) :                                               \
-    ((*(slicelen) = PySlice_AdjustIndices((length), (start), (stop), *(step))), \
-     0))
-PyAPI_FUNC(int) PySlice_Unpack(PyObject *slice,
-                               Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
-PyAPI_FUNC(Py_ssize_t) PySlice_AdjustIndices(Py_ssize_t length,
-                                             Py_ssize_t *start, Py_ssize_t *stop,
-                                             Py_ssize_t step);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SLICEOBJECT_H */

package/include/python3.8/structmember.h

@@ -1,74 +0,0 @@
-#ifndef Py_STRUCTMEMBER_H
-#define Py_STRUCTMEMBER_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* Interface to map C struct members to Python object attributes */
-
-#include <stddef.h> /* For offsetof */
-
-/* An array of PyMemberDef structures defines the name, type and offset
-   of selected members of a C structure.  These can be read by
-   PyMember_GetOne() and set by PyMember_SetOne() (except if their READONLY
-   flag is set).  The array must be terminated with an entry whose name
-   pointer is NULL. */
-
-typedef struct PyMemberDef {
-    const char *name;
-    int type;
-    Py_ssize_t offset;
-    int flags;
-    const char *doc;
-} PyMemberDef;
-
-/* Types */
-#define T_SHORT     0
-#define T_INT       1
-#define T_LONG      2
-#define T_FLOAT     3
-#define T_DOUBLE    4
-#define T_STRING    5
-#define T_OBJECT    6
-/* XXX the ordering here is weird for binary compatibility */
-#define T_CHAR      7   /* 1-character string */
-#define T_BYTE      8   /* 8-bit signed int */
-/* unsigned variants: */
-#define T_UBYTE     9
-#define T_USHORT    10
-#define T_UINT      11
-#define T_ULONG     12
-
-/* Added by Jack: strings contained in the structure */
-#define T_STRING_INPLACE    13
-
-/* Added by Lillo: bools contained in the structure (assumed char) */
-#define T_BOOL      14
-
-#define T_OBJECT_EX 16  /* Like T_OBJECT, but raises AttributeError
-                           when the value is NULL, instead of
-                           converting to None. */
-#define T_LONGLONG      17
-#define T_ULONGLONG     18
-
-#define T_PYSSIZET      19      /* Py_ssize_t */
-#define T_NONE          20      /* Value is always None */
-
-
-/* Flags */
-#define READONLY            1
-#define READ_RESTRICTED     2
-#define PY_WRITE_RESTRICTED 4
-#define RESTRICTED          (READ_RESTRICTED | PY_WRITE_RESTRICTED)
-
-
-/* Current API, use this */
-PyAPI_FUNC(PyObject *) PyMember_GetOne(const char *, struct PyMemberDef *);
-PyAPI_FUNC(int) PyMember_SetOne(char *, struct PyMemberDef *, PyObject *);
-
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_STRUCTMEMBER_H */

package/include/python3.8/structseq.h

@@ -1,49 +0,0 @@
-
-/* Named tuple object interface */
-
-#ifndef Py_STRUCTSEQ_H
-#define Py_STRUCTSEQ_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct PyStructSequence_Field {
-    const char *name;
-    const char *doc;
-} PyStructSequence_Field;
-
-typedef struct PyStructSequence_Desc {
-    const char *name;
-    const char *doc;
-    struct PyStructSequence_Field *fields;
-    int n_in_sequence;
-} PyStructSequence_Desc;
-
-extern char* PyStructSequence_UnnamedField;
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type,
-                                           PyStructSequence_Desc *desc);
-PyAPI_FUNC(int) PyStructSequence_InitType2(PyTypeObject *type,
-                                           PyStructSequence_Desc *desc);
-#endif
-PyAPI_FUNC(PyTypeObject*) PyStructSequence_NewType(PyStructSequence_Desc *desc);
-
-PyAPI_FUNC(PyObject *) PyStructSequence_New(PyTypeObject* type);
-
-#ifndef Py_LIMITED_API
-typedef PyTupleObject PyStructSequence;
-
-/* Macro, *only* to be used to fill in brand new objects */
-#define PyStructSequence_SET_ITEM(op, i, v) PyTuple_SET_ITEM(op, i, v)
-
-#define PyStructSequence_GET_ITEM(op, i) PyTuple_GET_ITEM(op, i)
-#endif
-
-PyAPI_FUNC(void) PyStructSequence_SetItem(PyObject*, Py_ssize_t, PyObject*);
-PyAPI_FUNC(PyObject*) PyStructSequence_GetItem(PyObject*, Py_ssize_t);
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_STRUCTSEQ_H */

package/include/python3.8/symtable.h

@@ -1,123 +0,0 @@
-#ifndef Py_LIMITED_API
-#ifndef Py_SYMTABLE_H
-#define Py_SYMTABLE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "Python-ast.h"   /* mod_ty */
-
-/* XXX(ncoghlan): This is a weird mix of public names and interpreter internal
- *                names.
- */
-
-typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock }
-    _Py_block_ty;
-
-struct _symtable_entry;
-
-struct symtable {
-    PyObject *st_filename;          /* name of file being compiled,
-                                       decoded from the filesystem encoding */
-    struct _symtable_entry *st_cur; /* current symbol table entry */
-    struct _symtable_entry *st_top; /* symbol table entry for module */
-    PyObject *st_blocks;            /* dict: map AST node addresses
-                                     *       to symbol table entries */
-    PyObject *st_stack;             /* list: stack of namespace info */
-    PyObject *st_global;            /* borrowed ref to st_top->ste_symbols */
-    int st_nblocks;                 /* number of blocks used. kept for
-                                       consistency with the corresponding
-                                       compiler structure */
-    PyObject *st_private;           /* name of current class or NULL */
-    PyFutureFeatures *st_future;    /* module's future features that affect
-                                       the symbol table */
-    int recursion_depth;            /* current recursion depth */
-    int recursion_limit;            /* recursion limit */
-};
-
-typedef struct _symtable_entry {
-    PyObject_HEAD
-    PyObject *ste_id;        /* int: key in ste_table->st_blocks */
-    PyObject *ste_symbols;   /* dict: variable names to flags */
-    PyObject *ste_name;      /* string: name of current block */
-    PyObject *ste_varnames;  /* list of function parameters */
-    PyObject *ste_children;  /* list of child blocks */
-    PyObject *ste_directives;/* locations of global and nonlocal statements */
-    _Py_block_ty ste_type;   /* module, class, or function */
-    int ste_nested;      /* true if block is nested */
-    unsigned ste_free : 1;        /* true if block has free variables */
-    unsigned ste_child_free : 1;  /* true if a child block has free vars,
-                                     including free refs to globals */
-    unsigned ste_generator : 1;   /* true if namespace is a generator */
-    unsigned ste_coroutine : 1;   /* true if namespace is a coroutine */
-    unsigned ste_comprehension : 1; /* true if namespace is a list comprehension */
-    unsigned ste_varargs : 1;     /* true if block has varargs */
-    unsigned ste_varkeywords : 1; /* true if block has varkeywords */
-    unsigned ste_returns_value : 1;  /* true if namespace uses return with
-                                        an argument */
-    unsigned ste_needs_class_closure : 1; /* for class scopes, true if a
-                                             closure over __class__
-                                             should be created */
-    unsigned ste_comp_iter_target : 1; /* true if visiting comprehension target */
-    int ste_comp_iter_expr; /* non-zero if visiting a comprehension range expression */
-    int ste_lineno;          /* first line of block */
-    int ste_col_offset;      /* offset of first line of block */
-    int ste_opt_lineno;      /* lineno of last exec or import * */
-    int ste_opt_col_offset;  /* offset of last exec or import * */
-    struct symtable *ste_table;
-} PySTEntryObject;
-
-PyAPI_DATA(PyTypeObject) PySTEntry_Type;
-
-#define PySTEntry_Check(op) (Py_TYPE(op) == &PySTEntry_Type)
-
-PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *);
-
-PyAPI_FUNC(struct symtable *) PySymtable_Build(
-    mod_ty mod,
-    const char *filename,       /* decoded from the filesystem encoding */
-    PyFutureFeatures *future);
-PyAPI_FUNC(struct symtable *) PySymtable_BuildObject(
-    mod_ty mod,
-    PyObject *filename,
-    PyFutureFeatures *future);
-PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
-
-PyAPI_FUNC(void) PySymtable_Free(struct symtable *);
-
-/* Flags for def-use information */
-
-#define DEF_GLOBAL 1           /* global stmt */
-#define DEF_LOCAL 2            /* assignment in code block */
-#define DEF_PARAM 2<<1         /* formal parameter */
-#define DEF_NONLOCAL 2<<2      /* nonlocal stmt */
-#define USE 2<<3               /* name is used */
-#define DEF_FREE 2<<4          /* name used but not defined in nested block */
-#define DEF_FREE_CLASS 2<<5    /* free variable from class's method */
-#define DEF_IMPORT 2<<6        /* assignment occurred via import */
-#define DEF_ANNOT 2<<7         /* this name is annotated */
-#define DEF_COMP_ITER 2<<8     /* this name is a comprehension iteration variable */
-
-#define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT)
-
-/* GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol
-   table.  GLOBAL is returned from PyST_GetScope() for either of them.
-   It is stored in ste_symbols at bits 12-15.
-*/
-#define SCOPE_OFFSET 11
-#define SCOPE_MASK (DEF_GLOBAL | DEF_LOCAL | DEF_PARAM | DEF_NONLOCAL)
-
-#define LOCAL 1
-#define GLOBAL_EXPLICIT 2
-#define GLOBAL_IMPLICIT 3
-#define FREE 4
-#define CELL 5
-
-#define GENERATOR 1
-#define GENERATOR_EXPRESSION 2
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_SYMTABLE_H */
-#endif /* !Py_LIMITED_API */