Ticket #71: class_registry.diff

File class_registry.diff, 81.8 KB (added by tewk, 6 years ago)
  • src/oo.c

     
    4545        __attribute__nonnull__(2) 
    4646        __attribute__nonnull__(3); 
    4747 
    48 static void fail_if_type_exists(PARROT_INTERP, ARGIN(PMC *name)) 
     48static INTVAL fail_if_type_exists(PARROT_INTERP, ARGIN(PMC *name)) 
    4949        __attribute__nonnull__(1) 
    5050        __attribute__nonnull__(2); 
    5151 
     
    423423    return Parrot_mmd_func_names[idx]; 
    424424} 
    425425 
    426  
    427 /* 
    428  
    429 =item C<PMC * Parrot_class_lookup> 
    430  
    431 Looks for the class named C<class_name> and returns it if it exists. 
    432 Otherwise it returns C<PMCNULL>. 
    433  
    434 =cut 
    435  
    436 */ 
    437  
    438 PARROT_EXPORT 
    439 PARROT_CAN_RETURN_NULL 
    440426PARROT_WARN_UNUSED_RESULT 
    441 PMC * 
    442 Parrot_class_lookup(PARROT_INTERP, ARGIN(STRING *class_name)) 
    443 { 
    444     const INTVAL type = pmc_type(interp, class_name); 
    445     PMC         *pmc; 
     427INTVAL lookup_typeid_s(PARROT_INTERP, ARGIN(STRING *name)) { 
     428    PMC *string_pmc = pmc_new(interp, enum_class_String); 
     429    VTABLE_set_string_native(interp, string_pmc, name); 
    446430 
    447     if (type <= 0) 
    448         return PMCNULL; 
    449  
    450     pmc = interp->vtables[type]->pmc_class; 
    451     PARROT_ASSERT(pmc); 
    452     return pmc; 
     431    return lookup_typeid(interp, string_pmc); 
    453432} 
    454433 
     434PARROT_WARN_UNUSED_RESULT 
     435INTVAL lookup_typeid(PARROT_INTERP, ARGIN(PMC *name)) { 
     436    PMC *ns; 
     437    /* Fast select of behavior based on type of the lookup key */ 
    455438 
    456 /* 
     439    switch (name->vtable->base_type) { 
     440        case enum_class_NameSpace: 
     441            ns = name; 
     442            break; 
     443        case enum_class_String: 
     444        case enum_class_Key: 
     445        case enum_class_ResizableStringArray: 
     446            { 
     447                PMC *base_ns; 
     448                base_ns = VTABLE_get_pmc_keyed_int(interp, interp->HLL_namespace, 
     449                        CONTEXT(interp)->current_HLL); 
     450                ns = Parrot_get_namespace_keyed(interp, base_ns, name); 
     451                //ns = Parrot_get_namespace_autobase(interp, name); 
     452            } 
     453            break; 
     454        default: 
     455            Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR, 
     456                    "Unrecognized type name PMC type %Ss", name->vtable->whoami ); 
     457            break; 
     458    } 
    457459 
    458 =item C<PMC * Parrot_class_lookup_p> 
     460    if (!PMC_IS_NULL(ns)) { 
     461        PMC *classobj = VTABLE_get_class(interp, ns); 
     462        if (!PMC_IS_NULL(classobj)) { 
     463            return VTABLE_type(interp, classobj); 
     464        } 
     465    } 
    459466 
    460 Looks for the class named C<class_name> and returns it if it exists. 
    461 Otherwise it returns C<PMCNULL>. 
     467    if (name->vtable->base_type == enum_class_String) { 
     468        /* Look up a low-level class*/ 
     469        const INTVAL type = pmc_type(interp, VTABLE_get_string(interp, name)); 
    462470 
    463 =cut 
    464  
    465 */ 
    466  
    467 PARROT_CAN_RETURN_NULL 
    468 PARROT_WARN_UNUSED_RESULT 
    469 PMC * 
    470 Parrot_class_lookup_p(PARROT_INTERP, ARGIN(PMC *class_name)) 
    471 { 
    472     const INTVAL type = pmc_type_p(interp, class_name); 
    473     PMC         *pmc; 
    474  
    475     if (type <= 0) 
    476         return PMCNULL; 
    477  
    478     pmc = interp->vtables[type]->pmc_class; 
    479     PARROT_ASSERT(pmc); 
    480     return pmc; 
     471        /* Reject invalid type numbers */ 
     472        if (type > interp->n_vtable_max) 
     473            return 0; 
     474        else 
     475            return type; 
     476    } 
     477    return 0; 
    481478} 
    482479 
    483  
    484480/* 
    485481 
    486482=item C<static void fail_if_type_exists> 
     
    494490 
    495491*/ 
    496492 
    497 static void 
     493static INTVAL 
    498494fail_if_type_exists(PARROT_INTERP, ARGIN(PMC *name)) 
    499495{ 
    500     INTVAL      type; 
     496    PMC *ns; 
     497    /* Parrot_printf(interp, "%Ss\n", VTABLE_get_repr(interp, name)); */ 
     498    /* Fast select of behavior based on type of the lookup key */ 
     499    switch (name->vtable->base_type) { 
     500        case enum_class_NameSpace: 
     501          /* Parrot_printf(interp, "%Ss\n", VTABLE_get_string(interp, name)); */ 
     502          ns = name; 
     503          break; 
     504        case enum_class_String: 
     505            { 
     506                /* Look up a low-level class and create a proxy */ 
     507                const INTVAL type = pmc_type(interp, VTABLE_get_string(interp, name)); 
    501508 
    502     PMC * const classname_hash = interp->class_hash; 
    503     PMC * const type_pmc       = (PMC *)VTABLE_get_pointer_keyed(interp, 
    504                                         classname_hash, name); 
     509                /* Reject invalid type numbers */ 
     510                if (type > interp->n_vtable_max || type <= 0) 
     511                    return 1; 
     512                else { 
     513                    Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION, 
     514                            "native type with name '%s' already exists - " 
     515                            "can't register Class", data_types[type].name); 
     516                } 
     517            } 
     518            break; 
     519        case enum_class_Key: 
     520        case enum_class_ResizableStringArray: 
     521            { 
     522                PMC * const hll_ns = VTABLE_get_pmc_keyed_int(interp, 
     523                        interp->HLL_namespace, 
     524                        CONTEXT(interp)->current_HLL); 
     525                ns = Parrot_get_namespace_keyed(interp, hll_ns, name); 
    505526 
    506     if (PMC_IS_NULL(type_pmc) 
    507     ||  type_pmc->vtable->base_type == enum_class_NameSpace) 
    508         type = 0; 
    509     else 
    510         type = VTABLE_get_integer(interp, type_pmc); 
     527            } 
     528            break; 
     529        default: 
     530            { 
     531                Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR, 
     532                        "Unrecognized class name PMC type" ); 
     533            } 
     534            break; 
     535    } 
    511536 
    512     if (type > enum_type_undef) { 
    513         STRING *classname; 
    514  
    515         if (VTABLE_isa(interp, name, CONST_STRING(interp, "ResizableStringArray"))) { 
    516             PMC * const base_ns = VTABLE_get_pmc_keyed_int(interp, 
    517                                     interp->HLL_namespace, 
    518                                     CONTEXT(interp)->current_HLL); 
    519             PMC             *ns = Parrot_get_namespace_keyed(interp, 
    520                                     base_ns, name); 
    521  
    522             if (!PMC_IS_NULL(ns)) 
    523                 classname = VTABLE_get_string(interp, ns); 
    524             else 
    525                 classname = CONST_STRING(interp, ""); 
     537    if (!PMC_IS_NULL(ns)) { 
     538        PMC *classobj = VTABLE_get_class(interp, ns); 
     539        if (!PMC_IS_NULL(classobj)) { 
     540            STRING *classname = VTABLE_get_string(interp, ns); 
     541            Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION, 
     542                    "Class %Ss already registered!\n", 
     543                    string_escape_string(interp, classname)); 
    526544        } 
    527         else 
    528             classname = VTABLE_get_string(interp, name); 
    529  
    530         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION, 
    531             "Class %Ss already registered!\n", 
    532             string_escape_string(interp, classname)); 
    533545    } 
    534546 
    535     if (type < enum_type_undef) 
    536         Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION, 
    537             "native type with name '%s' already exists - " 
    538             "can't register Class", data_types[type].name); 
     547    return 0; 
    539548} 
    540549 
    541550 
     
    547556already exists. The global type registry will go away eventually, but this 
    548557allows the new object metamodel to interact with the old one until it does. 
    549558 
     559Every type(PMCS, classes) gets a type number in the vtables table. 
     560Essentially only CORE PMCs go in the class_hash now. 
     561They are always registered with a String PMC as their name. 
     562Classes are always registered with a namespace or a ResizableStringArray as their name. 
     563 
    550564=cut 
    551565 
    552566*/ 
     
    557571{ 
    558572    INTVAL type; 
    559573    PMC   *classname_hash, *item; 
     574    INTVAL name_is_string = fail_if_type_exists(interp, name); 
    560575 
    561     fail_if_type_exists(interp, name); 
    562  
    563576    /* Type doesn't exist, so go ahead and register it. Lock interpreter so 
    564577     * pt_shared_fixup() can safely do a type lookup. */ 
    565578    LOCK_INTERPRETER(interp); 
     
    571584    if (type >= interp->n_vtable_alloced) 
    572585        parrot_realloc_vtables(interp); 
    573586 
    574     /* set entry in name->type hash */ 
    575     item              = pmc_new(interp, enum_class_Integer); 
    576     PMC_int_val(item) = type; 
     587    if (name_is_string) { 
     588        /* set entry in name->type hash */ 
     589        item              = pmc_new(interp, enum_class_Integer); 
     590        PMC_int_val(item) = type; 
    577591 
    578     VTABLE_set_pmc_keyed(interp, classname_hash, name, item); 
     592        VTABLE_set_pmc_keyed(interp, classname_hash, name, item); 
     593    } 
    579594    UNLOCK_INTERPRETER(interp); 
    580595 
    581596    return type; 
     
    777792        return; 
    778793    } 
    779794 
    780     type = pmc_type(interp, _class); 
     795    type = lookup_typeid_s(interp, _class); 
    781796 
    782797    if (type == 0) 
    783798        invalidate_all_caches(interp); 
  • src/ops/experimental.ops

     
    165165=cut 
    166166 
    167167inline op morph(invar PMC, in STR) { 
    168   INTVAL type = pmc_type(interp, $2); 
     168  INTVAL type = lookup_typeid_s(interp, $2); 
    169169  VTABLE_morph(interp, $1, type); 
    170170} 
    171171 
  • src/multidispatch.c

     
    826826        else if (string_equal(interp, type_name, CONST_STRING(interp, "FLOATVAL"))==0) 
    827827            type = enum_type_FLOATVAL; 
    828828        else 
    829             type = pmc_type(interp, type_name); 
     829            type = lookup_typeid_s(interp, type_name); 
    830830 
    831831        VTABLE_set_integer_keyed_int(interp, multi_sig, i, type); 
    832832    } 
     
    986986                break; 
    987987            } 
    988988 
    989             type = pmc_type(interp, sig); 
     989            type = lookup_typeid_s(interp, sig); 
    990990 
    991991            if (type == enum_type_undef) 
    992992                return PMCNULL; 
    993993        } 
    994994        else 
    995             type = pmc_type_p(interp, sig_elem); 
     995            type = lookup_typeid(interp, sig_elem); 
    996996 
    997997        /* create destination PMC only as necessary */ 
    998998        if (PMC_IS_NULL(ar)) { 
  • src/pmc/class.pmc

     
    218218        CLASS_is_anon_CLEAR(self); 
    219219 
    220220        /* Register a type number for the class. */ 
    221         type_num   = Parrot_oo_register_type(interp, name_arg); 
     221        type_num   = Parrot_oo_register_type(interp, new_namespace); 
    222222 
    223223        /* Link the type number with the class's vtable. */ 
    224224        new_vtable = Parrot_clone_vtable(interp, self->vtable); 
  • src/pmc/string.pmc

     
    977977    } 
    978978 
    979979    VTABLE STRING* get_repr() { 
    980         return key_set_to_string(INTERP, SELF); 
     980        return VTABLE_get_string(INTERP, SELF); 
    981981    } 
    982982 
    983983/* 
  • src/pmc/parrotinterpreter.pmc

     
    8383        for (i = s->n_vtable_max - 1; i >= start; --i) { 
    8484            if (s->vtables[i] && s->vtables[i]->pmc_class && 
    8585                PObj_is_class_TEST(s->vtables[i]->pmc_class)) { 
    86                 STRING * const class_name = 
    87                     VTABLE_get_string(s, s->vtables[i]->pmc_class); 
    88                 PARROT_ASSERT(VTABLE_exists_keyed_str(d, 
    89                     d->class_hash, class_name)); 
     86                STRING * const class_name = VTABLE_get_string(s, s->vtables[i]->pmc_class); 
    9087 
    9188                VTABLE_delete_keyed_str(d, d->class_hash, class_name); 
    9289 
  • src/pmc/fixedstringarray.pmc

     
    475475 
    476476/* 
    477477 
     478=item C<STRING *get_repr()> 
     479 
     480Returns the Parrot string representation C<key>. 
     481 
     482=cut 
     483 
     484*/ 
     485 
     486    VTABLE STRING *get_repr() { 
     487        STRING *res    = CONST_STRING(INTERP, "[ "); 
     488        const INTVAL n = SELF.get_integer(); 
     489        INTVAL  j; 
     490 
     491        for (j = 0; j < n; ++j) { 
     492            PMC * const val = SELF.get_pmc_keyed_int(j); 
     493            res = string_append(INTERP, res, CONST_STRING(INTERP, "\"")); 
     494            res = string_append(INTERP, res, VTABLE_get_repr(INTERP, val)); 
     495            res = string_append(INTERP, res, CONST_STRING(INTERP, "\"")); 
     496 
     497            if (j < n - 1) 
     498                res = string_append(INTERP, res, CONST_STRING(INTERP, ", ")); 
     499        } 
     500 
     501        res = string_append(INTERP, res, CONST_STRING(INTERP, " ]")); 
     502        return res; 
     503    } 
     504 
     505 
     506 
     507/* 
     508 
    478509=back 
    479510 
    480511=head2 Freeze/thaw Interface 
  • include/parrot/oo.h

     
    163163        __attribute__nonnull__(1) 
    164164        __attribute__nonnull__(2); 
    165165 
     166PARROT_WARN_UNUSED_RESULT 
     167INTVAL lookup_typeid_s(PARROT_INTERP, ARGIN(STRING *name)) 
     168        __attribute__nonnull__(1) 
     169        __attribute__nonnull__(2); 
     170 
     171PARROT_WARN_UNUSED_RESULT 
     172INTVAL lookup_typeid(PARROT_INTERP, ARGIN(PMC *name)) 
     173        __attribute__nonnull__(1) 
     174        __attribute__nonnull__(2); 
     175 
    166176void Parrot_oo_extract_methods_from_namespace(PARROT_INTERP, 
    167177    ARGIN(PMC *self), 
    168178    ARGIN(PMC *ns)) 
  • compilers/imcc/imcc.y

     
    388388    } 
    389389 
    390390    r[1]          = rhs; 
    391     rhs->pmc_type = pmc_type(interp, 
     391    rhs->pmc_type = lookup_typeid_s(interp, 
    392392        string_from_cstring(interp, unquoted_name, name_length)); 
    393393 
    394394    mem_sys_free(unquoted_name); 
     
    834834   | HLL_MAP STRINGC '=' STRINGC 
    835835         { 
    836836            Parrot_Context *ctx           = CONTEXT(interp); 
    837             STRING * const  built_in_name = 
    838                 string_unescape_cstring(interp, $2 + 1, '"', NULL); 
    839             STRING * const language_name  = 
    840                 string_unescape_cstring(interp, $4 + 1, '"', NULL); 
     837            STRING * const  built_in_name = string_unescape_cstring(interp, $2 + 1, '"', NULL); 
     838            STRING * const  language_name = string_unescape_cstring(interp, $4 + 1, '"', NULL); 
     839            int             built_in_type = lookup_typeid_s(interp, built_in_name); 
     840            int             language_type = lookup_typeid_s(interp, language_name); 
    841841 
    842             int             built_in_type = pmc_type(interp, built_in_name); 
    843             int             language_type = pmc_type(interp, language_name); 
    844  
    845             Parrot_register_HLL_type(interp, ctx->current_HLL, 
    846                 built_in_type, language_type); 
     842            Parrot_register_HLL_type(interp, ctx->current_HLL, built_in_type, language_type); 
    847843            $$ = 0; 
    848844         } 
    849845   ; 
     
    15921588         { 
    15931589           /* there'd normally be a str_dup() here, but the lexer already 
    15941590            * copied the string, so it's safe to use directly */ 
    1595            if ((IMCC_INFO(interp)->cur_pmc_type = pmc_type(interp, 
     1591           if ((IMCC_INFO(interp)->cur_pmc_type = lookup_typeid_s(interp, 
    15961592               string_from_cstring(interp, $1, 0))) <= 0) { 
    15971593               IMCC_fataly(interp, EXCEPTION_SYNTAX_ERROR, 
    15981594                    "Unknown PMC type '%s'\n", $1); 
  • compilers/imcc/pbc.c

     
    12221222        if (!PMC_IS_NULL(classobj)) 
    12231223            sub_pmc = VTABLE_instantiate(interp, classobj, PMCNULL); 
    12241224        else { 
    1225             const INTVAL type = pmc_type(interp, classname); 
     1225            const INTVAL type = lookup_typeid_s(interp, classname); 
    12261226            if (type <= 0) 
    12271227                Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_NO_CLASS, 
    12281228                    "Class '%Ss' specified in :instanceof(...) not found", 
  • compilers/imcc/imcparser.c

     
    712712    } 
    713713 
    714714    r[1]          = rhs; 
    715     rhs->pmc_type = pmc_type(interp, 
     715    rhs->pmc_type = lookup_typeid_s(interp, 
    716716        string_from_cstring(interp, unquoted_name, name_length)); 
    717717 
    718718    mem_sys_free(unquoted_name); 
     
    10271027    SymReg * sr; 
    10281028    Instruction *i; 
    10291029} 
    1030 /* Line 193 of yacc.c.  */ 
     1030/* Line 187 of yacc.c.  */ 
    10311031#line 1021 "compilers/imcc/imcparser.c" 
    10321032        YYSTYPE; 
    10331033# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 
     
    14681468static const yytype_uint16 yyrline[] = 
    14691469{ 
    14701470       0,   772,   772,   776,   777,   781,   782,   783,   789,   795, 
    1471      796,   797,   798,   802,   803,   812,   817,   825,   834,   852, 
    1472      852,   861,   861,   867,   867,   874,   875,   879,   880,   884, 
    1473      885,   886,   887,   888,   889,   890,   893,   893,   902,   901, 
    1474      913,   917,   925,   929,   933,   933,   945,   947,   951,   966, 
    1475      974,   979,   983,   987,   978,   999,  1000,  1001,  1014,  1014, 
    1476     1018,  1032,  1036,  1042,  1051,  1057,  1066,  1072,  1081,  1087, 
    1477     1096,  1104,  1109,  1120,  1123,  1128,  1136,  1137,  1138,  1139, 
    1478     1140,  1151,  1162,  1165,  1167,  1172,  1171,  1204,  1205,  1209, 
    1479     1210,  1214,  1215,  1219,  1220,  1224,  1225,  1226,  1227,  1228, 
    1480     1229,  1230,  1231,  1232,  1233,  1234,  1235,  1236,  1237,  1241, 
    1481     1246,  1250,  1255,  1259,  1263,  1268,  1277,  1278,  1282,  1287, 
    1482     1288,  1296,  1297,  1297,  1312,  1313,  1317,  1318,  1319,  1320, 
    1483     1321,  1322,  1327,  1327,  1330,  1338,  1338,  1344,  1345,  1350, 
    1484     1358,  1359,  1364,  1372,  1376,  1381,  1380,  1393,  1394,  1398, 
    1485     1399,  1409,  1413,  1423,  1431,  1432,  1444,  1448,  1450,  1451, 
    1486     1452,  1453,  1457,  1458,  1462,  1463,  1467,  1476,  1477,  1488, 
    1487     1495,  1504,  1514,  1515,  1520,  1521,  1522,  1522,  1538,  1542, 
    1488     1542,  1549,  1550,  1550,  1556,  1562,  1563,  1575,  1576,  1577, 
    1489     1578,  1579,  1580,  1584,  1585,  1586,  1587,  1591,  1604,  1606, 
    1490     1608,  1610,  1612,  1614,  1616,  1618,  1620,  1622,  1624,  1626, 
    1491     1628,  1632,  1634,  1636,  1639,  1646,  1645,  1654,  1655,  1656, 
    1492     1657,  1665,  1666,  1667,  1671,  1672,  1673,  1674,  1675,  1676, 
    1493     1677,  1678,  1679,  1680,  1681,  1682,  1683,  1684,  1685,  1686, 
    1494     1687,  1688,  1689,  1690,  1691,  1692,  1693,  1699,  1698,  1710, 
    1495     1717,  1718,  1719,  1720,  1721,  1722,  1723,  1724,  1725,  1726, 
    1496     1727,  1728,  1729,  1734,  1745,  1746,  1747,  1748,  1754,  1768, 
    1497     1774,  1780,  1779,  1788,  1789,  1799,  1809,  1815,  1824,  1828, 
    1498     1829,  1833,  1834,  1837,  1841,  1845,  1855,  1860,  1870,  1875, 
    1499     1879,  1880,  1884,  1888,  1892,  1899,  1903,  1907,  1914,  1915, 
    1500     1919,  1920,  1921,  1922,  1923,  1924,  1928,  1929,  1933,  1934, 
    1501     1938,  1939,  1943,  1944,  1951,  1958,  1959,  1960,  1964,  1965, 
    1502     1969,  1970,  1974,  1975,  1979,  1980,  1984,  1984,  1997,  1997, 
    1503     2010,  2011,  2019,  2028,  2029,  2030,  2031,  2032,  2036,  2037, 
    1504     2038,  2039 
     1471     796,   797,   798,   802,   803,   812,   817,   825,   834,   848, 
     1472     848,   857,   857,   863,   863,   870,   871,   875,   876,   880, 
     1473     881,   882,   883,   884,   885,   886,   889,   889,   898,   897, 
     1474     909,   913,   921,   925,   929,   929,   941,   943,   947,   962, 
     1475     970,   975,   979,   983,   974,   995,   996,   997,  1010,  1010, 
     1476    1014,  1028,  1032,  1038,  1047,  1053,  1062,  1068,  1077,  1083, 
     1477    1092,  1100,  1105,  1116,  1119,  1124,  1132,  1133,  1134,  1135, 
     1478    1136,  1147,  1158,  1161,  1163,  1168,  1167,  1200,  1201,  1205, 
     1479    1206,  1210,  1211,  1215,  1216,  1220,  1221,  1222,  1223,  1224, 
     1480    1225,  1226,  1227,  1228,  1229,  1230,  1231,  1232,  1233,  1237, 
     1481    1242,  1246,  1251,  1255,  1259,  1264,  1273,  1274,  1278,  1283, 
     1482    1284,  1292,  1293,  1293,  1308,  1309,  1313,  1314,  1315,  1316, 
     1483    1317,  1318,  1323,  1323,  1326,  1334,  1334,  1340,  1341,  1346, 
     1484    1354,  1355,  1360,  1368,  1372,  1377,  1376,  1389,  1390,  1394, 
     1485    1395,  1405,  1409,  1419,  1427,  1428,  1440,  1444,  1446,  1447, 
     1486    1448,  1449,  1453,  1454,  1458,  1459,  1463,  1472,  1473,  1484, 
     1487    1491,  1500,  1510,  1511,  1516,  1517,  1518,  1518,  1534,  1538, 
     1488    1538,  1545,  1546,  1546,  1552,  1558,  1559,  1571,  1572,  1573, 
     1489    1574,  1575,  1576,  1580,  1581,  1582,  1583,  1587,  1600,  1602, 
     1490    1604,  1606,  1608,  1610,  1612,  1614,  1616,  1618,  1620,  1622, 
     1491    1624,  1628,  1630,  1632,  1635,  1642,  1641,  1650,  1651,  1652, 
     1492    1653,  1661,  1662,  1663,  1667,  1668,  1669,  1670,  1671,  1672, 
     1493    1673,  1674,  1675,  1676,  1677,  1678,  1679,  1680,  1681,  1682, 
     1494    1683,  1684,  1685,  1686,  1687,  1688,  1689,  1695,  1694,  1706, 
     1495    1713,  1714,  1715,  1716,  1717,  1718,  1719,  1720,  1721,  1722, 
     1496    1723,  1724,  1725,  1730,  1741,  1742,  1743,  1744,  1750,  1764, 
     1497    1770,  1776,  1775,  1784,  1785,  1795,  1805,  1811,  1820,  1824, 
     1498    1825,  1829,  1830,  1833,  1837,  1841,  1851,  1856,  1866,  1871, 
     1499    1875,  1876,  1880,  1884,  1888,  1895,  1899,  1903,  1910,  1911, 
     1500    1915,  1916,  1917,  1918,  1919,  1920,  1924,  1925,  1929,  1930, 
     1501    1934,  1935,  1939,  1940,  1947,  1954,  1955,  1956,  1960,  1961, 
     1502    1965,  1966,  1970,  1971,  1975,  1976,  1980,  1980,  1993,  1993, 
     1503    2006,  2007,  2015,  2024,  2025,  2026,  2027,  2028,  2032,  2033, 
     1504    2034,  2035 
    15051505}; 
    15061506#endif 
    15071507 
     
    29602960#line 835 "compilers/imcc/imcc.y" 
    29612961    { 
    29622962            Parrot_Context *ctx           = CONTEXT(interp); 
    2963             STRING * const  built_in_name = 
    2964                 string_unescape_cstring(interp, (yyvsp[(2) - (4)].s) + 1, '"', NULL); 
    2965             STRING * const language_name  = 
    2966                 string_unescape_cstring(interp, (yyvsp[(4) - (4)].s) + 1, '"', NULL); 
     2963            STRING * const  built_in_name = string_unescape_cstring(interp, (yyvsp[(2) - (4)].s) + 1, '"', NULL); 
     2964            STRING * const  language_name = string_unescape_cstring(interp, (yyvsp[(4) - (4)].s) + 1, '"', NULL); 
     2965            int             built_in_type = lookup_typeid_s(interp, built_in_name); 
     2966            int             language_type = lookup_typeid_s(interp, language_name); 
    29672967 
    2968             int             built_in_type = pmc_type(interp, built_in_name); 
    2969             int             language_type = pmc_type(interp, language_name); 
    2970  
    2971             Parrot_register_HLL_type(interp, ctx->current_HLL, 
    2972                 built_in_type, language_type); 
     2968            Parrot_register_HLL_type(interp, ctx->current_HLL, built_in_type, language_type); 
    29732969            (yyval.t) = 0; 
    29742970         } 
    29752971    break; 
    29762972 
    29772973  case 19: 
    2978 #line 852 "compilers/imcc/imcc.y" 
     2974#line 848 "compilers/imcc/imcc.y" 
    29792975    { is_def = 1; } 
    29802976    break; 
    29812977 
    29822978  case 20: 
    2983 #line 853 "compilers/imcc/imcc.y" 
     2979#line 849 "compilers/imcc/imcc.y" 
    29842980    { 
    29852981             mk_const_ident(interp, (yyvsp[(4) - (6)].s), (yyvsp[(3) - (6)].t), (yyvsp[(6) - (6)].sr), 1); 
    29862982             mem_sys_free((yyvsp[(4) - (6)].s)); 
     
    29892985    break; 
    29902986 
    29912987  case 21: 
    2992 #line 861 "compilers/imcc/imcc.y" 
     2988#line 857 "compilers/imcc/imcc.y" 
    29932989    { is_def=1; } 
    29942990    break; 
    29952991 
    29962992  case 22: 
    2997 #line 862 "compilers/imcc/imcc.y" 
     2993#line 858 "compilers/imcc/imcc.y" 
    29982994    { 
    29992995           (yyval.i) = mk_pmc_const(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(3) - (6)].s), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].s)); 
    30002996           is_def = 0; 
     
    30022998    break; 
    30032999 
    30043000  case 23: 
    3005 #line 867 "compilers/imcc/imcc.y" 
     3001#line 863 "compilers/imcc/imcc.y" 
    30063002    { is_def=1; } 
    30073003    break; 
    30083004 
    30093005  case 24: 
    3010 #line 868 "compilers/imcc/imcc.y" 
     3006#line 864 "compilers/imcc/imcc.y" 
    30113007    { 
    30123008           (yyval.i) = mk_pmc_const_named(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(3) - (6)].s), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].s)); 
    30133009           is_def = 0; 
     
    30153011    break; 
    30163012 
    30173013  case 29: 
    3018 #line 884 "compilers/imcc/imcc.y" 
     3014#line 880 "compilers/imcc/imcc.y" 
    30193015    { (yyval.i) = 0;  } 
    30203016    break; 
    30213017 
    30223018  case 30: 
    3023 #line 885 "compilers/imcc/imcc.y" 
     3019#line 881 "compilers/imcc/imcc.y" 
    30243020    { (yyval.i) = 0;  } 
    30253021    break; 
    30263022 
    30273023  case 31: 
    3028 #line 886 "compilers/imcc/imcc.y" 
     3024#line 882 "compilers/imcc/imcc.y" 
    30293025    { (yyval.i) = 0;  } 
    30303026    break; 
    30313027 
    30323028  case 32: 
    3033 #line 887 "compilers/imcc/imcc.y" 
     3029#line 883 "compilers/imcc/imcc.y" 
    30343030    { (yyval.i) = 0;  } 
    30353031    break; 
    30363032 
    30373033  case 33: 
    3038 #line 888 "compilers/imcc/imcc.y" 
     3034#line 884 "compilers/imcc/imcc.y" 
    30393035    { (yyval.i) = (yyvsp[(1) - (1)].i); } 
    30403036    break; 
    30413037 
    30423038  case 36: 
    3043 #line 893 "compilers/imcc/imcc.y" 
     3039#line 889 "compilers/imcc/imcc.y" 
    30443040    { clear_state(interp); } 
    30453041    break; 
    30463042 
    30473043  case 37: 
    3048 #line 895 "compilers/imcc/imcc.y" 
     3044#line 891 "compilers/imcc/imcc.y" 
    30493045    { 
    30503046           (yyval.i) = INS(interp, IMCC_INFO(interp)->cur_unit, 
    30513047                    (yyvsp[(2) - (3)].s), 0, IMCC_INFO(interp)->regs, 
     
    30553051    break; 
    30563052 
    30573053  case 38: 
    3058 #line 902 "compilers/imcc/imcc.y" 
     3054#line 898 "compilers/imcc/imcc.y" 
    30593055    { 
    30603056           imc_close_unit(interp, IMCC_INFO(interp)->cur_unit); 
    30613057           IMCC_INFO(interp)->cur_unit = imc_open_unit(interp, IMC_PASM); 
     
    30633059    break; 
    30643060 
    30653061  case 39: 
    3066 #line 907 "compilers/imcc/imcc.y" 
     3062#line 903 "compilers/imcc/imcc.y" 
    30673063    { 
    30683064           (yyval.i) = iSUBROUTINE(interp, 
    30693065                    IMCC_INFO(interp)->cur_unit, 
     
    30733069    break; 
    30743070 
    30753071  case 40: 
    3076 #line 914 "compilers/imcc/imcc.y" 
     3072#line 910 "compilers/imcc/imcc.y" 
    30773073    { 
    30783074           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "null", 1, (yyvsp[(2) - (2)].sr)); 
    30793075         } 
    30803076    break; 
    30813077 
    30823078  case 41: 
    3083 #line 918 "compilers/imcc/imcc.y" 
     3079#line 914 "compilers/imcc/imcc.y" 
    30843080    { 
    30853081           SymReg *r = mk_pasm_reg(interp, (yyvsp[(4) - (4)].s)); 
    30863082           set_lexical(interp, r, (yyvsp[(2) - (4)].s)); 
     
    30913087    break; 
    30923088 
    30933089  case 42: 
    3094 #line 925 "compilers/imcc/imcc.y" 
     3090#line 921 "compilers/imcc/imcc.y" 
    30953091    { (yyval.i) = 0;} 
    30963092    break; 
    30973093 
    30983094  case 44: 
    3099 #line 933 "compilers/imcc/imcc.y" 
     3095#line 929 "compilers/imcc/imcc.y" 
    31003096    { IMCC_INFO(interp)->cur_unit = imc_open_unit(interp, IMC_PASM); } 
    31013097    break; 
    31023098 
    31033099  case 45: 
    3104 #line 936 "compilers/imcc/imcc.y" 
     3100#line 932 "compilers/imcc/imcc.y" 
    31053101    { 
    31063102           /* if (optimizer_level & OPT_PASM) 
    31073103                         imc_compile_unit(interp, IMCC_INFO(interp)->cur_unit); 
     
    31123108    break; 
    31133109 
    31143110  case 48: 
    3115 #line 952 "compilers/imcc/imcc.y" 
     3111#line 948 "compilers/imcc/imcc.y" 
    31163112    { 
    31173113           int re_open = 0; 
    31183114           (yyval.i) = 0; 
     
    31273123    break; 
    31283124 
    31293125  case 49: 
    3130 #line 967 "compilers/imcc/imcc.y" 
     3126#line 963 "compilers/imcc/imcc.y" 
    31313127    { 
    31323128            if (IMCC_INFO(interp)->in_slice) 
    31333129                IMCC_fataly(interp, EXCEPTION_SYNTAX_ERROR, 
     
    31383134    break; 
    31393135 
    31403136  case 50: 
    3141 #line 974 "compilers/imcc/imcc.y" 
     3137#line 970 "compilers/imcc/imcc.y" 
    31423138    { (yyval.sr) = NULL; } 
    31433139    break; 
    31443140 
    31453141  case 51: 
    3146 #line 979 "compilers/imcc/imcc.y" 
     3142#line 975 "compilers/imcc/imcc.y" 
    31473143    { 
    31483144           IMCC_INFO(interp)->cur_unit = imc_open_unit(interp, IMC_PCCSUB); 
    31493145         } 
    31503146    break; 
    31513147 
    31523148  case 52: 
    3153 #line 983 "compilers/imcc/imcc.y" 
     3149#line 979 "compilers/imcc/imcc.y" 
    31543150    { 
    31553151           iSUBROUTINE(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(3) - (3)].sr)); 
    31563152         } 
    31573153    break; 
    31583154 
    31593155  case 53: 
    3160 #line 987 "compilers/imcc/imcc.y" 
     3156#line 983 "compilers/imcc/imcc.y" 
    31613157    { 
    31623158          IMCC_INFO(interp)->cur_call->pcc_sub->pragma = (yyvsp[(5) - (6)].t); 
    31633159          if (!IMCC_INFO(interp)->cur_unit->instructions->symregs[0]->subid) { 
     
    31683164    break; 
    31693165 
    31703166  case 54: 
    3171 #line 995 "compilers/imcc/imcc.y" 
     3167#line 991 "compilers/imcc/imcc.y" 
    31723168    { (yyval.i) = 0; IMCC_INFO(interp)->cur_call = NULL; } 
    31733169    break; 
    31743170 
    31753171  case 55: 
    3176 #line 999 "compilers/imcc/imcc.y" 
     3172#line 995 "compilers/imcc/imcc.y" 
    31773173    { (yyval.sr) = 0; } 
    31783174    break; 
    31793175 
    31803176  case 56: 
    3181 #line 1000 "compilers/imcc/imcc.y" 
     3177#line 996 "compilers/imcc/imcc.y" 
    31823178    { (yyval.sr) = 0; } 
    31833179    break; 
    31843180 
    31853181  case 57: 
    3186 #line 1002 "compilers/imcc/imcc.y" 
     3182#line 998 "compilers/imcc/imcc.y" 
    31873183    { 
    31883184           if (IMCC_INFO(interp)->adv_named_id) { 
    31893185                 add_pcc_named_param(interp, IMCC_INFO(interp)->cur_call, 
     
    31963192    break; 
    31973193 
    31983194  case 58: 
    3199 #line 1014 "compilers/imcc/imcc.y" 
     3195#line 1010 "compilers/imcc/imcc.y" 
    32003196    { is_def=1; } 
    32013197    break; 
    32023198 
    32033199  case 59: 
    3204 #line 1014 "compilers/imcc/imcc.y" 
     3200#line 1010 "compilers/imcc/imcc.y" 
    32053201    { (yyval.sr) = (yyvsp[(3) - (3)].sr); is_def=0; } 
    32063202    break; 
    32073203 
    32083204  case 60: 
    3209 #line 1019 "compilers/imcc/imcc.y" 
     3205#line 1015 "compilers/imcc/imcc.y" 
    32103206    { 
    32113207           if ((yyvsp[(3) - (3)].t) & VT_UNIQUE_REG) 
    32123208               (yyval.sr) = mk_ident_ur(interp, (yyvsp[(2) - (3)].s), (yyvsp[(1) - (3)].t)); 
     
    32183214    break; 
    32193215 
    32203216  case 61: 
    3221 #line 1032 "compilers/imcc/imcc.y" 
     3217#line 1028 "compilers/imcc/imcc.y" 
    32223218    { (yyval.t) = 0; } 
    32233219    break; 
    32243220 
    32253221  case 62: 
    3226 #line 1037 "compilers/imcc/imcc.y" 
     3222#line 1033 "compilers/imcc/imcc.y" 
    32273223    { 
    32283224           (yyval.t) = 0; 
    32293225           IMCC_INFO(interp)->cur_unit->outer = mk_sub_address_fromc(interp, (yyvsp[(3) - (4)].s)); 
     
    32323228    break; 
    32333229 
    32343230  case 63: 
    3235 #line 1043 "compilers/imcc/imcc.y" 
     3231#line 1039 "compilers/imcc/imcc.y" 
    32363232    { 
    32373233           (yyval.t) = 0; 
    32383234           IMCC_INFO(interp)->cur_unit->outer = mk_const(interp, (yyvsp[(3) - (4)].s), 'S'); 
     
    32413237    break; 
    32423238 
    32433239  case 64: 
    3244 #line 1052 "compilers/imcc/imcc.y" 
     3240#line 1048 "compilers/imcc/imcc.y" 
    32453241    { 
    32463242           (yyval.t) = 0; 
    32473243           IMCC_INFO(interp)->cur_unit->vtable_name = NULL; 
     
    32503246    break; 
    32513247 
    32523248  case 65: 
    3253 #line 1058 "compilers/imcc/imcc.y" 
     3249#line 1054 "compilers/imcc/imcc.y" 
    32543250    { 
    32553251           (yyval.t) = 0; 
    32563252           IMCC_INFO(interp)->cur_unit->vtable_name = (yyvsp[(3) - (4)].s); 
     
    32593255    break; 
    32603256 
    32613257  case 66: 
    3262 #line 1067 "compilers/imcc/imcc.y" 
     3258#line 1063 "compilers/imcc/imcc.y" 
    32633259    { 
    32643260           (yyval.t) = P_METHOD; 
    32653261           IMCC_INFO(interp)->cur_unit->method_name = NULL; 
     
    32683264    break; 
    32693265 
    32703266  case 67: 
    3271 #line 1073 "compilers/imcc/imcc.y" 
     3267#line 1069 "compilers/imcc/imcc.y" 
    32723268    { 
    32733269           (yyval.t) = P_METHOD; 
    32743270           IMCC_INFO(interp)->cur_unit->method_name = (yyvsp[(3) - (4)].s); 
     
    32773273    break; 
    32783274 
    32793275  case 68: 
    3280 #line 1082 "compilers/imcc/imcc.y" 
     3276#line 1078 "compilers/imcc/imcc.y" 
    32813277    { 
    32823278           (yyval.t) = 0; 
    32833279           IMCC_INFO(interp)->cur_unit->ns_entry_name = NULL; 
     
    32863282    break; 
    32873283 
    32883284  case 69: 
    3289 #line 1088 "compilers/imcc/imcc.y" 
     3285#line 1084 "compilers/imcc/imcc.y" 
    32903286    { 
    32913287           (yyval.t) = 0; 
    32923288           IMCC_INFO(interp)->cur_unit->ns_entry_name = (yyvsp[(3) - (4)].s); 
     
    32953291    break; 
    32963292 
    32973293  case 70: 
    3298 #line 1097 "compilers/imcc/imcc.y" 
     3294#line 1093 "compilers/imcc/imcc.y" 
    32993295    { 
    33003296           (yyval.t) = 0; 
    33013297           IMCC_INFO(interp)->cur_unit->instance_of = (yyvsp[(3) - (4)].s); 
     
    33033299    break; 
    33043300 
    33053301  case 71: 
    3306 #line 1105 "compilers/imcc/imcc.y" 
     3302#line 1101 "compilers/imcc/imcc.y" 
    33073303    { 
    33083304           (yyval.t) = 0; 
    33093305           IMCC_INFO(interp)->cur_unit->subid = NULL; 
     
    33113307    break; 
    33123308 
    33133309  case 72: 
    3314 #line 1110 "compilers/imcc/imcc.y" 
     3310#line 1106 "compilers/imcc/imcc.y" 
    33153311    { 
    33163312           (yyval.t) = 0; 
    33173313           IMCC_INFO(interp)->cur_unit->subid = mk_const(interp, (yyvsp[(3) - (4)].s), 'S'); 
     
    33213317    break; 
    33223318 
    33233319  case 73: 
    3324 #line 1120 "compilers/imcc/imcc.y" 
     3320#line 1116 "compilers/imcc/imcc.y" 
    33253321    { 
    33263322           add_pcc_multi(IMCC_INFO(interp)->cur_call, NULL); 
    33273323         } 
    33283324    break; 
    33293325 
    33303326  case 74: 
    3331 #line 1124 "compilers/imcc/imcc.y" 
     3327#line 1120 "compilers/imcc/imcc.y" 
    33323328    { 
    33333329           (yyval.t) = 0; 
    33343330           add_pcc_multi(IMCC_INFO(interp)->cur_call, (yyvsp[(3) - (3)].sr)); 
     
    33363332    break; 
    33373333 
    33383334  case 75: 
    3339 #line 1129 "compilers/imcc/imcc.y" 
     3335#line 1125 "compilers/imcc/imcc.y" 
    33403336    { 
    33413337           (yyval.t) = 0; 
    33423338           add_pcc_multi(IMCC_INFO(interp)->cur_call, (yyvsp[(1) - (1)].sr)); 
     
    33443340    break; 
    33453341 
    33463342  case 76: 
    3347 #line 1136 "compilers/imcc/imcc.y" 
     3343#line 1132 "compilers/imcc/imcc.y" 
    33483344    { (yyval.sr) = mk_const(interp, "INTVAL",   'S'); } 
    33493345    break; 
    33503346 
    33513347  case 77: 
    3352 #line 1137 "compilers/imcc/imcc.y" 
     3348#line 1133 "compilers/imcc/imcc.y" 
    33533349    { (yyval.sr) = mk_const(interp, "FLOATVAL", 'S'); } 
    33543350    break; 
    33553351 
    33563352  case 78: 
    3357 #line 1138 "compilers/imcc/imcc.y" 
     3353#line 1134 "compilers/imcc/imcc.y" 
    33583354    { (yyval.sr) = mk_const(interp, "PMC",      'S'); } 
    33593355    break; 
    33603356 
    33613357  case 79: 
    3362 #line 1139 "compilers/imcc/imcc.y" 
     3358#line 1135 "compilers/imcc/imcc.y" 
    33633359    { (yyval.sr) = mk_const(interp, "STRING",   'S'); } 
    33643360    break; 
    33653361 
    33663362  case 80: 
    3367 #line 1141 "compilers/imcc/imcc.y" 
     3363#line 1137 "compilers/imcc/imcc.y" 
    33683364    { 
    33693365           SymReg *r; 
    33703366           if (strcmp((yyvsp[(1) - (1)].s), "_") != 0) 
     
    33783374    break; 
    33793375 
    33803376  case 81: 
    3381 #line 1152 "compilers/imcc/imcc.y" 
     3377#line 1148 "compilers/imcc/imcc.y" 
    33823378    { 
    33833379           SymReg *r; 
    33843380           if (strcmp((yyvsp[(1) - (1)].s), "_") != 0) 
     
    33923388    break; 
    33933389 
    33943390  case 82: 
    3395 #line 1162 "compilers/imcc/imcc.y" 
     3391#line 1158 "compilers/imcc/imcc.y" 
    33963392    { (yyval.sr) = (yyvsp[(2) - (3)].sr); } 
    33973393    break; 
    33983394 
    33993395  case 85: 
    3400 #line 1172 "compilers/imcc/imcc.y" 
     3396#line 1168 "compilers/imcc/imcc.y" 
    34013397    { 
    34023398           char name[128]; 
    34033399           SymReg *r, *r1; 
     
    34243420    break; 
    34253421 
    34263422  case 86: 
    3427 #line 1200 "compilers/imcc/imcc.y" 
     3423#line 1196 "compilers/imcc/imcc.y" 
    34283424    { (yyval.i) = 0; IMCC_INFO(interp)->cur_call = NULL; } 
    34293425    break; 
    34303426 
    34313427  case 87: 
    3432 #line 1204 "compilers/imcc/imcc.y" 
     3428#line 1200 "compilers/imcc/imcc.y" 
    34333429    { (yyval.i) = NULL; IMCC_INFO(interp)->cur_call->pcc_sub->label = 0; } 
    34343430    break; 
    34353431 
    34363432  case 88: 
    3437 #line 1205 "compilers/imcc/imcc.y" 
     3433#line 1201 "compilers/imcc/imcc.y" 
    34383434    { (yyval.i) = NULL; IMCC_INFO(interp)->cur_call->pcc_sub->label = 1; } 
    34393435    break; 
    34403436 
    34413437  case 89: 
    3442 #line 1209 "compilers/imcc/imcc.y" 
     3438#line 1205 "compilers/imcc/imcc.y" 
    34433439    { (yyval.i) = NULL; } 
    34443440    break; 
    34453441 
    34463442  case 90: 
    3447 #line 1210 "compilers/imcc/imcc.y" 
     3443#line 1206 "compilers/imcc/imcc.y" 
    34483444    { (yyval.i) = NULL;  IMCC_INFO(interp)->cur_call->pcc_sub->object = (yyvsp[(2) - (3)].sr); } 
    34493445    break; 
    34503446 
    34513447  case 91: 
    3452 #line 1214 "compilers/imcc/imcc.y" 
     3448#line 1210 "compilers/imcc/imcc.y" 
    34533449    { (yyval.t) = 0; } 
    34543450    break; 
    34553451 
    34563452  case 93: 
    3457 #line 1219 "compilers/imcc/imcc.y" 
     3453#line 1215 "compilers/imcc/imcc.y" 
    34583454    { (yyval.t) = (yyvsp[(1) - (1)].t); } 
    34593455    break; 
    34603456 
    34613457  case 94: 
    3462 #line 1220 "compilers/imcc/imcc.y" 
     3458#line 1216 "compilers/imcc/imcc.y" 
    34633459    { (yyval.t) = (yyvsp[(1) - (2)].t) | (yyvsp[(2) - (2)].t); } 
    34643460    break; 
    34653461 
    34663462  case 95: 
    3467 #line 1224 "compilers/imcc/imcc.y" 
     3463#line 1220 "compilers/imcc/imcc.y" 
    34683464    { (yyval.t) = P_LOAD; } 
    34693465    break; 
    34703466 
    34713467  case 96: 
    3472 #line 1225 "compilers/imcc/imcc.y" 
     3468#line 1221 "compilers/imcc/imcc.y" 
    34733469    { (yyval.t) = P_INIT; } 
    34743470    break; 
    34753471 
    34763472  case 97: 
    3477 #line 1226 "compilers/imcc/imcc.y" 
     3473#line 1222 "compilers/imcc/imcc.y" 
    34783474    { (yyval.t) = P_MAIN; } 
    34793475    break; 
    34803476 
    34813477  case 98: 
    3482 #line 1227 "compilers/imcc/imcc.y" 
     3478#line 1223 "compilers/imcc/imcc.y" 
    34833479    { (yyval.t) = P_IMMEDIATE; } 
    34843480    break; 
    34853481 
    34863482  case 99: 
    3487 #line 1228 "compilers/imcc/imcc.y" 
     3483#line 1224 "compilers/imcc/imcc.y" 
    34883484    { (yyval.t) = P_POSTCOMP; } 
    34893485    break; 
    34903486 
    34913487  case 100: 
    3492 #line 1229 "compilers/imcc/imcc.y" 
     3488#line 1225 "compilers/imcc/imcc.y" 
    34933489    { (yyval.t) = P_ANON; } 
    34943490    break; 
    34953491 
    34963492  case 101: 
    3497 #line 1230 "compilers/imcc/imcc.y" 
     3493#line 1226 "compilers/imcc/imcc.y" 
    34983494    { (yyval.t) = P_NEED_LEX; } 
    34993495    break; 
    35003496 
    35013497  case 109: 
    3502 #line 1242 "compilers/imcc/imcc.y" 
     3498#line 1238 "compilers/imcc/imcc.y" 
    35033499    { 
    35043500           add_pcc_sub(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (5)].sr)); 
    35053501           add_pcc_cc(IMCC_INFO(interp)->cur_call, (yyvsp[(4) - (5)].sr)); 
     
    35073503    break; 
    35083504 
    35093505  case 110: 
    3510 #line 1247 "compilers/imcc/imcc.y" 
     3506#line 1243 "compilers/imcc/imcc.y" 
    35113507    { 
    35123508           add_pcc_sub(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (3)].sr)); 
    35133509         } 
    35143510    break; 
    35153511 
    35163512  case 111: 
    3517 #line 1251 "compilers/imcc/imcc.y" 
     3513#line 1247 "compilers/imcc/imcc.y" 
    35183514    { 
    35193515           add_pcc_sub(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (3)].sr)); 
    35203516           IMCC_INFO(interp)->cur_call->pcc_sub->flags |= isNCI; 
     
    35223518    break; 
    35233519 
    35243520  case 112: 
    3525 #line 1256 "compilers/imcc/imcc.y" 
     3521#line 1252 "compilers/imcc/imcc.y" 
    35263522    { 
    35273523           add_pcc_sub(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (3)].sr)); 
    35283524         } 
    35293525    break; 
    35303526 
    35313527  case 113: 
    3532 #line 1260 "compilers/imcc/imcc.y" 
     3528#line 1256 "compilers/imcc/imcc.y" 
    35333529    { 
    35343530           add_pcc_sub(IMCC_INFO(interp)->cur_call, mk_const(interp, (yyvsp[(2) - (3)].s), 'S')); 
    35353531         } 
    35363532    break; 
    35373533 
    35383534  case 114: 
    3539 #line 1264 "compilers/imcc/imcc.y" 
     3535#line 1260 "compilers/imcc/imcc.y" 
    35403536    { 
    35413537           add_pcc_sub(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (5)].sr)); 
    35423538           add_pcc_cc(IMCC_INFO(interp)->cur_call, (yyvsp[(4) - (5)].sr)); 
     
    35443540    break; 
    35453541 
    35463542  case 115: 
    3547 #line 1269 "compilers/imcc/imcc.y" 
     3543#line 1265 "compilers/imcc/imcc.y" 
    35483544    { 
    35493545           add_pcc_sub(IMCC_INFO(interp)->cur_call, mk_const(interp, (yyvsp[(2) - (5)].s), 'S')); 
    35503546           add_pcc_cc(IMCC_INFO(interp)->cur_call, (yyvsp[(4) - (5)].sr)); 
     
    35523548    break; 
    35533549 
    35543550  case 116: 
    3555 #line 1277 "compilers/imcc/imcc.y" 
     3551#line 1273 "compilers/imcc/imcc.y" 
    35563552    { (yyval.sr) = 0; } 
    35573553    break; 
    35583554 
    35593555  case 117: 
    3560 #line 1278 "compilers/imcc/imcc.y" 
     3556#line 1274 "compilers/imcc/imcc.y" 
    35613557    { add_pcc_arg(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (3)].sr)); } 
    35623558    break; 
    35633559 
    35643560  case 118: 
    3565 #line 1282 "compilers/imcc/imcc.y" 
     3561#line 1278 "compilers/imcc/imcc.y" 
    35663562    { (yyval.sr) = (yyvsp[(2) - (2)].sr); } 
    35673563    break; 
    35683564 
    35693565  case 119: 
    3570 #line 1287 "compilers/imcc/imcc.y" 
     3566#line 1283 "compilers/imcc/imcc.y" 
    35713567    { (yyval.sr) = 0; } 
    35723568    break; 
    35733569 
    35743570  case 120: 
    3575 #line 1289 "compilers/imcc/imcc.y" 
     3571#line 1285 "compilers/imcc/imcc.y" 
    35763572    { 
    35773573           if ((yyvsp[(2) - (3)].sr)) 
    35783574               add_pcc_result(IMCC_INFO(interp)->cur_call, (yyvsp[(2) - (3)].sr)); 
     
    35803576    break; 
    35813577 
    35823578  case 121: 
    3583 #line 1296 "compilers/imcc/imcc.y" 
     3579#line 1292 "compilers/imcc/imcc.y" 
    35843580    { (yyval.sr) = (yyvsp[(2) - (3)].sr); (yyval.sr)->type |= (yyvsp[(3) - (3)].t); } 
    35853581    break; 
    35863582 
    35873583  case 122: 
    3588 #line 1297 "compilers/imcc/imcc.y" 
     3584#line 1293 "compilers/imcc/imcc.y" 
    35893585    { is_def=1; } 
    35903586    break; 
    35913587 
    35923588  case 123: 
    3593 #line 1298 "compilers/imcc/imcc.y" 
     3589#line 1294 "compilers/imcc/imcc.y" 
    35943590    { 
    35953591           IdList *l = (yyvsp[(4) - (4)].idlist); 
    35963592           SymReg *ignored; 
     
    36053601    break; 
    36063602 
    36073603  case 124: 
    3608 #line 1312 "compilers/imcc/imcc.y" 
     3604#line 1308 "compilers/imcc/imcc.y" 
    36093605    { (yyval.t) = 0; } 
    36103606    break; 
    36113607 
    36123608  case 125: 
    3613 #line 1313 "compilers/imcc/imcc.y" 
     3609#line 1309 "compilers/imcc/imcc.y" 
    36143610    { (yyval.t) = (yyvsp[(1) - (2)].t) | (yyvsp[(2) - (2)].t); } 
    36153611    break; 
    36163612 
    36173613  case 126: 
    3618 #line 1317 "compilers/imcc/imcc.y" 
     3614#line 1313 "compilers/imcc/imcc.y" 
    36193615    { (yyval.t) = VT_FLAT;   } 
    36203616    break; 
    36213617 
    36223618  case 127: 
    3623 #line 1318 "compilers/imcc/imcc.y" 
     3619#line 1314 "compilers/imcc/imcc.y" 
    36243620    { (yyval.t) = VT_OPTIONAL; } 
    36253621    break; 
    36263622 
    36273623  case 128: 
    3628 #line 1319 "compilers/imcc/imcc.y" 
     3624#line 1315 "compilers/imcc/imcc.y" 
    36293625    { (yyval.t) = VT_OPT_FLAG; } 
    36303626    break; 
    36313627 
    36323628  case 129: 
    3633 #line 1320 "compilers/imcc/imcc.y" 
     3629#line 1316 "compilers/imcc/imcc.y" 
    36343630    { (yyval.t) = VT_NAMED; } 
    36353631    break; 
    36363632 
    36373633  case 130: 
    3638 #line 1321 "compilers/imcc/imcc.y" 
     3634#line 1317 "compilers/imcc/imcc.y" 
    36393635    { adv_named_set(interp, (yyvsp[(3) - (4)].s)); (yyval.t) = 0; } 
    36403636    break; 
    36413637 
    36423638  case 131: 
    3643 #line 1322 "compilers/imcc/imcc.y" 
     3639#line 1318 "compilers/imcc/imcc.y" 
    36443640    { (yyval.t) = VT_UNIQUE_REG; } 
    36453641    break; 
    36463642 
    36473643  case 132: 
    3648 #line 1327 "compilers/imcc/imcc.y" 
     3644#line 1323 "compilers/imcc/imcc.y" 
    36493645    { begin_return_or_yield(interp, 0); } 
    36503646    break; 
    36513647 
    36523648  case 133: 
    3653 #line 1329 "compilers/imcc/imcc.y" 
     3649#line 1325 "compilers/imcc/imcc.y" 
    36543650    { (yyval.i) = 0; IMCC_INFO(interp)->asm_state = AsmDefault; } 
    36553651    break; 
    36563652 
    36573653  case 134: 
    3658 #line 1331 "compilers/imcc/imcc.y" 
     3654#line 1327 "compilers/imcc/imcc.y" 
    36593655    { 
    36603656           IMCC_INFO(interp)->asm_state = AsmDefault; 
    36613657           (yyval.i) = 0; 
     
    36633659    break; 
    36643660 
    36653661  case 135: 
    3666 #line 1338 "compilers/imcc/imcc.y" 
     3662#line 1334 "compilers/imcc/imcc.y" 
    36673663    { begin_return_or_yield(interp, 1); } 
    36683664    break; 
    36693665 
    36703666  case 136: 
    3671 #line 1340 "compilers/imcc/imcc.y" 
     3667#line 1336 "compilers/imcc/imcc.y" 
    36723668    { (yyval.i) = 0; IMCC_INFO(interp)->asm_state = AsmDefault; } 
    36733669    break; 
    36743670 
    36753671  case 137: 
    3676 #line 1344 "compilers/imcc/imcc.y" 
     3672#line 1340 "compilers/imcc/imcc.y" 
    36773673    { (yyval.sr) = 0; } 
    36783674    break; 
    36793675 
    36803676  case 138: 
    3681 #line 1346 "compilers/imcc/imcc.y" 
     3677#line 1342 "compilers/imcc/imcc.y" 
    36823678    { 
    36833679           if ((yyvsp[(1) - (2)].sr)) 
    36843680               add_pcc_result(IMCC_INFO(interp)->sr_return, (yyvsp[(1) - (2)].sr)); 
     
    36863682    break; 
    36873683 
    36883684  case 139: 
    3689 #line 1351 "compilers/imcc/imcc.y" 
     3685#line 1347 "compilers/imcc/imcc.y" 
    36903686    { 
    36913687           if ((yyvsp[(2) - (3)].sr)) 
    36923688               add_pcc_result(IMCC_INFO(interp)->sr_return, (yyvsp[(2) - (3)].sr)); 
     
    36943690    break; 
    36953691 
    36963692  case 140: 
    3697 #line 1358 "compilers/imcc/imcc.y" 
     3693#line 1354 "compilers/imcc/imcc.y" 
    36983694    { (yyval.sr) = 0; } 
    36993695    break; 
    37003696 
    37013697  case 141: 
    3702 #line 1360 "compilers/imcc/imcc.y" 
     3698#line 1356 "compilers/imcc/imcc.y" 
    37033699    { 
    37043700           if ((yyvsp[(1) - (2)].sr)) 
    37053701               add_pcc_result(IMCC_INFO(interp)->sr_return, (yyvsp[(1) - (2)].sr)); 
     
    37073703    break; 
    37083704 
    37093705  case 142: 
    3710 #line 1365 "compilers/imcc/imcc.y" 
     3706#line 1361 "compilers/imcc/imcc.y" 
    37113707    { 
    37123708           if ((yyvsp[(2) - (3)].sr)) 
    37133709               add_pcc_result(IMCC_INFO(interp)->sr_return, (yyvsp[(2) - (3)].sr)); 
     
    37153711    break; 
    37163712 
    37173713  case 143: 
    3718 #line 1372 "compilers/imcc/imcc.y" 
     3714#line 1368 "compilers/imcc/imcc.y" 
    37193715    { (yyval.sr) = (yyvsp[(2) - (3)].sr); (yyval.sr)->type |= (yyvsp[(3) - (3)].t); } 
    37203716    break; 
    37213717 
    37223718  case 144: 
    3723 #line 1376 "compilers/imcc/imcc.y" 
     3719#line 1372 "compilers/imcc/imcc.y" 
    37243720    { (yyval.sr) = (yyvsp[(2) - (3)].sr); (yyval.sr)->type |= (yyvsp[(3) - (3)].t); } 
    37253721    break; 
    37263722 
    37273723  case 145: 
    3728 #line 1381 "compilers/imcc/imcc.y" 
     3724#line 1377 "compilers/imcc/imcc.y" 
    37293725    { 
    37303726          if (IMCC_INFO(interp)->asm_state == AsmDefault) 
    37313727              begin_return_or_yield(interp, (yyvsp[(1) - (2)].t)); 
     
    37333729    break; 
    37343730 
    37353731  case 146: 
    3736 #line 1386 "compilers/imcc/imcc.y" 
     3732#line 1382 "compilers/imcc/imcc.y" 
    37373733    { 
    37383734          IMCC_INFO(interp)->asm_state = AsmDefault; 
    37393735          (yyval.t) = 0; 
     
    37413737    break; 
    37423738 
    37433739  case 147: 
    3744 #line 1393 "compilers/imcc/imcc.y" 
     3740#line 1389 "compilers/imcc/imcc.y" 
    37453741    { (yyval.t) = 0; } 
    37463742    break; 
    37473743 
    37483744  case 148: 
    3749 #line 1394 "compilers/imcc/imcc.y" 
     3745#line 1390 "compilers/imcc/imcc.y" 
    37503746    { (yyval.t) = 1; } 
    37513747    break; 
    37523748 
    37533749  case 149: 
    3754 #line 1398 "compilers/imcc/imcc.y" 
     3750#line 1394 "compilers/imcc/imcc.y" 
    37553751    { (yyval.i) = 0; } 
    37563752    break; 
    37573753 
    37583754  case 150: 
    3759 #line 1400 "compilers/imcc/imcc.y" 
     3755#line 1396 "compilers/imcc/imcc.y" 
    37603756    { 
    37613757           if (IMCC_INFO(interp)->adv_named_id) { 
    37623758               add_pcc_named_return(interp, IMCC_INFO(interp)->sr_return, 
     
    37693765    break; 
    37703766 
    37713767  case 151: 
    3772 #line 1410 "compilers/imcc/imcc.y" 
     3768#line 1406 "compilers/imcc/imcc.y" 
    37733769    { 
    37743770           add_pcc_named_return(interp, IMCC_INFO(interp)->sr_return, (yyvsp[(1) - (3)].s), (yyvsp[(3) - (3)].sr)); 
    37753771         } 
    37763772    break; 
    37773773 
    37783774  case 152: 
    3779 #line 1414 "compilers/imcc/imcc.y" 
     3775#line 1410 "compilers/imcc/imcc.y" 
    37803776    { 
    37813777           if (IMCC_INFO(interp)->adv_named_id) { 
    37823778               add_pcc_named_return(interp, IMCC_INFO(interp)->sr_return, 
     
    37893785    break; 
    37903786 
    37913787  case 153: 
    3792 #line 1424 "compilers/imcc/imcc.y" 
     3788#line 1420 "compilers/imcc/imcc.y" 
    37933789    { 
    37943790           add_pcc_named_return(interp, IMCC_INFO(interp)->sr_return, (yyvsp[(3) - (5)].s), (yyvsp[(5) - (5)].sr)); 
    37953791         } 
    37963792    break; 
    37973793 
    37983794  case 156: 
    3799 #line 1444 "compilers/imcc/imcc.y" 
     3795#line 1440 "compilers/imcc/imcc.y" 
    38003796    { clear_state(interp); } 
    38013797    break; 
    38023798 
    38033799  case 157: 
    3804 #line 1449 "compilers/imcc/imcc.y" 
     3800#line 1445 "compilers/imcc/imcc.y" 
    38053801    { (yyval.i) = (yyvsp[(2) - (2)].i); } 
    38063802    break; 
    38073803 
    38083804  case 158: 
    3809 #line 1450 "compilers/imcc/imcc.y" 
     3805#line 1446 "compilers/imcc/imcc.y" 
    38103806    { (yyval.i) = 0; } 
    38113807    break; 
    38123808 
    38133809  case 159: 
    3814 #line 1451 "compilers/imcc/imcc.y" 
     3810#line 1447 "compilers/imcc/imcc.y" 
    38153811    { (yyval.i) = 0; } 
    38163812    break; 
    38173813 
    38183814  case 160: 
    3819 #line 1452 "compilers/imcc/imcc.y" 
     3815#line 1448 "compilers/imcc/imcc.y" 
    38203816    { (yyval.i) = 0; } 
    38213817    break; 
    38223818 
    38233819  case 161: 
    3824 #line 1453 "compilers/imcc/imcc.y" 
     3820#line 1449 "compilers/imcc/imcc.y" 
    38253821    { (yyval.i) = 0; } 
    38263822    break; 
    38273823 
    38283824  case 162: 
    3829 #line 1457 "compilers/imcc/imcc.y" 
     3825#line 1453 "compilers/imcc/imcc.y" 
    38303826    { (yyval.i) = NULL; } 
    38313827    break; 
    38323828 
    38333829  case 166: 
    3834 #line 1468 "compilers/imcc/imcc.y" 
     3830#line 1464 "compilers/imcc/imcc.y" 
    38353831    { 
    38363832           (yyval.i) = iLABEL(interp, IMCC_INFO(interp)->cur_unit, mk_local_label(interp, (yyvsp[(1) - (1)].s))); 
    38373833         } 
    38383834    break; 
    38393835 
    38403836  case 167: 
    3841 #line 1476 "compilers/imcc/imcc.y" 
     3837#line 1472 "compilers/imcc/imcc.y" 
    38423838    { (yyval.i) = (yyvsp[(2) - (3)].i); } 
    38433839    break; 
    38443840 
    38453841  case 168: 
    3846 #line 1478 "compilers/imcc/imcc.y" 
     3842#line 1474 "compilers/imcc/imcc.y" 
    38473843    { 
    38483844           if (yynerrs >= PARROT_MAX_RECOVER_ERRORS) { 
    38493845               IMCC_warning(interp, "Too many errors. Correct some first.\n"); 
     
    38543850    break; 
    38553851 
    38563852  case 169: 
    3857 #line 1489 "compilers/imcc/imcc.y" 
     3853#line 1485 "compilers/imcc/imcc.y" 
    38583854    { 
    38593855           IdList* l = (yyvsp[(1) - (1)].idlist); 
    38603856           l->next = NULL; 
     
    38633859    break; 
    38643860 
    38653861  case 170: 
    3866 #line 1496 "compilers/imcc/imcc.y" 
     3862#line 1492 "compilers/imcc/imcc.y" 
    38673863    { 
    38683864           IdList* l = (yyvsp[(3) - (3)].idlist); 
    38693865           l->next = (yyvsp[(1) - (3)].idlist); 
     
    38723868    break; 
    38733869 
    38743870  case 171: 
    3875 #line 1505 "compilers/imcc/imcc.y" 
     3871#line 1501 "compilers/imcc/imcc.y" 
    38763872    { 
    38773873           IdList* const l = mem_allocate_n_zeroed_typed(1, IdList); 
    38783874           l->id           = (yyvsp[(1) - (2)].s); 
     
    38823878    break; 
    38833879 
    38843880  case 172: 
    3885 #line 1514 "compilers/imcc/imcc.y" 
     3881#line 1510 "compilers/imcc/imcc.y" 
    38863882    { (yyval.t) = 0; } 
    38873883    break; 
    38883884 
    38893885  case 173: 
    3890 #line 1515 "compilers/imcc/imcc.y" 
     3886#line 1511 "compilers/imcc/imcc.y" 
    38913887    { (yyval.t) = 1; } 
    38923888    break; 
    38933889 
    38943890  case 176: 
    3895 #line 1522 "compilers/imcc/imcc.y" 
     3891#line 1518 "compilers/imcc/imcc.y" 
    38963892    { is_def=1; } 
    38973893    break; 
    38983894 
    38993895  case 177: 
    3900 #line 1523 "compilers/imcc/imcc.y" 
     3896#line 1519 "compilers/imcc/imcc.y" 
    39013897    { 
    39023898           IdList *l = (yyvsp[(4) - (4)].idlist); 
    39033899           while (l) { 
     
    39163912    break; 
    39173913 
    39183914  case 178: 
    3919 #line 1539 "compilers/imcc/imcc.y" 
     3915#line 1535 "compilers/imcc/imcc.y" 
    39203916    { 
    39213917           set_lexical(interp, (yyvsp[(4) - (4)].sr), (yyvsp[(2) - (4)].s)); (yyval.i) = 0; 
    39223918         } 
    39233919    break; 
    39243920 
    39253921  case 179: 
    3926 #line 1542 "compilers/imcc/imcc.y" 
     3922#line 1538 "compilers/imcc/imcc.y" 
    39273923    { is_def=1; } 
    39283924    break; 
    39293925 
    39303926  case 180: 
    3931 #line 1543 "compilers/imcc/imcc.y" 
     3927#line 1539 "compilers/imcc/imcc.y" 
    39323928    { 
    39333929           mk_const_ident(interp, (yyvsp[(4) - (6)].s), (yyvsp[(3) - (6)].t), (yyvsp[(6) - (6)].sr), 0); 
    39343930           is_def=0; 
     
    39373933    break; 
    39383934 
    39393935  case 182: 
    3940 #line 1550 "compilers/imcc/imcc.y" 
     3936#line 1546 "compilers/imcc/imcc.y" 
    39413937    { is_def=1; } 
    39423938    break; 
    39433939 
    39443940  case 183: 
    3945 #line 1551 "compilers/imcc/imcc.y" 
     3941#line 1547 "compilers/imcc/imcc.y" 
    39463942    { 
    39473943           mk_const_ident(interp, (yyvsp[(4) - (6)].s), (yyvsp[(3) - (6)].t), (yyvsp[(6) - (6)].sr), 1); 
    39483944           is_def=0; 
     
    39513947    break; 
    39523948 
    39533949  case 184: 
    3954 #line 1557 "compilers/imcc/imcc.y" 
     3950#line 1553 "compilers/imcc/imcc.y" 
    39553951    { 
    39563952           (yyval.i) = NULL; 
    39573953           IMCC_INFO(interp)->cur_call->pcc_sub->flags |= isTAIL_CALL; 
     
    39603956    break; 
    39613957 
    39623958  case 185: 
    3963 #line 1562 "compilers/imcc/imcc.y" 
     3959#line 1558 "compilers/imcc/imcc.y" 
    39643960    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "branch", 1, (yyvsp[(2) - (2)].sr)); } 
    39653961    break; 
    39663962 
    39673963  case 186: 
    3968 #line 1564 "compilers/imcc/imcc.y" 
     3964#line 1560 "compilers/imcc/imcc.y" 
    39693965    { 
    39703966           (yyval.i) = INS(interp, 
    39713967                    IMCC_INFO(interp)->cur_unit, 
     
    39803976    break; 
    39813977 
    39823978  case 187: 
    3983 #line 1575 "compilers/imcc/imcc.y" 
     3979#line 1571 "compilers/imcc/imcc.y" 
    39843980    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "null", 1, (yyvsp[(2) - (2)].sr)); } 
    39853981    break; 
    39863982 
    39873983  case 188: 
    3988 #line 1576 "compilers/imcc/imcc.y" 
     3984#line 1572 "compilers/imcc/imcc.y" 
    39893985    { (yyval.i) = 0; IMCC_INFO(interp)->cur_call = NULL; } 
    39903986    break; 
    39913987 
    39923988  case 189: 
    3993 #line 1577 "compilers/imcc/imcc.y" 
     3989#line 1573 "compilers/imcc/imcc.y" 
    39943990    { (yyval.i) = 0; } 
    39953991    break; 
    39963992 
    39973993  case 192: 
    3998 #line 1580 "compilers/imcc/imcc.y" 
     3994#line 1576 "compilers/imcc/imcc.y" 
    39993995    { (yyval.i) = 0;} 
    40003996    break; 
    40013997 
    40023998  case 193: 
    4003 #line 1584 "compilers/imcc/imcc.y" 
     3999#line 1580 "compilers/imcc/imcc.y" 
    40044000    { (yyval.t) = 'I'; } 
    40054001    break; 
    40064002 
    40074003  case 194: 
    4008 #line 1585 "compilers/imcc/imcc.y" 
     4004#line 1581 "compilers/imcc/imcc.y" 
    40094005    { (yyval.t) = 'N'; } 
    40104006    break; 
    40114007 
    40124008  case 195: 
    4013 #line 1586 "compilers/imcc/imcc.y" 
     4009#line 1582 "compilers/imcc/imcc.y" 
    40144010    { (yyval.t) = 'S'; } 
    40154011    break; 
    40164012 
    40174013  case 196: 
    4018 #line 1587 "compilers/imcc/imcc.y" 
     4014#line 1583 "compilers/imcc/imcc.y" 
    40194015    { (yyval.t) = 'P'; } 
    40204016    break; 
    40214017 
    40224018  case 197: 
    4023 #line 1592 "compilers/imcc/imcc.y" 
     4019#line 1588 "compilers/imcc/imcc.y" 
    40244020    { 
    40254021           /* there'd normally be a str_dup() here, but the lexer already 
    40264022            * copied the string, so it's safe to use directly */ 
    4027            if ((IMCC_INFO(interp)->cur_pmc_type = pmc_type(interp, 
     4023           if ((IMCC_INFO(interp)->cur_pmc_type = lookup_typeid_s(interp, 
    40284024               string_from_cstring(interp, (yyvsp[(1) - (1)].s), 0))) <= 0) { 
    40294025               IMCC_fataly(interp, EXCEPTION_SYNTAX_ERROR, 
    40304026                    "Unknown PMC type '%s'\n", (yyvsp[(1) - (1)].s)); 
     
    40334029    break; 
    40344030 
    40354031  case 198: 
    4036 #line 1605 "compilers/imcc/imcc.y" 
     4032#line 1601 "compilers/imcc/imcc.y" 
    40374033    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "set", 2, (yyvsp[(1) - (3)].sr), (yyvsp[(3) - (3)].sr));  } 
    40384034    break; 
    40394035 
    40404036  case 199: 
    4041 #line 1607 "compilers/imcc/imcc.y" 
     4037#line 1603 "compilers/imcc/imcc.y" 
    40424038    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(3) - (4)].s), 2, (yyvsp[(1) - (4)].sr), (yyvsp[(4) - (4)].sr));  } 
    40434039    break; 
    40444040 
    40454041  case 200: 
    4046 #line 1609 "compilers/imcc/imcc.y" 
     4042#line 1605 "compilers/imcc/imcc.y" 
    40474043    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(4) - (5)].s), 3, (yyvsp[(1) - (5)].sr), (yyvsp[(3) - (5)].sr), (yyvsp[(5) - (5)].sr));  } 
    40484044    break; 
    40494045 
    40504046  case 201: 
    4051 #line 1611 "compilers/imcc/imcc.y" 
     4047#line 1607 "compilers/imcc/imcc.y" 
    40524048    { (yyval.i) = iINDEXFETCH(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(1) - (6)].sr), (yyvsp[(3) - (6)].sr), (yyvsp[(5) - (6)].sr)); } 
    40534049    break; 
    40544050 
    40554051  case 202: 
    4056 #line 1613 "compilers/imcc/imcc.y" 
     4052#line 1609 "compilers/imcc/imcc.y" 
    40574053    { (yyval.i) = iINDEXSET(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(1) - (6)].sr), (yyvsp[(3) - (6)].sr), (yyvsp[(6) - (6)].sr)); } 
    40584054    break; 
    40594055 
    40604056  case 203: 
    4061 #line 1615 "compilers/imcc/imcc.y" 
     4057#line 1611 "compilers/imcc/imcc.y" 
    40624058    { (yyval.i) = iNEW(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(1) - (6)].sr), (yyvsp[(4) - (6)].s), (yyvsp[(6) - (6)].sr), 1); } 
    40634059    break; 
    40644060 
    40654061  case 204: 
    4066 #line 1617 "compilers/imcc/imcc.y" 
     4062#line 1613 "compilers/imcc/imcc.y" 
    40674063    { (yyval.i) = iNEW(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(1) - (7)].sr), (yyvsp[(4) - (7)].s), (yyvsp[(6) - (7)].sr), 1); } 
    40684064    break; 
    40694065 
    40704066  case 205: 
    4071 #line 1619 "compilers/imcc/imcc.y" 
     4067#line 1615 "compilers/imcc/imcc.y" 
    40724068    { (yyval.i) = iNEW(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(1) - (4)].sr), (yyvsp[(4) - (4)].s), NULL, 1); } 
    40734069    break; 
    40744070 
    40754071  case 206: 
    4076 #line 1621 "compilers/imcc/imcc.y" 
     4072#line 1617 "compilers/imcc/imcc.y" 
    40774073    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 2, (yyvsp[(1) - (4)].sr), (yyvsp[(4) - (4)].sr)); } 
    40784074    break; 
    40794075 
    40804076  case 207: 
    4081 #line 1623 "compilers/imcc/imcc.y" 
     4077#line 1619 "compilers/imcc/imcc.y" 
    40824078    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 2, (yyvsp[(1) - (4)].sr), (yyvsp[(4) - (4)].sr)); } 
    40834079    break; 
    40844080 
    40854081  case 208: 
    4086 #line 1625 "compilers/imcc/imcc.y" 
     4082#line 1621 "compilers/imcc/imcc.y" 
    40874083    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 3, (yyvsp[(1) - (6)].sr), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].sr)); } 
    40884084    break; 
    40894085 
    40904086  case 209: 
    4091 #line 1627 "compilers/imcc/imcc.y" 
     4087#line 1623 "compilers/imcc/imcc.y" 
    40924088    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 3, (yyvsp[(1) - (6)].sr), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].sr)); } 
    40934089    break; 
    40944090 
    40954091  case 210: 
    4096 #line 1629 "compilers/imcc/imcc.y" 
     4092#line 1625 "compilers/imcc/imcc.y" 
    40974093    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 3, (yyvsp[(1) - (7)].sr), (yyvsp[(4) - (7)].sr), (yyvsp[(6) - (7)].sr)); } 
    40984094    break; 
    40994095 
    41004096  case 211: 
    4101 #line 1633 "compilers/imcc/imcc.y" 
     4097#line 1629 "compilers/imcc/imcc.y" 
    41024098    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 2, (yyvsp[(2) - (4)].sr), (yyvsp[(4) - (4)].sr)); } 
    41034099    break; 
    41044100 
    41054101  case 212: 
    4106 #line 1635 "compilers/imcc/imcc.y" 
     4102#line 1631 "compilers/imcc/imcc.y" 
    41074103    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 3, (yyvsp[(2) - (6)].sr), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].sr)); } 
    41084104    break; 
    41094105 
    41104106  case 213: 
    4111 #line 1637 "compilers/imcc/imcc.y" 
     4107#line 1633 "compilers/imcc/imcc.y" 
    41124108    { (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "new", 3, (yyvsp[(2) - (7)].sr), (yyvsp[(4) - (7)].sr), (yyvsp[(6) - (7)].sr)); } 
    41134109    break; 
    41144110 
    41154111  case 214: 
    4116 #line 1640 "compilers/imcc/imcc.y" 
     4112#line 1636 "compilers/imcc/imcc.y" 
    41174113    { 
    41184114           add_pcc_result((yyvsp[(3) - (3)].i)->symregs[0], (yyvsp[(1) - (3)].sr)); 
    41194115           IMCC_INFO(interp)->cur_call = NULL; 
     
    41224118    break; 
    41234119 
    41244120  case 215: 
    4125 #line 1646 "compilers/imcc/imcc.y" 
     4121#line 1642 "compilers/imcc/imcc.y" 
    41264122    { 
    41274123           (yyval.i) = IMCC_create_itcall_label(interp); 
    41284124         } 
    41294125    break; 
    41304126 
    41314127  case 216: 
    4132 #line 1650 "compilers/imcc/imcc.y" 
     4128#line 1646 "compilers/imcc/imcc.y" 
    41334129    { 
    41344130           IMCC_itcall_sub(interp, (yyvsp[(6) - (9)].sr)); 
    41354131           IMCC_INFO(interp)->cur_call = NULL; 
     
    41374133    break; 
    41384134 
    41394135  case 220: 
    4140 #line 1658 "compilers/imcc/imcc.y" 
     4136#line 1654 "compilers/imcc/imcc.y" 
    41414137    { 
    41424138           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "null", 1, (yyvsp[(1) - (3)].sr)); 
    41434139         } 
    41444140    break; 
    41454141 
    41464142  case 221: 
    4147 #line 1665 "compilers/imcc/imcc.y" 
     4143#line 1661 "compilers/imcc/imcc.y" 
    41484144    { (yyval.s) = (char *)"not"; } 
    41494145    break; 
    41504146 
    41514147  case 222: 
    4152 #line 1666 "compilers/imcc/imcc.y" 
     4148#line 1662 "compilers/imcc/imcc.y" 
    41534149    { (yyval.s) = (char *)"bnot"; } 
    41544150    break; 
    41554151 
    41564152  case 223: 
    4157 #line 1667 "compilers/imcc/imcc.y" 
     4153#line 1663 "compilers/imcc/imcc.y" 
    41584154    { (yyval.s) = (char *)"neg"; } 
    41594155    break; 
    41604156 
    41614157  case 224: 
    4162 #line 1671 "compilers/imcc/imcc.y" 
     4158#line 1667 "compilers/imcc/imcc.y" 
    41634159    { (yyval.s) = (char *)"sub"; } 
    41644160    break; 
    41654161 
    41664162  case 225: 
    4167 #line 1672 "compilers/imcc/imcc.y" 
     4163#line 1668 "compilers/imcc/imcc.y" 
    41684164    { (yyval.s) = (char *)"add"; } 
    41694165    break; 
    41704166 
    41714167  case 226: 
    4172 #line 1673 "compilers/imcc/imcc.y" 
     4168#line 1669 "compilers/imcc/imcc.y" 
    41734169    { (yyval.s) = (char *)"mul"; } 
    41744170    break; 
    41754171 
    41764172  case 227: 
    4177 #line 1674 "compilers/imcc/imcc.y" 
     4173#line 1670 "compilers/imcc/imcc.y" 
    41784174    { (yyval.s) = (char *)"div"; } 
    41794175    break; 
    41804176 
    41814177  case 228: 
    4182 #line 1675 "compilers/imcc/imcc.y" 
     4178#line 1671 "compilers/imcc/imcc.y" 
    41834179    { (yyval.s) = (char *)"mod"; } 
    41844180    break; 
    41854181 
    41864182  case 229: 
    4187 #line 1676 "compilers/imcc/imcc.y" 
     4183#line 1672 "compilers/imcc/imcc.y" 
    41884184    { (yyval.s) = (char *)"fdiv"; } 
    41894185    break; 
    41904186 
    41914187  case 230: 
    4192 #line 1677 "compilers/imcc/imcc.y" 
     4188#line 1673 "compilers/imcc/imcc.y" 
    41934189    { (yyval.s) = (char *)"pow"; } 
    41944190    break; 
    41954191 
    41964192  case 231: 
    4197 #line 1678 "compilers/imcc/imcc.y" 
     4193#line 1674 "compilers/imcc/imcc.y" 
    41984194    { (yyval.s) = (char *)"concat"; } 
    41994195    break; 
    42004196 
    42014197  case 232: 
    4202 #line 1679 "compilers/imcc/imcc.y" 
     4198#line 1675 "compilers/imcc/imcc.y" 
    42034199    { (yyval.s) = (char *)"iseq"; } 
    42044200    break; 
    42054201 
    42064202  case 233: 
    4207 #line 1680 "compilers/imcc/imcc.y" 
     4203#line 1676 "compilers/imcc/imcc.y" 
    42084204    { (yyval.s) = (char *)"isne"; } 
    42094205    break; 
    42104206 
    42114207  case 234: 
    4212 #line 1681 "compilers/imcc/imcc.y" 
     4208#line 1677 "compilers/imcc/imcc.y" 
    42134209    { (yyval.s) = (char *)"isgt"; } 
    42144210    break; 
    42154211 
    42164212  case 235: 
    4217 #line 1682 "compilers/imcc/imcc.y" 
     4213#line 1678 "compilers/imcc/imcc.y" 
    42184214    { (yyval.s) = (char *)"isge"; } 
    42194215    break; 
    42204216 
    42214217  case 236: 
    4222 #line 1683 "compilers/imcc/imcc.y" 
     4218#line 1679 "compilers/imcc/imcc.y" 
    42234219    { (yyval.s) = (char *)"islt"; } 
    42244220    break; 
    42254221 
    42264222  case 237: 
    4227 #line 1684 "compilers/imcc/imcc.y" 
     4223#line 1680 "compilers/imcc/imcc.y" 
    42284224    { (yyval.s) = (char *)"isle"; } 
    42294225    break; 
    42304226 
    42314227  case 238: 
    4232 #line 1685 "compilers/imcc/imcc.y" 
     4228#line 1681 "compilers/imcc/imcc.y" 
    42334229    { (yyval.s) = (char *)"shl"; } 
    42344230    break; 
    42354231 
    42364232  case 239: 
    4237 #line 1686 "compilers/imcc/imcc.y" 
     4233#line 1682 "compilers/imcc/imcc.y" 
    42384234    { (yyval.s) = (char *)"shr"; } 
    42394235    break; 
    42404236 
    42414237  case 240: 
    4242 #line 1687 "compilers/imcc/imcc.y" 
     4238#line 1683 "compilers/imcc/imcc.y" 
    42434239    { (yyval.s) = (char *)"lsr"; } 
    42444240    break; 
    42454241 
    42464242  case 241: 
    4247 #line 1688 "compilers/imcc/imcc.y" 
     4243#line 1684 "compilers/imcc/imcc.y" 
    42484244    { (yyval.s) = (char *)"and"; } 
    42494245    break; 
    42504246 
    42514247  case 242: 
    4252 #line 1689 "compilers/imcc/imcc.y" 
     4248#line 1685 "compilers/imcc/imcc.y" 
    42534249    { (yyval.s) = (char *)"or"; } 
    42544250    break; 
    42554251 
    42564252  case 243: 
    4257 #line 1690 "compilers/imcc/imcc.y" 
     4253#line 1686 "compilers/imcc/imcc.y" 
    42584254    { (yyval.s) = (char *)"xor"; } 
    42594255    break; 
    42604256 
    42614257  case 244: 
    4262 #line 1691 "compilers/imcc/imcc.y" 
     4258#line 1687 "compilers/imcc/imcc.y" 
    42634259    { (yyval.s) = (char *)"band"; } 
    42644260    break; 
    42654261 
    42664262  case 245: 
    4267 #line 1692 "compilers/imcc/imcc.y" 
     4263#line 1688 "compilers/imcc/imcc.y" 
    42684264    { (yyval.s) = (char *)"bor"; } 
    42694265    break; 
    42704266 
    42714267  case 246: 
    4272 #line 1693 "compilers/imcc/imcc.y" 
     4268#line 1689 "compilers/imcc/imcc.y" 
    42734269    { (yyval.s) = (char *)"bxor"; } 
    42744270    break; 
    42754271 
    42764272  case 247: 
    4277 #line 1699 "compilers/imcc/imcc.y" 
     4273#line 1695 "compilers/imcc/imcc.y" 
    42784274    { 
    42794275           (yyval.i) = IMCC_create_itcall_label(interp); 
    42804276           (yyval.i)->type &= ~ITCALL; 
     
    42834279    break; 
    42844280 
    42854281  case 248: 
    4286 #line 1704 "compilers/imcc/imcc.y" 
     4282#line 1700 "compilers/imcc/imcc.y" 
    42874283    {  (yyval.i) = 0; } 
    42884284    break; 
    42894285 
    42904286  case 249: 
    4291 #line 1711 "compilers/imcc/imcc.y" 
     4287#line 1707 "compilers/imcc/imcc.y" 
    42924288    { 
    42934289           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(2) - (3)].s), 2, (yyvsp[(1) - (3)].sr), (yyvsp[(3) - (3)].sr)); 
    42944290         } 
    42954291    break; 
    42964292 
    42974293  case 250: 
    4298 #line 1717 "compilers/imcc/imcc.y" 
     4294#line 1713 "compilers/imcc/imcc.y" 
    42994295    { (yyval.s) = (char *)"add"; } 
    43004296    break; 
    43014297 
    43024298  case 251: 
    4303 #line 1718 "compilers/imcc/imcc.y" 
     4299#line 1714 "compilers/imcc/imcc.y" 
    43044300    { (yyval.s) = (char *)"sub"; } 
    43054301    break; 
    43064302 
    43074303  case 252: 
    4308 #line 1719 "compilers/imcc/imcc.y" 
     4304#line 1715 "compilers/imcc/imcc.y" 
    43094305    { (yyval.s) = (char *)"mul"; } 
    43104306    break; 
    43114307 
    43124308  case 253: 
    4313 #line 1720 "compilers/imcc/imcc.y" 
     4309#line 1716 "compilers/imcc/imcc.y" 
    43144310    { (yyval.s) = (char *)"div"; } 
    43154311    break; 
    43164312 
    43174313  case 254: 
    4318 #line 1721 "compilers/imcc/imcc.y" 
     4314#line 1717 "compilers/imcc/imcc.y" 
    43194315    { (yyval.s) = (char *)"mod"; } 
    43204316    break; 
    43214317 
    43224318  case 255: 
    4323 #line 1722 "compilers/imcc/imcc.y" 
     4319#line 1718 "compilers/imcc/imcc.y" 
    43244320    { (yyval.s) = (char *)"fdiv"; } 
    43254321    break; 
    43264322 
    43274323  case 256: 
    4328 #line 1723 "compilers/imcc/imcc.y" 
     4324#line 1719 "compilers/imcc/imcc.y" 
    43294325    { (yyval.s) = (char *)"concat"; } 
    43304326    break; 
    43314327 
    43324328  case 257: 
    4333 #line 1724 "compilers/imcc/imcc.y" 
     4329#line 1720 "compilers/imcc/imcc.y" 
    43344330    { (yyval.s) = (char *)"band"; } 
    43354331    break; 
    43364332 
    43374333  case 258: 
    4338 #line 1725 "compilers/imcc/imcc.y" 
     4334#line 1721 "compilers/imcc/imcc.y" 
    43394335    { (yyval.s) = (char *)"bor"; } 
    43404336    break; 
    43414337 
    43424338  case 259: 
    4343 #line 1726 "compilers/imcc/imcc.y" 
     4339#line 1722 "compilers/imcc/imcc.y" 
    43444340    { (yyval.s) = (char *)"bxor"; } 
    43454341    break; 
    43464342 
    43474343  case 260: 
    4348 #line 1727 "compilers/imcc/imcc.y" 
     4344#line 1723 "compilers/imcc/imcc.y" 
    43494345    { (yyval.s) = (char *)"shr"; } 
    43504346    break; 
    43514347 
    43524348  case 261: 
    4353 #line 1728 "compilers/imcc/imcc.y" 
     4349#line 1724 "compilers/imcc/imcc.y" 
    43544350    { (yyval.s) = (char *)"shl"; } 
    43554351    break; 
    43564352 
    43574353  case 262: 
    4358 #line 1729 "compilers/imcc/imcc.y" 
     4354#line 1725 "compilers/imcc/imcc.y" 
    43594355    { (yyval.s) = (char *)"lsr"; } 
    43604356    break; 
    43614357 
    43624358  case 263: 
    4363 #line 1735 "compilers/imcc/imcc.y" 
     4359#line 1731 "compilers/imcc/imcc.y" 
    43644360    { 
    43654361        (yyval.i) = func_ins(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(1) - (4)].sr), (yyvsp[(3) - (4)].s), 
    43664362                      IMCC_INFO(interp) -> regs, 
     
    43714367    break; 
    43724368 
    43734369  case 264: 
    4374 #line 1745 "compilers/imcc/imcc.y" 
     4370#line 1741 "compilers/imcc/imcc.y" 
    43754371    { (yyval.sr) = mk_sub_address(interp, (yyvsp[(1) - (1)].s));  mem_sys_free((yyvsp[(1) - (1)].s)); } 
    43764372    break; 
    43774373 
    43784374  case 265: 
    4379 #line 1746 "compilers/imcc/imcc.y" 
     4375#line 1742 "compilers/imcc/imcc.y" 
    43804376    { (yyval.sr) = mk_sub_address_fromc(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    43814377    break; 
    43824378 
    43834379  case 266: 
    4384 #line 1747 "compilers/imcc/imcc.y" 
     4380#line 1743 "compilers/imcc/imcc.y" 
    43854381    { (yyval.sr) = mk_sub_address_u(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    43864382    break; 
    43874383 
    43884384  case 267: 
    4389 #line 1749 "compilers/imcc/imcc.y" 
     4385#line 1745 "compilers/imcc/imcc.y" 
    43904386    { 
    43914387           (yyval.sr) = (yyvsp[(1) - (1)].sr); 
    43924388           if ((yyvsp[(1) - (1)].sr)->set != 'P') 
     
    43954391    break; 
    43964392 
    43974393  case 268: 
    4398 #line 1755 "compilers/imcc/imcc.y" 
     4394#line 1751 "compilers/imcc/imcc.y" 
    43994395    { 
    44004396            /* disallow bareword method names; SREG name constants are fine */ 
    44014397            char *name = (yyvsp[(3) - (3)].sr)->name; 
     
    44124408    break; 
    44134409 
    44144410  case 269: 
    4415 #line 1769 "compilers/imcc/imcc.y" 
     4411#line 1765 "compilers/imcc/imcc.y" 
    44164412    { 
    44174413            IMCC_INFO(interp)->cur_obj = (yyvsp[(1) - (3)].sr); 
    44184414            (yyval.sr)                         = mk_const(interp, (yyvsp[(3) - (3)].s), 'S'); 
     
    44214417    break; 
    44224418 
    44234419  case 270: 
    4424 #line 1774 "compilers/imcc/imcc.y" 
     4420#line 1770 "compilers/imcc/imcc.y" 
    44254421    { IMCC_INFO(interp)->cur_obj = (yyvsp[(1) - (3)].sr); (yyval.sr) = (yyvsp[(3) - (3)].sr); } 
    44264422    break; 
    44274423 
    44284424  case 271: 
    4429 #line 1780 "compilers/imcc/imcc.y" 
     4425#line 1776 "compilers/imcc/imcc.y" 
    44304426    { 
    44314427           (yyval.i) = IMCC_create_itcall_label(interp); 
    44324428           IMCC_itcall_sub(interp, (yyvsp[(1) - (1)].sr)); 
     
    44344430    break; 
    44354431 
    44364432  case 272: 
    4437 #line 1784 "compilers/imcc/imcc.y" 
     4433#line 1780 "compilers/imcc/imcc.y" 
    44384434    { (yyval.i) = (yyvsp[(2) - (5)].i); } 
    44394435    break; 
    44404436 
    44414437  case 273: 
    4442 #line 1788 "compilers/imcc/imcc.y" 
     4438#line 1784 "compilers/imcc/imcc.y" 
    44434439    { (yyval.sr) = 0; } 
    44444440    break; 
    44454441 
    44464442  case 274: 
    4447 #line 1790 "compilers/imcc/imcc.y" 
     4443#line 1786 "compilers/imcc/imcc.y" 
    44484444    { 
    44494445           (yyval.sr) = 0; 
    44504446           if (IMCC_INFO(interp)->adv_named_id) { 
     
    44574453    break; 
    44584454 
    44594455  case 275: 
    4460 #line 1800 "compilers/imcc/imcc.y" 
     4456#line 1796 "compilers/imcc/imcc.y" 
    44614457    { 
    44624458           (yyval.sr) = 0; 
    44634459           if (IMCC_INFO(interp)->adv_named_id) { 
     
    44704466    break; 
    44714467 
    44724468  case 276: 
    4473 #line 1810 "compilers/imcc/imcc.y" 
     4469#line 1806 "compilers/imcc/imcc.y" 
    44744470    { 
    44754471           (yyval.sr) = 0; 
    44764472           add_pcc_named_arg(interp, IMCC_INFO(interp)->cur_call, (yyvsp[(3) - (5)].s), (yyvsp[(5) - (5)].sr)); 
     
    44794475    break; 
    44804476 
    44814477  case 277: 
    4482 #line 1816 "compilers/imcc/imcc.y" 
     4478#line 1812 "compilers/imcc/imcc.y" 
    44834479    { 
    44844480           (yyval.sr) = 0; 
    44854481           add_pcc_named_arg(interp, IMCC_INFO(interp)->cur_call, (yyvsp[(1) - (3)].s), (yyvsp[(3) - (3)].sr)); 
     
    44884484    break; 
    44894485 
    44904486  case 278: 
    4491 #line 1824 "compilers/imcc/imcc.y" 
     4487#line 1820 "compilers/imcc/imcc.y" 
    44924488    { (yyval.sr) = (yyvsp[(1) - (2)].sr); (yyval.sr)->type |= (yyvsp[(2) - (2)].t); } 
    44934489    break; 
    44944490 
    44954491  case 279: 
    4496 #line 1828 "compilers/imcc/imcc.y" 
     4492#line 1824 "compilers/imcc/imcc.y" 
    44974493    { (yyval.t) = 0; } 
    44984494    break; 
    44994495 
    45004496  case 280: 
    4501 #line 1829 "compilers/imcc/imcc.y" 
     4497#line 1825 "compilers/imcc/imcc.y" 
    45024498    { (yyval.t) = (yyvsp[(1) - (2)].t) | (yyvsp[(2) - (2)].t); } 
    45034499    break; 
    45044500 
    45054501  case 281: 
    4506 #line 1833 "compilers/imcc/imcc.y" 
     4502#line 1829 "compilers/imcc/imcc.y" 
    45074503    { (yyval.t) = VT_FLAT; } 
    45084504    break; 
    45094505 
    45104506  case 282: 
    4511 #line 1834 "compilers/imcc/imcc.y" 
     4507#line 1830 "compilers/imcc/imcc.y" 
    45124508    { (yyval.t) = VT_NAMED; } 
    45134509    break; 
    45144510 
    45154511  case 283: 
    4516 #line 1837 "compilers/imcc/imcc.y" 
     4512#line 1833 "compilers/imcc/imcc.y" 
    45174513    { adv_named_set(interp, (yyvsp[(3) - (4)].s)); (yyval.t) = 0; } 
    45184514    break; 
    45194515 
    45204516  case 284: 
    4521 #line 1841 "compilers/imcc/imcc.y" 
     4517#line 1837 "compilers/imcc/imcc.y" 
    45224518    { (yyval.sr) = (yyvsp[(1) - (2)].sr); (yyval.sr)->type |= (yyvsp[(2) - (2)].t); } 
    45234519    break; 
    45244520 
    45254521  case 285: 
    4526 #line 1846 "compilers/imcc/imcc.y" 
     4522#line 1842 "compilers/imcc/imcc.y" 
    45274523    { 
    45284524           (yyval.sr) = 0; 
    45294525           if (IMCC_INFO(interp)->adv_named_id) { 
     
    45364532    break; 
    45374533 
    45384534  case 286: 
    4539 #line 1856 "compilers/imcc/imcc.y" 
     4535#line 1852 "compilers/imcc/imcc.y" 
    45404536    { 
    45414537           add_pcc_named_result(interp, IMCC_INFO(interp)->cur_call, (yyvsp[(3) - (5)].s), (yyvsp[(5) - (5)].sr)); 
    45424538           mem_sys_free((yyvsp[(3) - (5)].s)); 
     
    45444540    break; 
    45454541 
    45464542  case 287: 
    4547 #line 1861 "compilers/imcc/imcc.y" 
     4543#line 1857 "compilers/imcc/imcc.y" 
    45484544    { 
    45494545           (yyval.sr) = 0; 
    45504546           if (IMCC_INFO(interp)->adv_named_id) { 
     
    45574553    break; 
    45584554 
    45594555  case 288: 
    4560 #line 1871 "compilers/imcc/imcc.y" 
     4556#line 1867 "compilers/imcc/imcc.y" 
    45614557    { 
    45624558           add_pcc_named_result(interp, IMCC_INFO(interp)->cur_call, (yyvsp[(1) - (3)].s), (yyvsp[(3) - (3)].sr)); 
    45634559           mem_sys_free((yyvsp[(1) - (3)].s)); 
     
    45654561    break; 
    45664562 
    45674563  case 289: 
    4568 #line 1875 "compilers/imcc/imcc.y" 
     4564#line 1871 "compilers/imcc/imcc.y" 
    45694565    { (yyval.sr) = 0; } 
    45704566    break; 
    45714567 
    45724568  case 290: 
    4573 #line 1879 "compilers/imcc/imcc.y" 
     4569#line 1875 "compilers/imcc/imcc.y" 
    45744570    { (yyval.i) = (yyvsp[(1) - (1)].i); } 
    45754571    break; 
    45764572 
    45774573  case 291: 
    4578 #line 1880 "compilers/imcc/imcc.y" 
     4574#line 1876 "compilers/imcc/imcc.y" 
    45794575    { (yyval.i) = (yyvsp[(1) - (1)].i); } 
    45804576    break; 
    45814577 
    45824578  case 292: 
    4583 #line 1885 "compilers/imcc/imcc.y" 
     4579#line 1881 "compilers/imcc/imcc.y" 
    45844580    { 
    45854581           (yyval.i) =MK_I(interp, IMCC_INFO(interp)->cur_unit, inv_op((yyvsp[(3) - (6)].s)), 3, (yyvsp[(2) - (6)].sr), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].sr)); 
    45864582         } 
    45874583    break; 
    45884584 
    45894585  case 293: 
    4590 #line 1889 "compilers/imcc/imcc.y" 
     4586#line 1885 "compilers/imcc/imcc.y" 
    45914587    { 
    45924588           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "unless_null", 2, (yyvsp[(3) - (5)].sr), (yyvsp[(5) - (5)].sr)); 
    45934589         } 
    45944590    break; 
    45954591 
    45964592  case 294: 
    4597 #line 1893 "compilers/imcc/imcc.y" 
     4593#line 1889 "compilers/imcc/imcc.y" 
    45984594    { 
    45994595           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "unless", 2, (yyvsp[(2) - (4)].sr), (yyvsp[(4) - (4)].sr)); 
    46004596         } 
    46014597    break; 
    46024598 
    46034599  case 295: 
    4604 #line 1900 "compilers/imcc/imcc.y" 
     4600#line 1896 "compilers/imcc/imcc.y" 
    46054601    { 
    46064602           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "if", 2, (yyvsp[(2) - (4)].sr), (yyvsp[(4) - (4)].sr)); 
    46074603         } 
    46084604    break; 
    46094605 
    46104606  case 296: 
    4611 #line 1904 "compilers/imcc/imcc.y" 
     4607#line 1900 "compilers/imcc/imcc.y" 
    46124608    { 
    46134609           (yyval.i) =MK_I(interp, IMCC_INFO(interp)->cur_unit, (yyvsp[(3) - (6)].s), 3, (yyvsp[(2) - (6)].sr), (yyvsp[(4) - (6)].sr), (yyvsp[(6) - (6)].sr)); 
    46144610         } 
    46154611    break; 
    46164612 
    46174613  case 297: 
    4618 #line 1908 "compilers/imcc/imcc.y" 
     4614#line 1904 "compilers/imcc/imcc.y" 
    46194615    { 
    46204616           (yyval.i) = MK_I(interp, IMCC_INFO(interp)->cur_unit, "if_null", 2, (yyvsp[(3) - (5)].sr), (yyvsp[(5) - (5)].sr)); 
    46214617         } 
    46224618    break; 
    46234619 
    46244620  case 298: 
    4625 #line 1914 "compilers/imcc/imcc.y" 
     4621#line 1910 "compilers/imcc/imcc.y" 
    46264622    { (yyval.t) = 0; } 
    46274623    break; 
    46284624 
    46294625  case 299: 
    4630 #line 1915 "compilers/imcc/imcc.y" 
     4626#line 1911 "compilers/imcc/imcc.y" 
    46314627    { (yyval.t) = 0; } 
    46324628    break; 
    46334629 
    46344630  case 300: 
    4635 #line 1919 "compilers/imcc/imcc.y" 
     4631#line 1915 "compilers/imcc/imcc.y" 
    46364632    { (yyval.s) = (char *)"eq"; } 
    46374633    break; 
    46384634 
    46394635  case 301: 
    4640 #line 1920 "compilers/imcc/imcc.y" 
     4636#line 1916 "compilers/imcc/imcc.y" 
    46414637    { (yyval.s) = (char *)"ne"; } 
    46424638    break; 
    46434639 
    46444640  case 302: 
    4645 #line 1921 "compilers/imcc/imcc.y" 
     4641#line 1917 "compilers/imcc/imcc.y" 
    46464642    { (yyval.s) = (char *)"gt"; } 
    46474643    break; 
    46484644 
    46494645  case 303: 
    4650 #line 1922 "compilers/imcc/imcc.y" 
     4646#line 1918 "compilers/imcc/imcc.y" 
    46514647    { (yyval.s) = (char *)"ge"; } 
    46524648    break; 
    46534649 
    46544650  case 304: 
    4655 #line 1923 "compilers/imcc/imcc.y" 
     4651#line 1919 "compilers/imcc/imcc.y" 
    46564652    { (yyval.s) = (char *)"lt"; } 
    46574653    break; 
    46584654 
    46594655  case 305: 
    4660 #line 1924 "compilers/imcc/imcc.y" 
     4656#line 1920 "compilers/imcc/imcc.y" 
    46614657    { (yyval.s) = (char *)"le"; } 
    46624658    break; 
    46634659 
    46644660  case 308: 
    4665 #line 1933 "compilers/imcc/imcc.y" 
     4661#line 1929 "compilers/imcc/imcc.y" 
    46664662    { (yyval.sr) = NULL; } 
    46674663    break; 
    46684664 
    46694665  case 309: 
    4670 #line 1934 "compilers/imcc/imcc.y" 
     4666#line 1930 "compilers/imcc/imcc.y" 
    46714667    { (yyval.sr) = (yyvsp[(1) - (1)].sr); } 
    46724668    break; 
    46734669 
    46744670  case 310: 
    4675 #line 1938 "compilers/imcc/imcc.y" 
     4671#line 1934 "compilers/imcc/imcc.y" 
    46764672    { (yyval.sr) = IMCC_INFO(interp)->regs[0]; } 
    46774673    break; 
    46784674 
    46794675  case 312: 
    4680 #line 1943 "compilers/imcc/imcc.y" 
     4676#line 1939 "compilers/imcc/imcc.y" 
    46814677    { IMCC_INFO(interp)->regs[IMCC_INFO(interp)->nargs++] = (yyvsp[(1) - (1)].sr); } 
    46824678    break; 
    46834679 
    46844680  case 313: 
    4685 #line 1945 "compilers/imcc/imcc.y" 
     4681#line 1941 "compilers/imcc/imcc.y" 
    46864682    { 
    46874683           IMCC_INFO(interp) -> regs[IMCC_INFO(interp)->nargs++] = (yyvsp[(1) - (4)].sr); 
    46884684           IMCC_INFO(interp) -> keyvec |= KEY_BIT(IMCC_INFO(interp)->nargs); 
     
    46924688    break; 
    46934689 
    46944690  case 314: 
    4695 #line 1952 "compilers/imcc/imcc.y" 
     4691#line 1948 "compilers/imcc/imcc.y" 
    46964692    { 
    46974693           IMCC_INFO(interp) -> regs[IMCC_INFO(interp)->nargs++] = (yyvsp[(2) - (3)].sr); 
    46984694           (yyval.sr) = (yyvsp[(2) - (3)].sr); 
     
    47004696    break; 
    47014697 
    47024698  case 316: 
    4703 #line 1959 "compilers/imcc/imcc.y" 
     4699#line 1955 "compilers/imcc/imcc.y" 
    47044700    { (yyval.sr) = mk_sub_address_fromc(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    47054701    break; 
    47064702 
    47074703  case 317: 
    4708 #line 1960 "compilers/imcc/imcc.y" 
     4704#line 1956 "compilers/imcc/imcc.y" 
    47094705    { (yyval.sr) = mk_sub_address_u(interp, (yyvsp[(1) - (1)].s));  mem_sys_free((yyvsp[(1) - (1)].s)); } 
    47104706    break; 
    47114707 
    47124708  case 318: 
    4713 #line 1964 "compilers/imcc/imcc.y" 
     4709#line 1960 "compilers/imcc/imcc.y" 
    47144710    { (yyval.sr) = mk_sub_address(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    47154711    break; 
    47164712 
    47174713  case 319: 
    4718 #line 1965 "compilers/imcc/imcc.y" 
     4714#line 1961 "compilers/imcc/imcc.y" 
    47194715    { (yyval.sr) = mk_sub_address(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    47204716    break; 
    47214717 
    47224718  case 320: 
    4723 #line 1969 "compilers/imcc/imcc.y" 
     4719#line 1965 "compilers/imcc/imcc.y" 
    47244720    { (yyval.sr) = mk_label_address(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    47254721    break; 
    47264722 
    47274723  case 321: 
    4728 #line 1970 "compilers/imcc/imcc.y" 
     4724#line 1966 "compilers/imcc/imcc.y" 
    47294725    { (yyval.sr) = mk_label_address(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    47304726    break; 
    47314727 
    47324728  case 326: 
    4733 #line 1984 "compilers/imcc/imcc.y" 
     4729#line 1980 "compilers/imcc/imcc.y" 
    47344730    { 
    47354731           IMCC_INFO(interp)->nkeys    = 0; 
    47364732           IMCC_INFO(interp)->in_slice = 0; 
     
    47384734    break; 
    47394735 
    47404736  case 327: 
    4741 #line 1989 "compilers/imcc/imcc.y" 
     4737#line 1985 "compilers/imcc/imcc.y" 
    47424738    { 
    47434739           (yyval.sr) = link_keys(interp, 
    47444740                          IMCC_INFO(interp)->nkeys, 
     
    47474743    break; 
    47484744 
    47494745  case 328: 
    4750 #line 1997 "compilers/imcc/imcc.y" 
     4746#line 1993 "compilers/imcc/imcc.y" 
    47514747    { 
    47524748           IMCC_INFO(interp)->nkeys = 0; 
    47534749           IMCC_INFO(interp)->in_slice = 0; 
     
    47554751    break; 
    47564752 
    47574753  case 329: 
    4758 #line 2002 "compilers/imcc/imcc.y" 
     4754#line 1998 "compilers/imcc/imcc.y" 
    47594755    { 
    47604756           (yyval.sr) = link_keys(interp, 
    47614757                          IMCC_INFO(interp)->nkeys, 
     
    47644760    break; 
    47654761 
    47664762  case 330: 
    4767 #line 2010 "compilers/imcc/imcc.y" 
     4763#line 2006 "compilers/imcc/imcc.y" 
    47684764    { IMCC_INFO(interp)->keys[IMCC_INFO(interp)->nkeys++] = (yyvsp[(1) - (1)].sr); } 
    47694765    break; 
    47704766 
    47714767  case 331: 
    4772 #line 2012 "compilers/imcc/imcc.y" 
     4768#line 2008 "compilers/imcc/imcc.y" 
    47734769    { 
    47744770           IMCC_INFO(interp)->keys[IMCC_INFO(interp)->nkeys++] = (yyvsp[(3) - (3)].sr); 
    47754771           (yyval.sr) = IMCC_INFO(interp)->keys[0]; 
     
    47774773    break; 
    47784774 
    47794775  case 332: 
    4780 #line 2020 "compilers/imcc/imcc.y" 
     4776#line 2016 "compilers/imcc/imcc.y" 
    47814777    { 
    47824778           if (IMCC_INFO(interp)->in_slice) 
    47834779               (yyvsp[(1) - (1)].sr)->type |= VT_START_SLICE | VT_END_SLICE; 
     
    47864782    break; 
    47874783 
    47884784  case 333: 
    4789 #line 2028 "compilers/imcc/imcc.y" 
     4785#line 2024 "compilers/imcc/imcc.y" 
    47904786    { (yyval.sr) = mk_symreg(interp, (yyvsp[(1) - (1)].s), 'I'); } 
    47914787    break; 
    47924788 
    47934789  case 334: 
    4794 #line 2029 "compilers/imcc/imcc.y" 
     4790#line 2025 "compilers/imcc/imcc.y" 
    47954791    { (yyval.sr) = mk_symreg(interp, (yyvsp[(1) - (1)].s), 'N'); } 
    47964792    break; 
    47974793 
    47984794  case 335: 
    4799 #line 2030 "compilers/imcc/imcc.y" 
     4795#line 2026 "compilers/imcc/imcc.y" 
    48004796    { (yyval.sr) = mk_symreg(interp, (yyvsp[(1) - (1)].s), 'S'); } 
    48014797    break; 
    48024798 
    48034799  case 336: 
    4804 #line 2031 "compilers/imcc/imcc.y" 
     4800#line 2027 "compilers/imcc/imcc.y" 
    48054801    { (yyval.sr) = mk_symreg(interp, (yyvsp[(1) - (1)].s), 'P'); } 
    48064802    break; 
    48074803 
    48084804  case 337: 
    4809 #line 2032 "compilers/imcc/imcc.y" 
     4805#line 2028 "compilers/imcc/imcc.y" 
    48104806    { (yyval.sr) = mk_pasm_reg(interp, (yyvsp[(1) - (1)].s)); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    48114807    break; 
    48124808 
    48134809  case 338: 
    4814 #line 2036 "compilers/imcc/imcc.y" 
     4810#line 2032 "compilers/imcc/imcc.y" 
    48154811    { (yyval.sr) = mk_const(interp, (yyvsp[(1) - (1)].s), 'I'); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    48164812    break; 
    48174813 
    48184814  case 339: 
    4819 #line 2037 "compilers/imcc/imcc.y" 
     4815#line 2033 "compilers/imcc/imcc.y" 
    48204816    { (yyval.sr) = mk_const(interp, (yyvsp[(1) - (1)].s), 'N'); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    48214817    break; 
    48224818 
    48234819  case 340: 
    4824 #line 2038 "compilers/imcc/imcc.y" 
     4820#line 2034 "compilers/imcc/imcc.y" 
    48254821    { (yyval.sr) = mk_const(interp, (yyvsp[(1) - (1)].s), 'S'); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    48264822    break; 
    48274823 
    48284824  case 341: 
    4829 #line 2039 "compilers/imcc/imcc.y" 
     4825#line 2035 "compilers/imcc/imcc.y" 
    48304826    { (yyval.sr) = mk_const(interp, (yyvsp[(1) - (1)].s), 'U'); mem_sys_free((yyvsp[(1) - (1)].s)); } 
    48314827    break; 
    48324828 
    48334829 
    48344830/* Line 1267 of yacc.c.  */ 
    4835 #line 4825 "compilers/imcc/imcparser.c" 
     4831#line 4821 "compilers/imcc/imcparser.c" 
    48364832      default: break; 
    48374833    } 
    48384834  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 
     
    50465042} 
    50475043 
    50485044 
    5049 #line 2045 "compilers/imcc/imcc.y" 
     5045#line 2041 "compilers/imcc/imcc.y" 
    50505046 
    50515047 
    50525048/* I need this prototype somewhere... */ 
  • compilers/imcc/parser_util.c

     
    132132    SymReg *regs[3]; 
    133133    SymReg *pmc; 
    134134    int nargs; 
    135     const int pmc_num = pmc_type(interp, 
     135    const int pmc_num = lookup_typeid_s(interp, 
    136136            string_from_cstring(interp, *type == '.' ? type + 1 : type, 0)); 
    137137 
    138138    snprintf(fmt, sizeof (fmt), "%d", pmc_num); 
  • compilers/imcc/imcparser.h

     
    303303    SymReg * sr; 
    304304    Instruction *i; 
    305305} 
    306 /* Line 1529 of yacc.c.  */ 
     306/* Line 1489 of yacc.c.  */ 
    307307#line 297 "compilers/imcc/imcparser.h" 
    308308        YYSTYPE; 
    309309# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 
  • compilers/pirc/new/pircompunit.c

     
    17491749    Parrot_Context *ctx           = CONTEXT(lexer->interp); 
    17501750    STRING * const  built_in_name = string_from_cstring(lexer->interp, stdtype, strlen(stdtype)); 
    17511751    STRING * const  language_name = string_from_cstring(lexer->interp, maptype, strlen(maptype)); 
    1752     int             built_in_type = pmc_type(lexer->interp, built_in_name); 
    1753     int             language_type = pmc_type(lexer->interp, language_name); 
     1752    int             built_in_type = lookup_typeid_s(lexer->interp, built_in_name); 
     1753    int             language_type = lookup_typeid_s(lexer->interp, language_name); 
    17541754 
    17551755    /* check if both the built-in and language types exist. */ 
    17561756 
  • t/pmc/key.t

     
    142142  pir_compiler = compreg 'PIR' 
    143143  $P0 = pir_compiler($S0) 
    144144  $P0 = $P0[0] 
    145   $P1 = new 'TclProc' 
     145  $P2 = get_root_global ['_tcl'], 'TclProc' 
     146  $P1 = new $P2 
    146147  assign $P1, $P0 
    147148  .local pmc ns_target 
    148149  ns_target = get_hll_namespace 
  • t/pmc/objects.t

     
    2121    .include "iglobals.pasm" 
    2222    .include "interpinfo.pasm" 
    2323 
    24     plan(194) 
     24    plan(191) 
    2525 
    2626    get_classname_from_class() 
    2727    test_get_class() 
     
    6868    short_name_attributes() 
    6969    init_with_and_without_arg() 
    7070    newclass_bracket_parsing() 
    71     verify_namespace_types() 
    72     verify_data_type() 
    7371    new_keyed() 
    7472    new_keyed_2() 
    7573    new_keyed_3() 
     
    11661164    ok( 1, 'newclass  created with brackets' ) 
    11671165.end 
    11681166 
    1169 .sub verify_namespace_types 
    1170     newclass $P0, ['Foo24';'Bar24'] 
    1171     getinterp $P0 
    1172     set $P1, $P0[.IGLOBALS_CLASSNAME_HASH] 
    1173     typeof $S0, $P1 
    1174     is( $S0, 'NameSpace', 'namespace verified' ) 
    1175  
    1176     set $P2, $P1['Foo24'] 
    1177     typeof $S0, $P2 
    1178     is( $S0, 'NameSpace', 'namespace verified' ) 
    1179 .end 
    1180  
    1181 .sub verify_data_type 
    1182     newclass $P0, ['Foo25';'Bar25'] 
    1183     getinterp $P0 
    1184     set $P1, $P0[.IGLOBALS_CLASSNAME_HASH] 
    1185     set $P2, $P1['Foo25'] 
    1186     set $P3, $P2['Bar25'] 
    1187  
    1188     set $I0, $P3 
    1189     isgt $I0, $I0, 0 
    1190     ok( $I0, 'verified datatype > 0' ) 
    1191 .end 
    1192  
    11931167# Puts init in a namespace 
    11941168.sub new_keyed 
    11951169    .local pmc cl, o, p 
  • t/compilers/imcc/syn/hll.t

     
    3838    : (); 
    3939pir_output_is( <<'CODE', <<'OUT', ".param :slurpy (using object)", @todo ); 
    4040 
     41.HLL 'misc' 
    4142.sub setup :anon :immediate 
    4243 $P0 = subclass 'ResizablePMCArray', 'Stack' 
    4344.end 
    4445 
    45 .HLL 'misc' 
    4646.HLL_map 'ResizablePMCArray' = 'Stack' 
    4747 
    4848.sub main :main 
  • t/oo/names.t

     
    4444    $P0.'name'('Object') 
    4545    pop_eh 
    4646    $S0 = $P0 
    47     ok (0, 'HLL obj created w/ same name as parrot obj') 
     47    ok (1, 'HLL obj created w/ same name as parrot obj') 
    4848    .return() 
    4949OK_1:     
    50     ok (1, 'HLL obj w/ same name as parrot obj not created') 
     50    ok (0, 'HLL obj w/ same name as parrot obj not created') 
    5151.end 
    5252 
    5353# Local Variables: 
  • t/oo/isa.t

     
    2727    subclass_isa_by_string_name() 
    2828    subclass_isa_by_class_object() 
    2929    string_isa_and_pmc_isa_have_same_result() 
    30     string_register_and_string_pmc_isa_have_same_result() 
     30    $P0 = get_root_global ['foo'; 'XYZ'], 'string_register_and_string_pmc_isa_have_same_result' 
     31    $P0() 
    3132.end 
    3233 
    3334 
     
    151152    ok ($I1, 'isa String instance an Object') 
    152153.end 
    153154 
     155.HLL 'foo' 
     156.namespace ['XYZ'] 
     157 
     158.sub 'abc' :method 
     159    .return( 'XYZ::abc' ) 
     160.end 
     161 
    154162.sub string_register_and_string_pmc_isa_have_same_result 
     163    .include 'include/test_more.pir' 
    155164    .local pmc xyzns, xyzclass, xyzobj 
    156165 
    157166    xyzns    = get_root_namespace ['foo';'XYZ'] 
     
    181190    ok( $I0, '... and false when it is not' ) 
    182191.end 
    183192 
    184 .HLL 'foo' 
    185 .namespace ['XYZ'] 
    186  
    187 .sub 'abc' :method 
    188     .return( 'XYZ::abc' ) 
    189 .end 
    190  
    191193# Local Variables: 
    192194#   mode: pir 
    193195#   fill-column: 100 
  • t/op/box.t

     
    1919.const int TESTS = 24 
    2020 
    2121# must set these up before the .HLL_map statements later 
    22 .sub '__setup' :immediate 
    23     $P0 = subclass 'Integer', 'MyInt' 
    24     $P0 = subclass 'String',  'MyString' 
    25     $P0 = subclass 'Float',   'MyFloat' 
    26 .end 
    2722 
    2823.sub 'main' :main 
    2924    .include 'include/test_more.pir' 
     
    9489 
    9590.HLL 'for_test' 
    9691 
     92.sub '__setup' :immediate 
     93    $P0 = subclass 'Integer', 'MyInt' 
     94    $P0 = subclass 'String',  'MyString' 
     95    $P0 = subclass 'Float',   'MyFloat' 
     96.end 
     97 
    9798.HLL_map 'Integer' = 'MyInt' 
    9899.HLL_map 'String'  = 'MyString' 
    99100.HLL_map 'Float'   = 'MyFloat' 
    100101 
    101102.sub 'box_int' 
     103    $P1 = get_hll_global 'MyInt' 
    102104    .include 'include/test_more.pir' 
    103105    $P0 = box -100 
    104106    $I0 = $P0 
    105107    is( $I0, -100, 'value preserved when boxing int in HLL' ) 
    106108 
    107     isa_ok( $P0, 'MyInt', 'int boxed to appropriate base type for HLL' ) 
     109    isa_ok( $P0, $P1, 'int boxed to appropriate base type for HLL' ) 
    108110 
    109111    $I0 = -999 
    110112    $P0 = box $I0 
    111113    $I0 = $P0 
    112114    is( $I0, -999, 'value preserved when boxing int in HLL from reg' ) 
    113115 
    114     isa_ok( $P0, 'MyInt', 'int boxed to appropriate type for HLL from reg') 
     116    isa_ok( $P0, $P1, 'int boxed to appropriate type for HLL from reg') 
    115117.end 
    116118 
    117119.sub 'box_num' 
     120    $P1 = get_hll_global 'MyFloat' 
    118121    $P0 = box -77.7 
    119122    $N0 = $P0 
    120123    is( $N0, -77.7, 'value preserved when boxing num in HLL' ) 
    121124 
    122     isa_ok( $P0, 'MyFloat', 'num boxed to appropriate base type for HLL' ) 
     125    isa_ok( $P0, $P1, 'num boxed to appropriate base type for HLL' ) 
    123126 
    124127    $N0 = -222222.222222 
    125128    $P0 = box $N0 
    126129    $N0 = $P0 
    127130    is( $N0, -222222.222222, 'value preserved when boxing num in HLL from reg' ) 
    128131 
    129     isa_ok( $P0, 'MyFloat', 'num boxed to appropriate type for HLL from reg' ) 
     132    isa_ok( $P0, $P1, 'num boxed to appropriate type for HLL from reg' ) 
    130133.end 
    131134 
    132135.sub 'box_string' 
     136    $P1 = get_hll_global 'MyString' 
    133137    $P0 = box 'Bye, bye!' 
    134138    $S0 = $P0 
    135139    is( $S0, 'Bye, bye!', 'value preserved when boxing string in HLL' ) 
    136140 
    137     isa_ok( $P0, 'MyString', 'string boxed to appropriate base type for HLL' ) 
     141    isa_ok( $P0, $P1, 'string boxed to appropriate base type for HLL' ) 
    138142 
    139143    $S0 = 'Hello, goodbye!' 
    140144    $P0 = box $S0 
    141145    $S0 = $P0 
    142146    is( $S0, 'Hello, goodbye!', 'value preserved when boxing string in HLL from reg' ) 
    143147 
    144     isa_ok($P0, 'MyString', 'string boxed to appropriate type for HLL from reg') 
     148    isa_ok($P0, $P1, 'string boxed to appropriate type for HLL from reg') 
    145149.end 
    146150 
    147151# Local Variables: