/*
 * This file includes functions to transform a concrete syntax tree (CST) to
 * an abstract syntax tree (AST).  The main function is PyAST_FromNode().
 *
 */
#include "Python.h"
#include "Python-ast.h"
#include "grammar.h"
#include "node.h"
#include "pyarena.h"
#include "ast.h"
#include "token.h"
#include "parsetok.h"
#include "graminit.h"

#include <assert.h>

/* Data structure used internally */
struct compiling {
    char *c_encoding; /* source encoding */
    int c_future_unicode; /* __future__ unicode literals flag */
    PyArena *c_arena; /* arena for allocating memeory */
    const char *c_filename; /* filename */
};

static asdl_seq *seq_for_testlist(struct compiling *, const node *);
static expr_ty ast_for_expr(struct compiling *, const node *);
static stmt_ty ast_for_stmt(struct compiling *, const node *);
static asdl_seq *ast_for_suite(struct compiling *, const node *);
static asdl_seq *ast_for_exprlist(struct compiling *, const node *,
                                  expr_context_ty);
static expr_ty ast_for_testlist(struct compiling *, const node *);
static stmt_ty ast_for_classdef(struct compiling *, const node *, asdl_seq *);
static expr_ty ast_for_testlist_gexp(struct compiling *, const node *);

/* Note different signature for ast_for_call */
static expr_ty ast_for_call(struct compiling *, const node *, expr_ty);

static PyObject *parsenumber(struct compiling *, const char *);
static PyObject *parsestr(struct compiling *, const char *);
static PyObject *parsestrplus(struct compiling *, const node *n);

#ifndef LINENO
#define LINENO(n)       ((n)->n_lineno)
#endif

static identifier
new_identifier(const char* n, PyArena *arena) {
    PyObject* id = PyString_InternFromString(n);
    if (id != NULL)
        PyArena_AddPyObject(arena, id);
    return id;
}

#define NEW_IDENTIFIER(n) new_identifier(STR(n), c->c_arena)

/* This routine provides an invalid object for the syntax error.
   The outermost routine must unpack this error and create the
   proper object.  We do this so that we don't have to pass
   the filename to everything function.

   XXX Maybe we should just pass the filename...
*/

static int
ast_error(const node *n, const char *errstr)
{
    PyObject *u = Py_BuildValue("zi", errstr, LINENO(n));
    if (!u)
        return 0;
    PyErr_SetObject(PyExc_SyntaxError, u);
    Py_DECREF(u);
    return 0;
}

static void
ast_error_finish(const char *filename)
{
    PyObject *type, *value, *tback, *errstr, *loc, *tmp;
    long lineno;

    assert(PyErr_Occurred());
    if (!PyErr_ExceptionMatches(PyExc_SyntaxError))
        return;

    PyErr_Fetch(&type, &value, &tback);
    errstr = PyTuple_GetItem(value, 0);
    if (!errstr)
        return;
    Py_INCREF(errstr);
    lineno = PyInt_AsLong(PyTuple_GetItem(value, 1));
    if (lineno == -1) {
        Py_DECREF(errstr);
        return;
    }
    Py_DECREF(value);

    loc = PyErr_ProgramText(filename, lineno);
    if (!loc) {
        Py_INCREF(Py_None);
        loc = Py_None;
    }
    tmp = Py_BuildValue("(zlOO)", filename, lineno, Py_None, loc);
    Py_DECREF(loc);
    if (!tmp) {
        Py_DECREF(errstr);
        return;
    }
    value = PyTuple_Pack(2, errstr, tmp);
    Py_DECREF(errstr);
    Py_DECREF(tmp);
    if (!value)
        return;
    PyErr_Restore(type, value, tback);
}

static int
ast_warn(struct compiling *c, const node *n, char *msg)
{
    if (PyErr_WarnExplicit(PyExc_SyntaxWarning, msg, c->c_filename, LINENO(n),
                           NULL, NULL) < 0) {
        /* if -Werr, change it to a SyntaxError */
        if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SyntaxWarning))
            ast_error(n, msg);
        return 0;
    }
    return 1;
}

static int
forbidden_check(struct compiling *c, const node *n, const char *x)
{
    if (!strcmp(x, "None"))
        return ast_error(n, "cannot assign to None");
    if (!strcmp(x, "__debug__"))
        return ast_error(n, "cannot assign to __debug__");
    if (Py_Py3kWarningFlag) {
        if (!(strcmp(x, "True") && strcmp(x, "False")) &&
            !ast_warn(c, n, "assignment to True or False is forbidden in 3.x"))
            return 0;
        if (!strcmp(x, "nonlocal") &&
            !ast_warn(c, n, "nonlocal is a keyword in 3.x"))
            return 0;
    }
    return 1;
}

/* num_stmts() returns number of contained statements.

   Use this routine to determine how big a sequence is needed for
   the statements in a parse tree.  Its raison d'etre is this bit of
   grammar:

   stmt: simple_stmt | compound_stmt
   simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE

   A simple_stmt can contain multiple small_stmt elements joined
   by semicolons.  If the arg is a simple_stmt, the number of
   small_stmt elements is returned.
*/

static int
num_stmts(const node *n)
{
    int i, l;
    node *ch;

    switch (TYPE(n)) {
        case single_input:
            if (TYPE(CHILD(n, 0)) == NEWLINE)
                return 0;
            else
                return num_stmts(CHILD(n, 0));
        case file_input:
            l = 0;
            for (i = 0; i < NCH(n); i++) {
                ch = CHILD(n, i);
                if (TYPE(ch) == stmt)
                    l += num_stmts(ch);
            }
            return l;
        case stmt:
            return num_stmts(CHILD(n, 0));
        case compound_stmt:
            return 1;
        case simple_stmt:
            return NCH(n) / 2; /* Divide by 2 to remove count of semi-colons */
        case suite:
            if (NCH(n) == 1)
                return num_stmts(CHILD(n, 0));
            else {
                l = 0;
                for (i = 2; i < (NCH(n) - 1); i++)
                    l += num_stmts(CHILD(n, i));
                return l;
            }
        default: {
            char buf[128];

            sprintf(buf, "Non-statement found: %d %d",
                    TYPE(n), NCH(n));
            Py_FatalError(buf);
        }
    }
    assert(0);
    return 0;
}

/* Transform the CST rooted at node * to the appropriate AST
*/

mod_ty
PyAST_FromNode(const node *n, PyCompilerFlags *flags, const char *filename,
               PyArena *arena)
{
    int i, j, k, num;
    asdl_seq *stmts = NULL;
    stmt_ty s;
    node *ch;
    struct compiling c;

    if (flags && flags->cf_flags & PyCF_SOURCE_IS_UTF8) {
        c.c_encoding = "utf-8";
        if (TYPE(n) == encoding_decl) {
            ast_error(n, "encoding declaration in Unicode string");
            goto error;
        }
    } else if (TYPE(n) == encoding_decl) {
        c.c_encoding = STR(n);
        n = CHILD(n, 0);
    } else {
        c.c_encoding = NULL;
    }
    c.c_future_unicode = flags && flags->cf_flags & CO_FUTURE_UNICODE_LITERALS;
    c.c_arena = arena;
    c.c_filename = filename;

    k = 0;
    switch (TYPE(n)) {
        case file_input:
            stmts = asdl_seq_new(num_stmts(n), arena);
            if (!stmts)
                return NULL;
            for (i = 0; i < NCH(n) - 1; i++) {
                ch = CHILD(n, i);
                if (TYPE(ch) == NEWLINE)
                    continue;
                REQ(ch, stmt);
                num = num_stmts(ch);
                if (num == 1) {
                    s = ast_for_stmt(&c, ch);
                    if (!s)
                        goto error;
                    asdl_seq_SET(stmts, k++, s);
                }
                else {
                    ch = CHILD(ch, 0);
                    REQ(ch, simple_stmt);
                    for (j = 0; j < num; j++) {
                        s = ast_for_stmt(&c, CHILD(ch, j * 2));
                        if (!s)
                            goto error;
                        asdl_seq_SET(stmts, k++, s);
                    }
                }
            }
            return Module(stmts, arena);
        case eval_input: {
            expr_ty testlist_ast;

            /* XXX Why not gen_for here? */
            testlist_ast = ast_for_testlist(&c, CHILD(n, 0));
            if (!testlist_ast)
                goto error;
            return Expression(testlist_ast, arena);
        }
        case single_input:
            if (TYPE(CHILD(n, 0)) == NEWLINE) {
                stmts = asdl_seq_new(1, arena);
                if (!stmts)
                    goto error;
                asdl_seq_SET(stmts, 0, Pass(n->n_lineno, n->n_col_offset,
                                            arena));
                if (!asdl_seq_GET(stmts, 0))
                    goto error;
                return Interactive(stmts, arena);
            }
            else {
                n = CHILD(n, 0);
                num = num_stmts(n);
                stmts = asdl_seq_new(num, arena);
                if (!stmts)
                    goto error;
                if (num == 1) {
                    s = ast_for_stmt(&c, n);
                    if (!s)
                        goto error;
                    asdl_seq_SET(stmts, 0, s);
                }
                else {
                    /* Only a simple_stmt can contain multiple statements. */
                    REQ(n, simple_stmt);
                    for (i = 0; i < NCH(n); i += 2) {
                        if (TYPE(CHILD(n, i)) == NEWLINE)
                            break;
                        s = ast_for_stmt(&c, CHILD(n, i));
                        if (!s)
                            goto error;
                        asdl_seq_SET(stmts, i / 2, s);
                    }
                }

                return Interactive(stmts, arena);
            }
        default:
            PyErr_Format(PyExc_SystemError,
                         "invalid node %d for PyAST_FromNode", TYPE(n));
            goto error;
    }
 error:
    ast_error_finish(filename);
    return NULL;
}

/* Return the AST repr. of the operator represented as syntax (|, ^, etc.)
*/

static operator_ty
get_operator(const node *n)
{
    switch (TYPE(n)) {
        case VBAR:
            return BitOr;
        case CIRCUMFLEX:
            return BitXor;
        case AMPER:
            return BitAnd;
        case LEFTSHIFT:
            return LShift;
        case RIGHTSHIFT:
            return RShift;
        case PLUS:
            return Add;
        case MINUS:
            return Sub;
        case STAR:
            return Mult;
        case SLASH:
            return Div;
        case DOUBLESLASH:
            return FloorDiv;
        case PERCENT:
            return Mod;
        default:
            return (operator_ty)0;
    }
}

/* Set the context ctx for expr_ty e, recursively traversing e.

   Only sets context for expr kinds that "can appear in assignment context"
   (according to ../Parser/Python.asdl).  For other expr kinds, it sets
   an appropriate syntax error and returns false.
*/

static int
set_context(struct compiling *c, expr_ty e, expr_context_ty ctx, const node *n)
{
    asdl_seq *s = NULL;
    /* If a particular expression type can't be used for assign / delete,
       set expr_name to its name and an error message will be generated.
    */
    const char* expr_name = NULL;

    /* The ast defines augmented store and load contexts, but the
       implementation here doesn't actually use them.  The code may be
       a little more complex than necessary as a result.  It also means
       that expressions in an augmented assignment have a Store context.
       Consider restructuring so that augmented assignment uses
       set_context(), too.
    */
    assert(ctx != AugStore && ctx != AugLoad);

    switch (e->kind) {
        case Attribute_kind:
            if (ctx == Store && !forbidden_check(c, n,
                                PyBytes_AS_STRING(e->v.Attribute.attr)))
                    return 0;
            e->v.Attribute.ctx = ctx;
            break;
        case Subscript_kind:
            e->v.Subscript.ctx = ctx;
            break;
        case Name_kind:
            if (ctx == Store && !forbidden_check(c, n,
                                PyBytes_AS_STRING(e->v.Name.id)))
                    return 0;
            e->v.Name.ctx = ctx;
            break;
        case List_kind:
            e->v.List.ctx = ctx;
            s = e->v.List.elts;
            break;
        case Tuple_kind:
            if (asdl_seq_LEN(e->v.Tuple.elts))  {
                e->v.Tuple.ctx = ctx;
                s = e->v.Tuple.elts;
            }
            else {
                expr_name = "()";
            }
            break;
        case Lambda_kind:
            expr_name = "lambda";
            break;
        case Call_kind:
            expr_name = "function call";
            break;
        case BoolOp_kind:
        case BinOp_kind:
        case UnaryOp_kind:
            expr_name = "operator";
            break;
        case GeneratorExp_kind:
            expr_name = "generator expression";
            break;
        case Yield_kind:
            expr_name = "yield expression";
            break;
        case ListComp_kind:
            expr_name = "list comprehension";
            break;
        case Dict_kind:
        case Num_kind:
        case Str_kind:
            expr_name = "literal";
            break;
        case Compare_kind:
            expr_name = "comparison";
            break;
        case Repr_kind:
            expr_name = "repr";
            break;
        case IfExp_kind:
            expr_name = "conditional expression";
            break;
        default:
            PyErr_Format(PyExc_SystemError, 
                         "unexpected expression in assignment %d (line %d)", 
                         e->kind, e->lineno);
            return 0;
    }
    /* Check for error string set by switch */
    if (expr_name) {
        char buf[300];
        PyOS_snprintf(buf, sizeof(buf),
                      "can't %s %s",
                      ctx == Store ? "assign to" : "delete",
                      expr_name);
        return ast_error(n, buf);
    }

    /* If the LHS is a list or tuple, we need to set the assignment
       context for all the contained elements.  
    */
    if (s) {
        int i;

        for (i = 0; i < asdl_seq_LEN(s); i++) {
            if (!set_context(c, (expr_ty)asdl_seq_GET(s, i), ctx, n))
                return 0;
        }
    }
    return 1;
}

static operator_ty
ast_for_augassign(struct compiling *c, const node *n)
{
    REQ(n, augassign);
    n = CHILD(n, 0);
    switch (STR(n)[0]) {
        case '+':
            return Add;
        case '-':
            return Sub;
        case '/':
            if (STR(n)[1] == '/')
                return FloorDiv;
            else
                return Div;
        case '%':
            return Mod;
        case '<':
            return LShift;
        case '>':
            return RShift;
        case '&':
            return BitAnd;
        case '^':
            return BitXor;
        case '|':
            return BitOr;
        case '*':
            if (STR(n)[1] == '*')
                return Pow;
            else
                return Mult;
        default:
            PyErr_Format(PyExc_SystemError, "invalid augassign: %s", STR(n));
            return (operator_ty)0;
    }
}

static cmpop_ty
ast_for_comp_op(struct compiling *c, const node *n)
{
    /* comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'
               |'is' 'not'
    */
    REQ(n, comp_op);
    if (NCH(n) == 1) {
        n = CHILD(n, 0);
        switch (TYPE(n)) {
            case LESS:
                return Lt;
            case GREATER:
                return Gt;
            case EQEQUAL:                       /* == */
                return Eq;
            case LESSEQUAL:
                return LtE;
            case GREATEREQUAL:
                return GtE;
            case NOTEQUAL:
                return NotEq;
            case NAME:
                if (strcmp(STR(n), "in") == 0)
                    return In;
                if (strcmp(STR(n), "is") == 0)
                    return Is;
            default:
                PyErr_Format(PyExc_SystemError, "invalid comp_op: %s",
                             STR(n));
                return (cmpop_ty)0;
        }
    }
    else if (NCH(n) == 2) {
        /* handle "not in" and "is not" */
        switch (TYPE(CHILD(n, 0))) {
            case NAME:
                if (strcmp(STR(CHILD(n, 1)), "in") == 0)
                    return NotIn;
                if (strcmp(STR(CHILD(n, 0)), "is") == 0)
                    return IsNot;
            default:
                PyErr_Format(PyExc_SystemError, "invalid comp_op: %s %s",
                             STR(CHILD(n, 0)), STR(CHILD(n, 1)));
                return (cmpop_ty)0;
        }
    }
    PyErr_Format(PyExc_SystemError, "invalid comp_op: has %d children",
                 NCH(n));
    return (cmpop_ty)0;
}

static asdl_seq *
seq_for_testlist(struct compiling *c, const node *n)
{
    /* testlist: test (',' test)* [','] */
    asdl_seq *seq;
    expr_ty expression;
    int i;
    assert(TYPE(n) == testlist ||
           TYPE(n) == listmaker ||
           TYPE(n) == testlist_gexp ||
           TYPE(n) == testlist_safe ||
           TYPE(n) == testlist1);

    seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
    if (!seq)
        return NULL;

    for (i = 0; i < NCH(n); i += 2) {
        assert(TYPE(CHILD(n, i)) == test || TYPE(CHILD(n, i)) == old_test);

        expression = ast_for_expr(c, CHILD(n, i));
        if (!expression)
            return NULL;

        assert(i / 2 < seq->size);
        asdl_seq_SET(seq, i / 2, expression);
    }
    return seq;
}

static expr_ty
compiler_complex_args(struct compiling *c, const node *n)
{
    int i, len = (NCH(n) + 1) / 2;
    expr_ty result;
    asdl_seq *args = asdl_seq_new(len, c->c_arena);
    if (!args)
        return NULL;

    /* fpdef: NAME | '(' fplist ')'
       fplist: fpdef (',' fpdef)* [',']
    */
    REQ(n, fplist);
    for (i = 0; i < len; i++) {
        PyObject *arg_id;
        const node *fpdef_node = CHILD(n, 2*i);
        const node *child;
        expr_ty arg;
set_name:
        /* fpdef_node is either a NAME or an fplist */
        child = CHILD(fpdef_node, 0);
        if (TYPE(child) == NAME) {
            if (!forbidden_check(c, n, STR(child)))
                return NULL;
            arg_id = NEW_IDENTIFIER(child);
            if (!arg_id)
                return NULL;
            arg = Name(arg_id, Store, LINENO(child), child->n_col_offset,
                       c->c_arena);
        }
        else {
            assert(TYPE(fpdef_node) == fpdef);
            /* fpdef_node[0] is not a name, so it must be '(', get CHILD[1] */
            child = CHILD(fpdef_node, 1);
            assert(TYPE(child) == fplist);
            /* NCH == 1 means we have (x), we need to elide the extra parens */
            if (NCH(child) == 1) {
                fpdef_node = CHILD(child, 0);
                assert(TYPE(fpdef_node) == fpdef);
                goto set_name;
            }
            arg = compiler_complex_args(c, child);
        }
        asdl_seq_SET(args, i, arg);
    }

    result = Tuple(args, Store, LINENO(n), n->n_col_offset, c->c_arena);
    if (!set_context(c, result, Store, n))
        return NULL;
    return result;
}


