Ticket #1395: tt1395.2.patch

File tt1395.2.patch, 50.6 KB (added by jimmy, 5 years ago)
  • src/pmc/addrregistry.pmc

     
    7373        Hash       *hash; 
    7474        const void *value; 
    7575 
    76         GET_ATTR_hash(interp, SELF, hash); 
     76        GET_ATTR_hash(INTERP, SELF, hash); 
    7777        value = parrot_hash_get(INTERP, hash, key); 
    7878 
    7979        if (value) 
     
    8585    VTABLE INTVAL elements() { 
    8686        const Hash *hash; 
    8787 
    88         GET_ATTR_hash(interp, SELF, hash); 
     88        GET_ATTR_hash(INTERP, SELF, hash); 
    8989 
    9090        return parrot_hash_size(INTERP, hash); 
    9191    } 
     
    9393    VTABLE INTVAL get_bool() { 
    9494        const Hash *hash; 
    9595 
    96         GET_ATTR_hash(interp, SELF, hash); 
     96        GET_ATTR_hash(INTERP, SELF, hash); 
    9797 
    9898        return parrot_hash_size(INTERP, hash) != 0; 
    9999    } 
     
    124124        Hash       *hash; 
    125125        UNUSED(value); 
    126126 
    127         GET_ATTR_hash(interp, SELF, hash); 
     127        GET_ATTR_hash(INTERP, SELF, hash); 
    128128 
    129129        oldval = parrot_hash_get(INTERP, hash, key); 
    130130 
     
    136136 
    137137    VTABLE void set_integer_keyed(PMC *key, INTVAL value) { 
    138138        Hash *hash; 
    139         GET_ATTR_hash(interp, SELF, hash); 
     139        GET_ATTR_hash(INTERP, SELF, hash); 
    140140        parrot_hash_put(INTERP, hash, key, (void *)value); 
    141141    } 
    142142 
     
    144144        Hash       *hash; 
    145145        void       *value; 
    146146 
    147         GET_ATTR_hash(interp, SELF, hash); 
     147        GET_ATTR_hash(INTERP, SELF, hash); 
    148148        value = parrot_hash_get(INTERP, hash, key); 
    149149 
    150150        /* these casts look bad, but they avoid type punning warnings with -O */ 
  • src/pmc/array.pmc

     
    151151        const INTVAL size = VTABLE_elements(INTERP, other); 
    152152        INTVAL       i; 
    153153 
    154         SELF.set_integer_native(size); 
     154        SELF.set_integer_native(size); 
    155155        for (i = 0; i < size; i++) { 
    156156            PMC * const elem = VTABLE_get_pmc_keyed_int(INTERP, other, i); 
    157             SELF.set_pmc_keyed_int(i, elem); 
     157            SELF.set_pmc_keyed_int(i, elem); 
    158158        } 
    159159    } 
    160160 
     
    170170*/ 
    171171 
    172172    VTABLE void set_pmc(PMC *other) { 
    173         SELF.assign_pmc(other); 
     173        SELF.assign_pmc(other); 
    174174    } 
    175175 
    176176/* 
     
    220220*/ 
    221221 
    222222    VTABLE INTVAL get_integer() { 
    223         return SELF.elements(); 
     223        return SELF.elements(); 
    224224    } 
    225225 
    226226/* 
     
    234234*/ 
    235235 
    236236    VTABLE INTVAL get_bool() { 
    237         const INTVAL size = SELF.elements(); 
    238         return (INTVAL)(size != 0); 
     237        return (INTVAL)(SELF.elements() != 0); 
    239238    } 
    240239 
    241240/* 
     
    292291*/ 
    293292 
    294293    VTABLE INTVAL get_integer_keyed_int(INTVAL key) { 
    295         PMC * const value = SELF.get_pmc_keyed_int(key); 
     294        PMC * const value = SELF.get_pmc_keyed_int(key); 
    296295 
    297296        return VTABLE_get_integer(INTERP, value); 
    298297    } 
     
    318317        nextkey = key_next(INTERP, key); 
    319318 
    320319        if (!nextkey) 
    321             return SELF.get_integer_keyed_int(ix); 
     320            return SELF.get_integer_keyed_int(ix); 
    322321 
    323         box = SELF.get_pmc_keyed_int(ix); 
     322        box = SELF.get_pmc_keyed_int(ix); 
    324323 
    325324        if (!box) 
    326325            box = undef(INTERP); 
     
    339338*/ 
    340339 
    341340    VTABLE FLOATVAL get_number_keyed_int(INTVAL key) { 
    342         PMC * const value = SELF.get_pmc_keyed_int(key); 
     341        PMC * const value = SELF.get_pmc_keyed_int(key); 
    343342 
    344343        return VTABLE_get_number(INTERP, value); 
    345344 
     
    366365        nextkey = key_next(INTERP, key); 
    367366 
    368367        if (!nextkey) 
    369             return SELF.get_number_keyed_int(ix); 
     368            return SELF.get_number_keyed_int(ix); 
    370369 
    371         box = SELF.get_pmc_keyed_int(ix); 
     370        box = SELF.get_pmc_keyed_int(ix); 
    372371 
    373372        if (!box) 
    374373            box = undef(INTERP); 
     
    387386*/ 
    388387 
    389388    VTABLE STRING *get_string_keyed_int(INTVAL key) { 
    390         PMC * const value = SELF.get_pmc_keyed_int(key); 
     389        PMC * const value = SELF.get_pmc_keyed_int(key); 
    391390 
    392391        return VTABLE_get_string(INTERP, value); 
    393392    } 
     
    413412        nextkey = key_next(INTERP, key); 
    414413 
    415414        if (!nextkey) 
    416             return SELF.get_string_keyed_int(ix); 
     415            return SELF.get_string_keyed_int(ix); 
    417416 
    418         box = SELF.get_pmc_keyed_int(ix); 
     417        box = SELF.get_pmc_keyed_int(ix); 
    419418 
    420419        if (!box) 
    421420            box = undef(INTERP); 
     
    434433*/ 
    435434 
    436435    VTABLE PMC *get_pmc_keyed_int(INTVAL key) { 
    437  
    438436        return retval(INTERP, 
    439437            Parrot_pmc_array_get(INTERP, (List *)PMC_data(SELF), key, enum_type_PMC)); 
    440438    } 
     
    460458        nextkey = key_next(INTERP, key); 
    461459 
    462460        if (!nextkey) 
    463             return SELF.get_pmc_keyed_int(ix); 
     461            return SELF.get_pmc_keyed_int(ix); 
    464462 
    465         box = SELF.get_pmc_keyed_int(ix); 
     463        box = SELF.get_pmc_keyed_int(ix); 
    466464 
    467465        if (!box) 
    468466            box = undef(INTERP); 
     
    536534        nextkey = key_next(INTERP, key); 
    537535 
    538536        if (!nextkey) { 
    539             SELF.set_integer_keyed_int(ix, value); 
     537            SELF.set_integer_keyed_int(ix, value); 
    540538            return; 
    541539        } 
    542540 
    543         box = SELF.get_pmc_keyed_int(ix); 
     541        box = SELF.get_pmc_keyed_int(ix); 
    544542 
    545543        /* autovivify an Array */ 
    546544        if (!box) 
     
    587585        nextkey = key_next(INTERP, key); 
    588586 
    589587        if (!nextkey) { 
    590             SELF.set_number_keyed_int(ix, value); 
     588            SELF.set_number_keyed_int(ix, value); 
    591589            return; 
    592590        } 
    593591 
    594         box = SELF.get_pmc_keyed_int(ix); 
     592        box = SELF.get_pmc_keyed_int(ix); 
    595593 
    596594        /* autovivify an Array */ 
    597595        if (!box) 
     
    642640            return; 
    643641        } 
    644642 
    645         box = SELF.get_pmc_keyed_int(ix); 
     643        box = SELF.get_pmc_keyed_int(ix); 
    646644 
    647645        /* autovivify an Array */ 
    648646        if (!box) 
     
    693691            return; 
    694692        } 
    695693 
    696         box = SELF.get_pmc_keyed_int(ix); 
     694        box = SELF.get_pmc_keyed_int(ix); 
    697695 
    698696        /* autovivify an Array */ 
    699697        if (!box) 
     
    714712*/ 
    715713 
    716714    VTABLE void push_integer(INTVAL value) { 
    717         const INTVAL nextix = SELF.elements(); 
    718         SELF.set_integer_keyed_int(nextix, value); 
     715        const INTVAL nextix = SELF.elements(); 
     716        SELF.set_integer_keyed_int(nextix, value); 
    719717    } 
    720718 
    721719/* 
     
    730728*/ 
    731729 
    732730    VTABLE void push_float(FLOATVAL value) { 
    733         const INTVAL nextix = SELF.elements(); 
    734         SELF.set_number_keyed_int(nextix, value); 
     731        const INTVAL nextix = SELF.elements(); 
     732        SELF.set_number_keyed_int(nextix, value); 
    735733    } 
    736734 
    737735/* 
     
    746744*/ 
    747745 
    748746    VTABLE void push_string(STRING *value) { 
    749         const INTVAL nextix = SELF.elements(); 
    750         SELF.set_string_keyed_int(nextix, value); 
     747        const INTVAL nextix = SELF.elements(); 
     748        SELF.set_string_keyed_int(nextix, value); 
    751749    } 
    752750 
    753751/* 
     
    762760*/ 
    763761 
    764762    VTABLE void push_pmc(PMC *value) { 
    765         const INTVAL nextix = SELF.elements(); 
    766         SELF.set_pmc_keyed_int(nextix, value); 
     763        const INTVAL nextix = SELF.elements(); 
     764        SELF.set_pmc_keyed_int(nextix, value); 
    767765    } 
    768766 
    769767/* 
     
    845843*/ 
    846844 
    847845    VTABLE INTVAL pop_integer() { 
    848         PMC * const ptr = SELF.pop_pmc(); 
     846        PMC * const ptr = SELF.pop_pmc(); 
    849847        return VTABLE_get_integer(INTERP, ptr); 
    850848    } 
    851849 
     
    860858*/ 
    861859 
    862860    VTABLE FLOATVAL pop_float() { 
    863         PMC * const ptr = SELF.pop_pmc(); 
     861        PMC * const ptr = SELF.pop_pmc(); 
    864862        return VTABLE_get_number(INTERP, ptr); 
    865863    } 
    866864 
     
    875873*/ 
    876874 
    877875    VTABLE STRING *pop_string() { 
    878         PMC * const ptr = SELF.pop_pmc(); 
     876        PMC * const ptr = SELF.pop_pmc(); 
    879877        return VTABLE_get_string(INTERP, ptr); 
    880878    } 
    881879 
     
    905903*/ 
    906904 
    907905    VTABLE INTVAL shift_integer() { 
    908         PMC * const ptr = SELF.shift_pmc(); 
     906        PMC * const ptr = SELF.shift_pmc(); 
    909907        return VTABLE_get_integer(INTERP, ptr); 
    910908    } 
    911909 
     
    920918*/ 
    921919 
    922920    VTABLE FLOATVAL shift_float() { 
    923         PMC * const ptr = SELF.shift_pmc(); 
     921        PMC * const ptr = SELF.shift_pmc(); 
    924922        return VTABLE_get_number(INTERP, ptr); 
    925923    } 
    926924 
     
    935933*/ 
    936934 
    937935    VTABLE STRING *shift_string() { 
    938         PMC * const ptr = SELF.shift_pmc(); 
     936        PMC * const ptr = SELF.shift_pmc(); 
    939937        return VTABLE_get_string(INTERP, ptr); 
    940938    } 
    941939 
     
    10201018        PMC * const  nextkey = key_next(INTERP, key); 
    10211019 
    10221020        if (!nextkey) 
    1023             return SELF.defined_keyed_int(ix); 
     1021            return SELF.defined_keyed_int(ix); 
    10241022 
    1025         box = SELF.get_pmc_keyed_int(ix); 
     1023        box = SELF.get_pmc_keyed_int(ix); 
    10261024 
    10271025        if (!box) 
    10281026            return 0; 
     
    10671065        PMC * const  nextkey = key_next(INTERP, key); 
    10681066 
    10691067        if (!nextkey) 
    1070             return SELF.exists_keyed_int(ix); 
     1068            return SELF.exists_keyed_int(ix); 
    10711069 
    1072         box = SELF.get_pmc_keyed_int(ix); 
     1070        box = SELF.get_pmc_keyed_int(ix); 
    10731071 
    10741072        if (!box) 
    10751073            return 0; 
     
    11221120        if (value->vtable->base_type != enum_class_Array) 
    11231121            return 0; 
    11241122 
    1125         n = SELF.elements(); 
     1123        n = SELF.elements(); 
    11261124 
    11271125        if (VTABLE_elements(INTERP, value) != n) 
    11281126            return 0; 
    11291127 
    11301128        for (j = 0; j < n; ++j) { 
    1131             PMC * const item1 = SELF.get_pmc_keyed_int(j); 
     1129            PMC * const item1 = SELF.get_pmc_keyed_int(j); 
    11321130            PMC * const item2 = VTABLE_get_pmc_keyed_int(INTERP, value, j); 
    11331131 
    11341132            if (item1 != item2) { 
     
    11461144 
    11471145=item C<PMC *get_iter()> 
    11481146 
    1149 Return a new iterator for SELF. 
     1147Return a new iterator for SELF. 
    11501148 
    11511149=cut 
    11521150 
     
    12041202 
    12051203        SUPER(info); 
    12061204        if (info->extra_flags == EXTRA_IS_NULL) { 
    1207             SELF.set_integer_native(VTABLE_shift_integer(INTERP, io)); 
     1205            SELF.set_integer_native(VTABLE_shift_integer(INTERP, io)); 
    12081206    } 
    12091207} 
    12101208 
     
    12181216 
    12191217*/ 
    12201218    VTABLE PMC *share_ro() { 
    1221         PMC *_true, *ret; 
     1219        PMC * const _true = pmc_new(INTERP, enum_class_Integer); 
     1220        PMC * const ret        = pt_shared_fixup(INTERP, SELF); 
    12221221 
    12231222        /* prevent infinite recursion */ 
    12241223        if (PObj_is_PMC_shared_TEST(SELF)) 
    12251224            Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION, 
    12261225                    "share_ro on something that already is shared"); 
    12271226 
    1228         _true = pmc_new(INTERP, enum_class_Integer); 
     1227         
    12291228        VTABLE_set_integer_native(INTERP, _true, 1); 
    12301229 
    1231         ret   = pt_shared_fixup(INTERP, SELF); 
    1232  
    12331230        /* first set readonly */ 
    12341231        VTABLE_setprop(INTERP, ret, CONST_STRING(INTERP, "_ro"), _true); 
    12351232 
  • src/pmc/arrayiterator.pmc

     
    8686 
    8787    VTABLE void init_pmc(PMC *array) { 
    8888 
    89         SET_ATTR_array(interp, SELF, array); 
     89        SET_ATTR_array(INTERP, SELF, array); 
    9090 
    9191        PObj_custom_mark_SET(SELF); 
    9292 
     
    124124        PMC   *array; 
    125125        PMC   *clone; 
    126126 
    127         GET_ATTR_array(interp, SELF, array); 
    128         GET_ATTR_pos(interp, SELF, pos); 
    129         GET_ATTR_reverse(interp, SELF, reverse); 
     127        GET_ATTR_array(INTERP, SELF, array); 
     128        GET_ATTR_pos(INTERP, SELF, pos); 
     129        GET_ATTR_reverse(INTERP, SELF, reverse); 
    130130 
    131131        clone = pmc_new_init(INTERP, enum_class_ArrayIterator, array); 
    132132 
    133         SET_ATTR_pos(interp, clone, pos); 
    134         SET_ATTR_reverse(interp, clone, reverse); 
     133        SET_ATTR_pos(INTERP, clone, pos); 
     134        SET_ATTR_reverse(INTERP, clone, reverse); 
    135135 
    136136        return clone; 
    137137    } 
     
    163163    VTABLE INTVAL elements() { 
    164164        INTVAL reverse, pos, length; 
    165165 
    166         GET_ATTR_reverse(interp, SELF, reverse); 
     166        GET_ATTR_reverse(INTERP, SELF, reverse); 
    167167 
    168168        if (reverse) { 
    169             GET_ATTR_pos(interp, SELF, pos); 
     169            GET_ATTR_pos(INTERP, SELF, pos); 
    170170            return pos; 
    171171        } 
    172172        else { 
    173             GET_ATTR_length(interp, SELF, length); 
    174             GET_ATTR_pos(interp, SELF, pos); 
     173            GET_ATTR_length(INTERP, SELF, length); 
     174            GET_ATTR_pos(INTERP, SELF, pos); 
    175175            return length - pos; 
    176176        } 
    177177    } 
     
    197197        PMC *array; 
    198198 
    199199        if (value == ITERATE_FROM_START) { 
    200             GET_ATTR_array(interp, SELF, array); 
    201             SET_ATTR_reverse(interp, SELF, 0); 
    202             SET_ATTR_pos(interp, SELF, 0); 
    203             SET_ATTR_length(interp, SELF, VTABLE_elements(INTERP, array)); 
     200            GET_ATTR_array(INTERP, SELF, array); 
     201            SET_ATTR_reverse(INTERP, SELF, 0); 
     202            SET_ATTR_pos(INTERP, SELF, 0); 
     203            SET_ATTR_length(INTERP, SELF, VTABLE_elements(INTERP, array)); 
    204204        } 
    205205        else if (value == ITERATE_FROM_END) { 
    206206            INTVAL element; 
    207             GET_ATTR_array(interp, SELF, array); 
     207            GET_ATTR_array(INTERP, SELF, array); 
    208208            element = VTABLE_elements(INTERP, array); 
    209             SET_ATTR_reverse(interp, SELF, 1); 
    210             SET_ATTR_length(interp, SELF, element); 
    211             SET_ATTR_pos(interp, SELF, element); 
     209            SET_ATTR_reverse(INTERP, SELF, 1); 
     210            SET_ATTR_length(INTERP, SELF, element); 
     211            SET_ATTR_pos(INTERP, SELF, element); 
    212212        } 
    213213        else 
    214214            Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION, 
  • src/pmc/bigint.pmc

     
    761761    } 
    762762 
    763763    VTABLE STRING *get_repr() { 
    764         STRING * const s = SELF.get_string(); 
     764        STRING * const s = SELF.get_string(); 
    765765        return Parrot_str_append(INTERP, s, CONST_STRING(INTERP, "L")); 
    766766    } 
    767767/* 
  • src/pmc/bignum.pmc

     
    10201020    } 
    10211021 
    10221022    VTABLE STRING *get_repr() { 
    1023         STRING *s = SELF.get_string(); 
     1023        STRING *s = SELF.get_string(); 
    10241024        return Parrot_str_append(INTERP, s, Parrot_str_new(interp, "N", 1)); 
    10251025    } 
    10261026/* 
  • src/pmc/boolean.pmc

     
    3434*/ 
    3535    VTABLE void init_pmc(PMC *value) { 
    3636        if (!PMC_IS_NULL(value)) { 
    37             SELF.set_bool(VTABLE_get_bool(INTERP, value)); 
     37            SELF.set_bool(VTABLE_get_bool(INTERP, value)); 
    3838        } 
    3939        else { 
    40             SELF.set_bool(0); 
     40            SELF.set_bool(0); 
    4141        } 
    4242    } 
    4343/* 
     
    7171 
    7272 
    7373    VTABLE void set_bool(INTVAL value) { 
    74         SELF.set_integer_native(value); 
     74        SELF.set_integer_native(value); 
    7575    } 
    7676 
    7777/* 
     
    8585*/ 
    8686 
    8787    VTABLE void set_number_native(FLOATVAL value) { 
    88         SELF.set_bool(!FLOAT_IS_ZERO(value)); 
     88        SELF.set_bool(!FLOAT_IS_ZERO(value)); 
    8989    } 
    9090 
    9191/* 
     
    9999*/ 
    100100 
    101101    VTABLE void set_string_native(STRING *value) { 
    102         SELF.set_bool(Parrot_str_boolean(INTERP, value)); 
     102        SELF.set_bool(Parrot_str_boolean(INTERP, value)); 
    103103    } 
    104104} 
    105105 
  • src/pmc/callcontext.pmc

     
    173173static Pcc_cell * 
    174174get_cell_at(PARROT_INTERP, ARGIN(PMC *SELF), INTVAL key) 
    175175{ 
    176     INTVAL    i, num_positionals; 
     176    INTVAL    num_positionals; 
    177177    Pcc_cell *cell; 
    178178 
    179179    GETATTR_CallContext_num_positionals(interp, SELF, num_positionals); 
     
    337337static void 
    338338mark_hash(PARROT_INTERP, ARGIN(Hash *h)) 
    339339{ 
    340     UINTVAL entries = h->entries; 
    341340    INTVAL  i; 
    342341 
    343342    for (i = h->mask; i >= 0; --i) { 
     
    469468 
    470469*/ 
    471470    VTABLE void mark() { 
    472         Hash     *hash; 
    473         STRING   *short_sig; 
    474         Pcc_cell *positionals; 
    475         INTVAL    num_positionals; 
    476         PMC      *arg_flags, *type_tuple, *return_flags, *tmp; 
    477         UINTVAL   i; 
    478         UINTVAL  *n_regs_used; 
    479         Regs_ps   bp_ps; 
     471        UINTVAL        i; 
     472        const UINTVAL *n_regs_used; 
     473        INTVAL         num_positionals; 
     474        STRING        *short_sig; 
     475        PMC          *tmp; 
     476        Hash          *hash; 
     477        Regs_ps        bp_ps; 
     478        Pcc_cell      *positionals; 
    480479 
    481480        if (!PMC_data(SELF)) 
    482481            return; 
    483482 
    484         GET_ATTR_type_tuple(INTERP, SELF, type_tuple); 
    485         GET_ATTR_short_sig(INTERP, SELF, short_sig); 
    486         GET_ATTR_arg_flags(INTERP, SELF, arg_flags); 
    487         GET_ATTR_return_flags(INTERP, SELF, return_flags); 
    488483        GET_ATTR_num_positionals(INTERP, SELF, num_positionals); 
    489484        GET_ATTR_positionals(INTERP, SELF, positionals); 
    490         GET_ATTR_hash(INTERP, SELF, hash); 
    491485 
    492         Parrot_gc_mark_PMC_alive(INTERP, type_tuple); 
    493         Parrot_gc_mark_STRING_alive(INTERP, short_sig); 
    494         Parrot_gc_mark_PMC_alive(INTERP, arg_flags); 
    495         Parrot_gc_mark_PMC_alive(INTERP, return_flags); 
    496  
    497486        if (num_positionals) 
    498487            mark_positionals(INTERP, positionals); 
    499488 
     489        GET_ATTR_hash(INTERP, SELF, hash); 
     490 
    500491        if (hash) 
    501492            mark_hash(INTERP, hash); 
    502493 
     494        GET_ATTR_short_sig(INTERP, SELF, short_sig); 
     495        Parrot_gc_mark_STRING_alive(INTERP, short_sig); 
     496 
     497        GET_ATTR_type_tuple(INTERP, SELF, tmp); 
     498        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
     499 
     500        GET_ATTR_arg_flags(INTERP, SELF, tmp); 
     501        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
     502 
     503        GET_ATTR_return_flags(INTERP, SELF, tmp); 
     504        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
     505 
    503506        GET_ATTR_caller_ctx(INTERP, SELF, tmp); 
    504507        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
    505508 
     
    530533        GET_ATTR_current_sig(INTERP, SELF, tmp); 
    531534        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
    532535 
     536 
    533537        GET_ATTR_n_regs_used(INTERP, SELF, n_regs_used); 
     538 
    534539        if (!n_regs_used) 
    535540            return; 
    536541 
    537542        GET_ATTR_bp_ps(INTERP, SELF, bp_ps); 
     543 
    538544        for (i = 0; i < n_regs_used[REGNO_PMC]; ++i) { 
    539545            PMC *p = bp_ps.regs_p[-1L-(i)]; 
    540546            /* Original code from CTX_REG_PMC */ 
    541547            if (p) 
    542                 Parrot_gc_mark_PMC_alive(interp, p); 
     548                Parrot_gc_mark_PMC_alive(INTERP, p); 
    543549        } 
    544550 
    545551        for (i = 0; i < n_regs_used[REGNO_STR]; ++i) { 
    546552            STRING *s = bp_ps.regs_s[i]; 
    547553            if (s) 
    548                 Parrot_gc_mark_STRING_alive(interp, s); 
     554                Parrot_gc_mark_STRING_alive(INTERP, s); 
    549555        } 
    550556 
    551557    } 
     
    737743*/ 
    738744 
    739745    VTABLE void set_attr_str(STRING *key, PMC *value) { 
    740  
    741746        if (Parrot_str_equal(INTERP, key, CONST_STRING(INTERP, "arg_flags"))) { 
    742747            SET_ATTR_arg_flags(INTERP, SELF, value); 
    743748        } 
     
    874879    } 
    875880 
    876881    VTABLE void push_integer(INTVAL value) { 
    877         Pcc_cell *cell = CREATE_INTVAL_CELL(INTERP); 
     882        Pcc_cell * const cell = CREATE_INTVAL_CELL(INTERP); 
    878883        APPEND_CELL(INTERP, SELF, cell); 
    879884        CELL_INT(cell) = value; 
    880885    } 
    881886 
    882887    VTABLE void push_float(FLOATVAL value) { 
    883         Pcc_cell *cell = CREATE_FLOATVAL_CELL(INTERP); 
     888        Pcc_cell * const cell = CREATE_FLOATVAL_CELL(INTERP); 
    884889        APPEND_CELL(INTERP, SELF, cell); 
    885890        CELL_FLOAT(cell) = value; 
    886891    } 
    887892 
    888893    VTABLE void push_string(STRING *value) { 
    889         Pcc_cell *cell = CREATE_STRING_CELL(INTERP); 
     894        Pcc_cell * const cell = CREATE_STRING_CELL(INTERP); 
    890895        APPEND_CELL(INTERP, SELF, cell); 
    891896        CELL_STRING(cell) = value; 
    892897    } 
    893898 
    894899    VTABLE void push_pmc(PMC *value) { 
    895         Pcc_cell *cell = CREATE_PMC_CELL(INTERP); 
     900        Pcc_cell * const cell = CREATE_PMC_CELL(INTERP); 
    896901        APPEND_CELL(INTERP, SELF, cell); 
    897902        CELL_PMC(cell) = value; 
    898903    } 
    899904 
    900905    VTABLE INTVAL pop_integer() { 
    901         Pcc_cell *cell = pop_cell(INTERP, SELF); 
     906        Pcc_cell * const cell = pop_cell(INTERP, SELF); 
    902907 
    903908        if (cell) { 
    904             INTVAL result = autobox_intval(INTERP, cell); 
     909            const INTVAL result = autobox_intval(INTERP, cell); 
    905910            FREE_CELL(INTERP, cell); 
    906911            return result; 
    907912        } 
     
    910915    } 
    911916 
    912917    VTABLE FLOATVAL pop_float() { 
    913         Pcc_cell *cell = pop_cell(INTERP, SELF); 
     918        Pcc_cell * const cell = pop_cell(INTERP, SELF); 
    914919 
    915920        if (cell) { 
    916             FLOATVAL result = autobox_floatval(INTERP, cell); 
     921            const FLOATVAL result = autobox_floatval(INTERP, cell); 
    917922            FREE_CELL(INTERP, cell); 
    918923            return result; 
    919924        } 
     
    922927    } 
    923928 
    924929    VTABLE PMC * pop_pmc() { 
    925         Pcc_cell *cell = pop_cell(INTERP, SELF); 
     930        Pcc_cell * const cell = pop_cell(INTERP, SELF); 
    926931 
    927932        if (cell) { 
    928             PMC *result = autobox_pmc(INTERP, cell); 
     933            PMC * const result = autobox_pmc(INTERP, cell); 
    929934            FREE_CELL(INTERP, cell); 
    930935            return result; 
    931936        } 
     
    934939    } 
    935940 
    936941    VTABLE STRING * pop_string() { 
    937         Pcc_cell *cell = pop_cell(INTERP, SELF); 
     942        Pcc_cell * const cell = pop_cell(INTERP, SELF); 
    938943 
    939944        if (cell) { 
    940             STRING *result = autobox_string(INTERP, cell); 
     945            STRING * const result = autobox_string(INTERP, cell); 
    941946            FREE_CELL(INTERP, cell); 
    942947            return result; 
    943948        } 
     
    946951    } 
    947952 
    948953    VTABLE INTVAL get_integer_keyed_int(INTVAL key) { 
    949         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     954        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    950955 
    951956        if (!cell) 
    952957            return 0; 
     
    955960    } 
    956961 
    957962    VTABLE FLOATVAL get_number_keyed_int(INTVAL key) { 
    958         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     963        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    959964 
    960965        if (!cell) 
    961966            return 0.0; 
     
    964969    } 
    965970 
    966971    VTABLE STRING * get_string_keyed_int(INTVAL key) { 
    967         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     972        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    968973 
    969974        if (!cell) 
    970975            return NULL; 
     
    982987    } 
    983988 
    984989    VTABLE void unshift_integer(INTVAL value) { 
    985         Pcc_cell *cell = CREATE_INTVAL_CELL(INTERP); 
     990        Pcc_cell * const cell = CREATE_INTVAL_CELL(INTERP); 
    986991        PREPEND_CELL(INTERP, SELF, cell); 
    987992        CELL_INT(cell) = value; 
    988993    } 
    989994 
    990995    VTABLE void unshift_float(FLOATVAL value) { 
    991         Pcc_cell *cell = CREATE_FLOATVAL_CELL(INTERP); 
     996        Pcc_cell * const cell = CREATE_FLOATVAL_CELL(INTERP); 
    992997        PREPEND_CELL(INTERP, SELF, cell); 
    993998        CELL_FLOAT(cell) = value; 
    994999    } 
    9951000 
    9961001    VTABLE void unshift_string(STRING *value) { 
    997         Pcc_cell *cell = CREATE_STRING_CELL(INTERP); 
     1002        Pcc_cell * const cell = CREATE_STRING_CELL(INTERP); 
    9981003        PREPEND_CELL(INTERP, SELF, cell); 
    9991004        CELL_STRING(cell) = value; 
    10001005    } 
     
    10061011    } 
    10071012 
    10081013    VTABLE INTVAL shift_integer() { 
    1009         Pcc_cell *cell = shift_cell(INTERP, SELF); 
     1014        Pcc_cell * const cell = shift_cell(INTERP, SELF); 
    10101015 
    10111016        if (cell) { 
    1012             INTVAL result = autobox_intval(INTERP, cell); 
     1017            const INTVAL result = autobox_intval(INTERP, cell); 
    10131018            FREE_CELL(INTERP, cell); 
    10141019            return result; 
    10151020        } 
     
    10211026        Pcc_cell *cell = shift_cell(INTERP, SELF); 
    10221027 
    10231028        if (cell) { 
    1024             FLOATVAL result = autobox_floatval(INTERP, cell); 
     1029            const FLOATVAL result = autobox_floatval(INTERP, cell); 
    10251030            FREE_CELL(INTERP, cell); 
    10261031            return result; 
    10271032        } 
     
    10301035    } 
    10311036 
    10321037    VTABLE STRING * shift_string() { 
    1033         Pcc_cell *cell = shift_cell(INTERP, SELF); 
     1038        Pcc_cell * const cell = shift_cell(INTERP, SELF); 
    10341039 
    10351040        if (cell) { 
    1036             STRING *result = autobox_string(INTERP, cell); 
     1041            STRING * const result = autobox_string(INTERP, cell); 
    10371042            FREE_CELL(INTERP, cell); 
    10381043            return result; 
    10391044        } 
     
    10421047    } 
    10431048 
    10441049    VTABLE PMC * shift_pmc() { 
    1045         Pcc_cell *cell = shift_cell(INTERP, SELF); 
     1050        Pcc_cell * const cell = shift_cell(INTERP, SELF); 
    10461051 
    10471052        if (cell) { 
    1048             PMC *result = autobox_pmc(INTERP, cell); 
     1053            PMC * const result = autobox_pmc(INTERP, cell); 
    10491054            FREE_CELL(INTERP, cell); 
    10501055            return result; 
    10511056        } 
     
    10541059    } 
    10551060 
    10561061    VTABLE void set_integer_keyed_int(INTVAL key, INTVAL value) { 
    1057         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     1062        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    10581063 
    10591064        if (!cell) { 
    10601065            INTVAL num_positionals; 
     
    10721077    } 
    10731078 
    10741079    VTABLE void set_number_keyed_int(INTVAL key, FLOATVAL value) { 
    1075         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     1080        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    10761081 
    10771082        if (!cell) { 
    10781083            INTVAL num_positionals; 
     
    10901095    } 
    10911096 
    10921097    VTABLE void set_string_keyed_int(INTVAL key, STRING *value) { 
    1093         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     1098        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    10941099 
    10951100        if (!cell) { 
    10961101            INTVAL num_positionals; 
     
    11081113    } 
    11091114 
    11101115    VTABLE void set_pmc_keyed_int(INTVAL key, PMC *value) { 
    1111         Pcc_cell *cell = get_cell_at(INTERP, SELF, key); 
     1116        Pcc_cell * const cell = get_cell_at(INTERP, SELF, key); 
    11121117 
    11131118        if (!cell) { 
    11141119            INTVAL num_positionals; 
     
    11261131    } 
    11271132 
    11281133    VTABLE void set_integer_keyed_str(STRING *key, INTVAL value) { 
    1129         Hash     *hash = get_hash(INTERP, SELF); 
    1130         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
     1134        Hash     * const hash = get_hash(INTERP, SELF); 
     1135        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
    11311136 
    11321137        if (!cell) { 
    11331138            cell = CREATE_INTVAL_CELL(INTERP); 
     
    11411146    } 
    11421147 
    11431148    VTABLE void set_number_keyed_str(STRING *key, FLOATVAL value) { 
    1144         Hash     *hash = get_hash(INTERP, SELF); 
    1145         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
     1149        Hash     * const hash = get_hash(INTERP, SELF); 
     1150        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
    11461151 
    11471152        if (!cell) { 
    11481153            cell = CREATE_FLOATVAL_CELL(INTERP); 
     
    11561161    } 
    11571162 
    11581163    VTABLE void set_string_keyed_str(STRING *key, STRING *value) { 
    1159         Hash     *hash = get_hash(INTERP, SELF); 
    1160         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
     1164        Hash     * const hash = get_hash(INTERP, SELF); 
     1165        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
    11611166 
    11621167        if (!cell) { 
    11631168            cell = CREATE_STRING_CELL(INTERP); 
     
    11711176    } 
    11721177 
    11731178    VTABLE void set_pmc_keyed_str(STRING *key, PMC *value) { 
    1174         Hash     *hash = get_hash(INTERP, SELF); 
    1175         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
     1179        Hash     * const hash = get_hash(INTERP, SELF); 
     1180        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, (void *)key); 
    11761181 
    11771182        if (!cell) { 
    11781183            cell = CREATE_PMC_CELL(INTERP); 
     
    11861191    } 
    11871192 
    11881193    VTABLE void set_integer_keyed(PMC *key, INTVAL value) { 
    1189         Hash     *hash = get_hash(INTERP, SELF); 
    1190         void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1191         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1194        Hash     * const hash = get_hash(INTERP, SELF); 
     1195        void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1196        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    11921197 
    11931198        if (!cell) { 
    11941199            cell = CREATE_INTVAL_CELL(INTERP); 
     
    12021207    } 
    12031208 
    12041209    VTABLE void set_number_keyed(PMC *key, FLOATVAL value) { 
    1205         Hash     *hash = get_hash(INTERP, SELF); 
    1206         void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1207         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1210        Hash     * const hash = get_hash(INTERP, SELF); 
     1211        void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1212        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    12081213 
    12091214        if (!cell) { 
    12101215            cell = CREATE_FLOATVAL_CELL(INTERP); 
     
    12181223    } 
    12191224 
    12201225    VTABLE void set_string_keyed(PMC *key, STRING *value) { 
    1221         Hash     *hash = get_hash(INTERP, SELF); 
    1222         void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1223         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1226        Hash     * const hash = get_hash(INTERP, SELF); 
     1227        void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1228        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    12241229 
    12251230        if (!cell) { 
    12261231            cell = CREATE_STRING_CELL(INTERP); 
     
    12341239    } 
    12351240 
    12361241    VTABLE void set_pmc_keyed(PMC *key, PMC *value) { 
    1237         Hash     *hash = get_hash(INTERP, SELF); 
    1238         void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1239         Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1242        Hash     * const hash = get_hash(INTERP, SELF); 
     1243        void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1244        Pcc_cell        *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    12401245 
    12411246        if (!cell) { 
    12421247            cell = CREATE_PMC_CELL(INTERP); 
     
    12501255    } 
    12511256 
    12521257    VTABLE INTVAL get_integer_keyed_str(STRING *key) { 
    1253         Hash *hash = get_hash(INTERP, SELF); 
     1258        Hash * const hash = get_hash(INTERP, SELF); 
    12541259 
    12551260        if (hash) { 
    1256             void     *k    = hash_key_from_string(INTERP, hash, key); 
    1257             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1261            void     * const k    = hash_key_from_string(INTERP, hash, key); 
     1262            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    12581263 
    12591264            if (cell) 
    12601265                return autobox_intval(INTERP, cell); 
     
    12641269    } 
    12651270 
    12661271    VTABLE FLOATVAL get_number_keyed_str(STRING *key) { 
    1267         Hash *hash = get_hash(INTERP, SELF); 
     1272        Hash * const hash = get_hash(INTERP, SELF); 
    12681273 
    12691274        if (hash) { 
    1270             void     *k    = hash_key_from_string(INTERP, hash, key); 
    1271             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1275            void     * const k    = hash_key_from_string(INTERP, hash, key); 
     1276            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    12721277 
    12731278            if (cell) 
    12741279                return autobox_floatval(INTERP, cell); 
     
    12791284 
    12801285 
    12811286    VTABLE STRING * get_string_keyed_str(STRING *key) { 
    1282         Hash *hash = get_hash(INTERP, SELF); 
     1287        Hash * const hash = get_hash(INTERP, SELF); 
    12831288 
    12841289        if (hash) { 
    1285             void     *k    = hash_key_from_string(INTERP, hash, key); 
    1286             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1290            void     * const k    = hash_key_from_string(INTERP, hash, key); 
     1291            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    12871292 
    12881293            if (cell) 
    12891294                return autobox_string(INTERP, cell); 
     
    12931298    } 
    12941299 
    12951300    VTABLE PMC * get_pmc_keyed_str(STRING *key) { 
    1296         Hash *hash = get_hash(INTERP, SELF); 
     1301        Hash * const hash = get_hash(INTERP, SELF); 
    12971302 
    12981303        if (hash) { 
    1299             void     *k    = hash_key_from_string(INTERP, hash, key); 
    1300             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1304            void     * const k    = hash_key_from_string(INTERP, hash, key); 
     1305            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    13011306 
    13021307            if (cell) 
    13031308                return autobox_pmc(INTERP, cell); 
     
    13071312    } 
    13081313 
    13091314    VTABLE INTVAL get_integer_keyed(PMC *key) { 
    1310         Hash *hash = get_hash(INTERP, SELF); 
     1315        Hash * const hash = get_hash(INTERP, SELF); 
    13111316 
    13121317        if (hash) { 
    1313             void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1314             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1318            void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1319            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    13151320 
    13161321            if (cell) 
    13171322                return autobox_intval(INTERP, cell); 
     
    13211326    } 
    13221327 
    13231328    VTABLE FLOATVAL get_number_keyed(PMC *key) { 
    1324         Hash *hash = get_hash(INTERP, SELF); 
     1329        Hash * const hash = get_hash(INTERP, SELF); 
    13251330 
    13261331        if (hash) { 
    1327             void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1328             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1332            void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1333            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    13291334 
    13301335            if (cell) 
    13311336                return autobox_floatval(INTERP, cell); 
     
    13351340    } 
    13361341 
    13371342    VTABLE STRING * get_string_keyed(PMC *key) { 
    1338         Hash *hash = get_hash(INTERP, SELF); 
     1343        Hash * const hash = get_hash(INTERP, SELF); 
    13391344 
    13401345        if (hash) { 
    1341             void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1342             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1346            void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1347            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    13431348 
    13441349            if (cell) 
    13451350                return autobox_string(INTERP, cell); 
     
    13491354    } 
    13501355 
    13511356    VTABLE PMC * get_pmc_keyed(PMC *key) { 
    1352         Hash *hash = get_hash(INTERP, SELF); 
     1357        Hash * const hash = get_hash(INTERP, SELF); 
    13531358 
    13541359        if (hash) { 
    1355             void     *k    = hash_key_from_pmc(INTERP, hash, key); 
    1356             Pcc_cell *cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
     1360            void     * const k    = hash_key_from_pmc(INTERP, hash, key); 
     1361            Pcc_cell * const cell = (Pcc_cell *)parrot_hash_get(INTERP, hash, k); 
    13571362 
    13581363            if (cell) 
    13591364                return autobox_pmc(INTERP, cell); 
     
    13631368    } 
    13641369 
    13651370    VTABLE INTVAL exists_keyed(PMC *key) { 
    1366         Hash *hash = get_hash(INTERP, SELF); 
     1371        Hash * const hash = get_hash(INTERP, SELF); 
    13671372 
    13681373        if (hash) { 
    1369             void     *k = hash_key_from_pmc(INTERP, hash, key); 
     1374            void * const k = hash_key_from_pmc(INTERP, hash, key); 
    13701375            return parrot_hash_exists(INTERP, hash, k); 
    13711376        } 
    13721377 
     
    13741379    } 
    13751380 
    13761381    VTABLE INTVAL exists_keyed_str(STRING *key) { 
    1377         Hash *hash = get_hash(INTERP, SELF); 
     1382        Hash * const hash = get_hash(INTERP, SELF); 
    13781383 
    13791384        if (hash) { 
    1380             void     *k = hash_key_from_string(INTERP, hash, key); 
     1385            void * const k = hash_key_from_string(INTERP, hash, key); 
    13811386            return parrot_hash_exists(INTERP, hash, k); 
    13821387        } 
    13831388 
     
    14081413        Pcc_cell    *cell; 
    14091414        STRING      *short_sig; 
    14101415        PMC         *type_tuple, *arg_flags, *return_flags; 
    1411         PMC * const dest = pmc_new(INTERP, SELF->vtable->base_type); 
     1416        PMC * const  dest = pmc_new(INTERP, SELF->vtable->base_type); 
    14121417 
    14131418        GET_ATTR_positionals(INTERP, SELF, cell); 
    14141419 
     
    14351440                CELL_PMC(cloned_cell) = CELL_PMC(cell); 
    14361441                break; 
    14371442              default: 
     1443                cloned_cell = NULL; 
    14381444                break; 
    14391445            } 
    14401446            APPEND_CELL(INTERP, dest, cloned_cell); 
     
    14901496*/ 
    14911497 
    14921498    METHOD backtrace(PMC *resume :optional, INTVAL has_resume :opt_flag) { 
    1493         PMC *result  = pmc_new(interp, enum_class_ResizablePMCArray); 
    1494         PMC *cur_ctx = SELF; 
    1495         Parrot_Continuation_attributes *cont = has_resume ? PMC_cont(resume) : NULL; 
     1499        PMC * const result  = pmc_new(INTERP, enum_class_ResizablePMCArray); 
     1500        PMC        *cur_ctx = SELF; 
    14961501 
    14971502        /* Get starting context, then loop over them. */ 
    14981503        while (cur_ctx) { 
    1499             PMC        *frame       = pmc_new(interp, enum_class_Hash); 
     1504            PMC * const frame       = pmc_new(INTERP, enum_class_Hash); 
    15001505            PMC        *annotations = NULL; 
    1501             Parrot_Sub_attributes *sub; 
    15021506 
    15031507            /* Get sub and put it in the hash. */ 
    1504             PMC *sub_pmc = Parrot_pcc_get_sub(interp, cur_ctx); 
     1508            PMC *sub_pmc = Parrot_pcc_get_sub(INTERP, cur_ctx); 
    15051509 
    15061510            if (!sub_pmc) 
    15071511                sub_pmc = PMCNULL; 
    15081512 
    1509             VTABLE_set_pmc_keyed_str(interp, frame, CONST_STRING(interp, "sub"), sub_pmc); 
     1513            VTABLE_set_pmc_keyed_str(INTERP, frame, CONST_STRING(INTERP, "sub"), sub_pmc); 
    15101514 
    15111515            /* Look up any annotations and put them in the hash. */ 
    15121516            if (!PMC_IS_NULL(sub_pmc)) { 
    1513                 PMC_get_sub(interp, sub_pmc, sub); 
     1517                Parrot_Sub_attributes *sub; 
     1518                Parrot_Continuation_attributes *cont = has_resume ? PMC_cont(resume) : NULL; 
    15141519 
     1520                PMC_get_sub(INTERP, sub_pmc, sub); 
     1521 
    15151522                if (sub->seg->annotations) { 
    1516                     PackFile_ByteCode *seg = sub->seg; 
    1517                     opcode_t          *pc  = cont && cur_ctx == cont->to_ctx 
    1518                                              ? cont->address 
    1519                                              : Parrot_pcc_get_pc(interp, cur_ctx); 
     1523                    PackFile_ByteCode * const seg = sub->seg; 
     1524                    opcode_t          * const pc  = cont && cur_ctx == cont->to_ctx 
     1525                            ? cont->address 
     1526                            : Parrot_pcc_get_pc(INTERP, cur_ctx); 
    15201527 
    1521                     annotations = PackFile_Annotations_lookup(interp, 
     1528                    annotations = PackFile_Annotations_lookup(INTERP, 
    15221529                        seg->annotations, pc - seg->base.data, 
    15231530                        NULL); 
    15241531                } 
    15251532            } 
    15261533 
    15271534            if (!annotations) 
    1528                 annotations = pmc_new(interp, enum_class_Hash); 
     1535                annotations = pmc_new(INTERP, enum_class_Hash); 
    15291536 
    1530             VTABLE_set_pmc_keyed_str(interp, frame, CONST_STRING(interp, "annotations"), annotations); 
     1537            VTABLE_set_pmc_keyed_str(INTERP, frame, CONST_STRING(INTERP, "annotations"), annotations); 
    15311538 
    15321539            /* Push frame and go to next caller. */ 
    1533             VTABLE_push_pmc(interp, result, frame); 
    1534             cur_ctx = Parrot_pcc_get_caller_ctx(interp, cur_ctx); 
     1540            VTABLE_push_pmc(INTERP, result, frame); 
     1541            cur_ctx = Parrot_pcc_get_caller_ctx(INTERP, cur_ctx); 
    15351542        } 
    15361543 
    15371544        RETURN(PMC *result); 
  • src/pmc/capture.pmc

     
    816816*/ 
    817817 
    818818    VTABLE void mark() { 
    819         PMC *array, *hash; 
     819        PMC *tmp; 
    820820 
    821821        if (!PMC_data(SELF)) 
    822822            return; 
    823823 
    824         GET_ATTR_array(INTERP, SELF, array); 
    825         GET_ATTR_hash(INTERP, SELF, hash); 
     824        GET_ATTR_array(INTERP, SELF, tmp); 
     825        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
    826826 
    827         Parrot_gc_mark_PMC_alive(INTERP, array); 
    828         Parrot_gc_mark_PMC_alive(INTERP, hash); 
     827        GET_ATTR_hash(INTERP, SELF, tmp); 
     828        Parrot_gc_mark_PMC_alive(INTERP, tmp); 
    829829    } 
    830830 
    831831/* 
  • src/pmc/codestring.pmc

     
    101101*/ 
    102102 
    103103  METHOD emit(STRING *fmt, PMC *args :slurpy, PMC *hash :slurpy :named) { 
     104    INTVAL         I0, I1; 
     105    INTVAL         pos         = 0; 
     106    INTVAL         replen      = 0; 
    104107    STRING * const percent     = CONST_STRING(INTERP, "%"); 
    105108    STRING * const comma       = CONST_STRING(INTERP, ","); 
    106109    STRING * const comma_space = CONST_STRING(INTERP, ", "); 
    107110    STRING * const newline     = CONST_STRING(INTERP, "\n"); 
    108     STRING *key, *repl, *S0, *S1; 
    109     INTVAL pos          = 0; 
    110     INTVAL replen       = 0; 
    111     INTVAL I0, I1; 
     111    STRING        *key, *repl, *S0, *S1; 
    112112 
    113113    fmt = Parrot_str_new_COW(INTERP, fmt); 
    114114 
  • src/pmc/complex.pmc

     
    233233 
    234234*/ 
    235235    VTABLE opcode_t *invoke(void *next) { 
    236         const int   argcP = REG_INT(interp, 3); 
     236        const int   argcP = REG_INT(INTERP, 3); 
    237237        PMC * const res   = pmc_new(INTERP, enum_class_Complex); 
    238238 
    239239        if (argcP == 1) { 
    240             PMC * const arg = REG_PMC(interp, 5); 
     240            PMC * const arg = REG_PMC(INTERP, 5); 
    241241 
    242242            if (arg->vtable->base_type == enum_class_String) 
    243                 VTABLE_set_string_native(INTERP, res, VTABLE_get_string(interp, arg)); 
     243                VTABLE_set_string_native(INTERP, res, VTABLE_get_string(INTERP, arg)); 
    244244            else 
    245245                SET_ATTR_re(INTERP, res, VTABLE_get_number(INTERP, arg)); 
    246246        } 
    247247        else if (argcP == 2) { 
    248             SET_ATTR_re(INTERP, res, VTABLE_get_number(INTERP, REG_PMC(interp, 5))); 
    249             SET_ATTR_im(INTERP, res, VTABLE_get_number(INTERP, REG_PMC(interp, 6))); 
     248            SET_ATTR_re(INTERP, res, VTABLE_get_number(INTERP, REG_PMC(INTERP, 5))); 
     249            SET_ATTR_im(INTERP, res, VTABLE_get_number(INTERP, REG_PMC(INTERP, 6))); 
    250250        } 
    251251 
    252         REG_PMC(interp, 5) = res; 
     252        REG_PMC(INTERP, 5) = res; 
    253253        return (opcode_t *)next; 
    254254    } 
    255255 
     
    284284    } 
    285285 
    286286    VTABLE void init_pmc(PMC *initializer) { 
    287         const INTVAL arg_type = VTABLE_type(interp, initializer); 
    288         SELF.init(); 
     287        const INTVAL arg_type = VTABLE_type(INTERP, initializer); 
     288        SELF.init(); 
    289289        switch (arg_type) { 
    290290          case enum_class_String: 
    291             SELF.set_string_native(VTABLE_get_string(interp, initializer)); 
     291            SELF.set_string_native(VTABLE_get_string(INTERP, initializer)); 
    292292            break; 
    293293          case enum_class_FixedFloatArray: 
    294294          case enum_class_ResizableFloatArray: 
    295295          case enum_class_FixedIntegerArray: 
    296296          case enum_class_ResizableIntegerArray: 
    297             if (VTABLE_get_integer(interp, initializer) == 2) { 
    298                 FLOATVAL re = VTABLE_get_number_keyed_int(interp, initializer, 0); 
    299                 FLOATVAL im = VTABLE_get_number_keyed_int(interp, initializer, 1); 
     297            if (VTABLE_get_integer(INTERP, initializer) == 2) { 
     298                FLOATVAL re = VTABLE_get_number_keyed_int(INTERP, initializer, 0); 
     299                FLOATVAL im = VTABLE_get_number_keyed_int(INTERP, initializer, 1); 
    300300                SET_ATTR_re(INTERP, SELF, re); 
    301301                SET_ATTR_im(INTERP, SELF, im); 
    302302                break; 
    303303            } 
    304304            /* else let it fall to default */ 
    305305          default: 
    306             if (VTABLE_isa(interp, initializer, CONST_STRING(interp, "String"))) { 
    307                 STRING * s = VTABLE_get_string(interp, initializer); 
    308                 SELF.set_string_native(s); 
     306            if (VTABLE_isa(INTERP, initializer, CONST_STRING(INTERP, "String"))) { 
     307                STRING * s = VTABLE_get_string(INTERP, initializer); 
     308                SELF.set_string_native(s); 
    309309            } 
    310310            else { 
    311                 Parrot_ex_throw_from_c_args(interp, NULL, 
     311                Parrot_ex_throw_from_c_args(INTERP, NULL, 
    312312                        EXCEPTION_INVALID_OPERATION, 
    313313                        "Invalid Complex initializer"); 
    314314            } 
     
    350350*/ 
    351351 
    352352    VTABLE INTVAL get_integer() { 
    353         const FLOATVAL f = SELF.get_number(); 
     353        const FLOATVAL f = SELF.get_number(); 
    354354        return (INTVAL)f; 
    355355    } 
    356356 
     
    397397 
    398398    VTABLE INTVAL get_integer_keyed(PMC *key) { 
    399399        STRING * const s = VTABLE_get_string(INTERP, key); 
    400         return SELF.get_integer_keyed_str(s); 
     400        return SELF.get_integer_keyed_str(s); 
    401401    } 
    402402 
    403403    VTABLE INTVAL get_integer_keyed_str(STRING *key) { 
    404         const FLOATVAL f = SELF.get_number_keyed_str(key); 
     404        const FLOATVAL f = SELF.get_number_keyed_str(key); 
    405405        return (INTVAL)f; 
    406406    } 
    407407 
    408408    VTABLE FLOATVAL get_number_keyed(PMC *key) { 
    409409        STRING * const s = VTABLE_get_string(INTERP, key); 
    410         return SELF.get_number_keyed_str(s); 
     410        return SELF.get_number_keyed_str(s); 
    411411    } 
    412412 
    413413    VTABLE FLOATVAL get_number_keyed_str(STRING *key) { 
     
    419419            GET_ATTR_im(INTERP, SELF, value); 
    420420        } 
    421421        else 
    422             Parrot_ex_throw_from_c_args(interp, NULL, 
     422            Parrot_ex_throw_from_c_args(INTERP, NULL, 
    423423                EXCEPTION_INVALID_OPERATION, "Complex: key is neither 'real' or 'imag'"); 
    424424        return value; 
    425425    } 
    426426 
    427427    VTABLE PMC *get_pmc_keyed(PMC *key) { 
    428         if (VTABLE_isa(interp, key, CONST_STRING(interp, "Integer"))) { 
    429             const INTVAL i = VTABLE_get_integer(interp, key); 
    430             return SELF.get_pmc_keyed_int(i); 
     428        if (VTABLE_isa(INTERP, key, CONST_STRING(INTERP, "Integer"))) { 
     429            const INTVAL i = VTABLE_get_integer(INTERP, key); 
     430            return SELF.get_pmc_keyed_int(i); 
    431431        } 
    432432        else { 
    433433            STRING * const s = VTABLE_get_string(INTERP, key); 
    434             return SELF.get_pmc_keyed_str(s); 
     434            return SELF.get_pmc_keyed_str(s); 
    435435        } 
    436436    } 
    437437 
    438438    VTABLE PMC *get_pmc_keyed_str(STRING *key) { 
    439439        PMC * const    ret = pmc_new(INTERP, enum_class_Float); 
    440         const FLOATVAL val = SELF.get_number_keyed_str(key); 
     440        const FLOATVAL val = SELF.get_number_keyed_str(key); 
    441441        VTABLE_set_number_native(INTERP, ret, val); 
    442442        return ret; 
    443443    } 
     
    454454 
    455455    VTABLE PMC *get_pmc_keyed_int(INTVAL key) { 
    456456        PMC * const    ret = pmc_new(INTERP, enum_class_Float); 
    457         const FLOATVAL val = SELF.get_number_keyed_int(key); 
     457        const FLOATVAL val = SELF.get_number_keyed_int(key); 
    458458        VTABLE_set_number_native(INTERP, ret, val); 
    459459        return ret; 
    460460    } 
     
    486486            GET_ATTR_im(INTERP, SELF, f); 
    487487            break; 
    488488          default: 
    489             Parrot_ex_throw_from_c_args(interp, NULL, 
     489            Parrot_ex_throw_from_c_args(INTERP, NULL, 
    490490                    EXCEPTION_INVALID_OPERATION, "Complex: key must be 0 or 1"); 
    491491        } 
    492492        return f; 
     
    501501            SET_ATTR_im(INTERP, SELF, v); 
    502502            break; 
    503503          default: 
    504             Parrot_ex_throw_from_c_args(interp, NULL, 
     504            Parrot_ex_throw_from_c_args(INTERP, NULL, 
    505505                    EXCEPTION_INVALID_OPERATION, "Complex: key must be 0 or 1"); 
    506506        } 
    507507    } 
     
    549549    } 
    550550 
    551551    VTABLE void set_integer_native(INTVAL value) { 
    552         SELF.set_number_native((FLOATVAL)value); 
     552        SELF.set_number_native((FLOATVAL)value); 
    553553    } 
    554554 
    555555    VTABLE void set_number_native(FLOATVAL value) { 
     
    579579*/ 
    580580 
    581581    VTABLE void set_integer_keyed(PMC *key, INTVAL value) { 
    582         SELF.set_number_keyed(key, (FLOATVAL)value); 
     582        SELF.set_number_keyed(key, (FLOATVAL)value); 
    583583    } 
    584584 
    585585    VTABLE void set_integer_keyed_str(STRING *key, INTVAL value) { 
    586         SELF.set_number_keyed_str(key, (FLOATVAL)value); 
     586        SELF.set_number_keyed_str(key, (FLOATVAL)value); 
    587587    } 
    588588 
    589589    VTABLE void set_number_keyed(PMC *key, FLOATVAL value) { 
    590         if (VTABLE_isa(interp, key, CONST_STRING(interp, "Integer"))) { 
    591             const INTVAL i = VTABLE_get_integer(interp, key); 
    592             SELF.set_number_keyed_int(i, value); 
     590        if (VTABLE_isa(INTERP, key, CONST_STRING(INTERP, "Integer"))) { 
     591            const INTVAL i = VTABLE_get_integer(INTERP, key); 
     592            SELF.set_number_keyed_int(i, value); 
    593593        } 
    594594        else { 
    595595            STRING *s = VTABLE_get_string(INTERP, key); 
    596             SELF.set_number_keyed_str(s, value); 
     596            SELF.set_number_keyed_str(s, value); 
    597597        } 
    598598    } 
    599599 
     
    605605            SET_ATTR_im(INTERP, SELF, value); 
    606606        } 
    607607        else 
    608             Parrot_ex_throw_from_c_args(interp, NULL, 
     608            Parrot_ex_throw_from_c_args(INTERP, NULL, 
    609609                EXCEPTION_INVALID_OPERATION, "Complex: key is neither 'real' or 'imag'"); 
    610610    } 
    611611 
    612612    VTABLE void set_pmc_keyed(PMC *key, PMC *value) { 
    613613        const FLOATVAL f = VTABLE_get_number(INTERP, value); 
    614         SELF.set_number_keyed(key, f); 
     614        SELF.set_number_keyed(key, f); 
    615615    } 
    616616 
    617617    VTABLE void set_pmc_keyed_str(STRING *key, PMC *value) { 
    618618        const FLOATVAL f = VTABLE_get_number(INTERP, value); 
    619         SELF.set_number_keyed_str(key, f); 
     619        SELF.set_number_keyed_str(key, f); 
    620620    } 
    621621 
    622622/* 
     
    662662    } 
    663663 
    664664    VTABLE PMC *add_int(INTVAL value, PMC *dest) { 
    665         return SELF.add_float((FLOATVAL)value, dest); 
     665        return SELF.add_float((FLOATVAL)value, dest); 
    666666    } 
    667667 
    668668    VTABLE PMC *add_float(FLOATVAL value, PMC *dest) { 
     
    698698    } 
    699699 
    700700    VTABLE void i_add_int(INTVAL value) { 
    701         SELF.i_add_float((FLOATVAL)value); 
     701        SELF.i_add_float((FLOATVAL)value); 
    702702    } 
    703703 
    704704    VTABLE void i_add_float(FLOATVAL value) { 
     
    751751    } 
    752752 
    753753    VTABLE PMC *subtract_int(INTVAL value, PMC *dest) { 
    754         return SELF.subtract_float((FLOATVAL)value, dest); 
     754        return SELF.subtract_float((FLOATVAL)value, dest); 
    755755    } 
    756756 
    757757    VTABLE PMC *subtract_float(FLOATVAL value, PMC *dest) { 
     
    787787    } 
    788788 
    789789    VTABLE void i_subtract_int(INTVAL value) { 
    790         SELF.i_subtract_float((FLOATVAL) value); 
     790        SELF.i_subtract_float((FLOATVAL) value); 
    791791    } 
    792792 
    793793    VTABLE void i_subtract_float(FLOATVAL value) { 
     
    852852    } 
    853853 
    854854    VTABLE PMC *multiply_int(INTVAL value, PMC *dest) { 
    855         return SELF.multiply_float((FLOATVAL) value, dest); 
     855        return SELF.multiply_float((FLOATVAL) value, dest); 
    856856    } 
    857857 
    858858    VTABLE PMC *multiply_float(FLOATVAL value, PMC *dest) { 
     
    17991799        dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF)); 
    18001800 
    18011801 
    1802         Parrot_pcc_invoke_method_from_c_args(interp, SELF, CONST_STRING(interp, "ln"), 
     1802        Parrot_pcc_invoke_method_from_c_args(INTERP, SELF, CONST_STRING(INTERP, "ln"), 
    18031803                    "->P", &log); 
    18041804 
    18051805        l = Parrot_Complex_multi_multiply_Complex_PMC(INTERP, 
    18061806                    log, value, l); 
    18071807 
    1808         Parrot_pcc_invoke_method_from_c_args(interp, l, CONST_STRING(interp, "exp"), 
     1808        Parrot_pcc_invoke_method_from_c_args(INTERP, l, CONST_STRING(INTERP, "exp"), 
    18091809                    "->P", &dest); 
    18101810 
    18111811        return dest; 
     
    18171817 
    18181818        dest = pmc_new(INTERP, VTABLE_type(INTERP, SELF)); 
    18191819 
    1820         Parrot_pcc_invoke_method_from_c_args(interp, SELF, CONST_STRING(interp, "ln"), 
     1820        Parrot_pcc_invoke_method_from_c_args(INTERP, SELF, CONST_STRING(INTERP, "ln"), 
    18211821                     "->P", &log); 
    18221822        l = Parrot_Complex_multi_multiply_DEFAULT_PMC(INTERP, log, value, l); 
    1823         Parrot_pcc_invoke_method_from_c_args(interp, l, CONST_STRING(interp, "exp"), 
     1823        Parrot_pcc_invoke_method_from_c_args(INTERP, l, CONST_STRING(INTERP, "exp"), 
    18241824                     "->P", &dest); 
    18251825 
    18261826        return dest;