Ticket #2093: tt2093.patch

File tt2093.patch, 45.8 KB (added by soh_cah_toa, 3 years ago)
  • src/ops/bit.ops

    diff --git a/src/ops/bit.ops b/src/ops/bit.ops
    index 24a63c5..c0c27ec 100644
    a b  
    5252 
    5353=cut 
    5454 
    55 inline op band(inout INT, in INT) :base_core { 
     55inline op band(inout INT, in INT) { 
    5656    $1 &= $2; 
    5757} 
    5858 
    59 inline op band(out INT, in INT, in INT) :base_core { 
     59inline op band(out INT, in INT, in INT) { 
    6060    $1 = $2 & $3; 
    6161} 
    6262 
     
    7474 
    7575=cut 
    7676 
    77 inline op bor(inout INT, in INT) :base_core { 
     77inline op bor(inout INT, in INT) { 
    7878    $1 |= $2; 
    7979} 
    8080 
    81 inline op bor(out INT, in INT, in INT) :base_core { 
     81inline op bor(out INT, in INT, in INT) { 
    8282    $1 = $2 | $3; 
    8383} 
    8484 
     
    9494 
    9595=cut 
    9696 
    97 inline op shl(inout INT, in INT) :base_core { 
     97inline op shl(inout INT, in INT) { 
    9898    $1 = bit_shift_left($1, $2); 
    9999} 
    100100 
    101 inline op shl(out INT, in INT, in INT) :base_core { 
     101inline op shl(out INT, in INT, in INT) { 
    102102    $1 = bit_shift_left($2, $3); 
    103103} 
    104104 
     
    114114 
    115115=cut 
    116116 
    117 inline op shr(inout INT, in INT) :base_core { 
     117inline op shr(inout INT, in INT) { 
    118118    const INTVAL signed_shift = -$2; 
    119119    $1 = bit_shift_left($1, signed_shift); 
    120120} 
    121121 
    122 inline op shr(out INT, in INT, in INT) :base_core { 
     122inline op shr(out INT, in INT, in INT) { 
    123123    const INTVAL signed_shift = -$3; 
    124124    $1 = bit_shift_left($2, signed_shift); 
    125125} 
     
    136136 
    137137=cut 
    138138 
    139 inline op lsr(out INT, in INT) :base_core { 
     139inline op lsr(out INT, in INT) { 
    140140    const UINTVAL a = (UINTVAL)$1; 
    141141    const UINTVAL b = a >> $2; 
    142142    $1 = (INTVAL)b; 
    143143} 
    144144 
    145 inline op lsr(out INT, in INT, in INT) :base_core { 
     145inline op lsr(out INT, in INT, in INT) { 
    146146    $1 = (INTVAL)((UINTVAL)$2 >> $3); 
    147147} 
    148148 
     
    160160 
    161161=cut 
    162162 
    163 inline op bxor(inout INT, in INT) :base_core { 
     163inline op bxor(inout INT, in INT) { 
    164164    $1 ^= $2; 
    165165} 
    166166 
    167 inline op bxor(out INT, in INT, in INT) :base_core { 
     167inline op bxor(out INT, in INT, in INT) { 
    168168    $1 = $2 ^ $3; 
    169169} 
    170170 
  • src/ops/cmp.ops

    diff --git a/src/ops/cmp.ops b/src/ops/cmp.ops
    index 7702267..7638f7c 100644
    a b  
    6464 
    6565=cut 
    6666 
    67 inline op eq(in INT, in INT, inconst LABEL) :base_core { 
     67inline op eq(in INT, in INT, inconst LABEL) { 
    6868    if ($1 == $2) { 
    6969        goto OFFSET($3); 
    7070    } 
    7171} 
    7272 
    73 inline op eq(in NUM, in NUM, inconst LABEL) :base_core { 
     73inline op eq(in NUM, in NUM, inconst LABEL) { 
    7474    if ($1 == $2) { 
    7575        goto OFFSET($3); 
    7676    } 
    7777} 
    7878 
    79 op eq(in STR, in STR, inconst LABEL) :base_core { 
     79op eq(in STR, in STR, inconst LABEL) { 
    8080    if (STRING_equal(interp, $1, $2)) { 
    8181        goto OFFSET($3); 
    8282    } 
    8383} 
    8484 
    85 op eq(invar PMC, invar PMC, inconst LABEL) :base_core { 
     85op eq(invar PMC, invar PMC, inconst LABEL) { 
    8686    if (VTABLE_is_equal(interp, $1, $2)) { 
    8787        goto OFFSET($3); 
    8888    } 
    8989} 
    9090 
    91 op eq(invar PMC, in INT, inconst LABEL) :base_core { 
     91op eq(invar PMC, in INT, inconst LABEL) { 
    9292    PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer); 
    9393    VTABLE_set_integer_native(interp, temp, $2); 
    9494 
     
    100100    Parrot_pmc_free_temporary(interp, temp); 
    101101} 
    102102 
    103 op eq(invar PMC, in NUM, inconst LABEL) :base_core { 
     103op eq(invar PMC, in NUM, inconst LABEL) { 
    104104    /* 
    105105     * the get_number and get_string should probably 
    106106     * be also replaced with code like above, as 
     
    112112    } 
    113113} 
    114114 
    115 op eq(invar PMC, in STR, inconst LABEL) :base_core { 
     115op eq(invar PMC, in STR, inconst LABEL) { 
    116116    if (STRING_equal(interp, VTABLE_get_string(interp, $1), $2)) { 
    117117        goto OFFSET($3); 
    118118    } 
    119119} 
    120120 
    121 op eq_str(invar PMC, invar PMC, inconst LABEL) :base_core { 
     121op eq_str(invar PMC, invar PMC, inconst LABEL) { 
    122122    if (VTABLE_is_equal_string(interp, $1, $2)) { 
    123123        goto OFFSET($3); 
    124124    } 
    125125} 
    126126 
    127 op eq_num(invar PMC, invar PMC, inconst LABEL) :base_core { 
     127op eq_num(invar PMC, invar PMC, inconst LABEL) { 
    128128    if (VTABLE_is_equal_num(interp, $1, $2)) { 
    129129        goto OFFSET($3); 
    130130    } 
    131131} 
    132132 
    133 op eq_addr(in STR, in STR, inconst LABEL) :base_core { 
     133op eq_addr(in STR, in STR, inconst LABEL) { 
    134134    if ($1 == $2) { 
    135135        goto OFFSET($3); 
    136136    } 
    137137} 
    138138 
    139 op eq_addr(invar PMC, invar PMC, inconst LABEL) :base_core { 
     139op eq_addr(invar PMC, invar PMC, inconst LABEL) { 
    140140    if ($1 == $2) { 
    141141        goto OFFSET($3); 
    142142    } 
     
    170170 
    171171=cut 
    172172 
    173 inline op ne(in INT, in INT, inconst LABEL) :base_core { 
     173inline op ne(in INT, in INT, inconst LABEL) { 
    174174    if ($1 != $2) { 
    175175        goto OFFSET($3); 
    176176    } 
    177177} 
    178178 
    179 inline op ne(in NUM, in NUM, inconst LABEL) :base_core { 
     179inline op ne(in NUM, in NUM, inconst LABEL) { 
    180180    if ($1 != $2) { 
    181181        goto OFFSET($3); 
    182182    } 
    183183} 
    184184 
    185 op ne(in STR, in STR, inconst LABEL) :base_core { 
     185op ne(in STR, in STR, inconst LABEL) { 
    186186    if (!STRING_equal(interp, $1, $2)) { 
    187187        goto OFFSET($3); 
    188188    } 
    189189} 
    190190 
    191 op ne(invar PMC, invar PMC, inconst LABEL) :base_core { 
     191op ne(invar PMC, invar PMC, inconst LABEL) { 
    192192    if (!VTABLE_is_equal(interp, $1, $2)) { 
    193193        goto OFFSET($3); 
    194194    } 
    195195} 
    196196 
    197 op ne(invar PMC, in INT, inconst LABEL) :base_core { 
     197op ne(invar PMC, in INT, inconst LABEL) { 
    198198    PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer); 
    199199    VTABLE_set_integer_native(interp, temp, $2); 
    200200 
     
    206206    Parrot_pmc_free_temporary(interp, temp); 
    207207} 
    208208 
    209 op ne(invar PMC, in NUM, inconst LABEL) :base_core { 
     209op ne(invar PMC, in NUM, inconst LABEL) { 
    210210    if (VTABLE_get_number(interp, $1) != $2) { 
    211211        goto OFFSET($3); 
    212212    } 
    213213} 
    214214 
    215 op ne(invar PMC, in STR, inconst LABEL) :base_core { 
     215op ne(invar PMC, in STR, inconst LABEL) { 
    216216    if (!STRING_equal(interp, VTABLE_get_string(interp, $1), $2)) { 
    217217        goto OFFSET($3); 
    218218    } 
    219219} 
    220220 
    221 op ne_str(invar PMC, invar PMC, inconst LABEL) :base_core { 
     221op ne_str(invar PMC, invar PMC, inconst LABEL) { 
    222222    if (VTABLE_cmp_string(interp, $1, $2) != 0) { 
    223223        goto OFFSET($3); 
    224224    } 
    225225} 
    226226 
    227 op ne_num(invar PMC, invar PMC, inconst LABEL) :base_core { 
     227op ne_num(invar PMC, invar PMC, inconst LABEL) { 
    228228    if (VTABLE_cmp_num(interp, $1, $2) != 0) { 
    229229        goto OFFSET($3); 
    230230    } 
    231231} 
    232232 
    233 op ne_addr(in STR, in STR, inconst LABEL) :base_core { 
     233op ne_addr(in STR, in STR, inconst LABEL) { 
    234234    if ($1 != $2) { 
    235235        goto OFFSET($3); 
    236236    } 
    237237} 
    238238 
    239 op ne_addr(invar PMC, invar PMC, inconst LABEL) :base_core { 
     239op ne_addr(invar PMC, invar PMC, inconst LABEL) { 
    240240    if ($1 != $2) { 
    241241        goto OFFSET($3); 
    242242    } 
     
    266266 
    267267=cut 
    268268 
    269 inline op lt(in INT, in INT, inconst LABEL) :base_core { 
     269inline op lt(in INT, in INT, inconst LABEL) { 
    270270    if ($1 < $2) { 
    271271        goto OFFSET($3); 
    272272    } 
    273273} 
    274274 
    275 inline op lt(in NUM, in NUM, inconst LABEL) :base_core { 
     275inline op lt(in NUM, in NUM, inconst LABEL) { 
    276276    if ($1 < $2) { 
    277277        goto OFFSET($3); 
    278278    } 
    279279} 
    280280 
    281 op lt(in STR, in STR, inconst LABEL) :base_core { 
     281op lt(in STR, in STR, inconst LABEL) { 
    282282    if (STRING_compare(interp, $1, $2) < 0) { 
    283283        goto OFFSET($3); 
    284284    } 
    285285} 
    286286 
    287 op lt(invar PMC, invar PMC, inconst LABEL) :base_core { 
     287op lt(invar PMC, invar PMC, inconst LABEL) { 
    288288    if (VTABLE_cmp(interp, $1, $2) < 0) { 
    289289        goto OFFSET($3); 
    290290    } 
    291291} 
    292292 
    293 op lt(invar PMC, in INT, inconst LABEL) :base_core { 
     293op lt(invar PMC, in INT, inconst LABEL) { 
    294294    PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer); 
    295295    VTABLE_set_integer_native(interp, temp, $2); 
    296296 
     
    302302    Parrot_pmc_free_temporary(interp, temp); 
    303303} 
    304304 
    305 op lt(invar PMC, in NUM, inconst LABEL) :base_core { 
     305op lt(invar PMC, in NUM, inconst LABEL) { 
    306306    if (VTABLE_get_number(interp, $1) < $2) { 
    307307        goto OFFSET($3); 
    308308    } 
    309309} 
    310310 
    311 op lt(invar PMC, in STR, inconst LABEL) :base_core { 
     311op lt(invar PMC, in STR, inconst LABEL) { 
    312312    if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) < 0) { 
    313313        goto OFFSET($3); 
    314314    } 
    315315} 
    316316 
    317 op lt_str(invar PMC, invar PMC, inconst LABEL) :base_core { 
     317op lt_str(invar PMC, invar PMC, inconst LABEL) { 
    318318    if (VTABLE_cmp_string(interp, $1, $2) < 0) { 
    319319        goto OFFSET($3); 
    320320    } 
    321321} 
    322322 
    323 op lt_num(invar PMC, invar PMC, inconst LABEL) :base_core { 
     323op lt_num(invar PMC, invar PMC, inconst LABEL) { 
    324324    if (VTABLE_cmp_num(interp, $1, $2) < 0) { 
    325325        goto OFFSET($3); 
    326326    } 
     
    350350 
    351351=cut 
    352352 
    353 inline op le(in INT, in INT, inconst LABEL) :base_core { 
     353inline op le(in INT, in INT, inconst LABEL) { 
    354354    if ($1 <= $2) { 
    355355        goto OFFSET($3); 
    356356    } 
    357357} 
    358358 
    359 inline op le(in NUM, in NUM, inconst LABEL) :base_core { 
     359inline op le(in NUM, in NUM, inconst LABEL) { 
    360360    if ($1 <= $2) { 
    361361        goto OFFSET($3); 
    362362    } 
    363363} 
    364364 
    365 op le(in STR, in STR, inconst LABEL) :base_core { 
     365op le(in STR, in STR, inconst LABEL) { 
    366366    if (STRING_compare(interp, $1, $2) <= 0) { 
    367367        goto OFFSET($3); 
    368368    } 
    369369} 
    370370 
    371 op le(invar PMC, invar PMC, inconst LABEL) :base_core { 
     371op le(invar PMC, invar PMC, inconst LABEL) { 
    372372    if (VTABLE_cmp(interp, $1, $2) <= 0) { 
    373373        goto OFFSET($3); 
    374374    } 
    375375} 
    376376 
    377 op le(invar PMC, in INT, inconst LABEL) :base_core { 
     377op le(invar PMC, in INT, inconst LABEL) { 
    378378    PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer); 
    379379    VTABLE_set_integer_native(interp, temp, $2); 
    380380 
     
    386386    Parrot_pmc_free_temporary(interp, temp); 
    387387} 
    388388 
    389 op le(invar PMC, in NUM, inconst LABEL) :base_core { 
     389op le(invar PMC, in NUM, inconst LABEL) { 
    390390    if (VTABLE_get_number(interp, $1) <= $2) { 
    391391        goto OFFSET($3); 
    392392    } 
    393393} 
    394394 
    395 op le(invar PMC, in STR, inconst LABEL) :base_core { 
     395op le(invar PMC, in STR, inconst LABEL) { 
    396396    if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) <= 0) { 
    397397        goto OFFSET($3); 
    398398    } 
    399399} 
    400400 
    401 op le_str(invar PMC, invar PMC, inconst LABEL) :base_core { 
     401op le_str(invar PMC, invar PMC, inconst LABEL) { 
    402402    if (VTABLE_cmp_string(interp, $1, $2) <= 0) { 
    403403        goto OFFSET($3); 
    404404    } 
    405405} 
    406406 
    407 op le_num(invar PMC, invar PMC, inconst LABEL) :base_core { 
     407op le_num(invar PMC, invar PMC, inconst LABEL) { 
    408408    if (VTABLE_cmp_num(interp, $1, $2) <= 0) { 
    409409        goto OFFSET($3); 
    410410    } 
     
    428428 
    429429=cut 
    430430 
    431 op gt(invar PMC, invar PMC, inconst LABEL) :base_core { 
     431op gt(invar PMC, invar PMC, inconst LABEL) { 
    432432    if (VTABLE_cmp(interp, $1, $2) > 0) { 
    433433        goto OFFSET($3); 
    434434    } 
    435435} 
    436436 
    437 op gt(invar PMC, in INT, inconst LABEL) :base_core { 
     437op gt(invar PMC, in INT, inconst LABEL) { 
    438438    PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer); 
    439439    VTABLE_set_integer_native(interp, temp, $2); 
    440440 
     
    446446    Parrot_pmc_free_temporary(interp, temp); 
    447447} 
    448448 
    449 op gt(invar PMC, in NUM, inconst LABEL) :base_core { 
     449op gt(invar PMC, in NUM, inconst LABEL) { 
    450450    if (VTABLE_get_number(interp, $1) > $2) { 
    451451        goto OFFSET($3); 
    452452    } 
    453453} 
    454454 
    455 op gt(invar PMC, in STR, inconst LABEL) :base_core { 
     455op gt(invar PMC, in STR, inconst LABEL) { 
    456456    if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) > 0) { 
    457457        goto OFFSET($3); 
    458458    } 
    459459} 
    460460 
    461 op gt_str(invar PMC, invar PMC, inconst LABEL) :base_core { 
     461op gt_str(invar PMC, invar PMC, inconst LABEL) { 
    462462    if (VTABLE_cmp_string(interp, $1, $2) > 0) { 
    463463        goto OFFSET($3); 
    464464    } 
    465465} 
    466466 
    467 op gt_num(invar PMC, invar PMC, inconst LABEL) :base_core { 
     467op gt_num(invar PMC, invar PMC, inconst LABEL) { 
    468468    if (VTABLE_cmp_num(interp, $1, $2) > 0) { 
    469469        goto OFFSET($3); 
    470470    } 
     
    488488 
    489489=cut 
    490490 
    491 op ge(invar PMC, invar PMC, inconst LABEL) :base_core { 
     491op ge(invar PMC, invar PMC, inconst LABEL) { 
    492492    if (VTABLE_cmp(interp, $1, $2) >= 0) { 
    493493        goto OFFSET($3); 
    494494    } 
    495495} 
    496496 
    497 op ge(invar PMC, in INT, inconst LABEL) :base_core { 
     497op ge(invar PMC, in INT, inconst LABEL) { 
    498498    PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer); 
    499499    VTABLE_set_integer_native(interp, temp, $2); 
    500500 
     
    506506    Parrot_pmc_free_temporary(interp, temp); 
    507507} 
    508508 
    509 op ge(invar PMC, in NUM, inconst LABEL) :base_core { 
     509op ge(invar PMC, in NUM, inconst LABEL) { 
    510510    if (VTABLE_get_number(interp, $1) >= $2) { 
    511511        goto OFFSET($3); 
    512512    } 
    513513} 
    514514 
    515 op ge(invar PMC, in STR, inconst LABEL) :base_core { 
     515op ge(invar PMC, in STR, inconst LABEL) { 
    516516    if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) >= 0) { 
    517517        goto OFFSET($3); 
    518518    } 
    519519} 
    520520 
    521 op ge_str(invar PMC, invar PMC, inconst LABEL) :base_core { 
     521op ge_str(invar PMC, invar PMC, inconst LABEL) { 
    522522    if (VTABLE_cmp_string(interp, $1, $2) >= 0) { 
    523523        goto OFFSET($3); 
    524524    } 
    525525} 
    526526 
    527 op ge_num(invar PMC, invar PMC, inconst LABEL) :base_core { 
     527op ge_num(invar PMC, invar PMC, inconst LABEL) { 
    528528    if (VTABLE_cmp_num(interp, $1, $2) >= 0) { 
    529529        goto OFFSET($3); 
    530530    } 
     
    613613 
    614614=cut 
    615615 
    616 inline op cmp(out INT, in INT, in INT) :base_core { 
     616inline op cmp(out INT, in INT, in INT) { 
    617617    $1 = $2 < $3 ? -1 : 
    618618         $2 > $3 ? +1 : 
    619619         0; 
    620620} 
    621621 
    622 inline op cmp(out INT, in NUM, in NUM) :base_core { 
     622inline op cmp(out INT, in NUM, in NUM) { 
    623623    $1 = $2 < $3 ? -1 : 
    624624         $2 > $3 ? +1 : 
    625625         0; 
    626626} 
    627627 
    628 inline op cmp(out INT, in STR, in STR) :base_core { 
     628inline op cmp(out INT, in STR, in STR) { 
    629629    $1 = STRING_compare(interp, $2, $3); 
    630630} 
    631631 
    632 inline op cmp(out INT, invar PMC, invar PMC) :base_core { 
     632inline op cmp(out INT, invar PMC, invar PMC) { 
    633633    $1 = VTABLE_cmp(interp, $2, $3); 
    634634} 
    635635 
    636 inline op cmp(out INT, invar PMC, in INT) :base_core { 
     636inline op cmp(out INT, invar PMC, in INT) { 
    637637    const INTVAL l = VTABLE_get_integer(interp, $2); 
    638638    $1 = l < $3 ? -1 : 
    639639         l > $3 ? +1 : 
    640640         0; 
    641641} 
    642642 
    643 inline op cmp(out INT, invar PMC, in NUM) :base_core { 
     643inline op cmp(out INT, invar PMC, in NUM) { 
    644644    const FLOATVAL l = VTABLE_get_number(interp, $2); 
    645645    $1 = l < $3 ? -1 : 
    646646         l > $3 ? +1 : 
    647647         0; 
    648648} 
    649649 
    650 inline op cmp(out INT, invar PMC, in STR) :base_core { 
     650inline op cmp(out INT, invar PMC, in STR) { 
    651651    STRING* const l = VTABLE_get_string(interp, $2); 
    652652    $1 = STRING_compare(interp, l, $3); 
    653653} 
    654654 
    655 inline op cmp_str(out INT, invar PMC, invar PMC) :base_core { 
     655inline op cmp_str(out INT, invar PMC, invar PMC) { 
    656656    $1 = VTABLE_cmp_string(interp, $2, $3); 
    657657} 
    658658 
    659 inline op cmp_num(out INT, invar PMC, invar PMC) :base_core { 
     659inline op cmp_num(out INT, invar PMC, invar PMC) { 
    660660    $1 = VTABLE_cmp_num(interp, $2, $3); 
    661661} 
    662662 
     
    668668 
    669669=cut 
    670670 
    671 inline op cmp_pmc(out PMC, invar PMC, invar PMC) :base_core { 
     671inline op cmp_pmc(out PMC, invar PMC, invar PMC) { 
    672672    $1 = VTABLE_cmp_pmc(interp, $2, $3); 
    673673} 
    674674 
     
    922922 
    923923=cut 
    924924 
    925 inline op and(out INT, in INT, in INT) :base_core { 
     925inline op and(out INT, in INT, in INT) { 
    926926    $1 = $2 ? $3 : $2; 
    927927} 
    928928 
    929 inline op and(invar PMC, invar PMC, invar PMC) :base_core { 
     929inline op and(invar PMC, invar PMC, invar PMC) { 
    930930    $1 = VTABLE_get_bool(interp, $2) ? $3 : $2; 
    931931} 
    932932 
     
    944944 
    945945=cut 
    946946 
    947 inline op not(inout INT) :base_core { 
     947inline op not(inout INT) { 
    948948    $1 = ! $1; 
    949949} 
    950950 
    951 inline op not(out INT, in INT) :base_core { 
     951inline op not(out INT, in INT) { 
    952952    $1 = ! $2; 
    953953} 
    954954 
    955 inline op not(invar PMC) :base_core { 
     955inline op not(invar PMC) { 
    956956    VTABLE_set_bool(interp, $1, !VTABLE_get_bool(interp, $1)); 
    957957} 
    958958 
    959 inline op not(out PMC, invar PMC) :base_core { 
     959inline op not(out PMC, invar PMC) { 
    960960    const INTVAL a = ! VTABLE_get_bool(interp, $2); 
    961961    if (PMC_IS_NULL($1)) 
    962962        $1 = Parrot_pmc_new(interp, Parrot_hll_get_ctx_HLL_type(interp, enum_class_Boolean)); 
     
    973973 
    974974=cut 
    975975 
    976 inline op or(out INT, in INT, in INT) :base_core { 
     976inline op or(out INT, in INT, in INT) { 
    977977    $1 = $2 ? $2 : $3; 
    978978} 
    979979 
    980 inline op or(invar PMC, invar PMC, invar PMC) :base_core { 
     980inline op or(invar PMC, invar PMC, invar PMC) { 
    981981    $1 = VTABLE_get_bool(interp, $2) ? $2 : $3; 
    982982} 
    983983 
     
    992992 
    993993=cut 
    994994 
    995 inline op xor(out INT, in INT, in INT) :base_core { 
     995inline op xor(out INT, in INT, in INT) { 
    996996    $1 = ($2 && ! $3) ? $2 : ($3 && ! $2) ? $3 : 0; 
    997997} 
    998998 
    999 inline op xor(invar PMC, invar PMC, invar PMC) :base_core { 
     999inline op xor(invar PMC, invar PMC, invar PMC) { 
    10001000    const INTVAL a = VTABLE_get_bool(interp, $2); 
    10011001    const INTVAL b = VTABLE_get_bool(interp, $3); 
    10021002    if (a && ! b) 
  • src/ops/core.ops

    diff --git a/src/ops/core.ops b/src/ops/core.ops
    index 22c298f..27f268a 100644
    a b  
    5454 
    5555=cut 
    5656 
    57 inline op end() :base_core :check_event :flow { 
     57inline op end() :check_event :flow { 
    5858    goto ADDRESS(0); 
    5959} 
    6060 
     
    8383 
    8484=cut 
    8585 
    86 inline op noop() :base_core { 
     86inline op noop() { 
    8787} 
    8888 
    89 inline op check_events() :base_core :flow { 
     89inline op check_events() :flow { 
    9090    opcode_t * const next = expr NEXT(); 
    9191    Parrot_cx_check_tasks(interp, interp->scheduler); 
    9292    goto ADDRESS(next);   /* force this being a branch op */ 
     
    151151 
    152152=cut 
    153153 
    154 inline op local_branch(invar PMC, in LABEL) :base_core :check_event :flow { 
     154inline op local_branch(invar PMC, in LABEL) :check_event :flow { 
    155155    INTVAL return_addr; 
    156156    opcode_t * const dest = expr NEXT(); 
    157157 
  • src/ops/experimental.ops

    diff --git a/src/ops/experimental.ops b/src/ops/experimental.ops
    index 88a7c89..be84031 100644
    a b  
    110110 
    111111=cut 
    112112 
    113 inline op fetch(out PMC, in PMC, in PMC, in PMC) :base_core { 
     113inline op fetch(out PMC, in PMC, in PMC, in PMC) { 
    114114    $1 = VTABLE_get_pmc_keyed(interp, $2, $3); 
    115115 
    116116    if (PMC_IS_NULL($1)) { 
     
    118118    } 
    119119} 
    120120 
    121 inline op fetch(out PMC, in PMC, in INT, in PMC) :base_core { 
     121inline op fetch(out PMC, in PMC, in INT, in PMC) { 
    122122    $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3); 
    123123 
    124124    if (PMC_IS_NULL($1)) { 
     
    126126    } 
    127127} 
    128128 
    129 inline op fetch(out PMC, in PMC, in STR, in PMC) :base_core { 
     129inline op fetch(out PMC, in PMC, in STR, in PMC) { 
    130130    $1 = VTABLE_get_pmc_keyed_str(interp, $2, $3); 
    131131 
    132132    if (PMC_IS_NULL($1)) { 
     
    145145 
    146146=cut 
    147147 
    148 inline op vivify(out PMC, in PMC, in PMC, in PMC) :base_core { 
     148inline op vivify(out PMC, in PMC, in PMC, in PMC) { 
    149149    $1 = VTABLE_get_pmc_keyed(interp, $2, $3); 
    150150 
    151151    if (PMC_IS_NULL($1)) { 
     
    155155    } 
    156156} 
    157157 
    158 inline op vivify(out PMC, in PMC, in INT, in PMC) :base_core { 
     158inline op vivify(out PMC, in PMC, in INT, in PMC) { 
    159159    $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3); 
    160160 
    161161    if (PMC_IS_NULL($1)) { 
     
    165165    } 
    166166} 
    167167 
    168 inline op vivify(out PMC, in PMC, in STR, in PMC) :base_core { 
     168inline op vivify(out PMC, in PMC, in STR, in PMC) { 
    169169    $1 = VTABLE_get_pmc_keyed_str(interp, $2, $3); 
    170170 
    171171    if (PMC_IS_NULL($1)) { 
  • src/ops/math.ops

    diff --git a/src/ops/math.ops b/src/ops/math.ops
    index 1a0825c..6bdadfa 100644
    a b  
    4545 
    4646=cut 
    4747 
    48 inline op abs(inout INT) :base_core { 
     48inline op abs(inout INT) { 
    4949    $1 = abs($1); 
    5050} 
    5151 
    52 inline op abs(inout NUM) :base_core { 
     52inline op abs(inout NUM) { 
    5353    $1 = fabs($1); 
    5454} 
    5555 
    56 inline op abs(out INT, in INT) :base_core { 
     56inline op abs(out INT, in INT) { 
    5757    $1 = abs($2); 
    5858} 
    5959 
    60 inline op abs(out NUM, in NUM) :base_core { 
     60inline op abs(out NUM, in NUM) { 
    6161    $1 = fabs($2); 
    6262} 
    6363 
    64 inline op abs(invar PMC) :base_core { 
     64inline op abs(invar PMC) { 
    6565    VTABLE_i_absolute(interp, $1); 
    6666} 
    6767 
    68 inline op abs(out PMC, invar PMC) :base_core { 
     68inline op abs(out PMC, invar PMC) { 
    6969    $1 = VTABLE_absolute(interp, $2, $1); 
    7070} 
    7171 
     
    9797 
    9898=cut 
    9999 
    100 inline op add(inout INT, in INT) :base_core { 
     100inline op add(inout INT, in INT) { 
    101101    $1 += $2; 
    102102} 
    103103 
    104 inline op add(inout NUM, in NUM) :base_core { 
     104inline op add(inout NUM, in NUM) { 
    105105    $1 += $2; 
    106106} 
    107107 
    108 inline op add(invar PMC, invar PMC) :base_core { 
     108inline op add(invar PMC, invar PMC) { 
    109109    VTABLE_i_add(interp, $1, $2); 
    110110} 
    111111 
    112 inline op add(invar PMC, in INT) :base_core { 
     112inline op add(invar PMC, in INT) { 
    113113    VTABLE_i_add_int(interp, $1, $2); 
    114114} 
    115115 
    116 inline op add(invar PMC, in NUM) :base_core { 
     116inline op add(invar PMC, in NUM) { 
    117117    VTABLE_i_add_float(interp, $1, $2); 
    118118} 
    119119 
    120 inline op add(out INT, in INT, in INT) :base_core { 
     120inline op add(out INT, in INT, in INT) { 
    121121    $1 = $2 + $3; 
    122122} 
    123123 
    124 inline op add(out NUM, in NUM, in NUM) :base_core { 
     124inline op add(out NUM, in NUM, in NUM) { 
    125125    $1 = $2 + $3; 
    126126} 
    127127 
    128 inline op add(invar PMC, invar PMC, invar PMC) :base_core { 
     128inline op add(invar PMC, invar PMC, invar PMC) { 
    129129    $1 = VTABLE_add(interp, $2, $3, $1); 
    130130} 
    131131 
    132 inline op add(invar PMC, invar PMC, in INT) :base_core { 
     132inline op add(invar PMC, invar PMC, in INT) { 
    133133    $1 = VTABLE_add_int(interp, $2, $3, $1); 
    134134} 
    135135 
    136 inline op add(invar PMC, invar PMC, in NUM) :base_core { 
     136inline op add(invar PMC, invar PMC, in NUM) { 
    137137    $1 = VTABLE_add_float(interp, $2, $3, $1); 
    138138} 
    139139 
     
    149149 
    150150=cut 
    151151 
    152 inline op dec(inout INT) :base_core { 
     152inline op dec(inout INT) { 
    153153    $1--; 
    154154} 
    155155 
    156 inline op dec(inout NUM) :base_core { 
     156inline op dec(inout NUM) { 
    157157    $1--; 
    158158} 
    159159 
    160 inline op dec(invar PMC) :base_core { 
     160inline op dec(invar PMC) { 
    161161    VTABLE_decrement(interp, $1); 
    162162} 
    163163 
     
    191191 
    192192=cut 
    193193 
    194 inline op div(inout INT, in INT) :base_core { 
     194inline op div(inout INT, in INT) { 
    195195    const INTVAL den = $2; 
    196196    if (den == 0) { 
    197197        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(), 
     
    202202    $1 /= den; 
    203203} 
    204204 
    205 inline op div(inout NUM, in NUM) :base_core { 
     205inline op div(inout NUM, in NUM) { 
    206206    const FLOATVAL den = $2; 
    207207    if (FLOAT_IS_ZERO(den)) { 
    208208        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(), 
     
    213213    $1 /= den; 
    214214} 
    215215 
    216 inline op div(invar PMC, invar PMC) :base_core { 
     216inline op div(invar PMC, invar PMC) { 
    217217    VTABLE_i_divide(interp, $1, $2); 
    218218} 
    219219 
    220 inline op div(invar PMC, in INT) :base_core { 
     220inline op div(invar PMC, in INT) { 
    221221    VTABLE_i_divide_int(interp, $1, $2); 
    222222} 
    223223 
    224 inline op div(invar PMC, in NUM) :base_core { 
     224inline op div(invar PMC, in NUM) { 
    225225    VTABLE_i_divide_float(interp, $1, $2); 
    226226} 
    227 inline op div(out INT, in INT, in INT) :base_core { 
     227inline op div(out INT, in INT, in INT) { 
    228228    const INTVAL den = $3; 
    229229    if (den == 0) { 
    230230        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(), 
     
    235235    $1 = $2 / den; 
    236236} 
    237237 
    238 inline op div(out NUM, in NUM, in NUM) :base_core { 
     238inline op div(out NUM, in NUM, in NUM) { 
    239239    const FLOATVAL den = $3; 
    240240    if (FLOAT_IS_ZERO(den)) { 
    241241        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(), 
     
    246246    $1 = $2 / den; 
    247247} 
    248248 
    249 inline op div(invar PMC, invar PMC, invar PMC) :base_core { 
     249inline op div(invar PMC, invar PMC, invar PMC) { 
    250250    $1 = VTABLE_divide(interp, $2, $3, $1); 
    251251} 
    252252 
    253 inline op div(invar PMC, invar PMC, in INT) :base_core { 
     253inline op div(invar PMC, invar PMC, in INT) { 
    254254    $1 = VTABLE_divide_int(interp, $2, $3, $1); 
    255255} 
    256256 
    257 inline op div(invar PMC, invar PMC, in NUM) :base_core { 
     257inline op div(invar PMC, invar PMC, in NUM) { 
    258258    $1 = VTABLE_divide_float(interp, $2, $3, $1); 
    259259} 
    260260 
     
    287287 
    288288=cut 
    289289 
    290 inline op fdiv(inout INT, in INT) :base_core { 
     290inline op fdiv(inout INT, in INT) { 
    291291    const INTVAL den = $2; 
    292292    FLOATVAL f; 
    293293 
     
    302302    $1 = (INTVAL)f; 
    303303} 
    304304 
    305 inline op fdiv(inout NUM, in NUM) :base_core { 
     305inline op fdiv(inout NUM, in NUM) { 
    306306    const FLOATVAL den = $2; 
    307307 
    308308    if (FLOAT_IS_ZERO(den)) { 
     
    314314    $1 = floor($1 / den); 
    315315} 
    316316 
    317 inline op fdiv(invar PMC, invar PMC) :base_core { 
     317inline op fdiv(invar PMC, invar PMC) { 
    318318    VTABLE_i_floor_divide(interp, $1, $2); 
    319319} 
    320320 
    321 inline op fdiv(invar PMC, in INT) :base_core { 
     321inline op fdiv(invar PMC, in INT) { 
    322322    VTABLE_i_floor_divide_int(interp, $1, $2); 
    323323} 
    324324 
    325 inline op fdiv(invar PMC, in NUM) :base_core { 
     325inline op fdiv(invar PMC, in NUM) { 
    326326    VTABLE_i_floor_divide_float(interp, $1, $2); 
    327327} 
    328328 
    329 inline op fdiv(out INT, in INT, in INT) :base_core { 
     329inline op fdiv(out INT, in INT, in INT) { 
    330330    const INTVAL den = $3; 
    331331    FLOATVAL f; 
    332332 
     
    341341    $1 = (INTVAL)f; 
    342342} 
    343343 
    344 inline op fdiv(out NUM, in NUM, in NUM) :base_core { 
     344inline op fdiv(out NUM, in NUM, in NUM) { 
    345345    FLOATVAL den = $3; 
    346346    if (FLOAT_IS_ZERO(den)) { 
    347347        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(), 
     
    352352    $1 = floor($2 / den); 
    353353} 
    354354 
    355 inline op fdiv(invar PMC, invar PMC, invar PMC) :base_core { 
     355inline op fdiv(invar PMC, invar PMC, invar PMC) { 
    356356    $1 = VTABLE_floor_divide(interp, $2, $3, $1); 
    357357} 
    358358 
    359 inline op fdiv(invar PMC, invar PMC, in INT) :base_core { 
     359inline op fdiv(invar PMC, invar PMC, in INT) { 
    360360    $1 = VTABLE_floor_divide_int(interp, $2, $3, $1); 
    361361} 
    362362 
    363 inline op fdiv(invar PMC, invar PMC, in NUM) :base_core { 
     363inline op fdiv(invar PMC, invar PMC, in NUM) { 
    364364    $1 = VTABLE_floor_divide_float(interp, $2, $3, $1); 
    365365} 
    366366 
     
    378378 
    379379=cut 
    380380 
    381 inline op ceil(inout NUM) :base_core { 
     381inline op ceil(inout NUM) { 
    382382    $1 = ceil($1); 
    383383} 
    384384 
    385 inline op ceil(out INT, in NUM) :base_core { 
     385inline op ceil(out INT, in NUM) { 
    386386    const FLOATVAL f = ceil($2); 
    387387    $1 = (INTVAL)f; 
    388388} 
    389389 
    390 inline op ceil(out NUM, in NUM) :base_core { 
     390inline op ceil(out NUM, in NUM) { 
    391391    $1 = ceil($2); 
    392392} 
    393393 
     
    405405 
    406406=cut 
    407407 
    408 inline op floor(inout NUM) :base_core { 
     408inline op floor(inout NUM) { 
    409409    $1 = floor($1); 
    410410} 
    411411 
    412 inline op floor(out INT, in NUM) :base_core { 
     412inline op floor(out INT, in NUM) { 
    413413    const FLOATVAL f = floor($2); 
    414414    $1 = (INTVAL)f; 
    415415} 
    416416 
    417 inline op floor(out NUM, in NUM) :base_core { 
     417inline op floor(out NUM, in NUM) { 
    418418    $1 = floor($2); 
    419419} 
    420420 
     
    430430 
    431431=cut 
    432432 
    433 inline op inc(inout INT) :base_core { 
     433inline op inc(inout INT) { 
    434434    $1++; 
    435435} 
    436436 
    437 inline op inc(inout NUM) :base_core { 
     437inline op inc(inout NUM) { 
    438438    $1++; 
    439439} 
    440440 
    441 inline op inc(invar PMC) :base_core { 
     441inline op inc(invar PMC) { 
    442442    VTABLE_increment(interp, $1); 
    443443} 
    444444 
     
    490490 
    491491=cut 
    492492 
    493 op mod(inout INT, in INT) :base_core { 
     493op mod(inout INT, in INT) { 
    494494    $1 = Parrot_util_intval_mod($1, $2); 
    495495} 
    496496 
    497 op mod(inout NUM, in NUM) :base_core { 
     497op mod(inout NUM, in NUM) { 
    498498    $1 = Parrot_util_floatval_mod($1, $2); 
    499499} 
    500500 
    501 inline op mod(invar PMC, invar PMC) :base_core { 
     501inline op mod(invar PMC, invar PMC) { 
    502502    VTABLE_i_modulus(interp, $1, $2); 
    503503} 
    504504 
    505 inline op mod(invar PMC, in INT) :base_core { 
     505inline op mod(invar PMC, in INT) { 
    506506    VTABLE_i_modulus_int(interp, $1, $2); 
    507507} 
    508508 
    509 inline op mod(invar PMC, in NUM) :base_core { 
     509inline op mod(invar PMC, in NUM) { 
    510510    VTABLE_i_modulus_float(interp, $1, $2); 
    511511} 
    512512 
    513 op mod(out INT, in INT, in INT) :base_core { 
     513op mod(out INT, in INT, in INT) { 
    514514    $1 = Parrot_util_intval_mod($2, $3); 
    515515} 
    516516 
    517 op mod(out NUM, in NUM, in NUM) :base_core { 
     517op mod(out NUM, in NUM, in NUM) { 
    518518    $1 = Parrot_util_floatval_mod($2, $3); 
    519519} 
    520520 
    521 inline op mod(invar PMC, invar PMC, invar PMC) :base_core { 
     521inline op mod(invar PMC, invar PMC, invar PMC) { 
    522522    $1 = VTABLE_modulus(interp, $2, $3, $1); 
    523523} 
    524524 
    525 inline op mod(invar PMC, invar PMC, in INT) :base_core { 
     525inline op mod(invar PMC, invar PMC, in INT) { 
    526526    $1 = VTABLE_modulus_int(interp, $2, $3, $1); 
    527527} 
    528528 
    529 inline op mod(invar PMC, invar PMC, in NUM) :base_core { 
     529inline op mod(invar PMC, invar PMC, in NUM) { 
    530530    $1 = VTABLE_modulus_float(interp, $2, $3, $1); 
    531531} 
    532532 
     
    558558 
    559559=cut 
    560560 
    561 inline op mul(inout INT, in INT) :base_core { 
     561inline op mul(inout INT, in INT) { 
    562562    $1 *= $2; 
    563563} 
    564564 
    565 inline op mul(inout NUM, in NUM) :base_core { 
     565inline op mul(inout NUM, in NUM) { 
    566566    $1 *= $2; 
    567567} 
    568568 
    569 inline op mul(invar PMC, invar PMC) :base_core { 
     569inline op mul(invar PMC, invar PMC) { 
    570570    VTABLE_i_multiply(interp, $1, $2); 
    571571} 
    572572 
    573 inline op mul(invar PMC, in INT) :base_core { 
     573inline op mul(invar PMC, in INT) { 
    574574    VTABLE_i_multiply_int(interp, $1, $2); 
    575575} 
    576576 
    577 inline op mul(invar PMC, in NUM) :base_core { 
     577inline op mul(invar PMC, in NUM) { 
    578578    VTABLE_i_multiply_float(interp, $1, $2); 
    579579} 
    580580 
    581 inline op mul(out INT, in INT, in INT) :base_core { 
     581inline op mul(out INT, in INT, in INT) { 
    582582    $1 = $2 * $3; 
    583583} 
    584584 
    585 inline op mul(out NUM, in NUM, in NUM) :base_core { 
     585inline op mul(out NUM, in NUM, in NUM) { 
    586586    $1 = $2 * $3; 
    587587} 
    588588 
    589 inline op mul(invar PMC, invar PMC, invar PMC) :base_core { 
     589inline op mul(invar PMC, invar PMC, invar PMC) { 
    590590    $1 = VTABLE_multiply(interp, $2, $3, $1); 
    591591} 
    592592 
    593 inline op mul(invar PMC, invar PMC, in INT) :base_core { 
     593inline op mul(invar PMC, invar PMC, in INT) { 
    594594    $1 = VTABLE_multiply_int(interp, $2, $3, $1); 
    595595} 
    596596 
    597 inline op mul(invar PMC, invar PMC, in NUM) :base_core { 
     597inline op mul(invar PMC, invar PMC, in NUM) { 
    598598    $1 = VTABLE_multiply_float(interp, $2, $3, $1); 
    599599} 
    600600 
     
    618618 
    619619=cut 
    620620 
    621 inline op neg(inout INT) :base_core { 
     621inline op neg(inout INT) { 
    622622    $1 = - $1; 
    623623} 
    624624 
    625 inline op neg(inout NUM) :base_core { 
     625inline op neg(inout NUM) { 
    626626    $1 = - $1; 
    627627} 
    628628 
    629 inline op neg(invar PMC) :base_core { 
     629inline op neg(invar PMC) { 
    630630    VTABLE_i_neg(interp, $1); 
    631631} 
    632632 
    633 inline op neg(out INT, in INT) :base_core { 
     633inline op neg(out INT, in INT) { 
    634634    $1 = - $2; 
    635635} 
    636636 
    637 inline op neg(out NUM, in NUM) :base_core { 
     637inline op neg(out NUM, in NUM) { 
    638638    $1 = - $2; 
    639639} 
    640640 
    641 inline op neg(out PMC, invar PMC) :base_core { 
     641inline op neg(out PMC, invar PMC) { 
    642642    $1 = VTABLE_neg(interp, $2, $1); 
    643643} 
    644644 
     
    670670 
    671671=cut 
    672672 
    673 inline op sub(inout INT, in INT) :base_core { 
     673inline op sub(inout INT, in INT) { 
    674674    $1 -= $2; 
    675675} 
    676676 
    677 inline op sub(inout NUM, in NUM) :base_core { 
     677inline op sub(inout NUM, in NUM) { 
    678678    $1 -= $2; 
    679679} 
    680680 
    681 inline op sub(invar PMC, invar PMC) :base_core { 
     681inline op sub(invar PMC, invar PMC) { 
    682682    VTABLE_i_subtract(interp, $1, $2); 
    683683} 
    684684 
    685 inline op sub(invar PMC, in INT) :base_core { 
     685inline op sub(invar PMC, in INT) { 
    686686    VTABLE_i_subtract_int(interp, $1, $2); 
    687687} 
    688688 
    689 inline op sub(invar PMC, in NUM) :base_core { 
     689inline op sub(invar PMC, in NUM) { 
    690690    VTABLE_i_subtract_float(interp, $1, $2); 
    691691} 
    692692 
    693 inline op sub(out INT, in INT, in INT) :base_core { 
     693inline op sub(out INT, in INT, in INT) { 
    694694    $1 = $2 - $3; 
    695695} 
    696696 
    697 inline op sub(out NUM, in NUM, in NUM) :base_core { 
     697inline op sub(out NUM, in NUM, in NUM) { 
    698698    $1 = $2 - $3; 
    699699} 
    700700 
    701 inline op sub(invar PMC, invar PMC, invar PMC) :base_core { 
     701inline op sub(invar PMC, invar PMC, invar PMC) { 
    702702    $1 = VTABLE_subtract(interp, $2, $3, $1); 
    703703} 
    704704 
    705 inline op sub(invar PMC, invar PMC, in INT) :base_core { 
     705inline op sub(invar PMC, invar PMC, in INT) { 
    706706    $1 = VTABLE_subtract_int(interp, $2, $3, $1); 
    707707} 
    708708 
    709 inline op sub(invar PMC, invar PMC, in NUM) :base_core { 
     709inline op sub(invar PMC, invar PMC, in NUM) { 
    710710    $1 = VTABLE_subtract_float(interp, $2, $3, $1); 
    711711} 
    712712 
     
    718718 
    719719=cut 
    720720 
    721 inline op sqrt(out NUM, in NUM) :base_core { 
     721inline op sqrt(out NUM, in NUM) { 
    722722    $1 = sqrt((FLOATVAL)$2); 
    723723} 
    724724 
  • src/ops/pmc.ops

    diff --git a/src/ops/pmc.ops b/src/ops/pmc.ops
    index b366adb..54e5efa 100644
    a b  
    669669 
    670670=cut 
    671671 
    672 inline op iter(out PMC, invar PMC) :base_core { 
     672inline op iter(out PMC, invar PMC) { 
    673673    $1 = VTABLE_get_iter(interp, $2); 
    674674} 
    675675 
  • src/ops/set.ops

    diff --git a/src/ops/set.ops b/src/ops/set.ops
    index c63c52b..2a8a15e 100644
    a b  
    8282 
    8383=cut 
    8484 
    85 inline op set(out INT, in INT) :base_core { 
     85inline op set(out INT, in INT) { 
    8686    $1 = $2; 
    8787} 
    8888 
    89 inline op set(out INT, in NUM) :base_core { 
     89inline op set(out INT, in NUM) { 
    9090    $1 = (INTVAL)($2); 
    9191} 
    9292 
    93 inline op set(out INT, in STR) :base_core { 
     93inline op set(out INT, in STR) { 
    9494    $1 = Parrot_str_to_int(interp, $2); 
    9595} 
    9696 
    97 inline op set(out NUM, in NUM) :base_core { 
     97inline op set(out NUM, in NUM) { 
    9898    $1 = $2; 
    9999} 
    100100 
    101 inline op set(out NUM, in INT) :base_core { 
     101inline op set(out NUM, in INT) { 
    102102    $1 = (FLOATVAL)$2; 
    103103} 
    104104 
    105 inline op set(out NUM, in STR) :base_core { 
     105inline op set(out NUM, in STR) { 
    106106    $1 = Parrot_str_to_num(interp, $2); 
    107107} 
    108108 
    109 inline op set(out NUM, invar PMC) :base_core { 
     109inline op set(out NUM, invar PMC) { 
    110110    $1 = VTABLE_get_number(interp, $2); 
    111111} 
    112112 
    113 inline op set(out STR, invar PMC) :base_core { 
     113inline op set(out STR, invar PMC) { 
    114114    $1 = VTABLE_get_string(interp, $2); 
    115115} 
    116116 
    117 inline op set(out STR, invar STR) :base_core { 
     117inline op set(out STR, invar STR) { 
    118118    $1 = $2; 
    119119} 
    120120 
    121 inline op set(out STR, inconst STR) :base_core { 
     121inline op set(out STR, inconst STR) { 
    122122    $1 = $2; 
    123123} 
    124124 
    125 inline op set(out STR, in INT) :base_core { 
     125inline op set(out STR, in INT) { 
    126126    $1 = Parrot_str_from_int(interp, $2); 
    127127} 
    128128 
    129 inline op set(out STR, in NUM) :base_core { 
     129inline op set(out STR, in NUM) { 
    130130    $1 = Parrot_str_from_num(interp, $2); 
    131131} 
    132132 
    133 inline op set(out PMC, inconst PMC) :base_core { 
     133inline op set(out PMC, inconst PMC) { 
    134134    $1 = $2; 
    135135} 
    136136 
    137 inline op set(out PMC, invar PMC) :base_core { 
     137inline op set(out PMC, invar PMC) { 
    138138    $1 = $2; 
    139139} 
    140140 
    141 inline op set(invar PMC, in INT) :base_core { 
     141inline op set(invar PMC, in INT) { 
    142142    VTABLE_set_integer_native(interp, $1, $2); 
    143143} 
    144144 
    145 inline op set(invar PMC, in NUM) :base_core { 
     145inline op set(invar PMC, in NUM) { 
    146146    VTABLE_set_number_native(interp, $1, $2); 
    147147} 
    148148 
    149 inline op set(invar PMC, invar STR) :base_core { 
     149inline op set(invar PMC, invar STR) { 
    150150    VTABLE_set_string_native(interp, $1, $2); 
    151151} 
    152152 
    153 inline op set(invar PMC, inconst STR) :base_core { 
     153inline op set(invar PMC, inconst STR) { 
    154154    VTABLE_set_string_native(interp, $1, $2); 
    155155} 
    156 inline op set(out INT, invar PMC) :base_core { 
     156inline op set(out INT, invar PMC) { 
    157157    $1 = VTABLE_get_integer(interp, $2); 
    158158} 
    159159 
     
    194194 
    195195=cut 
    196196 
    197 inline op assign(invar PMC, invar PMC) :base_core { 
     197inline op assign(invar PMC, invar PMC) { 
    198198    VTABLE_assign_pmc(interp, $1, $2); 
    199199} 
    200200 
    201 inline op assign(invar PMC, in INT) :base_core { 
     201inline op assign(invar PMC, in INT) { 
    202202    VTABLE_set_integer_native(interp, $1, $2); 
    203203} 
    204204 
    205 inline op assign(invar PMC, in NUM) :base_core { 
     205inline op assign(invar PMC, in NUM) { 
    206206    VTABLE_set_number_native(interp, $1, $2); 
    207207} 
    208208 
    209 inline op assign(invar PMC, in STR) :base_core { 
     209inline op assign(invar PMC, in STR) { 
    210210    VTABLE_assign_string_native(interp, $1, $2); 
    211211} 
    212212 
    213 inline op assign(out STR, in STR) :base_core { 
     213inline op assign(out STR, in STR) { 
    214214    $1 = $2; 
    215215} 
    216216 
    217 inline op setref(invar PMC, invar PMC) :base_core { 
     217inline op setref(invar PMC, invar PMC) { 
    218218    VTABLE_set_pmc(interp, $1, $2); 
    219219} 
    220220 
     
    242242 
    243243=cut 
    244244 
    245 inline op set(invar PMC, in INTKEY, in INT) :base_core { 
     245inline op set(invar PMC, in INTKEY, in INT) { 
    246246    VTABLE_set_integer_keyed_int(interp, $1, $2, $3); 
    247247} 
    248248 
    249 inline op set(invar PMC, in INTKEY, in NUM) :base_core { 
     249inline op set(invar PMC, in INTKEY, in NUM) { 
    250250    VTABLE_set_number_keyed_int(interp, $1, $2, $3); 
    251251} 
    252252 
    253 inline op set(invar PMC, in INTKEY, in STR) :base_core { 
     253inline op set(invar PMC, in INTKEY, in STR) { 
    254254    VTABLE_set_string_keyed_int(interp, $1, $2, $3); 
    255255} 
    256256 
    257 inline op set(invar PMC, in INTKEY, invar PMC) :base_core { 
     257inline op set(invar PMC, in INTKEY, invar PMC) { 
    258258    VTABLE_set_pmc_keyed_int(interp, $1, $2, $3); 
    259259} 
    260260 
     
    278278 
    279279=cut 
    280280 
    281 inline op set(out INT, invar PMC, in INTKEY) :base_core { 
     281inline op set(out INT, invar PMC, in INTKEY) { 
    282282    $1 = VTABLE_get_integer_keyed_int(interp, $2, $3); 
    283283} 
    284284 
    285 inline op set(out NUM, invar PMC, in INTKEY) :base_core { 
     285inline op set(out NUM, invar PMC, in INTKEY) { 
    286286    $1 = VTABLE_get_number_keyed_int(interp, $2, $3); 
    287287} 
    288288 
    289 inline op set(out STR, invar PMC, in INTKEY) :base_core { 
     289inline op set(out STR, invar PMC, in INTKEY) { 
    290290    $1 = VTABLE_get_string_keyed_int(interp, $2, $3); 
    291291} 
    292292 
    293 inline op set(out PMC, invar PMC, in INTKEY) :base_core { 
     293inline op set(out PMC, invar PMC, in INTKEY) { 
    294294    $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3); 
    295295} 
    296296 
     
    314314 
    315315=cut 
    316316 
    317 inline op set(invar PMC, in KEY, in INT) :base_core { 
     317inline op set(invar PMC, in KEY, in INT) { 
    318318    VTABLE_set_integer_keyed(interp, $1, $2, $3); 
    319319} 
    320320 
    321 inline op set(invar PMC, in KEY, in NUM) :base_core { 
     321inline op set(invar PMC, in KEY, in NUM) { 
    322322    VTABLE_set_number_keyed(interp, $1, $2, $3); 
    323323} 
    324324 
    325 inline op set(invar PMC, in KEY, in STR) :base_core { 
     325inline op set(invar PMC, in KEY, in STR) { 
    326326    VTABLE_set_string_keyed(interp, $1, $2, $3); 
    327327} 
    328328 
    329 inline op set(invar PMC, in KEY, invar PMC) :base_core { 
     329inline op set(invar PMC, in KEY, invar PMC) { 
    330330    VTABLE_set_pmc_keyed(interp, $1, $2, $3); 
    331331} 
    332332 
     
    350350 
    351351=cut 
    352352 
    353 inline op set(out INT, invar PMC, in KEY) :base_core { 
     353inline op set(out INT, invar PMC, in KEY) { 
    354354    $1 = VTABLE_get_integer_keyed(interp, $2, $3); 
    355355} 
    356356 
    357 inline op set(out NUM, invar PMC, in KEY) :base_core { 
     357inline op set(out NUM, invar PMC, in KEY) { 
    358358    $1 = VTABLE_get_number_keyed(interp, $2, $3); 
    359359} 
    360360 
    361 inline op set(out STR, invar PMC, in KEY) :base_core { 
     361inline op set(out STR, invar PMC, in KEY) { 
    362362    $1 = VTABLE_get_string_keyed(interp, $2, $3); 
    363363} 
    364364 
    365 inline op set(out PMC, invar PMC, in KEY) :base_core { 
     365inline op set(out PMC, invar PMC, in KEY) { 
    366366    $1 = VTABLE_get_pmc_keyed(interp, $2, $3); 
    367367} 
    368368 
     
    466466 
    467467=cut 
    468468 
    469 inline op null(out STR) :base_core { 
     469inline op null(out STR) { 
    470470    $1 = STRINGNULL; 
    471471} 
    472472 
    473 inline op null(out INT) :base_core { 
     473inline op null(out INT) { 
    474474    $1 = 0; 
    475475} 
    476476 
    477 inline op null(out PMC) :base_core { 
     477inline op null(out PMC) { 
    478478    $1 = PMCNULL; 
    479479} 
    480480 
    481 inline op null(out NUM) :base_core { 
     481inline op null(out NUM) { 
    482482    $1 = 0; 
    483483} 
    484484 
  • src/ops/string.ops

    diff --git a/src/ops/string.ops b/src/ops/string.ops
    index d3ce85f..84b7e03 100644
    a b  
    4646 
    4747=cut 
    4848 
    49 inline op ord(out INT, in STR) :base_core { 
     49inline op ord(out INT, in STR) { 
    5050    $1 = STRING_ord(interp, $2, 0); 
    5151} 
    5252 
    53 inline op ord(out INT, in STR, in INT) :base_core { 
     53inline op ord(out INT, in STR, in INT) { 
    5454    $1 = STRING_ord(interp, $2, $3); 
    5555} 
    5656 
     
    6161 
    6262=cut 
    6363 
    64 inline op chr(out STR, in INT) :base_core { 
     64inline op chr(out STR, in INT) { 
    6565    STRING * const s = Parrot_str_chr(interp, (UINTVAL)$2); 
    6666    $1 = s; 
    6767} 
     
    7575 
    7676=cut 
    7777 
    78 inline op chopn(out STR, in STR, in INT) :base_core { 
     78inline op chopn(out STR, in STR, in INT) { 
    7979    $1 = Parrot_str_chopn(interp, $2, $3); 
    8080} 
    8181 
     
    9696 
    9797=cut 
    9898 
    99 inline op concat(invar PMC, invar PMC) :base_core { 
     99inline op concat(invar PMC, invar PMC) { 
    100100    VTABLE_i_concatenate(interp, $1, $2); 
    101101} 
    102102 
    103 inline op concat(invar PMC, in STR) :base_core { 
     103inline op concat(invar PMC, in STR) { 
    104104    VTABLE_i_concatenate_str(interp, $1, $2); 
    105105} 
    106106 
     
    108108    $1 = Parrot_str_concat(interp, $2, $3); 
    109109} 
    110110 
    111 inline op concat(invar PMC, invar PMC, in STR) :base_core { 
     111inline op concat(invar PMC, invar PMC, in STR) { 
    112112    $1 = VTABLE_concatenate_str(interp, $2, $3, $1); 
    113113} 
    114114 
    115 inline op concat(invar PMC, invar PMC, invar PMC) :base_core { 
     115inline op concat(invar PMC, invar PMC, invar PMC) { 
    116116    $1 = VTABLE_concatenate(interp, $2, $3, $1); 
    117117} 
    118118 
     
    137137    $1 = Parrot_str_repeat(interp, $2, (UINTVAL)$3); 
    138138} 
    139139 
    140 inline op repeat(invar PMC, invar PMC, in INT) :base_core { 
     140inline op repeat(invar PMC, invar PMC, in INT) { 
    141141    if ($3 < 0) { 
    142142        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL, 
    143143                EXCEPTION_NEG_REPEAT, 
     
    147147    $1 = VTABLE_repeat_int(interp, $2, $3, $1); 
    148148} 
    149149 
    150 inline op repeat(invar PMC, invar PMC, invar PMC) :base_core { 
     150inline op repeat(invar PMC, invar PMC, invar PMC) { 
    151151    if (VTABLE_get_integer(interp, $3) < 0) { 
    152152        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL, 
    153153                EXCEPTION_NEG_REPEAT, 
     
    166166 
    167167=cut 
    168168 
    169 inline op repeat(invar PMC, in INT) :base_core { 
     169inline op repeat(invar PMC, in INT) { 
    170170    VTABLE_i_repeat_int(interp, $1, $2); 
    171171} 
    172172 
    173 inline op repeat(invar PMC, invar PMC) :base_core { 
     173inline op repeat(invar PMC, invar PMC) { 
    174174    VTABLE_i_repeat(interp, $1, $2); 
    175175} 
    176176 
     
    251251 
    252252=cut 
    253253 
    254 inline op substr(out STR, in STR, in INT) :base_core { 
     254inline op substr(out STR, in STR, in INT) { 
    255255    const INTVAL len = Parrot_str_byte_length(interp, $2); 
    256256    $1 = STRING_substr(interp, $2, $3, len); 
    257257} 
    258258 
    259 inline op substr(out STR, in STR, in INT, in INT) :base_core { 
     259inline op substr(out STR, in STR, in INT, in INT) { 
    260260    $1 = STRING_substr(interp, $2, $3, $4); 
    261261} 
    262262 
    263 inline op substr(out STR, invar PMC, in INT, in INT) :base_core { 
     263inline op substr(out STR, invar PMC, in INT, in INT) { 
    264264    $1 = VTABLE_substr_str(interp, $2, $3, $4); 
    265265} 
    266266 
    267 inline op replace(out STR, in STR, in INT, in INT, in STR) :base_core { 
     267inline op replace(out STR, in STR, in INT, in INT, in STR) { 
    268268    $1 = Parrot_str_replace(interp, $2, $3, $4, $5); 
    269269} 
    270270 
     
    284284 
    285285=cut 
    286286 
    287 inline op index(out INT, in STR, in STR) :base_core { 
     287inline op index(out INT, in STR, in STR) { 
    288288    $1 = ($2 && $3) ? STRING_index(interp, $2, $3, 0) : -1; 
    289289} 
    290290 
    291 inline op index(out INT, in STR, in STR, in INT) :base_core { 
     291inline op index(out INT, in STR, in STR, in INT) { 
    292292    $1 = ($2 && $3) ? STRING_index(interp, $2, $3, $4) : -1; 
    293293} 
    294294 
     
    308308 
    309309=cut 
    310310 
    311 inline op sprintf(out STR, in STR, invar PMC) :base_core { 
     311inline op sprintf(out STR, in STR, invar PMC) { 
    312312    $1=Parrot_psprintf(interp, $2, $3); 
    313313} 
    314314 
    315 inline op sprintf(out PMC, invar PMC, invar PMC) :base_core { 
     315inline op sprintf(out PMC, invar PMC, invar PMC) { 
    316316    VTABLE_set_string_native(interp, $1, 
    317317        Parrot_psprintf(interp, VTABLE_get_string(interp, $2), $3)); 
    318318} 
     
    362362 
    363363=cut 
    364364 
    365 inline op stringinfo(out INT, in STR, in INT) :base_core { 
     365inline op stringinfo(out INT, in STR, in INT) { 
    366366    if ($2 == NULL) 
    367367        $1 = 0; 
    368368    else { 
     
    403403 
    404404=cut 
    405405 
    406 inline op upcase(out STR, in STR) :base_core { 
     406inline op upcase(out STR, in STR) { 
    407407    $1 = Parrot_str_upcase(interp, $2); 
    408408} 
    409409 
     
    413413 
    414414=cut 
    415415 
    416 inline op downcase(out STR, in STR) :base_core { 
     416inline op downcase(out STR, in STR) { 
    417417    $1 = Parrot_str_downcase(interp, $2); 
    418418} 
    419419 
     
    423423 
    424424=cut 
    425425 
    426 inline op titlecase(out STR, in STR) :base_core { 
     426inline op titlecase(out STR, in STR) { 
    427427    $1 = Parrot_str_titlecase(interp, $2); 
    428428} 
    429429 
     
    445445 
    446446=cut 
    447447 
    448 op join(out STR, in STR, invar PMC) :base_core { 
     448op join(out STR, in STR, invar PMC) { 
    449449    $1 = Parrot_str_join(interp, $2, $3); 
    450450} 
    451451 
    452 op split(out PMC, in STR, in STR) :base_core { 
     452op split(out PMC, in STR, in STR) { 
    453453    $1 = Parrot_str_split(interp, $2, $3); 
    454454} 
    455455 
     
    476476 
    477477=cut 
    478478 
    479 op encoding(out INT, in STR) :base_core { 
     479op encoding(out INT, in STR) { 
    480480    $1 = Parrot_encoding_number_of_str(interp, $2); 
    481481} 
    482482 
    483 op encodingname(out STR, in INT) :base_core { 
     483op encodingname(out STR, in INT) { 
    484484    $1 = Parrot_encoding_name(interp, $2); 
    485485} 
    486486 
    487 op find_encoding(out INT, in STR) :base_core { 
     487op find_encoding(out INT, in STR) { 
    488488    const INTVAL n = Parrot_encoding_number(interp, $2); 
    489489    if (n < 0) { 
    490490        opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL, 
  • src/ops/var.ops

    diff --git a/src/ops/var.ops b/src/ops/var.ops
    index 212ca34..840eef4 100644
    a b  
    472472 
    473473=cut 
    474474 
    475 inline op find_sub_not_null(out PMC, in STR) :base_core { 
     475inline op find_sub_not_null(out PMC, in STR) { 
    476476    opcode_t *dest = expr NEXT(); 
    477477    PMC *sub = Parrot_ns_find_named_item(interp, $2, dest); 
    478478