/* Create AST for argument list. */

static arguments_ty
ast_for_arguments(struct compiling *c, const node *n)
{
    /* parameters: '(' [varargslist] ')'
       varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME]
            | '**' NAME) | fpdef ['=' test] (',' fpdef ['=' test])* [',']
    */
    int i, j, k, n_args = 0, n_defaults = 0, found_default = 0;
    asdl_seq *args, *defaults;
    identifier vararg = NULL, kwarg = NULL;
    node *ch;

    if (TYPE(n) == parameters) {
        if (NCH(n) == 2) /* () as argument list */
            return arguments(NULL, NULL, NULL, NULL, c->c_arena);
        n = CHILD(n, 1);
    }
    REQ(n, varargslist);

    /* first count the number of normal args & defaults */
    for (i = 0; i < NCH(n); i++) {
        ch = CHILD(n, i);
        if (TYPE(ch) == fpdef)
            n_args++;
        if (TYPE(ch) == EQUAL)
            n_defaults++;
    }
    args = (n_args ? asdl_seq_new(n_args, c->c_arena) : NULL);
    if (!args && n_args)
        return NULL; /* Don't need to goto error; no objects allocated */
    defaults = (n_defaults ? asdl_seq_new(n_defaults, c->c_arena) : NULL);
    if (!defaults && n_defaults)
        return NULL; /* Don't need to goto error; no objects allocated */

    /* fpdef: NAME | '(' fplist ')'
       fplist: fpdef (',' fpdef)* [',']
    */
    i = 0;
    j = 0;  /* index for defaults */
    k = 0;  /* index for args */
    while (i < NCH(n)) {
        ch = CHILD(n, i);
        switch (TYPE(ch)) {
            case fpdef:
            handle_fpdef:
                /* XXX Need to worry about checking if TYPE(CHILD(n, i+1)) is
                   anything other than EQUAL or a comma? */
                /* XXX Should NCH(n) check be made a separate check? */
                if (i + 1 < NCH(n) && TYPE(CHILD(n, i + 1)) == EQUAL) {
                    expr_ty expression = ast_for_expr(c, CHILD(n, i + 2));
                    if (!expression)
                        goto error;
                    assert(defaults != NULL);
                    asdl_seq_SET(defaults, j++, expression);
                    i += 2;
                    found_default = 1;
                }
                else if (found_default) {
                    ast_error(n, 
                             "non-default argument follows default argument");
                    goto error;
                }
                if (NCH(ch) == 3) {
                    ch = CHILD(ch, 1);
                    /* def foo((x)): is not complex, special case. */
                    if (NCH(ch) != 1) {
                        /* We have complex arguments, setup for unpacking. */
                        if (Py_Py3kWarningFlag && !ast_warn(c, ch,
                            "tuple parameter unpacking has been removed in 3.x"))
                            goto error;
                        asdl_seq_SET(args, k++, compiler_complex_args(c, ch));
                        if (!asdl_seq_GET(args, k-1))
                                goto error;
                    } else {
                        /* def foo((x)): setup for checking NAME below. */
                        /* Loop because there can be many parens and tuple
                           unpacking mixed in. */
                        ch = CHILD(ch, 0);
                        assert(TYPE(ch) == fpdef);
                        goto handle_fpdef;
                    }
                }
                if (TYPE(CHILD(ch, 0)) == NAME) {
                    PyObject *id;
                    expr_ty name;
                    if (!forbidden_check(c, n, STR(CHILD(ch, 0))))
                        goto error;
                    id = NEW_IDENTIFIER(CHILD(ch, 0));
                    if (!id)
                        goto error;
                    name = Name(id, Param, LINENO(ch), ch->n_col_offset,
                                c->c_arena);
                    if (!name)
                        goto error;
                    asdl_seq_SET(args, k++, name);
                                         
                }
                i += 2; /* the name and the comma */
                break;
            case STAR:
                if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))
                    goto error;
                vararg = NEW_IDENTIFIER(CHILD(n, i+1));
                if (!vararg)
                    goto error;
                i += 3;
                break;
            case DOUBLESTAR:
                if (!forbidden_check(c, CHILD(n, i+1), STR(CHILD(n, i+1))))
                    goto error;
                kwarg = NEW_IDENTIFIER(CHILD(n, i+1));
                if (!kwarg)
                    goto error;
                i += 3;
                break;
            default:
                PyErr_Format(PyExc_SystemError,
                             "unexpected node in varargslist: %d @ %d",
                             TYPE(ch), i);
                goto error;
        }
    }

    return arguments(args, vararg, kwarg, defaults, c->c_arena);

 error:
    Py_XDECREF(vararg);
    Py_XDECREF(kwarg);
    return NULL;
}

static expr_ty
ast_for_dotted_name(struct compiling *c, const node *n)
{
    expr_ty e;
    identifier id;
    int lineno, col_offset;
    int i;

    REQ(n, dotted_name);

    lineno = LINENO(n);
    col_offset = n->n_col_offset;

    id = NEW_IDENTIFIER(CHILD(n, 0));
    if (!id)
        return NULL;
    e = Name(id, Load, lineno, col_offset, c->c_arena);
    if (!e)
        return NULL;

    for (i = 2; i < NCH(n); i+=2) {
        id = NEW_IDENTIFIER(CHILD(n, i));
        if (!id)
            return NULL;
        e = Attribute(e, id, Load, lineno, col_offset, c->c_arena);
        if (!e)
            return NULL;
    }

    return e;
}

static expr_ty
ast_for_decorator(struct compiling *c, const node *n)
{
    /* decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE */
    expr_ty d = NULL;
    expr_ty name_expr;
    
    REQ(n, decorator);
    REQ(CHILD(n, 0), AT);
    REQ(RCHILD(n, -1), NEWLINE);
    
    name_expr = ast_for_dotted_name(c, CHILD(n, 1));
    if (!name_expr)
        return NULL;
        
    if (NCH(n) == 3) { /* No arguments */
        d = name_expr;
        name_expr = NULL;
    }
    else if (NCH(n) == 5) { /* Call with no arguments */
        d = Call(name_expr, NULL, NULL, NULL, NULL, LINENO(n),
                 n->n_col_offset, c->c_arena);
        if (!d)
            return NULL;
        name_expr = NULL;
    }
    else {
        d = ast_for_call(c, CHILD(n, 3), name_expr);
        if (!d)
            return NULL;
        name_expr = NULL;
    }

    return d;
}

static asdl_seq*
ast_for_decorators(struct compiling *c, const node *n)
{
    asdl_seq* decorator_seq;
    expr_ty d;
    int i;
    
    REQ(n, decorators);
    decorator_seq = asdl_seq_new(NCH(n), c->c_arena);
    if (!decorator_seq)
        return NULL;
        
    for (i = 0; i < NCH(n); i++) {
        d = ast_for_decorator(c, CHILD(n, i));
            if (!d)
                return NULL;
            asdl_seq_SET(decorator_seq, i, d);
    }
    return decorator_seq;
}

static stmt_ty
ast_for_funcdef(struct compiling *c, const node *n, asdl_seq *decorator_seq)
{
    /* funcdef: 'def' NAME parameters ':' suite */
    identifier name;
    arguments_ty args;
    asdl_seq *body;
    int name_i = 1;

    REQ(n, funcdef);

    name = NEW_IDENTIFIER(CHILD(n, name_i));
    if (!name)
        return NULL;
    else if (!forbidden_check(c, CHILD(n, name_i), STR(CHILD(n, name_i))))
        return NULL;
    args = ast_for_arguments(c, CHILD(n, name_i + 1));
    if (!args)
        return NULL;
    body = ast_for_suite(c, CHILD(n, name_i + 3));
    if (!body)
        return NULL;

    return FunctionDef(name, args, body, decorator_seq, LINENO(n),
                       n->n_col_offset, c->c_arena);
}

static stmt_ty
ast_for_decorated(struct compiling *c, const node *n)
{
    /* decorated: decorators (classdef | funcdef) */
    stmt_ty thing = NULL;
    asdl_seq *decorator_seq = NULL;

    REQ(n, decorated);

    decorator_seq = ast_for_decorators(c, CHILD(n, 0));
    if (!decorator_seq)
      return NULL;

    assert(TYPE(CHILD(n, 1)) == funcdef ||
	   TYPE(CHILD(n, 1)) == classdef);

    if (TYPE(CHILD(n, 1)) == funcdef) {
      thing = ast_for_funcdef(c, CHILD(n, 1), decorator_seq);
    } else if (TYPE(CHILD(n, 1)) == classdef) {
      thing = ast_for_classdef(c, CHILD(n, 1), decorator_seq);
    }
    /* we count the decorators in when talking about the class' or
       function's line number */
    if (thing) {
        thing->lineno = LINENO(n);
        thing->col_offset = n->n_col_offset;
    }
    return thing;
}

static expr_ty
ast_for_lambdef(struct compiling *c, const node *n)
{
    /* lambdef: 'lambda' [varargslist] ':' test */
    arguments_ty args;
    expr_ty expression;

    if (NCH(n) == 3) {
        args = arguments(NULL, NULL, NULL, NULL, c->c_arena);
        if (!args)
            return NULL;
        expression = ast_for_expr(c, CHILD(n, 2));
        if (!expression)
            return NULL;
    }
    else {
        args = ast_for_arguments(c, CHILD(n, 1));
        if (!args)
            return NULL;
        expression = ast_for_expr(c, CHILD(n, 3));
        if (!expression)
            return NULL;
    }

    return Lambda(args, expression, LINENO(n), n->n_col_offset, c->c_arena);
}

static expr_ty
ast_for_ifexpr(struct compiling *c, const node *n)
{
    /* test: or_test 'if' or_test 'else' test */ 
    expr_ty expression, body, orelse;

    assert(NCH(n) == 5);
    body = ast_for_expr(c, CHILD(n, 0));
    if (!body)
        return NULL;
    expression = ast_for_expr(c, CHILD(n, 2));
    if (!expression)
        return NULL;
    orelse = ast_for_expr(c, CHILD(n, 4));
    if (!orelse)
        return NULL;
    return IfExp(expression, body, orelse, LINENO(n), n->n_col_offset,
                 c->c_arena);
}

/* XXX(nnorwitz): the listcomp and genexpr code should be refactored
   so there is only a single version.  Possibly for loops can also re-use
   the code.
*/

/* Count the number of 'for' loop in a list comprehension.

   Helper for ast_for_listcomp().
*/

static int
count_list_fors(struct compiling *c, const node *n)
{
    int n_fors = 0;
    node *ch = CHILD(n, 1);

 count_list_for:
    n_fors++;
    REQ(ch, list_for);
    if (NCH(ch) == 5)
        ch = CHILD(ch, 4);
    else
        return n_fors;
 count_list_iter:
    REQ(ch, list_iter);
    ch = CHILD(ch, 0);
    if (TYPE(ch) == list_for)
        goto count_list_for;
    else if (TYPE(ch) == list_if) {
        if (NCH(ch) == 3) {
            ch = CHILD(ch, 2);
            goto count_list_iter;
        }
        else
            return n_fors;
    }

    /* Should never be reached */
    PyErr_SetString(PyExc_SystemError, "logic error in count_list_fors");
    return -1;
}

/* Count the number of 'if' statements in a list comprehension.

   Helper for ast_for_listcomp().
*/

static int
count_list_ifs(struct compiling *c, const node *n)
{
    int n_ifs = 0;

 count_list_iter:
    REQ(n, list_iter);
    if (TYPE(CHILD(n, 0)) == list_for)
        return n_ifs;
    n = CHILD(n, 0);
    REQ(n, list_if);
    n_ifs++;
    if (NCH(n) == 2)
        return n_ifs;
    n = CHILD(n, 2);
    goto count_list_iter;
}

static expr_ty
ast_for_listcomp(struct compiling *c, const node *n)
{
    /* listmaker: test ( list_for | (',' test)* [','] )
       list_for: 'for' exprlist 'in' testlist_safe [list_iter]
       list_iter: list_for | list_if
       list_if: 'if' test [list_iter]
       testlist_safe: test [(',' test)+ [',']]
    */
    expr_ty elt;
    asdl_seq *listcomps;
    int i, n_fors;
    node *ch;

    REQ(n, listmaker);
    assert(NCH(n) > 1);

    elt = ast_for_expr(c, CHILD(n, 0));
    if (!elt)
        return NULL;

    n_fors = count_list_fors(c, n);
    if (n_fors == -1)
        return NULL;

    listcomps = asdl_seq_new(n_fors, c->c_arena);
    if (!listcomps)
        return NULL;

    ch = CHILD(n, 1);
    for (i = 0; i < n_fors; i++) {
        comprehension_ty lc;
        asdl_seq *t;
        expr_ty expression;
        node *for_ch;
        
        REQ(ch, list_for);
        
        for_ch = CHILD(ch, 1);
        t = ast_for_exprlist(c, for_ch, Store);
        if (!t)
            return NULL;
        expression = ast_for_testlist(c, CHILD(ch, 3));
        if (!expression)
            return NULL;
        
        /* Check the # of children rather than the length of t, since
           [x for x, in ... ] has 1 element in t, but still requires a Tuple.
        */
        if (NCH(for_ch) == 1)
            lc = comprehension((expr_ty)asdl_seq_GET(t, 0), expression, NULL,
                               c->c_arena);
        else
            lc = comprehension(Tuple(t, Store, LINENO(ch), ch->n_col_offset,
                                     c->c_arena),
                               expression, NULL, c->c_arena);
        if (!lc)
            return NULL;

        if (NCH(ch) == 5) {
            int j, n_ifs;
            asdl_seq *ifs;
            expr_ty list_for_expr;

            ch = CHILD(ch, 4);
            n_ifs = count_list_ifs(c, ch);
            if (n_ifs == -1)
                return NULL;

            ifs = asdl_seq_new(n_ifs, c->c_arena);
            if (!ifs)
                return NULL;

            for (j = 0; j < n_ifs; j++) {
                REQ(ch, list_iter);
                ch = CHILD(ch, 0);
                REQ(ch, list_if);
                
                list_for_expr = ast_for_expr(c, CHILD(ch, 1));
                if (!list_for_expr)
                    return NULL;
                
                asdl_seq_SET(ifs, j, list_for_expr);
                if (NCH(ch) == 3)
                    ch = CHILD(ch, 2);
            }
            /* on exit, must guarantee that ch is a list_for */
            if (TYPE(ch) == list_iter)
                ch = CHILD(ch, 0);
            lc->ifs = ifs;
        }
        asdl_seq_SET(listcomps, i, lc);
    }

    return ListComp(elt, listcomps, LINENO(n), n->n_col_offset, c->c_arena);
}

/* Count the number of 'for' loops in a generator expression.

   Helper for ast_for_genexp().
*/

static int
count_gen_fors(struct compiling *c, const node *n)
{
    int n_fors = 0;
    node *ch = CHILD(n, 1);

 count_gen_for:
    n_fors++;
    REQ(ch, gen_for);
    if (NCH(ch) == 5)
        ch = CHILD(ch, 4);
    else
        return n_fors;
 count_gen_iter:
    REQ(ch, gen_iter);
    ch = CHILD(ch, 0);
    if (TYPE(ch) == gen_for)
        goto count_gen_for;
    else if (TYPE(ch) == gen_if) {
        if (NCH(ch) == 3) {
            ch = CHILD(ch, 2);
            goto count_gen_iter;
        }
        else
            return n_fors;
    }
    
    /* Should never be reached */
    PyErr_SetString(PyExc_SystemError,
                    "logic error in count_gen_fors");
    return -1;
}

/* Count the number of 'if' statements in a generator expression.

   Helper for ast_for_genexp().
*/

static int
count_gen_ifs(struct compiling *c, const node *n)
{
    int n_ifs = 0;

    while (1) {
        REQ(n, gen_iter);
        if (TYPE(CHILD(n, 0)) == gen_for)
            return n_ifs;
        n = CHILD(n, 0);
        REQ(n, gen_if);
        n_ifs++;
        if (NCH(n) == 2)
            return n_ifs;
        n = CHILD(n, 2);
    }
}

/* TODO(jhylton): Combine with list comprehension code? */
static expr_ty
ast_for_genexp(struct compiling *c, const node *n)
{
    /* testlist_gexp: test ( gen_for | (',' test)* [','] )
       argument: [test '='] test [gen_for]       # Really [keyword '='] test */
    expr_ty elt;
    asdl_seq *genexps;
    int i, n_fors;
    node *ch;
    
    assert(TYPE(n) == (testlist_gexp) || TYPE(n) == (argument));
    assert(NCH(n) > 1);
    
    elt = ast_for_expr(c, CHILD(n, 0));
    if (!elt)
        return NULL;
    
    n_fors = count_gen_fors(c, n);
    if (n_fors == -1)
        return NULL;

    genexps = asdl_seq_new(n_fors, c->c_arena);
    if (!genexps)
        return NULL;

    ch = CHILD(n, 1);
    for (i = 0; i < n_fors; i++) {
        comprehension_ty ge;
        asdl_seq *t;
        expr_ty expression;
        node *for_ch;
        
        REQ(ch, gen_for);
        
        for_ch = CHILD(ch, 1);
        t = ast_for_exprlist(c, for_ch, Store);
        if (!t)
            return NULL;
        expression = ast_for_expr(c, CHILD(ch, 3));
        if (!expression)
            return NULL;

        /* Check the # of children rather than the length of t, since
           (x for x, in ...) has 1 element in t, but still requires a Tuple. */
        if (NCH(for_ch) == 1)
            ge = comprehension((expr_ty)asdl_seq_GET(t, 0), expression,
                               NULL, c->c_arena);
        else
            ge = comprehension(Tuple(t, Store, LINENO(ch), ch->n_col_offset,
                                     c->c_arena),
                               expression, NULL, c->c_arena);

        if (!ge)
            return NULL;

        if (NCH(ch) == 5) {
            int j, n_ifs;
            asdl_seq *ifs;
            
            ch = CHILD(ch, 4);
            n_ifs = count_gen_ifs(c, ch);
            if (n_ifs == -1)
                return NULL;

            ifs = asdl_seq_new(n_ifs, c->c_arena);
            if (!ifs)
                return NULL;

            for (j = 0; j < n_ifs; j++) {
                REQ(ch, gen_iter);
                ch = CHILD(ch, 0);
                REQ(ch, gen_if);
                
                expression = ast_for_expr(c, CHILD(ch, 1));
                if (!expression)
                    return NULL;
                asdl_seq_SET(ifs, j, expression);
                if (NCH(ch) == 3)
                    ch = CHILD(ch, 2);
            }
            /* on exit, must guarantee that ch is a gen_for */
            if (TYPE(ch) == gen_iter)
                ch = CHILD(ch, 0);
            ge->ifs = ifs;
        }
        asdl_seq_SET(genexps, i, ge);
    }
    
    return GeneratorExp(elt, genexps, LINENO(n), n->n_col_offset, c->c_arena);
}

