#include "Python.h"
#include "Python-ast.h"
#include "code.h"
#include "symtable.h"
#include "structmember.h"

/* error strings used for warnings */
#define GLOBAL_AFTER_ASSIGN \
"name '%.400s' is assigned to before global declaration"

#define GLOBAL_AFTER_USE \
"name '%.400s' is used prior to global declaration"

#define IMPORT_STAR_WARNING "import * only allowed at module level"

#define RETURN_VAL_IN_GENERATOR \
    "'return' with argument inside generator"


static PySTEntryObject *
ste_new(struct symtable *st, identifier name, _Py_block_ty block,
              void *key, int lineno)
{
    PySTEntryObject *ste = NULL;
    PyObject *k;

    k = PyLong_FromVoidPtr(key);
    if (k == NULL)
        goto fail;
    ste = PyObject_New(PySTEntryObject, &PySTEntry_Type);
    if (ste == NULL)
        goto fail;
    ste->ste_table = st;
    ste->ste_id = k;

    ste->ste_name = name;
    Py_INCREF(name);

    ste->ste_symbols = NULL;
    ste->ste_varnames = NULL;
    ste->ste_children = NULL;

    ste->ste_symbols = PyDict_New();
    if (ste->ste_symbols == NULL)
        goto fail;

    ste->ste_varnames = PyList_New(0);
    if (ste->ste_varnames == NULL)
        goto fail;

    ste->ste_children = PyList_New(0);
    if (ste->ste_children == NULL)
        goto fail;

    ste->ste_type = block;
    ste->ste_unoptimized = 0;
    ste->ste_nested = 0;
    ste->ste_free = 0;
    ste->ste_varargs = 0;
    ste->ste_varkeywords = 0;
    ste->ste_opt_lineno = 0;
    ste->ste_lineno = lineno;

    if (st->st_cur != NULL &&
        (st->st_cur->ste_nested ||
         st->st_cur->ste_type == FunctionBlock))
        ste->ste_nested = 1;
    ste->ste_child_free = 0;
    ste->ste_generator = 0;
    ste->ste_returns_value = 0;

    if (PyDict_SetItem(st->st_symbols, ste->ste_id, (PyObject *)ste) < 0)
        goto fail;

    return ste;
 fail:
    Py_XDECREF(ste);
    return NULL;
}

static PyObject *
ste_repr(PySTEntryObject *ste)
{
    char buf[256];

    PyOS_snprintf(buf, sizeof(buf),
                  "<symtable entry %.100s(%ld), line %d>",
                  PyString_AS_STRING(ste->ste_name),
                  PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
    return PyString_FromString(buf);
}

static void
ste_dealloc(PySTEntryObject *ste)
{
    ste->ste_table = NULL;
    Py_XDECREF(ste->ste_id);
    Py_XDECREF(ste->ste_name);
    Py_XDECREF(ste->ste_symbols);
    Py_XDECREF(ste->ste_varnames);
    Py_XDECREF(ste->ste_children);
    PyObject_Del(ste);
}

#define OFF(x) offsetof(PySTEntryObject, x)

static PyMemberDef ste_memberlist[] = {
    {"id",       T_OBJECT, OFF(ste_id), READONLY},
    {"name",     T_OBJECT, OFF(ste_name), READONLY},
    {"symbols",  T_OBJECT, OFF(ste_symbols), READONLY},
    {"varnames", T_OBJECT, OFF(ste_varnames), READONLY},
    {"children", T_OBJECT, OFF(ste_children), READONLY},
    {"optimized",T_INT,    OFF(ste_unoptimized), READONLY},
    {"nested",   T_INT,    OFF(ste_nested), READONLY},
    {"type",     T_INT,    OFF(ste_type), READONLY},
    {"lineno",   T_INT,    OFF(ste_lineno), READONLY},
    {NULL}
};

PyTypeObject PySTEntry_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
    "symtable entry",
    sizeof(PySTEntryObject),
    0,
    (destructor)ste_dealloc,                /* tp_dealloc */
    0,                                      /* tp_print */
    0,                                         /* tp_getattr */
    0,                                          /* tp_setattr */
    0,                                          /* tp_compare */
    (reprfunc)ste_repr,                         /* tp_repr */
    0,                                          /* tp_as_number */
    0,                                          /* tp_as_sequence */
    0,                                          /* tp_as_mapping */
    0,                                          /* tp_hash */
    0,                                          /* tp_call */
    0,                                          /* tp_str */
    PyObject_GenericGetAttr,                    /* tp_getattro */
    0,                                          /* tp_setattro */
    0,                                          /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT,                         /* tp_flags */
    0,                                          /* tp_doc */
    0,                                          /* tp_traverse */
    0,                                          /* tp_clear */
    0,                                          /* tp_richcompare */
    0,                                          /* tp_weaklistoffset */
    0,                                          /* tp_iter */
    0,                                          /* tp_iternext */
    0,                                          /* tp_methods */
    ste_memberlist,                             /* tp_members */
    0,                                          /* tp_getset */
    0,                                          /* tp_base */
    0,                                          /* tp_dict */
    0,                                          /* tp_descr_get */
    0,                                          /* tp_descr_set */
    0,                                          /* tp_dictoffset */
    0,                                          /* tp_init */
    0,                                          /* tp_alloc */
    0,                                          /* tp_new */
};

static int symtable_analyze(struct symtable *st);
static int symtable_warn(struct symtable *st, char *msg, int lineno);
static int symtable_enter_block(struct symtable *st, identifier name,
                                _Py_block_ty block, void *ast, int lineno);
static int symtable_exit_block(struct symtable *st, void *ast);
static int symtable_visit_stmt(struct symtable *st, stmt_ty s);
static int symtable_visit_expr(struct symtable *st, expr_ty s);
static int symtable_visit_genexp(struct symtable *st, expr_ty s);
static int symtable_visit_setcomp(struct symtable *st, expr_ty e);
static int symtable_visit_dictcomp(struct symtable *st, expr_ty e);
static int symtable_visit_arguments(struct symtable *st, arguments_ty);
static int symtable_visit_excepthandler(struct symtable *st, excepthandler_ty);
static int symtable_visit_alias(struct symtable *st, alias_ty);
static int symtable_visit_comprehension(struct symtable *st, comprehension_ty);
static int symtable_visit_keyword(struct symtable *st, keyword_ty);
static int symtable_visit_slice(struct symtable *st, slice_ty);
static int symtable_visit_params(struct symtable *st, asdl_seq *args, int top);
static int symtable_visit_params_nested(struct symtable *st, asdl_seq *args);
static int symtable_implicit_arg(struct symtable *st, int pos);


static identifier top = NULL, lambda = NULL, genexpr = NULL, setcomp = NULL,
    dictcomp = NULL;

#define GET_IDENTIFIER(VAR) \
    ((VAR) ? (VAR) : ((VAR) = PyString_InternFromString(# VAR)))

#define DUPLICATE_ARGUMENT \
"duplicate argument '%s' in function definition"

static struct symtable *
symtable_new(void)
{
    struct symtable *st;

    st = (struct symtable *)PyMem_Malloc(sizeof(struct symtable));
    if (st == NULL)
        return NULL;

    st->st_filename = NULL;
    st->st_symbols = NULL;

    if ((st->st_stack = PyList_New(0)) == NULL)
        goto fail;
    if ((st->st_symbols = PyDict_New()) == NULL)
        goto fail;
    st->st_cur = NULL;
    st->st_private = NULL;
    return st;
 fail:
    PySymtable_Free(st);
    return NULL;
}

struct symtable *
PySymtable_Build(mod_ty mod, const char *filename, PyFutureFeatures *future)
{
    struct symtable *st = symtable_new();
    asdl_seq *seq;
    int i;

    if (st == NULL)
        return st;
    st->st_filename = filename;
    st->st_future = future;
    if (!GET_IDENTIFIER(top) ||
        !symtable_enter_block(st, top, ModuleBlock, (void *)mod, 0)) {
        PySymtable_Free(st);
        return NULL;
    }

    st->st_top = st->st_cur;
    st->st_cur->ste_unoptimized = OPT_TOPLEVEL;
    /* Any other top-level initialization? */
    switch (mod->kind) {
    case Module_kind:
        seq = mod->v.Module.body;
        for (i = 0; i < asdl_seq_LEN(seq); i++)
            if (!symtable_visit_stmt(st,
                        (stmt_ty)asdl_seq_GET(seq, i)))
                goto error;
        break;
    case Expression_kind:
        if (!symtable_visit_expr(st, mod->v.Expression.body))
            goto error;
        break;
    case Interactive_kind:
        seq = mod->v.Interactive.body;
        for (i = 0; i < asdl_seq_LEN(seq); i++)
            if (!symtable_visit_stmt(st,
                        (stmt_ty)asdl_seq_GET(seq, i)))
                goto error;
        break;
    case Suite_kind:
        PyErr_SetString(PyExc_RuntimeError,
                        "this compiler does not handle Suites");
        goto error;
    }
    if (!symtable_exit_block(st, (void *)mod)) {
        PySymtable_Free(st);
        return NULL;
    }
    if (symtable_analyze(st))
        return st;
    PySymtable_Free(st);
    return NULL;
 error:
    (void) symtable_exit_block(st, (void *)mod);
    PySymtable_Free(st);
    return NULL;
}

void
PySymtable_Free(struct symtable *st)
{
    Py_XDECREF(st->st_symbols);
    Py_XDECREF(st->st_stack);
    PyMem_Free((void *)st);
}

PySTEntryObject *
PySymtable_Lookup(struct symtable *st, void *key)
{
    PyObject *k, *v;

    k = PyLong_FromVoidPtr(key);
    if (k == NULL)
        return NULL;
    v = PyDict_GetItem(st->st_symbols, k);
    if (v) {
        assert(PySTEntry_Check(v));
        Py_INCREF(v);
    }
    else {
        PyErr_SetString(PyExc_KeyError,
                        "unknown symbol table entry");
    }

    Py_DECREF(k);
    return (PySTEntryObject *)v;
}

int
PyST_GetScope(PySTEntryObject *ste, PyObject *name)
{
    PyObject *v = PyDict_GetItem(ste->ste_symbols, name);
    if (!v)
        return 0;
    assert(PyInt_Check(v));
    return (PyInt_AS_LONG(v) >> SCOPE_OFF) & SCOPE_MASK;
}


/* Analyze raw symbol information to determine scope of each name.

   The next several functions are helpers for PySymtable_Analyze(),
   which determines whether a name is local, global, or free.  In addition,
   it determines which local variables are cell variables; they provide
   bindings that are used for free variables in enclosed blocks.

   There are also two kinds of free variables, implicit and explicit.  An
   explicit global is declared with the global statement.  An implicit
   global is a free variable for which the compiler has found no binding
   in an enclosing function scope.  The implicit global is either a global
   or a builtin.  Python's module and class blocks use the xxx_NAME opcodes
   to handle these names to implement slightly odd semantics.  In such a
   block, the name is treated as global until it is assigned to; then it
   is treated as a local.

   The symbol table requires two passes to determine the scope of each name.
   The first pass collects raw facts from the AST: the name is a parameter
   here, the name is used by not defined here, etc.  The second pass analyzes
   these facts during a pass over the PySTEntryObjects created during pass 1.

   When a function is entered during the second pass, the parent passes
   the set of all name bindings visible to its children.  These bindings
   are used to determine if the variable is free or an implicit global.
   After doing the local analysis, it analyzes each of its child blocks
   using an updated set of name bindings.

   The children update the free variable set.  If a local variable is free
   in a child, the variable is marked as a cell.  The current function must
   provide runtime storage for the variable that may outlive the function's
   frame.  Cell variables are removed from the free set before the analyze
   function returns to its parent.

   The sets of bound and free variables are implemented as dictionaries
   mapping strings to None.
*/

#define SET_SCOPE(DICT, NAME, I) { \
    PyObject *o = PyInt_FromLong(I); \
    if (!o) \
        return 0; \
    if (PyDict_SetItem((DICT), (NAME), o) < 0) { \
        Py_DECREF(o); \
        return 0; \
    } \
    Py_DECREF(o); \
}

/* Decide on scope of name, given flags.

   The namespace dictionaries may be modified to record information
   about the new name.  For example, a new global will add an entry to
   global.  A name that was global can be changed to local.
*/

static int
analyze_name(PySTEntryObject *ste, PyObject *dict, PyObject *name, long flags,
             PyObject *bound, PyObject *local, PyObject *free,
             PyObject *global)
{
    if (flags & DEF_GLOBAL) {
        if (flags & DEF_PARAM) {
            PyErr_Format(PyExc_SyntaxError,
                         "name '%s' is local and global",
                         PyString_AS_STRING(name));
            PyErr_SyntaxLocation(ste->ste_table->st_filename,
                                 ste->ste_lineno);

            return 0;
        }
        SET_SCOPE(dict, name, GLOBAL_EXPLICIT);
        if (PyDict_SetItem(global, name, Py_None) < 0)
            return 0;
        if (bound && PyDict_GetItem(bound, name)) {
            if (PyDict_DelItem(bound, name) < 0)
                return 0;
        }
        return 1;
    }
    if (flags & DEF_BOUND) {
        SET_SCOPE(dict, name, LOCAL);
        if (PyDict_SetItem(local, name, Py_None) < 0)
            return 0;
        if (PyDict_GetItem(global, name)) {
            if (PyDict_DelItem(global, name) < 0)
                return 0;
        }
        return 1;
    }
    /* If an enclosing block has a binding for this name, it
       is a free variable rather than a global variable.
       Note that having a non-NULL bound implies that the block
       is nested.
    */
    if (bound && PyDict_GetItem(bound, name)) {
        SET_SCOPE(dict, name, FREE);
        ste->ste_free = 1;
        if (PyDict_SetItem(free, name, Py_None) < 0)
            return 0;
        return 1;
    }
    /* If a parent has a global statement, then call it global
       explicit?  It could also be global implicit.
     */
    else if (global && PyDict_GetItem(global, name)) {
        SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
        return 1;
    }
    else {
        if (ste->ste_nested)
            ste->ste_free = 1;
        SET_SCOPE(dict, name, GLOBAL_IMPLICIT);
        return 1;
    }
    /* Should never get here. */
    PyErr_Format(PyExc_SystemError, "failed to set scope for %s",
                 PyString_AS_STRING(name));
    return 0;
}

#undef SET_SCOPE

/* If a name is defined in free and also in locals, then this block
   provides the binding for the free variable.  The name should be
   marked CELL in this block and removed from the free list.

   Note that the current block's free variables are included in free.
   That's safe because no name can be free and local in the same scope.
*/

static int
analyze_cells(PyObject *scope, PyObject *free)
{
    PyObject *name, *v, *w;
    int success = 0;
    Py_ssize_t pos = 0;

    w = PyInt_FromLong(CELL);
    if (!w)
        return 0;
    while (PyDict_Next(scope, &pos, &name, &v)) {
        long flags;
        assert(PyInt_Check(v));
        flags = PyInt_AS_LONG(v);
        if (flags != LOCAL)
            continue;
        if (!PyDict_GetItem(free, name))
            continue;
        /* Replace LOCAL with CELL for this name, and remove
           from free. It is safe to replace the value of name
           in the dict, because it will not cause a resize.
         */
        if (PyDict_SetItem(scope, name, w) < 0)
            goto error;
        if (!PyDict_DelItem(free, name) < 0)
            goto error;
    }
    success = 1;
 error:
    Py_DECREF(w);
    return success;
}

/* Check for illegal statements in unoptimized namespaces */
static int
check_unoptimized(const PySTEntryObject* ste) {
    char buf[300];
    const char* trailer;

    if (ste->ste_type != FunctionBlock || !ste->ste_unoptimized
        || !(ste->ste_free || ste->ste_child_free))
        return 1;

    trailer = (ste->ste_child_free ?
                   "contains a nested function with free variables" :
                   "is a nested function");

    switch (ste->ste_unoptimized) {
    case OPT_TOPLEVEL: /* exec / import * at top-level is fine */
    case OPT_EXEC: /* qualified exec is fine */
        return 1;
    case OPT_IMPORT_STAR:
        PyOS_snprintf(buf, sizeof(buf),
                      "import * is not allowed in function '%.100s' "
                      "because it %s",
                      PyString_AS_STRING(ste->ste_name), trailer);
        break;
    case OPT_BARE_EXEC:
        PyOS_snprintf(buf, sizeof(buf),
                      "unqualified exec is not allowed in function "
                      "'%.100s' it %s",
                      PyString_AS_STRING(ste->ste_name), trailer);
        break;
    default:
        PyOS_snprintf(buf, sizeof(buf),
                      "function '%.100s' uses import * and bare exec, "
                      "which are illegal because it %s",
                      PyString_AS_STRING(ste->ste_name), trailer);
        break;
    }

    PyErr_SetString(PyExc_SyntaxError, buf);
    PyErr_SyntaxLocation(ste->ste_table->st_filename,
                         ste->ste_opt_lineno);
    return 0;
}

/* Enter the final scope information into the st_symbols dict.
 *
 * All arguments are dicts.  Modifies symbols, others are read-only.
*/
static int
update_symbols(PyObject *symbols, PyObject *scope,
               PyObject *bound, PyObject *free, int classflag)
{
    PyObject *name, *v, *u, *w, *free_value = NULL;
    Py_ssize_t pos = 0;

    while (PyDict_Next(symbols, &pos, &name, &v)) {
        long i, flags;
        assert(PyInt_Check(v));
        flags = PyInt_AS_LONG(v);
        w = PyDict_GetItem(scope, name);
        assert(w && PyInt_Check(w));
        i = PyInt_AS_LONG(w);
        flags |= (i << SCOPE_OFF);
        u = PyInt_FromLong(flags);
        if (!u)
            return 0;
        if (PyDict_SetItem(symbols, name, u) < 0) {
            Py_DECREF(u);
            return 0;
        }
        Py_DECREF(u);
    }

    free_value = PyInt_FromLong(FREE << SCOPE_OFF);
    if (!free_value)
        return 0;

    /* add a free variable when it's only use is for creating a closure */
    pos = 0;
    while (PyDict_Next(free, &pos, &name, &v)) {
        PyObject *o = PyDict_GetItem(symbols, name);

        if (o) {
            /* It could be a free variable in a method of
               the class that has the same name as a local
               or global in the class scope.
            */
            if  (classflag &&
                 PyInt_AS_LONG(o) & (DEF_BOUND | DEF_GLOBAL)) {
                long i = PyInt_AS_LONG(o) | DEF_FREE_CLASS;
                o = PyInt_FromLong(i);
                if (!o) {
                    Py_DECREF(free_value);
                    return 0;
                }
                if (PyDict_SetItem(symbols, name, o) < 0) {
                    Py_DECREF(o);
                    Py_DECREF(free_value);
                    return 0;
                }
                Py_DECREF(o);
            }
            /* else it's not free, probably a cell */
            continue;
        }
        if (!PyDict_GetItem(bound, name))
            continue;       /* it's a global */

        if (PyDict_SetItem(symbols, name, free_value) < 0) {
            Py_DECREF(free_value);
            return 0;
        }
    }
    Py_DECREF(free_value);
    return 1;
}

/* Make final symbol table decisions for block of ste.

   Arguments:
   ste -- current symtable entry (input/output)
   bound -- set of variables bound in enclosing scopes (input).  bound
       is NULL for module blocks.
   free -- set of free variables in enclosed scopes (output)
   globals -- set of declared global variables in enclosing scopes (input)

   The implementation uses two mutually recursive functions,
   analyze_block() and analyze_child_block().  analyze_block() is
   responsible for analyzing the individual names defined in a block.
   analyze_child_block() prepares temporary namespace dictionaries
   used to evaluated nested blocks.

   The two functions exist because a child block should see the name
   bindings of its enclosing blocks, but those bindings should not
   propagate back to a parent block.
*/

static int
analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
                    PyObject *global, PyObject* child_free);

static int
analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
              PyObject *global)
{
    PyObject *name, *v, *local = NULL, *scope = NULL;
    PyObject *newbound = NULL, *newglobal = NULL;
    PyObject *newfree = NULL, *allfree = NULL;
    int i, success = 0;
    Py_ssize_t pos = 0;

    local = PyDict_New();  /* collect new names bound in block */
    if (!local)
        goto error;
    scope = PyDict_New(); /* collect scopes defined for each name */
    if (!scope)
        goto error;

    /* Allocate new global and bound variable dictionaries.  These
       dictionaries hold the names visible in nested blocks.  For
       ClassBlocks, the bound and global names are initialized
       before analyzing names, because class bindings aren't
       visible in methods.  For other blocks, they are initialized
       after names are analyzed.
     */

    /* TODO(jhylton): Package these dicts in a struct so that we
       can write reasonable helper functions?
    */
    newglobal = PyDict_New();
    if (!newglobal)
        goto error;
    newbound = PyDict_New();
    if (!newbound)
        goto error;
    newfree = PyDict_New();
    if (!newfree)
        goto error;

    if (ste->ste_type == ClassBlock) {
        if (PyDict_Update(newglobal, global) < 0)
            goto error;
        if (bound)
            if (PyDict_Update(newbound, bound) < 0)
                goto error;
    }

    while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
        long flags = PyInt_AS_LONG(v);
        if (!analyze_name(ste, scope, name, flags,
                          bound, local, free, global))
            goto error;
    }

    if (ste->ste_type != ClassBlock) {
        if (ste->ste_type == FunctionBlock) {
            if (PyDict_Update(newbound, local) < 0)
                goto error;
        }
        if (bound) {
            if (PyDict_Update(newbound, bound) < 0)
                goto error;
        }
        if (PyDict_Update(newglobal, global) < 0)
            goto error;
    }

    /* Recursively call analyze_block() on each child block.

       newbound, newglobal now contain the names visible in
       nested blocks.  The free variables in the children will
       be collected in allfree.
    */
    allfree = PyDict_New();
    if (!allfree)
        goto error;
    for (i = 0; i < PyList_GET_SIZE(ste->ste_children); ++i) {
        PyObject *c = PyList_GET_ITEM(ste->ste_children, i);
        PySTEntryObject* entry;
        assert(c && PySTEntry_Check(c));
        entry = (PySTEntryObject*)c;
        if (!analyze_child_block(entry, newbound, newfree, newglobal,
                                 allfree))
            goto error;
        if (entry->ste_free || entry->ste_child_free)
            ste->ste_child_free = 1;
    }

    if (PyDict_Update(newfree, allfree) < 0)
        goto error;
    if (ste->ste_type == FunctionBlock && !analyze_cells(scope, newfree))
        goto error;
    if (!update_symbols(ste->ste_symbols, scope, bound, newfree,
                        ste->ste_type == ClassBlock))
        goto error;
    if (!check_unoptimized(ste))
        goto error;

    if (PyDict_Update(free, newfree) < 0)
        goto error;
    success = 1;
 error:
    Py_XDECREF(local);
    Py_XDECREF(scope);
    Py_XDECREF(newbound);
    Py_XDECREF(newglobal);
    Py_XDECREF(newfree);
    Py_XDECREF(allfree);
    if (!success)
        assert(PyErr_Occurred());
    return success;
}

