Ticket #2093: tt2093.patch

src/ops/bit.ops

@@ -52 +52 @@
 
 =cut
 
-inline op band(inout INT, in INT) :base_core {
+inline op band(inout INT, in INT) {
     $1 &= $2;
 }
 
-inline op band(out INT, in INT, in INT) :base_core {
+inline op band(out INT, in INT, in INT) {
     $1 = $2 & $3;
 }
 
@@ -74 +74 @@
 
 =cut
 
-inline op bor(inout INT, in INT) :base_core {
+inline op bor(inout INT, in INT) {
     $1 |= $2;
 }
 
-inline op bor(out INT, in INT, in INT) :base_core {
+inline op bor(out INT, in INT, in INT) {
     $1 = $2 | $3;
 }
 
@@ -94 +94 @@
 
 =cut
 
-inline op shl(inout INT, in INT) :base_core {
+inline op shl(inout INT, in INT) {
     $1 = bit_shift_left($1, $2);
 }
 
-inline op shl(out INT, in INT, in INT) :base_core {
+inline op shl(out INT, in INT, in INT) {
     $1 = bit_shift_left($2, $3);
 }
 
@@ -114 +114 @@
 
 =cut
 
-inline op shr(inout INT, in INT) :base_core {
+inline op shr(inout INT, in INT) {
     const INTVAL signed_shift = -$2;
     $1 = bit_shift_left($1, signed_shift);
 }
 
-inline op shr(out INT, in INT, in INT) :base_core {
+inline op shr(out INT, in INT, in INT) {
     const INTVAL signed_shift = -$3;
     $1 = bit_shift_left($2, signed_shift);
 }
@@ -136 +136 @@
 
 =cut
 
-inline op lsr(out INT, in INT) :base_core {
+inline op lsr(out INT, in INT) {
     const UINTVAL a = (UINTVAL)$1;
     const UINTVAL b = a >> $2;
     $1 = (INTVAL)b;
 }
 
-inline op lsr(out INT, in INT, in INT) :base_core {
+inline op lsr(out INT, in INT, in INT) {
     $1 = (INTVAL)((UINTVAL)$2 >> $3);
 }
 
@@ -160 +160 @@
 
 =cut
 
-inline op bxor(inout INT, in INT) :base_core {
+inline op bxor(inout INT, in INT) {
     $1 ^= $2;
 }
 
-inline op bxor(out INT, in INT, in INT) :base_core {
+inline op bxor(out INT, in INT, in INT) {
     $1 = $2 ^ $3;
 }
 

src/ops/cmp.ops

@@ -64 +64 @@
 
 =cut
 
-inline op eq(in INT, in INT, inconst LABEL) :base_core {
+inline op eq(in INT, in INT, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
 }
 
-inline op eq(in NUM, in NUM, inconst LABEL) :base_core {
+inline op eq(in NUM, in NUM, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
 }
 
-op eq(in STR, in STR, inconst LABEL) :base_core {
+op eq(in STR, in STR, inconst LABEL) {
     if (STRING_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_is_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq(invar PMC, in INT, inconst LABEL) :base_core {
+op eq(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -100 +100 @@
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op eq(invar PMC, in NUM, inconst LABEL) :base_core {
+op eq(invar PMC, in NUM, inconst LABEL) {
     /*
      * the get_number and get_string should probably
      * be also replaced with code like above, as
@@ -112 +112 @@
     }
 }
 
-op eq(invar PMC, in STR, inconst LABEL) :base_core {
+op eq(invar PMC, in STR, inconst LABEL) {
     if (STRING_equal(interp, VTABLE_get_string(interp, $1), $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_is_equal_string(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_is_equal_num(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op eq_addr(in STR, in STR, inconst LABEL) :base_core {
+op eq_addr(in STR, in STR, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
 }
 
-op eq_addr(invar PMC, invar PMC, inconst LABEL) :base_core {
+op eq_addr(invar PMC, invar PMC, inconst LABEL) {
     if ($1 == $2) {
         goto OFFSET($3);
     }
@@ -170 +170 @@
 
 =cut
 
-inline op ne(in INT, in INT, inconst LABEL) :base_core {
+inline op ne(in INT, in INT, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
 }
 
-inline op ne(in NUM, in NUM, inconst LABEL) :base_core {
+inline op ne(in NUM, in NUM, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
 }
 
-op ne(in STR, in STR, inconst LABEL) :base_core {
+op ne(in STR, in STR, inconst LABEL) {
     if (!STRING_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op ne(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne(invar PMC, invar PMC, inconst LABEL) {
     if (!VTABLE_is_equal(interp, $1, $2)) {
         goto OFFSET($3);
     }
 }
 
-op ne(invar PMC, in INT, inconst LABEL) :base_core {
+op ne(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -206 +206 @@
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op ne(invar PMC, in NUM, inconst LABEL) :base_core {
+op ne(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) != $2) {
         goto OFFSET($3);
     }
 }
 
-op ne(invar PMC, in STR, inconst LABEL) :base_core {
+op ne(invar PMC, in STR, inconst LABEL) {
     if (!STRING_equal(interp, VTABLE_get_string(interp, $1), $2)) {
         goto OFFSET($3);
     }
 }
 
-op ne_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) != 0) {
         goto OFFSET($3);
     }
 }
 
-op ne_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) != 0) {
         goto OFFSET($3);
     }
 }
 
-op ne_addr(in STR, in STR, inconst LABEL) :base_core {
+op ne_addr(in STR, in STR, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
 }
 
-op ne_addr(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ne_addr(invar PMC, invar PMC, inconst LABEL) {
     if ($1 != $2) {
         goto OFFSET($3);
     }
@@ -266 +266 @@
 
 =cut
 
-inline op lt(in INT, in INT, inconst LABEL) :base_core {
+inline op lt(in INT, in INT, inconst LABEL) {
     if ($1 < $2) {
         goto OFFSET($3);
     }
 }
 
-inline op lt(in NUM, in NUM, inconst LABEL) :base_core {
+inline op lt(in NUM, in NUM, inconst LABEL) {
     if ($1 < $2) {
         goto OFFSET($3);
     }
 }
 
-op lt(in STR, in STR, inconst LABEL) :base_core {
+op lt(in STR, in STR, inconst LABEL) {
     if (STRING_compare(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt(invar PMC, invar PMC, inconst LABEL) :base_core {
+op lt(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt(invar PMC, in INT, inconst LABEL) :base_core {
+op lt(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -302 +302 @@
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op lt(invar PMC, in NUM, inconst LABEL) :base_core {
+op lt(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) < $2) {
         goto OFFSET($3);
     }
 }
 
-op lt(invar PMC, in STR, inconst LABEL) :base_core {
+op lt(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op lt_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
 }
 
-op lt_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op lt_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) < 0) {
         goto OFFSET($3);
     }
@@ -350 +350 @@
 
 =cut
 
-inline op le(in INT, in INT, inconst LABEL) :base_core {
+inline op le(in INT, in INT, inconst LABEL) {
     if ($1 <= $2) {
         goto OFFSET($3);
     }
 }
 
-inline op le(in NUM, in NUM, inconst LABEL) :base_core {
+inline op le(in NUM, in NUM, inconst LABEL) {
     if ($1 <= $2) {
         goto OFFSET($3);
     }
 }
 
-op le(in STR, in STR, inconst LABEL) :base_core {
+op le(in STR, in STR, inconst LABEL) {
     if (STRING_compare(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le(invar PMC, invar PMC, inconst LABEL) :base_core {
+op le(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le(invar PMC, in INT, inconst LABEL) :base_core {
+op le(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -386 +386 @@
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op le(invar PMC, in NUM, inconst LABEL) :base_core {
+op le(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) <= $2) {
         goto OFFSET($3);
     }
 }
 
-op le(invar PMC, in STR, inconst LABEL) :base_core {
+op le(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op le_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
 }
 
-op le_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op le_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) <= 0) {
         goto OFFSET($3);
     }
@@ -428 +428 @@
 
 =cut
 
-op gt(invar PMC, invar PMC, inconst LABEL) :base_core {
+op gt(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) > 0) {
         goto OFFSET($3);
     }
 }
 
-op gt(invar PMC, in INT, inconst LABEL) :base_core {
+op gt(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -446 +446 @@
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op gt(invar PMC, in NUM, inconst LABEL) :base_core {
+op gt(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) > $2) {
         goto OFFSET($3);
     }
 }
 
-op gt(invar PMC, in STR, inconst LABEL) :base_core {
+op gt(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) > 0) {
         goto OFFSET($3);
     }
 }
 
-op gt_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op gt_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) > 0) {
         goto OFFSET($3);
     }
 }
 
-op gt_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op gt_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) > 0) {
         goto OFFSET($3);
     }
@@ -488 +488 @@
 
 =cut
 
-op ge(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ge(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp(interp, $1, $2) >= 0) {
         goto OFFSET($3);
     }
 }
 
-op ge(invar PMC, in INT, inconst LABEL) :base_core {
+op ge(invar PMC, in INT, inconst LABEL) {
     PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
     VTABLE_set_integer_native(interp, temp, $2);
 
@@ -506 +506 @@
     Parrot_pmc_free_temporary(interp, temp);
 }
 
-op ge(invar PMC, in NUM, inconst LABEL) :base_core {
+op ge(invar PMC, in NUM, inconst LABEL) {
     if (VTABLE_get_number(interp, $1) >= $2) {
         goto OFFSET($3);
     }
 }
 
-op ge(invar PMC, in STR, inconst LABEL) :base_core {
+op ge(invar PMC, in STR, inconst LABEL) {
     if (STRING_compare(interp, VTABLE_get_string(interp, $1), $2) >= 0) {
         goto OFFSET($3);
     }
 }
 
-op ge_str(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ge_str(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_string(interp, $1, $2) >= 0) {
         goto OFFSET($3);
     }
 }
 
-op ge_num(invar PMC, invar PMC, inconst LABEL) :base_core {
+op ge_num(invar PMC, invar PMC, inconst LABEL) {
     if (VTABLE_cmp_num(interp, $1, $2) >= 0) {
         goto OFFSET($3);
     }
@@ -613 +613 @@
 
 =cut
 
-inline op cmp(out INT, in INT, in INT) :base_core {
+inline op cmp(out INT, in INT, in INT) {
     $1 = $2 < $3 ? -1 :
          $2 > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, in NUM, in NUM) :base_core {
+inline op cmp(out INT, in NUM, in NUM) {
     $1 = $2 < $3 ? -1 :
          $2 > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, in STR, in STR) :base_core {
+inline op cmp(out INT, in STR, in STR) {
     $1 = STRING_compare(interp, $2, $3);
 }
 
-inline op cmp(out INT, invar PMC, invar PMC) :base_core {
+inline op cmp(out INT, invar PMC, invar PMC) {
     $1 = VTABLE_cmp(interp, $2, $3);
 }
 
-inline op cmp(out INT, invar PMC, in INT) :base_core {
+inline op cmp(out INT, invar PMC, in INT) {
     const INTVAL l = VTABLE_get_integer(interp, $2);
     $1 = l < $3 ? -1 :
          l > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, invar PMC, in NUM) :base_core {
+inline op cmp(out INT, invar PMC, in NUM) {
     const FLOATVAL l = VTABLE_get_number(interp, $2);
     $1 = l < $3 ? -1 :
          l > $3 ? +1 :
          0;
 }
 
-inline op cmp(out INT, invar PMC, in STR) :base_core {
+inline op cmp(out INT, invar PMC, in STR) {
     STRING* const l = VTABLE_get_string(interp, $2);
     $1 = STRING_compare(interp, l, $3);
 }
 
-inline op cmp_str(out INT, invar PMC, invar PMC) :base_core {
+inline op cmp_str(out INT, invar PMC, invar PMC) {
     $1 = VTABLE_cmp_string(interp, $2, $3);
 }
 
-inline op cmp_num(out INT, invar PMC, invar PMC) :base_core {
+inline op cmp_num(out INT, invar PMC, invar PMC) {
     $1 = VTABLE_cmp_num(interp, $2, $3);
 }
 
@@ -668 +668 @@
 
 =cut
 
-inline op cmp_pmc(out PMC, invar PMC, invar PMC) :base_core {
+inline op cmp_pmc(out PMC, invar PMC, invar PMC) {
     $1 = VTABLE_cmp_pmc(interp, $2, $3);
 }
 
@@ -922 +922 @@
 
 =cut
 
-inline op and(out INT, in INT, in INT) :base_core {
+inline op and(out INT, in INT, in INT) {
     $1 = $2 ? $3 : $2;
 }
 
-inline op and(invar PMC, invar PMC, invar PMC) :base_core {
+inline op and(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_get_bool(interp, $2) ? $3 : $2;
 }
 
@@ -944 +944 @@
 
 =cut
 
-inline op not(inout INT) :base_core {
+inline op not(inout INT) {
     $1 = ! $1;
 }
 
-inline op not(out INT, in INT) :base_core {
+inline op not(out INT, in INT) {
     $1 = ! $2;
 }
 
-inline op not(invar PMC) :base_core {
+inline op not(invar PMC) {
     VTABLE_set_bool(interp, $1, !VTABLE_get_bool(interp, $1));
 }
 
-inline op not(out PMC, invar PMC) :base_core {
+inline op not(out PMC, invar PMC) {
     const INTVAL a = ! VTABLE_get_bool(interp, $2);
     if (PMC_IS_NULL($1))
         $1 = Parrot_pmc_new(interp, Parrot_hll_get_ctx_HLL_type(interp, enum_class_Boolean));
@@ -973 +973 @@
 
 =cut
 
-inline op or(out INT, in INT, in INT) :base_core {
+inline op or(out INT, in INT, in INT) {
     $1 = $2 ? $2 : $3;
 }
 
-inline op or(invar PMC, invar PMC, invar PMC) :base_core {
+inline op or(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_get_bool(interp, $2) ? $2 : $3;
 }
 
@@ -992 +992 @@
 
 =cut
 
-inline op xor(out INT, in INT, in INT) :base_core {
+inline op xor(out INT, in INT, in INT) {
     $1 = ($2 && ! $3) ? $2 : ($3 && ! $2) ? $3 : 0;
 }
 
-inline op xor(invar PMC, invar PMC, invar PMC) :base_core {
+inline op xor(invar PMC, invar PMC, invar PMC) {
     const INTVAL a = VTABLE_get_bool(interp, $2);
     const INTVAL b = VTABLE_get_bool(interp, $3);
     if (a && ! b)

src/ops/core.ops

@@ -54 +54 @@
 
 =cut
 
-inline op end() :base_core :check_event :flow {
+inline op end() :check_event :flow {
     goto ADDRESS(0);
 }
 
@@ -83 +83 @@
 
 =cut
 
-inline op noop() :base_core {
+inline op noop() {
 }
 
-inline op check_events() :base_core :flow {
+inline op check_events() :flow {
     opcode_t * const next = expr NEXT();
     Parrot_cx_check_tasks(interp, interp->scheduler);
     goto ADDRESS(next);   /* force this being a branch op */
@@ -151 +151 @@
 
 =cut
 
-inline op local_branch(invar PMC, in LABEL) :base_core :check_event :flow {
+inline op local_branch(invar PMC, in LABEL) :check_event :flow {
     INTVAL return_addr;
     opcode_t * const dest = expr NEXT();
 

src/ops/experimental.ops

@@ -110 +110 @@
 
 =cut
 
-inline op fetch(out PMC, in PMC, in PMC, in PMC) :base_core {
+inline op fetch(out PMC, in PMC, in PMC, in PMC) {
     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -118 +118 @@
     }
 }
 
-inline op fetch(out PMC, in PMC, in INT, in PMC) :base_core {
+inline op fetch(out PMC, in PMC, in INT, in PMC) {
     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -126 +126 @@
     }
 }
 
-inline op fetch(out PMC, in PMC, in STR, in PMC) :base_core {
+inline op fetch(out PMC, in PMC, in STR, in PMC) {
     $1 = VTABLE_get_pmc_keyed_str(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -145 +145 @@
 
 =cut
 
-inline op vivify(out PMC, in PMC, in PMC, in PMC) :base_core {
+inline op vivify(out PMC, in PMC, in PMC, in PMC) {
     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -155 +155 @@
     }
 }
 
-inline op vivify(out PMC, in PMC, in INT, in PMC) :base_core {
+inline op vivify(out PMC, in PMC, in INT, in PMC) {
     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {
@@ -165 +165 @@
     }
 }
 
-inline op vivify(out PMC, in PMC, in STR, in PMC) :base_core {
+inline op vivify(out PMC, in PMC, in STR, in PMC) {
     $1 = VTABLE_get_pmc_keyed_str(interp, $2, $3);
 
     if (PMC_IS_NULL($1)) {

src/ops/math.ops

@@ -45 +45 @@
 
 =cut
 
-inline op abs(inout INT) :base_core {
+inline op abs(inout INT) {
     $1 = abs($1);
 }
 
-inline op abs(inout NUM) :base_core {
+inline op abs(inout NUM) {
     $1 = fabs($1);
 }
 
-inline op abs(out INT, in INT) :base_core {
+inline op abs(out INT, in INT) {
     $1 = abs($2);
 }
 
-inline op abs(out NUM, in NUM) :base_core {
+inline op abs(out NUM, in NUM) {
     $1 = fabs($2);
 }
 
-inline op abs(invar PMC) :base_core {
+inline op abs(invar PMC) {
     VTABLE_i_absolute(interp, $1);
 }
 
-inline op abs(out PMC, invar PMC) :base_core {
+inline op abs(out PMC, invar PMC) {
     $1 = VTABLE_absolute(interp, $2, $1);
 }
 
@@ -97 +97 @@
 
 =cut
 
-inline op add(inout INT, in INT) :base_core {
+inline op add(inout INT, in INT) {
     $1 += $2;
 }
 
-inline op add(inout NUM, in NUM) :base_core {
+inline op add(inout NUM, in NUM) {
     $1 += $2;
 }
 
-inline op add(invar PMC, invar PMC) :base_core {
+inline op add(invar PMC, invar PMC) {
     VTABLE_i_add(interp, $1, $2);
 }
 
-inline op add(invar PMC, in INT) :base_core {
+inline op add(invar PMC, in INT) {
     VTABLE_i_add_int(interp, $1, $2);
 }
 
-inline op add(invar PMC, in NUM) :base_core {
+inline op add(invar PMC, in NUM) {
     VTABLE_i_add_float(interp, $1, $2);
 }
 
-inline op add(out INT, in INT, in INT) :base_core {
+inline op add(out INT, in INT, in INT) {
     $1 = $2 + $3;
 }
 
-inline op add(out NUM, in NUM, in NUM) :base_core {
+inline op add(out NUM, in NUM, in NUM) {
     $1 = $2 + $3;
 }
 
-inline op add(invar PMC, invar PMC, invar PMC) :base_core {
+inline op add(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_add(interp, $2, $3, $1);
 }
 
-inline op add(invar PMC, invar PMC, in INT) :base_core {
+inline op add(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_add_int(interp, $2, $3, $1);
 }
 
-inline op add(invar PMC, invar PMC, in NUM) :base_core {
+inline op add(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_add_float(interp, $2, $3, $1);
 }
 
@@ -149 +149 @@
 
 =cut
 
-inline op dec(inout INT) :base_core {
+inline op dec(inout INT) {
     $1--;
 }
 
-inline op dec(inout NUM) :base_core {
+inline op dec(inout NUM) {
     $1--;
 }
 
-inline op dec(invar PMC) :base_core {
+inline op dec(invar PMC) {
     VTABLE_decrement(interp, $1);
 }
 
@@ -191 +191 @@
 
 =cut
 
-inline op div(inout INT, in INT) :base_core {
+inline op div(inout INT, in INT) {
     const INTVAL den = $2;
     if (den == 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -202 +202 @@
     $1 /= den;
 }
 
-inline op div(inout NUM, in NUM) :base_core {
+inline op div(inout NUM, in NUM) {
     const FLOATVAL den = $2;
     if (FLOAT_IS_ZERO(den)) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -213 +213 @@
     $1 /= den;
 }
 
-inline op div(invar PMC, invar PMC) :base_core {
+inline op div(invar PMC, invar PMC) {
     VTABLE_i_divide(interp, $1, $2);
 }
 
-inline op div(invar PMC, in INT) :base_core {
+inline op div(invar PMC, in INT) {
     VTABLE_i_divide_int(interp, $1, $2);
 }
 
-inline op div(invar PMC, in NUM) :base_core {
+inline op div(invar PMC, in NUM) {
     VTABLE_i_divide_float(interp, $1, $2);
 }
-inline op div(out INT, in INT, in INT) :base_core {
+inline op div(out INT, in INT, in INT) {
     const INTVAL den = $3;
     if (den == 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -235 +235 @@
     $1 = $2 / den;
 }
 
-inline op div(out NUM, in NUM, in NUM) :base_core {
+inline op div(out NUM, in NUM, in NUM) {
     const FLOATVAL den = $3;
     if (FLOAT_IS_ZERO(den)) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -246 +246 @@
     $1 = $2 / den;
 }
 
-inline op div(invar PMC, invar PMC, invar PMC) :base_core {
+inline op div(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_divide(interp, $2, $3, $1);
 }
 
-inline op div(invar PMC, invar PMC, in INT) :base_core {
+inline op div(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_divide_int(interp, $2, $3, $1);
 }
 
-inline op div(invar PMC, invar PMC, in NUM) :base_core {
+inline op div(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_divide_float(interp, $2, $3, $1);
 }
 
@@ -287 +287 @@
 
 =cut
 
-inline op fdiv(inout INT, in INT) :base_core {
+inline op fdiv(inout INT, in INT) {
     const INTVAL den = $2;
     FLOATVAL f;
 
@@ -302 +302 @@
     $1 = (INTVAL)f;
 }
 
-inline op fdiv(inout NUM, in NUM) :base_core {
+inline op fdiv(inout NUM, in NUM) {
     const FLOATVAL den = $2;
 
     if (FLOAT_IS_ZERO(den)) {
@@ -314 +314 @@
     $1 = floor($1 / den);
 }
 
-inline op fdiv(invar PMC, invar PMC) :base_core {
+inline op fdiv(invar PMC, invar PMC) {
     VTABLE_i_floor_divide(interp, $1, $2);
 }
 
-inline op fdiv(invar PMC, in INT) :base_core {
+inline op fdiv(invar PMC, in INT) {
     VTABLE_i_floor_divide_int(interp, $1, $2);
 }
 
-inline op fdiv(invar PMC, in NUM) :base_core {
+inline op fdiv(invar PMC, in NUM) {
     VTABLE_i_floor_divide_float(interp, $1, $2);
 }
 
-inline op fdiv(out INT, in INT, in INT) :base_core {
+inline op fdiv(out INT, in INT, in INT) {
     const INTVAL den = $3;
     FLOATVAL f;
 
@@ -341 +341 @@
     $1 = (INTVAL)f;
 }
 
-inline op fdiv(out NUM, in NUM, in NUM) :base_core {
+inline op fdiv(out NUM, in NUM, in NUM) {
     FLOATVAL den = $3;
     if (FLOAT_IS_ZERO(den)) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, expr NEXT(),
@@ -352 +352 @@
     $1 = floor($2 / den);
 }
 
-inline op fdiv(invar PMC, invar PMC, invar PMC) :base_core {
+inline op fdiv(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_floor_divide(interp, $2, $3, $1);
 }
 
-inline op fdiv(invar PMC, invar PMC, in INT) :base_core {
+inline op fdiv(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_floor_divide_int(interp, $2, $3, $1);
 }
 
-inline op fdiv(invar PMC, invar PMC, in NUM) :base_core {
+inline op fdiv(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_floor_divide_float(interp, $2, $3, $1);
 }
 
@@ -378 +378 @@
 
 =cut
 
-inline op ceil(inout NUM) :base_core {
+inline op ceil(inout NUM) {
     $1 = ceil($1);
 }
 
-inline op ceil(out INT, in NUM) :base_core {
+inline op ceil(out INT, in NUM) {
     const FLOATVAL f = ceil($2);
     $1 = (INTVAL)f;
 }
 
-inline op ceil(out NUM, in NUM) :base_core {
+inline op ceil(out NUM, in NUM) {
     $1 = ceil($2);
 }
 
@@ -405 +405 @@
 
 =cut
 
-inline op floor(inout NUM) :base_core {
+inline op floor(inout NUM) {
     $1 = floor($1);
 }
 
-inline op floor(out INT, in NUM) :base_core {
+inline op floor(out INT, in NUM) {
     const FLOATVAL f = floor($2);
     $1 = (INTVAL)f;
 }
 
-inline op floor(out NUM, in NUM) :base_core {
+inline op floor(out NUM, in NUM) {
     $1 = floor($2);
 }
 
@@ -430 +430 @@
 
 =cut
 
-inline op inc(inout INT) :base_core {
+inline op inc(inout INT) {
     $1++;
 }
 
-inline op inc(inout NUM) :base_core {
+inline op inc(inout NUM) {
     $1++;
 }
 
-inline op inc(invar PMC) :base_core {
+inline op inc(invar PMC) {
     VTABLE_increment(interp, $1);
 }
 
@@ -490 +490 @@
 
 =cut
 
-op mod(inout INT, in INT) :base_core {
+op mod(inout INT, in INT) {
     $1 = Parrot_util_intval_mod($1, $2);
 }
 
-op mod(inout NUM, in NUM) :base_core {
+op mod(inout NUM, in NUM) {
     $1 = Parrot_util_floatval_mod($1, $2);
 }
 
-inline op mod(invar PMC, invar PMC) :base_core {
+inline op mod(invar PMC, invar PMC) {
     VTABLE_i_modulus(interp, $1, $2);
 }
 
-inline op mod(invar PMC, in INT) :base_core {
+inline op mod(invar PMC, in INT) {
     VTABLE_i_modulus_int(interp, $1, $2);
 }
 
-inline op mod(invar PMC, in NUM) :base_core {
+inline op mod(invar PMC, in NUM) {
     VTABLE_i_modulus_float(interp, $1, $2);
 }
 
-op mod(out INT, in INT, in INT) :base_core {
+op mod(out INT, in INT, in INT) {
     $1 = Parrot_util_intval_mod($2, $3);
 }
 
-op mod(out NUM, in NUM, in NUM) :base_core {
+op mod(out NUM, in NUM, in NUM) {
     $1 = Parrot_util_floatval_mod($2, $3);
 }
 
-inline op mod(invar PMC, invar PMC, invar PMC) :base_core {
+inline op mod(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_modulus(interp, $2, $3, $1);
 }
 
-inline op mod(invar PMC, invar PMC, in INT) :base_core {
+inline op mod(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_modulus_int(interp, $2, $3, $1);
 }
 
-inline op mod(invar PMC, invar PMC, in NUM) :base_core {
+inline op mod(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_modulus_float(interp, $2, $3, $1);
 }
 
@@ -558 +558 @@
 
 =cut
 
-inline op mul(inout INT, in INT) :base_core {
+inline op mul(inout INT, in INT) {
     $1 *= $2;
 }
 
-inline op mul(inout NUM, in NUM) :base_core {
+inline op mul(inout NUM, in NUM) {
     $1 *= $2;
 }
 
-inline op mul(invar PMC, invar PMC) :base_core {
+inline op mul(invar PMC, invar PMC) {
     VTABLE_i_multiply(interp, $1, $2);
 }
 
-inline op mul(invar PMC, in INT) :base_core {
+inline op mul(invar PMC, in INT) {
     VTABLE_i_multiply_int(interp, $1, $2);
 }
 
-inline op mul(invar PMC, in NUM) :base_core {
+inline op mul(invar PMC, in NUM) {
     VTABLE_i_multiply_float(interp, $1, $2);
 }
 
-inline op mul(out INT, in INT, in INT) :base_core {
+inline op mul(out INT, in INT, in INT) {
     $1 = $2 * $3;
 }
 
-inline op mul(out NUM, in NUM, in NUM) :base_core {
+inline op mul(out NUM, in NUM, in NUM) {
     $1 = $2 * $3;
 }
 
-inline op mul(invar PMC, invar PMC, invar PMC) :base_core {
+inline op mul(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_multiply(interp, $2, $3, $1);
 }
 
-inline op mul(invar PMC, invar PMC, in INT) :base_core {
+inline op mul(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_multiply_int(interp, $2, $3, $1);
 }
 
-inline op mul(invar PMC, invar PMC, in NUM) :base_core {
+inline op mul(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_multiply_float(interp, $2, $3, $1);
 }
 
@@ -618 +618 @@
 
 =cut
 
-inline op neg(inout INT) :base_core {
+inline op neg(inout INT) {
     $1 = - $1;
 }
 
-inline op neg(inout NUM) :base_core {
+inline op neg(inout NUM) {
     $1 = - $1;
 }
 
-inline op neg(invar PMC) :base_core {
+inline op neg(invar PMC) {
     VTABLE_i_neg(interp, $1);
 }
 
-inline op neg(out INT, in INT) :base_core {
+inline op neg(out INT, in INT) {
     $1 = - $2;
 }
 
-inline op neg(out NUM, in NUM) :base_core {
+inline op neg(out NUM, in NUM) {
     $1 = - $2;
 }
 
-inline op neg(out PMC, invar PMC) :base_core {
+inline op neg(out PMC, invar PMC) {
     $1 = VTABLE_neg(interp, $2, $1);
 }
 
@@ -670 +670 @@
 
 =cut
 
-inline op sub(inout INT, in INT) :base_core {
+inline op sub(inout INT, in INT) {
     $1 -= $2;
 }
 
-inline op sub(inout NUM, in NUM) :base_core {
+inline op sub(inout NUM, in NUM) {
     $1 -= $2;
 }
 
-inline op sub(invar PMC, invar PMC) :base_core {
+inline op sub(invar PMC, invar PMC) {
     VTABLE_i_subtract(interp, $1, $2);
 }
 
-inline op sub(invar PMC, in INT) :base_core {
+inline op sub(invar PMC, in INT) {
     VTABLE_i_subtract_int(interp, $1, $2);
 }
 
-inline op sub(invar PMC, in NUM) :base_core {
+inline op sub(invar PMC, in NUM) {
     VTABLE_i_subtract_float(interp, $1, $2);
 }
 
-inline op sub(out INT, in INT, in INT) :base_core {
+inline op sub(out INT, in INT, in INT) {
     $1 = $2 - $3;
 }
 
-inline op sub(out NUM, in NUM, in NUM) :base_core {
+inline op sub(out NUM, in NUM, in NUM) {
     $1 = $2 - $3;
 }
 
-inline op sub(invar PMC, invar PMC, invar PMC) :base_core {
+inline op sub(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_subtract(interp, $2, $3, $1);
 }
 
-inline op sub(invar PMC, invar PMC, in INT) :base_core {
+inline op sub(invar PMC, invar PMC, in INT) {
     $1 = VTABLE_subtract_int(interp, $2, $3, $1);
 }
 
-inline op sub(invar PMC, invar PMC, in NUM) :base_core {
+inline op sub(invar PMC, invar PMC, in NUM) {
     $1 = VTABLE_subtract_float(interp, $2, $3, $1);
 }
 
@@ -718 +718 @@
 
 =cut
 
-inline op sqrt(out NUM, in NUM) :base_core {
+inline op sqrt(out NUM, in NUM) {
     $1 = sqrt((FLOATVAL)$2);
 }
 

src/ops/pmc.ops

@@ -669 +669 @@
 
 =cut
 
-inline op iter(out PMC, invar PMC) :base_core {
+inline op iter(out PMC, invar PMC) {
     $1 = VTABLE_get_iter(interp, $2);
 }
 

src/ops/set.ops

@@ -82 +82 @@
 
 =cut
 
-inline op set(out INT, in INT) :base_core {
+inline op set(out INT, in INT) {
     $1 = $2;
 }
 
-inline op set(out INT, in NUM) :base_core {
+inline op set(out INT, in NUM) {
     $1 = (INTVAL)($2);
 }
 
-inline op set(out INT, in STR) :base_core {
+inline op set(out INT, in STR) {
     $1 = Parrot_str_to_int(interp, $2);
 }
 
-inline op set(out NUM, in NUM) :base_core {
+inline op set(out NUM, in NUM) {
     $1 = $2;
 }
 
-inline op set(out NUM, in INT) :base_core {
+inline op set(out NUM, in INT) {
     $1 = (FLOATVAL)$2;
 }
 
-inline op set(out NUM, in STR) :base_core {
+inline op set(out NUM, in STR) {
     $1 = Parrot_str_to_num(interp, $2);
 }
 
-inline op set(out NUM, invar PMC) :base_core {
+inline op set(out NUM, invar PMC) {
     $1 = VTABLE_get_number(interp, $2);
 }
 
-inline op set(out STR, invar PMC) :base_core {
+inline op set(out STR, invar PMC) {
     $1 = VTABLE_get_string(interp, $2);
 }
 
-inline op set(out STR, invar STR) :base_core {
+inline op set(out STR, invar STR) {
     $1 = $2;
 }
 
-inline op set(out STR, inconst STR) :base_core {
+inline op set(out STR, inconst STR) {
     $1 = $2;
 }
 
-inline op set(out STR, in INT) :base_core {
+inline op set(out STR, in INT) {
     $1 = Parrot_str_from_int(interp, $2);
 }
 
-inline op set(out STR, in NUM) :base_core {
+inline op set(out STR, in NUM) {
     $1 = Parrot_str_from_num(interp, $2);
 }
 
-inline op set(out PMC, inconst PMC) :base_core {
+inline op set(out PMC, inconst PMC) {
     $1 = $2;
 }
 
-inline op set(out PMC, invar PMC) :base_core {
+inline op set(out PMC, invar PMC) {
     $1 = $2;
 }
 
-inline op set(invar PMC, in INT) :base_core {
+inline op set(invar PMC, in INT) {
     VTABLE_set_integer_native(interp, $1, $2);
 }
 
-inline op set(invar PMC, in NUM) :base_core {
+inline op set(invar PMC, in NUM) {
     VTABLE_set_number_native(interp, $1, $2);
 }
 
-inline op set(invar PMC, invar STR) :base_core {
+inline op set(invar PMC, invar STR) {
     VTABLE_set_string_native(interp, $1, $2);
 }
 
-inline op set(invar PMC, inconst STR) :base_core {
+inline op set(invar PMC, inconst STR) {
     VTABLE_set_string_native(interp, $1, $2);
 }
-inline op set(out INT, invar PMC) :base_core {
+inline op set(out INT, invar PMC) {
     $1 = VTABLE_get_integer(interp, $2);
 }
 
@@ -194 +194 @@
 
 =cut
 
-inline op assign(invar PMC, invar PMC) :base_core {
+inline op assign(invar PMC, invar PMC) {
     VTABLE_assign_pmc(interp, $1, $2);
 }
 
-inline op assign(invar PMC, in INT) :base_core {
+inline op assign(invar PMC, in INT) {
     VTABLE_set_integer_native(interp, $1, $2);
 }
 
-inline op assign(invar PMC, in NUM) :base_core {
+inline op assign(invar PMC, in NUM) {
     VTABLE_set_number_native(interp, $1, $2);
 }
 
-inline op assign(invar PMC, in STR) :base_core {
+inline op assign(invar PMC, in STR) {
     VTABLE_assign_string_native(interp, $1, $2);
 }
 
-inline op assign(out STR, in STR) :base_core {
+inline op assign(out STR, in STR) {
     $1 = $2;
 }
 
-inline op setref(invar PMC, invar PMC) :base_core {
+inline op setref(invar PMC, invar PMC) {
     VTABLE_set_pmc(interp, $1, $2);
 }
 
@@ -242 +242 @@
 
 =cut
 
-inline op set(invar PMC, in INTKEY, in INT) :base_core {
+inline op set(invar PMC, in INTKEY, in INT) {
     VTABLE_set_integer_keyed_int(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in INTKEY, in NUM) :base_core {
+inline op set(invar PMC, in INTKEY, in NUM) {
     VTABLE_set_number_keyed_int(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in INTKEY, in STR) :base_core {
+inline op set(invar PMC, in INTKEY, in STR) {
     VTABLE_set_string_keyed_int(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in INTKEY, invar PMC) :base_core {
+inline op set(invar PMC, in INTKEY, invar PMC) {
     VTABLE_set_pmc_keyed_int(interp, $1, $2, $3);
 }
 
@@ -278 +278 @@
 
 =cut
 
-inline op set(out INT, invar PMC, in INTKEY) :base_core {
+inline op set(out INT, invar PMC, in INTKEY) {
     $1 = VTABLE_get_integer_keyed_int(interp, $2, $3);
 }
 
-inline op set(out NUM, invar PMC, in INTKEY) :base_core {
+inline op set(out NUM, invar PMC, in INTKEY) {
     $1 = VTABLE_get_number_keyed_int(interp, $2, $3);
 }
 
-inline op set(out STR, invar PMC, in INTKEY) :base_core {
+inline op set(out STR, invar PMC, in INTKEY) {
     $1 = VTABLE_get_string_keyed_int(interp, $2, $3);
 }
 
-inline op set(out PMC, invar PMC, in INTKEY) :base_core {
+inline op set(out PMC, invar PMC, in INTKEY) {
     $1 = VTABLE_get_pmc_keyed_int(interp, $2, $3);
 }
 
@@ -314 +314 @@
 
 =cut
 
-inline op set(invar PMC, in KEY, in INT) :base_core {
+inline op set(invar PMC, in KEY, in INT) {
     VTABLE_set_integer_keyed(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in KEY, in NUM) :base_core {
+inline op set(invar PMC, in KEY, in NUM) {
     VTABLE_set_number_keyed(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in KEY, in STR) :base_core {
+inline op set(invar PMC, in KEY, in STR) {
     VTABLE_set_string_keyed(interp, $1, $2, $3);
 }
 
-inline op set(invar PMC, in KEY, invar PMC) :base_core {
+inline op set(invar PMC, in KEY, invar PMC) {
     VTABLE_set_pmc_keyed(interp, $1, $2, $3);
 }
 
@@ -350 +350 @@
 
 =cut
 
-inline op set(out INT, invar PMC, in KEY) :base_core {
+inline op set(out INT, invar PMC, in KEY) {
     $1 = VTABLE_get_integer_keyed(interp, $2, $3);
 }
 
-inline op set(out NUM, invar PMC, in KEY) :base_core {
+inline op set(out NUM, invar PMC, in KEY) {
     $1 = VTABLE_get_number_keyed(interp, $2, $3);
 }
 
-inline op set(out STR, invar PMC, in KEY) :base_core {
+inline op set(out STR, invar PMC, in KEY) {
     $1 = VTABLE_get_string_keyed(interp, $2, $3);
 }
 
-inline op set(out PMC, invar PMC, in KEY) :base_core {
+inline op set(out PMC, invar PMC, in KEY) {
     $1 = VTABLE_get_pmc_keyed(interp, $2, $3);
 }
 
@@ -466 +466 @@
 
 =cut
 
-inline op null(out STR) :base_core {
+inline op null(out STR) {
     $1 = STRINGNULL;
 }
 
-inline op null(out INT) :base_core {
+inline op null(out INT) {
     $1 = 0;
 }
 
-inline op null(out PMC) :base_core {
+inline op null(out PMC) {
     $1 = PMCNULL;
 }
 
-inline op null(out NUM) :base_core {
+inline op null(out NUM) {
     $1 = 0;
 }
 

src/ops/string.ops

@@ -46 +46 @@
 
 =cut
 
-inline op ord(out INT, in STR) :base_core {
+inline op ord(out INT, in STR) {
     $1 = STRING_ord(interp, $2, 0);
 }
 
-inline op ord(out INT, in STR, in INT) :base_core {
+inline op ord(out INT, in STR, in INT) {
     $1 = STRING_ord(interp, $2, $3);
 }
 
@@ -61 +61 @@
 
 =cut
 
-inline op chr(out STR, in INT) :base_core {
+inline op chr(out STR, in INT) {
     STRING * const s = Parrot_str_chr(interp, (UINTVAL)$2);
     $1 = s;
 }
@@ -75 +75 @@
 
 =cut
 
-inline op chopn(out STR, in STR, in INT) :base_core {
+inline op chopn(out STR, in STR, in INT) {
     $1 = Parrot_str_chopn(interp, $2, $3);
 }
 
@@ -96 +96 @@
 
 =cut
 
-inline op concat(invar PMC, invar PMC) :base_core {
+inline op concat(invar PMC, invar PMC) {
     VTABLE_i_concatenate(interp, $1, $2);
 }
 
-inline op concat(invar PMC, in STR) :base_core {
+inline op concat(invar PMC, in STR) {
     VTABLE_i_concatenate_str(interp, $1, $2);
 }
 
@@ -108 +108 @@
     $1 = Parrot_str_concat(interp, $2, $3);
 }
 
-inline op concat(invar PMC, invar PMC, in STR) :base_core {
+inline op concat(invar PMC, invar PMC, in STR) {
     $1 = VTABLE_concatenate_str(interp, $2, $3, $1);
 }
 
-inline op concat(invar PMC, invar PMC, invar PMC) :base_core {
+inline op concat(invar PMC, invar PMC, invar PMC) {
     $1 = VTABLE_concatenate(interp, $2, $3, $1);
 }
 
@@ -137 +137 @@
     $1 = Parrot_str_repeat(interp, $2, (UINTVAL)$3);
 }
 
-inline op repeat(invar PMC, invar PMC, in INT) :base_core {
+inline op repeat(invar PMC, invar PMC, in INT) {
     if ($3 < 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
                 EXCEPTION_NEG_REPEAT,
@@ -147 +147 @@
     $1 = VTABLE_repeat_int(interp, $2, $3, $1);
 }
 
-inline op repeat(invar PMC, invar PMC, invar PMC) :base_core {
+inline op repeat(invar PMC, invar PMC, invar PMC) {
     if (VTABLE_get_integer(interp, $3) < 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
                 EXCEPTION_NEG_REPEAT,
@@ -166 +166 @@
 
 =cut
 
-inline op repeat(invar PMC, in INT) :base_core {
+inline op repeat(invar PMC, in INT) {
     VTABLE_i_repeat_int(interp, $1, $2);
 }
 
-inline op repeat(invar PMC, invar PMC) :base_core {
+inline op repeat(invar PMC, invar PMC) {
     VTABLE_i_repeat(interp, $1, $2);
 }
 
@@ -251 +251 @@
 
 =cut
 
-inline op substr(out STR, in STR, in INT) :base_core {
+inline op substr(out STR, in STR, in INT) {
     const INTVAL len = Parrot_str_byte_length(interp, $2);
     $1 = STRING_substr(interp, $2, $3, len);
 }
 
-inline op substr(out STR, in STR, in INT, in INT) :base_core {
+inline op substr(out STR, in STR, in INT, in INT) {
     $1 = STRING_substr(interp, $2, $3, $4);
 }
 
-inline op substr(out STR, invar PMC, in INT, in INT) :base_core {
+inline op substr(out STR, invar PMC, in INT, in INT) {
     $1 = VTABLE_substr_str(interp, $2, $3, $4);
 }
 
-inline op replace(out STR, in STR, in INT, in INT, in STR) :base_core {
+inline op replace(out STR, in STR, in INT, in INT, in STR) {
     $1 = Parrot_str_replace(interp, $2, $3, $4, $5);
 }
 
@@ -284 +284 @@
 
 =cut
 
-inline op index(out INT, in STR, in STR) :base_core {
+inline op index(out INT, in STR, in STR) {
     $1 = ($2 && $3) ? STRING_index(interp, $2, $3, 0) : -1;
 }
 
-inline op index(out INT, in STR, in STR, in INT) :base_core {
+inline op index(out INT, in STR, in STR, in INT) {
     $1 = ($2 && $3) ? STRING_index(interp, $2, $3, $4) : -1;
 }
 
@@ -308 +308 @@
 
 =cut
 
-inline op sprintf(out STR, in STR, invar PMC) :base_core {
+inline op sprintf(out STR, in STR, invar PMC) {
     $1=Parrot_psprintf(interp, $2, $3);
 }
 
-inline op sprintf(out PMC, invar PMC, invar PMC) :base_core {
+inline op sprintf(out PMC, invar PMC, invar PMC) {
     VTABLE_set_string_native(interp, $1,
         Parrot_psprintf(interp, VTABLE_get_string(interp, $2), $3));
 }
@@ -362 +362 @@
 
 =cut
 
-inline op stringinfo(out INT, in STR, in INT) :base_core {
+inline op stringinfo(out INT, in STR, in INT) {
     if ($2 == NULL)
         $1 = 0;
     else {
@@ -403 +403 @@
 
 =cut
 
-inline op upcase(out STR, in STR) :base_core {
+inline op upcase(out STR, in STR) {
     $1 = Parrot_str_upcase(interp, $2);
 }
 
@@ -413 +413 @@
 
 =cut
 
-inline op downcase(out STR, in STR) :base_core {
+inline op downcase(out STR, in STR) {
     $1 = Parrot_str_downcase(interp, $2);
 }
 
@@ -423 +423 @@
 
 =cut
 
-inline op titlecase(out STR, in STR) :base_core {
+inline op titlecase(out STR, in STR) {
     $1 = Parrot_str_titlecase(interp, $2);
 }
 
@@ -445 +445 @@
 
 =cut
 
-op join(out STR, in STR, invar PMC) :base_core {
+op join(out STR, in STR, invar PMC) {
     $1 = Parrot_str_join(interp, $2, $3);
 }
 
-op split(out PMC, in STR, in STR) :base_core {
+op split(out PMC, in STR, in STR) {
     $1 = Parrot_str_split(interp, $2, $3);
 }
 
@@ -476 +476 @@
 
 =cut
 
-op encoding(out INT, in STR) :base_core {
+op encoding(out INT, in STR) {
     $1 = Parrot_encoding_number_of_str(interp, $2);
 }
 
-op encodingname(out STR, in INT) :base_core {
+op encodingname(out STR, in INT) {
     $1 = Parrot_encoding_name(interp, $2);
 }
 
-op find_encoding(out INT, in STR) :base_core {
+op find_encoding(out INT, in STR) {
     const INTVAL n = Parrot_encoding_number(interp, $2);
     if (n < 0) {
         opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,

src/ops/var.ops

@@ -472 +472 @@
 
 =cut
 
-inline op find_sub_not_null(out PMC, in STR) :base_core {
+inline op find_sub_not_null(out PMC, in STR) {
     opcode_t *dest = expr NEXT();
     PMC *sub = Parrot_ns_find_named_item(interp, $2, dest);