static expr_ty
ast_for_atom(struct compiling *c, const node *n)
{
    /* atom: '(' [yield_expr|testlist_gexp] ')' | '[' [listmaker] ']'
       | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING+
    */
    node *ch = CHILD(n, 0);
    
    switch (TYPE(ch)) {
    case NAME: {
        /* All names start in Load context, but may later be
           changed. */
        PyObject *name = NEW_IDENTIFIER(ch);
        if (!name)
            return NULL;
        return Name(name, Load, LINENO(n), n->n_col_offset, c->c_arena);
    }
    case STRING: {
        PyObject *str = parsestrplus(c, n);
        if (!str) {
#ifdef Py_USING_UNICODE
            if (PyErr_ExceptionMatches(PyExc_UnicodeError)){
                PyObject *type, *value, *tback, *errstr;
                PyErr_Fetch(&type, &value, &tback);
                errstr = PyObject_Str(value);
                if (errstr) {
                    char *s = "";
                    char buf[128];
                    s = PyString_AsString(errstr);
                    PyOS_snprintf(buf, sizeof(buf), "(unicode error) %s", s);
                    ast_error(n, buf);
                    Py_DECREF(errstr);
                } else {
                    ast_error(n, "(unicode error) unknown error");
                }
                Py_DECREF(type);
                Py_DECREF(value);
                Py_XDECREF(tback);
            }
#endif
            return NULL;
        }
        PyArena_AddPyObject(c->c_arena, str);
        return Str(str, LINENO(n), n->n_col_offset, c->c_arena);
    }
    case NUMBER: {
        PyObject *pynum = parsenumber(c, STR(ch));
        if (!pynum)
            return NULL;

        PyArena_AddPyObject(c->c_arena, pynum);
        return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);
    }
    case LPAR: /* some parenthesized expressions */
        ch = CHILD(n, 1);
        
        if (TYPE(ch) == RPAR)
            return Tuple(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);
        
        if (TYPE(ch) == yield_expr)
            return ast_for_expr(c, ch);
        
        return ast_for_testlist_gexp(c, ch);
    case LSQB: /* list (or list comprehension) */
        ch = CHILD(n, 1);
        
        if (TYPE(ch) == RSQB)
            return List(NULL, Load, LINENO(n), n->n_col_offset, c->c_arena);
        
        REQ(ch, listmaker);
        if (NCH(ch) == 1 || TYPE(CHILD(ch, 1)) == COMMA) {
            asdl_seq *elts = seq_for_testlist(c, ch);
            if (!elts)
                return NULL;

            return List(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
        }
        else
            return ast_for_listcomp(c, ch);
    case LBRACE: {
        /* dictmaker: test ':' test (',' test ':' test)* [','] */
        int i, size;
        asdl_seq *keys, *values;
        
        ch = CHILD(n, 1);
        size = (NCH(ch) + 1) / 4; /* +1 in case no trailing comma */
        keys = asdl_seq_new(size, c->c_arena);
        if (!keys)
            return NULL;
        
        values = asdl_seq_new(size, c->c_arena);
        if (!values)
            return NULL;
        
        for (i = 0; i < NCH(ch); i += 4) {
            expr_ty expression;
            
            expression = ast_for_expr(c, CHILD(ch, i));
            if (!expression)
                return NULL;

            asdl_seq_SET(keys, i / 4, expression);

            expression = ast_for_expr(c, CHILD(ch, i + 2));
            if (!expression)
                return NULL;

            asdl_seq_SET(values, i / 4, expression);
        }
        return Dict(keys, values, LINENO(n), n->n_col_offset, c->c_arena);
    }
    case BACKQUOTE: { /* repr */
        expr_ty expression;
        if (Py_Py3kWarningFlag &&
            !ast_warn(c, n, "backquote not supported in 3.x; use repr()"))
            return NULL;
        expression = ast_for_testlist(c, CHILD(n, 1));
        if (!expression)
            return NULL;

        return Repr(expression, LINENO(n), n->n_col_offset, c->c_arena);
    }
    default:
        PyErr_Format(PyExc_SystemError, "unhandled atom %d", TYPE(ch));
        return NULL;
    }
}

static slice_ty
ast_for_slice(struct compiling *c, const node *n)
{
    node *ch;
    expr_ty lower = NULL, upper = NULL, step = NULL;

    REQ(n, subscript);

    /*
       subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
       sliceop: ':' [test]
    */
    ch = CHILD(n, 0);
    if (TYPE(ch) == DOT)
        return Ellipsis(c->c_arena);

    if (NCH(n) == 1 && TYPE(ch) == test) {
        /* 'step' variable hold no significance in terms of being used over
           other vars */
        step = ast_for_expr(c, ch); 
        if (!step)
            return NULL;
            
        return Index(step, c->c_arena);
    }

    if (TYPE(ch) == test) {
        lower = ast_for_expr(c, ch);
        if (!lower)
            return NULL;
    }

    /* If there's an upper bound it's in the second or third position. */
    if (TYPE(ch) == COLON) {
        if (NCH(n) > 1) {
            node *n2 = CHILD(n, 1);

            if (TYPE(n2) == test) {
                upper = ast_for_expr(c, n2);
                if (!upper)
                    return NULL;
            }
        }
    } else if (NCH(n) > 2) {
        node *n2 = CHILD(n, 2);

        if (TYPE(n2) == test) {
            upper = ast_for_expr(c, n2);
            if (!upper)
                return NULL;
        }
    }

    ch = CHILD(n, NCH(n) - 1);
    if (TYPE(ch) == sliceop) {
        if (NCH(ch) != 1) {
            ch = CHILD(ch, 1);
            if (TYPE(ch) == test) {
                step = ast_for_expr(c, ch);
                if (!step)
                    return NULL;
            }
        }
    }

    return Slice(lower, upper, step, c->c_arena);
}

static expr_ty
ast_for_binop(struct compiling *c, const node *n)
{
        /* Must account for a sequence of expressions.
           How should A op B op C by represented?  
           BinOp(BinOp(A, op, B), op, C).
        */

        int i, nops;
        expr_ty expr1, expr2, result;
        operator_ty newoperator;

        expr1 = ast_for_expr(c, CHILD(n, 0));
        if (!expr1)
            return NULL;

        expr2 = ast_for_expr(c, CHILD(n, 2));
        if (!expr2)
            return NULL;

        newoperator = get_operator(CHILD(n, 1));
        if (!newoperator)
            return NULL;

        result = BinOp(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,
                       c->c_arena);
        if (!result)
            return NULL;

        nops = (NCH(n) - 1) / 2;
        for (i = 1; i < nops; i++) {
                expr_ty tmp_result, tmp;
                const node* next_oper = CHILD(n, i * 2 + 1);

                newoperator = get_operator(next_oper);
                if (!newoperator)
                    return NULL;

                tmp = ast_for_expr(c, CHILD(n, i * 2 + 2));
                if (!tmp)
                    return NULL;

                tmp_result = BinOp(result, newoperator, tmp, 
                                   LINENO(next_oper), next_oper->n_col_offset,
                                   c->c_arena);
                if (!tmp_result) 
                        return NULL;
                result = tmp_result;
        }
        return result;
}

static expr_ty
ast_for_trailer(struct compiling *c, const node *n, expr_ty left_expr)
{
    /* trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME 
       subscriptlist: subscript (',' subscript)* [',']
       subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop]
     */
    REQ(n, trailer);
    if (TYPE(CHILD(n, 0)) == LPAR) {
        if (NCH(n) == 2)
            return Call(left_expr, NULL, NULL, NULL, NULL, LINENO(n),
                        n->n_col_offset, c->c_arena);
        else
            return ast_for_call(c, CHILD(n, 1), left_expr);
    }
    else if (TYPE(CHILD(n, 0)) == DOT ) {
        PyObject *attr_id = NEW_IDENTIFIER(CHILD(n, 1));
        if (!attr_id)
            return NULL;
        return Attribute(left_expr, attr_id, Load,
                         LINENO(n), n->n_col_offset, c->c_arena);
    }
    else {
        REQ(CHILD(n, 0), LSQB);
        REQ(CHILD(n, 2), RSQB);
        n = CHILD(n, 1);
        if (NCH(n) == 1) {
            slice_ty slc = ast_for_slice(c, CHILD(n, 0));
            if (!slc)
                return NULL;
            return Subscript(left_expr, slc, Load, LINENO(n), n->n_col_offset,
                             c->c_arena);
        }
        else {
            /* The grammar is ambiguous here. The ambiguity is resolved 
               by treating the sequence as a tuple literal if there are
               no slice features.
            */
            int j;
            slice_ty slc;
            expr_ty e;
            bool simple = true;
            asdl_seq *slices, *elts;
            slices = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
            if (!slices)
                return NULL;
            for (j = 0; j < NCH(n); j += 2) {
                slc = ast_for_slice(c, CHILD(n, j));
                if (!slc)
                    return NULL;
                if (slc->kind != Index_kind)
                    simple = false;
                asdl_seq_SET(slices, j / 2, slc);
            }
            if (!simple) {
                return Subscript(left_expr, ExtSlice(slices, c->c_arena),
                                 Load, LINENO(n), n->n_col_offset, c->c_arena);
            }
            /* extract Index values and put them in a Tuple */
            elts = asdl_seq_new(asdl_seq_LEN(slices), c->c_arena);
            if (!elts)
                return NULL;
            for (j = 0; j < asdl_seq_LEN(slices); ++j) {
                slc = (slice_ty)asdl_seq_GET(slices, j);
                assert(slc->kind == Index_kind  && slc->v.Index.value);
                asdl_seq_SET(elts, j, slc->v.Index.value);
            }
            e = Tuple(elts, Load, LINENO(n), n->n_col_offset, c->c_arena);
            if (!e)
                return NULL;
            return Subscript(left_expr, Index(e, c->c_arena),
                             Load, LINENO(n), n->n_col_offset, c->c_arena);
        }
    }
}

static expr_ty
ast_for_factor(struct compiling *c, const node *n)
{
    node *pfactor, *ppower, *patom, *pnum;
    expr_ty expression;

    /* If the unary - operator is applied to a constant, don't generate
       a UNARY_NEGATIVE opcode.  Just store the approriate value as a
       constant.  The peephole optimizer already does something like
       this but it doesn't handle the case where the constant is
       (sys.maxint - 1).  In that case, we want a PyIntObject, not a
       PyLongObject.
    */
    if (TYPE(CHILD(n, 0)) == MINUS &&
        NCH(n) == 2 &&
        TYPE((pfactor = CHILD(n, 1))) == factor &&
        NCH(pfactor) == 1 &&
        TYPE((ppower = CHILD(pfactor, 0))) == power &&
        NCH(ppower) == 1 &&
        TYPE((patom = CHILD(ppower, 0))) == atom &&
        TYPE((pnum = CHILD(patom, 0))) == NUMBER) {
        char *s = PyObject_MALLOC(strlen(STR(pnum)) + 2);
        if (s == NULL)
            return NULL;
        s[0] = '-';
        strcpy(s + 1, STR(pnum));
        PyObject_FREE(STR(pnum));
        STR(pnum) = s;
        return ast_for_atom(c, patom);
    }

    expression = ast_for_expr(c, CHILD(n, 1));
    if (!expression)
        return NULL;

    switch (TYPE(CHILD(n, 0))) {
        case PLUS:
            return UnaryOp(UAdd, expression, LINENO(n), n->n_col_offset,
                           c->c_arena);
        case MINUS:
            return UnaryOp(USub, expression, LINENO(n), n->n_col_offset,
                           c->c_arena);
        case TILDE:
            return UnaryOp(Invert, expression, LINENO(n),
                           n->n_col_offset, c->c_arena);
    }
    PyErr_Format(PyExc_SystemError, "unhandled factor: %d",
                 TYPE(CHILD(n, 0)));
    return NULL;
}

static expr_ty
ast_for_power(struct compiling *c, const node *n)
{
    /* power: atom trailer* ('**' factor)*
     */
    int i;
    expr_ty e, tmp;
    REQ(n, power);
    e = ast_for_atom(c, CHILD(n, 0));
    if (!e)
        return NULL;
    if (NCH(n) == 1)
        return e;
    for (i = 1; i < NCH(n); i++) {
        node *ch = CHILD(n, i);
        if (TYPE(ch) != trailer)
            break;
        tmp = ast_for_trailer(c, ch, e);
        if (!tmp)
            return NULL;
        tmp->lineno = e->lineno;
        tmp->col_offset = e->col_offset;
        e = tmp;
    }
    if (TYPE(CHILD(n, NCH(n) - 1)) == factor) {
        expr_ty f = ast_for_expr(c, CHILD(n, NCH(n) - 1));
        if (!f)
            return NULL;
        tmp = BinOp(e, Pow, f, LINENO(n), n->n_col_offset, c->c_arena);
        if (!tmp)
            return NULL;
        e = tmp;
    }
    return e;
}

/* Do not name a variable 'expr'!  Will cause a compile error.
*/

static expr_ty
ast_for_expr(struct compiling *c, const node *n)
{
    /* handle the full range of simple expressions
       test: or_test ['if' or_test 'else' test] | lambdef
       or_test: and_test ('or' and_test)* 
       and_test: not_test ('and' not_test)*
       not_test: 'not' not_test | comparison
       comparison: expr (comp_op expr)*
       expr: xor_expr ('|' xor_expr)*
       xor_expr: and_expr ('^' and_expr)*
       and_expr: shift_expr ('&' shift_expr)*
       shift_expr: arith_expr (('<<'|'>>') arith_expr)*
       arith_expr: term (('+'|'-') term)*
       term: factor (('*'|'/'|'%'|'//') factor)*
       factor: ('+'|'-'|'~') factor | power
       power: atom trailer* ('**' factor)*

       As well as modified versions that exist for backward compatibility,
       to explicitly allow:
       [ x for x in lambda: 0, lambda: 1 ]
       (which would be ambiguous without these extra rules)
       
       old_test: or_test | old_lambdef
       old_lambdef: 'lambda' [vararglist] ':' old_test

    */

    asdl_seq *seq;
    int i;

 loop:
    switch (TYPE(n)) {
        case test:
        case old_test:
            if (TYPE(CHILD(n, 0)) == lambdef ||
                TYPE(CHILD(n, 0)) == old_lambdef)
                return ast_for_lambdef(c, CHILD(n, 0));
            else if (NCH(n) > 1)
                return ast_for_ifexpr(c, n);
            /* Fallthrough */
        case or_test:
        case and_test:
            if (NCH(n) == 1) {
                n = CHILD(n, 0);
                goto loop;
            }
            seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
            if (!seq)
                return NULL;
            for (i = 0; i < NCH(n); i += 2) {
                expr_ty e = ast_for_expr(c, CHILD(n, i));
                if (!e)
                    return NULL;
                asdl_seq_SET(seq, i / 2, e);
            }
            if (!strcmp(STR(CHILD(n, 1)), "and"))
                return BoolOp(And, seq, LINENO(n), n->n_col_offset,
                              c->c_arena);
            assert(!strcmp(STR(CHILD(n, 1)), "or"));
            return BoolOp(Or, seq, LINENO(n), n->n_col_offset, c->c_arena);
        case not_test:
            if (NCH(n) == 1) {
                n = CHILD(n, 0);
                goto loop;
            }
            else {
                expr_ty expression = ast_for_expr(c, CHILD(n, 1));
                if (!expression)
                    return NULL;

                return UnaryOp(Not, expression, LINENO(n), n->n_col_offset,
                               c->c_arena);
            }
        case comparison:
            if (NCH(n) == 1) {
                n = CHILD(n, 0);
                goto loop;
            }
            else {
                expr_ty expression;
                asdl_int_seq *ops;
                asdl_seq *cmps;
                ops = asdl_int_seq_new(NCH(n) / 2, c->c_arena);
                if (!ops)
                    return NULL;
                cmps = asdl_seq_new(NCH(n) / 2, c->c_arena);
                if (!cmps) {
                    return NULL;
                }
                for (i = 1; i < NCH(n); i += 2) {
                    cmpop_ty newoperator;

                    newoperator = ast_for_comp_op(c, CHILD(n, i));
                    if (!newoperator) {
                        return NULL;
                    }

                    expression = ast_for_expr(c, CHILD(n, i + 1));
                    if (!expression) {
                        return NULL;
                    }
                        
                    asdl_seq_SET(ops, i / 2, newoperator);
                    asdl_seq_SET(cmps, i / 2, expression);
                }
                expression = ast_for_expr(c, CHILD(n, 0));
                if (!expression) {
                    return NULL;
                }
                    
                return Compare(expression, ops, cmps, LINENO(n),
                               n->n_col_offset, c->c_arena);
            }
            break;

        /* The next five cases all handle BinOps.  The main body of code
           is the same in each case, but the switch turned inside out to
           reuse the code for each type of operator.
         */
        case expr:
        case xor_expr:
        case and_expr:
        case shift_expr:
        case arith_expr:
        case term:
            if (NCH(n) == 1) {
                n = CHILD(n, 0);
                goto loop;
            }
            return ast_for_binop(c, n);
        case yield_expr: {
            expr_ty exp = NULL;
            if (NCH(n) == 2) {
                exp = ast_for_testlist(c, CHILD(n, 1));
                if (!exp)
                    return NULL;
            }
            return Yield(exp, LINENO(n), n->n_col_offset, c->c_arena);
        }
        case factor:
            if (NCH(n) == 1) {
                n = CHILD(n, 0);
                goto loop;
            }
            return ast_for_factor(c, n);
        case power:
            return ast_for_power(c, n);
        default:
            PyErr_Format(PyExc_SystemError, "unhandled expr: %d", TYPE(n));
            return NULL;
    }
    /* should never get here unless if error is set */
    return NULL;
}