static int
analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
                    PyObject *global, PyObject* child_free)
{
    PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL;

    /* Copy the bound and global dictionaries.

       These dictionary are used by all blocks enclosed by the
       current block.  The analyze_block() call modifies these
       dictionaries.

    */
    temp_bound = PyDict_New();
    if (!temp_bound)
        goto error;
    if (PyDict_Update(temp_bound, bound) < 0)
        goto error;
    temp_free = PyDict_New();
    if (!temp_free)
        goto error;
    if (PyDict_Update(temp_free, free) < 0)
        goto error;
    temp_global = PyDict_New();
    if (!temp_global)
        goto error;
    if (PyDict_Update(temp_global, global) < 0)
        goto error;

    if (!analyze_block(entry, temp_bound, temp_free, temp_global))
        goto error;
    if (PyDict_Update(child_free, temp_free) < 0)
        goto error;
    Py_DECREF(temp_bound);
    Py_DECREF(temp_free);
    Py_DECREF(temp_global);
    return 1;
 error:
    Py_XDECREF(temp_bound);
    Py_XDECREF(temp_free);
    Py_XDECREF(temp_global);
    return 0;
}

static int
symtable_analyze(struct symtable *st)
{
    PyObject *free, *global;
    int r;

    free = PyDict_New();
    if (!free)
        return 0;
    global = PyDict_New();
    if (!global) {
        Py_DECREF(free);
        return 0;
    }
    r = analyze_block(st->st_top, NULL, free, global);
    Py_DECREF(free);
    Py_DECREF(global);
    return r;
}


static int
symtable_warn(struct symtable *st, char *msg, int lineno)
{
    if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, st->st_filename,
                           lineno, NULL, NULL) < 0)     {
        if (PyErr_ExceptionMatches(PyExc_SyntaxWarning)) {
            PyErr_SetString(PyExc_SyntaxError, msg);
            PyErr_SyntaxLocation(st->st_filename,
                                 st->st_cur->ste_lineno);
        }
        return 0;
    }
    return 1;
}

/* symtable_enter_block() gets a reference via ste_new.
   This reference is released when the block is exited, via the DECREF
   in symtable_exit_block().
*/

static int
symtable_exit_block(struct symtable *st, void *ast)
{
    Py_ssize_t end;

    Py_CLEAR(st->st_cur);
    end = PyList_GET_SIZE(st->st_stack) - 1;
    if (end >= 0) {
        st->st_cur = (PySTEntryObject *)PyList_GET_ITEM(st->st_stack,
                                                        end);
        if (st->st_cur == NULL)
            return 0;
        Py_INCREF(st->st_cur);
        if (PySequence_DelItem(st->st_stack, end) < 0)
            return 0;
    }
    return 1;
}

static int
symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,
                     void *ast, int lineno)
{
    PySTEntryObject *prev = NULL;

    if (st->st_cur) {
        prev = st->st_cur;
        if (PyList_Append(st->st_stack, (PyObject *)st->st_cur) < 0) {
            return 0;
        }
        Py_DECREF(st->st_cur);
    }
    st->st_cur = ste_new(st, name, block, ast, lineno);
    if (st->st_cur == NULL)
        return 0;
    if (name == GET_IDENTIFIER(top))
        st->st_global = st->st_cur->ste_symbols;
    if (prev) {
        if (PyList_Append(prev->ste_children,
                          (PyObject *)st->st_cur) < 0) {
            return 0;
        }
    }
    return 1;
}

static long
symtable_lookup(struct symtable *st, PyObject *name)
{
    PyObject *o;
    PyObject *mangled = _Py_Mangle(st->st_private, name);
    if (!mangled)
        return 0;
    o = PyDict_GetItem(st->st_cur->ste_symbols, mangled);
    Py_DECREF(mangled);
    if (!o)
        return 0;
    return PyInt_AsLong(o);
}

static int
symtable_add_def(struct symtable *st, PyObject *name, int flag)
{
    PyObject *o;
    PyObject *dict;
    long val;
    PyObject *mangled = _Py_Mangle(st->st_private, name);

    if (!mangled)
        return 0;
    dict = st->st_cur->ste_symbols;
    if ((o = PyDict_GetItem(dict, mangled))) {
        val = PyInt_AS_LONG(o);
        if ((flag & DEF_PARAM) && (val & DEF_PARAM)) {
            /* Is it better to use 'mangled' or 'name' here? */
            PyErr_Format(PyExc_SyntaxError, DUPLICATE_ARGUMENT,
                         PyString_AsString(name));
            PyErr_SyntaxLocation(st->st_filename,
                               st->st_cur->ste_lineno);
            goto error;
        }
        val |= flag;
    } else
        val = flag;
    o = PyInt_FromLong(val);
    if (o == NULL)
        goto error;
    if (PyDict_SetItem(dict, mangled, o) < 0) {
        Py_DECREF(o);
        goto error;
    }
    Py_DECREF(o);

    if (flag & DEF_PARAM) {
        if (PyList_Append(st->st_cur->ste_varnames, mangled) < 0)
            goto error;
    } else      if (flag & DEF_GLOBAL) {
        /* XXX need to update DEF_GLOBAL for other flags too;
           perhaps only DEF_FREE_GLOBAL */
        val = flag;
        if ((o = PyDict_GetItem(st->st_global, mangled))) {
            val |= PyInt_AS_LONG(o);
        }
        o = PyInt_FromLong(val);
        if (o == NULL)
            goto error;
        if (PyDict_SetItem(st->st_global, mangled, o) < 0) {
            Py_DECREF(o);
            goto error;
        }
        Py_DECREF(o);
    }
    Py_DECREF(mangled);
    return 1;

error:
    Py_DECREF(mangled);
    return 0;
}

/* VISIT, VISIT_SEQ and VIST_SEQ_TAIL take an ASDL type as their second argument.
   They use the ASDL name to synthesize the name of the C type and the visit
   function.

   VISIT_SEQ_TAIL permits the start of an ASDL sequence to be skipped, which is
   useful if the first node in the sequence requires special treatment.
*/

#define VISIT(ST, TYPE, V) \
    if (!symtable_visit_ ## TYPE((ST), (V))) \
        return 0;

#define VISIT_IN_BLOCK(ST, TYPE, V, S) \
    if (!symtable_visit_ ## TYPE((ST), (V))) { \
        symtable_exit_block((ST), (S)); \
        return 0; \
    }

#define VISIT_SEQ(ST, TYPE, SEQ) { \
    int i; \
    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
    for (i = 0; i < asdl_seq_LEN(seq); i++) { \
        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
        if (!symtable_visit_ ## TYPE((ST), elt)) \
            return 0; \
    } \
}

#define VISIT_SEQ_IN_BLOCK(ST, TYPE, SEQ, S) { \
    int i; \
    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
    for (i = 0; i < asdl_seq_LEN(seq); i++) { \
        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
        if (!symtable_visit_ ## TYPE((ST), elt)) { \
            symtable_exit_block((ST), (S)); \
            return 0; \
        } \
    } \
}

#define VISIT_SEQ_TAIL(ST, TYPE, SEQ, START) { \
    int i; \
    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
    for (i = (START); i < asdl_seq_LEN(seq); i++) { \
        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
        if (!symtable_visit_ ## TYPE((ST), elt)) \
            return 0; \
    } \
}

#define VISIT_SEQ_TAIL_IN_BLOCK(ST, TYPE, SEQ, START, S) { \
    int i; \
    asdl_seq *seq = (SEQ); /* avoid variable capture */ \
    for (i = (START); i < asdl_seq_LEN(seq); i++) { \
        TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, i); \
        if (!symtable_visit_ ## TYPE((ST), elt)) { \
            symtable_exit_block((ST), (S)); \
            return 0; \
        } \
    } \
}

static int
symtable_visit_stmt(struct symtable *st, stmt_ty s)
{
    switch (s->kind) {
    case FunctionDef_kind:
        if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL))
            return 0;
        if (s->v.FunctionDef.args->defaults)
            VISIT_SEQ(st, expr, s->v.FunctionDef.args->defaults);
        if (s->v.FunctionDef.decorator_list)
            VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list);
        if (!symtable_enter_block(st, s->v.FunctionDef.name,
                                  FunctionBlock, (void *)s, s->lineno))
            return 0;
        VISIT_IN_BLOCK(st, arguments, s->v.FunctionDef.args, s);
        VISIT_SEQ_IN_BLOCK(st, stmt, s->v.FunctionDef.body, s);
        if (!symtable_exit_block(st, s))
            return 0;
        break;
    case ClassDef_kind: {
        PyObject *tmp;
        if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL))
            return 0;
        VISIT_SEQ(st, expr, s->v.ClassDef.bases);
        if (s->v.ClassDef.decorator_list)
            VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list);
        if (!symtable_enter_block(st, s->v.ClassDef.name, ClassBlock,
                                  (void *)s, s->lineno))
            return 0;
        tmp = st->st_private;
        st->st_private = s->v.ClassDef.name;
        VISIT_SEQ_IN_BLOCK(st, stmt, s->v.ClassDef.body, s);
        st->st_private = tmp;
        if (!symtable_exit_block(st, s))
            return 0;
        break;
    }
    case Return_kind:
        if (s->v.Return.value) {
            VISIT(st, expr, s->v.Return.value);
            st->st_cur->ste_returns_value = 1;
            if (st->st_cur->ste_generator) {
                PyErr_SetString(PyExc_SyntaxError,
                    RETURN_VAL_IN_GENERATOR);
                PyErr_SyntaxLocation(st->st_filename,
                             s->lineno);
                return 0;
            }
        }
        break;
    case Delete_kind:
        VISIT_SEQ(st, expr, s->v.Delete.targets);
        break;
    case Assign_kind:
        VISIT_SEQ(st, expr, s->v.Assign.targets);
        VISIT(st, expr, s->v.Assign.value);
        break;
    case AugAssign_kind:
        VISIT(st, expr, s->v.AugAssign.target);
        VISIT(st, expr, s->v.AugAssign.value);
        break;
    case Print_kind:
        if (s->v.Print.dest)
            VISIT(st, expr, s->v.Print.dest);
        VISIT_SEQ(st, expr, s->v.Print.values);
        break;
    case For_kind:
        VISIT(st, expr, s->v.For.target);
        VISIT(st, expr, s->v.For.iter);
        VISIT_SEQ(st, stmt, s->v.For.body);
        if (s->v.For.orelse)
            VISIT_SEQ(st, stmt, s->v.For.orelse);
        break;
    case While_kind:
        VISIT(st, expr, s->v.While.test);
        VISIT_SEQ(st, stmt, s->v.While.body);
        if (s->v.While.orelse)
            VISIT_SEQ(st, stmt, s->v.While.orelse);
        break;
    case If_kind:
        /* XXX if 0: and lookup_yield() hacks */
        VISIT(st, expr, s->v.If.test);
        VISIT_SEQ(st, stmt, s->v.If.body);
        if (s->v.If.orelse)
            VISIT_SEQ(st, stmt, s->v.If.orelse);
        break;
    case Raise_kind:
        if (s->v.Raise.type) {
            VISIT(st, expr, s->v.Raise.type);
            if (s->v.Raise.inst) {
                VISIT(st, expr, s->v.Raise.inst);
                if (s->v.Raise.tback)
                    VISIT(st, expr, s->v.Raise.tback);
            }
        }
        break;
    case TryExcept_kind:
        VISIT_SEQ(st, stmt, s->v.TryExcept.body);
        VISIT_SEQ(st, stmt, s->v.TryExcept.orelse);
        VISIT_SEQ(st, excepthandler, s->v.TryExcept.handlers);
        break;
    case TryFinally_kind:
        VISIT_SEQ(st, stmt, s->v.TryFinally.body);
        VISIT_SEQ(st, stmt, s->v.TryFinally.finalbody);
        break;
    case Assert_kind:
        VISIT(st, expr, s->v.Assert.test);
        if (s->v.Assert.msg)
            VISIT(st, expr, s->v.Assert.msg);
        break;
    case Import_kind:
        VISIT_SEQ(st, alias, s->v.Import.names);
        /* XXX Don't have the lineno available inside
           visit_alias */
        if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
            st->st_cur->ste_opt_lineno = s->lineno;
        break;
    case ImportFrom_kind:
        VISIT_SEQ(st, alias, s->v.ImportFrom.names);
        /* XXX Don't have the lineno available inside
           visit_alias */
        if (st->st_cur->ste_unoptimized && !st->st_cur->ste_opt_lineno)
            st->st_cur->ste_opt_lineno = s->lineno;
        break;
    case Exec_kind:
        VISIT(st, expr, s->v.Exec.body);
        if (!st->st_cur->ste_opt_lineno)
            st->st_cur->ste_opt_lineno = s->lineno;
        if (s->v.Exec.globals) {
            st->st_cur->ste_unoptimized |= OPT_EXEC;
            VISIT(st, expr, s->v.Exec.globals);
            if (s->v.Exec.locals)
                VISIT(st, expr, s->v.Exec.locals);
        } else {
            st->st_cur->ste_unoptimized |= OPT_BARE_EXEC;
        }
        break;
    case Global_kind: {
        int i;
        asdl_seq *seq = s->v.Global.names;
        for (i = 0; i < asdl_seq_LEN(seq); i++) {
            identifier name = (identifier)asdl_seq_GET(seq, i);
            char *c_name = PyString_AS_STRING(name);
            long cur = symtable_lookup(st, name);
            if (cur < 0)
                return 0;
            if (cur & (DEF_LOCAL | USE)) {
                char buf[256];
                if (cur & DEF_LOCAL)
                    PyOS_snprintf(buf, sizeof(buf),
                                  GLOBAL_AFTER_ASSIGN,
                                  c_name);
                else
                    PyOS_snprintf(buf, sizeof(buf),
                                  GLOBAL_AFTER_USE,
                                  c_name);
                if (!symtable_warn(st, buf, s->lineno))
                    return 0;
            }
            if (!symtable_add_def(st, name, DEF_GLOBAL))
                return 0;
        }
        break;
    }
    case Expr_kind:
        VISIT(st, expr, s->v.Expr.value);
        break;
    case Pass_kind:
    case Break_kind:
    case Continue_kind:
        /* nothing to do here */
        break;
    case With_kind:
        VISIT(st, expr, s->v.With.context_expr);
        if (s->v.With.optional_vars) {
            VISIT(st, expr, s->v.With.optional_vars);
        }
        VISIT_SEQ(st, stmt, s->v.With.body);
        break;
    }
    return 1;
}

static int
symtable_visit_expr(struct symtable *st, expr_ty e)
{
    switch (e->kind) {
    case BoolOp_kind:
        VISIT_SEQ(st, expr, e->v.BoolOp.values);
        break;
    case BinOp_kind:
        VISIT(st, expr, e->v.BinOp.left);
        VISIT(st, expr, e->v.BinOp.right);
        break;
    case UnaryOp_kind:
        VISIT(st, expr, e->v.UnaryOp.operand);
        break;
    case Lambda_kind: {
        if (!GET_IDENTIFIER(lambda))
            return 0;
        if (e->v.Lambda.args->defaults)
            VISIT_SEQ(st, expr, e->v.Lambda.args->defaults);
        if (!symtable_enter_block(st, lambda,
                                  FunctionBlock, (void *)e, e->lineno))
            return 0;
        VISIT_IN_BLOCK(st, arguments, e->v.Lambda.args, (void*)e);
        VISIT_IN_BLOCK(st, expr, e->v.Lambda.body, (void*)e);
        if (!symtable_exit_block(st, (void *)e))
            return 0;
        break;
    }
    case IfExp_kind:
        VISIT(st, expr, e->v.IfExp.test);
        VISIT(st, expr, e->v.IfExp.body);
        VISIT(st, expr, e->v.IfExp.orelse);
        break;
    case Dict_kind:
        VISIT_SEQ(st, expr, e->v.Dict.keys);
        VISIT_SEQ(st, expr, e->v.Dict.values);
        break;
    case Set_kind:
        VISIT_SEQ(st, expr, e->v.Set.elts);
        break;
    case ListComp_kind:
        VISIT(st, expr, e->v.ListComp.elt);
        VISIT_SEQ(st, comprehension, e->v.ListComp.generators);
        break;
    case GeneratorExp_kind:
        if (!symtable_visit_genexp(st, e))
            return 0;
        break;
    case SetComp_kind:
        if (!symtable_visit_setcomp(st, e))
            return 0;
        break;
    case DictComp_kind:
        if (!symtable_visit_dictcomp(st, e))
            return 0;
        break;
    case Yield_kind:
        if (e->v.Yield.value)
            VISIT(st, expr, e->v.Yield.value);
        st->st_cur->ste_generator = 1;
        if (st->st_cur->ste_returns_value) {
            PyErr_SetString(PyExc_SyntaxError,
                RETURN_VAL_IN_GENERATOR);
            PyErr_SyntaxLocation(st->st_filename,
                         e->lineno);
            return 0;
        }
        break;
    case Compare_kind:
        VISIT(st, expr, e->v.Compare.left);
        VISIT_SEQ(st, expr, e->v.Compare.comparators);
        break;
    case Call_kind:
        VISIT(st, expr, e->v.Call.func);
        VISIT_SEQ(st, expr, e->v.Call.args);
        VISIT_SEQ(st, keyword, e->v.Call.keywords);
        if (e->v.Call.starargs)
            VISIT(st, expr, e->v.Call.starargs);
        if (e->v.Call.kwargs)
            VISIT(st, expr, e->v.Call.kwargs);
        break;
    case Repr_kind:
        VISIT(st, expr, e->v.Repr.value);
        break;
    case Num_kind:
    case Str_kind:
        /* Nothing to do here. */
        break;
    /* The following exprs can be assignment targets. */
    case Attribute_kind:
        VISIT(st, expr, e->v.Attribute.value);
        break;
    case Subscript_kind:
        VISIT(st, expr, e->v.Subscript.value);
        VISIT(st, slice, e->v.Subscript.slice);
        break;
    case Name_kind:
        if (!symtable_add_def(st, e->v.Name.id,
                              e->v.Name.ctx == Load ? USE : DEF_LOCAL))
            return 0;
        break;
    /* child nodes of List and Tuple will have expr_context set */
    case List_kind:
        VISIT_SEQ(st, expr, e->v.List.elts);
        break;
    case Tuple_kind:
        VISIT_SEQ(st, expr, e->v.Tuple.elts);
        break;
    }
    return 1;
}

static int
symtable_implicit_arg(struct symtable *st, int pos)
{
    PyObject *id = PyString_FromFormat(".%d", pos);
    if (id == NULL)
        return 0;
    if (!symtable_add_def(st, id, DEF_PARAM)) {
        Py_DECREF(id);
        return 0;
    }
    Py_DECREF(id);
    return 1;
}

static int
symtable_visit_params(struct symtable *st, asdl_seq *args, int toplevel)
{
    int i;

    /* go through all the toplevel arguments first */
    for (i = 0; i < asdl_seq_LEN(args); i++) {
        expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
        if (arg->kind == Name_kind) {
            assert(arg->v.Name.ctx == Param ||
                   (arg->v.Name.ctx == Store && !toplevel));
            if (!symtable_add_def(st, arg->v.Name.id, DEF_PARAM))
                return 0;
        }
        else if (arg->kind == Tuple_kind) {
            assert(arg->v.Tuple.ctx == Store);
            if (toplevel) {
                if (!symtable_implicit_arg(st, i))
                    return 0;
            }
        }
        else {
            PyErr_SetString(PyExc_SyntaxError,
                            "invalid expression in parameter list");
            PyErr_SyntaxLocation(st->st_filename,
                                 st->st_cur->ste_lineno);
            return 0;
        }
    }

    if (!toplevel) {
        if (!symtable_visit_params_nested(st, args))
            return 0;
    }

    return 1;
}

