Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Objects/frameobject.c

    r2 r388  
    1616
    1717static PyMemberDef frame_memberlist[] = {
    18         {"f_back",      T_OBJECT,       OFF(f_back),    RO},
    19         {"f_code",      T_OBJECT,       OFF(f_code),    RO},
    20         {"f_builtins",  T_OBJECT,       OFF(f_builtins),RO},
    21         {"f_globals",   T_OBJECT,       OFF(f_globals), RO},
    22         {"f_lasti",     T_INT,          OFF(f_lasti),   RO},
    23         {"f_exc_type",  T_OBJECT,       OFF(f_exc_type)},
    24         {"f_exc_value", T_OBJECT,       OFF(f_exc_value)},
    25         {"f_exc_traceback", T_OBJECT,   OFF(f_exc_traceback)},
    26         {NULL}  /* Sentinel */
     18    {"f_back",          T_OBJECT,       OFF(f_back),    RO},
     19    {"f_code",          T_OBJECT,       OFF(f_code),    RO},
     20    {"f_builtins",      T_OBJECT,       OFF(f_builtins),RO},
     21    {"f_globals",       T_OBJECT,       OFF(f_globals), RO},
     22    {"f_lasti",         T_INT,          OFF(f_lasti),   RO},
     23    {NULL}      /* Sentinel */
    2724};
     25
     26#define WARN_GET_SET(NAME) \
     27static PyObject * frame_get_ ## NAME(PyFrameObject *f) { \
     28    if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \
     29        return NULL; \
     30    if (f->NAME) { \
     31        Py_INCREF(f->NAME); \
     32        return f->NAME; \
     33    } \
     34    Py_RETURN_NONE;     \
     35} \
     36static int frame_set_ ## NAME(PyFrameObject *f, PyObject *new) { \
     37    if (PyErr_WarnPy3k(#NAME " has been removed in 3.x", 2) < 0) \
     38        return -1; \
     39    if (f->NAME) { \
     40        Py_CLEAR(f->NAME); \
     41    } \
     42    if (new == Py_None) \
     43        new = NULL; \
     44    Py_XINCREF(new); \
     45    f->NAME = new; \
     46    return 0; \
     47}
     48
     49
     50WARN_GET_SET(f_exc_traceback)
     51WARN_GET_SET(f_exc_type)
     52WARN_GET_SET(f_exc_value)
     53
    2854
    2955static PyObject *
    3056frame_getlocals(PyFrameObject *f, void *closure)
    3157{
    32         PyFrame_FastToLocals(f);
    33         Py_INCREF(f->f_locals);
    34         return f->f_locals;
     58    PyFrame_FastToLocals(f);
     59    Py_INCREF(f->f_locals);
     60    return f->f_locals;
     61}
     62
     63int
     64PyFrame_GetLineNumber(PyFrameObject *f)
     65{
     66    if (f->f_trace)
     67        return f->f_lineno;
     68    else
     69        return PyCode_Addr2Line(f->f_code, f->f_lasti);
    3570}
    3671
    … …  
    3873frame_getlineno(PyFrameObject *f, void *closure)
    3974{
    40         int lineno;
    41 
    42         if (f->f_trace)
    43                 lineno = f->f_lineno;
    44         else
    45                 lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
    46 
    47         return PyInt_FromLong(lineno);
     75    return PyInt_FromLong(PyFrame_GetLineNumber(f));
    4876}
    4977
    5078/* Setter for f_lineno - you can set f_lineno from within a trace function in
    51  * order to jump to a given line of code, subject to some restrictions.  Most
     79 * order to jump to a given line of code, subject to some restrictions.  Most
    5280 * lines are OK to jump to because they don't make any assumptions about the
    5381 * state of the stack (obvious because you could remove the line and the code
    … …  
    6694frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno)
    6795{
    68         int new_lineno = 0;             /* The new value of f_lineno */
    69         int new_lasti = 0;              /* The new value of f_lasti */
    70         int new_iblock = 0;             /* The new value of f_iblock */
    71         unsigned char *code = NULL;     /* The bytecode for the frame... */
    72         Py_ssize_t code_len = 0;        /* ...and its length */
    73         unsigned char *lnotab = NULL;   /* Iterating over co_lnotab */
    74         Py_ssize_t lnotab_len = 0;      /* (ditto) */
    75         int offset = 0;                 /* (ditto) */
    76         int line = 0;                   /* (ditto) */
    77         int addr = 0;                   /* (ditto) */
    78         int min_addr = 0;               /* Scanning the SETUPs and POPs */
    79         int max_addr = 0;               /* (ditto) */
    80         int delta_iblock = 0;           /* (ditto) */
    81         int min_delta_iblock = 0;       /* (ditto) */
    82         int min_iblock = 0;             /* (ditto) */
    83         int f_lasti_setup_addr = 0;     /* Policing no-jump-into-finally */
    84         int new_lasti_setup_addr = 0;   /* (ditto) */
    85         int blockstack[CO_MAXBLOCKS];   /* Walking the 'finally' blocks */
    86         int in_finally[CO_MAXBLOCKS];   /* (ditto) */
    87         int blockstack_top = 0;         /* (ditto) */
    88         unsigned char setup_op = 0;     /* (ditto) */
    89         char *tmp;
    90 
    91         /* f_lineno must be an integer. */
    92         if (!PyInt_Check(p_new_lineno)) {
    93                 PyErr_SetString(PyExc_ValueError,
    94                                 "lineno must be an integer");
    95                 return -1;
    96         }
    97 
    98         /* You can only do this from within a trace function, not via
    99          * _getframe or similar hackery. */
    100         if (!f->f_trace)
    101         {
    102                 PyErr_Format(PyExc_ValueError,
    103                              "f_lineno can only be set by a trace function");
    104                 return -1;
    105         }
    106 
    107         /* Fail if the line comes before the start of the code block. */
    108         new_lineno = (int) PyInt_AsLong(p_new_lineno);
    109         if (new_lineno < f->f_code->co_firstlineno) {
    110                 PyErr_Format(PyExc_ValueError,
    111                              "line %d comes before the current code block",
    112                              new_lineno);
    113                 return -1;
    114         }
    115 
    116         /* Find the bytecode offset for the start of the given line, or the
    117          * first code-owning line after it. */
    118         PyString_AsStringAndSize(f->f_code->co_lnotab,
    119                                  &tmp, &lnotab_len);
    120         lnotab = (unsigned char *) tmp;
    121         addr = 0;
    122         line = f->f_code->co_firstlineno;
    123         new_lasti = -1;
    124         for (offset = 0; offset < lnotab_len; offset += 2) {
    125                 addr += lnotab[offset];
    126                 line += lnotab[offset+1];
    127                 if (line >= new_lineno) {
    128                         new_lasti = addr;
    129                         new_lineno = line;
    130                         break;
    131                 }
    132         }
    133 
    134         /* If we didn't reach the requested line, return an error. */
    135         if (new_lasti == -1) {
    136                 PyErr_Format(PyExc_ValueError,
    137                              "line %d comes after the current code block",
    138                              new_lineno);
    139                 return -1;
    140         }
    141 
    142         /* We're now ready to look at the bytecode. */
    143         PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
    144         min_addr = MIN(new_lasti, f->f_lasti);
    145         max_addr = MAX(new_lasti, f->f_lasti);
    146 
    147         /* You can't jump onto a line with an 'except' statement on it -
    148          * they expect to have an exception on the top of the stack, which
    149          * won't be true if you jump to them.  They always start with code
    150          * that either pops the exception using POP_TOP (plain 'except:'
    151          * lines do this) or duplicates the exception on the stack using
    152          * DUP_TOP (if there's an exception type specified).  See compile.c,
    153          * 'com_try_except' for the full details.  There aren't any other
    154          * cases (AFAIK) where a line's code can start with DUP_TOP or
    155          * POP_TOP, but if any ever appear, they'll be subject to the same
    156          * restriction (but with a different error message). */
    157         if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) {
    158                 PyErr_SetString(PyExc_ValueError,
    159                     "can't jump to 'except' line as there's no exception");
    160                 return -1;
    161         }
    162 
    163         /* You can't jump into or out of a 'finally' block because the 'try'
    164          * block leaves something on the stack for the END_FINALLY to clean
    165          * up.  So we walk the bytecode, maintaining a simulated blockstack.
    166          * When we reach the old or new address and it's in a 'finally' block
    167          * we note the address of the corresponding SETUP_FINALLY.  The jump
    168          * is only legal if neither address is in a 'finally' block or
    169          * they're both in the same one.  'blockstack' is a stack of the
    170          * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks
    171          * whether we're in a 'finally' block at each blockstack level. */
    172         f_lasti_setup_addr = -1;
    173         new_lasti_setup_addr = -1;
    174         memset(blockstack, '\0', sizeof(blockstack));
    175         memset(in_finally, '\0', sizeof(in_finally));
    176         blockstack_top = 0;
    177         for (addr = 0; addr < code_len; addr++) {
    178                 unsigned char op = code[addr];
    179                 switch (op) {
    180                 case SETUP_LOOP:
    181                 case SETUP_EXCEPT:
    182                 case SETUP_FINALLY:
    183                         blockstack[blockstack_top++] = addr;
    184                         in_finally[blockstack_top-1] = 0;
    185                         break;
    186 
    187                 case POP_BLOCK:
    188                         assert(blockstack_top > 0);
    189                         setup_op = code[blockstack[blockstack_top-1]];
    190                         if (setup_op == SETUP_FINALLY) {
    191                                 in_finally[blockstack_top-1] = 1;
    192                         }
    193                         else {
    194                                 blockstack_top--;
    195                         }
    196                         break;
    197 
    198                 case END_FINALLY:
    199                         /* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist
    200                          * in the bytecode but don't correspond to an actual
    201                          * 'finally' block.  (If blockstack_top is 0, we must
    202                          * be seeing such an END_FINALLY.) */
    203                         if (blockstack_top > 0) {
    204                                 setup_op = code[blockstack[blockstack_top-1]];
    205                                 if (setup_op == SETUP_FINALLY) {
    206                                         blockstack_top--;
    207                                 }
    208                         }
    209                         break;
    210                 }
    211 
    212                 /* For the addresses we're interested in, see whether they're
    213                  * within a 'finally' block and if so, remember the address
    214                  * of the SETUP_FINALLY. */
    215                 if (addr == new_lasti || addr == f->f_lasti) {
    216                         int i = 0;
    217                         int setup_addr = -1;
    218                         for (i = blockstack_top-1; i >= 0; i--) {
    219                                 if (in_finally[i]) {
    220                                         setup_addr = blockstack[i];
    221                                         break;
    222                                 }
    223                         }
    224 
    225                         if (setup_addr != -1) {
    226                                 if (addr == new_lasti) {
    227                                         new_lasti_setup_addr = setup_addr;
    228                                 }
    229 
    230                                 if (addr == f->f_lasti) {
    231                                         f_lasti_setup_addr = setup_addr;
    232                                 }
    233                         }
    234                 }
    235 
    236                 if (op >= HAVE_ARGUMENT) {
    237                         addr += 2;
    238                 }
    239         }
    240 
    241         /* Verify that the blockstack tracking code didn't get lost. */
    242         assert(blockstack_top == 0);
    243 
    244         /* After all that, are we jumping into / out of a 'finally' block? */
    245         if (new_lasti_setup_addr != f_lasti_setup_addr) {
    246                 PyErr_SetString(PyExc_ValueError,
    247                             "can't jump into or out of a 'finally' block");
    248                 return -1;
    249         }
    250 
    251 
    252         /* Police block-jumping (you can't jump into the middle of a block)
    253          * and ensure that the blockstack finishes up in a sensible state (by
    254          * popping any blocks we're jumping out of).  We look at all the
    255          * blockstack operations between the current position and the new
    256          * one, and keep track of how many blocks we drop out of on the way.
    257          * By also keeping track of the lowest blockstack position we see, we
    258          * can tell whether the jump goes into any blocks without coming out
    259          * again - in that case we raise an exception below. */
    260         delta_iblock = 0;
    261         for (addr = min_addr; addr < max_addr; addr++) {
    262                 unsigned char op = code[addr];
    263                 switch (op) {
    264                 case SETUP_LOOP:
    265                 case SETUP_EXCEPT:
    266                 case SETUP_FINALLY:
    267                         delta_iblock++;
    268                         break;
    269 
    270                 case POP_BLOCK:
    271                         delta_iblock--;
    272                         break;
    273                 }
    274 
    275                 min_delta_iblock = MIN(min_delta_iblock, delta_iblock);
    276 
    277                 if (op >= HAVE_ARGUMENT) {
    278                         addr += 2;
    279                 }
    280         }
    281 
    282         /* Derive the absolute iblock values from the deltas. */
    283         min_iblock = f->f_iblock + min_delta_iblock;
    284         if (new_lasti > f->f_lasti) {
    285                 /* Forwards jump. */
    286                 new_iblock = f->f_iblock + delta_iblock;
    287         }
    288         else {
    289                 /* Backwards jump. */
    290                 new_iblock = f->f_iblock - delta_iblock;
    291         }
    292 
    293         /* Are we jumping into a block? */
    294         if (new_iblock > min_iblock) {
    295                 PyErr_SetString(PyExc_ValueError,
    296                                 "can't jump into the middle of a block");
    297                 return -1;
    298         }
    299 
    300         /* Pop any blocks that we're jumping out of. */
    301         while (f->f_iblock > new_iblock) {
    302                 PyTryBlock *b = &f->f_blockstack[--f->f_iblock];
    303                 while ((f->f_stacktop - f->f_valuestack) > b->b_level) {
    304                         PyObject *v = (*--f->f_stacktop);
    305                         Py_DECREF(v);
    306                 }
    307         }
    308 
    309         /* Finally set the new f_lineno and f_lasti and return OK. */
    310         f->f_lineno = new_lineno;
    311         f->f_lasti = new_lasti;
    312         return 0;
     96    int new_lineno = 0;                 /* The new value of f_lineno */
     97    int new_lasti = 0;                  /* The new value of f_lasti */
     98    int new_iblock = 0;                 /* The new value of f_iblock */
     99    unsigned char *code = NULL;         /* The bytecode for the frame... */
     100    Py_ssize_t code_len = 0;            /* ...and its length */
     101    unsigned char *lnotab = NULL;       /* Iterating over co_lnotab */
     102    Py_ssize_t lnotab_len = 0;          /* (ditto) */
     103    int offset = 0;                     /* (ditto) */
     104    int line = 0;                       /* (ditto) */
     105    int addr = 0;                       /* (ditto) */
     106    int min_addr = 0;                   /* Scanning the SETUPs and POPs */
     107    int max_addr = 0;                   /* (ditto) */
     108    int delta_iblock = 0;               /* (ditto) */
     109    int min_delta_iblock = 0;           /* (ditto) */
     110    int min_iblock = 0;                 /* (ditto) */
     111    int f_lasti_setup_addr = 0;         /* Policing no-jump-into-finally */
     112    int new_lasti_setup_addr = 0;       /* (ditto) */
     113    int blockstack[CO_MAXBLOCKS];       /* Walking the 'finally' blocks */
     114    int in_finally[CO_MAXBLOCKS];       /* (ditto) */
     115    int blockstack_top = 0;             /* (ditto) */
     116    unsigned char setup_op = 0;         /* (ditto) */
     117
     118    /* f_lineno must be an integer. */
     119    if (!PyInt_Check(p_new_lineno)) {
     120        PyErr_SetString(PyExc_ValueError,
     121                        "lineno must be an integer");
     122        return -1;
     123    }
     124
     125    /* You can only do this from within a trace function, not via
     126     * _getframe or similar hackery. */
     127    if (!f->f_trace)
     128    {
     129        PyErr_Format(PyExc_ValueError,
     130                     "f_lineno can only be set by a"
     131                     " line trace function");
     132        return -1;
     133    }
     134
     135    /* Fail if the line comes before the start of the code block. */
     136    new_lineno = (int) PyInt_AsLong(p_new_lineno);
     137    if (new_lineno < f->f_code->co_firstlineno) {
     138        PyErr_Format(PyExc_ValueError,
     139                     "line %d comes before the current code block",
     140                     new_lineno);
     141        return -1;
     142    }
     143    else if (new_lineno == f->f_code->co_firstlineno) {
     144        new_lasti = 0;
     145        new_lineno = f->f_code->co_firstlineno;
     146    }
     147    else {
     148        /* Find the bytecode offset for the start of the given
     149         * line, or the first code-owning line after it. */
     150        char *tmp;
     151        PyString_AsStringAndSize(f->f_code->co_lnotab,
     152                                 &tmp, &lnotab_len);
     153        lnotab = (unsigned char *) tmp;
     154        addr = 0;
     155        line = f->f_code->co_firstlineno;
     156        new_lasti = -1;
     157        for (offset = 0; offset < lnotab_len; offset += 2) {
     158            addr += lnotab[offset];
     159            line += lnotab[offset+1];
     160            if (line >= new_lineno) {
     161                new_lasti = addr;
     162                new_lineno = line;
     163                break;
     164            }
     165        }
     166    }
     167
     168    /* If we didn't reach the requested line, return an error. */
     169    if (new_lasti == -1) {
     170        PyErr_Format(PyExc_ValueError,
     171                     "line %d comes after the current code block",
     172                     new_lineno);
     173        return -1;
     174    }
     175
     176    /* We're now ready to look at the bytecode. */
     177    PyString_AsStringAndSize(f->f_code->co_code, (char **)&code, &code_len);
     178    min_addr = MIN(new_lasti, f->f_lasti);
     179    max_addr = MAX(new_lasti, f->f_lasti);
     180
     181    /* You can't jump onto a line with an 'except' statement on it -
     182     * they expect to have an exception on the top of the stack, which
     183     * won't be true if you jump to them.  They always start with code
     184     * that either pops the exception using POP_TOP (plain 'except:'
     185     * lines do this) or duplicates the exception on the stack using
     186     * DUP_TOP (if there's an exception type specified).  See compile.c,
     187     * 'com_try_except' for the full details.  There aren't any other
     188     * cases (AFAIK) where a line's code can start with DUP_TOP or
     189     * POP_TOP, but if any ever appear, they'll be subject to the same
     190     * restriction (but with a different error message). */
     191    if (code[new_lasti] == DUP_TOP || code[new_lasti] == POP_TOP) {
     192        PyErr_SetString(PyExc_ValueError,
     193            "can't jump to 'except' line as there's no exception");
     194        return -1;
     195    }
     196
     197    /* You can't jump into or out of a 'finally' block because the 'try'
     198     * block leaves something on the stack for the END_FINALLY to clean
     199     * up.      So we walk the bytecode, maintaining a simulated blockstack.
     200     * When we reach the old or new address and it's in a 'finally' block
     201     * we note the address of the corresponding SETUP_FINALLY.  The jump
     202     * is only legal if neither address is in a 'finally' block or
     203     * they're both in the same one.  'blockstack' is a stack of the
     204     * bytecode addresses of the SETUP_X opcodes, and 'in_finally' tracks
     205     * whether we're in a 'finally' block at each blockstack level. */
     206    f_lasti_setup_addr = -1;
     207    new_lasti_setup_addr = -1;
     208    memset(blockstack, '\0', sizeof(blockstack));
     209    memset(in_finally, '\0', sizeof(in_finally));
     210    blockstack_top = 0;
     211    for (addr = 0; addr < code_len; addr++) {
     212        unsigned char op = code[addr];
     213        switch (op) {
     214        case SETUP_LOOP:
     215        case SETUP_EXCEPT:
     216        case SETUP_FINALLY:
     217        case SETUP_WITH:
     218            blockstack[blockstack_top++] = addr;
     219            in_finally[blockstack_top-1] = 0;
     220            break;
     221
     222        case POP_BLOCK:
     223            assert(blockstack_top > 0);
     224            setup_op = code[blockstack[blockstack_top-1]];
     225            if (setup_op == SETUP_FINALLY || setup_op == SETUP_WITH) {
     226                in_finally[blockstack_top-1] = 1;
     227            }
     228            else {
     229                blockstack_top--;
     230            }
     231            break;
     232
     233        case END_FINALLY:
     234            /* Ignore END_FINALLYs for SETUP_EXCEPTs - they exist
     235             * in the bytecode but don't correspond to an actual
     236             * 'finally' block.  (If blockstack_top is 0, we must
     237             * be seeing such an END_FINALLY.) */
     238            if (blockstack_top > 0) {
     239                setup_op = code[blockstack[blockstack_top-1]];
     240                if (setup_op == SETUP_FINALLY || setup_op == SETUP_WITH) {
     241                    blockstack_top--;
     242                }
     243            }
     244            break;
     245        }
     246
     247        /* For the addresses we're interested in, see whether they're
     248         * within a 'finally' block and if so, remember the address
     249         * of the SETUP_FINALLY. */
     250        if (addr == new_lasti || addr == f->f_lasti) {
     251            int i = 0;
     252            int setup_addr = -1;
     253            for (i = blockstack_top-1; i >= 0; i--) {
     254                if (in_finally[i]) {
     255                    setup_addr = blockstack[i];
     256                    break;
     257                }
     258            }
     259
     260            if (setup_addr != -1) {
     261                if (addr == new_lasti) {
     262                    new_lasti_setup_addr = setup_addr;
     263                }
     264
     265                if (addr == f->f_lasti) {
     266                    f_lasti_setup_addr = setup_addr;
     267                }
     268            }
     269        }
     270
     271        if (op >= HAVE_ARGUMENT) {
     272            addr += 2;
     273        }
     274    }
     275
     276    /* Verify that the blockstack tracking code didn't get lost. */
     277    assert(blockstack_top == 0);
     278
     279    /* After all that, are we jumping into / out of a 'finally' block? */
     280    if (new_lasti_setup_addr != f_lasti_setup_addr) {
     281        PyErr_SetString(PyExc_ValueError,
     282                    "can't jump into or out of a 'finally' block");
     283        return -1;
     284    }
     285
     286
     287    /* Police block-jumping (you can't jump into the middle of a block)
     288     * and ensure that the blockstack finishes up in a sensible state (by
     289     * popping any blocks we're jumping out of).  We look at all the
     290     * blockstack operations between the current position and the new
     291     * one, and keep track of how many blocks we drop out of on the way.
     292     * By also keeping track of the lowest blockstack position we see, we
     293     * can tell whether the jump goes into any blocks without coming out
     294     * again - in that case we raise an exception below. */
     295    delta_iblock = 0;
     296    for (addr = min_addr; addr < max_addr; addr++) {
     297        unsigned char op = code[addr];
     298        switch (op) {
     299        case SETUP_LOOP:
     300        case SETUP_EXCEPT:
     301        case SETUP_FINALLY:
     302        case SETUP_WITH:
     303            delta_iblock++;
     304            break;
     305
     306        case POP_BLOCK:
     307            delta_iblock--;
     308            break;
     309        }
     310
     311        min_delta_iblock = MIN(min_delta_iblock, delta_iblock);
     312
     313        if (op >= HAVE_ARGUMENT) {
     314            addr += 2;
     315        }
     316    }
     317
     318    /* Derive the absolute iblock values from the deltas. */
     319    min_iblock = f->f_iblock + min_delta_iblock;
     320    if (new_lasti > f->f_lasti) {
     321        /* Forwards jump. */
     322        new_iblock = f->f_iblock + delta_iblock;
     323    }
     324    else {
     325        /* Backwards jump. */
     326        new_iblock = f->f_iblock - delta_iblock;
     327    }
     328
     329    /* Are we jumping into a block? */
     330    if (new_iblock > min_iblock) {
     331        PyErr_SetString(PyExc_ValueError,
     332                        "can't jump into the middle of a block");
     333        return -1;
     334    }
     335
     336    /* Pop any blocks that we're jumping out of. */
     337    while (f->f_iblock > new_iblock) {
     338        PyTryBlock *b = &f->f_blockstack[--f->f_iblock];
     339        while ((f->f_stacktop - f->f_valuestack) > b->b_level) {
     340            PyObject *v = (*--f->f_stacktop);
     341            Py_DECREF(v);
     342        }
     343    }
     344
     345    /* Finally set the new f_lineno and f_lasti and return OK. */
     346    f->f_lineno = new_lineno;
     347    f->f_lasti = new_lasti;
     348    return 0;
    313349}
    314350
    … …  
    316352frame_gettrace(PyFrameObject *f, void *closure)
    317353{
    318         PyObject* trace = f->f_trace;
    319 
    320         if (trace == NULL)
    321                 trace = Py_None;
    322 
    323         Py_INCREF(trace);
    324 
    325         return trace;
     354    PyObject* trace = f->f_trace;
     355
     356    if (trace == NULL)
     357        trace = Py_None;
     358
     359    Py_INCREF(trace);
     360
     361    return trace;
    326362}
    327363
    … …  
    329365frame_settrace(PyFrameObject *f, PyObject* v, void *closure)
    330366{
    331         /* We rely on f_lineno being accurate when f_trace is set. */
    332 
    333         PyObject* old_value = f->f_trace;
    334 
    335         Py_XINCREF(v);
    336         f->f_trace = v;
    337 
    338         if (v != NULL)
    339                 f->f_lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
    340 
    341         Py_XDECREF(old_value);
    342 
    343         return 0;
     367    PyObject* old_value;
     368
     369    /* We rely on f_lineno being accurate when f_trace is set. */
     370    f->f_lineno = PyFrame_GetLineNumber(f);
     371
     372    old_value = f->f_trace;
     373    Py_XINCREF(v);
     374    f->f_trace = v;
     375    Py_XDECREF(old_value);
     376
     377    return 0;
    344378}
    345379
    … …  
    347381frame_getrestricted(PyFrameObject *f, void *closure)
    348382{
    349         return PyBool_FromLong(PyFrame_IsRestricted(f));
     383    return PyBool_FromLong(PyFrame_IsRestricted(f));
    350384}
    351385
    352386static PyGetSetDef frame_getsetlist[] = {
    353         {"f_locals",    (getter)frame_getlocals, NULL, NULL},
    354         {"f_lineno",    (getter)frame_getlineno,
    355                         (setter)frame_setlineno, NULL},
    356         {"f_trace",     (getter)frame_gettrace, (setter)frame_settrace, NULL},
    357         {"f_restricted",(getter)frame_getrestricted,NULL, NULL},
    358         {0}
     387    {"f_locals",        (getter)frame_getlocals, NULL, NULL},
     388    {"f_lineno",        (getter)frame_getlineno,
     389                    (setter)frame_setlineno, NULL},
     390    {"f_trace",         (getter)frame_gettrace, (setter)frame_settrace, NULL},
     391    {"f_restricted",(getter)frame_getrestricted,NULL, NULL},
     392    {"f_exc_traceback", (getter)frame_get_f_exc_traceback,
     393                    (setter)frame_set_f_exc_traceback, NULL},
     394    {"f_exc_type",  (getter)frame_get_f_exc_type,
     395                    (setter)frame_set_f_exc_type, NULL},
     396    {"f_exc_value", (getter)frame_get_f_exc_value,
     397                    (setter)frame_set_f_exc_value, NULL},
     398    {0}
    359399};
    360400
    … …  
    373413
    374414     * ob_type, ob_size, f_code, f_valuestack;
    375        
     415
    376416     * f_locals, f_trace,
    377417       f_exc_type, f_exc_value, f_exc_traceback are NULL;
    … …  
    384424   a stack frame is on the free list, only the following members have
    385425   a meaning:
    386         ob_type         == &Frametype
    387         f_back          next item on free list, or NULL
    388         f_stacksize     size of value stack
    389         ob_size         size of localsplus
     426    ob_type             == &Frametype
     427    f_back              next item on free list, or NULL
     428    f_stacksize         size of value stack
     429    ob_size             size of localsplus
    390430   Note that the value and block stacks are preserved -- this can save
    391431   another malloc() call or two (and two free() calls as well!).
    … …  
    403443
    404444static PyFrameObject *free_list = NULL;
    405 static int numfree = 0;         /* number of frames currently in free_list */
     445static int numfree = 0;         /* number of frames currently in free_list */
    406446/* max value for numfree */
    407 #define PyFrame_MAXFREELIST 200 
     447#define PyFrame_MAXFREELIST 200
    408448
    409449static void
    410450frame_dealloc(PyFrameObject *f)
    411451{
    412         PyObject **p, **valuestack;
    413         PyCodeObject *co;
    414 
    415         PyObject_GC_UnTrack(f);
    416         Py_TRASHCAN_SAFE_BEGIN(f)
    417         /* Kill all local variables */
    418         valuestack = f->f_valuestack;
    419         for (p = f->f_localsplus; p < valuestack; p++)
    420                 Py_CLEAR(*p);
    421 
    422         /* Free stack */
    423         if (f->f_stacktop != NULL) {
    424                 for (p = valuestack; p < f->f_stacktop; p++)
    425                         Py_XDECREF(*p);
    426         }
    427 
    428         Py_XDECREF(f->f_back);
    429         Py_DECREF(f->f_builtins);
    430         Py_DECREF(f->f_globals);
    431         Py_CLEAR(f->f_locals);
    432         Py_CLEAR(f->f_trace);
    433         Py_CLEAR(f->f_exc_type);
    434         Py_CLEAR(f->f_exc_value);
    435         Py_CLEAR(f->f_exc_traceback);
    436 
    437         co = f->f_code;
    438         if (co->co_zombieframe == NULL)
    439                 co->co_zombieframe = f;
    440         else if (numfree < PyFrame_MAXFREELIST) {
    441                 ++numfree;
    442                 f->f_back = free_list;
    443                 free_list = f;
    444         }
    445         else
    446                 PyObject_GC_Del(f);
    447 
    448         Py_DECREF(co);
    449         Py_TRASHCAN_SAFE_END(f)
     452    PyObject **p, **valuestack;
     453    PyCodeObject *co;
     454
     455    PyObject_GC_UnTrack(f);
     456    Py_TRASHCAN_SAFE_BEGIN(f)
     457    /* Kill all local variables */
     458    valuestack = f->f_valuestack;
     459    for (p = f->f_localsplus; p < valuestack; p++)
     460        Py_CLEAR(*p);
     461
     462    /* Free stack */
     463    if (f->f_stacktop != NULL) {
     464        for (p = valuestack; p < f->f_stacktop; p++)
     465            Py_XDECREF(*p);
     466    }
     467
     468    Py_XDECREF(f->f_back);
     469    Py_DECREF(f->f_builtins);
     470    Py_DECREF(f->f_globals);
     471    Py_CLEAR(f->f_locals);
     472    Py_CLEAR(f->f_trace);
     473    Py_CLEAR(f->f_exc_type);
     474    Py_CLEAR(f->f_exc_value);
     475    Py_CLEAR(f->f_exc_traceback);
     476
     477    co = f->f_code;
     478    if (co->co_zombieframe == NULL)
     479        co->co_zombieframe = f;
     480    else if (numfree < PyFrame_MAXFREELIST) {
     481        ++numfree;
     482        f->f_back = free_list;
     483        free_list = f;
     484    }
     485    else
     486        PyObject_GC_Del(f);
     487
     488    Py_DECREF(co);
     489    Py_TRASHCAN_SAFE_END(f)
    450490}
    451491
    … …  
    453493frame_traverse(PyFrameObject *f, visitproc visit, void *arg)
    454494{
    455         PyObject **fastlocals, **p;
    456         int i, slots;
    457 
    458         Py_VISIT(f->f_back);
    459         Py_VISIT(f->f_code);
    460         Py_VISIT(f->f_builtins);
    461         Py_VISIT(f->f_globals);
    462         Py_VISIT(f->f_locals);
    463         Py_VISIT(f->f_trace);
    464         Py_VISIT(f->f_exc_type);
    465         Py_VISIT(f->f_exc_value);
    466         Py_VISIT(f->f_exc_traceback);
    467 
    468         /* locals */
    469         slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
    470         fastlocals = f->f_localsplus;
    471         for (i = slots; --i >= 0; ++fastlocals)
    472                 Py_VISIT(*fastlocals);
    473 
    474         /* stack */
    475         if (f->f_stacktop != NULL) {
    476                 for (p = f->f_valuestack; p < f->f_stacktop; p++)
    477                         Py_VISIT(*p);
    478         }
    479         return 0;
     495    PyObject **fastlocals, **p;
     496    int i, slots;
     497
     498    Py_VISIT(f->f_back);
     499    Py_VISIT(f->f_code);
     500    Py_VISIT(f->f_builtins);
     501    Py_VISIT(f->f_globals);
     502    Py_VISIT(f->f_locals);
     503    Py_VISIT(f->f_trace);
     504    Py_VISIT(f->f_exc_type);
     505    Py_VISIT(f->f_exc_value);
     506    Py_VISIT(f->f_exc_traceback);
     507
     508    /* locals */
     509    slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
     510    fastlocals = f->f_localsplus;
     511    for (i = slots; --i >= 0; ++fastlocals)
     512        Py_VISIT(*fastlocals);
     513
     514    /* stack */
     515    if (f->f_stacktop != NULL) {
     516        for (p = f->f_valuestack; p < f->f_stacktop; p++)
     517            Py_VISIT(*p);
     518    }
     519    return 0;
    480520}
    481521
    … …  
    483523frame_clear(PyFrameObject *f)
    484524{
    485         PyObject **fastlocals, **p, **oldtop;
    486         int i, slots;
    487 
    488         /* Before anything else, make sure that this frame is clearly marked
    489         * as being defunct!  Else, e.g., a generator reachable from this
    490         * frame may also point to this frame, believe itself to still be
    491         * active, and try cleaning up this frame again.
    492         */
    493         oldtop = f->f_stacktop;
    494         f->f_stacktop = NULL;
    495 
    496         Py_CLEAR(f->f_exc_type);
    497         Py_CLEAR(f->f_exc_value);
    498         Py_CLEAR(f->f_exc_traceback);
    499         Py_CLEAR(f->f_trace);
    500 
    501         /* locals */
    502         slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
    503         fastlocals = f->f_localsplus;
    504         for (i = slots; --i >= 0; ++fastlocals)
    505                 Py_CLEAR(*fastlocals);
    506 
    507         /* stack */
    508         if (oldtop != NULL) {
    509                 for (p = f->f_valuestack; p < oldtop; p++)
    510                         Py_CLEAR(*p);
    511         }
     525    PyObject **fastlocals, **p, **oldtop;
     526    int i, slots;
     527
     528    /* Before anything else, make sure that this frame is clearly marked
     529    * as being defunct!  Else, e.g., a generator reachable from this
     530    * frame may also point to this frame, believe itself to still be
     531    * active, and try cleaning up this frame again.
     532    */
     533    oldtop = f->f_stacktop;
     534    f->f_stacktop = NULL;
     535
     536    Py_CLEAR(f->f_exc_type);
     537    Py_CLEAR(f->f_exc_value);
     538    Py_CLEAR(f->f_exc_traceback);
     539    Py_CLEAR(f->f_trace);
     540
     541    /* locals */
     542    slots = f->f_code->co_nlocals + PyTuple_GET_SIZE(f->f_code->co_cellvars) + PyTuple_GET_SIZE(f->f_code->co_freevars);
     543    fastlocals = f->f_localsplus;
     544    for (i = slots; --i >= 0; ++fastlocals)
     545        Py_CLEAR(*fastlocals);
     546
     547    /* stack */
     548    if (oldtop != NULL) {
     549        for (p = f->f_valuestack; p < oldtop; p++)
     550            Py_CLEAR(*p);
     551    }
    512552}
    513553
    … …  
    515555frame_sizeof(PyFrameObject *f)
    516556{
    517         Py_ssize_t res, extras, ncells, nfrees;
    518 
    519         ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars);
    520         nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars);
    521         extras = f->f_code->co_stacksize + f->f_code->co_nlocals +
    522                 ncells + nfrees;
    523         /* subtract one as it is already included in PyFrameObject */
    524         res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *);
    525 
    526         return PyInt_FromSsize_t(res);
     557    Py_ssize_t res, extras, ncells, nfrees;
     558
     559    ncells = PyTuple_GET_SIZE(f->f_code->co_cellvars);
     560    nfrees = PyTuple_GET_SIZE(f->f_code->co_freevars);
     561    extras = f->f_code->co_stacksize + f->f_code->co_nlocals +
     562            ncells + nfrees;
     563    /* subtract one as it is already included in PyFrameObject */
     564    res = sizeof(PyFrameObject) + (extras-1) * sizeof(PyObject *);
     565
     566    return PyInt_FromSsize_t(res);
    527567}
    528568
    … …  
    531571
    532572static PyMethodDef frame_methods[] = {
    533         {"__sizeof__",  (PyCFunction)frame_sizeof,      METH_NOARGS,
    534         sizeof__doc__},
    535         {NULL,          NULL}   /* sentinel */
     573    {"__sizeof__",      (PyCFunction)frame_sizeof,      METH_NOARGS,
     574    sizeof__doc__},
     575    {NULL,              NULL}   /* sentinel */
    536576};
    537577
    538578PyTypeObject PyFrame_Type = {
    539         PyVarObject_HEAD_INIT(&PyType_Type, 0)
    540         "frame",
    541         sizeof(PyFrameObject),
    542         sizeof(PyObject *),
    543         (destructor)frame_dealloc,              /* tp_dealloc */
    544         0,                                      /* tp_print */
    545         0,                                      /* tp_getattr */
    546         0,                                      /* tp_setattr */
    547         0,                                      /* tp_compare */
    548         0,                                      /* tp_repr */
    549         0,                                      /* tp_as_number */
    550         0,                                      /* tp_as_sequence */
    551         0,                                      /* tp_as_mapping */
    552         0,                                      /* tp_hash */
    553         0,                                      /* tp_call */
    554         0,                                      /* tp_str */
    555         PyObject_GenericGetAttr,                /* tp_getattro */
    556         PyObject_GenericSetAttr,                /* tp_setattro */
    557         0,                                      /* tp_as_buffer */
    558         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
    559         0,                                      /* tp_doc */
    560         (traverseproc)frame_traverse,           /* tp_traverse */
    561         (inquiry)frame_clear,                   /* tp_clear */
    562         0,                                      /* tp_richcompare */
    563         0,                                      /* tp_weaklistoffset */
    564         0,                                      /* tp_iter */
    565         0,                                      /* tp_iternext */
    566         frame_methods,                          /* tp_methods */
    567         frame_memberlist,                       /* tp_members */
    568         frame_getsetlist,                       /* tp_getset */
    569         0,                                      /* tp_base */
    570         0,                                      /* tp_dict */
     579    PyVarObject_HEAD_INIT(&PyType_Type, 0)
     580    "frame",
     581    sizeof(PyFrameObject),
     582    sizeof(PyObject *),
     583    (destructor)frame_dealloc,                  /* tp_dealloc */
     584    0,                                          /* tp_print */
     585    0,                                          /* tp_getattr */
     586    0,                                          /* tp_setattr */
     587    0,                                          /* tp_compare */
     588    0,                                          /* tp_repr */
     589    0,                                          /* tp_as_number */
     590    0,                                          /* tp_as_sequence */
     591    0,                                          /* tp_as_mapping */
     592    0,                                          /* tp_hash */
     593    0,                                          /* tp_call */
     594    0,                                          /* tp_str */
     595    PyObject_GenericGetAttr,                    /* tp_getattro */
     596    PyObject_GenericSetAttr,                    /* tp_setattro */
     597    0,                                          /* tp_as_buffer */
     598    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
     599    0,                                          /* tp_doc */
     600    (traverseproc)frame_traverse,               /* tp_traverse */
     601    (inquiry)frame_clear,                       /* tp_clear */
     602    0,                                          /* tp_richcompare */
     603    0,                                          /* tp_weaklistoffset */
     604    0,                                          /* tp_iter */
     605    0,                                          /* tp_iternext */
     606    frame_methods,                              /* tp_methods */
     607    frame_memberlist,                           /* tp_members */
     608    frame_getsetlist,                           /* tp_getset */
     609    0,                                          /* tp_base */
     610    0,                                          /* tp_dict */
    571611};
    572612
    … …  
    575615int _PyFrame_Init()
    576616{
    577         builtin_object = PyString_InternFromString("__builtins__");
    578         if (builtin_object == NULL)
    579                 return 0;
    580         return 1;
     617    builtin_object = PyString_InternFromString("__builtins__");
     618    if (builtin_object == NULL)
     619        return 0;
     620    return 1;
    581621}
    582622
    583623PyFrameObject *
    584624PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
    585             PyObject *locals)
    586 {
    587         PyFrameObject *back = tstate->frame;
    588         PyFrameObject *f;
    589         PyObject *builtins;
    590         Py_ssize_t i;
     625            PyObject *locals)
     626{
     627    PyFrameObject *back = tstate->frame;
     628    PyFrameObject *f;
     629    PyObject *builtins;
     630    Py_ssize_t i;
    591631
    592632#ifdef Py_DEBUG
    593         if (code == NULL || globals == NULL || !PyDict_Check(globals) ||
    594             (locals != NULL && !PyMapping_Check(locals))) {
    595                 PyErr_BadInternalCall();
    596                 return NULL;
    597         }
     633    if (code == NULL || globals == NULL || !PyDict_Check(globals) ||
     634        (locals != NULL && !PyMapping_Check(locals))) {
     635        PyErr_BadInternalCall();
     636        return NULL;
     637    }
    598638#endif
    599         if (back == NULL || back->f_globals != globals) {
    600                 builtins = PyDict_GetItem(globals, builtin_object);
    601                 if (builtins) {
    602                         if (PyModule_Check(builtins)) {
    603                                 builtins = PyModule_GetDict(builtins);
    604                                 assert(!builtins || PyDict_Check(builtins));
    605                         }
    606                         else if (!PyDict_Check(builtins))
    607                                 builtins = NULL;
    608                 }
    609                 if (builtins == NULL) {
    610                         /* No builtins! Make up a minimal one
    611                            Give them 'None', at least. */
    612                         builtins = PyDict_New();
    613                         if (builtins == NULL ||
    614                             PyDict_SetItemString(
    615                                     builtins, "None", Py_None) < 0)
    616                                 return NULL;
    617                 }
    618                 else
    619                         Py_INCREF(builtins);
    620 
    621         }
    622         else {
    623                 /* If we share the globals, we share the builtins.
    624                    Save a lookup and a call. */
    625                 builtins = back->f_builtins;
    626                 assert(builtins != NULL && PyDict_Check(builtins));
    627                 Py_INCREF(builtins);
    628         }
    629         if (code->co_zombieframe != NULL) {
    630                 f = code->co_zombieframe;
    631                 code->co_zombieframe = NULL;
    632                 _Py_NewReference((PyObject *)f);
    633                 assert(f->f_code == code);
    634         }
    635         else {
    636                 Py_ssize_t extras, ncells, nfrees;
    637                 ncells = PyTuple_GET_SIZE(code->co_cellvars);
    638                 nfrees = PyTuple_GET_SIZE(code->co_freevars);
    639                 extras = code->co_stacksize + code->co_nlocals + ncells +
    640                     nfrees;
    641                 if (free_list == NULL) {
    642                     f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type,
    643                         extras);
    644                     if (f == NULL) {
    645                             Py_DECREF(builtins);
    646                             return NULL;
    647                     }
    648                 }
    649                 else {
    650                     assert(numfree > 0);
    651                     --numfree;
    652                     f = free_list;
    653                     free_list = free_list->f_back;
    654                     if (Py_SIZE(f) < extras) {
    655                             f = PyObject_GC_Resize(PyFrameObject, f, extras);
    656                             if (f == NULL) {
    657                                     Py_DECREF(builtins);
    658                                     return NULL;
    659                             }
    660                     }
    661                     _Py_NewReference((PyObject *)f);
    662                 }
    663 
    664                 f->f_code = code;
    665                 extras = code->co_nlocals + ncells + nfrees;
    666                 f->f_valuestack = f->f_localsplus + extras;
    667                 for (i=0; i<extras; i++)
    668                         f->f_localsplus[i] = NULL;
    669                 f->f_locals = NULL;
    670                 f->f_trace = NULL;
    671                 f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL;
    672         }
    673         f->f_stacktop = f->f_valuestack;
    674         f->f_builtins = builtins;
    675         Py_XINCREF(back);
    676         f->f_back = back;
    677         Py_INCREF(code);
    678         Py_INCREF(globals);
    679         f->f_globals = globals;
    680         /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
    681         if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
    682                 (CO_NEWLOCALS | CO_OPTIMIZED))
    683                 ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
    684         else if (code->co_flags & CO_NEWLOCALS) {
    685                 locals = PyDict_New();
    686                 if (locals == NULL) {
    687                         Py_DECREF(f);
    688                         return NULL;
    689                 }
    690                 f->f_locals = locals;
    691         }
    692         else {
    693                 if (locals == NULL)
    694                         locals = globals;
    695                 Py_INCREF(locals);
    696                 f->f_locals = locals;
    697         }
    698         f->f_tstate = tstate;
    699 
    700         f->f_lasti = -1;
    701         f->f_lineno = code->co_firstlineno;
    702         f->f_iblock = 0;
    703 
    704         _PyObject_GC_TRACK(f);
    705         return f;
     639    if (back == NULL || back->f_globals != globals) {
     640        builtins = PyDict_GetItem(globals, builtin_object);
     641        if (builtins) {
     642            if (PyModule_Check(builtins)) {
     643                builtins = PyModule_GetDict(builtins);
     644                assert(!builtins || PyDict_Check(builtins));
     645            }
     646            else if (!PyDict_Check(builtins))
     647                builtins = NULL;
     648        }
     649        if (builtins == NULL) {
     650            /* No builtins!              Make up a minimal one
     651               Give them 'None', at least. */
     652            builtins = PyDict_New();
     653            if (builtins == NULL ||
     654                PyDict_SetItemString(
     655                    builtins, "None", Py_None) < 0)
     656                return NULL;
     657        }
     658        else
     659            Py_INCREF(builtins);
     660
     661    }
     662    else {
     663        /* If we share the globals, we share the builtins.
     664           Save a lookup and a call. */
     665        builtins = back->f_builtins;
     666        assert(builtins != NULL && PyDict_Check(builtins));
     667        Py_INCREF(builtins);
     668    }
     669    if (code->co_zombieframe != NULL) {
     670        f = code->co_zombieframe;
     671        code->co_zombieframe = NULL;
     672        _Py_NewReference((PyObject *)f);
     673        assert(f->f_code == code);
     674    }
     675    else {
     676        Py_ssize_t extras, ncells, nfrees;
     677        ncells = PyTuple_GET_SIZE(code->co_cellvars);
     678        nfrees = PyTuple_GET_SIZE(code->co_freevars);
     679        extras = code->co_stacksize + code->co_nlocals + ncells +
     680            nfrees;
     681        if (free_list == NULL) {
     682            f = PyObject_GC_NewVar(PyFrameObject, &PyFrame_Type,
     683            extras);
     684            if (f == NULL) {
     685                Py_DECREF(builtins);
     686                return NULL;
     687            }
     688        }
     689        else {
     690            assert(numfree > 0);
     691            --numfree;
     692            f = free_list;
     693            free_list = free_list->f_back;
     694            if (Py_SIZE(f) < extras) {
     695                f = PyObject_GC_Resize(PyFrameObject, f, extras);
     696                if (f == NULL) {
     697                    Py_DECREF(builtins);
     698                    return NULL;
     699                }
     700            }
     701            _Py_NewReference((PyObject *)f);
     702        }
     703
     704        f->f_code = code;
     705        extras = code->co_nlocals + ncells + nfrees;
     706        f->f_valuestack = f->f_localsplus + extras;
     707        for (i=0; i<extras; i++)
     708            f->f_localsplus[i] = NULL;
     709        f->f_locals = NULL;
     710        f->f_trace = NULL;
     711        f->f_exc_type = f->f_exc_value = f->f_exc_traceback = NULL;
     712    }
     713    f->f_stacktop = f->f_valuestack;
     714    f->f_builtins = builtins;
     715    Py_XINCREF(back);
     716    f->f_back = back;
     717    Py_INCREF(code);
     718    Py_INCREF(globals);
     719    f->f_globals = globals;
     720    /* Most functions have CO_NEWLOCALS and CO_OPTIMIZED set. */
     721    if ((code->co_flags & (CO_NEWLOCALS | CO_OPTIMIZED)) ==
     722        (CO_NEWLOCALS | CO_OPTIMIZED))
     723        ; /* f_locals = NULL; will be set by PyFrame_FastToLocals() */
     724    else if (code->co_flags & CO_NEWLOCALS) {
     725        locals = PyDict_New();
     726        if (locals == NULL) {
     727            Py_DECREF(f);
     728            return NULL;
     729        }
     730        f->f_locals = locals;
     731    }
     732    else {
     733        if (locals == NULL)
     734            locals = globals;
     735        Py_INCREF(locals);
     736        f->f_locals = locals;
     737    }
     738    f->f_tstate = tstate;
     739
     740    f->f_lasti = -1;
     741    f->f_lineno = code->co_firstlineno;
     742    f->f_iblock = 0;
     743
     744    _PyObject_GC_TRACK(f);
     745    return f;
    706746}
    707747
    … …  
    711751PyFrame_BlockSetup(PyFrameObject *f, int type, int handler, int level)
    712752{
    713         PyTryBlock *b;
    714         if (f->f_iblock >= CO_MAXBLOCKS)
    715                 Py_FatalError("XXX block stack overflow");
    716         b = &f->f_blockstack[f->f_iblock++];
    717         b->b_type = type;
    718         b->b_level = level;
    719         b->b_handler = handler;
     753    PyTryBlock *b;
     754    if (f->f_iblock >= CO_MAXBLOCKS)
     755        Py_FatalError("XXX block stack overflow");
     756    b = &f->f_blockstack[f->f_iblock++];
     757    b->b_type = type;
     758    b->b_level = level;
     759    b->b_handler = handler;
    720760}
    721761
    … …  
    723763PyFrame_BlockPop(PyFrameObject *f)
    724764{
    725         PyTryBlock *b;
    726         if (f->f_iblock <= 0)
    727                 Py_FatalError("XXX block stack underflow");
    728         b = &f->f_blockstack[--f->f_iblock];
    729         return b;
     765    PyTryBlock *b;
     766    if (f->f_iblock <= 0)
     767        Py_FatalError("XXX block stack underflow");
     768    b = &f->f_blockstack[--f->f_iblock];
     769    return b;
    730770}
    731771
    732772/* Convert between "fast" version of locals and dictionary version.
    733    
    734    map and values are input arguments.  map is a tuple of strings.
     773
     774   map and values are input arguments.  map is a tuple of strings.
    735775   values is an array of PyObject*.  At index i, map[i] is the name of
    736776   the variable with value values[i].  The function copies the first
    … …  
    748788static void
    749789map_to_dict(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
    750             int deref)
    751 {
    752         Py_ssize_t j;
    753         assert(PyTuple_Check(map));
    754         assert(PyDict_Check(dict));
    755         assert(PyTuple_Size(map) >= nmap);
    756         for (j = nmap; --j >= 0; ) {
    757                 PyObject *key = PyTuple_GET_ITEM(map, j);
    758                 PyObject *value = values[j];
    759                 assert(PyString_Check(key));
    760                 if (deref) {
    761                         assert(PyCell_Check(value));
    762                         value = PyCell_GET(value);
    763                 }
    764                 if (value == NULL) {
    765                         if (PyObject_DelItem(dict, key) != 0)
    766                                 PyErr_Clear();
    767                 }
    768                 else {
    769                         if (PyObject_SetItem(dict, key, value) != 0)
    770                                 PyErr_Clear();
    771                 }
    772         }
     790            int deref)
     791{
     792    Py_ssize_t j;
     793    assert(PyTuple_Check(map));
     794    assert(PyDict_Check(dict));
     795    assert(PyTuple_Size(map) >= nmap);
     796    for (j = nmap; --j >= 0; ) {
     797        PyObject *key = PyTuple_GET_ITEM(map, j);
     798        PyObject *value = values[j];
     799        assert(PyString_Check(key));
     800        if (deref) {
     801            assert(PyCell_Check(value));
     802            value = PyCell_GET(value);
     803        }
     804        if (value == NULL) {
     805            if (PyObject_DelItem(dict, key) != 0)
     806                PyErr_Clear();
     807        }
     808        else {
     809            if (PyObject_SetItem(dict, key, value) != 0)
     810                PyErr_Clear();
     811        }
     812    }
    773813}
    774814
    … …  
    778818   variables names and arbitrary PyObject* as values.
    779819
    780    map and values are input arguments.  map is a tuple of strings.
     820   map and values are input arguments.  map is a tuple of strings.
    781821   values is an array of PyObject*.  At index i, map[i] is the name of
    782822   the variable with value values[i].  The function copies the first
    … …  
    796836static void
    797837dict_to_map(PyObject *map, Py_ssize_t nmap, PyObject *dict, PyObject **values,
    798             int deref, int clear)
    799 {
    800         Py_ssize_t j;
    801         assert(PyTuple_Check(map));
    802         assert(PyDict_Check(dict));
    803         assert(PyTuple_Size(map) >= nmap);
    804         for (j = nmap; --j >= 0; ) {
    805                 PyObject *key = PyTuple_GET_ITEM(map, j);
    806                 PyObject *value = PyObject_GetItem(dict, key);
    807                 assert(PyString_Check(key));
    808                 /* We only care about NULLs if clear is true. */
    809                 if (value == NULL) {
    810                         PyErr_Clear();
    811                         if (!clear)
    812                                 continue;
    813                 }
    814                 if (deref) {
    815                         assert(PyCell_Check(values[j]));
    816                         if (PyCell_GET(values[j]) != value) {
    817                                 if (PyCell_Set(values[j], value) < 0)
    818                                         PyErr_Clear();
    819                         }
    820                 } else if (values[j] != value) {
    821                         Py_XINCREF(value);
    822                         Py_XDECREF(values[j]);
    823                         values[j] = value;
    824                 }
    825                 Py_XDECREF(value);
    826         }
     838            int deref, int clear)
     839{
     840    Py_ssize_t j;
     841    assert(PyTuple_Check(map));
     842    assert(PyDict_Check(dict));
     843    assert(PyTuple_Size(map) >= nmap);
     844    for (j = nmap; --j >= 0; ) {
     845        PyObject *key = PyTuple_GET_ITEM(map, j);
     846        PyObject *value = PyObject_GetItem(dict, key);
     847        assert(PyString_Check(key));
     848        /* We only care about NULLs if clear is true. */
     849        if (value == NULL) {
     850            PyErr_Clear();
     851            if (!clear)
     852                continue;
     853        }
     854        if (deref) {
     855            assert(PyCell_Check(values[j]));
     856            if (PyCell_GET(values[j]) != value) {
     857                if (PyCell_Set(values[j], value) < 0)
     858                    PyErr_Clear();
     859            }
     860        } else if (values[j] != value) {
     861            Py_XINCREF(value);
     862            Py_XDECREF(values[j]);
     863            values[j] = value;
     864        }
     865        Py_XDECREF(value);
     866    }
    827867}
    828868
    … …  
    830870PyFrame_FastToLocals(PyFrameObject *f)
    831871{
    832         /* Merge fast locals into f->f_locals */
    833         PyObject *locals, *map;
    834         PyObject **fast;
    835         PyObject *error_type, *error_value, *error_traceback;
    836         PyCodeObject *co;
    837         Py_ssize_t j;
    838         int ncells, nfreevars;
    839         if (f == NULL)
    840                 return;
    841         locals = f->f_locals;
    842         if (locals == NULL) {
    843                 locals = f->f_locals = PyDict_New();
    844                 if (locals == NULL) {
    845                         PyErr_Clear(); /* Can't report it :-( */
    846                         return;
    847                 }
    848         }
    849         co = f->f_code;
    850         map = co->co_varnames;
    851         if (!PyTuple_Check(map))
    852                 return;
    853         PyErr_Fetch(&error_type, &error_value, &error_traceback);
    854         fast = f->f_localsplus;
    855         j = PyTuple_GET_SIZE(map);
    856         if (j > co->co_nlocals)
    857                 j = co->co_nlocals;
    858         if (co->co_nlocals)
    859                 map_to_dict(map, j, locals, fast, 0);
    860         ncells = PyTuple_GET_SIZE(co->co_cellvars);
    861         nfreevars = PyTuple_GET_SIZE(co->co_freevars);
    862         if (ncells || nfreevars) {
    863                 map_to_dict(co->co_cellvars, ncells,
    864                             locals, fast + co->co_nlocals, 1);
    865                 /* If the namespace is unoptimized, then one of the
    866                    following cases applies:
    867                    1. It does not contain free variables, because it
    868                       uses import * or is a top-level namespace.
    869                    2. It is a class namespace.
    870                    We don't want to accidentally copy free variables
    871                    into the locals dict used by the class.
    872                 */
    873                 if (co->co_flags & CO_OPTIMIZED) {
    874                         map_to_dict(co->co_freevars, nfreevars,
    875                                     locals, fast + co->co_nlocals + ncells, 1);
    876                 }
    877         }
    878         PyErr_Restore(error_type, error_value, error_traceback);
     872    /* Merge fast locals into f->f_locals */
     873    PyObject *locals, *map;
     874    PyObject **fast;
     875    PyObject *error_type, *error_value, *error_traceback;
     876    PyCodeObject *co;
     877    Py_ssize_t j;
     878    int ncells, nfreevars;
     879    if (f == NULL)
     880        return;
     881    locals = f->f_locals;
     882    if (locals == NULL) {
     883        locals = f->f_locals = PyDict_New();
     884        if (locals == NULL) {
     885            PyErr_Clear(); /* Can't report it :-( */
     886            return;
     887        }
     888    }
     889    co = f->f_code;
     890    map = co->co_varnames;
     891    if (!PyTuple_Check(map))
     892        return;
     893    PyErr_Fetch(&error_type, &error_value, &error_traceback);
     894    fast = f->f_localsplus;
     895    j = PyTuple_GET_SIZE(map);
     896    if (j > co->co_nlocals)
     897        j = co->co_nlocals;
     898    if (co->co_nlocals)
     899        map_to_dict(map, j, locals, fast, 0);
     900    ncells = PyTuple_GET_SIZE(co->co_cellvars);
     901    nfreevars = PyTuple_GET_SIZE(co->co_freevars);
     902    if (ncells || nfreevars) {
     903        map_to_dict(co->co_cellvars, ncells,
     904                    locals, fast + co->co_nlocals, 1);
     905        /* If the namespace is unoptimized, then one of the
     906           following cases applies:
     907           1. It does not contain free variables, because it
     908              uses import * or is a top-level namespace.
     909           2. It is a class namespace.
     910           We don't want to accidentally copy free variables
     911           into the locals dict used by the class.
     912        */
     913        if (co->co_flags & CO_OPTIMIZED) {
     914            map_to_dict(co->co_freevars, nfreevars,
     915                        locals, fast + co->co_nlocals + ncells, 1);
     916        }
     917    }
     918    PyErr_Restore(error_type, error_value, error_traceback);
    879919}
    880920
    … …  
    882922PyFrame_LocalsToFast(PyFrameObject *f, int clear)
    883923{
    884         /* Merge f->f_locals into fast locals */
    885         PyObject *locals, *map;
    886         PyObject **fast;
    887         PyObject *error_type, *error_value, *error_traceback;
    888         PyCodeObject *co;
    889         Py_ssize_t j;
    890         int ncells, nfreevars;
    891         if (f == NULL)
    892                 return;
    893         locals = f->f_locals;
    894         co = f->f_code;
    895         map = co->co_varnames;
    896         if (locals == NULL)
    897                 return;
    898         if (!PyTuple_Check(map))
    899                 return;
    900         PyErr_Fetch(&error_type, &error_value, &error_traceback);
    901         fast = f->f_localsplus;
    902         j = PyTuple_GET_SIZE(map);
    903         if (j > co->co_nlocals)
    904                 j = co->co_nlocals;
    905         if (co->co_nlocals)
    906             dict_to_map(co->co_varnames, j, locals, fast, 0, clear);
    907         ncells = PyTuple_GET_SIZE(co->co_cellvars);
    908         nfreevars = PyTuple_GET_SIZE(co->co_freevars);
    909         if (ncells || nfreevars) {
    910                 dict_to_map(co->co_cellvars, ncells,
    911                             locals, fast + co->co_nlocals, 1, clear);
    912                 /* Same test as in PyFrame_FastToLocals() above. */
    913                 if (co->co_flags & CO_OPTIMIZED) {
    914                         dict_to_map(co->co_freevars, nfreevars,
    915                                 locals, fast + co->co_nlocals + ncells, 1,
    916                                 clear);
    917                 }
    918         }
    919         PyErr_Restore(error_type, error_value, error_traceback);
     924    /* Merge f->f_locals into fast locals */
     925    PyObject *locals, *map;
     926    PyObject **fast;
     927    PyObject *error_type, *error_value, *error_traceback;
     928    PyCodeObject *co;
     929    Py_ssize_t j;
     930    int ncells, nfreevars;
     931    if (f == NULL)
     932        return;
     933    locals = f->f_locals;
     934    co = f->f_code;
     935    map = co->co_varnames;
     936    if (locals == NULL)
     937        return;
     938    if (!PyTuple_Check(map))
     939        return;
     940    PyErr_Fetch(&error_type, &error_value, &error_traceback);
     941    fast = f->f_localsplus;
     942    j = PyTuple_GET_SIZE(map);
     943    if (j > co->co_nlocals)
     944        j = co->co_nlocals;
     945    if (co->co_nlocals)
     946        dict_to_map(co->co_varnames, j, locals, fast, 0, clear);
     947    ncells = PyTuple_GET_SIZE(co->co_cellvars);
     948    nfreevars = PyTuple_GET_SIZE(co->co_freevars);
     949    if (ncells || nfreevars) {
     950        dict_to_map(co->co_cellvars, ncells,
     951                    locals, fast + co->co_nlocals, 1, clear);
     952        /* Same test as in PyFrame_FastToLocals() above. */
     953        if (co->co_flags & CO_OPTIMIZED) {
     954            dict_to_map(co->co_freevars, nfreevars,
     955                locals, fast + co->co_nlocals + ncells, 1,
     956                clear);
     957        }
     958    }
     959    PyErr_Restore(error_type, error_value, error_traceback);
    920960}
    921961
    … …  
    924964PyFrame_ClearFreeList(void)
    925965{
    926         int freelist_size = numfree;
    927        
    928         while (free_list != NULL) {
    929                 PyFrameObject *f = free_list;
    930                 free_list = free_list->f_back;
    931                 PyObject_GC_Del(f);
    932                 --numfree;
    933         }
    934         assert(numfree == 0);
    935         return freelist_size;
     966    int freelist_size = numfree;
     967
     968    while (free_list != NULL) {
     969        PyFrameObject *f = free_list;
     970        free_list = free_list->f_back;
     971        PyObject_GC_Del(f);
     972        --numfree;
     973    }
     974    assert(numfree == 0);
     975    return freelist_size;
    936976}
    937977
    … …  
    939979PyFrame_Fini(void)
    940980{
    941         (void)PyFrame_ClearFreeList();
    942         Py_XDECREF(builtin_object);
    943         builtin_object = NULL;
    944 }
     981    (void)PyFrame_ClearFreeList();
     982    Py_XDECREF(builtin_object);
     983    builtin_object = NULL;
     984}
Note: See TracChangeset for help on using the changeset viewer.