static expr_ty
ast_for_call(struct compiling *c, const node *n, expr_ty func)
{
    /*
      arglist: (argument ',')* (argument [',']| '*' test [',' '**' test]
               | '**' test)
      argument: [test '='] test [gen_for]        # Really [keyword '='] test
    */

    int i, nargs, nkeywords, ngens;
    asdl_seq *args;
    asdl_seq *keywords;
    expr_ty vararg = NULL, kwarg = NULL;

    REQ(n, arglist);

    nargs = 0;
    nkeywords = 0;
    ngens = 0;
    for (i = 0; i < NCH(n); i++) {
        node *ch = CHILD(n, i);
        if (TYPE(ch) == argument) {
            if (NCH(ch) == 1)
                nargs++;
            else if (TYPE(CHILD(ch, 1)) == gen_for)
                ngens++;
            else
                nkeywords++;
        }
    }
    if (ngens > 1 || (ngens && (nargs || nkeywords))) {
        ast_error(n, "Generator expression must be parenthesized "
                  "if not sole argument");
        return NULL;
    }

    if (nargs + nkeywords + ngens > 255) {
      ast_error(n, "more than 255 arguments");
      return NULL;
    }

    args = asdl_seq_new(nargs + ngens, c->c_arena);
    if (!args)
        return NULL;
    keywords = asdl_seq_new(nkeywords, c->c_arena);
    if (!keywords)
        return NULL;
    nargs = 0;
    nkeywords = 0;
    for (i = 0; i < NCH(n); i++) {
        node *ch = CHILD(n, i);
        if (TYPE(ch) == argument) {
            expr_ty e;
            if (NCH(ch) == 1) {
                if (nkeywords) {
                    ast_error(CHILD(ch, 0),
                              "non-keyword arg after keyword arg");
                    return NULL;
                }
                if (vararg) {
                    ast_error(CHILD(ch, 0),
                              "only named arguments may follow *expression");
                    return NULL;
                }
                e = ast_for_expr(c, CHILD(ch, 0));
                if (!e)
                    return NULL;
                asdl_seq_SET(args, nargs++, e);
            }  
            else if (TYPE(CHILD(ch, 1)) == gen_for) {
                e = ast_for_genexp(c, ch);
                if (!e)
                    return NULL;
                asdl_seq_SET(args, nargs++, e);
            }
            else {
                keyword_ty kw;
                identifier key;
                int k;
                char *tmp;

                /* CHILD(ch, 0) is test, but must be an identifier? */ 
                e = ast_for_expr(c, CHILD(ch, 0));
                if (!e)
                    return NULL;
                /* f(lambda x: x[0] = 3) ends up getting parsed with
                 * LHS test = lambda x: x[0], and RHS test = 3.
                 * SF bug 132313 points out that complaining about a keyword
                 * then is very confusing.
                 */
                if (e->kind == Lambda_kind) {
                    ast_error(CHILD(ch, 0),
                              "lambda cannot contain assignment");
                    return NULL;
                } else if (e->kind != Name_kind) {
                    ast_error(CHILD(ch, 0), "keyword can't be an expression");
                    return NULL;
                }
                key = e->v.Name.id;
                if (!forbidden_check(c, CHILD(ch, 0), PyBytes_AS_STRING(key)))
                    return NULL;
                for (k = 0; k < nkeywords; k++) {
                    tmp = PyString_AS_STRING(
                        ((keyword_ty)asdl_seq_GET(keywords, k))->arg);
                    if (!strcmp(tmp, PyString_AS_STRING(key))) {
                        ast_error(CHILD(ch, 0), "keyword argument repeated");
                        return NULL;
                    }
                }
                e = ast_for_expr(c, CHILD(ch, 2));
                if (!e)
                    return NULL;
                kw = keyword(key, e, c->c_arena);
                if (!kw)
                    return NULL;
                asdl_seq_SET(keywords, nkeywords++, kw);
            }
        }
        else if (TYPE(ch) == STAR) {
            vararg = ast_for_expr(c, CHILD(n, i+1));
            if (!vararg)
                return NULL;
            i++;
        }
        else if (TYPE(ch) == DOUBLESTAR) {
            kwarg = ast_for_expr(c, CHILD(n, i+1));
            if (!kwarg)
                return NULL;
            i++;
        }
    }

    return Call(func, args, keywords, vararg, kwarg, func->lineno,
                func->col_offset, c->c_arena);
}

static expr_ty
ast_for_testlist(struct compiling *c, const node* n)
{
    /* testlist_gexp: test (',' test)* [','] */
    /* testlist: test (',' test)* [','] */
    /* testlist_safe: test (',' test)+ [','] */
    /* testlist1: test (',' test)* */
    assert(NCH(n) > 0);
    if (TYPE(n) == testlist_gexp) {
        if (NCH(n) > 1)
            assert(TYPE(CHILD(n, 1)) != gen_for);
    }
    else {
        assert(TYPE(n) == testlist ||
               TYPE(n) == testlist_safe ||
               TYPE(n) == testlist1);
    }
    if (NCH(n) == 1)
        return ast_for_expr(c, CHILD(n, 0));
    else {
        asdl_seq *tmp = seq_for_testlist(c, n);
        if (!tmp)
            return NULL;
        return Tuple(tmp, Load, LINENO(n), n->n_col_offset, c->c_arena);
    }
}

static expr_ty
ast_for_testlist_gexp(struct compiling *c, const node* n)
{
    /* testlist_gexp: test ( gen_for | (',' test)* [','] ) */
    /* argument: test [ gen_for ] */
    assert(TYPE(n) == testlist_gexp || TYPE(n) == argument);
    if (NCH(n) > 1 && TYPE(CHILD(n, 1)) == gen_for)
        return ast_for_genexp(c, n);
    return ast_for_testlist(c, n);
}

/* like ast_for_testlist() but returns a sequence */
static asdl_seq*
ast_for_class_bases(struct compiling *c, const node* n)
{
    /* testlist: test (',' test)* [','] */
    assert(NCH(n) > 0);
    REQ(n, testlist);
    if (NCH(n) == 1) {
        expr_ty base;
        asdl_seq *bases = asdl_seq_new(1, c->c_arena);
        if (!bases)
            return NULL;
        base = ast_for_expr(c, CHILD(n, 0));
        if (!base)
            return NULL;
        asdl_seq_SET(bases, 0, base);
        return bases;
    }

    return seq_for_testlist(c, n);
}

static stmt_ty
ast_for_expr_stmt(struct compiling *c, const node *n)
{
    REQ(n, expr_stmt);
    /* expr_stmt: testlist (augassign (yield_expr|testlist) 
                | ('=' (yield_expr|testlist))*)
       testlist: test (',' test)* [',']
       augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
                | '<<=' | '>>=' | '**=' | '//='
       test: ... here starts the operator precendence dance
     */

    if (NCH(n) == 1) {
        expr_ty e = ast_for_testlist(c, CHILD(n, 0));
        if (!e)
            return NULL;

        return Expr(e, LINENO(n), n->n_col_offset, c->c_arena);
    }
    else if (TYPE(CHILD(n, 1)) == augassign) {
        expr_ty expr1, expr2;
        operator_ty newoperator;
        node *ch = CHILD(n, 0);

        expr1 = ast_for_testlist(c, ch);
        if (!expr1)
            return NULL;
        if(!set_context(c, expr1, Store, ch))
            return NULL;

        ch = CHILD(n, 2);
        if (TYPE(ch) == testlist)
            expr2 = ast_for_testlist(c, ch);
        else
            expr2 = ast_for_expr(c, ch);
        if (!expr2)
            return NULL;

        newoperator = ast_for_augassign(c, CHILD(n, 1));
        if (!newoperator)
            return NULL;

        return AugAssign(expr1, newoperator, expr2, LINENO(n), n->n_col_offset,
                         c->c_arena);
    }
    else {
        int i;
        asdl_seq *targets;
        node *value;
        expr_ty expression;

        /* a normal assignment */
        REQ(CHILD(n, 1), EQUAL);
        targets = asdl_seq_new(NCH(n) / 2, c->c_arena);
        if (!targets)
            return NULL;
        for (i = 0; i < NCH(n) - 2; i += 2) {
            expr_ty e;
            node *ch = CHILD(n, i);
            if (TYPE(ch) == yield_expr) {
                ast_error(ch, "assignment to yield expression not possible");
                return NULL;
            }
            e = ast_for_testlist(c, ch);

            /* set context to assign */
            if (!e) 
                return NULL;

            if (!set_context(c, e, Store, CHILD(n, i)))
                return NULL;

            asdl_seq_SET(targets, i / 2, e);
        }
        value = CHILD(n, NCH(n) - 1);
        if (TYPE(value) == testlist)
            expression = ast_for_testlist(c, value);
        else
            expression = ast_for_expr(c, value);
        if (!expression)
            return NULL;
        return Assign(targets, expression, LINENO(n), n->n_col_offset,
                      c->c_arena);
    }
}

static stmt_ty
ast_for_print_stmt(struct compiling *c, const node *n)
{
    /* print_stmt: 'print' ( [ test (',' test)* [','] ]
                             | '>>' test [ (',' test)+ [','] ] )
     */
    expr_ty dest = NULL, expression;
    asdl_seq *seq = NULL;
    bool nl;
    int i, j, values_count, start = 1;

    REQ(n, print_stmt);
    if (NCH(n) >= 2 && TYPE(CHILD(n, 1)) == RIGHTSHIFT) {
        dest = ast_for_expr(c, CHILD(n, 2));
        if (!dest)
            return NULL;
            start = 4;
    }
    values_count = (NCH(n) + 1 - start) / 2;
    if (values_count) {
        seq = asdl_seq_new(values_count, c->c_arena);
        if (!seq)
            return NULL;
        for (i = start, j = 0; i < NCH(n); i += 2, ++j) {
            expression = ast_for_expr(c, CHILD(n, i));
            if (!expression)
                return NULL;
            asdl_seq_SET(seq, j, expression);
        }
    }
    nl = (TYPE(CHILD(n, NCH(n) - 1)) == COMMA) ? false : true;
    return Print(dest, seq, nl, LINENO(n), n->n_col_offset, c->c_arena);
}

static asdl_seq *
ast_for_exprlist(struct compiling *c, const node *n, expr_context_ty context)
{
    asdl_seq *seq;
    int i;
    expr_ty e;

    REQ(n, exprlist);

    seq = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
    if (!seq)
        return NULL;
    for (i = 0; i < NCH(n); i += 2) {
        e = ast_for_expr(c, CHILD(n, i));
        if (!e)
            return NULL;
        asdl_seq_SET(seq, i / 2, e);
        if (context && !set_context(c, e, context, CHILD(n, i)))
            return NULL;
    }
    return seq;
}

static stmt_ty
ast_for_del_stmt(struct compiling *c, const node *n)
{
    asdl_seq *expr_list;
    
    /* del_stmt: 'del' exprlist */
    REQ(n, del_stmt);

    expr_list = ast_for_exprlist(c, CHILD(n, 1), Del);
    if (!expr_list)
        return NULL;
    return Delete(expr_list, LINENO(n), n->n_col_offset, c->c_arena);
}

static stmt_ty
ast_for_flow_stmt(struct compiling *c, const node *n)
{
    /*
      flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt
                 | yield_stmt
      break_stmt: 'break'
      continue_stmt: 'continue'
      return_stmt: 'return' [testlist]
      yield_stmt: yield_expr
      yield_expr: 'yield' testlist
      raise_stmt: 'raise' [test [',' test [',' test]]]
    */
    node *ch;

    REQ(n, flow_stmt);
    ch = CHILD(n, 0);
    switch (TYPE(ch)) {
        case break_stmt:
            return Break(LINENO(n), n->n_col_offset, c->c_arena);
        case continue_stmt:
            return Continue(LINENO(n), n->n_col_offset, c->c_arena);
        case yield_stmt: { /* will reduce to yield_expr */
            expr_ty exp = ast_for_expr(c, CHILD(ch, 0));
            if (!exp)
                return NULL;
            return Expr(exp, LINENO(n), n->n_col_offset, c->c_arena);
        }
        case return_stmt:
            if (NCH(ch) == 1)
                return Return(NULL, LINENO(n), n->n_col_offset, c->c_arena);
            else {
                expr_ty expression = ast_for_testlist(c, CHILD(ch, 1));
                if (!expression)
                    return NULL;
                return Return(expression, LINENO(n), n->n_col_offset,
                              c->c_arena);
            }
        case raise_stmt:
            if (NCH(ch) == 1)
                return Raise(NULL, NULL, NULL, LINENO(n), n->n_col_offset,
                             c->c_arena);
            else if (NCH(ch) == 2) {
                expr_ty expression = ast_for_expr(c, CHILD(ch, 1));
                if (!expression)
                    return NULL;
                return Raise(expression, NULL, NULL, LINENO(n),
                             n->n_col_offset, c->c_arena);
            }
            else if (NCH(ch) == 4) {
                expr_ty expr1, expr2;

                expr1 = ast_for_expr(c, CHILD(ch, 1));
                if (!expr1)
                    return NULL;
                expr2 = ast_for_expr(c, CHILD(ch, 3));
                if (!expr2)
                    return NULL;

                return Raise(expr1, expr2, NULL, LINENO(n), n->n_col_offset,
                             c->c_arena);
            }
            else if (NCH(ch) == 6) {
                expr_ty expr1, expr2, expr3;

                expr1 = ast_for_expr(c, CHILD(ch, 1));
                if (!expr1)
                    return NULL;
                expr2 = ast_for_expr(c, CHILD(ch, 3));
                if (!expr2)
                    return NULL;
                expr3 = ast_for_expr(c, CHILD(ch, 5));
                if (!expr3)
                    return NULL;
                    
                return Raise(expr1, expr2, expr3, LINENO(n), n->n_col_offset,
                             c->c_arena);
            }
        default:
            PyErr_Format(PyExc_SystemError,
                         "unexpected flow_stmt: %d", TYPE(ch));
            return NULL;
    }

    PyErr_SetString(PyExc_SystemError, "unhandled flow statement");
    return NULL;
}

static alias_ty
alias_for_import_name(struct compiling *c, const node *n, int store)
{
    /*
      import_as_name: NAME ['as' NAME]
      dotted_as_name: dotted_name ['as' NAME]
      dotted_name: NAME ('.' NAME)*
    */
    PyObject *str, *name;

 loop:
    switch (TYPE(n)) {
         case import_as_name: {
            node *name_node = CHILD(n, 0);
            str = NULL;
            if (NCH(n) == 3) {
                node *str_node = CHILD(n, 2);
                if (store && !forbidden_check(c, str_node, STR(str_node)))
                    return NULL;
                str = NEW_IDENTIFIER(str_node);
                if (!str)
                    return NULL;
            }
            else {
                if (!forbidden_check(c, name_node, STR(name_node)))
                    return NULL;
            }
            name = NEW_IDENTIFIER(name_node);
            if (!name)
                return NULL;
            return alias(name, str, c->c_arena);
        }
        case dotted_as_name:
            if (NCH(n) == 1) {
                n = CHILD(n, 0);
                goto loop;
            }
            else {
                node *asname_node = CHILD(n, 2);
                alias_ty a = alias_for_import_name(c, CHILD(n, 0), 0);
                if (!a)
                    return NULL;
                assert(!a->asname);
                if (!forbidden_check(c, asname_node, STR(asname_node)))
                    return NULL;
                a->asname = NEW_IDENTIFIER(asname_node);
                if (!a->asname)
                    return NULL;
                return a;
            }
            break;
        case dotted_name:
            if (NCH(n) == 1) {
                node *name_node = CHILD(n, 0);
                if (store && !forbidden_check(c, name_node, STR(name_node)))
                    return NULL;
                name = NEW_IDENTIFIER(name_node);
                if (!name)
                    return NULL;
                return alias(name, NULL, c->c_arena);
            }
            else {
                /* Create a string of the form "a.b.c" */
                int i;
                size_t len;
                char *s;

                len = 0;
                for (i = 0; i < NCH(n); i += 2)
                    /* length of string plus one for the dot */
                    len += strlen(STR(CHILD(n, i))) + 1;
                len--; /* the last name doesn't have a dot */
                str = PyString_FromStringAndSize(NULL, len);
                if (!str)
                    return NULL;
                s = PyString_AS_STRING(str);
                if (!s)
                    return NULL;
                for (i = 0; i < NCH(n); i += 2) {
                    char *sch = STR(CHILD(n, i));
                    strcpy(s, STR(CHILD(n, i)));
                    s += strlen(sch);
                    *s++ = '.';
                }
                --s;
                *s = '\0';
                PyString_InternInPlace(&str);
                PyArena_AddPyObject(c->c_arena, str);
                return alias(str, NULL, c->c_arena);
            }
            break;
        case STAR:
            str = PyString_InternFromString("*");
            PyArena_AddPyObject(c->c_arena, str);
            return alias(str, NULL, c->c_arena);
        default:
            PyErr_Format(PyExc_SystemError,
                         "unexpected import name: %d", TYPE(n));
            return NULL;
    }

    PyErr_SetString(PyExc_SystemError, "unhandled import name condition");
    return NULL;
}

static stmt_ty
ast_for_import_stmt(struct compiling *c, const node *n)
{
    /*
      import_stmt: import_name | import_from
      import_name: 'import' dotted_as_names
      import_from: 'from' ('.'* dotted_name | '.') 'import'
                          ('*' | '(' import_as_names ')' | import_as_names)
    */
    int lineno;
    int col_offset;
    int i;
    asdl_seq *aliases;

    REQ(n, import_stmt);
    lineno = LINENO(n);
    col_offset = n->n_col_offset;
    n = CHILD(n, 0);
    if (TYPE(n) == import_name) {
        n = CHILD(n, 1);
        REQ(n, dotted_as_names);
        aliases = asdl_seq_new((NCH(n) + 1) / 2, c->c_arena);
        if (!aliases)
            return NULL;
        for (i = 0; i < NCH(n); i += 2) {
            alias_ty import_alias = alias_for_import_name(c, CHILD(n, i), 1);
            if (!import_alias)
                return NULL;
            asdl_seq_SE
    tb_getsetters<span class="hl opt">,</span>                              <span class="hl com">/* tp_getset */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_base */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_dict */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_descr_get */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_descr_set */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_dictoffset */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_init */</span>
    <span class="hl num">0</span><span class="hl opt">,</span>                                          <span class="hl com">/* tp_alloc */</span>
    tb_new<span class="hl opt">,</span>                                     <span class="hl com">/* tp_new */</span>
<span class="hl opt">};</span>


PyObject<span class="hl opt">*</span>
<span class="hl kwd">_PyTraceBack_FromFrame</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>tb_next<span class="hl opt">,</span> PyFrameObject <span class="hl opt">*</span>frame<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>tb_next <span class="hl opt">==</span> NULL <span class="hl opt">||</span> <span class="hl kwd">PyTraceBack_Check</span><span class="hl opt">(</span>tb_next<span class="hl opt">));</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>frame <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>
    <span class="hl kwb">int</span> addr <span class="hl opt">=</span> <span class="hl kwd">_PyInterpreterFrame_LASTI</span><span class="hl opt">(</span>frame<span class="hl opt">-&gt;</span>f_frame<span class="hl opt">) *</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>_Py_CODEUNIT<span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl kwd">tb_create_raw</span><span class="hl opt">((</span>PyTracebackObject <span class="hl opt">*)</span>tb_next<span class="hl opt">,</span> frame<span class="hl opt">,</span> addr<span class="hl opt">,</span>
                         <span class="hl kwd">PyFrame_GetLineNumber</span><span class="hl opt">(</span>frame<span class="hl opt">));</span>