static int
symtable_visit_params_nested(struct symtable *st, asdl_seq *args)
{
    int i;
    for (i = 0; i < asdl_seq_LEN(args); i++) {
        expr_ty arg = (expr_ty)asdl_seq_GET(args, i);
        if (arg->kind == Tuple_kind &&
            !symtable_visit_params(st, arg->v.Tuple.elts, 0))
            return 0;
    }

    return 1;
}

static int
symtable_visit_arguments(struct symtable *st, arguments_ty a)
{
    /* skip default arguments inside function block
       XXX should ast be different?
    */
    if (a->args && !symtable_visit_params(st, a->args, 1))
        return 0;
    if (a->vararg) {
        if (!symtable_add_def(st, a->vararg, DEF_PARAM))
            return 0;
        st->st_cur->ste_varargs = 1;
    }
    if (a->kwarg) {
        if (!symtable_add_def(st, a->kwarg, DEF_PARAM))
            return 0;
        st->st_cur->ste_varkeywords = 1;
    }
    if (a->args && !symtable_visit_params_nested(st, a->args))
        return 0;
    return 1;
}


static int
symtable_visit_excepthandler(struct symtable *st, excepthandler_ty eh)
{
    if (eh->v.ExceptHandler.type)
        VISIT(st, expr, eh->v.ExceptHandler.type);
    if (eh->v.ExceptHandler.name)
        VISIT(st, expr, eh->v.ExceptHandler.name);
    VISIT_SEQ(st, stmt, eh->v.ExceptHandler.body);
    return 1;
}


static int
symtable_visit_alias(struct symtable *st, alias_ty a)
{
    /* Compute store_name, the name actually bound by the import
       operation.  It is diferent than a->name when a->name is a
       dotted package name (e.g. spam.eggs)
    */
    PyObject *store_name;
    PyObject *name = (a->asname == NULL) ? a->name : a->asname;
    const char *base = PyString_AS_STRING(name);
    char *dot = strchr(base, '.');
    if (dot) {
        store_name = PyString_FromStringAndSize(base, dot - base);
        if (!store_name)
            return 0;
    }
    else {
        store_name = name;
        Py_INCREF(store_name);
    }
    if (strcmp(PyString_AS_STRING(name), "*")) {
        int r = symtable_add_def(st, store_name, DEF_IMPORT);
        Py_DECREF(store_name);
        return r;
    }
    else {
        if (st->st_cur->ste_type != ModuleBlock) {
        int lineno = st->st_cur->ste_lineno;
        if (!symtable_warn(st, IMPORT_STAR_WARNING, lineno)) {
            Py_DECREF(store_name);
            return 0;
        }
        }
        st->st_cur->ste_unoptimized |= OPT_IMPORT_STAR;
        Py_DECREF(store_name);
        return 1;
    }
}


static int
symtable_visit_comprehension(struct symtable *st, comprehension_ty lc)
{
    VISIT(st, expr, lc->target);
    VISIT(st, expr, lc->iter);
    VISIT_SEQ(st, expr, lc->ifs);
    return 1;
}


static int
symtable_visit_keyword(struct symtable *st, keyword_ty k)
{
    VISIT(st, expr, k->value);
    return 1;
}


static int
symtable_visit_slice(struct symtable *st, slice_ty s)
{
    switch (s->kind) {
    case Slice_kind:
        if (s->v.Slice.lower)
            VISIT(st, expr, s->v.Slice.lower)
        if (s->v.Slice.upper)
            VISIT(st, expr, s->v.Slice.upper)
        if (s->v.Slice.step)
            VISIT(st, expr, s->v.Slice.step)
        break;
    case ExtSlice_kind:
        VISIT_SEQ(st, slice, s->v.ExtSlice.dims)
        break;
    case Index_kind:
        VISIT(st, expr, s->v.Index.value)
        break;
    case Ellipsis_kind:
        break;
    }
    return 1;
}

static int
symtable_new_tmpname(struct symtable *st)
{
    char tmpname[256];
    identifier tmp;

    PyOS_snprintf(tmpname, sizeof(tmpname), "_[%d]",
                  ++st->st_cur->ste_tmpname);
    tmp = PyString_InternFromString(tmpname);
    if (!tmp)
        return 0;
    if (!symtable_add_def(st, tmp, DEF_LOCAL))
        return 0;
    Py_DECREF(tmp);
    return 1;
}

static int
symtable_handle_comprehension(struct symtable *st, expr_ty e,
                              identifier scope_name, asdl_seq *generators,
                              expr_ty elt, expr_ty value)
{
    int is_generator = (e->kind == GeneratorExp_kind);
    int needs_tmp = !is_generator;
    comprehension_ty outermost = ((comprehension_ty)
                                    asdl_seq_GET(generators, 0));
    /* Outermost iterator is evaluated in current scope */
    VISIT(st, expr, outermost->iter);
    /* Create comprehension scope for the rest */
    if (!scope_name ||
        !symtable_enter_block(st, scope_name, FunctionBlock, (void *)e, 0)) {
        return 0;
    }
    st->st_cur->ste_generator = is_generator;
    /* Outermost iter is received as an argument */
    if (!symtable_implicit_arg(st, 0)) {
        symtable_exit_block(st, (void *)e);
        return 0;
    }
    /* Allocate temporary name if needed */
    if (needs_tmp && !symtable_new_tmpname(st)) {
        symtable_exit_block(st, (void *)e);
        return 0;
    }
    VISIT_IN_BLOCK(st, expr, outermost->target, (void*)e);
    VISIT_SEQ_IN_BLOCK(st, expr, outermost->ifs, (void*)e);
    VISIT_SEQ_TAIL_IN_BLOCK(st, comprehension,
                            generators, 1, (void*)e);
    if (value)
        VISIT_IN_BLOCK(st, expr, value, (void*)e);
    VISIT_IN_BLOCK(st, expr, elt, (void*)e);
    return symtable_exit_block(st, (void *)e);
}

static int
symtable_visit_genexp(struct symtable *st, expr_ty e)
{
    return symtable_handle_comprehension(st, e, GET_IDENTIFIER(genexpr),
                                         e->v.GeneratorExp.generators,
                                         e->v.GeneratorExp.elt, NULL);
}

static int
symtable_visit_setcomp(struct symtable *st, expr_ty e)
{
    return symtable_handle_comprehension(st, e, GET_IDENTIFIER(setcomp),
                                         e->v.SetComp.generators,
                                         e->v.SetComp.elt, NULL);
}

static int
symtable_visit_dictcomp(struct symtable *st, expr_ty e)
{
    return symtable_handle_comprehension(st, e, GET_IDENTIFIER(dictcomp),
                                         e->v.DictComp.generators,
                                         e->v.DictComp.key,
                                         e->v.DictComp.value);
}
f='#n1313'>1313</a>
<a id='n1314' href='#n1314'>1314</a>
<a id='n1315' href='#n1315'>1315</a>
<a id='n1316' href='#n1316'>1316</a>
<a id='n1317' href='#n1317'>1317</a>
<a id='n1318' href='#n1318'>1318</a>
<a id='n1319' href='#n1319'>1319</a>
<a id='n1320' href='#n1320'>1320</a>
<a id='n1321' href='#n1321'>1321</a>
<a id='n1322' href='#n1322'>1322</a>
<a id='n1323' href='#n1323'>1323</a>
<a id='n1324' href='#n1324'>1324</a>
<a id='n1325' href='#n1325'>1325</a>
<a id='n1326' href='#n1326'>1326</a>
<a id='n1327' href='#n1327'>1327</a>
<a id='n1328' href='#n1328'>1328</a>
<a id='n1329' href='#n1329'>1329</a>
<a id='n1330' href='#n1330'>1330</a>
<a id='n1331' href='#n1331'>1331</a>
<a id='n1332' href='#n1332'>1332</a>
<a id='n1333' href='#n1333'>1333</a>
<a id='n1334' href='#n1334'>1334</a>
<a id='n1335' href='#n1335'>1335</a>
<a id='n1336' href='#n1336'>1336</a>
<a id='n1337' href='#n1337'>1337</a>
<a id='n1338' href='#n1338'>1338</a>
<a id='n1339' href='#n1339'>1339</a>
<a id='n1340' href='#n1340'>1340</a>
<a id='n1341' href='#n1341'>1341</a>
<a id='n1342' href='#n1342'>1342</a>
<a id='n1343' href='#n1343'>1343</a>
<a id='n1344' href='#n1344'>1344</a>
<a id='n1345' href='#n1345'>1345</a>
<a id='n1346' href='#n1346'>1346</a>
<a id='n1347' href='#n1347'>1347</a>
<a id='n1348' href='#n1348'>1348</a>
<a id='n1349' href='#n1349'>1349</a>
<a id='n1350' href='#n1350'>1350</a>
<a id='n1351' href='#n1351'>1351</a>
<a id='n1352' href='#n1352'>1352</a>
<a id='n1353' href='#n1353'>1353</a>
<a id='n1354' href='#n1354'>1354</a>
<a id='n1355' href='#n1355'>1355</a>
<a id='n1356' href='#n1356'>1356</a>
<a id='n1357' href='#n1357'>1357</a>
<a id='n1358' href='#n1358'>1358</a>
<a id='n1359' href='#n1359'>1359</a>
<a id='n1360' href='#n1360'>1360</a>
<a id='n1361' href='#n1361'>1361</a>
<a id='n1362' href='#n1362'>1362</a>
<a id='n1363' href='#n1363'>1363</a>
<a id='n1364' href='#n1364'>1364</a>
<a id='n1365' href='#n1365'>1365</a>
<a id='n1366' href='#n1366'>1366</a>
<a id='n1367' href='#n1367'>1367</a>
<a id='n1368' href='#n1368'>1368</a>
<a id='n1369' href='#n1369'>1369</a>
<a id='n1370' href='#n1370'>1370</a>
<a id='n1371' href='#n1371'>1371</a>
<a id='n1372' href='#n1372'>1372</a>
<a id='n1373' href='#n1373'>1373</a>
<a id='n1374' href='#n1374'>1374</a>
<a id='n1375' href='#n1375'>1375</a>
<a id='n1376' href='#n1376'>1376</a>
<a id='n1377' href='#n1377'>1377</a>
<a id='n1378' href='#n1378'>1378</a>
<a id='n1379' href='#n1379'>1379</a>
<a id='n1380' href='#n1380'>1380</a>
<a id='n1381' href='#n1381'>1381</a>
<a id='n1382' href='#n1382'>1382</a>
<a id='n1383' href='#n1383'>1383</a>
<a id='n1384' href='#n1384'>1384</a>
<a id='n1385' href='#n1385'>1385</a>
<a id='n1386' href='#n1386'>1386</a>
<a id='n1387' href='#n1387'>1387</a>
<a id='n1388' href='#n1388'>1388</a>
<a id='n1389' href='#n1389'>1389</a>
<a id='n1390' href='#n1390'>1390</a>
<a id='n1391' href='#n1391'>1391</a>
<a id='n1392' href='#n1392'>1392</a>
<a id='n1393' href='#n1393'>1393</a>
<a id='n1394' href='#n1394'>1394</a>
<a id='n1395' href='#n1395'>1395</a>
<a id='n1396' href='#n1396'>1396</a>
<a id='n1397' href='#n1397'>1397</a>
<a id='n1398' href='#n1398'>1398</a>
<a id='n1399' href='#n1399'>1399</a>
<a id='n1400' href='#n1400'>1400</a>
<a id='n1401' href='#n1401'>1401</a>
<a id='n1402' href='#n1402'>1402</a>
<a id='n1403' href='#n1403'>1403</a>
<a id='n1404' href='#n1404'>1404</a>
<a id='n1405' href='#n1405'>1405</a>
<a id='n1406' href='#n1406'>1406</a>
<a id='n1407' href='#n1407'>1407</a>
<a id='n1408' href='#n1408'>1408</a>
<a id='n1409' href='#n1409'>1409</a>
<a id='n1410' href='#n1410'>1410</a>
<a id='n1411' href='#n1411'>1411</a>
<a id='n1412' href='#n1412'>1412</a>
<a id='n1413' href='#n1413'>1413</a>
<a id='n1414' href='#n1414'>1414</a>
<a id='n1415' href='#n1415'>1415</a>
<a id='n1416' href='#n1416'>1416</a>
<a id='n1417' href='#n1417'>1417</a>
<a id='n1418' href='#n1418'>1418</a>
<a id='n1419' href='#n1419'>1419</a>
<a id='n1420' href='#n1420'>1420</a>
<a id='n1421' href='#n1421'>1421</a>
<a id='n1422' href='#n1422'>1422</a>
<a id='n1423' href='#n1423'>1423</a>
<a id='n1424' href='#n1424'>1424</a>
<a id='n1425' href='#n1425'>1425</a>
<a id='n1426' href='#n1426'>1426</a>
<a id='n1427' href='#n1427'>1427</a>
<a id='n1428' href='#n1428'>1428</a>
<a id='n1429' href='#n1429'>1429</a>
<a id='n1430' href='#n1430'>1430</a>
<a id='n1431' href='#n1431'>1431</a>
<a id='n1432' href='#n1432'>1432</a>
<a id='n1433' href='#n1433'>1433</a>
<a id='n1434' href='#n1434'>1434</a>
<a id='n1435' href='#n1435'>1435</a>
<a id='n1436' href='#n1436'>1436</a>
<a id='n1437' href='#n1437'>1437</a>
<a id='n1438' href='#n1438'>1438</a>
<a id='n1439' href='#n1439'>1439</a>
<a id='n1440' href='#n1440'>1440</a>
<a id='n1441' href='#n1441'>1441</a>
<a id='n1442' href='#n1442'>1442</a>
<a id='n1443' href='#n1443'>1443</a>
<a id='n1444' href='#n1444'>1444</a>
<a id='n1445' href='#n1445'>1445</a>
<a id='n1446' href='#n1446'>1446</a>
<a id='n1447' href='#n1447'>1447</a>
<a id='n1448' href='#n1448'>1448</a>
<a id='n1449' href='#n1449'>1449</a>
<a id='n1450' href='#n1450'>1450</a>
<a id='n1451' href='#n1451'>1451</a>
<a id='n1452' href='#n1452'>1452</a>
<a id='n1453' href='#n1453'>1453</a>
<a id='n1454' href='#n1454'>1454</a>
<a id='n1455' href='#n1455'>1455</a>
<a id='n1456' href='#n1456'>1456</a>
<a id='n1457' href='#n1457'>1457</a>
<a id='n1458' href='#n1458'>1458</a>
<a id='n1459' href='#n1459'>1459</a>
<a id='n1460' href='#n1460'>1460</a>
<a id='n1461' href='#n1461'>1461</a>
<a id='n1462' href='#n1462'>1462</a>
<a id='n1463' href='#n1463'>1463</a>
<a id='n1464' href='#n1464'>1464</a>
<a id='n1465' href='#n1465'>1465</a>
<a id='n1466' href='#n1466'>1466</a>
<a id='n1467' href='#n1467'>1467</a>
<a id='n1468' href='#n1468'>1468</a>
<a id='n1469' href='#n1469'>1469</a>
<a id='n1470' href='#n1470'>1470</a>
<a id='n1471' href='#n1471'>1471</a>
<a id='n1472' href='#n1472'>1472</a>
<a id='n1473' href='#n1473'>1473</a>
<a id='n1474' href='#n1474'>1474</a>
<a id='n1475' href='#n1475'>1475</a>
<a id='n1476' href='#n1476'>1476</a>
<a id='n1477' href='#n1477'>1477</a>
<a id='n1478' href='#n1478'>1478</a>
<a id='n1479' href='#n1479'>1479</a>
<a id='n1480' href='#n1480'>1480</a>
<a id='n1481' href='#n1481'>1481</a>
<a id='n1482' href='#n1482'>1482</a>
<a id='n1483' href='#n1483'>1483</a>
<a id='n1484' href='#n1484'>1484</a>
<a id='n1485' href='#n1485'>1485</a>
<a id='n1486' href='#n1486'>1486</a>
<a id='n1487' href='#n1487'>1487</a>
<a id='n1488' href='#n1488'>1488</a>
<a id='n1489' href='#n1489'>1489</a>
<a id='n1490' href='#n1490'>1490</a>
<a id='n1491' href='#n1491'>1491</a>
<a id='n1492' href='#n1492'>1492</a>
<a id='n1493' href='#n1493'>1493</a>
<a id='n1494' href='#n1494'>1494</a>
<a id='n1495' href='#n1495'>1495</a>
<a id='n1496' href='#n1496'>1496</a>
<a id='n1497' href='#n1497'>1497</a>
<a id='n1498' href='#n1498'>1498</a>
<a id='n1499' href='#n1499'>1499</a>
<a id='n1500' href='#n1500'>1500</a>
<a id='n1501' href='#n1501'>1501</a>
<a id='n1502' href='#n1502'>1502</a>
<a id='n1503' href='#n1503'>1503</a>
<a id='n1504' href='#n1504'>1504</a>
<a id='n1505' href='#n1505'>1505</a>
<a id='n1506' href='#n1506'>1506</a>
<a id='n1507' href='#n1507'>1507</a>
<a id='n1508' href='#n1508'>1508</a>
<a id='n1509' href='#n1509'>1509</a>
<a id='n1510' href='#n1510'>1510</a>
<a id='n1511' href='#n1511'>1511</a>
<a id='n1512' href='#n1512'>1512</a>
<a id='n1513' href='#n1513'>1513</a>
<a id='n1514' href='#n1514'>1514</a>
<a id='n1515' href='#n1515'>1515</a>
<a id='n1516' href='#n1516'>1516</a>
<a id='n1517' href='#n1517'>1517</a>
<a id='n1518' href='#n1518'>1518</a>
<a id='n1519' href='#n1519'>1519</a>
<a id='n1520' href='#n1520'>1520</a>
<a id='n1521' href='#n1521'>1521</a>
<a id='n1522' href='#n1522'>1522</a>
<a id='n1523' href='#n1523'>1523</a>
<a id='n1524' href='#n1524'>1524</a>
<a id='n1525' href='#n1525'>1525</a>
<a id='n1526' href='#n1526'>1526</a>
<a id='n1527' href='#n1527'>1527</a>
<a id='n1528' href='#n1528'>1528</a>
<a id='n1529' href='#n1529'>1529</a>
<a id='n1530' href='#n1530'>1530</a>
<a id='n1531' href='#n1531'>1531</a>
<a id='n1532' href='#n1532'>1532</a>
<a id='n1533' href='#n1533'>1533</a>
<a id='n1534' href='#n1534'>1534</a>
<a id='n1535' href='#n1535'>1535</a>
<a id='n1536' href='#n1536'>1536</a>
<a id='n1537' href='#n1537'>1537</a>
<a id='n1538' href='#n1538'>1538</a>
<a id='n1539' href='#n1539'>1539</a>
<a id='n1540' href='#n1540'>1540</a>
<a id='n1541' href='#n1541'>1541</a>
<a id='n1542' href='#n1542'>1542</a>
<a id='n1543' href='#n1543'>1543</a>
<a id='n1544' href='#n1544'>1544</a>
<a id='n1545' href='#n1545'>1545</a>
<a id='n1546' href='#n1546'>1546</a>
<a id='n1547' href='#n1547'>1547</a>
<a id='n1548' href='#n1548'>1548</a>
<a id='n1549' href='#n1549'>1549</a>
<a id='n1550' href='#n1550'>1550</a>
<a id='n1551' href='#n1551'>1551</a>
<a id='n1552' href='#n1552'>1552</a>
<a id='n1553' href='#n1553'>1553</a>
<a id='n1554' href='#n1554'>1554</a>
<a id='n1555' href='#n1555'>1555</a>
<a id='n1556' href='#n1556'>1556</a>
<a id='n1557' href='#n1557'>1557</a>
<a id='n1558' href='#n1558'>1558</a>
<a id='n1559' href='#n1559'>1559</a>
<a id='n1560' href='#n1560'>1560</a>
<a id='n1561' href='#n1561'>1561</a>
<a id='n1562' href='#n1562'>1562</a>
<a id='n1563' href='#n1563'>1563</a>
<a id='n1564' href='#n1564'>1564</a>
<a id='n1565' href='#n1565'>1565</a>
<a id='n1566' href='#n1566'>1566</a>
<a id='n1567' href='#n1567'>1567</a>
<a id='n1568' href='#n1568'>1568</a>
<a id='n1569' href='#n1569'>1569</a>
<a id='n1570' href='#n1570'>1570</a>
<a id='n1571' href='#n1571'>1571</a>
<a id='n1572' href='#n1572'>1572</a>
<a id='n1573' href='#n1573'>1573</a>
<a id='n1574' href='#n1574'>1574</a>
<a id='n1575' href='#n1575'>1575</a>
<a id='n1576' href='#n1576'>1576</a>
<a id='n1577' href='#n1577'>1577</a>
<a id='n1578' href='#n1578'>1578</a>
<a id='n1579' href='#n1579'>1579</a>
<a id='n1580' href='#n1580'>1580</a>
<a id='n1581' href='#n1581'>1581</a>
<a id='n1582' href='#n1582'>1582</a>
<a id='n1583' href='#n1583'>1583</a>
<a id='n1584' href='#n1584'>1584</a>
<a id='n1585' href='#n1585'>1585</a>
<a id='n1586' href='#n1586'>1586</a>
<a id='n1587' href='#n1587'>1587</a>
<a id='n1588' href='#n1588'>1588</a>
<a id='n1589' href='#n1589'>1589</a>
<a id='n1590' href='#n1590'>1590</a>
<a id='n1591' href='#n1591'>1591</a>
<a id='n1592' href='#n1592'>1592</a>
<a id='n1593' href='#n1593'>1593</a>
<a id='n1594' href='#n1594'>1594</a>
<a id='n1595' href='#n1595'>1595</a>
<a id='n1596' href='#n1596'>1596</a>
<a id='n1597' href='#n1597'>1597</a>
<a id='n1598' href='#n1598'>1598</a>
<a id='n1599' href='#n1599'>1599</a>
<a id='n1600' href='#n1600'>1600</a>
<a id='n1601' href='#n1601'>1601</a>
<a id='n1602' href='#n1602'>1602</a>
<a id='n1603' href='#n1603'>1603</a>
<a id='n1604' href='#n1604'>1604</a>
<a id='n1605' href='#n1605'>1605</a>
<a id='n1606' href='#n1606'>1606</a>
<a id='n1607' href='#n1607'>1607</a>
<a id='n1608' href='#n1608'>1608</a>
<a id='n1609' href='#n1609'>1609</a>
<a id='n1610' href='#n1610'>1610</a>
<a id='n1611' href='#n1611'>1611</a>
<a id='n1612' href='#n1612'>1612</a>
<a id='n1613' href='#n1613'>1613</a>
<a id='n1614' href='#n1614'>1614</a>
<a id='n1615' href='#n1615'>1615</a>
<a id='n1616' href='#n1616'>1616</a>
<a id='n1617' href='#n1617'>1617</a>
<a id='n1618' href='#n1618'>1618</a>
<a id='n1619' href='#n1619'>1619</a>
<a id='n1620' href='#n1620'>1620</a>
<a id='n1621' href='#n1621'>1621</a>
<a id='n1622' href='#n1622'>1622</a>
<a id='n1623' href='#n1623'>1623</a>
<a id='n1624' href='#n1624'>1624</a>
<a id='n1625' href='#n1625'>1625</a>
<a id='n1626' href='#n1626'>1626</a>
<a id='n1627' href='#n1627'>1627</a>
<a id='n1628' href='#n1628'>1628</a>
<a id='n1629' href='#n1629'>1629</a>
<a id='n1630' href='#n1630'>1630</a>
<a id='n1631' href='#n1631'>1631</a>
<a id='n1632' href='#n1632'>1632</a>
<a id='n1633' href='#n1633'>1633</a>
<a id='n1634' href='#n1634'>1634</a>
<a id='n1635' href='#n1635'>1635</a>
<a id='n1636' href='#n1636'>1636</a>
<a id='n1637' href='#n1637'>1637</a>
<a id='n1638' href='#n1638'>1638</a>
<a id='n1639' href='#n1639'>1639</a>
<a id='n1640' href='#n1640'>1640</a>
<a id='n1641' href='#n1641'>1641</a>
<a id='n1642' href='#n1642'>1642</a>
<a id='n1643' href='#n1643'>1643</a>
<a id='n1644' href='#n1644'>1644</a>
<a id='n1645' href='#n1645'>1645</a>
<a id='n1646' href='#n1646'>1646</a>
<a id='n1647' href='#n1647'>1647</a>
<a id='n1648' href='#n1648'>1648</a>
<a id='n1649' href='#n1649'>1649</a>
<a id='n1650' href='#n1650'>1650</a>
<a id='n1651' href='#n1651'>1651</a>
<a id='n1652' href='#n1652'>1652</a>
<a id='n1653' href='#n1653'>1653</a>
<a id='n1654' href='#n1654'>1654</a>
<a id='n1655' href='#n1655'>1655</a>
<a id='n1656' href='#n1656'>1656</a>
<a id='n1657' href='#n1657'>1657</a>
<a id='n1658' href='#n1658'>1658</a>
<a id='n1659' href='#n1659'>1659</a>
<a id='n1660' href='#n1660'>1660</a>
<a id='n1661' href='#n1661'>1661</a>
<a id='n1662' href='#n1662'>1662</a>
<a id='n1663' href='#n1663'>1663</a>
<a id='n1664' href='#n1664'>1664</a>
<a id='n1665' href='#n1665'>1665</a>
<a id='n1666' href='#n1666'>1666</a>
<a id='n1667' href='#n1667'>1667</a>
<a id='n1668' href='#n1668'>1668</a>
<a id='n1669' href='#n1669'>1669</a>
<a id='n1670' href='#n1670'>1670</a>
<a id='n1671' href='#n1671'>1671</a>
<a id='n1672' href='#n1672'>1672</a>
<a id='n1673' href='#n1673'>1673</a>
<a id='n1674' href='#n1674'>1674</a>
<a id='n1675' href='#n1675'>1675</a>
<a id='n1676' href='#n1676'>1676</a>
<a id='n1677' href='#n1677'>1677</a>
<a id='n1678' href='#n1678'>1678</a>
<a id='n1679' href='#n1679'>1679</a>
<a id='n1680' href='#n1680'>1680</a>
<a id='n1681' href='#n1681'>1681</a>
<a id='n1682' href='#n1682'>1682</a>
<a id='n1683' href='#n1683'>1683</a>
<a id='n1684' href='#n1684'>1684</a>
<a id='n1685' href='#n1685'>1685</a>
<a id='n1686' href='#n1686'>1686</a>
<a id='n1687' href='#n1687'>1687</a>
<a id='n1688' href='#n1688'>1688</a>
<a id='n1689' href='#n1689'>1689</a>
<a id='n1690' href='#n1690'>1690</a>
<a id='n1691' href='#n1691'>1691</a>
<a id='n1692' href='#n1692'>1692</a>
<a id='n1693' href='#n1693'>1693</a>
<a id='n1694' href='#n1694'>1694</a>
<a id='n1695' href='#n1695'>1695</a>
<a id='n1696' href='#n1696'>1696</a>
<a id='n1697' href='#n1697'>1697</a>
<a id='n1698' href='#n1698'>1698</a>
<a id='n1699' href='#n1699'>1699</a>
<a id='n1700' href='#n1700'>1700</a>
<a id='n1701' href='#n1701'>1701</a>
<a id='n1702' href='#n1702'>1702</a>
<a id='n1703' href='#n1703'>1703</a>
<a id='n1704' href='#n1704'>1704</a>
<a id='n1705' href='#n1705'>1705</a>
<a id='n1706' href='#n1706'>1706</a>
<a id='n1707' href='#n1707'>1707</a>
<a id='n1708' href='#n1708'>1708</a>
<a id='n1709' href='#n1709'>1709</a>
<a id='n1710' href='#n1710'>1710</a>
<a id='n1711' href='#n1711'>1711</a>
<a id='n1712' href='#n1712'>1712</a>
<a id='n1713' href='#n1713'>1713</a>
<a id='n1714' href='#n1714'>1714</a>
<a id='n1715' href='#n1715'>1715</a>
<a id='n1716' href='#n1716'>1716</a>
<a id='n1717' href='#n1717'>1717</a>
<a id='n1718' href='#n1718'>1718</a>
<a id='n1719' href='#n1719'>1719</a>
<a id='n1720' href='#n1720'>1720</a>
<a id='n1721' href='#n1721'>1721</a>
<a id='n1722' href='#n1722'>1722</a>
<a id='n1723' href='#n1723'>1723</a>
<a id='n1724' href='#n1724'>1724</a>
<a id='n1725' href='#n1725'>1725</a>
<a id='n1726' href='#n1726'>1726</a>
<a id='n1727' href='#n1727'>1727</a>
<a id='n1728' href='#n1728'>1728</a>
<a id='n1729' href='#n1729'>1729</a>
<a id='n1730' href='#n1730'>1730</a>
<a id='n1731' href='#n1731'>1731</a>
<a id='n1732' href='#n1732'>1732</a>
<a id='n1733' href='#n1733'>1733</a>
<a id='n1734' href='#n1734'>1734</a>
<a id='n1735' href='#n1735'>1735</a>
<a id='n1736' href='#n1736'>1736</a>
<a id='n1737' href='#n1737'>1737</a>
<a id='n1738' href='#n1738'>1738</a>
<a id='n1739' href='#n1739'>1739</a>
<a id='n1740' href='#n1740'>1740</a>
<a id='n1741' href='#n1741'>1741</a>
<a id='n1742' href='#n1742'>1742</a>
<a id='n1743' href='#n1743'>1743</a>
<a id='n1744' href='#n1744'>1744</a>
<a id='n1745' href='#n1745'>1745</a>
<a id='n1746' href='#n1746'>1746</a>
<a id='n1747' href='#n1747'>1747</a>
<a id='n1748' href='#n1748'>1748</a>
<a id='n1749' href='#n1749'>1749</a>
<a id='n1750' href='#n1750'>1750</a>
<a id='n1751' href='#n1751'>1751</a>
<a id='n1752' href='#n1752'>1752</a>
<a id='n1753' href='#n1753'>1753</a>
<a id='n1754' href='#n1754'>1754</a>
<a id='n1755' href='#n1755'>1755</a>
<a id='n1756' href='#n1756'>1756</a>
<a id='n1757' href='#n1757'>1757</a>
<a id='n1758' href='#n1758'>1758</a>
<a id='n1759' href='#n1759'>1759</a>
<a id='n1760' href='#n1760'>1760</a>
<a id='n1761' href='#n1761'>1761</a>
<a id='n1762' href='#n1762'>1762</a>
<a id='n1763' href='#n1763'>1763</a>
<a id='n1764' href='#n1764'>1764</a>
<a id='n1765' href='#n1765'>1765</a>
<a id='n1766' href='#n1766'>1766</a>
<a id='n1767' href='#n1767'>1767</a>
<a id='n1768' href='#n1768'>1768</a>
<a id='n1769' href='#n1769'>1769</a>
<a id='n1770' href='#n1770'>1770</a>
<a id='n1771' href='#n1771'>1771</a>
<a id='n1772' href='#n1772'>1772</a>
<a id='n1773' href='#n1773'>1773</a>
<a id='n1774' href='#n1774'>1774</a>
<a id='n1775' href='#n1775'>1775</a>
<a id='n1776' href='#n1776'>1776</a>
<a id='n1777' href='#n1777'>1777</a>
<a id='n1778' href='#n1778'>1778</a>
<a id='n1779' href='#n1779'>1779</a>
<a id='n1780' href='#n1780'>1780</a>
<a id='n1781' href='#n1781'>1781</a>
</pre></td>
<td class='lines'><pre><code>
<span class="hl com">/* System module */</span>