<span class="hl opt">}</span>


<span class="hl kwb">int</span>
<span class="hl kwd">PyTraceBack_Here</span><span class="hl opt">(</span>PyFrameObject <span class="hl opt">*</span>frame<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>exc <span class="hl opt">=</span> <span class="hl kwd">PyErr_GetRaisedException</span><span class="hl opt">();</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">PyExceptionInstance_Check</span><span class="hl opt">(</span>exc<span class="hl opt">));</span>
    PyObject <span class="hl opt">*</span>tb <span class="hl opt">=</span> <span class="hl kwd">PyException_GetTraceback</span><span class="hl opt">(</span>exc<span class="hl opt">);</span>
    PyObject <span class="hl opt">*</span>newtb <span class="hl opt">=</span> <span class="hl kwd">_PyTraceBack_FromFrame</span><span class="hl opt">(</span>tb<span class="hl opt">,</span> frame<span class="hl opt">);</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>tb<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>newtb <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">_PyErr_ChainExceptions1</span><span class="hl opt">(</span>exc<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">PyException_SetTraceback</span><span class="hl opt">(</span>exc<span class="hl opt">,</span> newtb<span class="hl opt">);</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>newtb<span class="hl opt">);</span>
    <span class="hl kwd">PyErr_SetRaisedException</span><span class="hl opt">(</span>exc<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 com">/* Insert a frame into the traceback for (funcname, filename, lineno). */</span>
<span class="hl kwb">void</span> <span class="hl kwd">_PyTraceback_Add</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>funcname<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>filename<span class="hl opt">,</span> <span class="hl kwb">int</span> lineno<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>globals<span class="hl opt">;</span>
    PyCodeObject <span class="hl opt">*</span>code<span class="hl opt">;</span>
    PyFrameObject <span class="hl opt">*</span>frame<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 com">/* Save and clear the current exception. Python functions must not be</span>
<span class="hl com">       called with an exception set. Calling Python functions happens when</span>
<span class="hl com">       the codec of the filesystem encoding is implemented in pure Python. */</span>
    PyObject <span class="hl opt">*</span>exc <span class="hl opt">=</span> <span class="hl kwd">_PyErr_GetRaisedException</span><span class="hl opt">(</span>tstate<span class="hl opt">);</span>

    globals <span class="hl opt">=</span> <span class="hl kwd">PyDict_New</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>globals<span class="hl opt">)</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>
    code <span class="hl opt">=</span> <span class="hl kwd">PyCode_NewEmpty</span><span class="hl opt">(</span>filename<span class="hl opt">,</span> funcname<span class="hl opt">,</span> lineno<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>code<span class="hl opt">) {</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>globals<span class="hl opt">);</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    frame <span class="hl opt">=</span> <span class="hl kwd">PyFrame_New</span><span class="hl opt">(</span>tstate<span class="hl opt">,</span> code<span class="hl opt">,</span> globals<span class="hl opt">,</span> NULL<span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>globals<span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>code<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>frame<span class="hl opt">)</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>
    frame<span class="hl opt">-&gt;</span>f_lineno <span class="hl opt">=</span> lineno<span class="hl opt">;</span>

    <span class="hl kwd">_PyErr_SetRaisedException</span><span class="hl opt">(</span>tstate<span class="hl opt">,</span> exc<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 kwd">Py_DECREF</span><span class="hl opt">(</span>frame<span class="hl opt">);</span>
    <span class="hl kwa">return</span><span class="hl opt">;</span>

error<span class="hl opt">:</span>
    <span class="hl kwd">_PyErr_ChainExceptions1</span><span class="hl opt">(</span>exc<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">_Py_FindSourceFile</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>filename<span class="hl opt">,</span> <span class="hl kwb">char</span><span class="hl opt">*</span> namebuf<span class="hl opt">,</span> <span class="hl kwb">size_t</span> namelen<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>io<span class="hl opt">)</span>
<span class="hl opt">{</span>
    Py_ssize_t i<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>binary<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>v<span class="hl opt">;</span>
    Py_ssize_t npath<span class="hl opt">;</span>
    <span class="hl kwb">size_t</span> taillen<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>syspath<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>path<span class="hl opt">;</span>
    <span class="hl kwb">const char</span><span class="hl opt">*</span> tail<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>filebytes<span class="hl opt">;</span>
    <span class="hl kwb">const char</span><span class="hl opt">*</span> filepath<span class="hl opt">;</span>
    Py_ssize_t len<span class="hl opt">;</span>
    PyObject<span class="hl opt">*</span> result<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>open <span class="hl opt">=</span> NULL<span class="hl opt">;</span>

    filebytes <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_EncodeFSDefault</span><span class="hl opt">(</span>filename<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>filebytes <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
        <span class="hl kwa">return</span> NULL<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    filepath <span class="hl opt">=</span> <span class="hl kwd">PyBytes_AS_STRING</span><span class="hl opt">(</span>filebytes<span class="hl opt">);</span>

    <span class="hl com">/* Search tail of filename in sys.path before giving up */</span>
    tail <span class="hl opt">=</span> <span class="hl kwd">strrchr</span><span class="hl opt">(</span>filepath<span class="hl opt">,</span> SEP<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>tail <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        tail <span class="hl opt">=</span> filepath<span class="hl opt">;</span>
    <span class="hl kwa">else</span>
        tail<span class="hl opt">++;</span>
    taillen <span class="hl opt">=</span> <span class="hl kwd">strlen</span><span class="hl opt">(</span>tail<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>
    syspath <span class="hl opt">=</span> <span class="hl kwd">_PySys_GetAttr</span><span class="hl opt">(</span>tstate<span class="hl opt">, &amp;</span><span class="hl kwd">_Py_ID</span><span class="hl opt">(</span>path<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>syspath <span class="hl opt">==</span> NULL <span class="hl opt">|| !</span><span class="hl kwd">PyList_Check</span><span class="hl opt">(</span>syspath<span class="hl opt">))</span>
        <span class="hl kwa">goto</span> error<span class="hl opt">;</span>
    npath <span class="hl opt">=</span> <span class="hl kwd">PyList_Size</span><span class="hl opt">(</span>syspath<span class="hl opt">);</span>

    open <span class="hl opt">=</span> <span class="hl kwd">PyObject_GetAttr</span><span class="hl opt">(</span>io<span class="hl opt">, &amp;</span><span class="hl kwd">_Py_ID</span><span class="hl opt">(</span>open<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> npath<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
        v <span class="hl opt">=</span> <span class="hl kwd">PyList_GetItem</span><span class="hl opt">(</span>syspath<span class="hl opt">,</span> i<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 kwd">PyErr_Clear</span><span class="hl opt">();</span>
            <span class="hl kwa">break</span><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">PyUnicode_Check</span><span class="hl opt">(</span>v<span class="hl opt">))</span>
            <span class="hl kwa">continue</span><span class="hl opt">;</span>
        path <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_EncodeFSDefault</span><span class="hl opt">(</span>v<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>path <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
            <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
            <span class="hl kwa">continue</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        len <span class="hl opt">=</span> <span class="hl kwd">PyBytes_GET_SIZE</span><span class="hl opt">(</span>path<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>len <span class="hl opt">+</span> <span class="hl num">1</span> <span class="hl opt">+ (</span>Py_ssize_t<span class="hl opt">)</span>taillen <span class="hl opt">&gt;= (</span>Py_ssize_t<span class="hl opt">)</span>namelen <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">) {</span>
            <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>path<span class="hl opt">);</span>
            <span class="hl kwa">continue</span><span class="hl opt">;</span> <span class="hl com">/* Too long */</span>
        <span class="hl opt">}</span>
        <span class="hl kwd">strcpy</span><span class="hl opt">(</span>namebuf<span class="hl opt">,</span> <span class="hl kwd">PyBytes_AS_STRING</span><span class="hl opt">(</span>path<span class="hl opt">));</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>path<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">strlen</span><span class="hl opt">(</span>namebuf<span class="hl opt">) != (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>len<span class="hl opt">)</span>
            <span class="hl kwa">continue</span><span class="hl opt">;</span> <span class="hl com">/* v contains '\0' */</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>len <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> namebuf<span class="hl opt">[</span>len<span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">] !=</span> SEP<span class="hl opt">)</span>
            namebuf<span class="hl opt">[</span>len<span class="hl opt">++] =</span> SEP<span class="hl opt">;</span>
        <span class="hl kwd">strcpy</span><span class="hl opt">(</span>namebuf<span class="hl opt">+</span>len<span class="hl opt">,</span> tail<span class="hl opt">);</span>

        binary <span class="hl opt">=</span> <span class="hl kwd">_PyObject_CallMethodFormat</span><span class="hl opt">(</span>tstate<span class="hl opt">,</span> open<span class="hl opt">,</span> <span class="hl str">&quot;ss&quot;</span><span class="hl opt">,</span> namebuf<span class="hl opt">,</span> <span class="hl str">&quot;rb&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>binary <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
            result <span class="hl opt">=</span> binary<span class="hl opt">;</span>
            <span class="hl kwa">goto</span> finally<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 opt">}</span>
    <span class="hl kwa">goto</span> error<span class="hl opt">;</span>

error<span class="hl opt">:</span>
    result <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
finally<span class="hl opt">:</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>open<span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>filebytes<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 com">/* Writes indent spaces. Returns 0 on success and non-zero on failure.</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">_Py_WriteIndent</span><span class="hl opt">(</span><span class="hl kwb">int</span> indent<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 kwb">char</span> buf<span class="hl opt">[</span><span class="hl num">11</span><span class="hl opt">] =</span> <span class="hl str">&quot;          &quot;</span><span class="hl opt">;</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">strlen</span><span class="hl opt">(</span>buf<span class="hl opt">) ==</span> <span class="hl num">10</span><span class="hl opt">);</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>indent <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>indent <span class="hl opt">&lt;</span> <span class="hl num">10</span><span class="hl opt">) {</span>
            buf<span class="hl opt">[</span>indent<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">if</span> <span class="hl opt">(</span><span class="hl kwd">PyFile_WriteString</span><span class="hl opt">(</span>buf<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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>
        indent <span class="hl opt">-=</span> <span class="hl num">10</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 com">/* Writes indent spaces, followed by the margin if it is not `\0`.</span>
<span class="hl com">   Returns 0 on success and non-zero on failure.</span>
<span class="hl com"> */</span>
<span class="hl kwb">int</span>
<span class="hl kwd">_Py_WriteIndentedMargin</span><span class="hl opt">(</span><span class="hl kwb">int</span> indent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>margin<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 kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">_Py_WriteIndent</span><span class="hl opt">(</span>indent<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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>margin<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>margin<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 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">display_source_line_with_margin</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>f<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>filename<span class="hl opt">,</span> <span class="hl kwb">int</span> lineno<span class="hl opt">,</span> <span class="hl kwb">int</span> indent<span class="hl opt">,</span>
                                <span class="hl kwb">int</span> margin_indent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>margin<span class="hl opt">,</span>
                                <span class="hl kwb">int</span> <span class="hl opt">*</span>truncation<span class="hl opt">,</span> PyObject <span class="hl opt">**</span>line<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> fd<span class="hl opt">;</span>
    <span class="hl kwb">int</span> i<span class="hl opt">;</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>found_encoding<span class="hl opt">;</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>encoding<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>io<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>binary<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>fob <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>lineobj <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>res<span class="hl opt">;</span>
    <span class="hl kwb">char</span> buf<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> kind<span class="hl opt">;</span>
    <span class="hl kwb">const void</span> <span class="hl opt">*</span>data<span class="hl opt">;</span>

    <span class="hl com">/* open the file */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>filename <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 com">/* Do not attempt to open things like &lt;string&gt; or &lt;stdin&gt; */</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span><span class="hl kwd">PyUnicode_Check</span><span class="hl opt">(</span>filename<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyUnicode_READ_CHAR</span><span class="hl opt">(</span>filename<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">) ==</span> <span class="hl str">'&lt;'</span><span class="hl opt">) {</span>
        Py_ssize_t len <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_GET_LENGTH</span><span class="hl opt">(</span>filename<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>len <span class="hl opt">&gt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">PyUnicode_READ_CHAR</span><span class="hl opt">(</span>filename<span class="hl opt">,</span> len <span class="hl opt">-</span> <span class="hl num">1</span><span class="hl opt">) ==</span> <span class="hl str">'&gt;'</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 opt">}</span>

    io <span class="hl opt">=</span> <span class="hl kwd">PyImport_ImportModule</span><span class="hl opt">(</span><span class="hl str">&quot;io&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>io <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>

    binary <span class="hl opt">=</span> <span class="hl kwd">_PyObject_CallMethod</span><span class="hl opt">(</span>io<span class="hl opt">, &amp;</span><span class="hl kwd">_Py_ID</span><span class="hl opt">(</span>open<span class="hl opt">),</span> <span class="hl str">&quot;Os&quot;</span><span class="hl opt">,</span> filename<span class="hl opt">,</span> <span class="hl str">&quot;rb&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>binary <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>

        binary <span class="hl opt">=</span> <span class="hl kwd">_Py_FindSourceFile</span><span class="hl opt">(</span>filename<span class="hl opt">,</span> buf<span class="hl opt">,</span> <span class="hl kwa">sizeof</span><span class="hl opt">(</span>buf<span class="hl opt">),</span> io<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>binary <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
            <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>io<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 opt">}</span>

    <span class="hl com">/* use the right encoding to decode the file as unicode */</span>
    fd <span class="hl opt">=</span> <span class="hl kwd">PyObject_AsFileDescriptor</span><span class="hl opt">(</span>binary<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>fd <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>io<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>binary<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>
    found_encoding <span class="hl opt">=</span> <span class="hl kwd">_PyTokenizer_FindEncodingFilename</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> filename<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>found_encoding <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
    encoding <span class="hl opt">= (</span>found_encoding <span class="hl opt">!=</span> NULL<span class="hl opt">)</span> ? found_encoding <span class="hl opt">:</span> <span class="hl str">&quot;utf-8&quot;</span><span class="hl opt">;</span>
    <span class="hl com">/* Reset position */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">lseek</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span> SEEK_SET<span class="hl opt">) == (</span>off_t<span class="hl opt">)-</span><span class="hl num">1</span><span class="hl opt">) {</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>io<span class="hl opt">);</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>binary<span class="hl opt">);</span>
        <span class="hl kwd">PyMem_Free</span><span class="hl opt">(</span>found_encoding<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>
    fob <span class="hl opt">=</span> <span class="hl kwd">_PyObject_CallMethod</span><span class="hl opt">(</span>io<span class="hl opt">, &amp;</span><span class="hl kwd">_Py_ID</span><span class="hl opt">(</span>TextIOWrapper<span class="hl opt">),</span>
                               <span class="hl str">&quot;Os&quot;</span><span class="hl opt">,</span> binary<span class="hl opt">,</span> encoding<span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>io<span class="hl opt">);</span>
    <span class="hl kwd">PyMem_Free</span><span class="hl opt">(</span>found_encoding<span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>fob <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>

        res <span class="hl opt">=</span> <span class="hl kwd">PyObject_CallMethodNoArgs</span><span class="hl opt">(</span>binary<span class="hl opt">, &amp;</span><span class="hl kwd">_Py_ID</span><span class="hl opt">(</span>close<span class="hl opt">));</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>binary<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>res<span class="hl opt">)</span>
            <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>res<span class="hl opt">);</span>
        <span class="hl kwa">else</span>
            <span class="hl kwd">PyErr_Clear</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 kwd">Py_DECREF</span><span class="hl opt">(</span>binary<span class="hl opt">);</span>

    <span class="hl com">/* get the line number lineno */</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> lineno<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
        <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>lineobj<span class="hl opt">);</span>
        lineobj <span class="hl opt">=</span> <span class="hl kwd">PyFile_GetLine</span><span class="hl opt">(</span>fob<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>lineobj<span class="hl opt">) {</span>
            <span class="hl kwd">PyErr_Clear</span><span class="hl opt">();</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
    res <span class="hl opt">=</span> <span class="hl kwd">PyObject_CallMethodNoArgs</span><span class="hl opt">(</span>fob<span class="hl opt">, &amp;</span><span class="hl kwd">_Py_ID</span><span class="hl opt">(</span>close<span class="hl opt">));</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>res<span class="hl opt">) {</span>
        <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>res<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_Clear</span><span class="hl opt">();</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>fob<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>lineobj <span class="hl opt">|| !</span><span class="hl kwd">PyUnicode_Check</span><span class="hl opt">(</span>lineobj<span class="hl opt">)) {</span>
        <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>lineobj<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>line<span class="hl opt">) {</span>
        <span class="hl opt">*</span>line <span class="hl opt">=</span> <span class="hl kwd">Py_NewRef</span><span class="hl opt">(</span>lineobj<span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl com">/* remove the indentation of the line */</span>
    kind <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_KIND</span><span class="hl opt">(</span>lineobj<span class="hl opt">);</span>
    data <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_DATA</span><span class="hl opt">(</span>lineobj<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 kwd">PyUnicode_GET_LENGTH</span><span class="hl opt">(</span>lineobj<span class="hl opt">);</span> i<span class="hl opt">++) {</span>
        Py_UCS4 ch <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_READ</span><span class="hl opt">(</span>kind<span class="hl opt">,</span> data<span class="hl opt">,</span> i<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>ch <span class="hl opt">!=</span> <span class="hl str">' '</span> <span class="hl opt">&amp;&amp;</span> ch <span class="hl opt">!=</span> <span class="hl str">'</span><span class="hl esc">\t</span><span class="hl str">'</span> <span class="hl opt">&amp;&amp;</span> ch <span class="hl opt">!=</span> <span class="hl str">'</span><span class="hl esc">\014</span><span class="hl str">'</span><span class="hl opt">)</span>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>i<span class="hl opt">) {</span>
        PyObject <span class="hl opt">*</span>truncated<span class="hl opt">;</span>
        truncated <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_Substring</span><span class="hl opt">(</span>lineobj<span class="hl opt">,</span> i<span class="hl opt">,</span> <span class="hl kwd">PyUnicode_GET_LENGTH</span><span class="hl opt">(</span>lineobj<span class="hl opt">));</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>truncated<span class="hl opt">) {</span>
            <span class="hl kwd">Py_SETREF</span><span class="hl opt">(</span>lineobj<span class="hl opt">,</span> truncated<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_Clear</span><span class="hl opt">();</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>truncation <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        <span class="hl opt">*</span>truncation <span class="hl opt">=</span> i <span class="hl opt">-</span> indent<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">_Py_WriteIndentedMargin</span><span class="hl opt">(</span>margin_indent<span class="hl opt">,</span> margin<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 com">/* Write some spaces before the line */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">_Py_WriteIndent</span><span class="hl opt">(</span>indent<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 com">/* finally display the line */</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyFile_WriteObject</span><span class="hl opt">(</span>lineobj<span class="hl opt">,</span> f<span class="hl opt">,</span> Py_PRINT_RAW<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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">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> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 kwd">Py_DECREF</span><span class="hl opt">(</span>lineobj<span class="hl opt">);</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
error<span class="hl opt">:</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>lineobj<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 kwb">int</span>
<span class="hl kwd">_Py_DisplaySourceLine</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>f<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>filename<span class="hl opt">,</span> <span class="hl kwb">int</span> lineno<span class="hl opt">,</span> <span class="hl kwb">int</span> indent<span class="hl opt">,</span>
                      <span class="hl kwb">int</span> <span class="hl opt">*</span>truncation<span class="hl opt">,</span> PyObject <span class="hl opt">**</span>line<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">return</span> <span class="hl kwd">display_source_line_with_margin</span><span class="hl opt">(</span>f<span class="hl opt">,</span> filename<span class="hl opt">,</span> lineno<span class="hl opt">,</span> indent<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">,</span>
                                           NULL<span class="hl opt">,</span> truncation<span class="hl opt">,</span> line<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/* AST based Traceback Specialization</span>
<span class="hl com"> *</span>
<span class="hl com"> * When displaying a new traceback line, for certain syntactical constructs</span>
<span class="hl com"> * (e.g a subscript, an arithmetic operation) we try to create a representation</span>
<span class="hl com"> * that separates the primary source of error from the rest.</span>
<span class="hl com"> *</span>
<span class="hl com"> * Example specialization of BinOp nodes:</span>
<span class="hl com"> *  Traceback (most recent call last):</span>
<span class="hl com"> *    File &quot;/home/isidentical/cpython/cpython/t.py&quot;, line 10, in &lt;module&gt;</span>
<span class="hl com"> *      add_values(1, 2, 'x', 3, 4)</span>
<span class="hl com"> *    File &quot;/home/isidentical/cpython/cpython/t.py&quot;, line 2, in add_values</span>
<span class="hl com"> *      return a + b + c + d + e</span>
<span class="hl com"> *             ~~~~~~^~~</span>
<span class="hl com"> *  TypeError: 'NoneType' object is not subscriptable</span>
<span class="hl com"> */</span>

<span class="hl ppc">#define IS_WHITESPACE(c) (((c) ==</span> <span class="hl pps">' '</span><span class="hl ppc">) || ((c) ==</span> <span class="hl pps">'</span><span class="hl esc">\t</span><span class="hl pps">'</span><span class="hl ppc">) || ((c) ==</span> <span class="hl pps">'</span><span class="hl esc">\f</span><span class="hl pps">'</span><span class="hl ppc">))</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">extract_anchors_from_expr</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>segment_str<span class="hl opt">,</span> expr_ty expr<span class="hl opt">,</span> Py_ssize_t <span class="hl opt">*</span>left_anchor<span class="hl opt">,</span> Py_ssize_t <span class="hl opt">*</span>right_anchor<span class="hl opt">,</span>
                          <span class="hl kwb">char</span><span class="hl opt">**</span> primary_error_char<span class="hl opt">,</span> <span class="hl kwb">char</span><span class="hl opt">**</span> secondary_error_char<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">switch</span> <span class="hl opt">(</span>expr<span class="hl opt">-&gt;</span>kind<span class="hl opt">) {</span>
        <span class="hl kwa">case</span> BinOp_kind<span class="hl opt">: {</span>
            expr_ty left <span class="hl opt">=</span> expr<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>BinOp<span class="hl opt">.</span>left<span class="hl opt">;</span>
            expr_ty right <span class="hl opt">=</span> expr<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>BinOp<span class="hl opt">.</span>right<span class="hl opt">;</span>
            <span class="hl kwa">for</span> <span class="hl opt">(</span><span class="hl kwb">int</span> i <span class="hl opt">=</span> left<span class="hl opt">-&gt;</span>end_col_offset<span class="hl opt">;</span> i <span class="hl opt">&lt;</span> right<span class="hl opt">-&gt;</span>col_offset<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">IS_WHITESPACE</span><span class="hl opt">(</span>segment_str<span class="hl opt">[</span>i<span class="hl opt">])) {</span>
                    <span class="hl kwa">continue</span><span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl opt">*</span>left_anchor <span class="hl opt">=</span> i<span class="hl opt">;</span>
                <span class="hl opt">*</span>right_anchor <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 slc">// Check whether if this a two-character operator (e.g //)</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span>i <span class="hl opt">+</span> <span class="hl num">1</span> <span class="hl opt">&lt;</span> right<span class="hl opt">-&gt;</span>col_offset <span class="hl opt">&amp;&amp; !</span><span class="hl kwd">IS_WHITESPACE</span><span class="hl opt">(</span>segment_str<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 opt">++*</span>right_anchor<span class="hl opt">;</span>
                <span class="hl opt">}</span>

                <span class="hl slc">// Set the error characters</span>
                <span class="hl opt">*</span>primary_error_char <span class="hl opt">=</span> <span class="hl str">&quot;~&quot;</span><span class="hl opt">;</span>
                <span class="hl opt">*</span>secondary_error_char <span class="hl opt">=</span> <span class="hl str">&quot;^&quot;</span><span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
            <span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">case</span> Subscript_kind<span class="hl opt">: {</span>
            <span class="hl opt">*</span>left_anchor <span class="hl opt">=</span> expr<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>Subscript<span class="hl opt">.</span>value<span class="hl opt">-&gt;</span>end_col_offset<span class="hl opt">;</span>
            <span class="hl opt">*</span>right_anchor <span class="hl opt">=</span> expr<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>Subscript<span class="hl opt">.</span>slice<span class="hl opt">-&gt;</span>end_col_offset <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">;</span>

            <span class="hl slc">// Set the error characters</span>
            <span class="hl opt">*</span>primary_error_char <span class="hl opt">=</span> <span class="hl str">&quot;~&quot;</span><span class="hl opt">;</span>
            <span class="hl opt">*</span>secondary_error_char <span class="hl opt">=</span> <span class="hl str">&quot;^&quot;</span><span class="hl opt">;</span>
            <span class="hl kwa">return</span> <span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">default</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 opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">extract_anchors_from_stmt</span><span class="hl opt">(</span><span class="hl kwb">const char</span> <span class="hl opt">*</span>segment_str<span class="hl opt">,</span> stmt_ty statement<span class="hl opt">,</span> Py_ssize_t <span class="hl opt">*</span>left_anchor<span class="hl opt">,</span> Py_ssize_t <span class="hl opt">*</span>right_anchor<span class="hl opt">,</span>
                          <span class="hl kwb">char</span><span class="hl opt">**</span> primary_error_char<span class="hl opt">,</span> <span class="hl kwb">char</span><span class="hl opt">**</span> secondary_error_char<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">switch</span> <span class="hl opt">(</span>statement<span class="hl opt">-&gt;</span>kind<span class="hl opt">) {</span>
        <span class="hl kwa">case</span> Expr_kind<span class="hl opt">: {</span>
            <span class="hl kwa">return</span> <span class="hl kwd">extract_anchors_from_expr</span><span class="hl opt">(</span>segment_str<span class="hl opt">,</span> statement<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>Expr<span class="hl opt">.</span>value<span class="hl opt">,</span> left_anchor<span class="hl opt">,</span> right_anchor<span class="hl opt">,</span>
                                             primary_error_char<span class="hl opt">,</span> secondary_error_char<span class="hl opt">);</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">default</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 opt">}</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">extract_anchors_from_line</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>filename<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>line<span class="hl opt">,</span>
                          Py_ssize_t start_offset<span class="hl opt">,</span> Py_ssize_t end_offset<span class="hl opt">,</span>
                          Py_ssize_t <span class="hl opt">*</span>left_anchor<span class="hl opt">,</span> Py_ssize_t <span class="hl opt">*</span>right_anchor<span class="hl opt">,</span>
                          <span class="hl kwb">char</span><span class="hl opt">**</span> primary_error_char<span class="hl opt">,</span> <span class="hl kwb">char</span><span class="hl opt">**</span> secondary_error_char<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">int</span> res <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
    PyArena <span class="hl opt">*</span>arena <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>segment <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_Substring</span><span class="hl opt">(</span>line<span class="hl opt">,</span> start_offset<span class="hl opt">,</span> end_offset<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>segment<span class="hl opt">) {</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwb">const char</span> <span class="hl opt">*</span>segment_str <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_AsUTF8</span><span class="hl opt">(</span>segment<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>segment_str<span class="hl opt">) {</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    arena <span class="hl opt">=</span> <span class="hl kwd">_PyArena_New</span><span class="hl opt">();</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>arena<span class="hl opt">) {</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    PyCompilerFlags flags <span class="hl opt">=</span> _PyCompilerFlags_INIT<span class="hl opt">;</span>

    _PyASTOptimizeState state<span class="hl opt">;</span>
    state<span class="hl opt">.</span>optimize <span class="hl opt">=</span> <span class="hl kwd">_Py_GetConfig</span><span class="hl opt">()-&gt;</span>optimization_level<span class="hl opt">;</span>
    state<span class="hl opt">.</span>ff_features <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    mod_ty module <span class="hl opt">=</span> <span class="hl kwd">_PyParser_ASTFromString</span><span class="hl opt">(</span>segment_str<span class="hl opt">,</span> filename<span class="hl opt">,</span> Py_file_input<span class="hl opt">,</span>
                                            <span class="hl opt">&amp;</span>flags<span class="hl opt">,</span> arena<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span>module<span class="hl opt">) {</span>
        <span class="hl kwa">goto</span> done<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">_PyAST_Optimize</span><span class="hl opt">(</span>module<span class="hl opt">,</span> arena<span class="hl opt">, &amp;</span>state<span class="hl opt">)) {</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">assert</span><span class="hl opt">(</span>module<span class="hl opt">-&gt;</span>kind <span class="hl opt">==</span> Module_kind<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">asdl_seq_LEN</span><span class="hl opt">(</span>module<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>Module<span class="hl opt">.</span>body<span class="hl opt">) ==</span> <span class="hl num">1</span><span class="hl opt">) {</span>
        stmt_ty statement <span class="hl opt">=</span> <span class="hl kwd">asdl_seq_GET</span><span class="hl opt">(</span>module<span class="hl opt">-&gt;</span>v<span class="hl opt">.</span>Module<span class="hl opt">.</span>body<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
        res <span class="hl opt">=</span> <span class="hl kwd">extract_anchors_from_stmt</span><span class="hl opt">(</span>segment_str<span class="hl opt">,</span> statement<span class="hl opt">,</span> left_anchor<span class="hl opt">,</span> right_anchor<span class="hl opt">,</span>
                                        primary_error_char<span class="hl opt">,</span> secondary_error_char<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 num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>res <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl slc">// Normalize the AST offsets to byte offsets and adjust them with the</span>
        <span class="hl slc">// start of the actual line (instead of the source code segment).</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>segment <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(*</span>left_anchor <span class="hl opt">&gt;=</span> <span class="hl num">0</span><span class="hl opt">);</span>
        <span class="hl kwa">assert</span><span class="hl opt">(*</span>right_anchor <span class="hl opt">&gt;=</span> <span class="hl num">0</span><span class="hl opt">);</span>
        <span class="hl opt">*</span>left_anchor <span class="hl opt">=</span> <span class="hl kwd">_PyPegen_byte_offset_to_character_offset</span><span class="hl opt">(</span>segment<span class="hl opt">, *</span>left_anchor<span class="hl opt">) +</span> start_offset<span class="hl opt">;</span>
        <span class="hl opt">*</span>right_anchor <span class="hl opt">=</span> <span class="hl kwd">_PyPegen_byte_offset_to_character_offset</span><span class="hl opt">(</span>segment<span class="hl opt">, *</span>right_anchor<span class="hl opt">) +</span> start_offset<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>segment<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>arena<span class="hl opt">) {</span>
        <span class="hl kwd">_PyArena_Free</span><span class="hl opt">(</span>arena<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 ppc">#define _TRACEBACK_SOURCE_LINE_INDENT 4</span>

<span class="hl kwb">static</span> <span class="hl kwc">inline</span> <span class="hl kwb">int</span>
<span class="hl kwd">ignore_source_errors</span><span class="hl opt">(</span><span class="hl kwb">void</span><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 kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">PyErr_ExceptionMatches</span><span class="hl opt">(</span>PyExc_KeyboardInterrupt<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">PyErr_Clear</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> <span class="hl kwc">inline</span> <span class="hl kwb">int</span>
<span class="hl kwd">print_error_location_carets</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>f<span class="hl opt">,</span> <span class="hl kwb">int</span> offset<span class="hl opt">,</span> Py_ssize_t start_offset<span class="hl opt">,</span> Py_ssize_t end_offset<span class="hl opt">,</span>
                            Py_ssize_t right_start_offset<span class="hl opt">,</span> Py_ssize_t left_end_offset<span class="hl opt">,</span>
                            <span class="hl kwb">const char</span> <span class="hl opt">*</span>primary<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>secondary<span class="hl opt">) {</span>
    <span class="hl kwb">int</span> special_chars <span class="hl opt">= (</span>left_end_offset <span class="hl opt">!= -</span><span class="hl num">1</span> <span class="hl opt">||</span> right_start_offset <span class="hl opt">!= -</span><span class="hl num">1</span><span class="hl opt">);</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>str<span class="hl opt">;</span>
    <span class="hl kwa">while</span> <span class="hl opt">(++</span>offset <span class="hl opt">&lt;=</span> end_offset<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>offset <span class="hl opt">&lt;=</span> start_offset<span class="hl opt">) {</span>
            str <span class="hl opt">=</span> <span class="hl str">&quot; &quot;</span><span class="hl opt">;</span>
        <span class="hl opt">}</span> <span class="hl kwa">else if</span> <span class="hl opt">(</span>special_chars <span class="hl opt">&amp;&amp;</span> left_end_offset <span class="hl opt">&lt;</span> offset <span class="hl opt">&amp;&amp;</span> offset <span class="hl opt">&lt;=</span> right_start_offset<span class="hl opt">) {</span>
            str <span class="hl opt">=</span> secondary<span class="hl opt">;</span>
        <span class="hl opt">}</span> <span class="hl kwa">else</span> <span class="hl opt">{</span>
            str <span class="hl opt">=</span> primary<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_WriteString</span><span class="hl opt">(</span>str<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 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> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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">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">tb_displayline</span><span class="hl opt">(</span>PyTracebackObject<span class="hl opt">*</span> tb<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>f<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>filename<span class="hl opt">,</span> <span class="hl kwb">int</span> lineno<span class="hl opt">,</span>
               PyFrameObject <span class="hl opt">*</span>frame<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>name<span class="hl opt">,</span> <span class="hl kwb">int</span> margin_indent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>margin<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>filename <span class="hl opt">==</span> NULL <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>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">_Py_WriteIndentedMargin</span><span class="hl opt">(</span>margin_indent<span class="hl opt">,</span> margin<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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>

    PyObject <span class="hl opt">*</span>line <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromFormat</span><span class="hl opt">(</span><span class="hl str">&quot;  File</span> <span class="hl esc">\&quot;</span><span class="hl str">%U</span><span class="hl esc">\&quot;</span><span class="hl str">, line %d, in %U</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
                                          filename<span class="hl opt">,</span> lineno<span class="hl opt">,</span> name<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>line <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 kwb">int</span> res <span class="hl opt">=</span> <span class="hl kwd">PyFile_WriteObject</span><span class="hl opt">(</span>line<span class="hl opt">,</span> f<span class="hl opt">,</span> Py_PRINT_RAW<span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>line<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>res <span class="hl opt">&lt;</span> <span class="hl num">0</span><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 kwb">int</span> err <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>

    <span class="hl kwb">int</span> truncation <span class="hl opt">=</span> _TRACEBACK_SOURCE_LINE_INDENT<span class="hl opt">;</span>
    PyObject<span class="hl opt">*</span> source_line <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">int</span> rc <span class="hl opt">=</span> <span class="hl kwd">display_source_line_with_margin</span><span class="hl opt">(</span>
            f<span class="hl opt">,</span> filename<span class="hl opt">,</span> lineno<span class="hl opt">,</span> _TRACEBACK_SOURCE_LINE_INDENT<span class="hl opt">,</span>
            margin_indent<span class="hl opt">,</span> margin<span class="hl opt">, &amp;</span>truncation<span class="hl opt">, &amp;</span>source_line<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>rc <span class="hl opt">!=</span> <span class="hl num">0</span> <span class="hl opt">|| !</span>source_line<span class="hl opt">) {</span>
        <span class="hl com">/* ignore errors since we can't report them, can we? */</span>
        err <span class="hl opt">=</span> <span class="hl kwd">ignore_source_errors</span><span class="hl opt">();</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwb">int</span> code_offset <span class="hl opt">=</span> tb<span class="hl opt">-&gt;</span>tb_lasti<span class="hl opt">;</span>
    PyCodeObject<span class="hl opt">*</span> code <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>f_frame<span class="hl opt">-&gt;</span>f_code<span class="hl opt">;</span>
    <span class="hl kwb">const</span> Py_ssize_t source_line_len <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_GET_LENGTH</span><span class="hl opt">(</span>source_line<span class="hl opt">);</span>

    <span class="hl kwb">int</span> start_line<span class="hl opt">;</span>
    <span class="hl kwb">int</span> end_line<span class="hl opt">;</span>
    <span class="hl kwb">int</span> start_col_byte_offset<span class="hl opt">;</span>
    <span class="hl kwb">int</span> end_col_byte_offset<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyCode_Addr2Location</span><span class="hl opt">(</span>code<span class="hl opt">,</span> code_offset<span class="hl opt">, &amp;</span>start_line<span class="hl opt">, &amp;</span>start_col_byte_offset<span class="hl opt">,</span>
                              <span class="hl opt">&amp;</span>end_line<span class="hl opt">, &amp;</span>end_col_byte_offset<span class="hl opt">)) {</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>start_line <span class="hl opt">&lt;</span> <span class="hl num">0</span> <span class="hl opt">||</span> end_line <span class="hl opt">&lt;</span> <span class="hl num">0</span>
        <span class="hl opt">||</span> start_col_byte_offset <span class="hl opt">&lt;</span> <span class="hl num">0</span>
        <span class="hl opt">||</span> end_col_byte_offset <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">)</span>
    <span class="hl opt">{</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl slc">// When displaying errors, we will use the following generic structure:</span>
    <span class="hl slc">//</span>
    <span class="hl slc">//  ERROR LINE ERROR LINE ERROR LINE ERROR LINE ERROR LINE ERROR LINE ERROR LINE</span>
    <span class="hl slc">//        ~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^~~~~~~~~~~~~~~~~~~~</span>
    <span class="hl slc">//        |              |-&gt; left_end_offset     |                  |-&gt; end_offset</span>
    <span class="hl slc">//        |-&gt; start_offset                       |-&gt; right_start_offset</span>
    <span class="hl slc">//</span>
    <span class="hl slc">// In general we will only have (start_offset, end_offset) but we can gather more information</span>
    <span class="hl slc">// by analyzing the AST of the text between *start_offset* and *end_offset*. If this succeeds</span>
    <span class="hl slc">// we could get *left_end_offset* and *right_start_offset* and some selection of characters for</span>
    <span class="hl slc">// the different ranges (primary_error_char and secondary_error_char). If we cannot obtain the</span>
    <span class="hl slc">// AST information or we cannot identify special ranges within it, then left_end_offset and</span>
    <span class="hl slc">// right_end_offset will be set to -1.</span>
    <span class="hl slc">//</span>
    <span class="hl slc">// To keep the column indicators pertinent, they are not shown when the primary character</span>
    <span class="hl slc">// spans the whole line.</span>

    <span class="hl slc">// Convert the utf-8 byte offset to the actual character offset so we print the right number of carets.</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>source_line<span class="hl opt">);</span>
    Py_ssize_t start_offset <span class="hl opt">=</span> <span class="hl kwd">_PyPegen_byte_offset_to_character_offset</span><span class="hl opt">(</span>source_line<span class="hl opt">,</span> start_col_byte_offset<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>start_offset <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        err <span class="hl opt">=</span> <span class="hl kwd">ignore_source_errors</span><span class="hl opt">() &lt;</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    Py_ssize_t end_offset <span class="hl opt">=</span> <span class="hl kwd">_PyPegen_byte_offset_to_character_offset</span><span class="hl opt">(</span>source_line<span class="hl opt">,</span> end_col_byte_offset<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>end_offset <span class="hl opt">&lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        err <span class="hl opt">=</span> <span class="hl kwd">ignore_source_errors</span><span class="hl opt">() &lt;</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

    Py_ssize_t left_end_offset <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
    Py_ssize_t right_start_offset <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>primary_error_char <span class="hl opt">=</span> <span class="hl str">&quot;^&quot;</span><span class="hl opt">;</span>
    <span class="hl kwb">char</span> <span class="hl opt">*</span>secondary_error_char <span class="hl opt">=</span> primary_error_char<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>start_line <span class="hl opt">==</span> end_line<span class="hl opt">) {</span>
        <span class="hl kwb">int</span> res <span class="hl opt">=</span> <span class="hl kwd">extract_anchors_from_line</span><span class="hl opt">(</span>filename<span class="hl opt">,</span> source_line<span class="hl opt">,</span> start_offset<span class="hl opt">,</span> end_offset<span class="hl opt">,</span>
                                            <span class="hl opt">&amp;</span>left_end_offset<span class="hl opt">, &amp;</span>right_start_offset<span class="hl opt">,</span>
                                            <span class="hl opt">&amp;</span>primary_error_char<span class="hl opt">, &amp;</span>secondary_error_char<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>res <span class="hl opt">&lt;</span> <span class="hl num">0</span> <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">ignore_source_errors</span><span class="hl opt">() &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            <span class="hl kwa">goto</span> done<span class="hl opt">;</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 slc">// If this is a multi-line expression, then we will highlight until</span>
        <span class="hl slc">// the last non-whitespace character.</span>
        <span class="hl kwb">const char</span> <span class="hl opt">*</span>source_line_str <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_AsUTF8</span><span class="hl opt">(</span>source_line<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(!</span>source_line_str<span class="hl opt">) {</span>
            <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
        <span class="hl opt">}</span>

        Py_ssize_t i <span class="hl opt">=</span> source_line_len<span class="hl opt">;</span>
        <span class="hl kwa">while</span> <span class="hl opt">(--</span>i <span class="hl opt">&gt;=</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">IS_WHITESPACE</span><span class="hl opt">(</span>source_line_str<span class="hl opt">[</span>i<span class="hl opt">])) {</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
        <span class="hl opt">}</span>

        end_offset <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 opt">}</span>

    <span class="hl slc">// Elide indicators if primary char spans the frame line</span>
    Py_ssize_t stripped_line_len <span class="hl opt">=</span> source_line_len <span class="hl opt">-</span> truncation <span class="hl opt">-</span> _TRACEBACK_SOURCE_LINE_INDENT<span class="hl opt">;</span>
    <span class="hl kwb">bool</span> has_secondary_ranges <span class="hl opt">= (</span>left_end_offset <span class="hl opt">!= -</span><span class="hl num">1</span> <span class="hl opt">||</span> right_start_offset <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>end_offset <span class="hl opt">-</span> start_offset <span class="hl opt">==</span> stripped_line_len <span class="hl opt">&amp;&amp; !</span>has_secondary_ranges<span class="hl opt">) {</span>
        <span class="hl kwa">goto</span> done<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">_Py_WriteIndentedMargin</span><span class="hl opt">(</span>margin_indent<span class="hl opt">,</span> margin<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        err <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl kwa">goto</span> done<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">print_error_location_carets</span><span class="hl opt">(</span>f<span class="hl opt">,</span> truncation<span class="hl opt">,</span> start_offset<span class="hl opt">,</span> end_offset<span class="hl opt">,</span>
                                    right_start_offset<span class="hl opt">,</span> left_end_offset<span class="hl opt">,</span>
                                    primary_error_char<span class="hl opt">,</span> secondary_error_char<span class="hl opt">) &lt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        err <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>source_line<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 kwb">static const int</span> TB_RECURSIVE_CUTOFF <span class="hl opt">=</span> <span class="hl num">3</span><span class="hl opt">;</span> <span class="hl slc">// Also hardcoded in traceback.py.</span>

<span class="hl kwb">static int</span>
<span class="hl kwd">tb_print_line_repeated</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>f<span class="hl opt">,</span> <span class="hl kwb">long</span> cnt<span class="hl opt">)</span>
<span class="hl opt">{</span>
    cnt <span class="hl opt">-=</span> TB_RECURSIVE_CUTOFF<span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>line <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_FromFormat</span><span class="hl opt">(</span>
        <span class="hl opt">(</span>cnt <span class="hl opt">&gt;</span> <span class="hl num">1</span><span class="hl opt">)</span>
          ? <span class="hl str">&quot;  [Previous line repeated %ld more times]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span>
          <span class="hl opt">:</span> <span class="hl str">&quot;  [Previous line repeated %ld more time]</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span>
        cnt<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>line <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 kwb">int</span> err <span class="hl opt">=</span> <span class="hl kwd">PyFile_WriteObject</span><span class="hl opt">(</span>line<span class="hl opt">,</span> f<span class="hl opt">,</span> Py_PRINT_RAW<span class="hl opt">);</span>
    <span class="hl kwd">Py_DECREF</span><span class="hl opt">(</span>line<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 kwb">static int</span>
<span class="hl kwd">tb_printinternal</span><span class="hl opt">(</span>PyTracebackObject <span class="hl opt">*</span>tb<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>f<span class="hl opt">,</span> <span class="hl kwb">long</span> limit<span class="hl opt">,</span>
                 <span class="hl kwb">int</span> indent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>margin<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyCodeObject <span class="hl opt">*</span>code <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    Py_ssize_t depth <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>last_file <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">int</span> last_line <span class="hl opt">= -</span><span class="hl num">1</span><span class="hl opt">;</span>
    PyObject <span class="hl opt">*</span>last_name <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">long</span> cnt <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    PyTracebackObject <span class="hl opt">*</span>tb1 <span class="hl opt">=</span> tb<span class="hl opt">;</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>tb1 <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        depth<span class="hl opt">++;</span>
        tb1 <span class="hl opt">=</span> tb1<span class="hl opt">-&gt;</span>tb_next<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>tb <span class="hl opt">!=</span> NULL <span class="hl opt">&amp;&amp;</span> depth <span class="hl opt">&gt;</span> limit<span class="hl opt">) {</span>
        depth<span class="hl opt">--;</span>
        tb <span class="hl opt">=</span> tb<span class="hl opt">-&gt;</span>tb_next<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">while</span> <span class="hl opt">(</span>tb <span class="hl opt">!=</span> NULL<span class="hl opt">) {</span>
        code <span class="hl opt">=</span> <span class="hl kwd">PyFrame_GetCode</span><span class="hl opt">(</span>tb<span class="hl opt">-&gt;</span>tb_frame<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>last_file <span class="hl opt">==</span> NULL <span class="hl opt">||</span>
            code<span class="hl opt">-&gt;</span>co_filename <span class="hl opt">!=</span> last_file <span class="hl opt">||</span>
            last_line <span class="hl opt">== -</span><span class="hl num">1</span> <span class="hl opt">||</span> tb<span class="hl opt">-&gt;</span>tb_lineno <span class="hl opt">!=</span> last_line <span class="hl opt">||</span>
            last_name <span class="hl opt">==</span> NULL <span class="hl opt">||</span> code<span class="hl opt">-&gt;</span>co_name <span class="hl opt">!=</span> last_name<span class="hl opt">) {</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>cnt <span class="hl opt">&gt;</span> TB_RECURSIVE_CUTOFF<span class="hl opt">) {</span>
                <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">tb_print_line_repeated</span><span class="hl opt">(</span>f<span class="hl opt">,</span> cnt<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 opt">}</span>
            last_file <span class="hl opt">=</span> code<span class="hl opt">-&gt;</span>co_filename<span class="hl opt">;</span>
            last_line <span class="hl opt">=</span> tb<span class="hl opt">-&gt;</span>tb_lineno<span class="hl opt">;</span>
            last_name <span class="hl opt">=</span> code<span class="hl opt">-&gt;</span>co_name<span class="hl opt">;</span>
            cnt <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        cnt<span class="hl opt">++;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>cnt <span class="hl opt">&lt;=</span> TB_RECURSIVE_CUTOFF<span class="hl opt">) {</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">tb_displayline</span><span class="hl opt">(</span>tb<span class="hl opt">,</span> f<span class="hl opt">,</span> code<span class="hl opt">-&gt;</span>co_filename<span class="hl opt">,</span> tb<span class="hl opt">-&gt;</span>tb_lineno<span class="hl opt">,</span>
                               tb<span class="hl opt">-&gt;</span>tb_frame<span class="hl opt">,</span> code<span class="hl opt">-&gt;</span>co_name<span class="hl opt">,</span> indent<span class="hl opt">,</span> margin<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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">if</span> <span class="hl opt">(</span><span class="hl kwd">PyErr_CheckSignals</span><span class="hl opt">() &lt;</span> <span class="hl num">0</span><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 opt">}</span>
        <span class="hl kwd">Py_CLEAR</span><span class="hl opt">(</span>code<span class="hl opt">);</span>
        tb <span class="hl opt">=</span> tb<span class="hl opt">-&gt;</span>tb_next<span class="hl opt">;</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>cnt <span class="hl opt">&gt;</span> TB_RECURSIVE_CUTOFF<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">tb_print_line_repeated</span><span class="hl opt">(</span>f<span class="hl opt">,</span> cnt<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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 opt">}</span>
    <span class="hl kwa">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
error<span class="hl opt">:</span>
    <span class="hl kwd">Py_XDECREF</span><span class="hl opt">(</span>code<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 ppc">#define PyTraceBack_LIMIT 1000</span>

<span class="hl kwb">int</span>
<span class="hl kwd">_PyTraceBack_Print_Indented</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>v<span class="hl opt">,</span> <span class="hl kwb">int</span> indent<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>margin<span class="hl opt">,</span>
                            <span class="hl kwb">const char</span> <span class="hl opt">*</span>header_margin<span class="hl opt">,</span> <span class="hl kwb">const char</span> <span class="hl opt">*</span>header<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>f<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyObject <span class="hl opt">*</span>limitv<span class="hl opt">;</span>
    <span class="hl kwb">long</span> limit <span class="hl opt">=</span> PyTraceBack_LIMIT<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> <span class="hl num">0</span><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">PyTraceBack_Check</span><span class="hl opt">(</span>v<span class="hl opt">)) {</span>
        <span class="hl kwd">PyErr_BadInternalCall</span><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>
    limitv <span class="hl opt">=</span> <span class="hl kwd">PySys_GetObject</span><span class="hl opt">(</span><span class="hl str">&quot;tracebacklimit&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>limitv <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">PyLong_Check</span><span class="hl opt">(</span>limitv<span class="hl opt">)) {</span>
        <span class="hl kwb">int</span> overflow<span class="hl opt">;</span>
        limit <span class="hl opt">=</span> <span class="hl kwd">PyLong_AsLongAndOverflow</span><span class="hl opt">(</span>limitv<span class="hl opt">, &amp;</span>overflow<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>overflow <span class="hl opt">&gt;</span> <span class="hl num">0</span><span class="hl opt">) {</span>
            limit <span class="hl opt">=</span> LONG_MAX<span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">else if</span> <span class="hl opt">(</span>limit <span class="hl opt">&lt;=</span> <span class="hl num">0</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 opt">}</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl kwd">_Py_WriteIndentedMargin</span><span class="hl opt">(</span>indent<span class="hl opt">,</span> header_margin<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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><span class="hl kwd">PyFile_WriteString</span><span class="hl opt">(</span>header<span class="hl opt">,</span> f<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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><span class="hl kwd">tb_printinternal</span><span class="hl opt">((</span>PyTracebackObject <span class="hl opt">*)</span>v<span class="hl opt">,</span> f<span class="hl opt">,</span> limit<span class="hl opt">,</span> indent<span class="hl opt">,</span> margin<span class="hl opt">) &lt;</span> <span class="hl num">0</span><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">return</span> <span class="hl num">0</span><span class="hl opt">;</span>
<span class="hl opt">}</span>

<span class="hl kwb">int</span>
<span class="hl kwd">PyTraceBack_Print</span><span class="hl opt">(</span>PyObject <span class="hl opt">*</span>v<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 kwb">int</span> indent <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>margin <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>header_margin <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    <span class="hl kwb">const char</span> <span class="hl opt">*</span>header <span class="hl opt">=</span> EXCEPTION_TB_HEADER<span class="hl opt">;</span>

    <span class="hl kwa">return</span> <span class="hl kwd">_PyTraceBack_Print_Indented</span><span class="hl opt">(</span>v<span class="hl opt">,</span> indent<span class="hl opt">,</span> margin<span class="hl opt">,</span> header_margin<span class="hl opt">,</span> header<span class="hl opt">,</span> f<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/* Format an integer in range [0; 0xffffffff] to decimal and write it</span>
<span class="hl com">   into the file fd.</span>
<span class="hl com"></span>
<span class="hl com">   This function is signal safe. */</span>

<span class="hl kwb">void</span>
<span class="hl kwd">_Py_DumpDecimal</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> <span class="hl kwb">size_t</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl com">/* maximum number of characters required for output of %lld or %p.</span>
<span class="hl com">       We need at most ceil(log10(256)*SIZEOF_LONG_LONG) digits,</span>
<span class="hl com">       plus 1 for the null byte.  53/22 is an upper bound for log10(256). */</span>
    <span class="hl kwb">char</span> buffer<span class="hl opt">[</span><span class="hl num">1</span> <span class="hl opt">+ (</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">size_t</span><span class="hl opt">)*</span><span class="hl num">53</span><span class="hl opt">-</span><span class="hl num">1</span><span class="hl opt">) /</span> <span class="hl num">22</span> <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>ptr<span class="hl opt">, *</span>end<span class="hl opt">;</span>

    end <span class="hl opt">= &amp;</span>buffer<span class="hl opt">[</span><span class="hl kwd">Py_ARRAY_LENGTH</span><span class="hl opt">(</span>buffer<span class="hl opt">) -</span> <span class="hl num">1</span><span class="hl opt">];</span>
    ptr <span class="hl opt">=</span> end<span class="hl opt">;</span>
    <span class="hl opt">*</span>ptr <span class="hl opt">=</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
    <span class="hl kwa">do</span> <span class="hl opt">{</span>
        <span class="hl opt">--</span>ptr<span class="hl opt">;</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>ptr <span class="hl opt">&gt;=</span> buffer<span class="hl opt">);</span>
        <span class="hl opt">*</span>ptr <span class="hl opt">=</span> <span class="hl str">'0'</span> <span class="hl opt">+ (</span>value <span class="hl opt">%</span> <span class="hl num">10</span><span class="hl opt">);</span>
        value <span class="hl opt">/=</span> <span class="hl num">10</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span>value<span class="hl opt">);</span>

    <span class="hl kwd">_Py_write_noraise</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> ptr<span class="hl opt">,</span> end <span class="hl opt">-</span> ptr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/* Format an integer as hexadecimal with width digits into fd file descriptor.</span>
<span class="hl com">   The function is signal safe. */</span>
<span class="hl kwb">void</span>
<span class="hl kwd">_Py_DumpHexadecimal</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> <span class="hl kwb">uintptr_t</span> value<span class="hl opt">,</span> Py_ssize_t width<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwb">char</span> buffer<span class="hl opt">[</span><span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">uintptr_t</span><span class="hl opt">) *</span> <span class="hl num">2</span> <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">], *</span>ptr<span class="hl opt">, *</span>end<span class="hl opt">;</span>
    <span class="hl kwb">const</span> Py_ssize_t size <span class="hl opt">=</span> <span class="hl kwd">Py_ARRAY_LENGTH</span><span class="hl opt">(</span>buffer<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>width <span class="hl opt">&gt;</span> size<span class="hl opt">)</span>
        width <span class="hl opt">=</span> size<span class="hl opt">;</span>
    <span class="hl com">/* it's ok if width is negative */</span>

    end <span class="hl opt">= &amp;</span>buffer<span class="hl opt">[</span>size<span class="hl opt">];</span>
    ptr <span class="hl opt">=</span> end<span class="hl opt">;</span>
    <span class="hl opt">*</span>ptr <span class="hl opt">=</span> <span class="hl str">'\0'</span><span class="hl opt">;</span>
    <span class="hl kwa">do</span> <span class="hl opt">{</span>
        <span class="hl opt">--</span>ptr<span class="hl opt">;</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>ptr <span class="hl opt">&gt;=</span> buffer<span class="hl opt">);</span>
        <span class="hl opt">*</span>ptr <span class="hl opt">=</span> Py_hexdigits<span class="hl opt">[</span>value <span class="hl opt">&amp;</span> <span class="hl num">15</span><span class="hl opt">];</span>
        value <span class="hl opt">&gt;&gt;=</span> <span class="hl num">4</span><span class="hl opt">;</span>
    <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">((</span>end <span class="hl opt">-</span> ptr<span class="hl opt">) &lt;</span> width <span class="hl opt">||</span> value<span class="hl opt">);</span>

    <span class="hl kwd">_Py_write_noraise</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> ptr<span class="hl opt">,</span> end <span class="hl opt">-</span> ptr<span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl kwb">void</span>
<span class="hl kwd">_Py_DumpASCII</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> PyObject <span class="hl opt">*</span>text<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyASCIIObject <span class="hl opt">*</span>ascii <span class="hl opt">=</span> <span class="hl kwd">_PyASCIIObject_CAST</span><span class="hl opt">(</span>text<span class="hl opt">);</span>
    Py_ssize_t i<span class="hl opt">,</span> size<span class="hl opt">;</span>
    <span class="hl kwb">int</span> truncated<span class="hl opt">;</span>
    <span class="hl kwb">int</span> kind<span class="hl opt">;</span>
    <span class="hl kwb">void</span> <span class="hl opt">*</span>data <span class="hl opt">=</span> NULL<span class="hl opt">;</span>
    Py_UCS4 ch<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(!</span><span class="hl kwd">PyUnicode_Check</span><span class="hl opt">(</span>text<span class="hl opt">))</span>
        <span class="hl kwa">return</span><span class="hl opt">;</span>

    size <span class="hl opt">=</span> ascii<span class="hl opt">-&gt;</span>length<span class="hl opt">;</span>
    kind <span class="hl opt">=</span> ascii<span class="hl opt">-&gt;</span>state<span class="hl opt">.</span>kind<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>ascii<span class="hl opt">-&gt;</span>state<span class="hl opt">.</span>compact<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>ascii<span class="hl opt">-&gt;</span>state<span class="hl opt">.</span>ascii<span class="hl opt">)</span>
            data <span class="hl opt">=</span> ascii <span class="hl opt">+</span> <span class="hl num">1</span><span class="hl opt">;</span>
        <span class="hl kwa">else</span>
            data <span class="hl opt">=</span> <span class="hl kwd">_PyCompactUnicodeObject_CAST</span><span class="hl opt">(</span>text<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">else</span> <span class="hl opt">{</span>
        data <span class="hl opt">=</span> <span class="hl kwd">_PyUnicodeObject_CAST</span><span class="hl opt">(</span>text<span class="hl opt">)-&gt;</span>data<span class="hl opt">.</span>any<span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>data <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>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>MAX_STRING_LENGTH <span class="hl opt">&lt;</span> size<span class="hl opt">) {</span>
        size <span class="hl opt">=</span> MAX_STRING_LENGTH<span class="hl opt">;</span>
        truncated <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">else</span> <span class="hl opt">{</span>
        truncated <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    <span class="hl slc">// Is an ASCII string?</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>ascii<span class="hl opt">-&gt;</span>state<span class="hl opt">.</span>ascii<span class="hl opt">) {</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>kind <span class="hl opt">==</span> PyUnicode_1BYTE_KIND<span class="hl opt">);</span>
        <span class="hl kwb">char</span> <span class="hl opt">*</span>str <span class="hl opt">=</span> data<span class="hl opt">;</span>

        <span class="hl kwb">int</span> need_escape <span class="hl opt">=</span> <span class="hl num">0</span><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> size<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
            ch <span class="hl opt">=</span> str<span class="hl opt">[</span>i<span class="hl opt">];</span>
            <span class="hl kwa">if</span> <span class="hl opt">(!(</span><span class="hl str">' '</span> <span class="hl opt">&lt;=</span> ch <span class="hl opt">&amp;&amp;</span> ch <span class="hl opt">&lt;=</span> <span class="hl num">126</span><span class="hl opt">)) {</span>
                need_escape <span class="hl opt">=</span> <span class="hl num">1</span><span class="hl opt">;</span>
                <span class="hl kwa">break</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">if</span> <span class="hl opt">(!</span>need_escape<span class="hl opt">) {</span>
            <span class="hl slc">// The string can be written with a single write() syscall</span>
            <span class="hl kwd">_Py_write_noraise</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> str<span class="hl opt">,</span> size<span class="hl opt">);</span>
            <span class="hl kwa">goto</span> done<span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <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> size<span class="hl opt">;</span> i<span class="hl opt">++) {</span>
        ch <span class="hl opt">=</span> <span class="hl kwd">PyUnicode_READ</span><span class="hl opt">(</span>kind<span class="hl opt">,</span> data<span class="hl opt">,</span> i<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span><span class="hl str">' '</span> <span class="hl opt">&lt;=</span> ch <span class="hl opt">&amp;&amp;</span> ch <span class="hl opt">&lt;=</span> <span class="hl num">126</span><span class="hl opt">) {</span>
            <span class="hl com">/* printable ASCII character */</span>
            <span class="hl kwb">char</span> c <span class="hl opt">= (</span><span class="hl kwb">char</span><span class="hl opt">)</span>ch<span class="hl opt">;</span>
            <span class="hl kwd">_Py_write_noraise</span><span class="hl opt">(</span>fd<span class="hl opt">, &amp;</span>c<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">else if</span> <span class="hl opt">(</span>ch <span class="hl opt">&lt;=</span> <span class="hl num">0xff</span><span class="hl opt">) {</span>
            <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\\</span><span class="hl str">x&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">_Py_DumpHexadecimal</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> ch<span class="hl opt">,</span> <span class="hl num">2</span><span class="hl opt">);</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">else if</span> <span class="hl opt">(</span>ch <span class="hl opt">&lt;=</span> <span class="hl num">0xffff</span><span class="hl opt">) {</span>
            <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\\</span><span class="hl str">u&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">_Py_DumpHexadecimal</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> ch<span class="hl opt">,</span> <span class="hl num">4</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">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\\</span><span class="hl str">U&quot;</span><span class="hl opt">);</span>
            <span class="hl kwd">_Py_DumpHexadecimal</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> ch<span class="hl opt">,</span> <span class="hl num">8</span><span class="hl opt">);</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>

done<span class="hl opt">:</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>truncated<span class="hl opt">) {</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;...&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/* Write a frame into the file fd: &quot;File &quot;xxx&quot;, line xxx in xxx&quot;.</span>
<span class="hl com"></span>
<span class="hl com">   This function is signal safe. */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">dump_frame</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> _PyInterpreterFrame <span class="hl opt">*</span>frame<span class="hl opt">)</span>
<span class="hl opt">{</span>
    PyCodeObject <span class="hl opt">*</span>code <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>f_code<span class="hl opt">;</span>
    <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;  File &quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>code<span class="hl opt">-&gt;</span>co_filename <span class="hl opt">!=</span> NULL
        <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">PyUnicode_Check</span><span class="hl opt">(</span>code<span class="hl opt">-&gt;</span>co_filename<span class="hl opt">))</span>
    <span class="hl opt">{</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\&quot;</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
        <span class="hl kwd">_Py_DumpASCII</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> code<span class="hl opt">-&gt;</span>co_filename<span class="hl opt">);</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;</span><span class="hl esc">\&quot;</span><span class="hl str">&quot;</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">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;???&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwb">int</span> lineno <span class="hl opt">=</span> <span class="hl kwd">_PyInterpreterFrame_GetLine</span><span class="hl opt">(</span>frame<span class="hl opt">);</span>
    <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;, line &quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>lineno <span class="hl opt">&gt;=</span> <span class="hl num">0</span><span class="hl opt">) {</span>
        <span class="hl kwd">_Py_DumpDecimal</span><span class="hl opt">(</span>fd<span class="hl opt">, (</span><span class="hl kwb">size_t</span><span class="hl opt">)</span>lineno<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">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;???&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>
    <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot; in &quot;</span><span class="hl opt">);</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>code<span class="hl opt">-&gt;</span>co_name <span class="hl opt">!=</span> NULL
       <span class="hl opt">&amp;&amp;</span> <span class="hl kwd">PyUnicode_Check</span><span class="hl opt">(</span>code<span class="hl opt">-&gt;</span>co_name<span class="hl opt">)) {</span>
        <span class="hl kwd">_Py_DumpASCII</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> code<span class="hl opt">-&gt;</span>co_name<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">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;???&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<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>
<span class="hl opt">}</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">dump_traceback</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> PyThreadState <span class="hl opt">*</span>tstate<span class="hl opt">,</span> <span class="hl kwb">int</span> write_header<span class="hl opt">)</span>
<span class="hl opt">{</span>
    _PyInterpreterFrame <span class="hl opt">*</span>frame<span class="hl opt">;</span>
    <span class="hl kwb">unsigned int</span> depth<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>write_header<span class="hl opt">) {</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;Stack (most recent call first):</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
    <span class="hl opt">}</span>

    frame <span class="hl opt">=</span> tstate<span class="hl opt">-&gt;</span>cframe<span class="hl opt">-&gt;</span>current_frame<span class="hl opt">;</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>frame <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;  &lt;no Python frame&gt;</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
        <span class="hl kwa">return</span><span class="hl opt">;</span>
    <span class="hl opt">}</span>

    depth <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    <span class="hl kwa">while</span> <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>MAX_FRAME_DEPTH <span class="hl opt">&lt;=</span> depth<span class="hl opt">) {</span>
            <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<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>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwd">dump_frame</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> frame<span class="hl opt">);</span>
        frame <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>previous<span class="hl opt">;</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>frame <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 kwa">if</span> <span class="hl opt">(</span>frame<span class="hl opt">-&gt;</span>owner <span class="hl opt">==</span> FRAME_OWNED_BY_CSTACK<span class="hl opt">) {</span>
            <span class="hl com">/* Trampoline frame */</span>
            frame <span class="hl opt">=</span> frame<span class="hl opt">-&gt;</span>previous<span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>frame <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 com">/* Can't have more than one shim frame in a row */</span>
        <span class="hl kwa">assert</span><span class="hl opt">(</span>frame<span class="hl opt">-&gt;</span>owner <span class="hl opt">!=</span> FRAME_OWNED_BY_CSTACK<span class="hl opt">);</span>
        depth<span class="hl opt">++;</span>
    <span class="hl opt">}</span>
<span class="hl opt">}</span>

<span class="hl com">/* Dump the traceback of a Python thread into fd. Use write() to write the</span>
<span class="hl com">   traceback and retry if write() is interrupted by a signal (failed with</span>
<span class="hl com">   EINTR), but don't call the Python signal handler.</span>
<span class="hl com"></span>
<span class="hl com">   The caller is responsible to call PyErr_CheckSignals() to call Python signal</span>
<span class="hl com">   handlers if signals were received. */</span>
<span class="hl kwb">void</span>
<span class="hl kwd">_Py_DumpTraceback</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> PyThreadState <span class="hl opt">*</span>tstate<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwd">dump_traceback</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> tstate<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">/* Write the thread identifier into the file 'fd': &quot;Current thread 0xHHHH:\&quot; if</span>
<span class="hl com">   is_current is true, &quot;Thread 0xHHHH:\n&quot; otherwise.</span>
<span class="hl com"></span>
<span class="hl com">   This function is signal safe. */</span>

<span class="hl kwb">static void</span>
<span class="hl kwd">write_thread_id</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> PyThreadState <span class="hl opt">*</span>tstate<span class="hl opt">,</span> <span class="hl kwb">int</span> is_current<span class="hl opt">)</span>
<span class="hl opt">{</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>is_current<span class="hl opt">)</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;Current thread 0x&quot;</span><span class="hl opt">);</span>
    <span class="hl kwa">else</span>
        <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;Thread 0x&quot;</span><span class="hl opt">);</span>
    <span class="hl kwd">_Py_DumpHexadecimal</span><span class="hl opt">(</span>fd<span class="hl opt">,</span>
                        tstate<span class="hl opt">-&gt;</span>thread_id<span class="hl opt">,</span>
                        <span class="hl kwa">sizeof</span><span class="hl opt">(</span><span class="hl kwb">unsigned long</span><span class="hl opt">) *</span> <span class="hl num">2</span><span class="hl opt">);</span>
    <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot; (most recent call first):</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
<span class="hl opt">}</span>

<span class="hl com">/* Dump the traceback of all Python threads into fd. Use write() to write the</span>
<span class="hl com">   traceback and retry if write() is interrupted by a signal (failed with</span>
<span class="hl com">   EINTR), but don't call the Python signal handler.</span>
<span class="hl com"></span>
<span class="hl com">   The caller is responsible to call PyErr_CheckSignals() to call Python signal</span>
<span class="hl com">   handlers if signals were received. */</span>
<span class="hl kwb">const char</span><span class="hl opt">*</span>
<span class="hl kwd">_Py_DumpTracebackThreads</span><span class="hl opt">(</span><span class="hl kwb">int</span> fd<span class="hl opt">,</span> PyInterpreterState <span class="hl opt">*</span>interp<span class="hl opt">,</span>
                         PyThreadState <span class="hl opt">*</span>current_tstate<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 kwb">unsigned int</span> nthreads<span class="hl opt">;</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>current_tstate <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl com">/* _Py_DumpTracebackThreads() is called from signal handlers by</span>
<span class="hl com">           faulthandler.</span>
<span class="hl com"></span>
<span class="hl com">           SIGSEGV, SIGFPE, SIGABRT, SIGBUS and SIGILL are synchronous signals</span>
<span class="hl com">           and are thus delivered to the thread that caused the fault. Get the</span>
<span class="hl com">           Python thread state of the current thread.</span>
<span class="hl com"></span>
<span class="hl com">           PyThreadState_Get() doesn't give the state of the thread that caused</span>
<span class="hl com">           the fault if the thread released the GIL, and so</span>
<span class="hl com">           _PyThreadState_GET() cannot be used. Read the thread specific</span>
<span class="hl com">           storage (TSS) instead: call PyGILState_GetThisThreadState(). */</span>
        current_tstate <span class="hl opt">=</span> <span class="hl kwd">PyGILState_GetThisThreadState</span><span class="hl opt">();</span>
    <span class="hl opt">}</span>

    <span class="hl kwa">if</span> <span class="hl opt">(</span>interp <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>current_tstate <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
            interp <span class="hl opt">=</span> <span class="hl kwd">_PyGILState_GetInterpreterStateUnsafe</span><span class="hl opt">();</span>
            <span class="hl kwa">if</span> <span class="hl opt">(</span>interp <span class="hl opt">==</span> NULL<span class="hl opt">) {</span>
                <span class="hl com">/* We need the interpreter state to get Python threads */</span>
                <span class="hl kwa">return</span> <span class="hl str">&quot;unable to get the interpreter state&quot;</span><span class="hl opt">;</span>
            <span class="hl opt">}</span>
        <span class="hl opt">}</span>
        <span class="hl kwa">else</span> <span class="hl opt">{</span>
            interp <span class="hl opt">=</span> current_tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">;</span>
        <span class="hl opt">}</span>
    <span class="hl opt">}</span>
    <span class="hl kwa">assert</span><span class="hl opt">(</span>interp <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>

    <span class="hl com">/* Get the current interpreter from the current thread */</span>
    tstate <span class="hl opt">=</span> <span class="hl kwd">PyInterpreterState_ThreadHead</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    <span class="hl kwa">if</span> <span class="hl opt">(</span>tstate <span class="hl opt">==</span> NULL<span class="hl opt">)</span>
        <span class="hl kwa">return</span> <span class="hl str">&quot;unable to get the thread head state&quot;</span><span class="hl opt">;</span>

    <span class="hl com">/* Dump the traceback of each thread */</span>
    tstate <span class="hl opt">=</span> <span class="hl kwd">PyInterpreterState_ThreadHead</span><span class="hl opt">(</span>interp<span class="hl opt">);</span>
    nthreads <span class="hl opt">=</span> <span class="hl num">0</span><span class="hl opt">;</span>
    _Py_BEGIN_SUPPRESS_IPH
    <span class="hl kwa">do</span>
    <span class="hl opt">{</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>nthreads <span class="hl opt">!=</span> <span class="hl num">0</span><span class="hl opt">)</span>
            <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<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>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>nthreads <span class="hl opt">&gt;=</span> MAX_NTHREADS<span class="hl opt">) {</span>
            <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<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>
            <span class="hl kwa">break</span><span class="hl opt">;</span>
        <span class="hl opt">}</span>
        <span class="hl kwd">write_thread_id</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> tstate<span class="hl opt">,</span> tstate <span class="hl opt">==</span> current_tstate<span class="hl opt">);</span>
        <span class="hl kwa">if</span> <span class="hl opt">(</span>tstate <span class="hl opt">==</span> current_tstate <span class="hl opt">&amp;&amp;</span> tstate<span class="hl opt">-&gt;</span>interp<span class="hl opt">-&gt;</span>gc<span class="hl opt">.</span>collecting<span class="hl opt">) {</span>
            <span class="hl kwd">PUTS</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> <span class="hl str">&quot;  Garbage-collecting</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">);</span>
        <span class="hl opt">}</span>
        <span class="hl kwd">dump_traceback</span><span class="hl opt">(</span>fd<span class="hl opt">,</span> tstate<span class="hl opt">,</span> <span class="hl num">0</span><span class="hl opt">);</span>
        tstate <span class="hl opt">=</span> <span class="hl kwd">PyThreadState_Next</span><span class="hl opt">(</span>tstate<span class="hl opt">);</span>
        nthreads<span class="hl opt">++;</span>
    <span class="hl opt">}</span> <span class="hl kwa">while</span> <span class="hl opt">(</span>tstate <span class="hl opt">!=</span> NULL<span class="hl opt">);</span>
    _Py_END_SUPPRESS_IPH

    <span class="hl kwa">return</span> NULL<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-07-25 22:00:43 (GMT)</div>
</div> <!-- id=cgit -->
</body>
</html>