<span class="hl com">/*</span>
<span class="hl com">Various bits of information used by the interpreter are collected in</span>
<span class="hl com">module 'sys'.</span>
<span class="hl com">Function member:</span>
<span class="hl com">- exit(sts): raise SystemExit</span>
<span class="hl com">Data members:</span>
<span class="hl com">- stdin, stdout, stderr: standard file objects</span>
<span class="hl com">- modules: the table of modules (dictionary)</span>
<span class="hl com">- path: module search path (list of strings)</span>
<span class="hl com">- argv: script arguments (list of strings)</span>
<span class="hl com">- ps1, ps2: optional primary and secondary prompts (strings)</span>
<span class="hl com">*/</span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;Python.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;structseq.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;code.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;frameobject.h&quot;</span><span class="hl ppc"></span>
<span class="hl ppc">#include</span> <span class="hl pps">&quot;eval.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#include</span> <span class="hl pps">&quot;osdefs.h&quot;</span><span class="hl ppc"></span>

<span class="hl ppc">#ifdef MS_WINDOWS</span>
<span class="hl ppc">#define WIN32_LEAN_AND_MEAN</span>
<span class="hl ppc">#include &lt;windows.h&gt;</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* MS_WINDOWS */</span><span class="hl ppc"></span>

<span class="hl ppc">#ifdef MS_COREDLL</span>
<span class="hl kwc">extern</span> <span class="hl kwb">void</span> <span class="hl opt">*</span>PyWin_DLLhModule<span class="hl opt">;</span>
<span class="hl com">/* A string loaded from the DLL at startup: */</span>
<span class="hl kwc">extern</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>PyWin_DLLVersionString<span class="hl opt">;</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifdef __VMS</span>
<span class="hl ppc">#include &lt;unixlib.h&gt;</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifdef HAVE_LANGINFO_H</span>
<span class="hl ppc">#include &lt;locale.h&gt;</span>
<span class="hl ppc">#include &lt;langinfo.h&gt;</span>
<span class="hl ppc">#endif</span>

PyObject <span class="hl opt">*</span>
<span class="hl kwd">PySys_GetObject</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    PyObject <span class="hl opt">*</span>sd <span class="hl opt">=</span> tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>sysdict<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>sd <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyDict_GetItemString</span><span class="hl opt">(</span>sd<span class="hl opt">,</span> name<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">PySys_SetObject</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>v<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    PyObject <span class="hl opt">*</span>sd <span class="hl opt">=</span> tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>sysdict<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyDict_GetItemString</span><span class="hl opt">(</span>sd<span class="hl opt">,</span> name<span class="hl opt">) ==</span> NULL<span class="hl opt">)</span>
            <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">else</span>
            <span class="hl kwa">return</span> <span class="hl kwd">PyDict_DelItemString</span><span class="hl opt">(</span>sd<span class="hl opt">,</span> name<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span>
        <span class="hl kwa">return</span> <span class="hl kwd">PyDict_SetItemString</span><span class="hl opt">(</span>sd<span class="hl opt">,</span> name<span class="hl opt">,</span> v<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_displayhook</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>o<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>outf<span class="hl opt">;</span>
    PyInterpreterState <span class="hl opt">*</span>interp <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">()-&gt;</span>interp<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>modules <span class="hl opt">=</span> interp<span class="hl opt">-&gt;</span>modules<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>builtins <span class="hl opt">=</span> <span class="hl kwd">PyDict_GetItemString</span><span class="hl opt">(</span>modules<span class="hl opt">,</span> <span class="hl str">&quot;builtins&quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>builtins <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_SetString</span><span class="hl opt">(</span>PyExc_RuntimeError<span class="hl opt">,</span> <span class="hl str">&quot;lost builtins module&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Print value except if None */</span>
    <span class="hl com">/* After printing, also assign to '_' */</span>
    <span class="hl com">/* Before, set '_' to None to avoid recursion */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>o <span class="hl opt">==</span> Py_None<span class="hl opt">) {</span>
        <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
        <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyObject_SetAttrString</span><span class="hl opt">(</span>builtins<span class="hl opt">,</span> <span class="hl str">&quot;_&quot;</span><span class="hl opt">,</span> Py_None<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    outf <span class="hl opt">=</span> <span class="hl kwd">PySys_GetObject</span><span class="hl opt">(</span><span class="hl str">&quot;stdout&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>outf <span class="hl opt">==</span> NULL <span class="hl opt">||</span> outf <span class="hl opt">==</span> Py_None<span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_SetString</span><span class="hl opt">(</span>PyExc_RuntimeError<span class="hl opt">,</span> <span class="hl str">&quot;lost sys.stdout&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyFile_WriteObject</span><span class="hl opt">(</span>o<span class="hl opt">,</span> outf<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyFile_WriteString</span><span class="hl opt">(</span><span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> outf<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyObject_SetAttrString</span><span class="hl opt">(</span>builtins<span class="hl opt">,</span> <span class="hl str">&quot;_&quot;</span><span class="hl opt">,</span> o<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>displayhook_doc<span class="hl opt">,</span>
<span class="hl str">&quot;displayhook(object) -&gt; None</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;Print an object to sys.stdout and also save it in builtins._</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_excepthook</span><span class="hl opt">(</span>PyObject<span class="hl opt">*</span> self<span class="hl opt">,</span> PyObject<span class="hl opt">*</span> args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>exc<span class="hl opt">, *</span>value<span class="hl opt">, *</span>tb<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_UnpackTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;excepthook&quot;</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">,</span> <span class="hl num">3</span><span class="hl opt">, &amp;</span>exc<span class="hl opt">, &amp;</span>value<span class="hl opt">, &amp;</span>tb<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">PyErr_Display</span><span class="hl opt">(</span>exc<span class="hl opt">,</span> value<span class="hl opt">,</span> tb<span class="hl opt">);</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>excepthook_doc<span class="hl opt">,</span>
<span class="hl str">&quot;excepthook(exctype, value, traceback) -&gt; None</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl str">&quot;Handle an exception by displaying it with a traceback on sys.stderr.</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_exc_info</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>noargs<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate<span class="hl opt">;</span>
    tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Py_BuildValue</span><span class="hl opt">(</span>
        <span class="hl str">&quot;(OOO)&quot;</span><span class="hl opt">,</span>
        tstate<span class="hl opt">-&gt;</span>exc_type <span class="hl opt">!=</span> NULL ? tstate<span class="hl opt">-&gt;</span>exc_type <span class="hl opt">:</span> Py_None<span class="hl opt">,</span>
        tstate<span class="hl opt">-&gt;</span>exc_value <span class="hl opt">!=</span> NULL ? tstate<span class="hl opt">-&gt;</span>exc_value <span class="hl opt">:</span> Py_None<span class="hl opt">,</span>
        tstate<span class="hl opt">-&gt;</span>exc_traceback <span class="hl opt">!=</span> NULL ?
            tstate<span class="hl opt">-&gt;</span>exc_traceback <span class="hl opt">:</span> Py_None<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>exc_info_doc<span class="hl opt">,</span>
<span class="hl str">&quot;exc_info() -&gt; (type, value, traceback)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return information about the most recent exception caught by an except</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">clause in the current stack frame or in an older stack frame.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_exit</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>exit_code <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_UnpackTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;exit&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">, &amp;</span>exit_code<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl com">/* Raise SystemExit so callers may catch it or clean up. */</span>
    <span class="hl kwd">PyErr_SetObject</span><span class="hl opt">(</span>PyExc_SystemExit<span class="hl opt">,</span> exit_code<span class="hl opt">);</span>
    <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>exit_doc<span class="hl opt">,</span>
<span class="hl str">&quot;exit([status])</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Exit the interpreter by raising SystemExit(status).</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">If the status is omitted or None, it defaults to zero (i.e., success).</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">If the status is numeric, it will be used as the system exit status.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">If it is another kind of object, it will be printed and the system</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">exit status will be one (i.e., failure).&quot;</span>
<span class="hl opt">);</span>


<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getdefaultencoding</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span><span class="hl kwd">PyUnicode_GetDefaultEncoding</span><span class="hl opt">());</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getdefaultencoding_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getdefaultencoding() -&gt; string</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the current default string encoding used by the Unicode</span> <span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">implementation.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_setdefaultencoding</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>encoding<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;s:setdefaultencoding&quot;</span><span class="hl opt">, &amp;</span>encoding<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyUnicode_SetDefaultEncoding</span><span class="hl opt">(</span>encoding<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>setdefaultencoding_doc<span class="hl opt">,</span>
<span class="hl str">&quot;setdefaultencoding(encoding)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Set the current default string encoding used by the Unicode implementation.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getfilesystemencoding</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>Py_FileSystemDefaultEncoding<span class="hl opt">)</span>
        <span class="hl kwa">return</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>Py_FileSystemDefaultEncoding<span class="hl opt">);</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getfilesystemencoding_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getfilesystemencoding() -&gt; string</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the encoding used to convert Unicode filenames in</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">operating system filenames.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_setfilesystemencoding</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>new_encoding<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;U:setfilesystemencoding&quot;</span><span class="hl opt">, &amp;</span>new_encoding<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">_Py_SetFileSystemEncoding</span><span class="hl opt">(</span>new_encoding<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>setfilesystemencoding_doc<span class="hl opt">,</span>
<span class="hl str">&quot;setfilesystemencoding(string) -&gt; None</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Set the encoding used to convert Unicode filenames in</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">operating system filenames.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_intern</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>s<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;U:intern&quot;</span><span class="hl opt">, &amp;</span>s<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyUnicode_CheckExact</span><span class="hl opt">(</span>s<span class="hl opt">)) {</span>
        <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>s<span class="hl opt">);</span>
        <span class="hl kwd">PyUnicode_InternInPlace</span><span class="hl opt">(&amp;</span>s<span class="hl opt">);</span>
        <span class="hl kwa">return</span> s<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        <span class="hl kwd">PyErr_Format</span><span class="hl opt">(</span>PyExc_TypeError<span class="hl opt">,</span>
                        <span class="hl str">&quot;can't intern %.400s&quot;</span><span class="hl opt">,</span> s<span class="hl opt">-&gt;</span>ob_type<span class="hl opt">-&gt;</span>tp_name<span class="hl opt">);</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>intern_doc<span class="hl opt">,</span>
<span class="hl str">&quot;intern(string) -&gt; string</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">``Intern'' the given string.  This enters the string in the (global)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">table of interned strings whose purpose is to speed up dictionary lookups.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the string itself or the previously interned string object with the</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">same value.&quot;</span><span class="hl opt">);</span>


<span class="hl com">/*</span>
<span class="hl com"> * Cached interned string objects used for calling the profile and</span>
<span class="hl com"> * trace functions.  Initialized by trace_init().</span>
<span class="hl com"> */</span>
<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>whatstrings<span class="hl opt">[</span><span class="hl num">7</span><span class="hl opt">] = {</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">,</span> NULL<span class="hl opt">};</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">trace_init</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">static char</span> <span class="hl opt">*</span>whatnames<span class="hl opt">[</span><span class="hl num">7</span><span class="hl opt">] = {</span><span class="hl str">&quot;call&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;exception&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;line&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;return&quot;</span><span class="hl opt">,</span>
                                    <span class="hl str">&quot;c_call&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;c_exception&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;c_return&quot;</span><span class="hl opt">};</span>
    PyObject <span class="hl opt">*</span>name<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span> i <span class="hl opt">&lt;</span> <span class="hl num">7</span><span class="hl opt">; ++</span>i<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>whatstrings<span class="hl opt">[</span>i<span class="hl opt">] ==</span> NULL<span class="hl opt">) {</span>
            name <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_InternFromString</span><span class="hl opt">(</span>whatnames<span class="hl opt">[</span>i<span class="hl opt">]);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>name <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
                <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
            whatstrings<span class="hl opt">[</span>i<span class="hl opt">] =</span> name<span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>


<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">call_trampoline</span><span class="hl opt">(</span>PyThreadState <span class="hl opt">*</span>tstate<span class="hl opt">,</span> PyObject<span class="hl opt">*</span> callback<span class="hl opt">,</span>
                PyFrameObject <span class="hl opt">*</span>frame<span class="hl opt">,</span> <span class="hl kwb">int</span> what<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>arg<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>args <span class="hl opt">=</span> <span class="hl kwd">PyTuple_New</span><span class="hl opt">(</span><span class="hl num">3</span><span class="hl opt">);</span>
    PyObject <span class="hl opt">*</span>whatstr<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>result<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>args <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>frame<span class="hl opt">);</span>
    whatstr <span class="hl opt">=</span> whatstrings<span class="hl opt">[</span>what<span class="hl opt">];</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>whatstr<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>arg <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        arg <span class="hl opt">=</span> Py_None<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>arg<span class="hl opt">);</span>
    <span class="hl kwd">PyTuple_SET_ITEM</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">, (</span>PyObject <span class="hl opt">*)</span>frame<span class="hl opt">);</span>
    <span class="hl kwd">PyTuple_SET_ITEM</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">,</span> whatstr<span class="hl opt">);</span>
    <span class="hl kwd">PyTuple_SET_ITEM</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">,</span> arg<span class="hl opt">);</span>

    <span class="hl com">/* call the Python-level function */</span>
    <span class="hl kwd">PyFrame_FastToLocals</span><span class="hl opt">(</span>frame<span class="hl opt">);</span>
    result <span class="hl opt">=</span> <span class="hl kwd">PyEval_CallObject</span><span class="hl opt">(</span>callback<span class="hl opt">,</span> args<span class="hl opt">);</span>
    <span class="hl kwd">PyFrame_LocalsToFast</span><span class="hl opt">(</span>frame<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwd">PyTraceBack_Here</span><span class="hl opt">(</span>frame<span class="hl opt">);</span>

    <span class="hl com">/* cleanup */</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>args<span class="hl opt">);</span>
    <span class="hl kwa">return</span> result<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">profile_trampoline</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyFrameObject <span class="hl opt">*</span>frame<span class="hl opt">,</span>
                   <span class="hl kwb">int</span> what<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>arg<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>f_tstate<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>result<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>arg <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        arg <span class="hl opt">=</span> Py_None<span class="hl opt">;</span>
    result <span class="hl opt">=</span> <span class="hl kwd">call_trampoline</span><span class="hl opt">(</span>tstate<span class="hl opt">,</span> self<span class="hl opt">,</span> frame<span class="hl opt">,</span> what<span class="hl opt">,</span> arg<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyEval_SetProfile</span><span class="hl opt">(</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
        <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>result<span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">trace_trampoline</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyFrameObject <span class="hl opt">*</span>frame<span class="hl opt">,</span>
                 <span class="hl kwb">int</span> what<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>arg<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>f_tstate<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>callback<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>result<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>what <span class="hl opt">==</span> PyTrace_CALL<span class="hl opt">)</span>
        callback <span class="hl opt">=</span> self<span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        callback <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>f_trace<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>callback <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
    result <span class="hl opt">=</span> <span class="hl kwd">call_trampoline</span><span class="hl opt">(</span>tstate<span class="hl opt">,</span> callback<span class="hl opt">,</span> frame<span class="hl opt">,</span> what<span class="hl opt">,</span> arg<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyEval_SetTrace</span><span class="hl opt">(</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
        <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>frame<span class="hl opt">-&gt;</span>f_trace<span class="hl opt">);</span>
        frame<span class="hl opt">-&gt;</span>f_trace <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
        <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">!=</span> Py_None<span class="hl opt">) {</span>
        PyObject <span class="hl opt">*</span>temp <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>f_trace<span class="hl opt">;</span>
        frame<span class="hl opt">-&gt;</span>f_trace <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
        <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>temp<span class="hl opt">);</span>
        frame<span class="hl opt">-&gt;</span>f_trace <span class="hl opt">=</span> result<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>result<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_settrace</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">trace_init</span><span class="hl opt">() == -</span><span class="hl num">1</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>args <span class="hl opt">==</span> Py_None<span class="hl opt">)</span>
        <span class="hl kwd">PyEval_SetTrace</span><span class="hl opt">(</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwa">else</span>
        <span class="hl kwd">PyEval_SetTrace</span><span class="hl opt">(</span>trace_trampoline<span class="hl opt">,</span> args<span class="hl opt">);</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>settrace_doc<span class="hl opt">,</span>
<span class="hl str">&quot;settrace(function)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Set the global debug tracing function.  It will be called on each</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">function call.  See the debugger chapter in the library manual.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_gettrace</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    PyObject <span class="hl opt">*</span>temp <span class="hl opt">=</span> tstate<span class="hl opt">-&gt;</span>c_traceobj<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>temp <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        temp <span class="hl opt">=</span> Py_None<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>temp<span class="hl opt">);</span>
    <span class="hl kwa">return</span> temp<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>gettrace_doc<span class="hl opt">,</span>
<span class="hl str">&quot;gettrace()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the global debug tracing function set with sys.settrace.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">See the debugger chapter in the library manual.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_setprofile</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">trace_init</span><span class="hl opt">() == -</span><span class="hl num">1</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>args <span class="hl opt">==</span> Py_None<span class="hl opt">)</span>
        <span class="hl kwd">PyEval_SetProfile</span><span class="hl opt">(</span>NULL<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwa">else</span>
        <span class="hl kwd">PyEval_SetProfile</span><span class="hl opt">(</span>profile_trampoline<span class="hl opt">,</span> args<span class="hl opt">);</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>setprofile_doc<span class="hl opt">,</span>
<span class="hl str">&quot;setprofile(function)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Set the profiling function.  It will be called on each function call</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">and return.  See the profiler chapter in the library manual.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getprofile</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    PyObject <span class="hl opt">*</span>temp <span class="hl opt">=</span> tstate<span class="hl opt">-&gt;</span>c_profileobj<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>temp <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        temp <span class="hl opt">=</span> Py_None<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>temp<span class="hl opt">);</span>
    <span class="hl kwa">return</span> temp<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getprofile_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getprofile()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the profiling function set with sys.setprofile.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">See the profiler chapter in the library manual.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_setcheckinterval</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;i:setcheckinterval&quot;</span><span class="hl opt">, &amp;</span>_Py_CheckInterval<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>setcheckinterval_doc<span class="hl opt">,</span>
<span class="hl str">&quot;setcheckinterval(n)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Tell the Python interpreter to check for asynchronous events every</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">n instructions.  This also affects how often thread switches occur.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getcheckinterval</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyLong_FromLong</span><span class="hl opt">(</span>_Py_CheckInterval<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getcheckinterval_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getcheckinterval() -&gt; current check interval; see setcheckinterval().&quot;</span>
<span class="hl opt">);</span>

<span class="hl ppc">#ifdef WITH_TSC</span>
<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_settscdump</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int bool</span><span class="hl opt">;</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_Get</span><span class="hl opt">();</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;i:settscdump&quot;</span><span class="hl opt">, &amp;</span><span class="hl kwb">bool</span><span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwb">bool</span><span class="hl opt">)</span>
        tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>tscdump <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>tscdump <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>

<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>settscdump_doc<span class="hl opt">,</span>
<span class="hl str">&quot;settscdump(bool)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">If true, tell the Python interpreter to dump VM measurements to</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">stderr.  If false, turn off dump.  The measurements are based on the</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">processor's time-stamp counter.&quot;</span>
<span class="hl opt">);</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* TSC */</span><span class="hl ppc"></span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_setrecursionlimit</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> new_limit<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;i:setrecursionlimit&quot;</span><span class="hl opt">, &amp;</span>new_limit<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>new_limit <span class="hl opt">&lt;=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_SetString</span><span class="hl opt">(</span>PyExc_ValueError<span class="hl opt">,</span>
                        <span class="hl str">&quot;recursion limit must be positive&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Py_SetRecursionLimit</span><span class="hl opt">(</span>new_limit<span class="hl opt">);</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>setrecursionlimit_doc<span class="hl opt">,</span>
<span class="hl str">&quot;setrecursionlimit(n)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Set the maximum depth of the Python interpreter stack to n.  This</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">limit prevents infinite recursion from causing an overflow of the C</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">stack and crashing Python.  The highest possible limit is platform-</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">dependent.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getrecursionlimit</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyLong_FromLong</span><span class="hl opt">(</span><span class="hl kwd">Py_GetRecursionLimit</span><span class="hl opt">());</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getrecursionlimit_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getrecursionlimit()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the current value of the recursion limit, the maximum depth</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">of the Python interpreter stack.  This limit prevents infinite</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">recursion from causing an overflow of the C stack and crashing Python.&quot;</span>
<span class="hl opt">);</span>

<span class="hl ppc">#ifdef MS_WINDOWS</span>
<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getwindowsversion_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getwindowsversion()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return information about the running version of Windows.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">The result is a tuple of (major, minor, build, platform, text)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">All elements are numbers, except text which is a string.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Platform may be 0 for win32s, 1 for Windows 9x/ME, 2 for Windows NT/2000/XP</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getwindowsversion</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">)</span>
<span class="hl opt">{</span>
    OSVERSIONINFO ver<span class="hl opt">;</span>
    ver<span class="hl opt">.</span>dwOSVersionInfoSize <span class="hl opt">=</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>ver<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">GetVersionEx</span><span class="hl opt">(&amp;</span>ver<span class="hl opt">))</span>
        <span class="hl kwa">return</span> <span class="hl kwd">PyErr_SetFromWindowsErr</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl kwd">Py_BuildValue</span><span class="hl opt">(</span><span class="hl str">&quot;HHHHs&quot;</span><span class="hl opt">,</span>
                         ver<span class="hl opt">.</span>dwMajorVersion<span class="hl opt">,</span>
                         ver<span class="hl opt">.</span>dwMinorVersion<span class="hl opt">,</span>
                         ver<span class="hl opt">.</span>dwBuildNumber<span class="hl opt">,</span>
                         ver<span class="hl opt">.</span>dwPlatformId<span class="hl opt">,</span>
                         ver<span class="hl opt">.</span>szCSDVersion<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl ppc">#endif</span> <span class="hl com">/* MS_WINDOWS */</span><span class="hl ppc"></span>

<span class="hl ppc">#ifdef HAVE_DLOPEN</span>
<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_setdlopenflags</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> new_val<span class="hl opt">;</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;i:setdlopenflags&quot;</span><span class="hl opt">, &amp;</span>new_val<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>tstate<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>dlopenflags <span class="hl opt">=</span> new_val<span class="hl opt">;</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>setdlopenflags_doc<span class="hl opt">,</span>
<span class="hl str">&quot;setdlopenflags(n) -&gt; None</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Set the flags used by the interpreter for dlopen calls, such as when the</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">interpreter loads extension modules.  Among other things, this will enable</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">a lazy resolving of symbols when importing a module, if called as</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">sys.setdlopenflags(0).  To share symbols across extension modules, call as</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">sys.setdlopenflags(ctypes.RTLD_GLOBAL).  Symbolic names for the flag modules</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">can be either found in the ctypes module, or in the DLFCN module. If DLFCN</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">is not available, it can be generated from /usr/include/dlfcn.h using the</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">h2py script.&quot;</span><span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getdlopenflags</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyThreadState <span class="hl opt">*</span>tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>tstate<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyLong_FromLong</span><span class="hl opt">(</span>tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>dlopenflags<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getdlopenflags_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getdlopenflags() -&gt; int</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the current value of the flags that are used for dlopen calls.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">The flag constants are defined in the ctypes and DLFCN modules.&quot;</span><span class="hl opt">);</span>

<span class="hl ppc">#endif</span>  <span class="hl com">/* HAVE_DLOPEN */</span><span class="hl ppc"></span>

<span class="hl ppc">#ifdef USE_MALLOPT</span>
<span class="hl com">/* Link with -lmalloc (or -lmpc) on an SGI */</span>
<span class="hl ppc">#include &lt;malloc.h&gt;</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_mdebug</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> flag<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;i:mdebug&quot;</span><span class="hl opt">, &amp;</span>flag<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwd">mallopt</span><span class="hl opt">(</span>M_DEBUG<span class="hl opt">,</span> flag<span class="hl opt">);</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>Py_None<span class="hl opt">);</span>
    <span class="hl kwa">return</span> Py_None<span class="hl opt">;</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* USE_MALLOPT */</span><span class="hl ppc"></span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getsizeof</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>kwds<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>res <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>str__sizeof__ <span class="hl opt">=</span> NULL<span class="hl opt">, *</span>gc_head_size <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">static char</span> <span class="hl opt">*</span>kwlist<span class="hl opt">[] = {</span><span class="hl str">&quot;object&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;default&quot;</span><span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">};</span>
    PyObject <span class="hl opt">*</span>o<span class="hl opt">, *</span>dflt <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>method<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTupleAndKeywords</span><span class="hl opt">(</span>args<span class="hl opt">,</span> kwds<span class="hl opt">,</span> <span class="hl str">&quot;O|O:getsizeof&quot;</span><span class="hl opt">,</span>
                                     kwlist<span class="hl opt">, &amp;</span>o<span class="hl opt">, &amp;</span>dflt<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

    <span class="hl com">/* Initialize static variable for GC head size */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>gc_head_size <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        gc_head_size <span class="hl opt">=</span> <span class="hl kwd">PyLong_FromSsize_t</span><span class="hl opt">(</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>PyGC_Head<span class="hl opt">));</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>gc_head_size <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
            <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Make sure the type is initialized. float gets initialized late */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyType_Ready</span><span class="hl opt">(</span><span class="hl kwd">Py_TYPE</span><span class="hl opt">(</span>o<span class="hl opt">)) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

    method <span class="hl opt">=</span> <span class="hl kwd">_PyObject_LookupSpecial</span><span class="hl opt">(</span>o<span class="hl opt">,</span> <span class="hl str">&quot;__sizeof__&quot;</span><span class="hl opt">,</span>
                                     <span class="hl opt">&amp;</span>str__sizeof__<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>method <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyErr_Occurred</span><span class="hl opt">())</span>
            <span class="hl kwd">PyErr_Format</span><span class="hl opt">(</span>PyExc_TypeError<span class="hl opt">,</span>
                         <span class="hl str">&quot;Type %.100s doesn't define __sizeof__&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">Py_TYPE</span><span class="hl opt">(</span>o<span class="hl opt">)-&gt;</span>tp_name<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        res <span class="hl opt">=</span> <span class="hl kwd">PyObject_CallFunctionObjArgs</span><span class="hl opt">(</span>method<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>method<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* Has a default value been given */</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>res <span class="hl opt">==</span> NULL<span class="hl opt">) &amp;&amp; (</span>dflt <span class="hl opt">!=</span> NULL<span class="hl opt">) &amp;&amp;</span>
        <span class="hl kwd">PyErr_ExceptionMatches</span><span class="hl opt">(</span>PyExc_TypeError<span class="hl opt">))</span>
    <span class="hl opt">{</span>
        <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
        <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>dflt<span class="hl opt">);</span>
        <span class="hl kwa">return</span> dflt<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else if</span> <span class="hl opt">(</span>res <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> res<span class="hl opt">;</span>

    <span class="hl com">/* add gc_head size */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyObject_IS_GC</span><span class="hl opt">(</span>o<span class="hl opt">)) {</span>
        PyObject <span class="hl opt">*</span>tmp <span class="hl opt">=</span> res<span class="hl opt">;</span>
        res <span class="hl opt">=</span> <span class="hl kwd">PyNumber_Add</span><span class="hl opt">(</span>tmp<span class="hl opt">,</span> gc_head_size<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>tmp<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> res<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getsizeof_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getsizeof(object, default) -&gt; int</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the size of object in bytes.&quot;</span><span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getrefcount</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>arg<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyLong_FromSsize_t</span><span class="hl opt">(</span>arg<span class="hl opt">-&gt;</span>ob_refcnt<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifdef Py_REF_DEBUG</span>
<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_gettotalrefcount</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">PyLong_FromSsize_t</span><span class="hl opt">(</span><span class="hl kwd">_Py_GetRefTotal</span><span class="hl opt">());</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* Py_REF_DEBUG */</span><span class="hl ppc"></span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getrefcount_doc<span class="hl opt">,</span>
<span class="hl str">&quot;getrefcount(object) -&gt; integer</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return the reference count of object.  The count returned is generally</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">one higher than you might expect, because it includes the (temporary)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">reference as an argument to getrefcount().&quot;</span>
<span class="hl opt">);</span>

<span class="hl ppc">#ifdef COUNT_ALLOCS</span>
<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getcounts</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwc">extern</span> PyObject <span class="hl opt">*</span><span class="hl kwd">get_counts</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">);</span>

    <span class="hl kwa">return</span> <span class="hl kwd">get_counts</span><span class="hl opt">();</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>getframe_doc<span class="hl opt">,</span>
<span class="hl str">&quot;_getframe([depth]) -&gt; frameobject</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return a frame object from the call stack.  If optional integer depth is</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">given, return the frame object that many calls below the top of the stack.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">If that is deeper than the call stack, ValueError is raised.  The default</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">for depth is zero, returning the frame at the top of the call stack.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">This function should be used for internal and specialized</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">purposes only.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_getframe</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyFrameObject <span class="hl opt">*</span>f <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_GET</span><span class="hl opt">()-&gt;</span>frame<span class="hl opt">;</span>
    <span class="hl kwb">int</span> depth <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;|i:_getframe&quot;</span><span class="hl opt">, &amp;</span>depth<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

    <span class="hl kwa">while</span> <span class="hl opt">(</span>depth <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> f <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        f <span class="hl opt">=</span> f<span class="hl opt">-&gt;</span>f_back<span class="hl opt">;</span>
        <span class="hl opt">--</span>depth<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>f <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_SetString</span><span class="hl opt">(</span>PyExc_ValueError<span class="hl opt">,</span>
                        <span class="hl str">&quot;call stack is not deep enough&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>f<span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl opt">(</span>PyObject<span class="hl opt">*)</span>f<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>current_frames_doc<span class="hl opt">,</span>
<span class="hl str">&quot;_current_frames() -&gt; dictionary</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return a dictionary mapping each current thread T's thread id to T's</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">current stack frame.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">This function should be used for specialized purposes only.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_current_frames</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>noargs<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">_PyThread_CurrentFrames</span><span class="hl opt">();</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>call_tracing_doc<span class="hl opt">,</span>
<span class="hl str">&quot;call_tracing(func, args) -&gt; object</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Call func(*args), while tracing is enabled.  The tracing state is</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">saved, and restored afterwards.  This is intended to be called from</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">a debugger from a checkpoint, to recursively debug some other code.&quot;</span>
<span class="hl opt">);</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_call_tracing</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>self<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>func<span class="hl opt">, *</span>funcargs<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyArg_ParseTuple</span><span class="hl opt">(</span>args<span class="hl opt">,</span> <span class="hl str">&quot;OO!:call_tracing&quot;</span><span class="hl opt">, &amp;</span>func<span class="hl opt">, &amp;</span>PyTuple_Type<span class="hl opt">, &amp;</span>funcargs<span class="hl opt">))</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">return</span> <span class="hl kwd">_PyEval_CallTracing</span><span class="hl opt">(</span>func<span class="hl opt">,</span> funcargs<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>callstats_doc<span class="hl opt">,</span>
<span class="hl str">&quot;callstats() -&gt; tuple of integers</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Return a tuple of function call statistics, if CALL_PROFILE was defined</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">when Python was built.  Otherwise, return None.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">When enabled, this function returns detailed, implementation-specific</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">details about the number of function calls executed. The return value is</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">a 11-tuple where the entries in the tuple are counts of:</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">0. all function calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">1. calls to PyFunction_Type objects</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">2. PyFunction calls that do not create an argument tuple</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">3. PyFunction calls that do not create an argument tuple</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">   and bypass PyEval_EvalCodeEx()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">4. PyMethod calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">5. PyMethod calls on bound methods</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">6. PyType calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">7. PyCFunction calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">8. generator calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">9. All other calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">10. Number of stack pops performed by call_function()&quot;</span>
<span class="hl opt">);</span>

<span class="hl ppc">#ifdef __cplusplus</span>
<span class="hl kwc">extern</span> <span class="hl str">&quot;C&quot;</span> <span class="hl opt">{</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifdef Py_TRACE_REFS</span>
<span class="hl com">/* Defined in objects.c because it uses static globals if that file */</span>
<span class="hl kwc">extern</span> PyObject <span class="hl opt">*</span><span class="hl kwd">_Py_GetObjects</span><span class="hl opt">(</span>PyObject <span class="hl opt">*,</span> PyObject <span class="hl opt">*);</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifdef DYNAMIC_EXECUTION_PROFILE</span>
<span class="hl com">/* Defined in ceval.c because it uses static globals if that file */</span>
<span class="hl kwc">extern</span> PyObject <span class="hl opt">*</span><span class="hl kwd">_Py_GetDXProfile</span><span class="hl opt">(</span>PyObject <span class="hl opt">*,</span>  PyObject <span class="hl opt">*);</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifdef __cplusplus</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">sys_clear_type_cache</span><span class="hl opt">(</span>PyObject<span class="hl opt">*</span> self<span class="hl opt">,</span> PyObject<span class="hl opt">*</span> args<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">PyType_ClearCache</span><span class="hl opt">();</span>
    Py_RETURN_NONE<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>sys_clear_type_cache__doc__<span class="hl opt">,</span>
<span class="hl str">&quot;_clear_type_cache() -&gt; None</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Clear the internal type lookup cache.&quot;</span><span class="hl opt">);</span>


<span class="hl kwb">static</span> PyMethodDef sys_methods<span class="hl opt">[] = {</span>
    <span class="hl com">/* Might as well keep this in alphabetic order */</span>
    <span class="hl opt">{</span><span class="hl str">&quot;callstats&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>PyEval_GetCallStats<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span>
     callstats_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;_clear_type_cache&quot;</span><span class="hl opt">,</span>       sys_clear_type_cache<span class="hl opt">,</span>     METH_NOARGS<span class="hl opt">,</span>
     sys_clear_type_cache__doc__<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;_current_frames&quot;</span><span class="hl opt">,</span> sys_current_frames<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span>
     current_frames_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;displayhook&quot;</span><span class="hl opt">,</span>     sys_displayhook<span class="hl opt">,</span> METH_O<span class="hl opt">,</span> displayhook_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;exc_info&quot;</span><span class="hl opt">,</span>        sys_exc_info<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span> exc_info_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;excepthook&quot;</span><span class="hl opt">,</span>      sys_excepthook<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span> excepthook_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;exit&quot;</span><span class="hl opt">,</span>            sys_exit<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span> exit_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getdefaultencoding&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>sys_getdefaultencoding<span class="hl opt">,</span>
     METH_NOARGS<span class="hl opt">,</span> getdefaultencoding_doc<span class="hl opt">},</span>
<span class="hl ppc">#ifdef HAVE_DLOPEN</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getdlopenflags&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>sys_getdlopenflags<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span>
     getdlopenflags_doc<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
<span class="hl ppc">#ifdef COUNT_ALLOCS</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getcounts&quot;</span><span class="hl opt">,       (</span>PyCFunction<span class="hl opt">)</span>sys_getcounts<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
<span class="hl ppc">#ifdef DYNAMIC_EXECUTION_PROFILE</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getdxp&quot;</span><span class="hl opt">,</span>          _Py_GetDXProfile<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getfilesystemencoding&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>sys_getfilesystemencoding<span class="hl opt">,</span>
     METH_NOARGS<span class="hl opt">,</span> getfilesystemencoding_doc<span class="hl opt">},</span>
<span class="hl ppc">#ifdef Py_TRACE_REFS</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getobjects&quot;</span><span class="hl opt">,</span>      _Py_GetObjects<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
<span class="hl ppc">#ifdef Py_REF_DEBUG</span>
    <span class="hl opt">{</span><span class="hl str">&quot;gettotalrefcount&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>sys_gettotalrefcount<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getrefcount&quot;</span><span class="hl opt">,     (</span>PyCFunction<span class="hl opt">)</span>sys_getrefcount<span class="hl opt">,</span> METH_O<span class="hl opt">,</span> getrefcount_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getrecursionlimit&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>sys_getrecursionlimit<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span>
     getrecursionlimit_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getsizeof&quot;</span><span class="hl opt">,   (</span>PyCFunction<span class="hl opt">)</span>sys_getsizeof<span class="hl opt">,</span>
     METH_VARARGS <span class="hl opt">|</span> METH_KEYWORDS<span class="hl opt">,</span> getsizeof_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;_getframe&quot;</span><span class="hl opt">,</span> sys_getframe<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span> getframe_doc<span class="hl opt">},</span>
<span class="hl ppc">#ifdef MS_WINDOWS</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getwindowsversion&quot;</span><span class="hl opt">, (</span>PyCFunction<span class="hl opt">)</span>sys_getwindowsversion<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span>
     getwindowsversion_doc<span class="hl opt">},</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* MS_WINDOWS */</span><span class="hl ppc"></span>
    <span class="hl opt">{</span><span class="hl str">&quot;intern&quot;</span><span class="hl opt">,</span>          sys_intern<span class="hl opt">,</span>     METH_VARARGS<span class="hl opt">,</span> intern_doc<span class="hl opt">},</span>
<span class="hl ppc">#ifdef USE_MALLOPT</span>
    <span class="hl opt">{</span><span class="hl str">&quot;mdebug&quot;</span><span class="hl opt">,</span>          sys_mdebug<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">{</span><span class="hl str">&quot;setdefaultencoding&quot;</span><span class="hl opt">,</span> sys_setdefaultencoding<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span>
     setdefaultencoding_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;setfilesystemencoding&quot;</span><span class="hl opt">,</span> sys_setfilesystemencoding<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span>
     setfilesystemencoding_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;setcheckinterval&quot;</span><span class="hl opt">,</span>        sys_setcheckinterval<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span>
     setcheckinterval_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getcheckinterval&quot;</span><span class="hl opt">,</span>        sys_getcheckinterval<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span>
     getcheckinterval_doc<span class="hl opt">},</span>
<span class="hl ppc">#ifdef HAVE_DLOPEN</span>
    <span class="hl opt">{</span><span class="hl str">&quot;setdlopenflags&quot;</span><span class="hl opt">,</span> sys_setdlopenflags<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span>
     setdlopenflags_doc<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">{</span><span class="hl str">&quot;setprofile&quot;</span><span class="hl opt">,</span>      sys_setprofile<span class="hl opt">,</span> METH_O<span class="hl opt">,</span> setprofile_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;getprofile&quot;</span><span class="hl opt">,</span>      sys_getprofile<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span> getprofile_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;setrecursionlimit&quot;</span><span class="hl opt">,</span> sys_setrecursionlimit<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span>
     setrecursionlimit_doc<span class="hl opt">},</span>
<span class="hl ppc">#ifdef WITH_TSC</span>
    <span class="hl opt">{</span><span class="hl str">&quot;settscdump&quot;</span><span class="hl opt">,</span> sys_settscdump<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span> settscdump_doc<span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
    <span class="hl opt">{</span><span class="hl str">&quot;settrace&quot;</span><span class="hl opt">,</span>        sys_settrace<span class="hl opt">,</span> METH_O<span class="hl opt">,</span> settrace_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;gettrace&quot;</span><span class="hl opt">,</span>        sys_gettrace<span class="hl opt">,</span> METH_NOARGS<span class="hl opt">,</span> gettrace_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;call_tracing&quot;</span><span class="hl opt">,</span> sys_call_tracing<span class="hl opt">,</span> METH_VARARGS<span class="hl opt">,</span> call_tracing_doc<span class="hl opt">},</span>
    <span class="hl opt">{</span>NULL<span class="hl opt">,</span>              NULL<span class="hl opt">}</span>           <span class="hl com">/* sentinel */</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">list_builtin_module_names</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>list <span class="hl opt">=</span> <span class="hl kwd">PyList_New</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>list <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span> PyImport_Inittab<span class="hl opt">[</span>i<span class="hl opt">].</span>name <span class="hl opt">!=</span> NULL<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
        PyObject <span class="hl opt">*</span>name <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>
            PyImport_Inittab<span class="hl opt">[</span>i<span class="hl opt">].</span>name<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>name <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl kwd">PyList_Append</span><span class="hl opt">(</span>list<span class="hl opt">,</span> name<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>name<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyList_Sort</span><span class="hl opt">(</span>list<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>list<span class="hl opt">);</span>
        list <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>list<span class="hl opt">) {</span>
        PyObject <span class="hl opt">*</span>v <span class="hl opt">=</span> <span class="hl kwd">PyList_AsTuple</span><span class="hl opt">(</span>list<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>list<span class="hl opt">);</span>
        list <span class="hl opt">=</span> v<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> list<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>warnoptions <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_ResetWarnOptions</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>warnoptions <span class="hl opt">==</span> NULL <span class="hl opt">|| !</span><span class="hl kwd">PyList_Check</span><span class="hl opt">(</span>warnoptions<span class="hl opt">))</span>
        <span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl kwd">PyList_SetSlice</span><span class="hl opt">(</span>warnoptions<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> <span class="hl kwd">PyList_GET_SIZE</span><span class="hl opt">(</span>warnoptions<span class="hl opt">),</span> NULL<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_AddWarnOption</span><span class="hl opt">(</span><span class="hl kwb">const wchar_t</span> <span class="hl opt">*</span>s<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>str<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>warnoptions <span class="hl opt">==</span> NULL <span class="hl opt">|| !</span><span class="hl kwd">PyList_Check</span><span class="hl opt">(</span>warnoptions<span class="hl opt">)) {</span>
        <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>warnoptions<span class="hl opt">);</span>
        warnoptions <span class="hl opt">=</span> <span class="hl kwd">PyList_New</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>warnoptions <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
            <span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    str <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span>s<span class="hl opt">, -</span><span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>str <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyList_Append</span><span class="hl opt">(</span>warnoptions<span class="hl opt">,</span> str<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>str<span class="hl opt">);</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">PySys_HasWarnOptions</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl opt">(</span>warnoptions <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp; (</span><span class="hl kwd">PyList_Size</span><span class="hl opt">(</span>warnoptions<span class="hl opt">) &gt;</span> <span class="hl num">0</span><span class="hl opt">))</span> ? <span class="hl num">1</span> <span class="hl opt">:</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/* XXX This doc string is too long to be a single string literal in VC++ 5.0.</span>
<span class="hl com">   Two literals concatenated works just fine.  If you have a K&amp;R compiler</span>
<span class="hl com">   or other abomination that however *does* understand longer strings,</span>
<span class="hl com">   get rid of the !!! comment in the middle and the quotes that surround it. */</span>
<span class="hl kwd">PyDoc_VAR</span><span class="hl opt">(</span>sys_doc<span class="hl opt">) =</span>
<span class="hl kwd">PyDoc_STR</span><span class="hl opt">(</span>
<span class="hl str">&quot;This module provides access to some objects used or maintained by the</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">interpreter and to functions that interact strongly with the interpreter.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Dynamic objects:</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">argv -- command line arguments; argv[0] is the script pathname if known</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">path -- module search path; path[0] is the script directory, else ''</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">modules -- dictionary of loaded modules</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">displayhook -- called to show results in an interactive session</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">excepthook -- called to handle any uncaught exception other than SystemExit</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">  To customize printing in an interactive session or to install a custom</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">  top-level exception handler, assign other functions to replace these.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">stdin -- standard input file object; used by input()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">stdout -- standard output file object; used by print()</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">stderr -- standard error object; used for error messages</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">  By assigning other file objects (or objects that behave like files)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">  to these, it is possible to redirect all of the interpreter's I/O.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">last_type -- type of last uncaught exception</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">last_value -- value of last uncaught exception</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">last_traceback -- traceback of last uncaught exception</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">  These three are only available in an interactive session after a</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">  traceback has been printed.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">&quot;</span>
<span class="hl opt">)</span>
<span class="hl com">/* concatenating string here */</span>
<span class="hl kwd">PyDoc_STR</span><span class="hl opt">(</span>
<span class="hl str">&quot;</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Static objects:</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">float_info -- a dict with information about the float implementation.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">int_info -- a struct sequence with information about the int implementation.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">maxsize -- the largest supported length of containers.</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">maxunicode -- the largest supported character</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">builtin_module_names -- tuple of module names built into this interpreter</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">subversion -- subversion information of the build as tuple</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">version -- the version of this interpreter as a string</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">version_info -- version information as a named tuple</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">hexversion -- version information encoded as a single integer</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">copyright -- copyright notice pertaining to this interpreter</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">platform -- platform identifier</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">executable -- pathname of this Python interpreter</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">prefix -- prefix used to find the Python library</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">exec_prefix -- prefix used to find the machine-specific Python library</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">float_repr_style -- string indicating the style of repr() output for floats</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">&quot;</span>
<span class="hl opt">)</span>
<span class="hl ppc">#ifdef MS_WINDOWS</span>
<span class="hl com">/* concatenating string here */</span>
<span class="hl kwd">PyDoc_STR</span><span class="hl opt">(</span>
<span class="hl str">&quot;dllhandle -- [Windows only] integer handle of the Python DLL</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">winver -- [Windows only] version number of the Python DLL</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">&quot;</span>
<span class="hl opt">)</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* MS_WINDOWS */</span><span class="hl ppc"></span>
<span class="hl kwd">PyDoc_STR</span><span class="hl opt">(</span>
<span class="hl str">&quot;__stdin__ -- the original stdin; don't touch!</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">__stdout__ -- the original stdout; don't touch!</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">__stderr__ -- the original stderr; don't touch!</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">__displayhook__ -- the original displayhook; don't touch!</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">__excepthook__ -- the original excepthook; don't touch!</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Functions:</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">displayhook() -- print an object to the screen, and save it in builtins._</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">excepthook() -- print an exception and its traceback to sys.stderr</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">exc_info() -- return thread-safe information about the current exception</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">exit() -- exit the interpreter by raising SystemExit</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">getdlopenflags() -- returns flags to be used for dlopen() calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">getprofile() -- get the global profiling function</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">getrefcount() -- return the reference count for an object (plus one :-)</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">getrecursionlimit() -- return the max recursion depth for the interpreter</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">getsizeof() -- return the size of an object in bytes</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">gettrace() -- get the global debug tracing function</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">setcheckinterval() -- control how often the interpreter checks for events</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">setdlopenflags() -- set the flags to be used for dlopen() calls</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">setprofile() -- set the global profiling function</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">setrecursionlimit() -- set the max recursion depth for the interpreter</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">settrace() -- set the global debug tracing function</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">&quot;</span>
<span class="hl opt">)</span>
<span class="hl com">/* end of sys_doc */</span> <span class="hl opt">;</span>

<span class="hl com">/* Subversion branch and revision management */</span>
<span class="hl kwb">static const char</span> _patchlevel_revision<span class="hl opt">[] =</span> PY_PATCHLEVEL_REVISION<span class="hl opt">;</span>
<span class="hl kwb">static const char</span> headurl<span class="hl opt">[] =</span> <span class="hl str">&quot;$HeadURL$&quot;</span><span class="hl opt">;</span>
<span class="hl kwb">static int</span> svn_initialized<span class="hl opt">;</span>
<span class="hl kwb">static char</span> patchlevel_revision<span class="hl opt">[</span><span class="hl num">50</span><span class="hl opt">];</span> <span class="hl com">/* Just the number */</span>
<span class="hl kwb">static char</span> branch<span class="hl opt">[</span><span class="hl num">50</span><span class="hl opt">];</span>
<span class="hl kwb">static char</span> shortbranch<span class="hl opt">[</span><span class="hl num">50</span><span class="hl opt">];</span>
<span class="hl kwb">static const char</span> <span class="hl opt">*</span>svn_revision<span class="hl opt">;</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">svnversion_init</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>python<span class="hl opt">, *</span>br_start<span class="hl opt">, *</span>br_end<span class="hl opt">, *</span>br_end2<span class="hl opt">, *</span>svnversion<span class="hl opt">;</span>
    Py_ssize_t len<span class="hl opt">;</span>
    <span class="hl kwb">int</span> istag <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>svn_initialized<span class="hl opt">)</span>
        <span class="hl kwa">return</span><span class="hl opt">;</span>

    python <span class="hl opt">=</span> <span class="hl kwd">strstr</span><span class="hl opt">(</span>headurl<span class="hl opt">,</span> <span class="hl str">&quot;/python/&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>python<span class="hl opt">) {</span>
        <span class="hl kwd">strcpy</span><span class="hl opt">(</span>branch<span class="hl opt">,</span> <span class="hl str">&quot;unknown branch&quot;</span><span class="hl opt">);</span>
        <span class="hl kwd">strcpy</span><span class="hl opt">(</span>shortbranch<span class="hl opt">,</span> <span class="hl str">&quot;unknown&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        br_start <span class="hl opt">=</span> python <span class="hl opt">+</span> <span class="hl num">8</span><span class="hl opt">;</span>
        br_end <span class="hl opt">=</span> <span class="hl kwd">strchr</span><span class="hl opt">(</span>br_start<span class="hl opt">,</span> <span class="hl str">'/'</span><span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>br_end<span class="hl opt">);</span>

        <span class="hl com">/* Works even for trunk,</span>
<span class="hl com">           as we are in trunk/Python/sysmodule.c */</span>
        br_end2 <span class="hl opt">=</span> <span class="hl kwd">strchr</span><span class="hl opt">(</span>br_end<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">,</span> <span class="hl str">'/'</span><span class="hl opt">);</span>

        istag <span class="hl opt">=</span> <span class="hl kwd">strncmp</span><span class="hl opt">(</span>br_start<span class="hl opt">,</span> <span class="hl str">&quot;tags&quot;</span><span class="hl opt">,</span> <span class="hl num">4</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strncmp</span><span class="hl opt">(</span>br_start<span class="hl opt">,</span> <span class="hl str">&quot;trunk&quot;</span><span class="hl opt">,</span> <span class="hl num">5</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            <span class="hl kwd">strcpy</span><span class="hl opt">(</span>branch<span class="hl opt">,</span> <span class="hl str">&quot;trunk&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">strcpy</span><span class="hl opt">(</span>shortbranch<span class="hl opt">,</span> <span class="hl str">&quot;trunk&quot;</span><span class="hl opt">);</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">else if</span> <span class="hl opt">(</span>istag <span class="hl opt">||</span> <span class="hl kwd">strncmp</span><span class="hl opt">(</span>br_start<span class="hl opt">,</span> <span class="hl str">&quot;branches&quot;</span><span class="hl opt">,</span> <span class="hl num">8</span><span class="hl opt">) ==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            len <span class="hl opt">=</span> br_end2 <span class="hl opt">-</span> br_start<span class="hl opt">;</span>
            <span class="hl kwd">strncpy</span><span class="hl opt">(</span>branch<span class="hl opt">,</span> br_start<span class="hl opt">,</span> len<span class="hl opt">);</span>
            branch<span class="hl opt">[</span>len<span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>

            len <span class="hl opt">=</span> br_end2 <span class="hl opt">- (</span>br_end <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">);</span>
            <span class="hl kwd">strncpy</span><span class="hl opt">(</span>shortbranch<span class="hl opt">,</span> br_end <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">,</span> len<span class="hl opt">);</span>
            shortbranch<span class="hl opt">[</span>len<span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">else</span> <span class="hl opt">{</span>
            <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;bad HeadURL&quot;</span><span class="hl opt">);</span>
            <span class="hl kwa">return</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>


    svnversion <span class="hl opt">=</span> <span class="hl kwd">_Py_svnversion</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strcmp</span><span class="hl opt">(</span>svnversion<span class="hl opt">,</span> <span class="hl str">&quot;Unversioned directory&quot;</span><span class="hl opt">) !=</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">strcmp</span><span class="hl opt">(</span>svnversion<span class="hl opt">,</span> <span class="hl str">&quot;exported&quot;</span><span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        svn_revision <span class="hl opt">=</span> svnversion<span class="hl opt">;</span>
    <span class="hl kwa">else if</span> <span class="hl opt">(</span>istag<span class="hl opt">) {</span>
        len <span class="hl opt">=</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>_patchlevel_revision<span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>len <span class="hl opt">&gt;=</span> <span class="hl num">13</span><span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>len <span class="hl opt">&lt; (</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>patchlevel_revision<span class="hl opt">) +</span> <span class="hl num">13</span><span class="hl opt">));</span>
        <span class="hl kwd">strncpy</span><span class="hl opt">(</span>patchlevel_revision<span class="hl opt">,</span> _patchlevel_revision <span class="hl opt">+</span> <span class="hl num">11</span><span class="hl opt">,</span>
            len <span class="hl opt">-</span> <span class="hl num">13</span><span class="hl opt">);</span>
        patchlevel_revision<span class="hl opt">[</span>len <span class="hl opt">-</span> <span class="hl num">13</span><span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
        svn_revision <span class="hl opt">=</span> patchlevel_revision<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span>
        svn_revision <span class="hl opt">=</span> <span class="hl str">&quot;&quot;</span><span class="hl opt">;</span>

    svn_initialized <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl com">/* Return svnversion output if available.</span>
<span class="hl com">   Else return Revision of patchlevel.h if on branch.</span>
<span class="hl com">   Else return empty string */</span>
<span class="hl kwb">const char</span><span class="hl opt">*</span>
<span class="hl kwd">Py_SubversionRevision</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
    <span class="hl kwd">svnversion_init</span><span class="hl opt">();</span>
    <span class="hl kwa">return</span> svn_revision<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">const char</span><span class="hl opt">*</span>
<span class="hl kwd">Py_SubversionShortBranch</span><span class="hl opt">()</span>
<span class="hl opt">{</span>
    <span class="hl kwd">svnversion_init</span><span class="hl opt">();</span>
    <span class="hl kwa">return</span> shortbranch<span class="hl opt">;</span>
<span class="hl opt">}</span>


<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>flags__doc__<span class="hl opt">,</span>
<span class="hl str">&quot;sys.flags</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Flags provided through command line arguments or environment vars.&quot;</span><span class="hl opt">);</span>

<span class="hl kwb">static</span> PyTypeObject FlagsType<span class="hl opt">;</span>

<span class="hl kwb">static</span> PyStructSequence_Field flags_fields<span class="hl opt">[] = {</span>
    <span class="hl opt">{</span><span class="hl str">&quot;debug&quot;</span><span class="hl opt">,</span>                   <span class="hl str">&quot;-d&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;division_warning&quot;</span><span class="hl opt">,</span>        <span class="hl str">&quot;-Q&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;inspect&quot;</span><span class="hl opt">,</span>                 <span class="hl str">&quot;-i&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;interactive&quot;</span><span class="hl opt">,</span>             <span class="hl str">&quot;-i&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;optimize&quot;</span><span class="hl opt">,</span>                <span class="hl str">&quot;-O or -OO&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;dont_write_bytecode&quot;</span><span class="hl opt">,</span>     <span class="hl str">&quot;-B&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;no_user_site&quot;</span><span class="hl opt">,</span>            <span class="hl str">&quot;-s&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;no_site&quot;</span><span class="hl opt">,</span>                 <span class="hl str">&quot;-S&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;ignore_environment&quot;</span><span class="hl opt">,</span>      <span class="hl str">&quot;-E&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;verbose&quot;</span><span class="hl opt">,</span>                 <span class="hl str">&quot;-v&quot;</span><span class="hl opt">},</span>
<span class="hl ppc">#ifdef RISCOS</span>
    <span class="hl opt">{</span><span class="hl str">&quot;riscos_wimp&quot;</span><span class="hl opt">,</span>             <span class="hl str">&quot;???&quot;</span><span class="hl opt">},</span>
<span class="hl ppc">#endif</span>
    <span class="hl com">/* {&quot;unbuffered&quot;,                   &quot;-u&quot;}, */</span>
    <span class="hl com">/* {&quot;skip_first&quot;,                   &quot;-x&quot;}, */</span>
    <span class="hl opt">{</span><span class="hl str">&quot;bytes_warning&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;-b&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl num">0</span><span class="hl opt">}</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> PyStructSequence_Desc flags_desc <span class="hl opt">= {</span>
    <span class="hl str">&quot;sys.flags&quot;</span><span class="hl opt">,</span>        <span class="hl com">/* name */</span>
    flags__doc__<span class="hl opt">,</span>       <span class="hl com">/* doc */</span>
    flags_fields<span class="hl opt">,</span>       <span class="hl com">/* fields */</span>
<span class="hl ppc">#ifdef RISCOS</span>
    <span class="hl num">12</span>
<span class="hl ppc">#else</span>
    <span class="hl num">11</span>
<span class="hl ppc">#endif</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> PyObject<span class="hl opt">*</span>
<span class="hl kwd">make_flags</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> pos <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>seq<span class="hl opt">;</span>

    seq <span class="hl opt">=</span> <span class="hl kwd">PyStructSequence_New</span><span class="hl opt">(&amp;</span>FlagsType<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>seq <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>

<span class="hl ppc">#define SetFlag(flag) \</span>
<span class="hl ppc">    PyStructSequence_SET_ITEM(seq, pos++, PyLong_FromLong(flag))</span>

    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_DebugFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_DivisionWarningFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_InspectFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_InteractiveFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_OptimizeFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_DontWriteBytecodeFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_NoUserSiteDirectory<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_NoSiteFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_IgnoreEnvironmentFlag<span class="hl opt">);</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_VerboseFlag<span class="hl opt">);</span>
<span class="hl ppc">#ifdef RISCOS</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_RISCOSWimpFlag<span class="hl opt">);</span>
<span class="hl ppc">#endif</span>
    <span class="hl com">/* SetFlag(saw_unbuffered_flag); */</span>
    <span class="hl com">/* SetFlag(skipfirstline); */</span>
    <span class="hl kwd">SetFlag</span><span class="hl opt">(</span>Py_BytesWarningFlag<span class="hl opt">);</span>
<span class="hl ppc">#undef SetFlag</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyErr_Occurred</span><span class="hl opt">()) {</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> seq<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwd">PyDoc_STRVAR</span><span class="hl opt">(</span>version_info__doc__<span class="hl opt">,</span>
<span class="hl str">&quot;sys.version_info</span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str"></span><span class="hl esc">\n</span><span class="hl str">\</span>
<span class="hl str">Version information as a named tuple.&quot;</span><span class="hl opt">);</span>

<span class="hl kwb">static</span> PyTypeObject VersionInfoType<span class="hl opt">;</span>

<span class="hl kwb">static</span> PyStructSequence_Field version_info_fields<span class="hl opt">[] = {</span>
    <span class="hl opt">{</span><span class="hl str">&quot;major&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;Major release number&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;minor&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;Minor release number&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;micro&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;Patch release number&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;releaselevel&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;'alpha', 'beta', 'candidate', or 'release'&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl str">&quot;serial&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;Serial release number&quot;</span><span class="hl opt">},</span>
    <span class="hl opt">{</span><span class="hl num">0</span><span class="hl opt">}</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> PyStructSequence_Desc version_info_desc <span class="hl opt">= {</span>
    <span class="hl str">&quot;sys.version_info&quot;</span><span class="hl opt">,</span>     <span class="hl com">/* name */</span>
    version_info__doc__<span class="hl opt">,</span>    <span class="hl com">/* doc */</span>
    version_info_fields<span class="hl opt">,</span>    <span class="hl com">/* fields */</span>
    <span class="hl num">5</span>
<span class="hl opt">};</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">make_version_info</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>version_info<span class="hl opt">;</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>s<span class="hl opt">;</span>
    <span class="hl kwb">int</span> pos <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    version_info <span class="hl opt">=</span> <span class="hl kwd">PyStructSequence_New</span><span class="hl opt">(&amp;</span>VersionInfoType<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>version_info <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl com">/*</span>
<span class="hl com">     * These release level checks are mutually exclusive and cover</span>
<span class="hl com">     * the field, so don't get too fancy with the pre-processor!</span>
<span class="hl com">     */</span>
<span class="hl ppc">#if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA</span>
    s <span class="hl opt">=</span> <span class="hl str">&quot;alpha&quot;</span><span class="hl opt">;</span>
<span class="hl ppc">#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA</span>
    s <span class="hl opt">=</span> <span class="hl str">&quot;beta&quot;</span><span class="hl opt">;</span>
<span class="hl ppc">#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA</span>
    s <span class="hl opt">=</span> <span class="hl str">&quot;candidate&quot;</span><span class="hl opt">;</span>
<span class="hl ppc">#elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL</span>
    s <span class="hl opt">=</span> <span class="hl str">&quot;final&quot;</span><span class="hl opt">;</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#define SetIntItem(flag) \</span>
<span class="hl ppc">    PyStructSequence_SET_ITEM(version_info, pos++, PyLong_FromLong(flag))</span>
<span class="hl ppc">#define SetStrItem(flag) \</span>
<span class="hl ppc">    PyStructSequence_SET_ITEM(version_info, pos++, PyUnicode_FromString(flag))</span>

    <span class="hl kwd">SetIntItem</span><span class="hl opt">(</span>PY_MAJOR_VERSION<span class="hl opt">);</span>
    <span class="hl kwd">SetIntItem</span><span class="hl opt">(</span>PY_MINOR_VERSION<span class="hl opt">);</span>
    <span class="hl kwd">SetIntItem</span><span class="hl opt">(</span>PY_MICRO_VERSION<span class="hl opt">);</span>
    <span class="hl kwd">SetStrItem</span><span class="hl opt">(</span>s<span class="hl opt">);</span>
    <span class="hl kwd">SetIntItem</span><span class="hl opt">(</span>PY_RELEASE_SERIAL<span class="hl opt">);</span>
<span class="hl ppc">#undef SetIntItem</span>
<span class="hl ppc">#undef SetStrItem</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyErr_Occurred</span><span class="hl opt">()) {</span>
        <span class="hl kwd">Py_CLEAR</span><span class="hl opt">(</span>version_info<span class="hl opt">);</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> version_info<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static struct</span> PyModuleDef sysmodule <span class="hl opt">= {</span>
    PyModuleDef_HEAD_INIT<span class="hl opt">,</span>
    <span class="hl str">&quot;sys&quot;</span><span class="hl opt">,</span>
    sys_doc<span class="hl opt">,</span>
    <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">,</span> <span class="hl com">/* multiple &quot;initialization&quot; just copies the module dict. */</span>
    sys_methods<span class="hl opt">,</span>
    NULL<span class="hl opt">,</span>
    NULL<span class="hl opt">,</span>
    NULL<span class="hl opt">,</span>
    NULL
<span class="hl opt">};</span>

PyObject <span class="hl opt">*</span>
<span class="hl kwd">_PySys_Init</span><span class="hl opt">(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>m<span class="hl opt">, *</span>v<span class="hl opt">, *</span>sysdict<span class="hl opt">;</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>s<span class="hl opt">;</span>

    m <span class="hl opt">=</span> <span class="hl kwd">PyModule_Create</span><span class="hl opt">(&amp;</span>sysmodule<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>m <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    sysdict <span class="hl opt">=</span> <span class="hl kwd">PyModule_GetDict</span><span class="hl opt">(</span>m<span class="hl opt">);</span>
<span class="hl ppc">#define SET_SYS_FROM_STRING(key, value)                 \</span>
<span class="hl ppc">    v = value;                                          \</span>
<span class="hl ppc">    if (v != NULL)                                      \</span>
<span class="hl ppc">        PyDict_SetItemString(sysdict, key, v);          \</span>
<span class="hl ppc">    Py_XDECREF(v)</span>

    <span class="hl com">/* Check that stdin is not a directory</span>
<span class="hl com">    Using shell redirection, you can redirect stdin to a directory,</span>
<span class="hl com">    crashing the Python interpreter. Catch this common mistake here</span>
<span class="hl com">    and output a useful error message. Note that under MS Windows,</span>
<span class="hl com">    the shell already prevents that. */</span>
<span class="hl ppc">#if !defined(MS_WINDOWS)</span>
    <span class="hl opt">{</span>
        <span class="hl kwb">struct</span> stat sb<span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">fstat</span><span class="hl opt">(</span><span class="hl kwd">fileno</span><span class="hl opt">(</span>stdin<span class="hl opt">), &amp;</span>sb<span class="hl opt">) ==</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span>
            <span class="hl kwd">S_ISDIR</span><span class="hl opt">(</span>sb<span class="hl opt">.</span>st_mode<span class="hl opt">)) {</span>
            <span class="hl com">/* There's nothing more we can do. */</span>
            <span class="hl com">/* Py_FatalError() will core dump, so just exit. */</span>
            <span class="hl kwd">PySys_WriteStderr</span><span class="hl opt">(</span><span class="hl str">&quot;Python error: &lt;stdin&gt; is a directory, cannot continue</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">exit</span><span class="hl opt">(</span>EXIT_FAILURE<span class="hl opt">);</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
<span class="hl ppc">#endif</span>

    <span class="hl com">/* stdin/stdout/stderr are now set by pythonrun.c */</span>

    <span class="hl kwd">PyDict_SetItemString</span><span class="hl opt">(</span>sysdict<span class="hl opt">,</span> <span class="hl str">&quot;__displayhook__&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">PyDict_GetItemString</span><span class="hl opt">(</span>sysdict<span class="hl opt">,</span> <span class="hl str">&quot;displayhook&quot;</span><span class="hl opt">));</span>
    <span class="hl kwd">PyDict_SetItemString</span><span class="hl opt">(</span>sysdict<span class="hl opt">,</span> <span class="hl str">&quot;__excepthook__&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">PyDict_GetItemString</span><span class="hl opt">(</span>sysdict<span class="hl opt">,</span> <span class="hl str">&quot;excepthook&quot;</span><span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;version&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span><span class="hl kwd">Py_GetVersion</span><span class="hl opt">()));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;hexversion&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">PyLong_FromLong</span><span class="hl opt">(</span>PY_VERSION_HEX<span class="hl opt">));</span>
    <span class="hl kwd">svnversion_init</span><span class="hl opt">();</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;subversion&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">Py_BuildValue</span><span class="hl opt">(</span><span class="hl str">&quot;(UUU)&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;CPython&quot;</span><span class="hl opt">,</span> branch<span class="hl opt">,</span>
                                      svn_revision<span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;_mercurial&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">Py_BuildValue</span><span class="hl opt">(</span><span class="hl str">&quot;(szz)&quot;</span><span class="hl opt">,</span> <span class="hl str">&quot;CPython&quot;</span><span class="hl opt">,</span> <span class="hl kwd">_Py_hgidentifier</span><span class="hl opt">(),</span>
                                      <span class="hl kwd">_Py_hgversion</span><span class="hl opt">()));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;dont_write_bytecode&quot;</span><span class="hl opt">,</span>
                         <span class="hl kwd">PyBool_FromLong</span><span class="hl opt">(</span>Py_DontWriteBytecodeFlag<span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;api_version&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyLong_FromLong</span><span class="hl opt">(</span>PYTHON_API_VERSION<span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;copyright&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span><span class="hl kwd">Py_GetCopyright</span><span class="hl opt">()));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;platform&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span><span class="hl kwd">Py_GetPlatform</span><span class="hl opt">()));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;executable&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span>
                               <span class="hl kwd">Py_GetProgramFullPath</span><span class="hl opt">(), -</span><span class="hl num">1</span><span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;prefix&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span><span class="hl kwd">Py_GetPrefix</span><span class="hl opt">(), -</span><span class="hl num">1</span><span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;exec_prefix&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span><span class="hl kwd">Py_GetExecPrefix</span><span class="hl opt">(), -</span><span class="hl num">1</span><span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;maxsize&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyLong_FromSsize_t</span><span class="hl opt">(</span>PY_SSIZE_T_MAX<span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;float_info&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyFloat_GetInfo</span><span class="hl opt">());</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;int_info&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyLong_GetInfo</span><span class="hl opt">());</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;maxunicode&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyLong_FromLong</span><span class="hl opt">(</span><span class="hl kwd">PyUnicode_GetMax</span><span class="hl opt">()));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;builtin_module_names&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">list_builtin_module_names</span><span class="hl opt">());</span>
    <span class="hl opt">{</span>
        <span class="hl com">/* Assumes that longs are at least 2 bytes long.</span>
<span class="hl com">           Should be safe! */</span>
        <span class="hl kwb">unsigned long</span> number <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl kwb">char</span> <span class="hl opt">*</span>value<span class="hl opt">;</span>

        s <span class="hl opt">= (</span><span class="hl kwb">char</span> <span class="hl opt">*) &amp;</span>number<span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>s<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ==</span> <span class="hl num">0</span><span class="hl opt">)</span>
            value <span class="hl opt">=</span> <span class="hl str">&quot;big&quot;</span><span class="hl opt">;</span>
        <span class="hl kwa">else</span>
            value <span class="hl opt">=</span> <span class="hl str">&quot;little&quot;</span><span class="hl opt">;</span>
        <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;byteorder&quot;</span><span class="hl opt">,</span>
                            <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>value<span class="hl opt">));</span>
    <span class="hl opt">}</span>
<span class="hl ppc">#ifdef MS_COREDLL</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;dllhandle&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyLong_FromVoidPtr</span><span class="hl opt">(</span>PyWin_DLLhModule<span class="hl opt">));</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;winver&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>PyWin_DLLVersionString<span class="hl opt">));</span>
<span class="hl ppc">#endif</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>warnoptions <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        warnoptions <span class="hl opt">=</span> <span class="hl kwd">PyList_New</span><span class="hl opt">(</span><span class="hl num">0</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">else</span> <span class="hl opt">{</span>
        <span class="hl kwd">Py_INCREF</span><span class="hl opt">(</span>warnoptions<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>warnoptions <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyDict_SetItemString</span><span class="hl opt">(</span>sysdict<span class="hl opt">,</span> <span class="hl str">&quot;warnoptions&quot;</span><span class="hl opt">,</span> warnoptions<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* version_info */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>VersionInfoType<span class="hl opt">.</span>tp_name <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">PyStructSequence_InitType</span><span class="hl opt">(&amp;</span>VersionInfoType<span class="hl opt">, &amp;</span>version_info_desc<span class="hl opt">);</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;version_info&quot;</span><span class="hl opt">,</span> <span class="hl kwd">make_version_info</span><span class="hl opt">());</span>
    <span class="hl com">/* prevent user from creating new instances */</span>
    VersionInfoType<span class="hl opt">.</span>tp_init <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    VersionInfoType<span class="hl opt">.</span>tp_new <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

    <span class="hl com">/* flags */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>FlagsType<span class="hl opt">.</span>tp_name <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">PyStructSequence_InitType</span><span class="hl opt">(&amp;</span>FlagsType<span class="hl opt">, &amp;</span>flags_desc<span class="hl opt">);</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;flags&quot;</span><span class="hl opt">,</span> <span class="hl kwd">make_flags</span><span class="hl opt">());</span>
    <span class="hl com">/* prevent user from creating new instances */</span>
    FlagsType<span class="hl opt">.</span>tp_init <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    FlagsType<span class="hl opt">.</span>tp_new <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

    <span class="hl com">/* float repr style: 0.03 (short) vs 0.029999999999999999 (legacy) */</span>
<span class="hl ppc">#ifndef PY_NO_SHORT_FLOAT_REPR</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;float_repr_style&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span><span class="hl str">&quot;short&quot;</span><span class="hl opt">));</span>
<span class="hl ppc">#else</span>
    <span class="hl kwd">SET_SYS_FROM_STRING</span><span class="hl opt">(</span><span class="hl str">&quot;float_repr_style&quot;</span><span class="hl opt">,</span>
                        <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span><span class="hl str">&quot;legacy&quot;</span><span class="hl opt">));</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#undef SET_SYS_FROM_STRING</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyErr_Occurred</span><span class="hl opt">())</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">return</span> m<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">makepathobject</span><span class="hl opt">(</span><span class="hl kwb">const wchar_t</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> <span class="hl kwb">wchar_t</span> delim<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> i<span class="hl opt">,</span> n<span class="hl opt">;</span>
    <span class="hl kwb">const wchar_t</span> <span class="hl opt">*</span>p<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>v<span class="hl opt">, *</span>w<span class="hl opt">;</span>

    n <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    p <span class="hl opt">=</span> path<span class="hl opt">;</span>
    <span class="hl kwa">while</span> <span class="hl opt">((</span>p <span class="hl opt">=</span> <span class="hl kwd">wcschr</span><span class="hl opt">(</span>p<span class="hl opt">,</span> delim<span class="hl opt">)) !=</span> NULL<span class="hl opt">) {</span>
        n<span class="hl opt">++;</span>
        p<span class="hl opt">++;</span>
    <span class="hl opt">}</span>
    v <span class="hl opt">=</span> <span class="hl kwd">PyList_New</span><span class="hl opt">(</span>n<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>v <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl kwa">for</span> <span class="hl opt">(</span>i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">; ;</span> i<span class="hl opt">++) {</span>
        p <span class="hl opt">=</span> <span class="hl kwd">wcschr</span><span class="hl opt">(</span>path<span class="hl opt">,</span> delim<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>p <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
            p <span class="hl opt">=</span> path <span class="hl opt">+</span> <span class="hl kwd">wcslen</span><span class="hl opt">(</span>path<span class="hl opt">);</span> <span class="hl com">/* End of string */</span>
        w <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span>path<span class="hl opt">, (</span>Py_ssize_t<span class="hl opt">)(</span>p <span class="hl opt">-</span> path<span class="hl opt">));</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>w <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
            <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
            <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwd">PyList_SetItem</span><span class="hl opt">(</span>v<span class="hl opt">,</span> i<span class="hl opt">,</span> w<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(*</span>p <span class="hl opt">==</span> <span class="hl str">'\0'</span><span class="hl opt">)</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        path <span class="hl opt">=</span> p<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> v<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_SetPath</span><span class="hl opt">(</span><span class="hl kwb">const wchar_t</span> <span class="hl opt">*</span>path<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>v<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">((</span>v <span class="hl opt">=</span> <span class="hl kwd">makepathobject</span><span class="hl opt">(</span>path<span class="hl opt">,</span> DELIM<span class="hl opt">)) ==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;can't create sys.path&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PySys_SetObject</span><span class="hl opt">(</span><span class="hl str">&quot;path&quot;</span><span class="hl opt">,</span> v<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;can't assign sys.path&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">static</span> PyObject <span class="hl opt">*</span>
<span class="hl kwd">makeargvobject</span><span class="hl opt">(</span><span class="hl kwb">int</span> argc<span class="hl opt">,</span> <span class="hl kwb">wchar_t</span> <span class="hl opt">**</span>argv<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>av<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>argc <span class="hl opt">&lt;=</span> <span class="hl num">0</span> <span class="hl opt">||</span> argv <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl com">/* Ensure at least one (empty) argument is seen */</span>
        <span class="hl kwb">static wchar_t</span> <span class="hl opt">*</span>empty_argv<span class="hl opt">[</span><span class="hl num">1</span><span class="hl opt">] = {</span>L<span class="hl str">&quot;&quot;</span><span class="hl opt">};</span>
        argv <span class="hl opt">=</span> empty_argv<span class="hl opt">;</span>
        argc <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    av <span class="hl opt">=</span> <span class="hl kwd">PyList_New</span><span class="hl opt">(</span>argc<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>av <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwb">int</span> i<span class="hl opt">;</span>
        <span class="hl kwa">for</span> <span class="hl opt">(</span>i <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span> i <span class="hl opt">&lt;</span> argc<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
<span class="hl ppc">#ifdef __VMS</span>
            PyObject <span class="hl opt">*</span>v<span class="hl opt">;</span>

            <span class="hl com">/* argv[0] is the script pathname if known */</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>i <span class="hl opt">==</span> <span class="hl num">0</span><span class="hl opt">) {</span>
                <span class="hl kwb">char</span><span class="hl opt">*</span> fn <span class="hl opt">=</span> decc$<span class="hl kwd">translate_vms</span><span class="hl opt">(</span>argv<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]);</span>
                <span class="hl kwa">if</span> <span class="hl opt">((</span>fn <span class="hl opt">== (</span><span class="hl kwb">char</span> <span class="hl opt">*)</span><span class="hl num">0</span><span class="hl opt">) ||</span> fn <span class="hl opt">== (</span><span class="hl kwb">char</span> <span class="hl opt">*)-</span><span class="hl num">1</span><span class="hl opt">)</span>
                    v <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>argv<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]);</span>
                <span class="hl kwa">else</span>
                    v <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>
                        decc$<span class="hl kwd">translate_vms</span><span class="hl opt">(</span>argv<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]));</span>
            <span class="hl opt">}</span> <span class="hl kwa">else</span>
                v <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>argv<span class="hl opt">[</span>i<span class="hl opt">]);</span>
<span class="hl ppc">#else</span>
            PyObject <span class="hl opt">*</span>v <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span>argv<span class="hl opt">[</span>i<span class="hl opt">], -</span><span class="hl num">1</span><span class="hl opt">);</span>
<span class="hl ppc">#endif</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>v <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
                <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>av<span class="hl opt">);</span>
                av <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwd">PyList_SetItem</span><span class="hl opt">(</span>av<span class="hl opt">,</span> i<span class="hl opt">,</span> v<span class="hl opt">);</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> av<span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifdef HAVE_REALPATH</span>
<span class="hl kwb">static wchar_t</span><span class="hl opt">*</span>
<span class="hl kwd">_wrealpath</span><span class="hl opt">(</span><span class="hl kwb">const wchar_t</span> <span class="hl opt">*</span>path<span class="hl opt">,</span> <span class="hl kwb">wchar_t</span> <span class="hl opt">*</span>resolved_path<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">char</span> cpath<span class="hl opt">[</span>PATH_MAX<span class="hl opt">];</span>
    <span class="hl kwb">char</span> cresolved_path<span class="hl opt">[</span>PATH_MAX<span class="hl opt">];</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>res<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span> r<span class="hl opt">;</span>
    r <span class="hl opt">=</span> <span class="hl kwd">wcstombs</span><span class="hl opt">(</span>cpath<span class="hl opt">,</span> path<span class="hl opt">,</span> PATH_MAX<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>r <span class="hl opt">== (</span><span class="hl kwb">size_t</span><span class="hl opt">)-</span><span class="hl num">1</span> <span class="hl opt">||</span> r <span class="hl opt">&gt;=</span> PATH_MAX<span class="hl opt">) {</span>
        errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    res <span class="hl opt">=</span> <span class="hl kwd">realpath</span><span class="hl opt">(</span>cpath<span class="hl opt">,</span> cresolved_path<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>res <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    r <span class="hl opt">=</span> <span class="hl kwd">mbstowcs</span><span class="hl opt">(</span>resolved_path<span class="hl opt">,</span> cresolved_path<span class="hl opt">,</span> PATH_MAX<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>r <span class="hl opt">== (</span><span class="hl kwb">size_t</span><span class="hl opt">)-</span><span class="hl num">1</span> <span class="hl opt">||</span> r <span class="hl opt">&gt;=</span> PATH_MAX<span class="hl opt">) {</span>
        errno <span class="hl opt">=</span> EINVAL<span class="hl opt">;</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">return</span> resolved_path<span class="hl opt">;</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_SetArgvEx</span><span class="hl opt">(</span><span class="hl kwb">int</span> argc<span class="hl opt">,</span> <span class="hl kwb">wchar_t</span> <span class="hl opt">**</span>argv<span class="hl opt">,</span> <span class="hl kwb">int</span> updatepath<span class="hl opt">)</span>
<span class="hl opt">{</span>
<span class="hl ppc">#if defined(HAVE_REALPATH)</span>
    <span class="hl kwb">wchar_t</span> fullpath<span class="hl opt">[</span>MAXPATHLEN<span class="hl opt">];</span>
<span class="hl ppc">#elif defined(MS_WINDOWS) &amp;&amp; !defined(MS_WINCE)</span>
    <span class="hl kwb">wchar_t</span> fullpath<span class="hl opt">[</span>MAX_PATH<span class="hl opt">];</span>
<span class="hl ppc">#endif</span>
    PyObject <span class="hl opt">*</span>av <span class="hl opt">=</span> <span class="hl kwd">makeargvobject</span><span class="hl opt">(</span>argc<span class="hl opt">,</span> argv<span class="hl opt">);</span>
    PyObject <span class="hl opt">*</span>path <span class="hl opt">=</span> <span class="hl kwd">PySys_GetObject</span><span class="hl opt">(</span><span class="hl str">&quot;path&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>av <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;no mem for sys.argv&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PySys_SetObject</span><span class="hl opt">(</span><span class="hl str">&quot;argv&quot;</span><span class="hl opt">,</span> av<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
        <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;can't assign sys.argv&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>updatepath <span class="hl opt">&amp;&amp;</span> path <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwb">wchar_t</span> <span class="hl opt">*</span>argv0 <span class="hl opt">=</span> argv<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">];</span>
        <span class="hl kwb">wchar_t</span> <span class="hl opt">*</span>p <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
        Py_ssize_t n <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        PyObject <span class="hl opt">*</span>a<span class="hl opt">;</span>
        <span class="hl kwc">extern</span> <span class="hl kwb">int</span> <span class="hl kwd">_Py_wreadlink</span><span class="hl opt">(</span><span class="hl kwb">const wchar_t</span> <span class="hl opt">*,</span> <span class="hl kwb">wchar_t</span> <span class="hl opt">*,</span> <span class="hl kwb">size_t</span><span class="hl opt">);</span>
<span class="hl ppc">#ifdef HAVE_READLINK</span>
        <span class="hl kwb">wchar_t</span> link<span class="hl opt">[</span>MAXPATHLEN<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">];</span>
        <span class="hl kwb">wchar_t</span> argv0copy<span class="hl opt">[</span><span class="hl num">2</span><span class="hl opt">*</span>MAXPATHLEN<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">];</span>
        <span class="hl kwb">int</span> nr <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>argc <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> argv0 <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">wcscmp</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> L<span class="hl str">&quot;-c&quot;</span><span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">)</span>
            nr <span class="hl opt">=</span> <span class="hl kwd">_Py_wreadlink</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> link<span class="hl opt">,</span> MAXPATHLEN<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>nr <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            <span class="hl com">/* It's a symlink */</span>
            link<span class="hl opt">[</span>nr<span class="hl opt">] =</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>link<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">] ==</span> SEP<span class="hl opt">)</span>
                argv0 <span class="hl opt">=</span> link<span class="hl opt">;</span> <span class="hl com">/* Link to absolute path */</span>
            <span class="hl kwa">else if</span> <span class="hl opt">(</span><span class="hl kwd">wcschr</span><span class="hl opt">(</span>link<span class="hl opt">,</span> SEP<span class="hl opt">) ==</span> NULL<span class="hl opt">)</span>
                <span class="hl opt">;</span> <span class="hl com">/* Link without path */</span>
            <span class="hl kwa">else</span> <span class="hl opt">{</span>
                <span class="hl com">/* Must join(dirname(argv0), link) */</span>
                <span class="hl kwb">wchar_t</span> <span class="hl opt">*</span>q <span class="hl opt">=</span> <span class="hl kwd">wcsrchr</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> SEP<span class="hl opt">);</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>q <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
                    argv0 <span class="hl opt">=</span> link<span class="hl opt">;</span> <span class="hl com">/* argv0 without path */</span>
                <span class="hl kwa">else</span> <span class="hl opt">{</span>
                    <span class="hl com">/* Must make a copy */</span>
                    <span class="hl kwd">wcscpy</span><span class="hl opt">(</span>argv0copy<span class="hl opt">,</span> argv0<span class="hl opt">);</span>
                    q <span class="hl opt">=</span> <span class="hl kwd">wcsrchr</span><span class="hl opt">(</span>argv0copy<span class="hl opt">,</span> SEP<span class="hl opt">);</span>
                    <span class="hl kwd">wcscpy</span><span class="hl opt">(</span>q<span class="hl opt">+</span><span class="hl num">1</span><span class="hl opt">,</span> link<span class="hl opt">);</span>
                    argv0 <span class="hl opt">=</span> argv0copy<span class="hl opt">;</span>
                <span class="hl opt">}</span>
            <span class="hl opt">}</span>
        <span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* HAVE_READLINK */</span><span class="hl ppc"></span>
<span class="hl ppc">#if SEP ==</span> <span class="hl pps">'</span><span class="hl esc">\\</span><span class="hl pps">'</span><span class="hl ppc"></span> <span class="hl com">/* Special case for MS filename syntax */</span><span class="hl ppc"></span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>argc <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> argv0 <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">wcscmp</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> L<span class="hl str">&quot;-c&quot;</span><span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            <span class="hl kwb">wchar_t</span> <span class="hl opt">*</span>q<span class="hl opt">;</span>
<span class="hl ppc">#if defined(MS_WINDOWS) &amp;&amp; !defined(MS_WINCE)</span>
            <span class="hl com">/* This code here replaces the first element in argv with the full</span>
<span class="hl com">            path that it represents. Under CE, there are no relative paths so</span>
<span class="hl com">            the argument must be the full path anyway. */</span>
            <span class="hl kwb">wchar_t</span> <span class="hl opt">*</span>ptemp<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">GetFullPathNameW</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span>
                               <span class="hl kwa">sizeof</span><span class="hl opt">(</span>fullpath<span class="hl opt">)/</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span>fullpath<span class="hl opt">[</span><span class="hl num">0</span><span class="hl opt">]),</span>
                               fullpath<span class="hl opt">,</span>
                               <span class="hl opt">&amp;</span>ptemp<span class="hl opt">)) {</span>
                argv0 <span class="hl opt">=</span> fullpath<span class="hl opt">;</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#endif</span>
            p <span class="hl opt">=</span> <span class="hl kwd">wcsrchr</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> SEP<span class="hl opt">);</span>
            <span class="hl com">/* Test for alternate separator */</span>
            q <span class="hl opt">=</span> <span class="hl kwd">wcsrchr</span><span class="hl opt">(</span>p ? p <span class="hl opt">:</span> argv0<span class="hl opt">,</span> <span class="hl str">'/'</span><span class="hl opt">);</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>q <span class="hl opt">!=</span> NULL<span class="hl opt">)</span>
                p <span class="hl opt">=</span> q<span class="hl opt">;</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>p <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
                n <span class="hl opt">=</span> p <span class="hl opt">+</span> <span class="hl num">1</span> <span class="hl opt">-</span> argv0<span class="hl opt">;</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>n <span class="hl opt">&gt;</span> <span class="hl num">1</span> <span class="hl opt">&amp;&amp;</span> p<span class="hl opt">[-</span><span class="hl num">1</span><span class="hl opt">] !=</span> <span class="hl str">':'</span><span class="hl opt">)</span>
                    n<span class="hl opt">--;</span> <span class="hl com">/* Drop trailing separator */</span>
            <span class="hl opt">}</span>
        <span class="hl opt">}</span>
<span class="hl ppc">#else</span> <span class="hl com">/* All other filename syntaxes */</span><span class="hl ppc"></span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>argc <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> argv0 <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">wcscmp</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> L<span class="hl str">&quot;-c&quot;</span><span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
<span class="hl ppc">#if defined(HAVE_REALPATH)</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">_wrealpath</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> fullpath<span class="hl opt">)) {</span>
                argv0 <span class="hl opt">=</span> fullpath<span class="hl opt">;</span>
            <span class="hl opt">}</span>
<span class="hl ppc">#endif</span>
            p <span class="hl opt">=</span> <span class="hl kwd">wcsrchr</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> SEP<span class="hl opt">);</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>p <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
            n <span class="hl opt">=</span> p <span class="hl opt">+</span> <span class="hl num">1</span> <span class="hl opt">-</span> argv0<span class="hl opt">;</span>
<span class="hl ppc">#if SEP ==</span> <span class="hl pps">'/'</span><span class="hl ppc"></span> <span class="hl com">/* Special case for Unix filename syntax */</span><span class="hl ppc"></span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>n <span class="hl opt">&gt;</span> <span class="hl num">1</span><span class="hl opt">)</span>
                n<span class="hl opt">--;</span> <span class="hl com">/* Drop trailing separator */</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* Unix */</span><span class="hl ppc"></span>
        <span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* All others */</span><span class="hl ppc"></span>
        a <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromWideChar</span><span class="hl opt">(</span>argv0<span class="hl opt">,</span> n<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>a <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
            <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;no mem for sys.path insertion&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyList_Insert</span><span class="hl opt">(</span>path<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> a<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">Py_FatalError</span><span class="hl opt">(</span><span class="hl str">&quot;sys.path.insert(0) failed&quot;</span><span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>a<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>av<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_SetArgv</span><span class="hl opt">(</span><span class="hl kwb">int</span> argc<span class="hl opt">,</span> <span class="hl kwb">wchar_t</span> <span class="hl opt">**</span>argv<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">PySys_SetArgvEx</span><span class="hl opt">(</span>argc<span class="hl opt">,</span> argv<span class="hl opt">,</span> <span class="hl num">1</span><span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/* Reimplementation of PyFile_WriteString() no calling indirectly</span>
<span class="hl com">   PyErr_CheckSignals(): avoid the call to PyObject_Str(). */</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">sys_pyfile_write</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>text<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>file<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>unicode <span class="hl opt">=</span> NULL<span class="hl opt">, *</span>writer <span class="hl opt">=</span> NULL<span class="hl opt">, *</span>args <span class="hl opt">=</span> NULL<span class="hl opt">, *</span>result <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">int</span> err<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>file <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> <span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">;</span>

    unicode <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromString</span><span class="hl opt">(</span>text<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>unicode <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>

    writer <span class="hl opt">=</span> <span class="hl kwd">PyObject_GetAttrString</span><span class="hl opt">(</span>file<span class="hl opt">,</span> <span class="hl str">&quot;write&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>writer <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>

    args <span class="hl opt">=</span> <span class="hl kwd">PyTuple_Pack</span><span class="hl opt">(</span><span class="hl num">1</span><span class="hl opt">,</span> unicode<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>args <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>

    result <span class="hl opt">=</span> <span class="hl kwd">PyEval_CallObject</span><span class="hl opt">(</span>writer<span class="hl opt">,</span> args<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>result <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
        err <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">goto</span> finally<span class="hl opt">;</span>
    <span class="hl opt">}</span>

error<span class="hl opt">:</span>
    err <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
finally<span class="hl opt">:</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>unicode<span class="hl opt">);</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>writer<span class="hl opt">);</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>args<span class="hl opt">);</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>result<span class="hl opt">);</span>
    <span class="hl kwa">return</span> err<span class="hl opt">;</span>
<span class="hl opt">}</span>


<span class="hl com">/* APIs to write to sys.stdout or sys.stderr using a printf-like interface.</span>
<span class="hl com">   Adapted from code submitted by Just van Rossum.</span>
<span class="hl com"></span>
<span class="hl com">   PySys_WriteStdout(format, ...)</span>
<span class="hl com">   PySys_WriteStderr(format, ...)</span>
<span class="hl com"></span>
<span class="hl com">      The first function writes to sys.stdout; the second to sys.stderr.  When</span>
<span class="hl com">      there is a problem, they write to the real (C level) stdout or stderr;</span>
<span class="hl com">      no exceptions are raised.</span>
<span class="hl com"></span>
<span class="hl com">      PyErr_CheckSignals() is not called to avoid the execution of the Python</span>
<span class="hl com">      signal handlers: they may raise a new exception whereas mywrite() ignores</span>
<span class="hl com">      all exceptions.</span>
<span class="hl com"></span>
<span class="hl com">      Both take a printf-style format string as their first argument followed</span>
<span class="hl com">      by a variable length argument list determined by the format string.</span>
<span class="hl com"></span>
<span class="hl com">      *** WARNING ***</span>
<span class="hl com"></span>
<span class="hl com">      The format should limit the total size of the formatted output string to</span>
<span class="hl com">      1000 bytes.  In particular, this means that no unrestricted &quot;%s&quot; formats</span>
<span class="hl com">      should occur; these should be limited using &quot;%.&lt;N&gt;s where &lt;N&gt; is a</span>
<span class="hl com">      decimal number calculated so that &lt;N&gt; plus the maximum size of other</span>
<span class="hl com">      formatted text does not exceed 1000 bytes.  Also watch out for &quot;%f&quot;,</span>
<span class="hl com">      which can print hundreds of digits for very large numbers.</span>
<span class="hl com"></span>
<span class="hl com"> */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">mywrite</span><span class="hl opt">(</span><span class="hl kwb">char</span> <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">FILE</span> <span class="hl opt">*</span>fp<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>format<span class="hl opt">,</span> <span class="hl kwb">va_list</span> va<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>file<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>error_type<span class="hl opt">, *</span>error_value<span class="hl opt">, *</span>error_traceback<span class="hl opt">;</span>
    <span class="hl kwb">char</span> buffer<span class="hl opt">[</span><span class="hl num">1001</span><span class="hl opt">];</span>
    <span class="hl kwb">int</span> written<span class="hl opt">;</span>

    <span class="hl kwd">PyErr_Fetch</span><span class="hl opt">(&amp;</span>error_type<span class="hl opt">, &amp;</span>error_value<span class="hl opt">, &amp;</span>error_traceback<span class="hl opt">);</span>
    file <span class="hl opt">=</span> <span class="hl kwd">PySys_GetObject</span><span class="hl opt">(</span>name<span class="hl opt">);</span>
    written <span class="hl opt">=</span> <span class="hl kwd">PyOS_vsnprintf</span><span class="hl opt">(</span>buffer<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>buffer<span class="hl opt">),</span> format<span class="hl opt">,</span> va<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">sys_pyfile_write</span><span class="hl opt">(</span>buffer<span class="hl opt">,</span> file<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
        <span class="hl kwd">fputs</span><span class="hl opt">(</span>buffer<span class="hl opt">,</span> fp<span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>written <span class="hl opt">&lt;</span> <span class="hl num">0</span> <span class="hl opt">|| (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>written <span class="hl opt">&gt;=</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>buffer<span class="hl opt">)) {</span>
        <span class="hl kwb">const char</span> <span class="hl opt">*</span>truncated <span class="hl opt">=</span> <span class="hl str">&quot;... truncated&quot;</span><span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">sys_pyfile_write</span><span class="hl opt">(</span>truncated<span class="hl opt">,</span> file<span class="hl opt">) !=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
            <span class="hl kwd">fputs</span><span class="hl opt">(</span>truncated<span class="hl opt">,</span> fp<span class="hl opt">);</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">PyErr_Restore</span><span class="hl opt">(</span>error_type<span class="hl opt">,</span> error_value<span class="hl opt">,</span> error_traceback<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_WriteStdout</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>format<span class="hl opt">, ...)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">va_list</span> va<span class="hl opt">;</span>

    <span class="hl kwd">va_start</span><span class="hl opt">(</span>va<span class="hl opt">,</span> format<span class="hl opt">);</span>
    <span class="hl kwd">mywrite</span><span class="hl opt">(</span><span class="hl str">&quot;stdout&quot;</span><span class="hl opt">,</span> stdout<span class="hl opt">,</span> format<span class="hl opt">,</span> va<span class="hl opt">);</span>
    <span class="hl kwd">va_end</span><span class="hl opt">(</span>va<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">PySys_WriteStderr</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>format<span class="hl opt">, ...)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">va_list</span> va<span class="hl opt">;</span>

    <span class="hl kwd">va_start</span><span class="hl opt">(</span>va<span class="hl opt">,</span> format<span class="hl opt">);</span>
    <span class="hl kwd">mywrite</span><span class="hl opt">(</span><span class="hl str">&quot;stderr&quot;</span><span class="hl opt">,</span> stderr<span class="hl opt">,</span> format<span class="hl opt">,</span> va<span class="hl opt">);</span>
    <span class="hl kwd">va_end</span><span class="hl opt">(</span>va<span class="hl opt">);</span>
<span class="hl opt">}</span>
</code></pre></td></tr></table>
</div> <!-- class=content -->
<div class='footer'>generated by <a href='http://git.zx2c4.com/cgit/about/'>cgit v0.12</a> at 2025-12-22 15:14:02 (GMT)</div>
</div> <!-- id=cgit -->
</body>
</html>