[svn:parrot] r46922 - in trunk: . compilers/opsc compilers/opsc/gen compilers/opsc/gen/Ops compilers/opsc/gen/Ops/Compiler compilers/opsc/gen/Ops/Trans compilers/opsc/src compilers/opsc/src/Ops compilers/opsc/src/Ops/Compiler compilers/opsc/src/Ops/Trans compilers/pct config/auto config/gen/makefiles docs include/parrot include/parrot/oplib lib/Parrot lib/Parrot/Harness lib/Parrot/Ops2c lib/Parrot/Test runtime/parrot/library src/dynoplibs src/ops src/pmc t t/codingstd t/compilers/opsc t/op t/tools/ops2cutils t/tools/ops2cutils/testlib t/tools/ops2pm t/tools/ops2pm/samples tools/build
bacek at svn.parrot.org
bacek at svn.parrot.org
Sun May 23 21:38:32 UTC 2010
Author: bacek
Date: Sun May 23 21:38:28 2010
New Revision: 46922
URL: https://trac.parrot.org/parrot/changeset/46922
Log:
Merge branch 'ops_pct' back to trunk.
Added:
trunk/compilers/opsc/
trunk/compilers/opsc/Defines.mak
trunk/compilers/opsc/Rules.mak
trunk/compilers/opsc/TODO
trunk/compilers/opsc/gen/
trunk/compilers/opsc/gen/Ops/
trunk/compilers/opsc/gen/Ops/Compiler/
trunk/compilers/opsc/gen/Ops/Compiler/IGNOREME
trunk/compilers/opsc/gen/Ops/Trans/
trunk/compilers/opsc/gen/Ops/Trans/IGNOREME
trunk/compilers/opsc/ops2c.nqp
trunk/compilers/opsc/opsc.pir
trunk/compilers/opsc/src/
trunk/compilers/opsc/src/Ops/
trunk/compilers/opsc/src/Ops/Compiler/
trunk/compilers/opsc/src/Ops/Compiler.pm
trunk/compilers/opsc/src/Ops/Compiler/Actions.pm
trunk/compilers/opsc/src/Ops/Compiler/Grammar.pm
trunk/compilers/opsc/src/Ops/Emitter.pm
trunk/compilers/opsc/src/Ops/File.pm
trunk/compilers/opsc/src/Ops/Op.pm
trunk/compilers/opsc/src/Ops/OpLib.pm
trunk/compilers/opsc/src/Ops/Renumberer.pm
trunk/compilers/opsc/src/Ops/Trans/
trunk/compilers/opsc/src/Ops/Trans.pm
trunk/compilers/opsc/src/Ops/Trans/C.pm
trunk/compilers/opsc/src/builtins.pir
trunk/include/parrot/oplib/core_ops.h
trunk/include/parrot/oplib/ops.h
trunk/include/parrot/opsenum.h
trunk/src/ops/core_ops.c
trunk/t/compilers/opsc/
trunk/t/compilers/opsc/01-parse.t
trunk/t/compilers/opsc/02-parse-all-ops.t
trunk/t/compilers/opsc/03-past.t
trunk/t/compilers/opsc/04-op.t
trunk/t/compilers/opsc/05-oplib.t
trunk/t/compilers/opsc/06-opsfile.t
trunk/t/compilers/opsc/07-emitter.t
trunk/t/compilers/opsc/common.pir
Deleted:
trunk/t/op/01-parse_ops.t
trunk/t/tools/ops2cutils/01-new.t
trunk/t/tools/ops2cutils/02-usage.t
trunk/t/tools/ops2cutils/03-print_c_header_file.t
trunk/t/tools/ops2cutils/04-print_c_source_top.t
trunk/t/tools/ops2cutils/05-print_c_source_bottom.t
trunk/t/tools/ops2cutils/06-dynamic.t
trunk/t/tools/ops2cutils/07-make_incdir.t
trunk/t/tools/ops2cutils/08-nolines.t
trunk/t/tools/ops2cutils/09-dynamic_nolines.t
trunk/t/tools/ops2cutils/10-print_c_source_file.t
trunk/t/tools/ops2cutils/testlib/GenerateCore.pm
trunk/t/tools/ops2pm/00-qualify.t
trunk/t/tools/ops2pm/01-ops2pm.t
trunk/t/tools/ops2pm/02-usage.t
trunk/t/tools/ops2pm/03-new.t
trunk/t/tools/ops2pm/04-prepare_ops.t
trunk/t/tools/ops2pm/05-renum_op_map_file.t
trunk/t/tools/ops2pm/06-load_op_map_files.t
trunk/t/tools/ops2pm/07-no_ops_skip.t
trunk/t/tools/ops2pm/08-sort_ops.t
trunk/t/tools/ops2pm/09-prepare_real_ops.t
trunk/t/tools/ops2pm/10-print_module.t
trunk/t/tools/ops2pm/11-print_h.t
trunk/t/tools/ops2pm/samples/bit_ops.original
trunk/t/tools/ops2pm/samples/bit_ops.second
trunk/t/tools/ops2pm/samples/core_ops.original
trunk/t/tools/ops2pm/samples/ops_num.original
trunk/t/tools/ops2pm/samples/pic_ops.original
Modified:
trunk/MANIFEST
trunk/MANIFEST.SKIP
trunk/MANIFEST.generated
trunk/compilers/pct/Rules.mak
trunk/config/auto/extra_nci_thunks.pm
trunk/config/gen/makefiles/root.in
trunk/docs/tests.pod
trunk/lib/Parrot/Distribution.pm
trunk/lib/Parrot/Harness/DefaultTests.pm
trunk/lib/Parrot/Ops2c/Utils.pm
trunk/lib/Parrot/Test/Pod.pm
trunk/runtime/parrot/library/distutils.pir
trunk/src/dynoplibs/Rules.in
trunk/src/ops/var.ops
trunk/src/pmc/nci.pmc
trunk/t/codingstd/linelength.t
trunk/t/codingstd/perlcritic.t
trunk/t/harness.pir
trunk/tools/build/ops2c.pl
Modified: trunk/MANIFEST
==============================================================================
--- trunk/MANIFEST Sun May 23 21:12:16 2010 (r46921)
+++ trunk/MANIFEST Sun May 23 21:38:28 2010 (r46922)
@@ -1,7 +1,7 @@
# ex: set ro:
# $Id$
#
-# generated by tools/dev/mk_manifest_and_skip.pl Sun May 23 08:19:12 2010 UT
+# generated by tools/dev/mk_manifest_and_skip.pl Sun May 23 18:01:00 2010 UT
#
# See below for documentation on the format of this file.
#
@@ -62,6 +62,24 @@
compilers/imcc/symreg.c [imcc]
compilers/imcc/symreg.h [imcc]
compilers/imcc/unit.h [imcc]
+compilers/opsc/Defines.mak [opsc]
+compilers/opsc/Rules.mak [opsc]
+compilers/opsc/TODO [opsc]
+compilers/opsc/gen/Ops/Compiler/IGNOREME [opsc]
+compilers/opsc/gen/Ops/Trans/IGNOREME [opsc]
+compilers/opsc/ops2c.nqp [opsc]
+compilers/opsc/opsc.pir [opsc]
+compilers/opsc/src/Ops/Compiler.pm [opsc]
+compilers/opsc/src/Ops/Compiler/Actions.pm [opsc]
+compilers/opsc/src/Ops/Compiler/Grammar.pm [opsc]
+compilers/opsc/src/Ops/Emitter.pm [opsc]
+compilers/opsc/src/Ops/File.pm [opsc]
+compilers/opsc/src/Ops/Op.pm [opsc]
+compilers/opsc/src/Ops/OpLib.pm [opsc]
+compilers/opsc/src/Ops/Renumberer.pm [opsc]
+compilers/opsc/src/Ops/Trans.pm [opsc]
+compilers/opsc/src/Ops/Trans/C.pm [opsc]
+compilers/opsc/src/builtins.pir [opsc]
compilers/pct/Defines.mak [pct]
compilers/pct/PCT.pir [pct]
compilers/pct/README.pod []doc
@@ -963,6 +981,9 @@
include/parrot/oo_private.h [main]include
include/parrot/op.h [main]include
include/parrot/oplib.h [main]include
+include/parrot/oplib/core_ops.h [main]include
+include/parrot/oplib/ops.h [main]include
+include/parrot/opsenum.h [main]include
include/parrot/packfile.h [main]include
include/parrot/parrot.h [main]include
include/parrot/platform_interface.h [main]include
@@ -1312,6 +1333,7 @@
src/ops/bit.ops []
src/ops/cmp.ops []
src/ops/core.ops []
+src/ops/core_ops.c []
src/ops/debug.ops []
src/ops/experimental.ops []
src/ops/io.ops []
@@ -1521,6 +1543,14 @@
t/compilers/imcc/syn/symbols.t [test]
t/compilers/imcc/syn/tail.t [test]
t/compilers/imcc/syn/veracity.t [test]
+t/compilers/opsc/01-parse.t [test]
+t/compilers/opsc/02-parse-all-ops.t [test]
+t/compilers/opsc/03-past.t [test]
+t/compilers/opsc/04-op.t [test]
+t/compilers/opsc/05-oplib.t [test]
+t/compilers/opsc/06-opsfile.t [test]
+t/compilers/opsc/07-emitter.t [test]
+t/compilers/opsc/common.pir [test]
t/compilers/pct/complete_workflow.t [test]
t/compilers/pct/past.t [test]
t/compilers/pct/pct_hllcompiler.t [test]
@@ -1741,7 +1771,6 @@
t/oo/vtableoverride.t [test]
t/op/00ff-dos.t [test]
t/op/00ff-unix.t [test]
-t/op/01-parse_ops.t [test]
t/op/64bit.t [test]
t/op/annotate-old.t [test]
t/op/annotate.t [test]
@@ -2034,34 +2063,6 @@
t/tools/install/testlib/src/pmc/pmc_object.h [test]
t/tools/install/testlib/tools/build/ops2c.pl [test]
t/tools/install/testlib/vtable.dump [test]
-t/tools/ops2cutils/01-new.t [test]
-t/tools/ops2cutils/02-usage.t [test]
-t/tools/ops2cutils/03-print_c_header_file.t [test]
-t/tools/ops2cutils/04-print_c_source_top.t [test]
-t/tools/ops2cutils/05-print_c_source_bottom.t [test]
-t/tools/ops2cutils/06-dynamic.t [test]
-t/tools/ops2cutils/07-make_incdir.t [test]
-t/tools/ops2cutils/08-nolines.t [test]
-t/tools/ops2cutils/09-dynamic_nolines.t [test]
-t/tools/ops2cutils/10-print_c_source_file.t [test]
-t/tools/ops2cutils/testlib/GenerateCore.pm [test]
-t/tools/ops2pm/00-qualify.t [test]
-t/tools/ops2pm/01-ops2pm.t [test]
-t/tools/ops2pm/02-usage.t [test]
-t/tools/ops2pm/03-new.t [test]
-t/tools/ops2pm/04-prepare_ops.t [test]
-t/tools/ops2pm/05-renum_op_map_file.t [test]
-t/tools/ops2pm/06-load_op_map_files.t [test]
-t/tools/ops2pm/07-no_ops_skip.t [test]
-t/tools/ops2pm/08-sort_ops.t [test]
-t/tools/ops2pm/09-prepare_real_ops.t [test]
-t/tools/ops2pm/10-print_module.t [test]
-t/tools/ops2pm/11-print_h.t [test]
-t/tools/ops2pm/samples/bit_ops.original [test]
-t/tools/ops2pm/samples/bit_ops.second [test]
-t/tools/ops2pm/samples/core_ops.original [test]
-t/tools/ops2pm/samples/ops_num.original [test]
-t/tools/ops2pm/samples/pic_ops.original [test]
t/tools/parrot_debugger.t [test]
t/tools/pbc_disassemble.t [test]
t/tools/pbc_dump.t [test]
Modified: trunk/MANIFEST.SKIP
==============================================================================
--- trunk/MANIFEST.SKIP Sun May 23 21:12:16 2010 (r46921)
+++ trunk/MANIFEST.SKIP Sun May 23 21:38:28 2010 (r46922)
@@ -1,6 +1,6 @@
# ex: set ro:
# $Id$
-# generated by tools/dev/mk_manifest_and_skip.pl Sun May 23 08:10:47 2010 UT
+# generated by tools/dev/mk_manifest_and_skip.pl Sat May 22 04:46:14 2010 UT
#
# This file should contain a transcript of the svn:ignore properties
# of the directories in the Parrot subversion repository. (Needed for
@@ -81,6 +81,14 @@
^miniparrot/
^myconfig$
^myconfig/
+^ops2c$
+^ops2c/
+^ops2c\.c$
+^ops2c\.c/
+^ops2c\.pbc$
+^ops2c\.pbc/
+^ops2c\.pir$
+^ops2c\.pir/
^parrot$
^parrot/
^parrot-nqp$
@@ -188,6 +196,22 @@
^compilers/imcc/imcparser\.h/
^compilers/imcc/imcparser\.output$
^compilers/imcc/imcparser\.output/
+# generated from svn:ignore of 'compilers/opsc/'
+^compilers/opsc/opsc\.pbc$
+^compilers/opsc/opsc\.pbc/
+# generated from svn:ignore of 'compilers/opsc/gen/Ops/'
+^compilers/opsc/gen/Ops/ $
+^compilers/opsc/gen/Ops/ /
+^compilers/opsc/gen/Ops/.*\.pir$
+^compilers/opsc/gen/Ops/.*\.pir/
+# generated from svn:ignore of 'compilers/opsc/gen/Ops/Compiler/'
+^compilers/opsc/gen/Ops/Compiler/Actions\.pir$
+^compilers/opsc/gen/Ops/Compiler/Actions\.pir/
+^compilers/opsc/gen/Ops/Compiler/Grammar\.pir$
+^compilers/opsc/gen/Ops/Compiler/Grammar\.pir/
+# generated from svn:ignore of 'compilers/opsc/gen/Ops/Trans/'
+^compilers/opsc/gen/Ops/Trans/C\.pir$
+^compilers/opsc/gen/Ops/Trans/C\.pir/
# generated from svn:ignore of 'compilers/pct/src/PAST/'
^compilers/pct/src/PAST/.*\.pbc$
^compilers/pct/src/PAST/.*\.pbc/
@@ -428,6 +452,12 @@
# generated from svn:ignore of 'ext/Parrot-Embed/t/'
^ext/Parrot-Embed/t/.*\.pbc$
^ext/Parrot-Embed/t/.*\.pbc/
+# generated from svn:ignore of 'ext/nqp-rx/src/gen/'
+^ext/nqp-rx/src/gen/settings\.pir$
+^ext/nqp-rx/src/gen/settings\.pir/
+# generated from svn:ignore of 'ext/nqp-rx/src/stage0/'
+^ext/nqp-rx/src/stage0/nqp-setting\.pir$
+^ext/nqp-rx/src/stage0/nqp-setting\.pir/
# generated from svn:ignore of 'include/parrot/'
^include/parrot/.*\.tmp$
^include/parrot/.*\.tmp/
Modified: trunk/MANIFEST.generated
==============================================================================
--- trunk/MANIFEST.generated Sun May 23 21:12:16 2010 (r46921)
+++ trunk/MANIFEST.generated Sun May 23 21:38:28 2010 (r46922)
@@ -125,6 +125,8 @@
include/pmc/pmc_undef.h [devel]include
include/pmc/pmc_unmanagedstruct.h [devel]include
install_config.fpmc [main]lib
+installable_ops2c [main]bin
+installable_ops2c.exe [main]bin
installable_parrot [main]bin
installable_parrot-nqp [main]bin
installable_parrot-nqp.exe [main]bin
@@ -145,7 +147,6 @@
installable_pbc_to_exe [main]bin
installable_pbc_to_exe.exe [main]bin
lib/Parrot/Config/Generated.pm [devel]lib
-lib/Parrot/OpLib/core.pm [devel]lib
lib/Parrot/PMC.pm [devel]lib
lib/Parrot/Pmc2c/PCCMETHOD_BITS.pm [devel]lib
libparrot.dll [main]bin
@@ -272,7 +273,6 @@
runtime/parrot/library/TAP/Formatter.pbc [main]
runtime/parrot/library/TAP/Harness.pbc [main]
runtime/parrot/library/TAP/Parser.pbc [main]
-runtime/parrot/library/TGE.pbc [tge]
runtime/parrot/library/Tcl/Glob.pbc [main]
runtime/parrot/library/TclLibrary.pbc [main]
runtime/parrot/library/Test/Builder.pbc [main]
@@ -294,6 +294,7 @@
runtime/parrot/library/ncurses.pbc [main]
runtime/parrot/library/nqp-rx.pbc [nqp]
runtime/parrot/library/nqp-setting.pbc [nqp]
+runtime/parrot/library/opsc.pbc [main]
runtime/parrot/library/osutils.pbc [main]
runtime/parrot/library/parrotlib.pbc [main]
runtime/parrot/library/pcore.pbc [main]
Added: trunk/compilers/opsc/Defines.mak
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/Defines.mak Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,24 @@
+OPSC_DIR = compilers/opsc
+
+OPSC_SOURCES_GENERATED = \
+ $(OPSC_DIR)/gen/Ops/Compiler.pir \
+ $(OPSC_DIR)/gen/Ops/Compiler/Actions.pir \
+ $(OPSC_DIR)/gen/Ops/Compiler/Grammar.pir \
+ $(OPSC_DIR)/gen/Ops/Emitter.pir \
+ $(OPSC_DIR)/gen/Ops/Trans.pir \
+ $(OPSC_DIR)/gen/Ops/Trans/C.pir \
+ $(OPSC_DIR)/gen/Ops/Op.pir \
+ $(OPSC_DIR)/gen/Ops/OpLib.pir \
+ $(OPSC_DIR)/gen/Ops/File.pir \
+ $(OPSC_DIR)/gen/Ops/Renumberer.pir
+
+OPSC_SOURCES = \
+ $(OPSC_DIR)/opsc.pir \
+ $(OPSC_DIR)/src/builtins.pir \
+ $(OPSC_SOURCES_GENERATED)
+
+OPSC_CLEANUPS = \
+ $(OPSC_DIR)/opsc.pbc \
+ $(LIBRARY_DIR)/opsc.pbc \
+ $(OPSC_SOURCES_GENERATED)
+
Added: trunk/compilers/opsc/Rules.mak
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/Rules.mak Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,50 @@
+$(LIBRARY_DIR)/opsc.pbc: $(NQP_RX) $(OPSC_SOURCES) $(NQPRX_LIB_SETTING)
+ $(PARROT) -o $(LIBRARY_DIR)/opsc.pbc $(OPSC_DIR)/opsc.pir
+
+$(OPSC_DIR)/gen/Ops/Compiler.pir: $(OPSC_DIR)/src/Ops/Compiler.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Compiler.pm
+
+$(OPSC_DIR)/gen/Ops/Compiler/Actions.pir: $(OPSC_DIR)/src/Ops/Compiler/Actions.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Compiler/Actions.pm
+
+$(OPSC_DIR)/gen/Ops/Compiler/Grammar.pir: $(OPSC_DIR)/src/Ops/Compiler/Grammar.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Compiler/Grammar.pm
+
+$(OPSC_DIR)/gen/Ops/Emitter.pir: $(OPSC_DIR)/src/Ops/Emitter.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Emitter.pm
+
+$(OPSC_DIR)/gen/Ops/File.pir: $(OPSC_DIR)/src/Ops/File.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/File.pm
+
+$(OPSC_DIR)/gen/Ops/Op.pir: $(OPSC_DIR)/src/Ops/Op.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Op.pm
+
+$(OPSC_DIR)/gen/Ops/OpLib.pir: $(OPSC_DIR)/src/Ops/OpLib.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/OpLib.pm
+
+$(OPSC_DIR)/gen/Ops/Trans.pir: $(OPSC_DIR)/src/Ops/Trans.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Trans.pm
+
+$(OPSC_DIR)/gen/Ops/Trans/C.pir: $(OPSC_DIR)/src/Ops/Trans/C.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Trans/C.pm
+
+$(OPSC_DIR)/gen/Ops/Renumberer.pir: $(OPSC_DIR)/src/Ops/Renumberer.pm $(NQP_RX)
+ $(NQP_RX) --target=pir --output=$@ $(OPSC_DIR)/src/Ops/Renumberer.pm
+
+# Target to force rebuild opsc from main Makefile
+$(OPSC_DIR)/ops2c.nqp: $(LIBRARY_DIR)/opsc.pbc
+
+$(OPS2C): $(OPSC_DIR)/ops2c.nqp $(LIBRARY_DIR)/opsc.pbc $(NQP_RX) $(PBC_TO_EXE)
+ $(NQP_RX) --target=pir $(OPSC_DIR)/ops2c.nqp >ops2c.pir
+ $(PARROT) -o ops2c.pbc ops2c.pir
+ $(PBC_TO_EXE) ops2c.pbc
+
+$(INSTALLABLEOPS2C): $(OPS2C) src/install_config$(O)
+ $(PBC_TO_EXE) ops2c.pbc --install
+
+opsc: $(LIBRARY_DIR)/opsc.pbc
+
+# Local variables:
+# mode: makefile
+# End:
+# vim: ft=make:
Added: trunk/compilers/opsc/TODO
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/TODO Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,14 @@
+Simple todo.
+
+Required for initial self-hosting:
+
+ * NONE! We are selfhosted now!
+
+Required for full implementation:
+ * Handling #line directives.
+ * A LOT OF DOCUMENTATION.
+ * Add tests for Trans::C independent from 06-emitter.t
+ * Add tests for dynamic mode of Emitter.
+
+Nice to have:
+ * Profiling and performance tuning of ops parsing (we need pmichaud).
Added: trunk/compilers/opsc/gen/Ops/Compiler/IGNOREME
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/gen/Ops/Compiler/IGNOREME Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1 @@
+I just dummy file. Please ignore me. Please...
Added: trunk/compilers/opsc/gen/Ops/Trans/IGNOREME
==============================================================================
Added: trunk/compilers/opsc/ops2c.nqp
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/ops2c.nqp Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,113 @@
+#! ./parrot-nqp
+# $Id$
+
+pir::load_bytecode("opsc.pbc");
+pir::load_bytecode("Getopt/Obj.pbc");
+
+my $core := 0;
+my @files;
+my $emit_lines := 1;
+
+my $getopts := Q:PIR{ %r = new ['Getopt';'Obj'] };
+
+$getopts.notOptStop();
+my $arg := $getopts.add();
+$arg.long('core');
+$arg.short('c');
+
+$arg := $getopts.add();
+$arg.long('dynamic');
+$arg.short('d');
+$arg.type('String');
+
+$arg := $getopts.add();
+$arg.long('debug');
+$arg.short('g');
+
+$arg := $getopts.add();
+$arg.long('no-lines');
+$arg.short('n');
+
+$arg := $getopts.add();
+$arg.long('help');
+$arg.short('h');
+
+$arg := $getopts.add();
+$arg.long('force-regen');
+$arg.short('f');
+
+my $opts := $getopts.get_options(pir::getinterp__p()[2]);
+
+if $opts<core> {
+ @files := <
+ src/ops/core.ops
+ src/ops/bit.ops
+ src/ops/cmp.ops
+ src/ops/debug.ops
+ src/ops/io.ops
+ src/ops/math.ops
+ src/ops/object.ops
+ src/ops/pmc.ops
+ src/ops/set.ops
+ src/ops/string.ops
+ src/ops/sys.ops
+ src/ops/var.ops
+ src/ops/experimental.ops
+ >;
+ $core := 1;
+}
+elsif $opts<dynamic> {
+ $core := 0;
+ @files.push( $opts<dynamic>);
+}
+elsif (+$opts == 0 || $opts<help>) {
+ say("This is ops2c, part of Parrot build infrastructure.
+usage:
+ops2c --core
+ops2c --dynamic path/to/dynops.ops");
+ pir::exit(0);
+}
+
+my $force_regen := ?$opts<force-regen>;
+
+if ($opts<no-lines>) {
+ #TODO: figure out how to generate line numbers
+ # $emit_lines is currently ignored
+ $emit_lines := 0;
+}
+
+my $trans := Ops::Trans::C.new();
+my $start_time := pir::time__N();
+my $debug := ?$opts<debug>;
+my $f;
+my $renum;
+
+if $core {
+ my $lib := Ops::OpLib.new(
+ :num_file('src/ops/ops.num'),
+ :skip_file('src/ops/ops.skip'),
+ );
+ $f := Ops::File.new(|@files, :oplib($lib), :core(1));
+}
+else {
+ $f := Ops::File.new(|@files, :core(0));
+}
+
+pir::sprintf(my $time, "%.3f", [pir::time__N() - $start_time] );
+#say("# Ops parsed in $time seconds.");
+
+my $emitter := Ops::Emitter.new(
+ :ops_file($f), :trans($trans),
+ :script('ops2c.nqp'), :file(@files[0]),
+ :flags( hash( core => $core ) ),
+);
+
+unless $debug {
+ if $force_regen || $f<renum>.need_regeneration {
+ $emitter.print_ops_num_files();
+ }
+ $emitter.print_c_header_files();
+ $emitter.print_c_source_file();
+}
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/opsc.pir
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/opsc.pir Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,25 @@
+#! parrot
+# Copyright (C) 2009-2010, Parrot Foundation.
+# $Id$
+
+.namespace [ 'Ops';'Compiler' ]
+
+.include 'compilers/opsc/src/builtins.pir'
+.include 'compilers/opsc/gen/Ops/Compiler/Grammar.pir'
+.include 'compilers/opsc/gen/Ops/Compiler/Actions.pir'
+.include 'compilers/opsc/gen/Ops/Compiler.pir'
+
+.include 'compilers/opsc/gen/Ops/Emitter.pir'
+.include 'compilers/opsc/gen/Ops/Trans.pir'
+.include 'compilers/opsc/gen/Ops/Trans/C.pir'
+
+.include 'compilers/opsc/gen/Ops/Op.pir'
+.include 'compilers/opsc/gen/Ops/OpLib.pir'
+.include 'compilers/opsc/gen/Ops/File.pir'
+.include 'compilers/opsc/gen/Ops/Renumberer.pir'
+
+# Local Variables:
+# mode: pir
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=pir:
Added: trunk/compilers/opsc/src/Ops/Compiler.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Compiler.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,17 @@
+#! nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+class Ops::Compiler is HLL::Compiler;
+
+INIT {
+ Ops::Compiler.language('Ops');
+ Ops::Compiler.parsegrammar(Ops::Compiler::Grammar);
+ Ops::Compiler.parseactions(Ops::Compiler::Actions);
+}
+
+method set_oplib($oplib) {
+ $Ops::Compiler::Actions::OPLIB := $oplib;
+}
+
+# vim: ft=perl6 expandtab shiftwidth=4:
Added: trunk/compilers/opsc/src/Ops/Compiler/Actions.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Compiler/Actions.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,413 @@
+#! nqp
+# Copyright (C) 2009-2010, Parrot Foundation.
+# $Id$
+
+class Ops::Compiler::Actions is HLL::Actions;
+
+our $OPLIB;
+
+INIT {
+ pir::load_bytecode("nqp-setting.pbc");
+ $OPLIB := 0;
+}
+
+method TOP($/) {
+ make $<body>.ast;
+}
+
+method body($/) {
+ my $past := PAST::Stmts.new(
+ :node($/)
+ );
+
+ $past<preamble> := PAST::Stmts.new(
+ :node($/)
+ );
+ $past<ops> := PAST::Stmts.new(
+ :node($/)
+ );
+
+ for $<preamble> {
+ $past<preamble>.push($_<preamble_guts>);
+ }
+
+ for $<op> {
+ my $ops := $_.ast;
+ my $op_skip_table;
+ if $OPLIB {
+ $op_skip_table := $OPLIB.op_skip_table;
+ }
+ for @($ops) -> $op {
+ if $OPLIB && !$op_skip_table.exists($op.full_name) || !$OPLIB {
+ $past<ops>.push($op);
+ }
+ }
+ }
+
+ make $past;
+}
+
+method preamble($/) {
+ make PAST::Op.new(
+ :node($/),
+ :pasttype('preamble'),
+ ~$<preamble_guts>
+ );
+}
+
+method op($/) {
+
+ # Handling flags.
+ my %flags := hash();
+ for $<op_flag> {
+ %flags{~$_<identifier>} := 1;
+ }
+
+ my @args := list();
+ if ($<op_params>) {
+ @args := @($<op_params>[0].ast);
+ }
+
+ my @norm_args := normalize_args(@args);
+ # We have to clone @norm_args. Otherwise it will be destroyed...
+ my @variants := expand_args(pir::clone__PP(@norm_args));
+
+ my $op := Ops::Op.new(
+ :name(~$<op_name>),
+ );
+
+ # Flatten PAST::Stmts into Op.
+ for @($<op_body>.ast) {
+ $op.push($_);
+ }
+
+ for $<op_body>.ast<jump> {
+ $op.add_jump($_);
+ }
+ if ~$<op_name> eq 'runinterp' {
+ $op.add_jump('PARROT_JUMP_RELATIVE');
+ }
+ $op<flags> := %flags;
+ $op<args> := @args;
+ $op<type> := ~$<op_type>;
+ $op<normalized_args> := @norm_args;
+
+ if !%flags<flow> {
+ my $goto_next := PAST::Op.new(
+ :pasttype('call'),
+ :name('goto_offset'),
+ PAST::Op.new(
+ :pasttype<call>,
+ :name<OPSIZE>,
+ )
+ );
+
+ my $nl := "\n";
+ $op.push(PAST::Op.new(
+ :pasttype<inline>,
+ :inline($nl)
+ ));
+ $op.push($goto_next);
+ $op.push(PAST::Op.new(
+ :pasttype<inline>,
+ :inline<;>
+ ));
+ }
+
+ my $past := PAST::Stmts.new(
+ :node($/)
+ );
+
+ if @variants {
+ for @variants {
+ my $new_op := pir::clone__PP($op);
+ $new_op<arg_types> := $_;
+ $past.push($new_op);
+ }
+ }
+ else {
+ $past.push($op);
+ }
+
+ make $past;
+}
+
+# Normalize args
+# For each arg produce LoL of all available variants
+# E.g. "in" will produce "i" and "ic" variants
+#
+# type one of <i p s n>
+# direction one of <i o io>
+# is_label one of <0 1>
+
+sub normalize_args(@args) {
+ my @result;
+ for @args -> $arg {
+ my $res := PAST::Var.new(
+ :isdecl(1)
+ );
+
+ if $arg<type> eq 'LABEL' {
+ $res<type> := 'i';
+ $res<is_label> := 1;
+ }
+ else {
+ $res<is_label> := 0;
+ }
+
+ if $arg<type> eq 'INTKEY' {
+ $res<type> := 'ki';
+ }
+ elsif $arg<type> ne 'LABEL' {
+ $res<type> := lc(substr($arg<type>, 0, 1));
+ }
+
+ my $use := $arg<direction>;
+
+ if $use eq 'in' {
+ $res<variant> := $res<type> ~ "c";
+ $res<direction> := 'i';
+ }
+ elsif $use eq 'invar' {
+ $res<direction> := 'i';
+ }
+ elsif $use eq 'inconst' {
+ $res<type> := $res<type> ~ "c";
+ $res<direction> := 'i';
+ }
+ elsif $use eq 'inout' {
+ $res<direction> := 'io';
+ }
+ else {
+ $res<direction> := 'o';
+ }
+
+ @result.push($res);
+ }
+ @result;
+}
+
+=begin
+
+=item C<expand_args(@args)>
+
+Given an argument list, returns a list of all the possible argument
+combinations.
+
+=end
+sub expand_args(@args) {
+
+ return list() unless @args;
+
+ my $arg := @args.shift;
+
+ my @var := list($arg<type>);
+ if $arg<variant> {
+ @var.push($arg<variant>);
+ }
+
+ my @list := expand_args(@args);
+ unless + at list {
+ return @var;
+ }
+
+ my @results;
+ for @list -> $l {
+ for @var -> $v {
+ # NQP can't handle it automagically. So wrap $l into list.
+ my @l := pir::does__IPS($l, 'array') ?? $l !! list($l);
+ @results.push(list($v, |@l));
+ }
+ }
+
+ @results;
+}
+
+
+method op_params($/) {
+ my $past := PAST::Stmts.new(
+ :node($/)
+ );
+
+ for $<op_param> {
+ $past.push($_.ast);
+ }
+
+ make $past;
+}
+
+method op_param($/) {
+ my $past := PAST::Var.new(
+ :node($/),
+ :isdecl(1)
+ );
+
+ # We have to store 2 "types". Just set 2 properties on Var for now
+ $past<direction> := ~$<op_param_direction>;
+ $past<type> := ~$<op_param_type>;
+
+ make $past;
+}
+
+method op_body($/) {
+ my $past := PAST::Stmts.new(
+ :node($/),
+ );
+ $past<jump> := list();
+ my $prev_words := '';
+ for $<body_word> {
+ if $prev_words && $_<word> {
+ $prev_words := $prev_words ~ ~$_<word>;
+ }
+ elsif $_<word> {
+ $prev_words := ~$_<word>;
+ }
+ else {
+ $past.push(PAST::Op.new(
+ :pasttype('inline'),
+ :inline($prev_words),
+ ));
+ $prev_words := '';
+
+ if $_<macro_param> {
+ $past.push($_<macro_param>.ast);
+ }
+ elsif $_<op_macro> {
+ $past.push($_<op_macro>.ast);
+ for $_<op_macro>.ast<jump> {
+ $past<jump>.push($_);
+ }
+ }
+ }
+ }
+ if $prev_words {
+ $past.push(PAST::Op.new(
+ :pasttype('inline'),
+ :inline($prev_words)
+ ));
+ }
+ make $past;
+}
+
+method macro_param($/) {
+ make PAST::Var.new(
+ :name(~$<num>),
+ :node($/),
+ );
+}
+
+method body_word($/) {
+ #say('# body_word: '~ ~$<word>);
+ my $past;
+ if $<word> {
+ $past := PAST::Op.new(
+ :pasttype('inline'),
+ :inline(~$<word>)
+ );
+ }
+ elsif $<macro_param> {
+ $past := $<macro_param>.ast;
+ }
+ elsif $<op_macro> {
+ $past := $<op_macro>.ast;
+ }
+ else {
+ die('horribly');
+ }
+ #_dumper($past);
+ make $past;
+}
+
+method op_macro($/) {
+ #say('# op_macro');
+ # Generate set of calls to Trans:
+ # goto NEXT() -> goto_offset(opsize())
+ # goto OFFSET($addr) -> goto_offset($addr)
+ # goto ADDRESS($addr) -> goto_address($addr)
+ # expr NEXT() -> expr_offset(opsize())
+ # expr OFFSET($addr) -> expr_offset($addr)
+ # expr ADDRERR($addr) -> expr_address($addr)
+ # restart NEXT() -> restart_offset(opsize()); goto_address(0)
+ # restart OFFSET() -> restart_offset($addr); goto_offset($addr)
+ # XXX In trunk "restart ADDRESS" equivalent of "goto ADDRESS".
+ # restart ADDRESS() -> restart_address($addr); goto_address($addr)
+
+ my $macro_type := ~$<macro_type>;
+ my $macro_dest := ~$<macro_destination>;
+ my $is_next := $macro_dest eq 'NEXT';
+ my $macro_name := $macro_type ~ '_' ~ lc($is_next ?? 'offset' !! $macro_dest);
+
+ my $past := PAST::Stmts.new;
+
+ my $macro := PAST::Op.new(
+ :pasttype('call'),
+ :name($macro_name),
+ );
+ $past.push($macro);
+
+ $past<jump> := list();
+
+ if $macro_type ne 'expr' && $macro_dest eq 'OFFSET' {
+ $past<jump>.push('PARROT_JUMP_RELATIVE');
+ }
+
+ if $macro_type eq 'expr' || $macro_type eq 'goto' {
+ if $is_next {
+ $macro.push(PAST::Op.new(
+ :pasttype<call>,
+ :name<OPSIZE>,
+ ));
+ }
+ else {
+ process_op_macro_body_word($/, $macro);
+ }
+ }
+ elsif $macro_type eq 'restart' {
+ if $is_next {
+ $macro.push(PAST::Op.new(
+ :pasttype<call>,
+ :name<OPSIZE>,
+ ));
+ }
+ else {
+ process_op_macro_body_word($/, $macro);
+ }
+
+ $macro := PAST::Op.new(
+ :pasttype<call>,
+ :name<goto_address>,
+ );
+ if $is_next {
+ $macro.push(PAST::Op.new(
+ :pasttype<inline>,
+ :inline<0>,
+ ));
+ }
+ else {
+ process_op_macro_body_word($/, $macro);
+ }
+ $past.push($macro);
+ }
+ else {
+ pir::die("Horribly");
+ }
+
+ make $past;
+}
+
+sub process_op_macro_body_word($/, $macro) {
+ #_dumper($<body_word>);
+ if $<body_word> {
+ for $<body_word> {
+ #say(' word ' ~ $_);
+ my $bit := $_.ast;
+ $macro.push($_.ast) if defined($bit);
+ }
+ }
+}
+
+# Local Variables:
+# mode: perl6
+# fill-column: 100
+# End:
+# vim: expandtab ft=perl6 shiftwidth=4:
Added: trunk/compilers/opsc/src/Ops/Compiler/Grammar.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Compiler/Grammar.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,147 @@
+#! nqp
+# Copyright (C) 2009-2010, Parrot Foundation.
+# $Id$
+
+INIT { pir::load_bytecode('HLL.pbc'); }
+
+grammar Ops::Compiler::Grammar is HLL::Grammar;
+
+rule TOP {
+ <body>
+ [ $ || <panic: 'Syntax error'> ]
+ {*}
+}
+
+rule body {
+ [ <preamble> | <op> ]* {*}
+}
+
+token preamble {
+ <begin_preamble>
+ <preamble_guts>
+ <end_preamble> {*}
+}
+
+regex preamble_guts {
+ .*? <?end_preamble>
+}
+
+token begin_preamble {
+ ^^'BEGIN_OPS_PREAMBLE'
+}
+
+token end_preamble {
+ ^^'END_OPS_PREAMBLE'
+}
+
+rule op {
+ <op_type>? 'op' <op_name=identifier> '('
+ [ <op_params>? || <panic: "Fail to parse params"> ]
+ ')' <op_flag>*
+ [ <op_body> || <panic: "Fail to parse op body"> ]
+ {*}
+}
+
+token op_type {
+ [ 'inline' | 'function' ]
+}
+
+rule op_params {
+ <op_param> [ ',' <op_param> ]*
+ {*}
+}
+
+rule op_param {
+ <op_param_direction> <op_param_type>
+ {*}
+}
+
+token op_param_direction {
+ # Order is crucial. PGE doesn't support LTM yet.
+ [
+ | 'inout'
+ | 'inconst'
+ | 'invar'
+ | 'in'
+ | 'out'
+ ]
+}
+
+token op_param_type {
+ # Order is crucial. PGE doesn't support LTM yet.
+ [
+ | 'INTKEY'
+ | 'INT'
+ | 'NUM'
+ | 'STR'
+ | 'PMC'
+ | 'KEY'
+ | 'LABEL'
+ ]
+}
+
+rule op_flag {
+ ':' <identifier>
+}
+
+# OpBody starts with '{' and ends with single '}' on line.
+regex op_body {
+ '{'
+ <body_word>*?
+ ^^ '}'
+}
+
+#Process op body by breaking it into "words" consisting entirely of whitespace,
+#alnums or a single punctuation, then checking for interesting macros (e.g $1
+#or goto NEXT() ) in the midst of the words.
+regex body_word {
+ [
+ | <macro_param>
+ | <op_macro>
+ | $<word>=[<alnum>+|<punct>|<space>+]
+ ]
+ {*}
+}
+
+token macro_param {
+ '$' $<num>=[<digit>+]
+ {*}
+}
+
+regex op_macro {
+ <macro_type> <space>* <macro_destination> <space>* '(' <space>* <body_word>*? ')'
+ {*}
+}
+
+token macro_type {
+ [
+ | 'goto'
+ | 'expr'
+ | 'restart'
+ ]
+}
+
+token macro_destination {
+ [
+ | 'OFFSET'
+ | 'ADDRESS'
+ | 'NEXT'
+ ]
+}
+
+token identifier {
+ <.ident>
+}
+
+# ws handles whitespace, pod and perl and C comments
+token ws {
+ [
+ | \s+
+ | '#' \N*
+ | ^^ '=' .*? \n '=cut'
+ | '/*' .*? '*/'
+ ]*
+}
+
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/src/Ops/Emitter.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Emitter.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,444 @@
+#! nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+class Ops::Emitter is Hash;
+
+=begin
+
+Emitter.
+
+=end
+
+method new(:$ops_file!, :$trans!, :$script!, :$file, :%flags!) {
+ self<ops_file> := $ops_file;
+ self<trans> := $trans;
+ self<script> := $script;
+ self<file> := $file;
+ self<flags> := %flags;
+
+ # Preparing various bits.
+ my $suffix := $trans.suffix();
+ my $base := 'core';
+
+ if !%flags<core> {
+ $base := subst( $file, /.ops$$/, '');
+ $base := subst( $base, /.*\//, '');
+ }
+
+ my $base_ops_stub := $base ~ '_ops' ~ $suffix;
+ my $base_ops_h := $base_ops_stub ~ '.h';
+
+ self<base> := $base;
+ self<suffix> := $suffix;
+ self<bs> := $base ~ $suffix ~ '_';
+
+ if %flags<core> {
+ self<include> := "parrot/oplib/$base_ops_h";
+ self<func_header> := (~%flags<dir>) ~ "include/" ~ self<include>;
+ self<enum_header> := (~%flags<dir>) ~ "include/parrot/oplib/ops.h";
+ self<source> := (~%flags<dir>) ~ "src/ops/$base_ops_stub.c";
+ }
+ else {
+ my $dynops_dir := subst( $file, /\w+\.ops$$/, '');
+ self<include> := $base ~ "_ops.h";
+ self<func_header> := $dynops_dir ~ self<include>;
+ self<source> := $dynops_dir ~ $base ~ "_ops.c";
+ }
+
+ self<sym_export> := %flags<core>
+ ?? ''
+ !! 'PARROT_DYNEXT_EXPORT';
+
+ self<init_func> := join('_',
+ 'Parrot', 'DynOp', $base ~ $suffix, |$ops_file.version );
+
+ # Prepare ops
+ $trans.prepare_ops(self, $ops_file);
+
+ self;
+};
+
+method ops_file() { self<ops_file> };
+method trans() { self<trans> };
+method script() { self<script> };
+method file() { self<file> };
+method flags() { self<flags> };
+method sym_export() { self<sym_export> };
+method init_func() { self<init_func> };
+
+method base() { self<base> };
+method suffix() { self<suffix> };
+method bs() { self<bs> };
+
+method print_c_header_files() {
+
+ my $fh := pir::open__PSs(self<func_header>, 'w')
+ || die("Can't open "~ self<func_header>);
+ self.emit_c_op_func_header($fh);
+ $fh.close();
+
+ if self.ops_file<core> {
+ $fh := pir::open__PSs(self<enum_header>, 'w')
+ || die("Can't open "~ self<enum_header>);
+ self.emit_c_op_enum_header($fh);
+ $fh.close();
+ }
+}
+
+method emit_c_op_func_header($fh) {
+
+ self._emit_guard_prefix($fh, self<func_header>);
+
+ self._emit_preamble($fh);
+
+ self._emit_includes($fh);
+
+ # Emit runcore specific part.
+ self.trans.emit_c_op_funcs_header_part($fh);
+
+ self._emit_guard_suffix($fh, self<func_header>);
+
+ self._emit_coda($fh);
+}
+
+method emit_c_op_enum_header($fh) {
+
+ self._emit_guard_prefix($fh, self<enum_header>);
+
+ self._emit_preamble($fh);
+
+ self._emit_c_op_enum_header_part($fh);
+
+ self._emit_guard_suffix($fh, self<enum_header>);
+
+ self._emit_coda($fh);
+}
+
+method print_ops_num_files() {
+
+ my $file := ~self<dir> ~ ~self<ops_file>.oplib.num_file;
+ my $fh := pir::open__pss($file, 'w')
+ || die("Can't open $file for writing: " ~ ~pir::err__s());
+ self.emit_ops_num_file($fh);
+ $fh.close();
+
+ $file := ~self<dir> ~ "include/parrot/opsenum.h";
+ $fh := pir::open__pss($file, 'w')
+ || die("Can't open $file for writing: " ~ ~pir::err__s());
+ self.emit_c_opsenum_header($fh, $file);
+ $fh.close();
+}
+
+method emit_ops_num_file($fh) {
+
+ if !self.exists('max_fixed_op_num') {
+ self._prepare_ops_num();
+ }
+
+ $fh.print( join('', |self<ops_num_start>) );
+ my $max_op_num := self<max_fixed_op_num> + 0; #+ 0 to force cloning
+
+ for self.ops_file.ops -> $op {
+ if self<numbered_ops>.exists( $op.full_name ) {
+
+ $max_op_num++;
+
+ my $space := pir::repeat__SsI(' ',
+ 35 - pir::length__Is($op.full_name) - pir::length__Is(~$max_op_num));
+ $fh.print($op.full_name ~ $space ~ $max_op_num ~ "\n");
+ }
+ }
+
+}
+
+method emit_c_opsenum_header($fh, $file) {
+
+ if !self.exists('max_fixed_op_num') {
+ self._prepare_ops_num();
+ }
+
+ self._emit_guard_prefix($fh, $file);
+
+ self._emit_preamble($fh);
+
+ self.emit_opsenum_h_body($fh);
+
+ self._emit_guard_suffix($fh, $file);
+
+ self._emit_coda($fh);
+}
+
+method emit_opsenum_h_body($fh) {
+
+ $fh.print("enum OPS_ENUM \{\n");
+
+ my $max_op_num := self<max_fixed_op_num> + 0;
+ for self.ops_file.ops -> $op {
+ if self<numbered_ops>.exists( $op.full_name ) {
+ $max_op_num++;
+
+ my $space := pir::repeat__SsI(' ', 30 - pir::length__Is($op.full_name));
+ $fh.print(" enum_ops_" ~ $op.full_name ~ $space ~ "=");
+ $space := pir::repeat__SsI(' ', 5 - pir::length__Is(~$max_op_num));
+ $fh.print($space ~ $max_op_num ~ ",\n");
+ }
+ }
+
+ $fh.print("};\n");
+}
+
+method _prepare_ops_num() {
+
+ #grab all ops in ops.num
+ self<numbered_ops> := hash();
+ my $found_dynamic := 0;
+ self<max_fixed_op_num> := 0;
+ self<ops_num_start> := list();
+
+ #record which ones have fixed numbers and which just need to be somewhere in ops.num
+ for self.ops_file.oplib.num_file_lines -> $line {
+
+ #copy all lines through ###DYNAMIC### into the new ops.num verbatim
+ unless $found_dynamic {
+ self<ops_num_start>.push(~$line);
+ }
+
+ if $line<op> {
+ if $found_dynamic {
+ self<numbered_ops>{ $line<op><name> } := 1;
+ #say("# added '"~$line<op><name> ~" to numered ops");
+ }
+ else {
+ #don't need to keep track of fixed ops
+ self<max_fixed_op_num> := +$line<op><number>;
+ #say("# added '"~$line<op><name> ~" to fixed ops");
+ }
+ }
+ elsif $line<dynamic> {
+ $found_dynamic := 1;
+ }
+ }
+}
+
+method print_c_source_file() {
+ # Build file in memeory
+ my $fh := pir::new__Ps('StringHandle');
+ $fh.open('dummy.c', 'w');
+ self.emit_c_source_file($fh);
+ $fh.close();
+
+ # ... and write it to disk
+ my $final := pir::open__PSs(self<source>, 'w') || die("Can't open filehandle");
+ $final.print($fh.readall());
+ $final.close();
+ return self<source>;
+}
+
+method emit_c_source_file($fh) {
+ self._emit_source_preamble($fh);
+
+ self.trans.emit_source_part(self, $fh);
+
+ self._emit_op_lib_descriptor($fh);
+
+ self.trans.emit_op_lookup(self, $fh);
+
+ self._emit_init_func($fh);
+ self._emit_dymanic_lib_load($fh);
+ self._emit_coda($fh);
+}
+
+method _emit_c_op_enum_header_part($fh) {
+ my $sb := pir::new__Ps('StringBuilder');
+ my $last_op_code := +self.ops_file.ops - 1;
+ for self.ops_file.ops -> $op {
+ $sb.append_format(" PARROT_OP_%0%1 %2 /* %3 */\n",
+ $op.full_name,
+ ($op.code == $last_op_code ?? ' ' !! ','),
+ pir::repeat__SsI(' ', 30 - pir::length__Is($op.full_name)),
+ $op.code);
+ }
+ $fh.print(q|
+typedef enum {
+|);
+ $fh.print(~$sb);
+ $fh.print(q|
+} parrot_opcode_enums;
+|);
+}
+
+method _emit_source_preamble($fh) {
+
+ self._emit_preamble($fh);
+ $fh.print(qq|
+#include "{self<include>}"
+#include "pmc/pmc_parrotlibrary.h"
+#include "pmc/pmc_callcontext.h"
+
+{self.trans.defines(self)}
+
+|);
+
+ $fh.print(self.ops_file.preamble);
+}
+
+method _emit_op_lib_descriptor($fh) {
+
+ my $core_type := self.trans.core_type;
+ $fh.print(q|
+/*
+** op lib descriptor:
+*/
+
+static op_lib_t | ~ self.bs ~ q|op_lib = {| ~ qq|
+ "{self.base}", /* name */
+ "{self.suffix}", /* suffix */
+ $core_type, /* core_type = PARROT_XX_CORE */
+ 0, /* flags */
+ {self.ops_file.version_major}, /* major_version */
+ {self.ops_file.version_minor}, /* minor_version */
+ {self.ops_file.version_patch}, /* patch_version */
+ {+self.ops_file.ops}, /* op_count */
+ {self.trans.op_info(self)}, /* op_info_table */
+ {self.trans.op_func(self)}, /* op_func_table */
+ {self.trans.getop(self)} /* op_code() */ | ~ q|
+};
+|);
+}
+
+method _emit_init_func($fh) {
+
+ my $init1 := self.trans.init_func_init1;
+ my $dispatch := self.trans.init_func_disaptch;
+
+ # TODO There is a bug in NQP about \{
+ $fh.print(q|
+op_lib_t *
+| ~ self.init_func ~ q|(PARROT_INTERP, long init) {
+ /* initialize and return op_lib ptr */
+ if (init == 1) {
+| ~ $init1 ~ q|
+ return &| ~ self.bs ~q|op_lib;
+ }
+ /* set op_lib to the passed ptr (in init) */
+ else if (init) {
+| ~ $dispatch ~ q|
+ }
+ /* deinit - free resources */
+ else {
+ hop_deinit(interp);
+ }
+ return NULL;
+}
+
+|);
+}
+
+method _emit_dymanic_lib_load($fh) {
+
+ if self.flags<core> {
+ return;
+ }
+
+ my $load_func := join('_',
+ q{Parrot}, q{lib}, self.base, q{ops} ~ self.suffix, q{load}, );
+ $fh.print(qq|
+/*
+ * dynamic lib load function - called once
+ */
+{self.sym_export} PMC*
+$load_func(PARROT_INTERP);
+
+{self.sym_export} PMC*
+$load_func(PARROT_INTERP)
+| ~ q|
+{
+ PMC *const lib = Parrot_pmc_new(interp, enum_class_ParrotLibrary);
+ ((Parrot_ParrotLibrary_attributes*)PMC_data(lib))->oplib_init = (void *) | ~ self.init_func ~q|;
+ dynop_register(interp, lib);
+ return lib;
+}
+|);
+}
+
+# given a headerfile name like "include/parrot/oplib/core_ops.h", this
+# returns a string like "PARROT_OPLIB_CORE_OPS_H_GUARD"
+method _generate_guard_macro_name($filename) {
+ $filename := subst($filename, /.h$/, '');
+ #my @path = File::Spec->splitdir($filename);
+ my @path := split('/', $filename);
+ @path.shift if @path[0]~'/' eq self<flags><dir>;
+ @path.shift if @path[0] eq 'include';
+ @path.shift if @path[0] eq 'parrot';
+ uc( join( '_', 'parrot', |@path, 'h', 'guard' ) );
+}
+
+
+method _emit_guard_prefix($fh, $filename) {
+ my $guardname := self._generate_guard_macro_name($filename);
+ $fh.print('
+/* $Id' ~ '$ */
+');
+ $fh.print(qq/
+#ifndef $guardname
+#define $guardname
+
+/);
+}
+
+method _emit_guard_suffix($fh, $filename) {
+ my $guardname := self._generate_guard_macro_name($filename);
+ $fh.print(qq|
+
+#endif /* $guardname */
+|);
+}
+
+
+method _emit_coda($fh) {
+ $fh.print(q|
+
+/*
+ * Local variables:
+ * c-file-style: "parrot"
+ * buffer-read-only: t
+ * End:
+ * vim: expandtab shiftwidth=4:
+ */
+|);
+}
+
+method _emit_includes($fh) {
+
+ $fh.print(qq|
+#include "parrot/parrot.h"
+#include "parrot/oplib.h"
+#include "parrot/runcore_api.h"
+
+{self.sym_export} op_lib_t *{self.init_func}(PARROT_INTERP, long init);
+
+|);
+}
+
+method _emit_preamble($fh) {
+
+ $fh.print(qq|
+/* ex: set ro:
+ * !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
+ *
+ * This file is generated automatically from '{self<file>}' (and possibly other
+ * .ops files). by {self<script>}.
+ *
+ * Any changes made here will be lost!
+ *
+ */
+|);
+
+ if !self.flags<core> {
+ $fh.print("#define PARROT_IN_EXTENSION\n");
+ }
+
+}
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/src/Ops/File.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/File.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,331 @@
+#! nqp
+# Copyright (C) 2001-2009, Parrot Foundation.
+# $Id$
+
+# XXX Better to put this into docs/ somewhere.
+
+=begin
+
+=head1 NAME
+
+Ops::File - Ops To C Code Generation
+
+=head1 SYNOPSIS
+
+ use Ops::File;
+
+=head1 DESCRIPTION
+
+C<Ops::File> takes one or more files of op functions and
+creates real C code for them.
+
+This class is used by F<tools/build/ops2c.pl>,
+F<tools/build/ops2pm.pl> and F<tools/build/pbc2c.pl>.
+
+=head2 Op Functions
+
+For ops that have trivial bodies (such as just a call to some other
+function and a C<return> statement), opcode functions are in the format:
+
+ inline op opname (args) :flags {
+ ... body of function ...
+ }
+
+Note that currently the C<inline> op type is ignored.
+
+Alternately, for opcode functions that have more internal complexity the
+format is:
+
+ op opname (args) :flags {
+ ... body of function ...
+ }
+
+There may be more than one C<return>.
+
+In both cases the closing brace B<must> be on its own line.
+
+When specifying multiple flags, each flag gets its own prefixing colon.
+
+=head2 Op Arguments
+
+Op arguments are a comma-separated list of direction and type pairs.
+
+Argument direction is one of:
+
+ in the argument passes a value into the op
+ out the argument passes a value out of the op
+ inout the argument passes a value into and out of the op
+ inconst the argument passes a constant value into the op
+ invar the argument passes a variable value into the op
+
+Argument direction is used to determine the life times of symbols and
+their related register allocations. When an argument is passed into an
+op a register is read from, when it's passed out of an op a register is
+written to.
+
+Argument type is one of:
+
+ INT the argument is an integer
+ NUM the argument is an numeric
+ STR the argument is an string
+ PMC the argument is an PMC
+ KEY the argument is an aggregate PMC key
+ INTKEY the argument is an aggregate PMC integer key
+ LABEL the argument is an integer branch offset or address
+
+The size of the return offset is determined from the op function's
+signature.
+
+=head2 Op Flags
+
+The flags are of two types:
+
+=over 4
+
+=item 1 class
+
+The classification of ops is intended to facilitate the selection of
+suitable ops for a Parrot safe mode.
+
+=item 2 behavior
+
+The presence (or absence) of certain flags will change how the op behaves. For
+example, the lack of the C<flow> flag will cause the op to be implicitly
+terminated with C<goto NEXT()>. (See next section).
+
+The :deprecated flag will generate a diagnostic to standard error at
+runtime when a deprecated opcode is invoked and
+C<PARROT_WARNINGS_DEPRECATED_FLAG> has been set.
+
+=back
+
+=head2 Op Body (Macro Substitutions)
+
+In the following macro descriptions, C<PC> and C<PC'> are the current
+and next position within the Parrot code.
+
+=over 4
+
+=item C<goto OFFSET(X)>
+
+Transforms to C<PC' = PC + X>. This is used for branches.
+
+=item C<goto NEXT()>
+
+Transforms to C<PC' = PC + S>, where C<S> is the size of an op.
+
+=item C<goto ADDRESS(X)>
+
+Transforms to C<PC' = X>. This is used for absolute jumps.
+
+=item C<expr OFFSET(X)>
+
+Transforms to C<PC + X>. This is used to give a relative address.
+
+=item C<expr NEXT()>
+
+Transforms to C<PC + S>, the position of the next op.
+
+=item C<expr ADDRESS(X)>
+
+Transforms to C<X>, an absolute address.
+
+=item C<OP_SIZE>
+
+Transforms to C<S>, the size of an op.
+
+=item C<HALT()>
+
+Transforms to C<PC' = 0>. Halts run loop, and resets the current
+position to the start of the Parrot code, without resuming.
+
+=item C<restart OFFSET(X)>
+
+Transforms to C<PC' = 0> and restarts at C<PC + X>.
+
+=item C<restart NEXT()>
+
+Transforms to C<PC' = 0> and restarts at C<PC + S>.
+
+=item C<$n>
+
+Transforms to the op function's nth argument. C<$0> is the opcode itself.
+
+=back
+
+Note that, for ease of parsing, if the argument to one of the above
+notations in a ops file contains parentheses, then double the enclosing
+parentheses and add a space around the argument, like so:
+
+ goto OFFSET(( (void*)interp->happy_place ))
+
+=head2 Class Methods
+
+=over 4
+
+=end
+
+class Ops::File is Hash;
+
+pir::load_bytecode('config.pbc');
+
+=begin
+
+=item C<new(@files)>
+
+Returns a new instance initialized by calling C<read_ops()> on each of
+the specified op files.
+
+=item C<new_str($str)>
+
+Returns a new instance initialized by compiling C<$str> as the contents of an
+ops file.
+
+=end
+
+method new(*@files, :$oplib, :$core!, :$nolines) {
+ self<files> := @files;
+ self<core> := $core;
+ self<ops> := list(); # Ops
+ self<preamble>:= '';
+ self<compiler>:= pir::compreg__Ps('Ops');
+ self<op_order>:= 0;
+ self<renum> := Ops::Renumberer.new( :ops_file(self) );
+
+ if $core {
+ self<oplib> := $oplib;
+ self<compiler>.set_oplib($oplib);
+ }
+ else {
+ self<file> := @files[0];
+ }
+
+ self._set_version();
+
+ for @files { self.read_ops( $_, $nolines ) }
+
+ self._calculate_op_codes();
+
+ self;
+}
+
+method new_str($str, :$oplib) {
+ self<ops> := list(); # Ops
+ self<preamble> := '';
+
+ self<compiler> := pir::compreg__Ps('Ops');
+ self<oplib> := $oplib;
+ self<compiler>.set_oplib($oplib);
+
+ self._set_version();
+
+ self._set_version();
+
+ self.compile_ops($str);
+
+ self;
+}
+
+
+=begin
+
+=back
+
+=head2 Instance Methods
+
+=over 4
+
+=item C<read_ops($file,$nolines)>
+
+Reads in the specified .ops file, gathering information about the ops.
+
+=end
+
+method read_ops($file, $nolines) {
+ $Ops::Compiler::Actions::OPLIB := self<oplib>;
+
+ say("# Parsing $file...");
+ my $start_time := pir::time__N();
+ my $buffer := slurp($file);
+ self.compile_ops($buffer, :experimental( $file ~~ /experimental\.ops/));
+ pir::sprintf(my $time, "%.3f", [pir::time__N() - $start_time] );
+ say("# Parsed $file in $time seconds.");
+}
+
+method compile_ops($str, :$experimental? = 0) {
+ my $compiler := self<compiler>;
+ my $past := $compiler.compile($str, :target('past'));
+
+ for @($past<ops>) {
+ $_<experimental> := $experimental;
+ self<ops>.push($_);
+ #say($_.full_name ~ " is number " ~ self<op_order>);
+ self<op_order>++;
+ }
+
+ for @( $past<preamble> ) {
+ self<preamble> := self<preamble> ~ $_;
+ }
+ $past;
+}
+
+method get_parse_tree($str) {
+ my $compiler := pir::compreg__Ps('Ops');
+ $compiler.compile($str, :target('parse'));
+}
+
+method preamble() { self<preamble> };
+method ops() { self<ops> };
+method oplib() { self<oplib> };
+method version() { self<version>; }
+
+method version_major() { self<version_major> }
+method version_minor() { self<version_minor> }
+method version_patch() { self<version_patch> }
+
+method _calculate_op_codes() {
+
+ my $code := self<oplib> ??
+ self<oplib>.max_op_num + 1 !!
+ 0;
+
+ for self<ops> -> $op {
+ #ops listed in ops.num are non-experimental
+ if self<oplib> {
+ my $full_name := $op.full_name;
+ if self<oplib>.op_num_table.exists($full_name) {
+ $op<code> := self<oplib>.op_num_table{$full_name};
+ }
+ elsif !$op<experimental> && !self<oplib>.op_skip_table.exists($full_name) {
+ die("Non-experimental op " ~ $op.full_name ~ " is not in ops.num.");
+ }
+ #ops not explicitly listed but not skipped are experimental
+ else {
+ $op<code> := $code++;
+ say("# Experimental op " ~ $op.full_name ~ " is not in ops.num.");
+ }
+ }
+ #if there's no oplib, we're compiling dynops and ops aren't experimental
+ else {
+ $op<code> := $code++;
+ }
+ }
+}
+
+method _set_version() {
+ my $config := _config();
+ my $version := $config<VERSION>;
+ #say("# $version");
+ my @bits := split('.', $version);
+ self<version_major> := @bits[0];
+ self<version_minor> := @bits[1];
+ self<version_patch> := @bits[2];
+ self<version> := @bits;
+}
+
+# Local Variables:
+# mode: cperl
+# cperl-indent-level: 4
+# fill-column: 100
+# End:
+# vim: ft=perl6 expandtab shiftwidth=4:
Added: trunk/compilers/opsc/src/Ops/Op.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Op.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,392 @@
+#! nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+=begin
+
+=head1 NAME
+
+Ops::Op - Parrot Operation
+
+=head1 SYNOPSIS
+
+ use Ops::Op;
+
+=head1 DESCRIPTION
+
+C<Ops::Op> represents a Parrot operation (op, for short), as read
+from an ops file via C<Ops::OpsFile>, or perhaps even generated by
+some other means. It is the Perl equivalent of the C<op_info_t> C
+C<struct> defined in F<include/parrot/op.h>.
+
+=head2 Op Type
+
+Ops are either I<auto> or I<manual>. Manual ops are responsible for
+having explicit next-op C<RETURN()> statements, while auto ops can count
+on an automatically generated next-op to be appended to the op body.
+
+Note that F<tools/build/ops2c.pl> supplies either 'inline' or 'function'
+as the op's type, depending on whether the C<inline> keyword is present
+in the op definition. This has the effect of causing all ops to be
+considered manual.
+
+=head2 Op Arguments
+
+Note that argument 0 is considered to be the op itself, with arguments
+1..9 being the arguments passed to the op.
+
+Op argument direction and type are represented by short one or two letter
+descriptors.
+
+Op Direction:
+
+ i The argument is incoming
+ o The argument is outgoing
+ io The argument is both incoming and outgoing
+
+Op Type:
+
+ i The argument is an integer register index.
+ n The argument is a number register index.
+ p The argument is a PMC register index.
+ s The argument is a string register index.
+ ic The argument is an integer constant (in-line).
+ nc The argument is a number constant index.
+ pc The argument is a PMC constant index.
+ sc The argument is a string constant index.
+ kc The argument is a key constant index.
+ ki The argument is a key integer register index.
+ kic The argument is a key integer constant (in-line).
+
+=head2 Class Methods
+
+=over 4
+
+=end
+
+class Ops::Op is PAST::Block;
+
+INIT {
+ pir::load_bytecode("dumper.pbc");
+}
+
+=begin
+
+=item C<new(:$code, :$type, :$name, :@args, :%flags)>
+
+Allocates a new bodyless op. A body must be provided eventually for the
+op to be usable.
+
+C<$code> is the integer identifier for the op.
+
+C<$type> is the type of op (see the note on op types above).
+
+C<$name> is the name of the op.
+
+C<@args> is a reference to an array of argument type descriptors.
+
+C<$flags> is a hash reference containing zero or more I<hints> or
+I<directives>.
+
+
+=back
+
+=head2 Instance Methods
+
+=over 4
+
+=item C<code()>
+
+Returns the op code.
+
+=item C<type()>
+
+The type of the op, either 'inline' or 'function'.
+
+=item C<name()>
+
+The (short or root) name of the op.
+
+=item C<full_name()>
+
+For argumentless ops, it's the same as C<name()>. For ops with
+arguments, an underscore followed by underscore-separated argument types
+are appended to the name.
+
+=item C<func_name()>
+
+The same as C<full_name()>, but with 'C<Parrot_>' prefixed.
+
+=end
+
+method code($code?) { self.attr('code', $code, defined($code)) }
+
+method type($type?) { self.attr('type', $type, defined($type)) }
+
+method name($name?) { self.attr('name', $name, defined($name)) }
+
+method args($args?) { self.attr('args', $args, defined($args)) }
+
+method arg_types($args?) {
+ my $res := self.attr('arg_types', $args, defined($args));
+
+ return list() if !defined($res);
+ pir::does__IPS($res, 'array') ?? $res !! list($res);
+}
+
+method arg_dirs($args?) { self.attr('arg_dirs', $args, defined($args)) }
+
+method arg_type($arg_num) {
+ my @arg_types := self.arg_types;
+ @arg_types[$arg_num];
+}
+
+method full_name() {
+ my $name := self.name;
+ my @arg_types := self.arg_types;
+
+ #say("# $name arg_types " ~ @arg_types);
+ join('_', $name, |@arg_types);
+}
+
+method func_name($trans) {
+ return $trans.prefix ~ self.full_name;
+}
+
+
+=begin
+
+=item C<flags()>
+
+Sets the op's flags. This returns a hash reference, whose keys are any
+flags (passed as ":flag") specified for the op.
+
+=end
+
+method flags(%flags?) { self.attr('flags', %flags, defined(%flags)) }
+
+=begin
+
+=item C<body($body)>
+
+=item C<body()>
+
+Sets/gets the op's code body.
+
+=end
+
+method body() {
+ my $res := '';
+ for @(self) -> $part {
+ $res := $res ~ $part<inline>;
+ }
+ $res;
+}
+
+=begin
+
+=item C<jump($jump)>
+
+=item C<jump()>
+
+Sets/gets a string containing one or more C<op_jump_t> values joined with
+C<|> (see F<include/parrot/op.h>). This indicates if and how an op
+may jump.
+
+=end
+
+method jump($jump?) { self.attr('jump', $jump, defined($jump)) }
+
+=begin
+
+=item C<add_jump($jump)>
+
+=item C<add_jump($jump)>
+
+Add a jump flag to this op if it's not there already.
+
+=end
+
+method add_jump($jump) {
+ my $found_jump := 0;
+
+ unless self.jump { self.jump(list()) }
+
+ for self.jump {
+ if $_ eq $jump { $found_jump := 1 }
+ }
+
+ unless $found_jump {
+ self.jump.push($jump);
+ }
+}
+
+=begin
+
+=item C<get_jump()>
+
+=item C<get_jump()>
+
+Get the jump flags that apply to this op.
+
+=end
+
+method get_jump() {
+
+ if self.jump {
+ return join( '|', |self.jump );
+ }
+ else {
+ return '0';
+ }
+}
+
+=begin
+
+=item C<source($trans, $op)>
+
+Returns the L<C<body()>> of the op with substitutions made by
+C<$trans> (a subclass of C<Ops::Trans>).
+
+=end
+
+method source( $trans ) {
+
+ my $prelude := $trans.body_prelude;
+ return $prelude ~ self.get_body( $trans );
+}
+
+=begin
+
+=item C<get_body($trans)>
+
+Performs the various macro substitutions using the specified transform,
+correctly handling nested substitions, and repeating over the whole string
+until no more substitutions can be made.
+
+C<VTABLE_> macros are enforced by converting C<<< I<< x >>->vtable->I<<
+method >> >>> to C<VTABLE_I<method>>.
+
+=end
+
+method get_body( $trans ) {
+
+ my @body := list();
+
+ #work through the op_body tree
+ for @(self) {
+ my $chunk := self.process_body_chunk($trans, $_);
+ #pir::say('# chunk ' ~ $chunk);
+ @body.push($chunk);
+ }
+
+ join('', |@body);
+}
+
+# Recursively process body chunks returning string.
+# Ideally bunch of multisubs, but...
+method process_body_chunk($trans, $chunk) {
+ my $what := $chunk.WHAT;
+ # Poor man multis...
+ if $what eq 'PAST::Var()' {
+ my $n := +$chunk.name;
+ return $trans.access_arg( self.arg_type($n - 1), $n);
+ }
+ elsif $what eq 'PAST::Op()' {
+ my $type := $chunk.pasttype;
+ #say('OP ' ~ $type);
+ if $type eq 'inline' {
+ #_dumper($chunk);
+ #pir::say('RET ' ~ $chunk<inline>);
+ return $chunk.inline;
+ }
+ elsif $type eq 'call' {
+ my $name := $chunk.name;
+ #say('NAME '~$name ~ ' ' ~ $is_next);
+ if $name eq 'OPSIZE' {
+ #say('is_next');
+ return ~self.size;
+ }
+
+ my @children := list();
+ for @($chunk) {
+ @children.push(self.process_body_chunk($trans, $_));
+ }
+ my $children := join('', |@children);
+
+ #pir::say('children ' ~ $children);
+ my $ret := Q:PIR<
+ $P0 = find_lex '$trans'
+ $P1 = find_lex '$name'
+ $S0 = $P1
+ $P1 = find_lex '$children'
+ %r = $P0.$S0($P1)
+ >;
+ #pir::say('RET ' ~ $ret);
+ return $ret;
+ }
+ }
+ elsif $what eq 'PAST::Stmts()' {
+ my @children := list();
+ for @($chunk) {
+ @children.push(self.process_body_chunk($trans, $_));
+ }
+ my $children := join('', |@children);
+ return $children;
+ }
+ else {
+ pir::die('HOLEY');
+ }
+}
+
+
+=begin
+
+=item C<size()>
+
+Returns the op's number of arguments. Note that this also includes
+the op itself as one argument.
+
+=end
+
+method size() {
+ return pir::does__IPs(self.arg_types, 'array') ?? +self.arg_types + 1 !! 2;
+}
+
+=begin
+
+=back
+
+=head1 SEE ALSO
+
+=over 4
+
+=item C<Ops::OpsFile>
+
+=item C<Ops::OpTrans>
+
+=item F<tools/build/ops2c.pl>
+
+=item F<tools/build/ops2pm.pl>
+
+=item F<tools/build/pbc2c.pl>
+
+=back
+
+=head1 HISTORY
+
+Author: Gregor N. Purdy E<lt>gregor at focusresearch.comE<gt>
+
+Migrate to NQP: Vasily Chekalkin E<lt>bacek at bacek.comE<gt>
+
+=end
+
+1;
+
+# Local Variables:
+# mode: cperl
+# cperl-indent-level: 4
+# fill-column: 100
+# End:
+# vim: ft=perl6 expandtab shiftwidth=4:
+
Added: trunk/compilers/opsc/src/Ops/OpLib.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/OpLib.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,234 @@
+#! nqp
+# Copyright (C) 2009-2010, Parrot Foundation.
+# $Id$
+
+INIT {
+ pir::load_bytecode("dumper.pbc");
+};
+
+class Ops::OpLib is Hash;
+
+=begin NAME
+
+C<Ops::OpLib> - library of Parrot Operations.
+
+=end NAME
+
+=begin DESCRIPTION
+
+Responsible for loading F<src/ops/ops.num> and F<src/ops/ops.skip> files,
+parse F<.ops> files, sort them, etc.
+
+Heavily inspired by Perl5 Parrot::Ops2pm.
+
+=end DESCRIPTION
+
+=begin SYNOPSIS
+
+ my $oplib := Ops::OpLib.new(
+ :num_file('../../src/ops/ops.num'),
+ :skip_file('../../src/ops/ops.skip'),
+ ));
+
+=end SYNOPSIS
+
+=begin ATTRIBUTES
+
+=over 4
+
+=item * C<$.max_op_num>
+
+Scalar holding number of highest non-experimental op. Example:
+
+ 'max_op_num' => 1246,
+
+=item * C<%.op_num_table>
+
+Hash holding mapping of opcode names ops to their numbers.
+Example:
+
+ 'op_num_table' => {
+ 'pow_p_p_i' => 650,
+ 'say_s' => 463,
+ 'lsr_p_p_i' => 207,
+ 'lt_s_sc_ic' => 289,
+ # ...
+ 'debug_init' => 429,
+ 'iseq_i_nc_n' => 397,
+ 'eq_addr_sc_s_ic' => 254
+ },
+
+Per F<src/ops/ops.num>, this mapping exists so that we can nail down
+the op numbers for the core opcodes in a particular version of the
+bytecode and provide backward-compatibility for bytecode.
+
+=item * C<%.op_skip_table>
+
+Reference to a 'seen-hash' of skipped opcodes.
+
+ 'op_skip_table' => {
+ 'bor_i_ic_ic' => 1,
+ 'xor_i_ic_ic' => 1,
+ 'tanh_n_nc' => 1,
+ # ...
+ },
+
+As F<src/ops/ops.skip> states, these are "... opcodes that could be listed in
+F<[src/ops/]ops.num> but aren't ever to be generated or implemented because
+they are useless and/or silly."
+
+=back
+
+=end ATTRIBUTES
+
+=begin METHODS
+
+=over 4
+
+=item C<new>
+
+Build OpLib.
+
+(It's NQP. In Perl 6 it should be submethod and invoked automatically)
+
+=end METHODS
+
+method new(:$num_file, :$skip_file) {
+ self<num_file> := $num_file // './src/ops/ops.num';
+ self<skip_file> := $skip_file // './src/ops/ops.skip';
+
+ # Initialize self.
+ self<max_op_num> := 0;
+ self<op_num_table> := hash();
+ self<op_skip_table> := hash();
+ self<num_file_lines>:= list();
+ self<ops_past> := list();
+ self<regen_ops_num> := 0;
+
+ self.load_op_map_files();
+
+ self;
+}
+
+=begin METHODS
+
+=item C<load_op_map_files>
+
+Load ops.num and ops.skip files.
+
+=end METHODS
+
+method load_op_map_files() {
+ self._load_num_file;
+ self._load_skip_file;
+}
+
+my method _load_num_file() {
+ # slurp isn't very efficient. But extending NQP beyond bare minimum is not in scope.
+ my $buf := slurp(self<num_file>);
+ grammar NUM {
+ rule TOP { <line>+ }
+
+ rule line {
+ [
+ | <op>
+ | <dynamic>
+ | <comment>
+ ]
+ }
+ rule op { $<name>=(\w+) $<number>=(\d+) }
+ rule dynamic { '###DYNAMIC###' \N* }
+ rule comment { '#' \N* }
+ }
+
+ #say("Parsing NUM");
+ my $ops := NUM.parse($buf);
+ #_dumper($ops);
+ #pir::exit(0);
+
+ my $prev := -1;
+ for $ops<line> {
+ self<num_file_lines>.push($_);
+ if $_<op> {
+ my $name := ~$_<op><name>;
+ my $number := +$_<op><number>;
+ if (+$number) eq $number {
+ if ($prev + 1 != $number) {
+ self<regen_ops_num> := 1;
+ say("# hole in ops.num before #$number: will regenerate ops.num");
+ }
+ if self<op_num_table>.exists($name) {
+ self<regen_ops_num> := 1;
+ say("# duplicate opcode $name and $number: will regenerate ops.num");
+ }
+
+ $prev := $number;
+ self<op_num_table>{$name} := $number;
+ if ( $number > self<max_op_num> ) {
+ self<max_op_num> := $number;
+ }
+ }
+ }
+ }
+
+ #_dumper(self<op_num_table>);
+}
+
+method _load_skip_file() {
+ my $buf := slurp(self<skip_file>);
+ grammar SKIP {
+ rule TOP { <op>+ }
+
+ rule op { $<name>=(\w+) }
+ token ws {
+ [
+ | \s+
+ | '#' \N*
+ ]*
+ }
+ }
+
+ my $lines := SKIP.parse($buf);
+
+ for $lines<op> {
+ if self<op_num_table> && self<op_num_table>.exists($_<name>) {
+ die("skipped opcode '$_' is also in num_file");
+ }
+ self<op_skip_table>{$_<name>} := 1;
+ }
+}
+
+
+=begin ACCESSORS
+
+Various methods for accessing internals.
+
+=over 4
+
+=item * C<max_op_num>
+
+=item * C<op_num_table>
+
+=item * C<op_skip_table>
+
+=item * C<num_file>
+
+=item * C<num_file_lines>
+
+=end ACCESSORS
+
+method max_op_num() { self<max_op_num>; }
+
+method op_num_table() { self<op_num_table>; }
+
+method op_skip_table() { self<op_skip_table>; }
+
+method num_file() { self<num_file>; }
+
+method num_file_lines() { self<num_file_lines>; }
+
+# Local Variables:
+# mode: perl6
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/src/Ops/Renumberer.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Renumberer.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,108 @@
+#! nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+INIT {
+ pir::load_bytecode("dumper.pbc");
+};
+
+class Ops::Renumberer is Hash;
+
+=begin NAME
+
+C<Ops::Renumberer> - renumber ops.num.
+
+=end NAME
+
+=begin DESCRIPTION
+
+This class is responsible for regenerating src/ops/ops.num when the number or
+order of ops there needs to be changed.
+
+=end DESCRIPTION
+
+=begin SYNOPSIS
+
+ my $renum := Ops::Renumberer.new( :ops_file($f) );
+
+=end SYNOPSIS
+
+=begin ATTRIBUTES
+
+=over 4
+
+=item * C<$.max_op_num>
+
+Scalar holding number of highest non-experimental op. Example:
+
+ 'max_op_num' => 1246,
+
+=back
+
+=end ATTRIBUTES
+
+=begin METHODS
+
+=over 4
+
+=item C<new>
+
+Build an Ope::Renumberer.
+
+(It's NQP. In Perl 6 it should be submethod and invoked automatically)
+
+=end METHODS
+
+method new(:$ops_file!) {
+ self<ops_file> := $ops_file;
+
+ self;
+}
+
+=begin METHODS
+
+=item C<need_regeneration>
+
+Check if ops.num needs to be regenerated.
+
+=end METHODS
+
+method need_regeneration() {
+
+ #only need regeneration for core ops
+ unless self<ops_file>.oplib {
+ return 0;
+ }
+
+ #shortcut in case the oplib found an invalid ops.num
+ if self<ops_file>.oplib<regen_ops_num>{
+ return 1;
+ }
+
+ my $op_num_table := self<ops_file>.oplib.op_num_table;
+ my $opsfile_ops := self<ops_file>.ops;
+ my $opsfile_num := 0;
+ my $need_regeneration := 0;
+
+ #find out if the order in ops.num reflects the order in Ops::File
+ for $opsfile_ops -> $opsfile_op {
+
+ my $op_name := $opsfile_op.full_name;
+ my $op_num_table_num := +$op_num_table{ $op_name };
+ #say("ops.num says $op_name is $op_num_table_num, opsfile says $opsfile_num");
+
+ if (!$opsfile_op<experimental> && $opsfile_num != $op_num_table_num) {
+ say("# Opsfile and ops.num disagree about $op_name: $opsfile_num vs $op_num_table_num");
+ $need_regeneration := 1;
+ }
+ $opsfile_num++;
+ }
+
+ $need_regeneration;
+}
+
+# Local Variables:
+# mode: perl6
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/src/Ops/Trans.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Trans.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,58 @@
+#! nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+class Ops::Trans is Hash;
+
+=begin
+
+Base class for Runcode transformations.
+
+=end
+
+method prefix() { 'Parrot_' };
+
+# We can't use yada-yada-yada
+method suffix() { die("...") }
+
+method core_type() { die("...") }
+
+# Prepare internal structures from Ops::File.ops.
+method prepare_ops($emitter, $ops_file) { die('...') }
+
+#
+method emit_c_op_funcs_header_part($fh) { die('...') }
+
+# Called from Ops::Op.
+method body_prelude() { '' }
+
+method defines($emitter) { die('...') }
+
+method emit_source_part($emitter, $fh) { die('...') }
+
+# Default op lookup do nothing. But op_deinit referenced anyway.
+method emit_op_lookup($fh) {
+ $fh.print(q|static void hop_deinit(SHIM_INTERP) {}|);
+}
+
+method init_func_init1() { '' }
+method init_func_disaptch() { '' }
+
+method op_info($emitter) { 'NULL' }
+method op_func($emitter) { 'NULL' }
+method getop($emitter) { '( int (*)(PARROT_INTERP, const char *, int) )NULL' };
+
+our %arg_maps := {};
+
+method access_arg($type, $num) { die('...'); }
+
+method restart_address($addr) { die('...'); }
+method restart_offset($offset) { die('...'); }
+
+method goto_address($addr) { die('...'); }
+method goto_offset($offset) { die('...'); }
+
+method expr_address($addr) { die('...'); }
+method expr_offset($offset) { die('...'); }
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/src/Ops/Trans/C.pm
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/Ops/Trans/C.pm Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,367 @@
+#! nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+class Ops::Trans::C is Ops::Trans;
+
+method new() {
+ # Storage for generated ops functions.
+ self<op_funcs> := list();
+ # Storage for generated ops functions prototypes.
+ self<op_protos> := list();
+
+ self<names> := hash();
+
+ self<num_entries> := 0;
+
+ self<arg_maps> := hash(
+ :op("cur_opcode[NUM]"),
+
+ :i("IREG(NUM)"),
+ :n("NREG(NUM)"),
+ :p("PREG(NUM)"),
+ :s("SREG(NUM)"),
+ :k("PREG(NUM)"),
+ :ki("IREG(NUM)"),
+
+ :ic("cur_opcode[NUM]"),
+ :nc("CONST(NUM)->u.number"),
+ :pc("CONST(NUM)->u.key"),
+ :sc("CONST(NUM)->u.string"),
+ :kc("CONST(NUM)->u.key"),
+ :kic("cur_opcode[NUM]")
+ );
+
+ self;
+}
+
+method suffix() { '' };
+
+method core_type() { 'PARROT_FUNCTION_CORE' }
+
+method prepare_ops($emitter, $ops_file) {
+
+ my $index := 0;
+ my @op_protos;
+ my @op_funcs;
+ my @op_func_table;
+
+ for $ops_file.ops -> $op {
+ #say("# preparing " ~ $op);
+ my $func_name := $op.func_name( self );
+ my $definition := "opcode_t *\n$func_name(opcode_t *cur_opcode, PARROT_INTERP)";
+ my $prototype := $emitter.sym_export
+ ~ " opcode_t * $func_name(opcode_t *, PARROT_INTERP);\n";
+
+ my $src := $op.source( self );
+
+ @op_func_table.push(sprintf( " %-50s /* %6ld */\n", "$func_name,", $index ));
+
+ my $body := join('', $definition, ' {', "\n", $src, '}', "\n\n");
+ @op_funcs.push($body);
+ @op_protos.push($prototype);
+ $index++;
+ }
+
+ self<op_funcs> := @op_funcs;
+ self<op_protos> := @op_protos;
+ self<op_func_table> := @op_func_table;
+ self<num_entries> := + at op_funcs + 1;
+}
+
+method emit_c_op_funcs_header_part($fh) {
+ for self<op_protos> -> $proto {
+ $fh.print($proto);
+ }
+}
+
+method access_arg($type, $num) {
+ my $access := self<arg_maps>{$type};
+ die("unrecognized arg type '$type'") unless $access;
+ subst($access, /NUM/, $num);
+}
+
+method restart_address($addr) {
+ "interp->resume_offset = $addr; interp->resume_flag = 1;";
+}
+
+method restart_offset($offset) {
+ "interp->resume_offset = REL_PC + $offset; interp->resume_flag = 1;";
+}
+
+method goto_address($addr) { "return (opcode_t *)$addr"; }
+
+method goto_offset($offset) { "return (opcode_t *)cur_opcode + $offset"; }
+
+method expr_address($addr) { $addr; }
+
+method expr_offset($offset) { "cur_opcode + $offset"; }
+
+=begin
+
+=item C<defines()>
+
+Returns the C C<#define> macros for register access etc.
+
+=end
+
+method defines($emitter) {
+ return qq|
+/* defines - Ops::Trans::C */
+#undef CONST
+#define REL_PC ((size_t)(cur_opcode - (opcode_t *)interp->code->base.data))
+#define CUR_OPCODE cur_opcode
+#define IREG(i) (CUR_CTX->bp.regs_i[cur_opcode[i]])
+#define NREG(i) (CUR_CTX->bp.regs_n[-1L - cur_opcode[i]])
+#define PREG(i) (CUR_CTX->bp_ps.regs_p[-1L - cur_opcode[i]])
+#define SREG(i) (CUR_CTX->bp_ps.regs_s[cur_opcode[i]])
+#define CONST(i) Parrot_pcc_get_constants(interp, interp->ctx)[cur_opcode[i]]
+
+static int get_op(PARROT_INTERP, const char * name, int full);
+|;
+}
+
+method op_info($emitter) { $emitter.bs ~ 'op_info_table' }
+method op_func($emitter) { $emitter.bs ~ 'op_func_table' }
+method getop($emitter) { 'get_op' };
+
+method body_prelude() { ' const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);' }
+
+method emit_source_part($emitter, $fh) {
+ self._emit_op_func_table($emitter, $fh);
+ self._emit_op_info_table($emitter, $fh);
+ self._emit_op_function_definitions($emitter, $fh);
+}
+
+method _emit_op_func_table($emitter, $fh) {
+
+ $fh.print(qq|
+
+INTVAL {$emitter.bs}numops{self.suffix} = {self<num_entries>};
+
+/*
+** Op Function Table:
+*/
+
+static op_func{self.suffix}_t {self.op_func($emitter)}[{self<num_entries>}] = | ~ '{'
+);
+
+ for self<op_func_table> {
+ $fh.print($_)
+ }
+
+ $fh.print(q|
+ NULL /* NULL function pointer */
+};
+
+|);
+}
+
+
+method _emit_op_info_table($emitter, $fh) {
+
+ my %names := self<names>;
+ my %arg_dir_mapping := hash(
+ :i('PARROT_ARGDIR_IN'),
+ :o('PARROT_ARGDIR_OUT'),
+ :io('PARROT_ARGDIR_INOUT')
+ );
+
+ #
+ # Op Info Table:
+ #
+ $fh.print(qq|
+
+/*
+** Op Info Table:
+*/
+
+static op_info_t {self.op_info($emitter)}[{self<num_entries>}] = | ~ q|{
+|);
+
+ my $index := 0;
+
+ for $emitter.ops_file.ops -> $op {
+ my $type := sprintf( "PARROT_%s_OP", uc($op.type ?? 'INLINE' !! 'FUNCTION') );
+ my $name := $op.name;
+ %names{$name} := 1;
+ my $full_name := $op.full_name;
+ my $func_name := $op.func_name( self );
+ my $body := $op.body;
+ my $jump := $op.get_jump;
+ my $arg_count := $op.size;
+
+ ## 0 inserted if arrays are empty to prevent msvc compiler errors
+ my $arg_types := +$op.arg_types
+ ?? '{ ' ~ join( ", ",
+ |map( -> $t { sprintf( "PARROT_ARG_%s", uc($t) ) }, |$op.arg_types)
+ ) ~ ' }'
+ !! '{ (arg_type_t) 0 }';
+ my $arg_dirs := $op<normalized_args>
+ ?? '{ ' ~ join(", ",
+ |map( -> $d { %arg_dir_mapping{$d<direction>} }, |$op<normalized_args>)
+ ) ~ ' }'
+ !! '{ (arg_dir_t) 0 }';
+ my $labels := $op<normalized_args>
+ ?? '{ ' ~ join(", ",
+ |map( -> $d { $d<is_label> ?? 1 !! 0 }, |$op<normalized_args>)
+ ) ~ ' }'
+ !! '{ 0 }';
+
+ $fh.print(' { ' ~ qq|/* $index */
+ /* type $type, */
+ "$name",
+ "$full_name",
+ "$func_name",
+ /* "", body */
+ $jump,
+ $arg_count,
+ $arg_types,
+ $arg_dirs,
+ $labels
+ | ~ '},
+',
+ );
+
+ $index++;
+ }
+ $fh.print(q|
+};
+
+|);
+}
+
+method _emit_op_function_definitions($emitter, $fh) {
+ $fh.print(q|
+/*
+** Op Function Definitions:
+*/
+
+|);
+
+ for self<op_funcs> -> $op {
+ $fh.print($op);
+ }
+}
+
+method emit_op_lookup($emitter, $fh) {
+
+ if !$emitter.flags<core> {
+ return;
+ }
+
+ my $hash_size := 3041;
+# my $tot := $self->{index} + scalar keys( %{ $self->{names} } );
+# if ( $hash_size < $tot * 1.2 ) {
+# print STDERR "please increase hash_size ($hash_size) in lib/Parrot/Ops2c/Utils.pm "
+# . "to a prime number > ", $tot * 1.2, "\n";
+# }
+ # Due bug in NQP do it in two passes.
+ my $res := q|
+/*
+** Op lookup function:
+*/
+
+#define OP_HASH_SIZE 3041
+
+/* we could calculate a prime somewhat bigger than
+ * n of fullnames + n of names
+ * for now this should be ok
+ *
+ * look up an op_code: at first call to op_code() a hash
+ * of short and full opcode names is created
+ * hash functions are from imcc, thanks to Melvin.
+ */
+
+
+typedef struct hop {
+ op_info_t * info;
+ struct hop *next;
+} HOP;
+static HOP **hop;
+
+static void hop_init(PARROT_INTERP);
+static size_t hash_str(const char *str);
+static void store_op(PARROT_INTERP, op_info_t *info, int full);
+
+/* XXX on changing interpreters, this should be called,
+ through a hook */
+
+static void hop_deinit(PARROT_INTERP);
+
+/*
+ * find a short or full opcode
+ * usage:
+ *
+ * interp->op_lib->op_code("set", 0)
+ * interp->op_lib->op_code("set_i_i", 1)
+ *
+ * returns >= 0 (found idx into info_table), -1 if not
+ */
+
+static size_t hash_str(const char *str) {
+ size_t key = 0;
+ const char *s = str;
+
+ while (*s) {
+ key *= 65599;
+ key += *s++;
+ }
+
+ return key;
+}
+
+static void store_op(PARROT_INTERP, op_info_t *info, int full) {
+ HOP * const p = mem_gc_allocate_zeroed_typed(interp, HOP);
+ const size_t hidx =
+ hash_str(full ? info->full_name : info->name) % OP_HASH_SIZE;
+
+ p->info = info;
+ p->next = hop[hidx];
+ hop[hidx] = p;
+}
+static int get_op(PARROT_INTERP, const char * name, int full) {
+ const HOP * p;
+ const size_t hidx = hash_str(name) % OP_HASH_SIZE;
+ if (!hop) {
+ hop = mem_gc_allocate_n_zeroed_typed(interp, OP_HASH_SIZE,HOP *);
+ hop_init(interp);
+ }
+ for (p = hop[hidx]; p; p = p->next) {
+ if(STREQ(name, full ? p->info->full_name : p->info->name))
+ return p->info - [[BS]]op_lib.op_info_table;
+ }
+ return -1;
+}
+static void hop_init(PARROT_INTERP) {
+ size_t i;
+ op_info_t * const info = [[BS]]op_lib.op_info_table;
+ /* store full names */
+ for (i = 0; i < [[BS]]op_lib.op_count; i++)
+ store_op(interp, info + i, 1);
+ /* plus one short name */
+ for (i = 0; i < [[BS]]op_lib.op_count; i++)
+ if (get_op(interp, info[i].name, 0) == -1)
+ store_op(interp, info + i, 0);
+}
+static void hop_deinit(PARROT_INTERP)
+{
+ if (hop) {
+ size_t i;
+ for (i = 0; i < OP_HASH_SIZE; i++) {
+ HOP *p = hop[i];
+ while (p) {
+ HOP * const next = p->next;
+ mem_gc_free(interp, p);
+ p = next;
+ }
+ }
+ mem_sys_free(hop);
+ hop = NULL;
+ }
+}|;
+
+ $fh.print(subst($res, /'[[' BS ']]'/, $emitter.bs, :global));
+}
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/compilers/opsc/src/builtins.pir
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/compilers/opsc/src/builtins.pir Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,196 @@
+#! parrot
+# Copyright (C) 2009-2010, Parrot Foundation.
+# $Id$
+
+=head1 Builtins
+
+Variour helper builtins.
+
+=cut
+.namespace []
+
+.sub 'lc'
+ .param string arg
+ $S0 = downcase arg
+ .return ($S0)
+.end
+
+.sub 'uc'
+ .param string arg
+ $S0 = upcase arg
+ .return ($S0)
+.end
+
+.sub 'defined'
+ .param pmc thing
+ $I0 = defined thing
+ .return ($I0)
+.end
+
+.sub 'clone'
+ .param pmc what
+ $P0 = clone what
+ .return ($P0)
+.end
+
+.sub 'elements'
+ .param pmc p
+ $I0 = elements p
+ .return ($I0)
+.end
+
+
+.sub 'substr'
+ .param string orig
+ .param int from
+ .param int len
+ $S0 = substr orig, from, len
+ .return ($S0)
+.end
+
+.sub 'match'
+ .param string pattern
+ .param string subject
+
+ .local pmc recomp, resub, match, recache
+
+ load_bytecode 'PGE.pbc'
+
+ #hash cache mapping patterns to subs, avoiding unneeded recompilation
+ recache = get_hll_global ['Ops';'Op'], '%recache'
+ $I0 = isnull recache
+ if $I0 goto no_cache
+ $I0 = exists recache[pattern]
+ if $I0 goto found_re
+ goto no_re
+
+ no_cache:
+ recache = new ['Hash']
+
+ no_re:
+ recomp = compreg 'PGE::Perl6Regex'
+ resub = recomp(pattern)
+ recache[pattern] = resub
+
+ found_re:
+ resub = recache[pattern]
+ set_hll_global ['Ops';'Op'], '%recache', recache
+
+ match = resub(subject)
+ if match goto found_match
+ .return (0)
+ found_match:
+ .return (1)
+.end
+
+.sub 'die'
+ .param string why :optional
+ .param int has_why :opt_flag
+
+ die why
+.end
+
+.sub 'slurp'
+ .param string file
+ .local pmc pio
+ pio = open file
+ $S0 = pio.'readall'()
+ close pio
+ .return ($S0)
+.end
+
+.sub 'split' :multi(_,_)
+ .param string splitter
+ .param string buf
+
+ $P0 = split splitter, buf
+ .return ($P0)
+.end
+
+.sub 'split' :multi('Sub', _)
+ .param pmc regex
+ .param pmc str
+ .param int count :optional
+ .param int has_count :opt_flag
+ .local pmc match
+ .local pmc retv
+ .local int start_pos
+ .local int end_pos
+ .local int zwm_start
+
+ $S0 = str
+ retv = new 'ResizableStringArray'
+ start_pos = 0
+
+ # per Perl 5's negative LIMIT behavior
+ unless has_count goto positive_count
+ if count < 1 goto done
+
+ positive_count:
+ match = regex($S0)
+ if match goto loop
+ retv.'push'($S0)
+ goto done
+
+ loop:
+ unless has_count goto skip_count
+ dec count
+ unless count < 1 goto skip_count
+ $S1 = substr $S0, start_pos
+ retv.'push'($S1)
+ goto done
+ next_zwm:
+ zwm_start = start_pos
+ inc_zwm:
+ inc start_pos
+ match = regex($S0, 'continue' => start_pos)
+ end_pos = match.'from'()
+ unless start_pos == end_pos goto inc_zwm
+ start_pos = zwm_start
+ end_pos -= start_pos
+ goto add_str
+ skip_count:
+ match = regex($S0, 'continue' => start_pos)
+ end_pos = match.'from'()
+ $I99 = match.'to'()
+ if $I99 == end_pos goto next_zwm
+ end_pos -= start_pos
+ add_str:
+ $S1 = substr $S0, start_pos, end_pos
+ retv.'push'($S1)
+ unless match goto done
+ $I0 = match.'to'()
+ if $I0 == start_pos goto zero_width
+ start_pos = $I0
+ goto loop
+ zero_width:
+ inc start_pos
+ goto loop
+
+ done:
+ .return(retv)
+.end
+
+.sub 'list'
+ .param pmc l :slurpy
+ .return (l)
+.end
+
+.sub 'sprintf'
+ .param string format
+ .param pmc args :slurpy
+
+ $S0 = sprintf format, args
+ .return($S0)
+.end
+
+.sub 'say'
+ .param string arg
+ say arg
+.end
+
+# Local Variables:
+# mode: pir
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=pir:
Modified: trunk/compilers/pct/Rules.mak
==============================================================================
--- trunk/compilers/pct/Rules.mak Sun May 23 21:12:16 2010 (r46921)
+++ trunk/compilers/pct/Rules.mak Sun May 23 21:38:28 2010 (r46922)
@@ -4,7 +4,7 @@
$(LIBRARY_DIR)/PCT/Grammar.pbc $(LIBRARY_DIR)/PCT/PAST.pbc
$(PARROT) -o $@ compilers/pct/PCT.pir
-$(LIBRARY_DIR)/PCT/PAST.pbc : compilers/pct/src/PAST.pir $(PARROT) \
+$(LIBRARY_DIR)/PCT/PAST.pbc : compilers/pct/src/PAST.pir $(PARROT) $(PBC_MERGE) \
$(LIBRARY_DIR)/PCT/HLLCompiler.pbc \
compilers/pct/src/PCT/Node.pbc \
compilers/pct/src/PAST/Node.pbc \
Modified: trunk/config/auto/extra_nci_thunks.pm
==============================================================================
--- trunk/config/auto/extra_nci_thunks.pm Sun May 23 21:12:16 2010 (r46921)
+++ trunk/config/auto/extra_nci_thunks.pm Sun May 23 21:38:28 2010 (r46922)
@@ -1,4 +1,3 @@
-#! perl
# Copyright (C) 2010, Parrot Foundation.
# $Id$
Modified: trunk/config/gen/makefiles/root.in
==============================================================================
--- trunk/config/gen/makefiles/root.in Sun May 23 21:12:16 2010 (r46921)
+++ trunk/config/gen/makefiles/root.in Sun May 23 21:38:28 2010 (r46922)
@@ -125,6 +125,7 @@
include compilers/tge/Defines.mak
include compilers/pge/Defines.mak
include compilers/pct/Defines.mak
+include compilers/opsc/Defines.mak
include ext/nqp-rx/Defines.mak
include compilers/data_json/Defines.mak
@@ -172,8 +173,7 @@
config_lib.pir \
parrot.pc \
compilers/imcc/imcc.y.flag \
- compilers/imcc/imcc.l.flag \
- src/ops/core_ops.c
+ compilers/imcc/imcc.l.flag
GEN_PASM_INCLUDES = \
runtime/parrot/include/cclass.pasm \
@@ -233,17 +233,12 @@
#
###############################################################################
-GEN_OPSFILES =
-
GEN_HEADERS = \
$(INC_DIR)/vtable.h \
- $(INC_DIR)/oplib/core_ops.h \
- $(INC_DIR)/oplib/ops.h \
$(INC_DIR)/extend_vtable.h \
$(INC_DIR)/pbcversion.h
GEN_SOURCES = \
- src/core_ops.c \
src/nci.c \
src/glut_nci_thunks.c \
src/parrot_config.c \
@@ -253,7 +248,6 @@
src/extra_nci_thunks.c
GEN_MODULES = \
- lib/Parrot/OpLib/core.pm
GEN_LIBRARY = \
$(LIBRARY_DIR)/Archive/Tar.pbc \
@@ -335,7 +329,6 @@
$(LIBRARY_DIR)/postgres.pbc
FLUID_FILES_1 = \
- $(GEN_OPSFILES) \
$(GEN_HEADERS) \
$(GEN_SOURCES) \
$(GEN_MODULES) \
@@ -357,61 +350,61 @@
# parrot.h and all the includes it causes to be included
PARROT_H_HEADERS = \
- $(INC_DIR)/parrot.h \
- $(INC_DIR)/config.h \
- $(INC_DIR)/settings.h \
- $(INC_DIR)/enums.h \
- $(INC_DIR)/platform.h \
- $(INC_DIR)/platform_interface.h \
- $(INC_DIR)/global_setup.h \
- $(INC_DIR)/caches.h \
- $(INC_DIR)/interpreter.h \
- $(INC_DIR)/datatypes.h \
- $(INC_DIR)/encoding.h \
- $(INC_DIR)/charset.h \
- $(INC_DIR)/string.h \
- $(INC_DIR)/string_primitives.h \
- $(INC_DIR)/hash.h \
- $(INC_DIR)/pmc_freeze.h \
- $(INC_DIR)/vtable.h \
- $(INC_DIR)/context.h \
- $(INC_DIR)/exceptions.h \
- $(INC_DIR)/warnings.h \
- $(INC_DIR)/memory.h \
- $(INC_DIR)/packfile.h \
- $(INC_DIR)/io.h \
- $(INC_DIR)/op.h \
- $(INC_DIR)/pmc.h \
- $(INC_DIR)/gc_api.h \
- $(INC_DIR)/string_funcs.h \
- $(INC_DIR)/misc.h \
- $(INC_DIR)/sub.h \
- $(INC_DIR)/call.h \
- $(INC_DIR)/key.h \
- $(INC_DIR)/exit.h \
- $(INC_DIR)/nci.h \
- $(INC_DIR)/thread.h \
- $(INC_DIR)/scheduler.h \
- $(INC_DIR)/longopt.h \
- $(INC_DIR)/oo.h \
- $(INC_DIR)/vtables.h \
- $(INC_DIR)/multidispatch.h \
- $(INC_DIR)/library.h \
- $(INC_DIR)/global.h \
- $(INC_DIR)/stat.h \
- $(INC_DIR)/hll.h \
- $(INC_DIR)/pbcversion.h \
- $(INC_DIR)/pobj.h \
- $(INC_DIR)/platform_limits.h \
- $(INC_DIR)/has_header.h \
- $(INC_DIR)/oplib.h \
- $(INC_DIR)/feature.h \
- $(INC_DIR)/debugger.h \
- $(INC_DIR)/core_types.h \
- $(INC_DIR)/core_pmcs.h \
- $(INC_DIR)/compiler.h \
- $(INC_DIR)/cclass.h \
- include/pmc/pmc_callcontext.h
+ $(INC_DIR)/parrot.h \
+ $(INC_DIR)/config.h \
+ $(INC_DIR)/settings.h \
+ $(INC_DIR)/enums.h \
+ $(INC_DIR)/platform.h \
+ $(INC_DIR)/platform_interface.h \
+ $(INC_DIR)/global_setup.h \
+ $(INC_DIR)/caches.h \
+ $(INC_DIR)/interpreter.h \
+ $(INC_DIR)/datatypes.h \
+ $(INC_DIR)/encoding.h \
+ $(INC_DIR)/charset.h \
+ $(INC_DIR)/string.h \
+ $(INC_DIR)/string_primitives.h \
+ $(INC_DIR)/hash.h \
+ $(INC_DIR)/pmc_freeze.h \
+ $(INC_DIR)/vtable.h \
+ $(INC_DIR)/context.h \
+ $(INC_DIR)/exceptions.h \
+ $(INC_DIR)/warnings.h \
+ $(INC_DIR)/memory.h \
+ $(INC_DIR)/packfile.h \
+ $(INC_DIR)/io.h \
+ $(INC_DIR)/op.h \
+ $(INC_DIR)/pmc.h \
+ $(INC_DIR)/gc_api.h \
+ $(INC_DIR)/string_funcs.h \
+ $(INC_DIR)/misc.h \
+ $(INC_DIR)/sub.h \
+ $(INC_DIR)/call.h \
+ $(INC_DIR)/key.h \
+ $(INC_DIR)/exit.h \
+ $(INC_DIR)/nci.h \
+ $(INC_DIR)/thread.h \
+ $(INC_DIR)/scheduler.h \
+ $(INC_DIR)/longopt.h \
+ $(INC_DIR)/oo.h \
+ $(INC_DIR)/vtables.h \
+ $(INC_DIR)/multidispatch.h \
+ $(INC_DIR)/library.h \
+ $(INC_DIR)/global.h \
+ $(INC_DIR)/stat.h \
+ $(INC_DIR)/hll.h \
+ $(INC_DIR)/pbcversion.h \
+ $(INC_DIR)/pobj.h \
+ $(INC_DIR)/platform_limits.h \
+ $(INC_DIR)/has_header.h \
+ $(INC_DIR)/oplib.h \
+ $(INC_DIR)/feature.h \
+ $(INC_DIR)/debugger.h \
+ $(INC_DIR)/core_types.h \
+ $(INC_DIR)/core_pmcs.h \
+ $(INC_DIR)/compiler.h \
+ $(INC_DIR)/cclass.h \
+ include/pmc/pmc_callcontext.h
# generated list of header files
GENERAL_H_FILES = $(NONGEN_HEADERS) $(GEN_HEADERS) \
@@ -504,7 +497,7 @@
#IF(platform_asm): src/platform_asm$(O) \
-OPS_FILES = @ops@ $(GEN_OPSFILES)
+OPS_FILES = @ops@
###############################################################################
#
@@ -525,6 +518,7 @@
NQP_RX = . at slash@parrot-nqp$(EXE)
NCI_THUNK_GEN = . at slash@parrot_nci_thunk_gen$(EXE)
PROVE = . at slash@parrot-prove$(EXE)
+OPS2C = . at slash@ops2c$(EXE)
# Installable executables
INSTALLABLEPARROT = . at slash@installable_parrot$(EXE)
@@ -537,6 +531,7 @@
INSTALLABLENQP = . at slash@installable_parrot-nqp$(EXE)
INSTALLABLENCITHUNKGEN = . at slash@installable_parrot_nci_thunk_gen$(EXE)
INSTALLABLEPROVE = . at slash@installable_parrot-prove$(EXE)
+INSTALLABLEOPS2C = . at slash@installable_ops2c$(EXE)
# Libraries
LIBPARROT_STATIC = @blib_dir@/@libparrot_static@
@@ -619,6 +614,7 @@
$(DATA_JSON_LIB_PBCS) \
$(NQP_LIB_PBCS) \
$(GEN_LIBRARY) \
+ $(DYNOPLIBS_TARGETS) \
$(LIBNCI_TEST_SO)
corevm : \
@@ -628,8 +624,7 @@
runtime/parrot/include/parrotlib.pbc \
runtime/parrot/include/config.fpmc \
$(LIBRARY_DIR)/Test/More.pbc \
- $(DYNPMC_TARGETS) \
- $(DYNOPLIBS_TARGETS)
+ $(DYNPMC_TARGETS)
$(GEN_LIBRARY) : $(PARROT) $(GEN_PASM_INCLUDES)
@@ -798,10 +793,13 @@
world : all parrot_utils
-parrot_utils : $(PDUMP) $(DIS) $(PDB) $(PBC_MERGE) $(PBC_TO_EXE) $(PARROT_CONFIG) src/install_config$(O) $(PROVE)
+parrot_utils : $(PDUMP) $(DIS) $(PDB) $(PBC_MERGE) $(PBC_TO_EXE) $(PARROT_CONFIG) src/install_config$(O) $(PROVE) $(OPS2C)
-installable: all $(INSTALLABLEPARROT) $(INSTALLABLEPDUMP) $(INSTALLABLEDIS) $(INSTALLABLEPDB) $(INSTALLABLEPBC_MERGE) $(INSTALLABLEPBCTOEXE) $(INSTALLABLECONFIG) $(INSTALLABLENQP) $(INSTALLABLENCITHUNKGEN) $(INSTALLABLEPROVE)
+installable: all $(INSTALLABLEPARROT) $(INSTALLABLEPDUMP) $(INSTALLABLEDIS) $(INSTALLABLEPDB) $(INSTALLABLEPBC_MERGE) $(INSTALLABLEPBCTOEXE) $(INSTALLABLECONFIG) $(INSTALLABLENQP) $(INSTALLABLENCITHUNKGEN) $(INSTALLABLEPROVE) $(INSTALLABLEOPS2C)
+bootstrap-ops : $(OPS2C)
+ $(OPS2C) --core
+ $(MAKE) .
runtime/parrot/include/parrotlib.pbc: runtime/parrot/library/parrotlib.pir $(PARROT) $(GEN_PASM_INCLUDES)
$(PARROT) -o $@ runtime/parrot/library/parrotlib.pir
@@ -811,7 +809,7 @@
$(MINIPARROT) -Iruntime/parrot/include config_lib.pir > $@
$(PARROT) : src/main$(O) $(GEN_HEADERS) $(LIBPARROT) \
- lib/Parrot/OpLib/core.pm src/parrot_config$(O) \
+ src/parrot_config$(O) \
$(MINIPARROT)
$(LINK) @ld_out@$@ \
src/main$(O) src/parrot_config$(O) \
@@ -839,13 +837,13 @@
$(PARROT) pbc_to_exe.pbc parrot_config.pbc
$(MINIPARROT) : src/main$(O) $(GEN_HEADERS) $(LIBPARROT) \
- lib/Parrot/OpLib/core.pm src/null_config$(O)
+ src/null_config$(O)
$(LINK) @ld_out@$@ src/main$(O) src/null_config$(O) \
@rpath_blib@ $(ALL_PARROT_LIBS) $(LINKFLAGS)
#IF(win32): if exist $@.manifest mt.exe -nologo -manifest $@.manifest -outputresource:$@;1
$(INSTALLABLEPARROT) : src/main$(O) $(GEN_HEADERS) $(LIBPARROT) \
- lib/Parrot/OpLib/core.pm src/install_config$(O) \
+ src/install_config$(O) \
$(PARROT)
$(LINK) @ld_out@$@ \
src/main$(O) src/install_config$(O) \
@@ -885,10 +883,10 @@
include/pmc/pmc_object.h src/oo.str $(INC_DIR)/oo_private.h
src/scheduler$(O) : $(PARROT_H_HEADERS) src/scheduler.str src/scheduler.c \
- include/pmc/pmc_scheduler.h include/pmc/pmc_task.h \
- include/pmc/pmc_timer.h \
- $(INC_DIR)/scheduler_private.h \
- $(INC_DIR)/runcore_api.h
+ include/pmc/pmc_scheduler.h include/pmc/pmc_task.h \
+ include/pmc/pmc_timer.h \
+ $(INC_DIR)/scheduler_private.h \
+ $(INC_DIR)/runcore_api.h
src/io/core$(O) : $(PARROT_H_HEADERS) src/io/io_private.h src/io/core.c
@@ -899,9 +897,9 @@
src/io/io_private.h src/io/socket_unix.c
src/io/socket_win32$(O) : $(PARROT_H_HEADERS) \
- src/io/io_private.h \
- include/pmc/pmc_socket.h \
- src/io/socket_win32.c
+ src/io/io_private.h \
+ include/pmc/pmc_socket.h \
+ src/io/socket_win32.c
O_FILES = \
$(INTERP_O_FILES) \
@@ -962,17 +960,17 @@
#
src/parrot_debugger$(O) : $(INC_DIR)/embed.h \
- src/parrot_debugger.c \
- $(INC_DIR)/runcore_api.h \
- compilers/imcc/imc.h $(PARROT_H_HEADERS) compilers/imcc/parser.h \
- compilers/imcc/cfg.h \
- compilers/imcc/debug.h \
- compilers/imcc/imcparser.h \
- compilers/imcc/instructions.h \
- compilers/imcc/sets.h \
- compilers/imcc/symreg.h \
- compilers/imcc/unit.h \
- $(INC_DIR)/oplib/ops.h
+ src/parrot_debugger.c \
+ $(INC_DIR)/runcore_api.h \
+ compilers/imcc/imc.h $(PARROT_H_HEADERS) compilers/imcc/parser.h \
+ compilers/imcc/cfg.h \
+ compilers/imcc/debug.h \
+ compilers/imcc/imcparser.h \
+ compilers/imcc/instructions.h \
+ compilers/imcc/sets.h \
+ compilers/imcc/symreg.h \
+ compilers/imcc/unit.h \
+ $(INC_DIR)/oplib/ops.h
$(PDB) : src/parrot_debugger$(O) src/parrot_config$(O) $(LIBPARROT)
$(LINK) @ld_out@$@ \
@@ -1021,7 +1019,7 @@
#IF(win32): if exist $@.manifest mt.exe -nologo -manifest $@.manifest -outputresource:$@;1
src/pbc_dump$(O) : $(INC_DIR)/embed.h $(INC_DIR)/oplib/ops.h \
- $(PARROT_H_HEADERS) src/pbc_dump.c
+ $(PARROT_H_HEADERS) src/pbc_dump.c
$(INSTALLABLEPDUMP) : src/pbc_dump$(O) src/packdump$(O) \
src/install_config$(O) $(LIBPARROT)
@@ -1180,15 +1178,6 @@
$(PERL) $(H2INC) src/utils.c $@
-# ops.h is built by ops2pm.pl after it builds core.pm
-$(INC_DIR)/oplib/ops.h: lib/Parrot/OpLib/core.pm
-
-$(BUILD_TOOLS_DIR)/ops2c.pl: lib/Parrot/OpLib/core.pm
-
-lib/Parrot/OpLib/core.pm : $(OPS_FILES) $(BUILD_TOOLS_DIR)/ops2pm.pl \
- lib/Parrot/OpsFile.pm lib/Parrot/Op.pm src/ops/ops.num src/ops/ops.skip
- $(PERL) $(BUILD_TOOLS_DIR)/ops2pm.pl @no_lines_flag@ $(OPS_FILES)
-
###############################################################################
#
# Examples (Assembly):
@@ -1234,7 +1223,7 @@
src/datatypes$(O) : $(PARROT_H_HEADERS) src/datatypes.c
src/extend_vtable$(O) : $(PARROT_H_HEADERS) \
- $(INC_DIR)/extend.h $(INC_DIR)/extend_vtable.h src/extend_vtable.c
+ $(INC_DIR)/extend.h $(INC_DIR)/extend_vtable.h src/extend_vtable.c
src/global_setup$(O) : $(PARROT_H_HEADERS) src/global_setup.str src/global_setup.c
@@ -1249,13 +1238,13 @@
src/hash$(O) : $(PARROT_H_HEADERS) include/pmc/pmc_key.h src/hash.c
src/library$(O) : $(PARROT_H_HEADERS) src/library.str src/library.c\
- $(INC_DIR)/dynext.h
+ $(INC_DIR)/dynext.h
$(INC_DIR)/extend_vtable.h src/extend_vtable.c src/vtable.h : src/vtable.tbl $(BUILD_TOOLS_DIR)/vtable_extend.pl lib/Parrot/Vtable.pm
$(PERL) $(BUILD_TOOLS_DIR)/vtable_extend.pl
src/key$(O) : $(PARROT_H_HEADERS) src/key.str src/key.c \
- include/pmc/pmc_key.h
+ include/pmc/pmc_key.h
src/gc/mark_sweep$(O) : $(PARROT_H_HEADERS) src/gc/gc_private.h src/gc/mark_sweep.c
@@ -1266,7 +1255,7 @@
src/gc/api$(O) : $(PARROT_H_HEADERS) src/gc/gc_private.h src/gc/api.c
src/gc/alloc_resources$(O) : $(PARROT_H_HEADERS) \
- src/gc/gc_private.h src/gc/alloc_resources.c
+ src/gc/gc_private.h src/gc/alloc_resources.c
src/hll$(O) : $(PARROT_H_HEADERS) src/hll.str $(INC_DIR)/dynext.h src/hll.c
@@ -1277,37 +1266,37 @@
src/core_pmcs$(O) : $(PARROT_H_HEADERS) src/core_pmcs.c
src/runcore/trace$(O) : include/pmc/pmc_sub.h src/runcore/trace.c \
- $(INC_DIR)/oplib/ops.h $(INC_DIR)/runcore_trace.h \
- $(PARROT_H_HEADERS)
+ $(INC_DIR)/oplib/ops.h $(INC_DIR)/runcore_trace.h \
+ $(PARROT_H_HEADERS)
src/debug$(O) : $(INC_DIR)/embed.h $(INC_DIR)/extend.h \
- $(PARROT_H_HEADERS) src/debug.c \
- $(INC_DIR)/oplib/ops.h \
- $(INC_DIR)/runcore_api.h $(INC_DIR)/runcore_trace.h \
- src/debug.str include/pmc/pmc_key.h \
- include/pmc/pmc_continuation.h \
- $(INC_DIR)/extend_vtable.h
+ $(PARROT_H_HEADERS) src/debug.c \
+ $(INC_DIR)/oplib/ops.h \
+ $(INC_DIR)/runcore_api.h $(INC_DIR)/runcore_trace.h \
+ src/debug.str include/pmc/pmc_key.h \
+ include/pmc/pmc_continuation.h \
+ $(INC_DIR)/extend_vtable.h
src/sub$(O) : $(PARROT_H_HEADERS) $(INC_DIR)/oplib/ops.h \
- src/sub.str src/sub.c \
+ src/sub.str src/sub.c \
include/pmc/pmc_sub.h include/pmc/pmc_continuation.h
src/string/api$(O) : $(PARROT_H_HEADERS) src/string/api.str \
- src/string/private_cstring.h src/string/api.c
+ src/string/private_cstring.h src/string/api.c
src/string/primitives$(O) : $(PARROT_H_HEADERS) src/string/primitives.c
src/longopt$(O) : $(PARROT_H_HEADERS) src/longopt.c
src/dynext$(O) : $(PARROT_H_HEADERS) $(INC_DIR)/dynext.h \
- src/dynext.str include/pmc/pmc_parrotlibrary.h src/dynext.c
+ src/dynext.str include/pmc/pmc_parrotlibrary.h src/dynext.c
src/exceptions$(O) : $(PARROT_H_HEADERS) \
- src/exceptions.str src/exceptions.c \
+ src/exceptions.str src/exceptions.c \
include/pmc/pmc_continuation.h
src/thread$(O) : $(PARROT_H_HEADERS) $(INC_DIR)/atomic.h src/thread.c \
- include/pmc/pmc_sub.h \
+ include/pmc/pmc_sub.h \
include/pmc/pmc_parrotinterpreter.h \
$(INC_DIR)/runcore_api.h
@@ -1320,31 +1309,31 @@
src/runcore/main.c \
src/runcore/main.str \
include/pmc/pmc_parrotlibrary.h \
- $(INC_DIR)/dynext.h $(INC_DIR)/oplib/core_ops.h \
- $(INC_DIR)/oplib/ops.h \
- $(PARROT_H_HEADERS) $(INC_DIR)/runcore_api.h \
- $(INC_DIR)/runcore_profiling.h
+ $(INC_DIR)/dynext.h $(INC_DIR)/oplib/core_ops.h \
+ $(INC_DIR)/oplib/ops.h \
+ $(PARROT_H_HEADERS) $(INC_DIR)/runcore_api.h \
+ $(INC_DIR)/runcore_profiling.h
src/runcore/profiling$(O) : src/runcore/profiling.str src/runcore/profiling.c \
include/pmc/pmc_sub.h \
include/pmc/pmc_namespace.h \
- $(INC_DIR)/oplib/core_ops.h $(INC_DIR)/runcore_api.h \
- $(INC_DIR)/runcore_profiling.h $(INC_DIR)/embed.h \
- $(PARROT_H_HEADERS)
+ $(INC_DIR)/oplib/core_ops.h $(INC_DIR)/runcore_api.h \
+ $(INC_DIR)/runcore_profiling.h $(INC_DIR)/embed.h \
+ $(PARROT_H_HEADERS)
src/call/args$(O) : \
- $(PARROT_H_HEADERS) $(INC_DIR)/oplib/ops.h \
+ $(PARROT_H_HEADERS) $(INC_DIR)/oplib/ops.h \
src/call/args.c \
src/call/args.str \
include/pmc/pmc_key.h \
include/pmc/pmc_fixedintegerarray.h
src/call/context_accessors$(O): $(PARROT_H_HEADERS) \
- src/call/context_accessors.c
+ src/call/context_accessors.c
src/call/pcc$(O) : $(INC_DIR)/oplib/ops.h \
- $(PARROT_H_HEADERS) \
- $(INC_DIR)/runcore_api.h \
+ $(PARROT_H_HEADERS) \
+ $(INC_DIR)/runcore_api.h \
src/call/pcc.c \
src/call/pcc.str \
include/pmc/pmc_key.h include/pmc/pmc_continuation.h
@@ -1353,12 +1342,12 @@
include/pmc/pmc_sub.h src/call/context.c
src/interp/inter_cb$(O) : $(PARROT_H_HEADERS) \
- include/pmc/pmc_parrotinterpreter.h \
+ include/pmc/pmc_parrotinterpreter.h \
src/interp/inter_cb.str src/interp/inter_cb.c
src/interp/inter_misc$(O) : $(PARROT_H_HEADERS) \
- src/interp/inter_misc.c \
- src/interp/inter_misc.str \
+ src/interp/inter_misc.c \
+ src/interp/inter_misc.str \
compilers/imcc/imc.h \
compilers/imcc/cfg.h \
compilers/imcc/debug.h \
@@ -1366,14 +1355,14 @@
compilers/imcc/sets.h \
compilers/imcc/symreg.h \
compilers/imcc/unit.h \
- $(INC_DIR)/oplib/ops.h \
- $(INC_DIR)/runcore_api.h
+ $(INC_DIR)/oplib/ops.h \
+ $(INC_DIR)/runcore_api.h
src/interp/inter_create$(O) : $(PARROT_H_HEADERS) \
$(INC_DIR)/oplib/core_ops.h \
src/gc/gc_private.h \
- src/interp/inter_create.c \
- src/interp/inter_create.str \
+ src/interp/inter_create.c \
+ src/interp/inter_create.str \
compilers/imcc/imc.h \
compilers/imcc/cfg.h \
compilers/imcc/debug.h \
@@ -1381,19 +1370,19 @@
compilers/imcc/sets.h \
compilers/imcc/symreg.h \
compilers/imcc/unit.h \
- $(INC_DIR)/oplib/ops.h \
- $(INC_DIR)/runcore_api.h
+ $(INC_DIR)/oplib/ops.h \
+ $(INC_DIR)/runcore_api.h
src/call/ops$(O) : $(INC_DIR)/oplib/ops.h \
$(PARROT_H_HEADERS) include/pmc/pmc_continuation.h \
- $(INC_DIR)/runcore_api.h src/call/ops.c
+ $(INC_DIR)/runcore_api.h src/call/ops.c
src/io/api$(O) : $(PARROT_H_HEADERS) src/io/io_private.h \
- src/io/api.c \
- src/io/api.str include/pmc/pmc_filehandle.h \
- include/pmc/pmc_stringhandle.h \
- $(INC_DIR)/extend.h \
- $(INC_DIR)/extend_vtable.h
+ src/io/api.c \
+ src/io/api.str include/pmc/pmc_filehandle.h \
+ include/pmc/pmc_stringhandle.h \
+ $(INC_DIR)/extend.h \
+ $(INC_DIR)/extend_vtable.h
src/io/buffer$(O) : $(PARROT_H_HEADERS) src/io/io_private.h src/io/buffer.c
@@ -1411,28 +1400,28 @@
src/gc/alloc_memory$(O) : $(PARROT_H_HEADERS) src/gc/alloc_memory.c
src/main$(O) : $(INC_DIR)/imcc.h $(PARROT_H_HEADERS) \
- $(INC_DIR)/embed.h $(INC_DIR)/runcore_api.h src/gc/gc_private.h \
- src/main.c
+ $(INC_DIR)/embed.h $(INC_DIR)/runcore_api.h src/gc/gc_private.h \
+ src/main.c
src/multidispatch$(O) : \
- src/multidispatch.c \
- src/multidispatch.str \
- $(INC_DIR)/oplib/ops.h $(PARROT_H_HEADERS) \
+ src/multidispatch.c \
+ src/multidispatch.str \
+ $(INC_DIR)/oplib/ops.h $(PARROT_H_HEADERS) \
include/pmc/pmc_nci.h include/pmc/pmc_sub.h
src/packfile$(O) : src/packfile.str \
- src/packfile.c \
+ src/packfile.c \
include/pmc/pmc_sub.h include/pmc/pmc_key.h \
- compilers/imcc/imc.h \
+ compilers/imcc/imc.h \
compilers/imcc/cfg.h \
compilers/imcc/debug.h \
compilers/imcc/instructions.h \
compilers/imcc/sets.h \
compilers/imcc/symreg.h \
compilers/imcc/unit.h \
- $(INC_DIR)/oplib/ops.h \
- $(INC_DIR)/embed.h $(INC_DIR)/extend.h $(INC_DIR)/extend_vtable.h \
- $(PARROT_H_HEADERS) $(INC_DIR)/runcore_api.h
+ $(INC_DIR)/oplib/ops.h \
+ $(INC_DIR)/embed.h $(INC_DIR)/extend.h $(INC_DIR)/extend_vtable.h \
+ $(PARROT_H_HEADERS) $(INC_DIR)/runcore_api.h
src/packfile/pf_items$(O) : $(PARROT_H_HEADERS) src/packfile/pf_items.c
@@ -1441,12 +1430,12 @@
src/parrot$(O) : $(GENERAL_H_FILES)
src/runcore/cores$(O) : src/runcore/cores.str \
- src/runcore/cores.c \
+ src/runcore/cores.c \
include/pmc/pmc_sub.h \
- $(INC_DIR)/dynext.h $(INC_DIR)/embed.h $(INC_DIR)/oplib/core_ops.h \
- $(INC_DIR)/oplib/ops.h \
- $(INC_DIR)/runcore_api.h $(INC_DIR)/runcore_trace.h \
- $(PARROT_H_HEADERS)
+ $(INC_DIR)/dynext.h $(INC_DIR)/embed.h $(INC_DIR)/oplib/core_ops.h \
+ $(INC_DIR)/oplib/ops.h \
+ $(INC_DIR)/runcore_api.h $(INC_DIR)/runcore_trace.h \
+ $(PARROT_H_HEADERS)
src/embed$(O) : $(PARROT_H_HEADERS) $(INC_DIR)/embed.h \
src/embed.c src/embed.str \
@@ -1458,19 +1447,19 @@
compilers/imcc/sets.h \
compilers/imcc/symreg.h \
compilers/imcc/unit.h \
- include/pmc/pmc_sub.h
+ include/pmc/pmc_sub.h
src/dataypes$(O) : $(GENERAL_H_FILES) src/dataypes.c
src/exit$(O) : $(PARROT_H_HEADERS) src/exit.c
src/nci/api$(O) : src/nci/api.str \
- src/nci/api.c \
- $(PARROT_H_HEADERS)
+ src/nci/api.c \
+ $(PARROT_H_HEADERS)
src/nci/core_thunks$(O) : src/nci/core_thunks.c \
- $(PARROT_H_HEADERS) \
- include/pmc/pmc_nci.h
+ $(PARROT_H_HEADERS) \
+ include/pmc/pmc_nci.h
## SUFFIX OVERRIDE
src/nci/extra_thunks$(O) : \
@@ -1480,11 +1469,11 @@
$(CC) $(CFLAGS) @optimize::src/nci/extra_thunks.c@ @ccwarn::src/nci/extra_thunks.c@ @cc_shared@ -I$(@D) @cc_o_out@$@ -c src/nci/extra_thunks.c
src/frame_builder$(O) : $(PARROT_H_HEADERS) src/frame_builder.h \
- src/frame_builder.c \
- include/pmc/pmc_fixedintegerarray.h \
- include/pmc/pmc_unmanagedstruct.h \
- include/pmc/pmc_managedstruct.h \
- $(INC_DIR)/oplib/ops.h
+ src/frame_builder.c \
+ include/pmc/pmc_fixedintegerarray.h \
+ include/pmc/pmc_unmanagedstruct.h \
+ include/pmc/pmc_managedstruct.h \
+ $(INC_DIR)/oplib/ops.h
src/vtables$(O) : $(PARROT_H_HEADERS) src/vtables.c
@@ -1511,14 +1500,14 @@
src/string/encoding$(O) : $(PARROT_H_HEADERS) src/string/encoding.c
src/string/charset$(O) : $(PARROT_H_HEADERS) src/string/charset.c \
- src/string/encoding/fixed_8.h \
- src/string/encoding/utf8.h \
- src/string/encoding/utf16.h \
- src/string/encoding/ucs2.h \
- src/string/charset/ascii.h \
- src/string/charset/binary.h \
- src/string/charset/iso-8859-1.h \
- src/string/charset/unicode.h
+ src/string/encoding/fixed_8.h \
+ src/string/encoding/utf8.h \
+ src/string/encoding/utf16.h \
+ src/string/encoding/ucs2.h \
+ src/string/charset/ascii.h \
+ src/string/charset/binary.h \
+ src/string/charset/iso-8859-1.h \
+ src/string/charset/unicode.h
src/pbc_merge$(O) : $(INC_DIR)/embed.h src/pbc_merge.c \
include/pmc/pmc_sub.h $(INC_DIR)/oplib/ops.h $(PARROT_H_HEADERS)
@@ -1545,15 +1534,6 @@
include/pmc/pmc_parrotlibrary.h \
src/io/io_private.h
-# .h files are built along with .c
-$(INC_DIR)/oplib/core_ops.h: src/ops/core_ops.c
-
-src/ops/core_ops.c : $(OPS_FILES) $(BUILD_TOOLS_DIR)/ops2c.pl \
- lib/Parrot/OpsFile.pm lib/Parrot/Op.pm $(INC_DIR)/config.h \
- lib/Parrot/OpLib/core.pm lib/Parrot/OpTrans/C.pm \
- include/pmc/pmc_continuation.h
- $(PERL) $(BUILD_TOOLS_DIR)/ops2c.pl C --core @no_lines_flag@
-
@TEMP_gc_c@
@TEMP_pmc_build@
@@ -1661,13 +1641,9 @@
t/tools/*.t
LIBRARY_TEST_FILES = @library_tests@
PMC2CUTILS_DIR = t/tools/pmc2cutils
-OPS2PMUTILS_DIR = t/tools/ops2pm
-OPS2CUTILS_DIR = t/tools/ops2cutils
HARNESS_DIR = t/pharness
BUILDTOOLS_TEST_FILES = \
$(PMC2CUTILS_DIR)/*.t \
- $(OPS2PMUTILS_DIR)/*.t \
- $(OPS2CUTILS_DIR)/*.t \
$(HARNESS_DIR)/*.t
MANIFEST_DIR = t/manifest
INSTALL_TOOLS_DIR = t/tools/install
@@ -1834,7 +1810,6 @@
ext-clean \
#UNLESS(win32): cover-clean \
editor-clean
- $(RM_F) $(INC_DIR)/oplib/core_ops_cg.h src/ops/core_ops_cg.c
$(RM_F) chartypes "*.s" "*~"
$(RM_F) $(FLUID_FILES_1)
$(RM_F) $(FLUID_FILES_2)
@@ -1844,7 +1819,7 @@
$(RM_F) $(PIRC_CLEANUPS) $(PCT_CLEANUPS) $(DATA_JSON_CLEANUPS)
$(RM_F) $(DYNOPLIBS_CLEANUPS) $(DYNPMC_CLEANUPS)
$(RM_F) $(GEN_PASM_INCLUDES) $(GEN_PM_INCLUDES)
- $(RM_F) $(NQPRX_CLEANUPS)
+ $(RM_F) $(NQPRX_CLEANUPS) $(OPSC_CLEANUPS)
prog-clean :
$(RM_F) \
@@ -1852,6 +1827,7 @@
$(PARROT) \
$(MINIPARROT) \
$(LIBPARROT) \
+ $(INSTALLABLEOPS2C) \
$(INSTALLABLEPARROT) \
$(INSTALLABLEDIS) \
$(INSTALLABLEPDUMP) \
@@ -1864,6 +1840,7 @@
$(INSTALLABLEPROVE) \
pbc_to_exe.pbc pbc_to_exe.c pbc_to_exe$(O) pbc_to_exe$(EXE) \
$(NCI_THUNK_GEN) parrot_nci_thunk_gen.c parrot_nci_thunk_gen$(O) parrot_nci_thunk_gen.pbc \
+ ops2c.pbc ops2c.c ops2c$(O) ops2c$(EXE) ops2c.pir \
parrot-prove.pbc parrot-prove.c parrot-prove$(O) parrot-prove$(EXE) \
parrot_config$(EXE) parrot_config.c parrot_config$(O) parrot_config.pbc \
compilers/imcc/main$(O) \
@@ -1946,20 +1923,14 @@
# XXX Is there a danger of too long command lines in the $(RM_F) commands,
# or is there an automatic xargs?
test-clean :
- $(RM_F) \
- "t/compilers/*/*.out" \
- "t/compilers/*/*.pasm" \
- "t/compilers/*/*.pbc" \
- "t/compilers/*/*_pbcexe*" \
- "t/compilers/*/*.pir" \
- "t/compilers/*/*.stabs.s"
- $(RM_F) \
- "t/compilers/*/*/*.out" \
- "t/compilers/*/*/*.pasm" \
- "t/compilers/*/*/*.pbc" \
- "t/compilers/*/*/*_pbcexe*" \
- "t/compilers/*/*/*.pir" \
- "t/compilers/*/*/*.stabs.s"
+ $(RM_F) t/compilers/data_json/*.pir
+ $(RM_F) t/compilers/imcc/imcpasm/*.pir
+ $(RM_F) t/compilers/imcc/syn/*.pir t/compilers/imcc/syn/*.pasm
+ $(RM_F) t/compilers/imcc/reg/*.pir t/compilers/imcc/reg/*.pasm
+ $(RM_F) t/compilers/pct/*.pir
+ $(RM_F) t/compilers/pge/perl6regex/*.pir
+ $(RM_F) t/compilers/pge/*.pir
+ $(RM_F) t/compilers/tge/*.pir
$(RM_F) \
"t/*/*$(O)" \
"t/*/*.out" \
@@ -2301,10 +2272,10 @@
build_dir=$$PWD; \
for dir in $(COVER_DIRS); \
do \
- cd $$dir; \
- gcov *.c; \
- cd $$build_dir; \
- gcov2perl $$dir/*.gcov; \
+ cd $$dir; \
+ gcov *.c; \
+ cd $$build_dir; \
+ gcov2perl $$dir/*.gcov; \
done
cover -ignore_re '^\/usr\/local\/bin'
@@ -2418,7 +2389,7 @@
$(PERL) -lane 'print"parrot-$(VERSION)/$$F[0]"unless!length||/#/' MANIFEST | \
tar -zcv -T - -f parrot-$(VERSION).tar.gz
$(PERL) -lane 'print"parrot-$(VERSION)/$$F[0]"unless!length||/#/' \
- MANIFEST | tar -jcv -T - -f parrot-$(VERSION).tar.bz2
+ MANIFEST | tar -jcv -T - -f parrot-$(VERSION).tar.bz2
mv MANIFEST.real MANIFEST
rm parrot-$(VERSION)
@@ -2452,10 +2423,10 @@
src/glut_nci_thunks.c: $(NCI_THUNK_GEN)
$(NCI_THUNK_GEN) \
- --loader-name=Parrot_glut_nci_loader \
- --loader-storage-class=PARROT_DYNEXT_EXPORT \
- --output=src/glut_nci_thunks.c \
- <src/glut_nci_thunks.nci
+ --loader-name=Parrot_glut_nci_loader \
+ --loader-storage-class=PARROT_DYNEXT_EXPORT \
+ --output=src/glut_nci_thunks.c \
+ <src/glut_nci_thunks.nci
src/glut_nci_thunks$(O) : $(PARROT_H_HEADERS) \
src/glut_nci_thunks.c \
@@ -2468,7 +2439,7 @@
src/extra_nci_thunks.c : src/nci/extra_thunks.nci $(NCI_THUNK_GEN)
$(NCI_THUNK_GEN) --dynext --no-warn-dups \
- --output=src/extra_nci_thunks.c <src/nci/extra_thunks.nci
+ --output=src/extra_nci_thunks.c <src/nci/extra_thunks.nci
## SUFFIX OVERRIDE
src/extra_nci_thunks$(O) : $(PARROT_H_HEADERS) src/extra_nci_thunks.c \
@@ -2486,17 +2457,17 @@
tags-emacs: tags.emacs.dummy
$(RM_F) TAGS
@ctags@ -e \
- --links=no --totals \
- -R --exclude=blib --exclude=.svn \
- --languages=c,perl --langmap=c:+.h,c:+.pmc,c:+.ops \
- -I NOTNULL,NULLOK,ARGIN,ARGMOD,ARGOUT,ARGINOUT,ARGIN_NULLOK,ARGOUT_NULLOK,ARGMOD_NULLOK,ARGFREE,ARGFREE_NOTNULL \
- .
+ --links=no --totals \
+ -R --exclude=blib --exclude=.svn \
+ --languages=c,perl --langmap=c:+.h,c:+.pmc,c:+.ops \
+ -I NOTNULL,NULLOK,ARGIN,ARGMOD,ARGOUT,ARGINOUT,ARGIN_NULLOK,ARGOUT_NULLOK,ARGMOD_NULLOK,ARGFREE,ARGFREE_NOTNULL \
+ .
# this works with an old etags (XEmacs 21.5*)
tags-xemacs: tags.emacs.dummy
$(RM_F) TAGS
find . \
- -name \*.c -o -name \*.h -o -name \*.pmc -o -name \*.ops | etags -l c - -o TAGS
+ -name \*.c -o -name \*.h -o -name \*.pmc -o -name \*.ops | etags -l c - -o TAGS
tags.emacs.dummy:
@@ -2556,6 +2527,7 @@
include compilers/pirc/Rules.mak
include compilers/pge/Rules.mak
include compilers/pct/Rules.mak
+include compilers/opsc/Rules.mak
include compilers/tge/Rules.mak
include compilers/data_json/Rules.mak
include ext/nqp-rx/Rules.mak
Modified: trunk/docs/tests.pod
==============================================================================
--- trunk/docs/tests.pod Sun May 23 21:12:16 2010 (r46921)
+++ trunk/docs/tests.pod Sun May 23 21:38:28 2010 (r46922)
@@ -190,10 +190,9 @@
The files in F<t/postconfigure> are tests for build system. The build tools
tests are intended to be run after someone has made changes in modules such as
-F<lib/Parrot/Pmc2cUtils/>, F<Ops2cUtils/> and F<Ops2pmutils/>. They're set up
-to be run after F<Configure.pl> has completed but before make has been invoked.
-(In fact, they will generate errors if make has completed.) You can run them
-with any of the following:
+F<lib/Parrot/Pmc2cUtils/>. They're set up to be run after F<Configure.pl> has
+completed but before make has been invoked. (In fact, they will generate
+errors if make has completed.) You can run them with any of the following:
perl Configure.pl --test
perl Configure.pl --test=build
Added: trunk/include/parrot/oplib/core_ops.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/include/parrot/oplib/core_ops.h Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,1303 @@
+
+/* $Id$ */
+
+#ifndef PARROT_OPLIB_CORE_OPS_H_GUARD
+#define PARROT_OPLIB_CORE_OPS_H_GUARD
+
+
+/* ex: set ro:
+ * !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
+ *
+ * This file is generated automatically from 'src/ops/core.ops' (and possibly other
+ * .ops files). by ops2c.nqp.
+ *
+ * Any changes made here will be lost!
+ *
+ */
+
+#include "parrot/parrot.h"
+#include "parrot/oplib.h"
+#include "parrot/runcore_api.h"
+
+ op_lib_t *Parrot_DynOp_core_2_4_0(PARROT_INTERP, long init);
+
+ opcode_t * Parrot_end(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_noop(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_check_events(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_check_events__(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_wrapper__(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_load_bytecode_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_load_bytecode_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_load_language_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_load_language_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_branch_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_branch_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_local_branch_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_local_branch_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_local_return_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_jump_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_jump_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_enternative(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_if_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_if_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_if_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_if_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unless_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unless_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unless_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unless_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_invokecc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_invoke_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_yield(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tailcall_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_returncc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_capture_lex_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_newclosure_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_args_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_params_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_returns_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_results_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_result_info_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_result_info_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_result_info_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_addr_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_addr_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_addr_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_addr_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_schedule_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addhandler_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_eh_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_eh_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pop_eh(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_throw_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_throw_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_rethrow_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_count_eh_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_die_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exit_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exit_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_debug_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_debug_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bounds_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bounds_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_profile_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_profile_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trace_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trace_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gc_debug_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gc_debug_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_interpinfo_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_interpinfo_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_interpinfo_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_interpinfo_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_interpinfo_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_interpinfo_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_warningson_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_warningson_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_warningsoff_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_warningsoff_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_errorson_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_errorson_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_errorsoff_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_errorsoff_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_runinterp_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_runinterp_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getinterp_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sweep_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_collect(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sweepoff(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sweepon(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_collectoff(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_collecton(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_needs_destroy_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_loadlib_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_loadlib_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_loadlib_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_loadlib_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_loadlib_p_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_loadlib_p_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dlfunc_p_p_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dlfunc_p_p_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dlfunc_p_p_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dlfunc_p_p_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dlvar_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dlvar_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_compreg_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_compreg_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_compreg_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_compreg_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_callback_p_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_callback_p_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_annotations_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_annotations_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_annotations_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_band_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_s_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_s_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_s_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bands_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnot_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnot_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnot_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnot_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnots_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnots_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnots_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bnots_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bor_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_s_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_s_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_s_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bors_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shl_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shr_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lsr_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_rot_i_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_rot_i_ic_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_rot_i_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxor_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_s_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_s_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_s_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bxors_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_ic_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_n_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_nc_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_n_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_str_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_num_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_addr_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_addr_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_addr_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_addr_sc_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_eq_addr_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_ic_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_n_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_nc_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_n_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_str_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_num_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_addr_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_addr_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_addr_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_addr_sc_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ne_addr_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_ic_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_n_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_nc_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_n_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_str_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_lt_num_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_ic_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_n_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_nc_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_n_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_str_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_le_num_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_str_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gt_num_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_str_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ge_num_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_if_null_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_if_null_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unless_null_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unless_null_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_i_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_str_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_num_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmp_pmc_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_issame_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_issame_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_issame_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_issame_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_issame_i_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isntsame_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isntsame_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isntsame_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isntsame_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isntsame_i_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_istrue_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isfalse_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isnull_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isnull_i_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isnull_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isnull_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isgt_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isge_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isle_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_islt_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iseq_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isne_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_and_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_and_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_and_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_and_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_not_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_not_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_not_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_not_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_or_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_or_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_or_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_or_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_xor_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_xor_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_xor_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_xor_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_debug_init(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_debug_load_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_debug_break(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_debug_print(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_backtrace(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getline_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getfile_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_close_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdopen_p_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdopen_p_ic_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdopen_p_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdopen_p_ic_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getstdin_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getstdout_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getstderr_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setstdin_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setstdout_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setstderr_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_open_p_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_open_p_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_open_p_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_open_p_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_open_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_open_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_say_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_printerr_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_print_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_read_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_read_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_read_s_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_read_s_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_readline_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_peek_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_peek_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stat_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_ic_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_ic_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_ic_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_seek_p_ic_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tell_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tell_i_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_abs_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_abs_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_abs_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_abs_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_abs_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_abs_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cmod_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dec_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dec_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_dec_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_i_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_n_nc_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_div_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fdiv_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ceil_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ceil_i_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ceil_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_floor_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_floor_i_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_floor_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mod_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_mul_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_neg_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_neg_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_neg_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_neg_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_neg_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_neg_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_n_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_nc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pow_n_nc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_i_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_i_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_i_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sub_p_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sqrt_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_acos_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_asec_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_asin_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_atan_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_atan_n_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_atan_n_nc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_atan_n_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cos_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_cosh_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exp_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ln_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_log10_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_log2_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sec_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sech_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sin_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sinh_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tan_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tanh_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_callmethodcc_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_callmethodcc_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_callmethodcc_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_callmethod_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_callmethod_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_callmethod_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tailcallmethod_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tailcallmethod_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_tailcallmethod_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addmethod_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addmethod_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_can_i_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_can_i_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_does_i_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_does_i_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_does_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_does_i_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isa_i_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isa_i_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isa_i_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_isa_i_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_newclass_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_newclass_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_newclass_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_newclass_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_pc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_pc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_subclass_p_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_class_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_class_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_class_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_class_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_class_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addparent_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_removeparent_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addrole_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addattribute_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_addattribute_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_removeattribute_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_removeattribute_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getattribute_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getattribute_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getattribute_p_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getattribute_p_p_pc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getattribute_p_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getattribute_p_p_pc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setattribute_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setattribute_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setattribute_p_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setattribute_p_pc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setattribute_p_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setattribute_p_pc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inspect_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inspect_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inspect_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inspect_p_pc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inspect_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_inspect_p_pc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_typeof_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_typeof_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_repr_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_method_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_method_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_defined_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_defined_i_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_defined_i_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_defined_i_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_defined_i_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exists_i_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exists_i_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exists_i_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_exists_i_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_delete_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_delete_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_delete_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_delete_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_elements_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_push_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pop_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pop_n_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pop_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pop_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unshift_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shift_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shift_n_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shift_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_shift_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_splice_p_p_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_splice_p_p_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_splice_p_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_splice_p_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setprop_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setprop_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getprop_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_getprop_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_delprop_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_delprop_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_prophash_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_freeze_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_thaw_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_thaw_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_multi_s_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_multi_sc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_multi_s_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_add_multi_sc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_multi_p_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_multi_p_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_multi_p_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_multi_p_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_register_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unregister_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_box_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_box_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_box_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_box_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_box_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_box_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_iter_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_morph_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_morph_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_clone_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_clone_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_assign_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_setref_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_deref_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_ki_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kic_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_p_ki(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_p_kic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_k_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_kc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_i_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_n_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_s_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_p_k(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_p_p_kc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_clone_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_clone_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_clone_p_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_copy_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_null_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_null_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_null_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_null_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ord_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ord_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ord_i_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ord_i_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ord_i_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_ord_i_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_chr_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_chr_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_chopn_s_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_chopn_s_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_chopn_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_chopn_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_s_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_s_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_s_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_concat_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_s_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_s_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_repeat_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_length_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_length_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bytelength_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_bytelength_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_pin_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unpin_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_s_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_sc_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_s_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_sc_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_s_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_sc_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_s_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_sc_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_p_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_p_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_p_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_substr_s_p_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_i_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_i_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_ic_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_ic_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_i_ic_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_i_ic_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_ic_ic_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_ic_ic_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_i_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_i_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_ic_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_ic_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_i_ic_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_i_ic_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_s_ic_ic_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_replace_s_sc_ic_ic_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_s_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_sc_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_s_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_sc_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_sc_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_index_i_sc_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sprintf_s_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sprintf_s_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sprintf_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stringinfo_i_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stringinfo_i_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stringinfo_i_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_stringinfo_i_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_upcase_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_upcase_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_downcase_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_downcase_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_titlecase_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_titlecase_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_join_s_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_join_s_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_split_p_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_split_p_sc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_split_p_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_split_p_sc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_charset_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_charset_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_charsetname_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_charsetname_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_charset_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_charset_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_charset_s_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_charset_s_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_charset_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_charset_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_encoding_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_encoding_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_encodingname_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_encodingname_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_encoding_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_encoding_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_encoding_s_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_encoding_s_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_encoding_s_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trans_encoding_s_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_i_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_ic_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_i_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_ic_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_i_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_ic_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_i_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_is_cclass_i_ic_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_s_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_s_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_sc_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_sc_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_s_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_s_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_sc_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_sc_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_s_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_s_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_sc_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_sc_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_s_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_s_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_i_sc_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_cclass_i_ic_sc_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_s_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_s_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_sc_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_sc_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_s_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_s_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_sc_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_sc_ic_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_s_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_s_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_sc_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_sc_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_s_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_s_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_i_sc_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_not_cclass_i_ic_sc_ic_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_escape_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_compose_s_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_compose_s_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_spawnw_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_spawnw_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_spawnw_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_err_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_err_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_err_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_err_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_time_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_time_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gmtime_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_gmtime_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_localtime_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_localtime_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_decodetime_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_decodetime_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_decodelocaltime_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_decodelocaltime_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sysinfo_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sysinfo_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sysinfo_i_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sysinfo_i_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sleep_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sleep_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sleep_n(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_sleep_nc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_store_lex_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_store_lex_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_store_dynamic_lex_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_store_dynamic_lex_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_lex_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_lex_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_dynamic_lex_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_dynamic_lex_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_caller_lex_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_caller_lex_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_namespace_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_namespace_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_namespace_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_namespace_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_namespace_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_namespace_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_namespace_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_namespace_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_namespace_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_global_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_global_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_global_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_global_p_pc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_global_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_global_p_pc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_global_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_global_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_global_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_global_p_pc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_global_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_hll_global_p_pc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_global_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_global_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_global_p_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_global_p_pc_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_global_p_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_root_global_p_pc_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_global_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_global_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_global_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_global_pc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_global_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_global_pc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_hll_global_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_hll_global_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_hll_global_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_hll_global_pc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_hll_global_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_hll_global_pc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_root_global_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_root_global_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_root_global_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_root_global_pc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_root_global_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_root_global_pc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_name_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_name_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_sub_not_null_p_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_sub_not_null_p_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_trap(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_set_label_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_get_label_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_ic_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_ic_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_i_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_i_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_ic_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_ic_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_p_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_fetch_p_pc_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_p_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_pc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_p_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_pc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_i_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_ic_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_ic_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_i_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_i_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_ic_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_ic_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_s_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_sc_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_s_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_p_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_vivify_p_pc_sc_pc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_s_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_sc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_s_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_sc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_pc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_new_p_pc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_p_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_pc_i(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_p_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_root_new_p_pc_ic(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_codepoint_i_s(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_find_codepoint_i_sc(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unroll_p(opcode_t *, PARROT_INTERP);
+ opcode_t * Parrot_unroll_pc(opcode_t *, PARROT_INTERP);
+
+
+#endif /* PARROT_OPLIB_CORE_OPS_H_GUARD */
+
+
+/*
+ * Local variables:
+ * c-file-style: "parrot"
+ * buffer-read-only: t
+ * End:
+ * vim: expandtab shiftwidth=4:
+ */
Added: trunk/include/parrot/oplib/ops.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/include/parrot/oplib/ops.h Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,1300 @@
+
+/* $Id$ */
+
+#ifndef PARROT_OPLIB_OPS_H_GUARD
+#define PARROT_OPLIB_OPS_H_GUARD
+
+
+/* ex: set ro:
+ * !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
+ *
+ * This file is generated automatically from 'src/ops/core.ops' (and possibly other
+ * .ops files). by ops2c.nqp.
+ *
+ * Any changes made here will be lost!
+ *
+ */
+
+typedef enum {
+ PARROT_OP_end, /* 0 */
+ PARROT_OP_noop, /* 1 */
+ PARROT_OP_check_events, /* 2 */
+ PARROT_OP_check_events__, /* 3 */
+ PARROT_OP_wrapper__, /* 4 */
+ PARROT_OP_load_bytecode_s, /* 5 */
+ PARROT_OP_load_bytecode_sc, /* 6 */
+ PARROT_OP_load_language_s, /* 7 */
+ PARROT_OP_load_language_sc, /* 8 */
+ PARROT_OP_branch_i, /* 9 */
+ PARROT_OP_branch_ic, /* 10 */
+ PARROT_OP_local_branch_p_i, /* 11 */
+ PARROT_OP_local_branch_p_ic, /* 12 */
+ PARROT_OP_local_return_p, /* 13 */
+ PARROT_OP_jump_i, /* 14 */
+ PARROT_OP_jump_ic, /* 15 */
+ PARROT_OP_enternative, /* 16 */
+ PARROT_OP_if_i_ic, /* 17 */
+ PARROT_OP_if_n_ic, /* 18 */
+ PARROT_OP_if_s_ic, /* 19 */
+ PARROT_OP_if_p_ic, /* 20 */
+ PARROT_OP_unless_i_ic, /* 21 */
+ PARROT_OP_unless_n_ic, /* 22 */
+ PARROT_OP_unless_s_ic, /* 23 */
+ PARROT_OP_unless_p_ic, /* 24 */
+ PARROT_OP_invokecc_p, /* 25 */
+ PARROT_OP_invoke_p_p, /* 26 */
+ PARROT_OP_yield, /* 27 */
+ PARROT_OP_tailcall_p, /* 28 */
+ PARROT_OP_returncc, /* 29 */
+ PARROT_OP_capture_lex_p, /* 30 */
+ PARROT_OP_newclosure_p_p, /* 31 */
+ PARROT_OP_set_args_pc, /* 32 */
+ PARROT_OP_get_params_pc, /* 33 */
+ PARROT_OP_set_returns_pc, /* 34 */
+ PARROT_OP_get_results_pc, /* 35 */
+ PARROT_OP_set_result_info_p, /* 36 */
+ PARROT_OP_set_result_info_pc, /* 37 */
+ PARROT_OP_result_info_p, /* 38 */
+ PARROT_OP_set_addr_i_ic, /* 39 */
+ PARROT_OP_set_addr_p_ic, /* 40 */
+ PARROT_OP_set_addr_p_i, /* 41 */
+ PARROT_OP_get_addr_i_p, /* 42 */
+ PARROT_OP_schedule_p, /* 43 */
+ PARROT_OP_addhandler_p, /* 44 */
+ PARROT_OP_push_eh_ic, /* 45 */
+ PARROT_OP_push_eh_p, /* 46 */
+ PARROT_OP_pop_eh, /* 47 */
+ PARROT_OP_throw_p, /* 48 */
+ PARROT_OP_throw_p_p, /* 49 */
+ PARROT_OP_rethrow_p, /* 50 */
+ PARROT_OP_count_eh_i, /* 51 */
+ PARROT_OP_die_s, /* 52 */
+ PARROT_OP_die_sc, /* 53 */
+ PARROT_OP_die_p, /* 54 */
+ PARROT_OP_die_pc, /* 55 */
+ PARROT_OP_die_i_i, /* 56 */
+ PARROT_OP_die_ic_i, /* 57 */
+ PARROT_OP_die_i_ic, /* 58 */
+ PARROT_OP_die_ic_ic, /* 59 */
+ PARROT_OP_exit_i, /* 60 */
+ PARROT_OP_exit_ic, /* 61 */
+ PARROT_OP_debug_i, /* 62 */
+ PARROT_OP_debug_ic, /* 63 */
+ PARROT_OP_bounds_i, /* 64 */
+ PARROT_OP_bounds_ic, /* 65 */
+ PARROT_OP_profile_i, /* 66 */
+ PARROT_OP_profile_ic, /* 67 */
+ PARROT_OP_trace_i, /* 68 */
+ PARROT_OP_trace_ic, /* 69 */
+ PARROT_OP_gc_debug_i, /* 70 */
+ PARROT_OP_gc_debug_ic, /* 71 */
+ PARROT_OP_interpinfo_i_i, /* 72 */
+ PARROT_OP_interpinfo_i_ic, /* 73 */
+ PARROT_OP_interpinfo_p_i, /* 74 */
+ PARROT_OP_interpinfo_p_ic, /* 75 */
+ PARROT_OP_interpinfo_s_i, /* 76 */
+ PARROT_OP_interpinfo_s_ic, /* 77 */
+ PARROT_OP_warningson_i, /* 78 */
+ PARROT_OP_warningson_ic, /* 79 */
+ PARROT_OP_warningsoff_i, /* 80 */
+ PARROT_OP_warningsoff_ic, /* 81 */
+ PARROT_OP_errorson_i, /* 82 */
+ PARROT_OP_errorson_ic, /* 83 */
+ PARROT_OP_errorsoff_i, /* 84 */
+ PARROT_OP_errorsoff_ic, /* 85 */
+ PARROT_OP_runinterp_p_i, /* 86 */
+ PARROT_OP_runinterp_p_ic, /* 87 */
+ PARROT_OP_getinterp_p, /* 88 */
+ PARROT_OP_sweep_ic, /* 89 */
+ PARROT_OP_collect, /* 90 */
+ PARROT_OP_sweepoff, /* 91 */
+ PARROT_OP_sweepon, /* 92 */
+ PARROT_OP_collectoff, /* 93 */
+ PARROT_OP_collecton, /* 94 */
+ PARROT_OP_needs_destroy_p, /* 95 */
+ PARROT_OP_loadlib_p_s, /* 96 */
+ PARROT_OP_loadlib_p_sc, /* 97 */
+ PARROT_OP_loadlib_p_s_p, /* 98 */
+ PARROT_OP_loadlib_p_sc_p, /* 99 */
+ PARROT_OP_loadlib_p_s_pc, /* 100 */
+ PARROT_OP_loadlib_p_sc_pc, /* 101 */
+ PARROT_OP_dlfunc_p_p_s_s, /* 102 */
+ PARROT_OP_dlfunc_p_p_sc_s, /* 103 */
+ PARROT_OP_dlfunc_p_p_s_sc, /* 104 */
+ PARROT_OP_dlfunc_p_p_sc_sc, /* 105 */
+ PARROT_OP_dlvar_p_p_s, /* 106 */
+ PARROT_OP_dlvar_p_p_sc, /* 107 */
+ PARROT_OP_compreg_s_p, /* 108 */
+ PARROT_OP_compreg_sc_p, /* 109 */
+ PARROT_OP_compreg_p_s, /* 110 */
+ PARROT_OP_compreg_p_sc, /* 111 */
+ PARROT_OP_new_callback_p_p_p_s, /* 112 */
+ PARROT_OP_new_callback_p_p_p_sc, /* 113 */
+ PARROT_OP_annotations_p, /* 114 */
+ PARROT_OP_annotations_p_s, /* 115 */
+ PARROT_OP_annotations_p_sc, /* 116 */
+ PARROT_OP_band_i_i, /* 117 */
+ PARROT_OP_band_i_ic, /* 118 */
+ PARROT_OP_band_p_i, /* 119 */
+ PARROT_OP_band_p_ic, /* 120 */
+ PARROT_OP_band_p_p, /* 121 */
+ PARROT_OP_band_i_i_i, /* 122 */
+ PARROT_OP_band_i_ic_i, /* 123 */
+ PARROT_OP_band_i_i_ic, /* 124 */
+ PARROT_OP_band_p_p_i, /* 125 */
+ PARROT_OP_band_p_p_ic, /* 126 */
+ PARROT_OP_band_p_p_p, /* 127 */
+ PARROT_OP_bands_p_s, /* 128 */
+ PARROT_OP_bands_p_sc, /* 129 */
+ PARROT_OP_bands_p_p, /* 130 */
+ PARROT_OP_bands_s_s_s, /* 131 */
+ PARROT_OP_bands_s_sc_s, /* 132 */
+ PARROT_OP_bands_s_s_sc, /* 133 */
+ PARROT_OP_bands_p_p_s, /* 134 */
+ PARROT_OP_bands_p_p_sc, /* 135 */
+ PARROT_OP_bands_p_p_p, /* 136 */
+ PARROT_OP_bnot_i, /* 137 */
+ PARROT_OP_bnot_i_i, /* 138 */
+ PARROT_OP_bnot_p, /* 139 */
+ PARROT_OP_bnot_p_p, /* 140 */
+ PARROT_OP_bnots_s_s, /* 141 */
+ PARROT_OP_bnots_s_sc, /* 142 */
+ PARROT_OP_bnots_p, /* 143 */
+ PARROT_OP_bnots_p_p, /* 144 */
+ PARROT_OP_bor_i_i, /* 145 */
+ PARROT_OP_bor_i_ic, /* 146 */
+ PARROT_OP_bor_p_i, /* 147 */
+ PARROT_OP_bor_p_ic, /* 148 */
+ PARROT_OP_bor_p_p, /* 149 */
+ PARROT_OP_bor_i_i_i, /* 150 */
+ PARROT_OP_bor_i_ic_i, /* 151 */
+ PARROT_OP_bor_i_i_ic, /* 152 */
+ PARROT_OP_bor_p_p_i, /* 153 */
+ PARROT_OP_bor_p_p_ic, /* 154 */
+ PARROT_OP_bor_p_p_p, /* 155 */
+ PARROT_OP_bors_p_s, /* 156 */
+ PARROT_OP_bors_p_sc, /* 157 */
+ PARROT_OP_bors_p_p, /* 158 */
+ PARROT_OP_bors_s_s_s, /* 159 */
+ PARROT_OP_bors_s_sc_s, /* 160 */
+ PARROT_OP_bors_s_s_sc, /* 161 */
+ PARROT_OP_bors_p_p_s, /* 162 */
+ PARROT_OP_bors_p_p_sc, /* 163 */
+ PARROT_OP_bors_p_p_p, /* 164 */
+ PARROT_OP_shl_i_i, /* 165 */
+ PARROT_OP_shl_i_ic, /* 166 */
+ PARROT_OP_shl_p_i, /* 167 */
+ PARROT_OP_shl_p_ic, /* 168 */
+ PARROT_OP_shl_p_p, /* 169 */
+ PARROT_OP_shl_i_i_i, /* 170 */
+ PARROT_OP_shl_i_ic_i, /* 171 */
+ PARROT_OP_shl_i_i_ic, /* 172 */
+ PARROT_OP_shl_p_p_i, /* 173 */
+ PARROT_OP_shl_p_p_ic, /* 174 */
+ PARROT_OP_shl_p_p_p, /* 175 */
+ PARROT_OP_shr_i_i, /* 176 */
+ PARROT_OP_shr_i_ic, /* 177 */
+ PARROT_OP_shr_p_i, /* 178 */
+ PARROT_OP_shr_p_ic, /* 179 */
+ PARROT_OP_shr_p_p, /* 180 */
+ PARROT_OP_shr_i_i_i, /* 181 */
+ PARROT_OP_shr_i_ic_i, /* 182 */
+ PARROT_OP_shr_i_i_ic, /* 183 */
+ PARROT_OP_shr_p_p_i, /* 184 */
+ PARROT_OP_shr_p_p_ic, /* 185 */
+ PARROT_OP_shr_p_p_p, /* 186 */
+ PARROT_OP_lsr_i_i, /* 187 */
+ PARROT_OP_lsr_i_ic, /* 188 */
+ PARROT_OP_lsr_p_i, /* 189 */
+ PARROT_OP_lsr_p_ic, /* 190 */
+ PARROT_OP_lsr_p_p, /* 191 */
+ PARROT_OP_lsr_i_i_i, /* 192 */
+ PARROT_OP_lsr_i_ic_i, /* 193 */
+ PARROT_OP_lsr_i_i_ic, /* 194 */
+ PARROT_OP_lsr_p_p_i, /* 195 */
+ PARROT_OP_lsr_p_p_ic, /* 196 */
+ PARROT_OP_lsr_p_p_p, /* 197 */
+ PARROT_OP_rot_i_i_i_ic, /* 198 */
+ PARROT_OP_rot_i_ic_i_ic, /* 199 */
+ PARROT_OP_rot_i_i_ic_ic, /* 200 */
+ PARROT_OP_bxor_i_i, /* 201 */
+ PARROT_OP_bxor_i_ic, /* 202 */
+ PARROT_OP_bxor_p_i, /* 203 */
+ PARROT_OP_bxor_p_ic, /* 204 */
+ PARROT_OP_bxor_p_p, /* 205 */
+ PARROT_OP_bxor_i_i_i, /* 206 */
+ PARROT_OP_bxor_i_ic_i, /* 207 */
+ PARROT_OP_bxor_i_i_ic, /* 208 */
+ PARROT_OP_bxor_p_p_i, /* 209 */
+ PARROT_OP_bxor_p_p_ic, /* 210 */
+ PARROT_OP_bxor_p_p_p, /* 211 */
+ PARROT_OP_bxors_p_s, /* 212 */
+ PARROT_OP_bxors_p_sc, /* 213 */
+ PARROT_OP_bxors_p_p, /* 214 */
+ PARROT_OP_bxors_s_s_s, /* 215 */
+ PARROT_OP_bxors_s_sc_s, /* 216 */
+ PARROT_OP_bxors_s_s_sc, /* 217 */
+ PARROT_OP_bxors_p_p_s, /* 218 */
+ PARROT_OP_bxors_p_p_sc, /* 219 */
+ PARROT_OP_bxors_p_p_p, /* 220 */
+ PARROT_OP_eq_i_i_ic, /* 221 */
+ PARROT_OP_eq_ic_i_ic, /* 222 */
+ PARROT_OP_eq_i_ic_ic, /* 223 */
+ PARROT_OP_eq_n_n_ic, /* 224 */
+ PARROT_OP_eq_nc_n_ic, /* 225 */
+ PARROT_OP_eq_n_nc_ic, /* 226 */
+ PARROT_OP_eq_s_s_ic, /* 227 */
+ PARROT_OP_eq_sc_s_ic, /* 228 */
+ PARROT_OP_eq_s_sc_ic, /* 229 */
+ PARROT_OP_eq_p_p_ic, /* 230 */
+ PARROT_OP_eq_p_i_ic, /* 231 */
+ PARROT_OP_eq_p_ic_ic, /* 232 */
+ PARROT_OP_eq_p_n_ic, /* 233 */
+ PARROT_OP_eq_p_nc_ic, /* 234 */
+ PARROT_OP_eq_p_s_ic, /* 235 */
+ PARROT_OP_eq_p_sc_ic, /* 236 */
+ PARROT_OP_eq_str_p_p_ic, /* 237 */
+ PARROT_OP_eq_num_p_p_ic, /* 238 */
+ PARROT_OP_eq_addr_s_s_ic, /* 239 */
+ PARROT_OP_eq_addr_sc_s_ic, /* 240 */
+ PARROT_OP_eq_addr_s_sc_ic, /* 241 */
+ PARROT_OP_eq_addr_sc_sc_ic, /* 242 */
+ PARROT_OP_eq_addr_p_p_ic, /* 243 */
+ PARROT_OP_ne_i_i_ic, /* 244 */
+ PARROT_OP_ne_ic_i_ic, /* 245 */
+ PARROT_OP_ne_i_ic_ic, /* 246 */
+ PARROT_OP_ne_n_n_ic, /* 247 */
+ PARROT_OP_ne_nc_n_ic, /* 248 */
+ PARROT_OP_ne_n_nc_ic, /* 249 */
+ PARROT_OP_ne_s_s_ic, /* 250 */
+ PARROT_OP_ne_sc_s_ic, /* 251 */
+ PARROT_OP_ne_s_sc_ic, /* 252 */
+ PARROT_OP_ne_p_p_ic, /* 253 */
+ PARROT_OP_ne_p_i_ic, /* 254 */
+ PARROT_OP_ne_p_ic_ic, /* 255 */
+ PARROT_OP_ne_p_n_ic, /* 256 */
+ PARROT_OP_ne_p_nc_ic, /* 257 */
+ PARROT_OP_ne_p_s_ic, /* 258 */
+ PARROT_OP_ne_p_sc_ic, /* 259 */
+ PARROT_OP_ne_str_p_p_ic, /* 260 */
+ PARROT_OP_ne_num_p_p_ic, /* 261 */
+ PARROT_OP_ne_addr_s_s_ic, /* 262 */
+ PARROT_OP_ne_addr_sc_s_ic, /* 263 */
+ PARROT_OP_ne_addr_s_sc_ic, /* 264 */
+ PARROT_OP_ne_addr_sc_sc_ic, /* 265 */
+ PARROT_OP_ne_addr_p_p_ic, /* 266 */
+ PARROT_OP_lt_i_i_ic, /* 267 */
+ PARROT_OP_lt_ic_i_ic, /* 268 */
+ PARROT_OP_lt_i_ic_ic, /* 269 */
+ PARROT_OP_lt_n_n_ic, /* 270 */
+ PARROT_OP_lt_nc_n_ic, /* 271 */
+ PARROT_OP_lt_n_nc_ic, /* 272 */
+ PARROT_OP_lt_s_s_ic, /* 273 */
+ PARROT_OP_lt_sc_s_ic, /* 274 */
+ PARROT_OP_lt_s_sc_ic, /* 275 */
+ PARROT_OP_lt_p_p_ic, /* 276 */
+ PARROT_OP_lt_p_i_ic, /* 277 */
+ PARROT_OP_lt_p_ic_ic, /* 278 */
+ PARROT_OP_lt_p_n_ic, /* 279 */
+ PARROT_OP_lt_p_nc_ic, /* 280 */
+ PARROT_OP_lt_p_s_ic, /* 281 */
+ PARROT_OP_lt_p_sc_ic, /* 282 */
+ PARROT_OP_lt_str_p_p_ic, /* 283 */
+ PARROT_OP_lt_num_p_p_ic, /* 284 */
+ PARROT_OP_le_i_i_ic, /* 285 */
+ PARROT_OP_le_ic_i_ic, /* 286 */
+ PARROT_OP_le_i_ic_ic, /* 287 */
+ PARROT_OP_le_n_n_ic, /* 288 */
+ PARROT_OP_le_nc_n_ic, /* 289 */
+ PARROT_OP_le_n_nc_ic, /* 290 */
+ PARROT_OP_le_s_s_ic, /* 291 */
+ PARROT_OP_le_sc_s_ic, /* 292 */
+ PARROT_OP_le_s_sc_ic, /* 293 */
+ PARROT_OP_le_p_p_ic, /* 294 */
+ PARROT_OP_le_p_i_ic, /* 295 */
+ PARROT_OP_le_p_ic_ic, /* 296 */
+ PARROT_OP_le_p_n_ic, /* 297 */
+ PARROT_OP_le_p_nc_ic, /* 298 */
+ PARROT_OP_le_p_s_ic, /* 299 */
+ PARROT_OP_le_p_sc_ic, /* 300 */
+ PARROT_OP_le_str_p_p_ic, /* 301 */
+ PARROT_OP_le_num_p_p_ic, /* 302 */
+ PARROT_OP_gt_p_p_ic, /* 303 */
+ PARROT_OP_gt_p_i_ic, /* 304 */
+ PARROT_OP_gt_p_ic_ic, /* 305 */
+ PARROT_OP_gt_p_n_ic, /* 306 */
+ PARROT_OP_gt_p_nc_ic, /* 307 */
+ PARROT_OP_gt_p_s_ic, /* 308 */
+ PARROT_OP_gt_p_sc_ic, /* 309 */
+ PARROT_OP_gt_str_p_p_ic, /* 310 */
+ PARROT_OP_gt_num_p_p_ic, /* 311 */
+ PARROT_OP_ge_p_p_ic, /* 312 */
+ PARROT_OP_ge_p_i_ic, /* 313 */
+ PARROT_OP_ge_p_ic_ic, /* 314 */
+ PARROT_OP_ge_p_n_ic, /* 315 */
+ PARROT_OP_ge_p_nc_ic, /* 316 */
+ PARROT_OP_ge_p_s_ic, /* 317 */
+ PARROT_OP_ge_p_sc_ic, /* 318 */
+ PARROT_OP_ge_str_p_p_ic, /* 319 */
+ PARROT_OP_ge_num_p_p_ic, /* 320 */
+ PARROT_OP_if_null_p_ic, /* 321 */
+ PARROT_OP_if_null_s_ic, /* 322 */
+ PARROT_OP_unless_null_p_ic, /* 323 */
+ PARROT_OP_unless_null_s_ic, /* 324 */
+ PARROT_OP_cmp_i_i_i, /* 325 */
+ PARROT_OP_cmp_i_ic_i, /* 326 */
+ PARROT_OP_cmp_i_i_ic, /* 327 */
+ PARROT_OP_cmp_i_n_n, /* 328 */
+ PARROT_OP_cmp_i_nc_n, /* 329 */
+ PARROT_OP_cmp_i_n_nc, /* 330 */
+ PARROT_OP_cmp_i_s_s, /* 331 */
+ PARROT_OP_cmp_i_sc_s, /* 332 */
+ PARROT_OP_cmp_i_s_sc, /* 333 */
+ PARROT_OP_cmp_i_p_p, /* 334 */
+ PARROT_OP_cmp_i_p_i, /* 335 */
+ PARROT_OP_cmp_i_p_ic, /* 336 */
+ PARROT_OP_cmp_i_p_n, /* 337 */
+ PARROT_OP_cmp_i_p_nc, /* 338 */
+ PARROT_OP_cmp_i_p_s, /* 339 */
+ PARROT_OP_cmp_i_p_sc, /* 340 */
+ PARROT_OP_cmp_str_i_p_p, /* 341 */
+ PARROT_OP_cmp_num_i_p_p, /* 342 */
+ PARROT_OP_cmp_pmc_p_p_p, /* 343 */
+ PARROT_OP_issame_i_p_p, /* 344 */
+ PARROT_OP_issame_i_s_s, /* 345 */
+ PARROT_OP_issame_i_sc_s, /* 346 */
+ PARROT_OP_issame_i_s_sc, /* 347 */
+ PARROT_OP_issame_i_sc_sc, /* 348 */
+ PARROT_OP_isntsame_i_p_p, /* 349 */
+ PARROT_OP_isntsame_i_s_s, /* 350 */
+ PARROT_OP_isntsame_i_sc_s, /* 351 */
+ PARROT_OP_isntsame_i_s_sc, /* 352 */
+ PARROT_OP_isntsame_i_sc_sc, /* 353 */
+ PARROT_OP_istrue_i_p, /* 354 */
+ PARROT_OP_isfalse_i_p, /* 355 */
+ PARROT_OP_isnull_i_p, /* 356 */
+ PARROT_OP_isnull_i_pc, /* 357 */
+ PARROT_OP_isnull_i_s, /* 358 */
+ PARROT_OP_isnull_i_sc, /* 359 */
+ PARROT_OP_isgt_i_p_p, /* 360 */
+ PARROT_OP_isge_i_p_p, /* 361 */
+ PARROT_OP_isle_i_i_i, /* 362 */
+ PARROT_OP_isle_i_ic_i, /* 363 */
+ PARROT_OP_isle_i_i_ic, /* 364 */
+ PARROT_OP_isle_i_n_n, /* 365 */
+ PARROT_OP_isle_i_nc_n, /* 366 */
+ PARROT_OP_isle_i_n_nc, /* 367 */
+ PARROT_OP_isle_i_s_s, /* 368 */
+ PARROT_OP_isle_i_sc_s, /* 369 */
+ PARROT_OP_isle_i_s_sc, /* 370 */
+ PARROT_OP_isle_i_p_p, /* 371 */
+ PARROT_OP_islt_i_i_i, /* 372 */
+ PARROT_OP_islt_i_ic_i, /* 373 */
+ PARROT_OP_islt_i_i_ic, /* 374 */
+ PARROT_OP_islt_i_n_n, /* 375 */
+ PARROT_OP_islt_i_nc_n, /* 376 */
+ PARROT_OP_islt_i_n_nc, /* 377 */
+ PARROT_OP_islt_i_s_s, /* 378 */
+ PARROT_OP_islt_i_sc_s, /* 379 */
+ PARROT_OP_islt_i_s_sc, /* 380 */
+ PARROT_OP_islt_i_p_p, /* 381 */
+ PARROT_OP_iseq_i_i_i, /* 382 */
+ PARROT_OP_iseq_i_ic_i, /* 383 */
+ PARROT_OP_iseq_i_i_ic, /* 384 */
+ PARROT_OP_iseq_i_n_n, /* 385 */
+ PARROT_OP_iseq_i_nc_n, /* 386 */
+ PARROT_OP_iseq_i_n_nc, /* 387 */
+ PARROT_OP_iseq_i_s_s, /* 388 */
+ PARROT_OP_iseq_i_sc_s, /* 389 */
+ PARROT_OP_iseq_i_s_sc, /* 390 */
+ PARROT_OP_iseq_i_p_p, /* 391 */
+ PARROT_OP_isne_i_i_i, /* 392 */
+ PARROT_OP_isne_i_ic_i, /* 393 */
+ PARROT_OP_isne_i_i_ic, /* 394 */
+ PARROT_OP_isne_i_n_n, /* 395 */
+ PARROT_OP_isne_i_nc_n, /* 396 */
+ PARROT_OP_isne_i_n_nc, /* 397 */
+ PARROT_OP_isne_i_s_s, /* 398 */
+ PARROT_OP_isne_i_sc_s, /* 399 */
+ PARROT_OP_isne_i_s_sc, /* 400 */
+ PARROT_OP_isne_i_p_p, /* 401 */
+ PARROT_OP_and_i_i_i, /* 402 */
+ PARROT_OP_and_i_ic_i, /* 403 */
+ PARROT_OP_and_i_i_ic, /* 404 */
+ PARROT_OP_and_p_p_p, /* 405 */
+ PARROT_OP_not_i, /* 406 */
+ PARROT_OP_not_i_i, /* 407 */
+ PARROT_OP_not_p, /* 408 */
+ PARROT_OP_not_p_p, /* 409 */
+ PARROT_OP_or_i_i_i, /* 410 */
+ PARROT_OP_or_i_ic_i, /* 411 */
+ PARROT_OP_or_i_i_ic, /* 412 */
+ PARROT_OP_or_p_p_p, /* 413 */
+ PARROT_OP_xor_i_i_i, /* 414 */
+ PARROT_OP_xor_i_ic_i, /* 415 */
+ PARROT_OP_xor_i_i_ic, /* 416 */
+ PARROT_OP_xor_p_p_p, /* 417 */
+ PARROT_OP_debug_init, /* 418 */
+ PARROT_OP_debug_load_sc, /* 419 */
+ PARROT_OP_debug_break, /* 420 */
+ PARROT_OP_debug_print, /* 421 */
+ PARROT_OP_backtrace, /* 422 */
+ PARROT_OP_getline_i, /* 423 */
+ PARROT_OP_getfile_s, /* 424 */
+ PARROT_OP_close_p, /* 425 */
+ PARROT_OP_fdopen_p_i_s, /* 426 */
+ PARROT_OP_fdopen_p_ic_s, /* 427 */
+ PARROT_OP_fdopen_p_i_sc, /* 428 */
+ PARROT_OP_fdopen_p_ic_sc, /* 429 */
+ PARROT_OP_getstdin_p, /* 430 */
+ PARROT_OP_getstdout_p, /* 431 */
+ PARROT_OP_getstderr_p, /* 432 */
+ PARROT_OP_setstdin_p, /* 433 */
+ PARROT_OP_setstdout_p, /* 434 */
+ PARROT_OP_setstderr_p, /* 435 */
+ PARROT_OP_open_p_s_s, /* 436 */
+ PARROT_OP_open_p_sc_s, /* 437 */
+ PARROT_OP_open_p_s_sc, /* 438 */
+ PARROT_OP_open_p_sc_sc, /* 439 */
+ PARROT_OP_open_p_s, /* 440 */
+ PARROT_OP_open_p_sc, /* 441 */
+ PARROT_OP_print_i, /* 442 */
+ PARROT_OP_print_ic, /* 443 */
+ PARROT_OP_print_n, /* 444 */
+ PARROT_OP_print_nc, /* 445 */
+ PARROT_OP_print_s, /* 446 */
+ PARROT_OP_print_sc, /* 447 */
+ PARROT_OP_print_p, /* 448 */
+ PARROT_OP_say_i, /* 449 */
+ PARROT_OP_say_ic, /* 450 */
+ PARROT_OP_say_n, /* 451 */
+ PARROT_OP_say_nc, /* 452 */
+ PARROT_OP_say_s, /* 453 */
+ PARROT_OP_say_sc, /* 454 */
+ PARROT_OP_say_p, /* 455 */
+ PARROT_OP_printerr_i, /* 456 */
+ PARROT_OP_printerr_ic, /* 457 */
+ PARROT_OP_printerr_n, /* 458 */
+ PARROT_OP_printerr_nc, /* 459 */
+ PARROT_OP_printerr_s, /* 460 */
+ PARROT_OP_printerr_sc, /* 461 */
+ PARROT_OP_printerr_p, /* 462 */
+ PARROT_OP_print_p_i, /* 463 */
+ PARROT_OP_print_p_ic, /* 464 */
+ PARROT_OP_print_p_n, /* 465 */
+ PARROT_OP_print_p_nc, /* 466 */
+ PARROT_OP_print_p_s, /* 467 */
+ PARROT_OP_print_p_sc, /* 468 */
+ PARROT_OP_print_p_p, /* 469 */
+ PARROT_OP_read_s_i, /* 470 */
+ PARROT_OP_read_s_ic, /* 471 */
+ PARROT_OP_read_s_p_i, /* 472 */
+ PARROT_OP_read_s_p_ic, /* 473 */
+ PARROT_OP_readline_s_p, /* 474 */
+ PARROT_OP_peek_s, /* 475 */
+ PARROT_OP_peek_s_p, /* 476 */
+ PARROT_OP_stat_i_s_i, /* 477 */
+ PARROT_OP_stat_i_sc_i, /* 478 */
+ PARROT_OP_stat_i_s_ic, /* 479 */
+ PARROT_OP_stat_i_sc_ic, /* 480 */
+ PARROT_OP_stat_i_i_i, /* 481 */
+ PARROT_OP_stat_i_ic_i, /* 482 */
+ PARROT_OP_stat_i_i_ic, /* 483 */
+ PARROT_OP_stat_i_ic_ic, /* 484 */
+ PARROT_OP_seek_p_i_i, /* 485 */
+ PARROT_OP_seek_p_ic_i, /* 486 */
+ PARROT_OP_seek_p_i_ic, /* 487 */
+ PARROT_OP_seek_p_ic_ic, /* 488 */
+ PARROT_OP_seek_p_i_i_i, /* 489 */
+ PARROT_OP_seek_p_ic_i_i, /* 490 */
+ PARROT_OP_seek_p_i_ic_i, /* 491 */
+ PARROT_OP_seek_p_ic_ic_i, /* 492 */
+ PARROT_OP_seek_p_i_i_ic, /* 493 */
+ PARROT_OP_seek_p_ic_i_ic, /* 494 */
+ PARROT_OP_seek_p_i_ic_ic, /* 495 */
+ PARROT_OP_seek_p_ic_ic_ic, /* 496 */
+ PARROT_OP_tell_i_p, /* 497 */
+ PARROT_OP_tell_i_i_p, /* 498 */
+ PARROT_OP_abs_i, /* 499 */
+ PARROT_OP_abs_n, /* 500 */
+ PARROT_OP_abs_i_i, /* 501 */
+ PARROT_OP_abs_n_n, /* 502 */
+ PARROT_OP_abs_p, /* 503 */
+ PARROT_OP_abs_p_p, /* 504 */
+ PARROT_OP_add_i_i, /* 505 */
+ PARROT_OP_add_i_ic, /* 506 */
+ PARROT_OP_add_n_n, /* 507 */
+ PARROT_OP_add_n_nc, /* 508 */
+ PARROT_OP_add_p_p, /* 509 */
+ PARROT_OP_add_p_i, /* 510 */
+ PARROT_OP_add_p_ic, /* 511 */
+ PARROT_OP_add_p_n, /* 512 */
+ PARROT_OP_add_p_nc, /* 513 */
+ PARROT_OP_add_i_i_i, /* 514 */
+ PARROT_OP_add_i_ic_i, /* 515 */
+ PARROT_OP_add_i_i_ic, /* 516 */
+ PARROT_OP_add_n_n_n, /* 517 */
+ PARROT_OP_add_n_nc_n, /* 518 */
+ PARROT_OP_add_n_n_nc, /* 519 */
+ PARROT_OP_add_p_p_p, /* 520 */
+ PARROT_OP_add_p_p_i, /* 521 */
+ PARROT_OP_add_p_p_ic, /* 522 */
+ PARROT_OP_add_p_p_n, /* 523 */
+ PARROT_OP_add_p_p_nc, /* 524 */
+ PARROT_OP_cmod_i_i_i, /* 525 */
+ PARROT_OP_cmod_i_ic_i, /* 526 */
+ PARROT_OP_cmod_i_i_ic, /* 527 */
+ PARROT_OP_cmod_p_p_i, /* 528 */
+ PARROT_OP_cmod_p_p_ic, /* 529 */
+ PARROT_OP_cmod_p_p_p, /* 530 */
+ PARROT_OP_cmod_n_n_n, /* 531 */
+ PARROT_OP_cmod_n_nc_n, /* 532 */
+ PARROT_OP_cmod_n_n_nc, /* 533 */
+ PARROT_OP_cmod_p_p_n, /* 534 */
+ PARROT_OP_cmod_p_p_nc, /* 535 */
+ PARROT_OP_dec_i, /* 536 */
+ PARROT_OP_dec_n, /* 537 */
+ PARROT_OP_dec_p, /* 538 */
+ PARROT_OP_div_i_i, /* 539 */
+ PARROT_OP_div_i_ic, /* 540 */
+ PARROT_OP_div_n_n, /* 541 */
+ PARROT_OP_div_n_nc, /* 542 */
+ PARROT_OP_div_p_p, /* 543 */
+ PARROT_OP_div_p_i, /* 544 */
+ PARROT_OP_div_p_ic, /* 545 */
+ PARROT_OP_div_p_n, /* 546 */
+ PARROT_OP_div_p_nc, /* 547 */
+ PARROT_OP_div_i_i_i, /* 548 */
+ PARROT_OP_div_i_ic_i, /* 549 */
+ PARROT_OP_div_i_i_ic, /* 550 */
+ PARROT_OP_div_i_ic_ic, /* 551 */
+ PARROT_OP_div_n_n_n, /* 552 */
+ PARROT_OP_div_n_nc_n, /* 553 */
+ PARROT_OP_div_n_n_nc, /* 554 */
+ PARROT_OP_div_n_nc_nc, /* 555 */
+ PARROT_OP_div_p_p_p, /* 556 */
+ PARROT_OP_div_p_p_i, /* 557 */
+ PARROT_OP_div_p_p_ic, /* 558 */
+ PARROT_OP_div_p_p_n, /* 559 */
+ PARROT_OP_div_p_p_nc, /* 560 */
+ PARROT_OP_fdiv_i_i, /* 561 */
+ PARROT_OP_fdiv_i_ic, /* 562 */
+ PARROT_OP_fdiv_n_n, /* 563 */
+ PARROT_OP_fdiv_n_nc, /* 564 */
+ PARROT_OP_fdiv_p_p, /* 565 */
+ PARROT_OP_fdiv_p_i, /* 566 */
+ PARROT_OP_fdiv_p_ic, /* 567 */
+ PARROT_OP_fdiv_p_n, /* 568 */
+ PARROT_OP_fdiv_p_nc, /* 569 */
+ PARROT_OP_fdiv_i_i_i, /* 570 */
+ PARROT_OP_fdiv_i_ic_i, /* 571 */
+ PARROT_OP_fdiv_i_i_ic, /* 572 */
+ PARROT_OP_fdiv_n_n_n, /* 573 */
+ PARROT_OP_fdiv_n_nc_n, /* 574 */
+ PARROT_OP_fdiv_n_n_nc, /* 575 */
+ PARROT_OP_fdiv_p_p_p, /* 576 */
+ PARROT_OP_fdiv_p_p_i, /* 577 */
+ PARROT_OP_fdiv_p_p_ic, /* 578 */
+ PARROT_OP_fdiv_p_p_n, /* 579 */
+ PARROT_OP_fdiv_p_p_nc, /* 580 */
+ PARROT_OP_ceil_n, /* 581 */
+ PARROT_OP_ceil_i_n, /* 582 */
+ PARROT_OP_ceil_n_n, /* 583 */
+ PARROT_OP_floor_n, /* 584 */
+ PARROT_OP_floor_i_n, /* 585 */
+ PARROT_OP_floor_n_n, /* 586 */
+ PARROT_OP_inc_i, /* 587 */
+ PARROT_OP_inc_n, /* 588 */
+ PARROT_OP_inc_p, /* 589 */
+ PARROT_OP_mod_i_i, /* 590 */
+ PARROT_OP_mod_i_ic, /* 591 */
+ PARROT_OP_mod_n_n, /* 592 */
+ PARROT_OP_mod_n_nc, /* 593 */
+ PARROT_OP_mod_p_p, /* 594 */
+ PARROT_OP_mod_p_i, /* 595 */
+ PARROT_OP_mod_p_ic, /* 596 */
+ PARROT_OP_mod_p_n, /* 597 */
+ PARROT_OP_mod_p_nc, /* 598 */
+ PARROT_OP_mod_i_i_i, /* 599 */
+ PARROT_OP_mod_i_ic_i, /* 600 */
+ PARROT_OP_mod_i_i_ic, /* 601 */
+ PARROT_OP_mod_n_n_n, /* 602 */
+ PARROT_OP_mod_n_nc_n, /* 603 */
+ PARROT_OP_mod_n_n_nc, /* 604 */
+ PARROT_OP_mod_p_p_p, /* 605 */
+ PARROT_OP_mod_p_p_i, /* 606 */
+ PARROT_OP_mod_p_p_ic, /* 607 */
+ PARROT_OP_mod_p_p_n, /* 608 */
+ PARROT_OP_mod_p_p_nc, /* 609 */
+ PARROT_OP_mul_i_i, /* 610 */
+ PARROT_OP_mul_i_ic, /* 611 */
+ PARROT_OP_mul_n_n, /* 612 */
+ PARROT_OP_mul_n_nc, /* 613 */
+ PARROT_OP_mul_p_p, /* 614 */
+ PARROT_OP_mul_p_i, /* 615 */
+ PARROT_OP_mul_p_ic, /* 616 */
+ PARROT_OP_mul_p_n, /* 617 */
+ PARROT_OP_mul_p_nc, /* 618 */
+ PARROT_OP_mul_i_i_i, /* 619 */
+ PARROT_OP_mul_i_ic_i, /* 620 */
+ PARROT_OP_mul_i_i_ic, /* 621 */
+ PARROT_OP_mul_n_n_n, /* 622 */
+ PARROT_OP_mul_n_nc_n, /* 623 */
+ PARROT_OP_mul_n_n_nc, /* 624 */
+ PARROT_OP_mul_p_p_p, /* 625 */
+ PARROT_OP_mul_p_p_i, /* 626 */
+ PARROT_OP_mul_p_p_ic, /* 627 */
+ PARROT_OP_mul_p_p_n, /* 628 */
+ PARROT_OP_mul_p_p_nc, /* 629 */
+ PARROT_OP_neg_i, /* 630 */
+ PARROT_OP_neg_n, /* 631 */
+ PARROT_OP_neg_p, /* 632 */
+ PARROT_OP_neg_i_i, /* 633 */
+ PARROT_OP_neg_n_n, /* 634 */
+ PARROT_OP_neg_p_p, /* 635 */
+ PARROT_OP_pow_n_n_n, /* 636 */
+ PARROT_OP_pow_n_nc_n, /* 637 */
+ PARROT_OP_pow_n_n_nc, /* 638 */
+ PARROT_OP_pow_p_p_p, /* 639 */
+ PARROT_OP_pow_p_p_i, /* 640 */
+ PARROT_OP_pow_p_p_ic, /* 641 */
+ PARROT_OP_pow_p_p_n, /* 642 */
+ PARROT_OP_pow_p_p_nc, /* 643 */
+ PARROT_OP_pow_n_n_i, /* 644 */
+ PARROT_OP_pow_n_nc_i, /* 645 */
+ PARROT_OP_pow_n_n_ic, /* 646 */
+ PARROT_OP_pow_n_nc_ic, /* 647 */
+ PARROT_OP_sub_i_i, /* 648 */
+ PARROT_OP_sub_i_ic, /* 649 */
+ PARROT_OP_sub_n_n, /* 650 */
+ PARROT_OP_sub_n_nc, /* 651 */
+ PARROT_OP_sub_p_p, /* 652 */
+ PARROT_OP_sub_p_i, /* 653 */
+ PARROT_OP_sub_p_ic, /* 654 */
+ PARROT_OP_sub_p_n, /* 655 */
+ PARROT_OP_sub_p_nc, /* 656 */
+ PARROT_OP_sub_i_i_i, /* 657 */
+ PARROT_OP_sub_i_ic_i, /* 658 */
+ PARROT_OP_sub_i_i_ic, /* 659 */
+ PARROT_OP_sub_n_n_n, /* 660 */
+ PARROT_OP_sub_n_nc_n, /* 661 */
+ PARROT_OP_sub_n_n_nc, /* 662 */
+ PARROT_OP_sub_p_p_p, /* 663 */
+ PARROT_OP_sub_p_p_i, /* 664 */
+ PARROT_OP_sub_p_p_ic, /* 665 */
+ PARROT_OP_sub_p_p_n, /* 666 */
+ PARROT_OP_sub_p_p_nc, /* 667 */
+ PARROT_OP_sqrt_n_n, /* 668 */
+ PARROT_OP_acos_n_n, /* 669 */
+ PARROT_OP_asec_n_n, /* 670 */
+ PARROT_OP_asin_n_n, /* 671 */
+ PARROT_OP_atan_n_n, /* 672 */
+ PARROT_OP_atan_n_n_n, /* 673 */
+ PARROT_OP_atan_n_nc_n, /* 674 */
+ PARROT_OP_atan_n_n_nc, /* 675 */
+ PARROT_OP_cos_n_n, /* 676 */
+ PARROT_OP_cosh_n_n, /* 677 */
+ PARROT_OP_exp_n_n, /* 678 */
+ PARROT_OP_ln_n_n, /* 679 */
+ PARROT_OP_log10_n_n, /* 680 */
+ PARROT_OP_log2_n_n, /* 681 */
+ PARROT_OP_sec_n_n, /* 682 */
+ PARROT_OP_sech_n_n, /* 683 */
+ PARROT_OP_sin_n_n, /* 684 */
+ PARROT_OP_sinh_n_n, /* 685 */
+ PARROT_OP_tan_n_n, /* 686 */
+ PARROT_OP_tanh_n_n, /* 687 */
+ PARROT_OP_callmethodcc_p_s, /* 688 */
+ PARROT_OP_callmethodcc_p_sc, /* 689 */
+ PARROT_OP_callmethodcc_p_p, /* 690 */
+ PARROT_OP_callmethod_p_s_p, /* 691 */
+ PARROT_OP_callmethod_p_sc_p, /* 692 */
+ PARROT_OP_callmethod_p_p_p, /* 693 */
+ PARROT_OP_tailcallmethod_p_s, /* 694 */
+ PARROT_OP_tailcallmethod_p_sc, /* 695 */
+ PARROT_OP_tailcallmethod_p_p, /* 696 */
+ PARROT_OP_addmethod_p_s_p, /* 697 */
+ PARROT_OP_addmethod_p_sc_p, /* 698 */
+ PARROT_OP_can_i_p_s, /* 699 */
+ PARROT_OP_can_i_p_sc, /* 700 */
+ PARROT_OP_does_i_p_s, /* 701 */
+ PARROT_OP_does_i_p_sc, /* 702 */
+ PARROT_OP_does_i_p_p, /* 703 */
+ PARROT_OP_does_i_p_pc, /* 704 */
+ PARROT_OP_isa_i_p_s, /* 705 */
+ PARROT_OP_isa_i_p_sc, /* 706 */
+ PARROT_OP_isa_i_p_p, /* 707 */
+ PARROT_OP_isa_i_p_pc, /* 708 */
+ PARROT_OP_newclass_p_s, /* 709 */
+ PARROT_OP_newclass_p_sc, /* 710 */
+ PARROT_OP_newclass_p_p, /* 711 */
+ PARROT_OP_newclass_p_pc, /* 712 */
+ PARROT_OP_subclass_p_p, /* 713 */
+ PARROT_OP_subclass_p_pc, /* 714 */
+ PARROT_OP_subclass_p_p_s, /* 715 */
+ PARROT_OP_subclass_p_pc_s, /* 716 */
+ PARROT_OP_subclass_p_p_sc, /* 717 */
+ PARROT_OP_subclass_p_pc_sc, /* 718 */
+ PARROT_OP_subclass_p_p_p, /* 719 */
+ PARROT_OP_subclass_p_pc_p, /* 720 */
+ PARROT_OP_subclass_p_p_pc, /* 721 */
+ PARROT_OP_subclass_p_pc_pc, /* 722 */
+ PARROT_OP_subclass_p_s, /* 723 */
+ PARROT_OP_subclass_p_sc, /* 724 */
+ PARROT_OP_subclass_p_s_s, /* 725 */
+ PARROT_OP_subclass_p_sc_s, /* 726 */
+ PARROT_OP_subclass_p_s_sc, /* 727 */
+ PARROT_OP_subclass_p_sc_sc, /* 728 */
+ PARROT_OP_subclass_p_s_p, /* 729 */
+ PARROT_OP_subclass_p_sc_p, /* 730 */
+ PARROT_OP_subclass_p_s_pc, /* 731 */
+ PARROT_OP_subclass_p_sc_pc, /* 732 */
+ PARROT_OP_get_class_p_s, /* 733 */
+ PARROT_OP_get_class_p_sc, /* 734 */
+ PARROT_OP_get_class_p_p, /* 735 */
+ PARROT_OP_get_class_p_pc, /* 736 */
+ PARROT_OP_class_p_p, /* 737 */
+ PARROT_OP_addparent_p_p, /* 738 */
+ PARROT_OP_removeparent_p_p, /* 739 */
+ PARROT_OP_addrole_p_p, /* 740 */
+ PARROT_OP_addattribute_p_s, /* 741 */
+ PARROT_OP_addattribute_p_sc, /* 742 */
+ PARROT_OP_removeattribute_p_s, /* 743 */
+ PARROT_OP_removeattribute_p_sc, /* 744 */
+ PARROT_OP_getattribute_p_p_s, /* 745 */
+ PARROT_OP_getattribute_p_p_sc, /* 746 */
+ PARROT_OP_getattribute_p_p_p_s, /* 747 */
+ PARROT_OP_getattribute_p_p_pc_s, /* 748 */
+ PARROT_OP_getattribute_p_p_p_sc, /* 749 */
+ PARROT_OP_getattribute_p_p_pc_sc, /* 750 */
+ PARROT_OP_setattribute_p_s_p, /* 751 */
+ PARROT_OP_setattribute_p_sc_p, /* 752 */
+ PARROT_OP_setattribute_p_p_s_p, /* 753 */
+ PARROT_OP_setattribute_p_pc_s_p, /* 754 */
+ PARROT_OP_setattribute_p_p_sc_p, /* 755 */
+ PARROT_OP_setattribute_p_pc_sc_p, /* 756 */
+ PARROT_OP_inspect_p_p, /* 757 */
+ PARROT_OP_inspect_p_pc, /* 758 */
+ PARROT_OP_inspect_p_p_s, /* 759 */
+ PARROT_OP_inspect_p_pc_s, /* 760 */
+ PARROT_OP_inspect_p_p_sc, /* 761 */
+ PARROT_OP_inspect_p_pc_sc, /* 762 */
+ PARROT_OP_new_p_s, /* 763 */
+ PARROT_OP_new_p_sc, /* 764 */
+ PARROT_OP_new_p_s_p, /* 765 */
+ PARROT_OP_new_p_sc_p, /* 766 */
+ PARROT_OP_new_p_s_pc, /* 767 */
+ PARROT_OP_new_p_sc_pc, /* 768 */
+ PARROT_OP_new_p_p, /* 769 */
+ PARROT_OP_new_p_pc, /* 770 */
+ PARROT_OP_new_p_p_p, /* 771 */
+ PARROT_OP_new_p_pc_p, /* 772 */
+ PARROT_OP_new_p_p_pc, /* 773 */
+ PARROT_OP_new_p_pc_pc, /* 774 */
+ PARROT_OP_root_new_p_p, /* 775 */
+ PARROT_OP_root_new_p_pc, /* 776 */
+ PARROT_OP_root_new_p_p_p, /* 777 */
+ PARROT_OP_root_new_p_pc_p, /* 778 */
+ PARROT_OP_root_new_p_p_pc, /* 779 */
+ PARROT_OP_root_new_p_pc_pc, /* 780 */
+ PARROT_OP_typeof_s_p, /* 781 */
+ PARROT_OP_typeof_p_p, /* 782 */
+ PARROT_OP_get_repr_s_p, /* 783 */
+ PARROT_OP_find_method_p_p_s, /* 784 */
+ PARROT_OP_find_method_p_p_sc, /* 785 */
+ PARROT_OP_defined_i_p, /* 786 */
+ PARROT_OP_defined_i_p_ki, /* 787 */
+ PARROT_OP_defined_i_p_kic, /* 788 */
+ PARROT_OP_defined_i_p_k, /* 789 */
+ PARROT_OP_defined_i_p_kc, /* 790 */
+ PARROT_OP_exists_i_p_ki, /* 791 */
+ PARROT_OP_exists_i_p_kic, /* 792 */
+ PARROT_OP_exists_i_p_k, /* 793 */
+ PARROT_OP_exists_i_p_kc, /* 794 */
+ PARROT_OP_delete_p_k, /* 795 */
+ PARROT_OP_delete_p_kc, /* 796 */
+ PARROT_OP_delete_p_ki, /* 797 */
+ PARROT_OP_delete_p_kic, /* 798 */
+ PARROT_OP_elements_i_p, /* 799 */
+ PARROT_OP_push_p_i, /* 800 */
+ PARROT_OP_push_p_ic, /* 801 */
+ PARROT_OP_push_p_n, /* 802 */
+ PARROT_OP_push_p_nc, /* 803 */
+ PARROT_OP_push_p_s, /* 804 */
+ PARROT_OP_push_p_sc, /* 805 */
+ PARROT_OP_push_p_p, /* 806 */
+ PARROT_OP_pop_i_p, /* 807 */
+ PARROT_OP_pop_n_p, /* 808 */
+ PARROT_OP_pop_s_p, /* 809 */
+ PARROT_OP_pop_p_p, /* 810 */
+ PARROT_OP_unshift_p_i, /* 811 */
+ PARROT_OP_unshift_p_ic, /* 812 */
+ PARROT_OP_unshift_p_n, /* 813 */
+ PARROT_OP_unshift_p_nc, /* 814 */
+ PARROT_OP_unshift_p_s, /* 815 */
+ PARROT_OP_unshift_p_sc, /* 816 */
+ PARROT_OP_unshift_p_p, /* 817 */
+ PARROT_OP_shift_i_p, /* 818 */
+ PARROT_OP_shift_n_p, /* 819 */
+ PARROT_OP_shift_s_p, /* 820 */
+ PARROT_OP_shift_p_p, /* 821 */
+ PARROT_OP_splice_p_p_i_i, /* 822 */
+ PARROT_OP_splice_p_p_ic_i, /* 823 */
+ PARROT_OP_splice_p_p_i_ic, /* 824 */
+ PARROT_OP_splice_p_p_ic_ic, /* 825 */
+ PARROT_OP_setprop_p_s_p, /* 826 */
+ PARROT_OP_setprop_p_sc_p, /* 827 */
+ PARROT_OP_getprop_p_s_p, /* 828 */
+ PARROT_OP_getprop_p_sc_p, /* 829 */
+ PARROT_OP_delprop_p_s, /* 830 */
+ PARROT_OP_delprop_p_sc, /* 831 */
+ PARROT_OP_prophash_p_p, /* 832 */
+ PARROT_OP_freeze_s_p, /* 833 */
+ PARROT_OP_thaw_p_s, /* 834 */
+ PARROT_OP_thaw_p_sc, /* 835 */
+ PARROT_OP_add_multi_s_s_p, /* 836 */
+ PARROT_OP_add_multi_sc_s_p, /* 837 */
+ PARROT_OP_add_multi_s_sc_p, /* 838 */
+ PARROT_OP_add_multi_sc_sc_p, /* 839 */
+ PARROT_OP_find_multi_p_s_s, /* 840 */
+ PARROT_OP_find_multi_p_sc_s, /* 841 */
+ PARROT_OP_find_multi_p_s_sc, /* 842 */
+ PARROT_OP_find_multi_p_sc_sc, /* 843 */
+ PARROT_OP_register_p, /* 844 */
+ PARROT_OP_unregister_p, /* 845 */
+ PARROT_OP_box_p_i, /* 846 */
+ PARROT_OP_box_p_ic, /* 847 */
+ PARROT_OP_box_p_n, /* 848 */
+ PARROT_OP_box_p_nc, /* 849 */
+ PARROT_OP_box_p_s, /* 850 */
+ PARROT_OP_box_p_sc, /* 851 */
+ PARROT_OP_iter_p_p, /* 852 */
+ PARROT_OP_morph_p_p, /* 853 */
+ PARROT_OP_morph_p_pc, /* 854 */
+ PARROT_OP_clone_s_s, /* 855 */
+ PARROT_OP_clone_s_sc, /* 856 */
+ PARROT_OP_set_i_i, /* 857 */
+ PARROT_OP_set_i_ic, /* 858 */
+ PARROT_OP_set_i_n, /* 859 */
+ PARROT_OP_set_i_nc, /* 860 */
+ PARROT_OP_set_i_s, /* 861 */
+ PARROT_OP_set_i_sc, /* 862 */
+ PARROT_OP_set_n_n, /* 863 */
+ PARROT_OP_set_n_nc, /* 864 */
+ PARROT_OP_set_n_i, /* 865 */
+ PARROT_OP_set_n_ic, /* 866 */
+ PARROT_OP_set_n_s, /* 867 */
+ PARROT_OP_set_n_sc, /* 868 */
+ PARROT_OP_set_n_p, /* 869 */
+ PARROT_OP_set_s_p, /* 870 */
+ PARROT_OP_set_s_s, /* 871 */
+ PARROT_OP_set_s_sc, /* 872 */
+ PARROT_OP_set_s_i, /* 873 */
+ PARROT_OP_set_s_ic, /* 874 */
+ PARROT_OP_set_s_n, /* 875 */
+ PARROT_OP_set_s_nc, /* 876 */
+ PARROT_OP_set_p_pc, /* 877 */
+ PARROT_OP_set_p_p, /* 878 */
+ PARROT_OP_set_p_i, /* 879 */
+ PARROT_OP_set_p_ic, /* 880 */
+ PARROT_OP_set_p_n, /* 881 */
+ PARROT_OP_set_p_nc, /* 882 */
+ PARROT_OP_set_p_s, /* 883 */
+ PARROT_OP_set_p_sc, /* 884 */
+ PARROT_OP_set_i_p, /* 885 */
+ PARROT_OP_assign_p_p, /* 886 */
+ PARROT_OP_assign_p_i, /* 887 */
+ PARROT_OP_assign_p_ic, /* 888 */
+ PARROT_OP_assign_p_n, /* 889 */
+ PARROT_OP_assign_p_nc, /* 890 */
+ PARROT_OP_assign_p_s, /* 891 */
+ PARROT_OP_assign_p_sc, /* 892 */
+ PARROT_OP_assign_s_s, /* 893 */
+ PARROT_OP_assign_s_sc, /* 894 */
+ PARROT_OP_setref_p_p, /* 895 */
+ PARROT_OP_deref_p_p, /* 896 */
+ PARROT_OP_set_p_ki_i, /* 897 */
+ PARROT_OP_set_p_kic_i, /* 898 */
+ PARROT_OP_set_p_ki_ic, /* 899 */
+ PARROT_OP_set_p_kic_ic, /* 900 */
+ PARROT_OP_set_p_ki_n, /* 901 */
+ PARROT_OP_set_p_kic_n, /* 902 */
+ PARROT_OP_set_p_ki_nc, /* 903 */
+ PARROT_OP_set_p_kic_nc, /* 904 */
+ PARROT_OP_set_p_ki_s, /* 905 */
+ PARROT_OP_set_p_kic_s, /* 906 */
+ PARROT_OP_set_p_ki_sc, /* 907 */
+ PARROT_OP_set_p_kic_sc, /* 908 */
+ PARROT_OP_set_p_ki_p, /* 909 */
+ PARROT_OP_set_p_kic_p, /* 910 */
+ PARROT_OP_set_i_p_ki, /* 911 */
+ PARROT_OP_set_i_p_kic, /* 912 */
+ PARROT_OP_set_n_p_ki, /* 913 */
+ PARROT_OP_set_n_p_kic, /* 914 */
+ PARROT_OP_set_s_p_ki, /* 915 */
+ PARROT_OP_set_s_p_kic, /* 916 */
+ PARROT_OP_set_p_p_ki, /* 917 */
+ PARROT_OP_set_p_p_kic, /* 918 */
+ PARROT_OP_set_p_k_i, /* 919 */
+ PARROT_OP_set_p_kc_i, /* 920 */
+ PARROT_OP_set_p_k_ic, /* 921 */
+ PARROT_OP_set_p_kc_ic, /* 922 */
+ PARROT_OP_set_p_k_n, /* 923 */
+ PARROT_OP_set_p_kc_n, /* 924 */
+ PARROT_OP_set_p_k_nc, /* 925 */
+ PARROT_OP_set_p_kc_nc, /* 926 */
+ PARROT_OP_set_p_k_s, /* 927 */
+ PARROT_OP_set_p_kc_s, /* 928 */
+ PARROT_OP_set_p_k_sc, /* 929 */
+ PARROT_OP_set_p_kc_sc, /* 930 */
+ PARROT_OP_set_p_k_p, /* 931 */
+ PARROT_OP_set_p_kc_p, /* 932 */
+ PARROT_OP_set_i_p_k, /* 933 */
+ PARROT_OP_set_i_p_kc, /* 934 */
+ PARROT_OP_set_n_p_k, /* 935 */
+ PARROT_OP_set_n_p_kc, /* 936 */
+ PARROT_OP_set_s_p_k, /* 937 */
+ PARROT_OP_set_s_p_kc, /* 938 */
+ PARROT_OP_set_p_p_k, /* 939 */
+ PARROT_OP_set_p_p_kc, /* 940 */
+ PARROT_OP_clone_p_p, /* 941 */
+ PARROT_OP_clone_p_p_p, /* 942 */
+ PARROT_OP_clone_p_p_pc, /* 943 */
+ PARROT_OP_copy_p_p, /* 944 */
+ PARROT_OP_null_s, /* 945 */
+ PARROT_OP_null_i, /* 946 */
+ PARROT_OP_null_p, /* 947 */
+ PARROT_OP_null_n, /* 948 */
+ PARROT_OP_ord_i_s, /* 949 */
+ PARROT_OP_ord_i_sc, /* 950 */
+ PARROT_OP_ord_i_s_i, /* 951 */
+ PARROT_OP_ord_i_sc_i, /* 952 */
+ PARROT_OP_ord_i_s_ic, /* 953 */
+ PARROT_OP_ord_i_sc_ic, /* 954 */
+ PARROT_OP_chr_s_i, /* 955 */
+ PARROT_OP_chr_s_ic, /* 956 */
+ PARROT_OP_chopn_s_s_i, /* 957 */
+ PARROT_OP_chopn_s_sc_i, /* 958 */
+ PARROT_OP_chopn_s_s_ic, /* 959 */
+ PARROT_OP_chopn_s_sc_ic, /* 960 */
+ PARROT_OP_concat_s_s, /* 961 */
+ PARROT_OP_concat_s_sc, /* 962 */
+ PARROT_OP_concat_p_p, /* 963 */
+ PARROT_OP_concat_p_s, /* 964 */
+ PARROT_OP_concat_p_sc, /* 965 */
+ PARROT_OP_concat_s_s_s, /* 966 */
+ PARROT_OP_concat_s_sc_s, /* 967 */
+ PARROT_OP_concat_s_s_sc, /* 968 */
+ PARROT_OP_concat_p_p_s, /* 969 */
+ PARROT_OP_concat_p_p_sc, /* 970 */
+ PARROT_OP_concat_p_p_p, /* 971 */
+ PARROT_OP_repeat_s_s_i, /* 972 */
+ PARROT_OP_repeat_s_sc_i, /* 973 */
+ PARROT_OP_repeat_s_s_ic, /* 974 */
+ PARROT_OP_repeat_s_sc_ic, /* 975 */
+ PARROT_OP_repeat_p_p_i, /* 976 */
+ PARROT_OP_repeat_p_p_ic, /* 977 */
+ PARROT_OP_repeat_p_p_p, /* 978 */
+ PARROT_OP_repeat_p_i, /* 979 */
+ PARROT_OP_repeat_p_ic, /* 980 */
+ PARROT_OP_repeat_p_p, /* 981 */
+ PARROT_OP_length_i_s, /* 982 */
+ PARROT_OP_length_i_sc, /* 983 */
+ PARROT_OP_bytelength_i_s, /* 984 */
+ PARROT_OP_bytelength_i_sc, /* 985 */
+ PARROT_OP_pin_s, /* 986 */
+ PARROT_OP_unpin_s, /* 987 */
+ PARROT_OP_substr_s_s_i, /* 988 */
+ PARROT_OP_substr_s_sc_i, /* 989 */
+ PARROT_OP_substr_s_s_ic, /* 990 */
+ PARROT_OP_substr_s_sc_ic, /* 991 */
+ PARROT_OP_substr_s_s_i_i, /* 992 */
+ PARROT_OP_substr_s_sc_i_i, /* 993 */
+ PARROT_OP_substr_s_s_ic_i, /* 994 */
+ PARROT_OP_substr_s_sc_ic_i, /* 995 */
+ PARROT_OP_substr_s_s_i_ic, /* 996 */
+ PARROT_OP_substr_s_sc_i_ic, /* 997 */
+ PARROT_OP_substr_s_s_ic_ic, /* 998 */
+ PARROT_OP_substr_s_sc_ic_ic, /* 999 */
+ PARROT_OP_substr_s_p_i_i, /* 1000 */
+ PARROT_OP_substr_s_p_ic_i, /* 1001 */
+ PARROT_OP_substr_s_p_i_ic, /* 1002 */
+ PARROT_OP_substr_s_p_ic_ic, /* 1003 */
+ PARROT_OP_replace_s_s_i_i_s, /* 1004 */
+ PARROT_OP_replace_s_sc_i_i_s, /* 1005 */
+ PARROT_OP_replace_s_s_ic_i_s, /* 1006 */
+ PARROT_OP_replace_s_sc_ic_i_s, /* 1007 */
+ PARROT_OP_replace_s_s_i_ic_s, /* 1008 */
+ PARROT_OP_replace_s_sc_i_ic_s, /* 1009 */
+ PARROT_OP_replace_s_s_ic_ic_s, /* 1010 */
+ PARROT_OP_replace_s_sc_ic_ic_s, /* 1011 */
+ PARROT_OP_replace_s_s_i_i_sc, /* 1012 */
+ PARROT_OP_replace_s_sc_i_i_sc, /* 1013 */
+ PARROT_OP_replace_s_s_ic_i_sc, /* 1014 */
+ PARROT_OP_replace_s_sc_ic_i_sc, /* 1015 */
+ PARROT_OP_replace_s_s_i_ic_sc, /* 1016 */
+ PARROT_OP_replace_s_sc_i_ic_sc, /* 1017 */
+ PARROT_OP_replace_s_s_ic_ic_sc, /* 1018 */
+ PARROT_OP_replace_s_sc_ic_ic_sc, /* 1019 */
+ PARROT_OP_index_i_s_s, /* 1020 */
+ PARROT_OP_index_i_sc_s, /* 1021 */
+ PARROT_OP_index_i_s_sc, /* 1022 */
+ PARROT_OP_index_i_sc_sc, /* 1023 */
+ PARROT_OP_index_i_s_s_i, /* 1024 */
+ PARROT_OP_index_i_sc_s_i, /* 1025 */
+ PARROT_OP_index_i_s_sc_i, /* 1026 */
+ PARROT_OP_index_i_sc_sc_i, /* 1027 */
+ PARROT_OP_index_i_s_s_ic, /* 1028 */
+ PARROT_OP_index_i_sc_s_ic, /* 1029 */
+ PARROT_OP_index_i_s_sc_ic, /* 1030 */
+ PARROT_OP_index_i_sc_sc_ic, /* 1031 */
+ PARROT_OP_sprintf_s_s_p, /* 1032 */
+ PARROT_OP_sprintf_s_sc_p, /* 1033 */
+ PARROT_OP_sprintf_p_p_p, /* 1034 */
+ PARROT_OP_new_s, /* 1035 */
+ PARROT_OP_new_s_i, /* 1036 */
+ PARROT_OP_new_s_ic, /* 1037 */
+ PARROT_OP_stringinfo_i_s_i, /* 1038 */
+ PARROT_OP_stringinfo_i_sc_i, /* 1039 */
+ PARROT_OP_stringinfo_i_s_ic, /* 1040 */
+ PARROT_OP_stringinfo_i_sc_ic, /* 1041 */
+ PARROT_OP_upcase_s_s, /* 1042 */
+ PARROT_OP_upcase_s_sc, /* 1043 */
+ PARROT_OP_downcase_s_s, /* 1044 */
+ PARROT_OP_downcase_s_sc, /* 1045 */
+ PARROT_OP_titlecase_s_s, /* 1046 */
+ PARROT_OP_titlecase_s_sc, /* 1047 */
+ PARROT_OP_join_s_s_p, /* 1048 */
+ PARROT_OP_join_s_sc_p, /* 1049 */
+ PARROT_OP_split_p_s_s, /* 1050 */
+ PARROT_OP_split_p_sc_s, /* 1051 */
+ PARROT_OP_split_p_s_sc, /* 1052 */
+ PARROT_OP_split_p_sc_sc, /* 1053 */
+ PARROT_OP_charset_i_s, /* 1054 */
+ PARROT_OP_charset_i_sc, /* 1055 */
+ PARROT_OP_charsetname_s_i, /* 1056 */
+ PARROT_OP_charsetname_s_ic, /* 1057 */
+ PARROT_OP_find_charset_i_s, /* 1058 */
+ PARROT_OP_find_charset_i_sc, /* 1059 */
+ PARROT_OP_trans_charset_s_s_i, /* 1060 */
+ PARROT_OP_trans_charset_s_sc_i, /* 1061 */
+ PARROT_OP_trans_charset_s_s_ic, /* 1062 */
+ PARROT_OP_trans_charset_s_sc_ic, /* 1063 */
+ PARROT_OP_encoding_i_s, /* 1064 */
+ PARROT_OP_encoding_i_sc, /* 1065 */
+ PARROT_OP_encodingname_s_i, /* 1066 */
+ PARROT_OP_encodingname_s_ic, /* 1067 */
+ PARROT_OP_find_encoding_i_s, /* 1068 */
+ PARROT_OP_find_encoding_i_sc, /* 1069 */
+ PARROT_OP_trans_encoding_s_s_i, /* 1070 */
+ PARROT_OP_trans_encoding_s_sc_i, /* 1071 */
+ PARROT_OP_trans_encoding_s_s_ic, /* 1072 */
+ PARROT_OP_trans_encoding_s_sc_ic, /* 1073 */
+ PARROT_OP_is_cclass_i_i_s_i, /* 1074 */
+ PARROT_OP_is_cclass_i_ic_s_i, /* 1075 */
+ PARROT_OP_is_cclass_i_i_sc_i, /* 1076 */
+ PARROT_OP_is_cclass_i_ic_sc_i, /* 1077 */
+ PARROT_OP_is_cclass_i_i_s_ic, /* 1078 */
+ PARROT_OP_is_cclass_i_ic_s_ic, /* 1079 */
+ PARROT_OP_is_cclass_i_i_sc_ic, /* 1080 */
+ PARROT_OP_is_cclass_i_ic_sc_ic, /* 1081 */
+ PARROT_OP_find_cclass_i_i_s_i_i, /* 1082 */
+ PARROT_OP_find_cclass_i_ic_s_i_i, /* 1083 */
+ PARROT_OP_find_cclass_i_i_sc_i_i, /* 1084 */
+ PARROT_OP_find_cclass_i_ic_sc_i_i, /* 1085 */
+ PARROT_OP_find_cclass_i_i_s_ic_i, /* 1086 */
+ PARROT_OP_find_cclass_i_ic_s_ic_i, /* 1087 */
+ PARROT_OP_find_cclass_i_i_sc_ic_i, /* 1088 */
+ PARROT_OP_find_cclass_i_ic_sc_ic_i, /* 1089 */
+ PARROT_OP_find_cclass_i_i_s_i_ic, /* 1090 */
+ PARROT_OP_find_cclass_i_ic_s_i_ic, /* 1091 */
+ PARROT_OP_find_cclass_i_i_sc_i_ic, /* 1092 */
+ PARROT_OP_find_cclass_i_ic_sc_i_ic, /* 1093 */
+ PARROT_OP_find_cclass_i_i_s_ic_ic, /* 1094 */
+ PARROT_OP_find_cclass_i_ic_s_ic_ic, /* 1095 */
+ PARROT_OP_find_cclass_i_i_sc_ic_ic, /* 1096 */
+ PARROT_OP_find_cclass_i_ic_sc_ic_ic, /* 1097 */
+ PARROT_OP_find_not_cclass_i_i_s_i_i, /* 1098 */
+ PARROT_OP_find_not_cclass_i_ic_s_i_i, /* 1099 */
+ PARROT_OP_find_not_cclass_i_i_sc_i_i, /* 1100 */
+ PARROT_OP_find_not_cclass_i_ic_sc_i_i, /* 1101 */
+ PARROT_OP_find_not_cclass_i_i_s_ic_i, /* 1102 */
+ PARROT_OP_find_not_cclass_i_ic_s_ic_i, /* 1103 */
+ PARROT_OP_find_not_cclass_i_i_sc_ic_i, /* 1104 */
+ PARROT_OP_find_not_cclass_i_ic_sc_ic_i, /* 1105 */
+ PARROT_OP_find_not_cclass_i_i_s_i_ic, /* 1106 */
+ PARROT_OP_find_not_cclass_i_ic_s_i_ic, /* 1107 */
+ PARROT_OP_find_not_cclass_i_i_sc_i_ic, /* 1108 */
+ PARROT_OP_find_not_cclass_i_ic_sc_i_ic, /* 1109 */
+ PARROT_OP_find_not_cclass_i_i_s_ic_ic, /* 1110 */
+ PARROT_OP_find_not_cclass_i_ic_s_ic_ic, /* 1111 */
+ PARROT_OP_find_not_cclass_i_i_sc_ic_ic, /* 1112 */
+ PARROT_OP_find_not_cclass_i_ic_sc_ic_ic, /* 1113 */
+ PARROT_OP_escape_s_s, /* 1114 */
+ PARROT_OP_compose_s_s, /* 1115 */
+ PARROT_OP_compose_s_sc, /* 1116 */
+ PARROT_OP_spawnw_i_s, /* 1117 */
+ PARROT_OP_spawnw_i_sc, /* 1118 */
+ PARROT_OP_spawnw_i_p, /* 1119 */
+ PARROT_OP_err_i, /* 1120 */
+ PARROT_OP_err_s, /* 1121 */
+ PARROT_OP_err_s_i, /* 1122 */
+ PARROT_OP_err_s_ic, /* 1123 */
+ PARROT_OP_time_i, /* 1124 */
+ PARROT_OP_time_n, /* 1125 */
+ PARROT_OP_gmtime_s_i, /* 1126 */
+ PARROT_OP_gmtime_s_ic, /* 1127 */
+ PARROT_OP_localtime_s_i, /* 1128 */
+ PARROT_OP_localtime_s_ic, /* 1129 */
+ PARROT_OP_decodetime_p_i, /* 1130 */
+ PARROT_OP_decodetime_p_ic, /* 1131 */
+ PARROT_OP_decodelocaltime_p_i, /* 1132 */
+ PARROT_OP_decodelocaltime_p_ic, /* 1133 */
+ PARROT_OP_sysinfo_s_i, /* 1134 */
+ PARROT_OP_sysinfo_s_ic, /* 1135 */
+ PARROT_OP_sysinfo_i_i, /* 1136 */
+ PARROT_OP_sysinfo_i_ic, /* 1137 */
+ PARROT_OP_sleep_i, /* 1138 */
+ PARROT_OP_sleep_ic, /* 1139 */
+ PARROT_OP_sleep_n, /* 1140 */
+ PARROT_OP_sleep_nc, /* 1141 */
+ PARROT_OP_store_lex_s_p, /* 1142 */
+ PARROT_OP_store_lex_sc_p, /* 1143 */
+ PARROT_OP_store_dynamic_lex_s_p, /* 1144 */
+ PARROT_OP_store_dynamic_lex_sc_p, /* 1145 */
+ PARROT_OP_find_lex_p_s, /* 1146 */
+ PARROT_OP_find_lex_p_sc, /* 1147 */
+ PARROT_OP_find_dynamic_lex_p_s, /* 1148 */
+ PARROT_OP_find_dynamic_lex_p_sc, /* 1149 */
+ PARROT_OP_find_caller_lex_p_s, /* 1150 */
+ PARROT_OP_find_caller_lex_p_sc, /* 1151 */
+ PARROT_OP_get_namespace_p, /* 1152 */
+ PARROT_OP_get_namespace_p_p, /* 1153 */
+ PARROT_OP_get_namespace_p_pc, /* 1154 */
+ PARROT_OP_get_hll_namespace_p, /* 1155 */
+ PARROT_OP_get_hll_namespace_p_p, /* 1156 */
+ PARROT_OP_get_hll_namespace_p_pc, /* 1157 */
+ PARROT_OP_get_root_namespace_p, /* 1158 */
+ PARROT_OP_get_root_namespace_p_p, /* 1159 */
+ PARROT_OP_get_root_namespace_p_pc, /* 1160 */
+ PARROT_OP_get_global_p_s, /* 1161 */
+ PARROT_OP_get_global_p_sc, /* 1162 */
+ PARROT_OP_get_global_p_p_s, /* 1163 */
+ PARROT_OP_get_global_p_pc_s, /* 1164 */
+ PARROT_OP_get_global_p_p_sc, /* 1165 */
+ PARROT_OP_get_global_p_pc_sc, /* 1166 */
+ PARROT_OP_get_hll_global_p_s, /* 1167 */
+ PARROT_OP_get_hll_global_p_sc, /* 1168 */
+ PARROT_OP_get_hll_global_p_p_s, /* 1169 */
+ PARROT_OP_get_hll_global_p_pc_s, /* 1170 */
+ PARROT_OP_get_hll_global_p_p_sc, /* 1171 */
+ PARROT_OP_get_hll_global_p_pc_sc, /* 1172 */
+ PARROT_OP_get_root_global_p_s, /* 1173 */
+ PARROT_OP_get_root_global_p_sc, /* 1174 */
+ PARROT_OP_get_root_global_p_p_s, /* 1175 */
+ PARROT_OP_get_root_global_p_pc_s, /* 1176 */
+ PARROT_OP_get_root_global_p_p_sc, /* 1177 */
+ PARROT_OP_get_root_global_p_pc_sc, /* 1178 */
+ PARROT_OP_set_global_s_p, /* 1179 */
+ PARROT_OP_set_global_sc_p, /* 1180 */
+ PARROT_OP_set_global_p_s_p, /* 1181 */
+ PARROT_OP_set_global_pc_s_p, /* 1182 */
+ PARROT_OP_set_global_p_sc_p, /* 1183 */
+ PARROT_OP_set_global_pc_sc_p, /* 1184 */
+ PARROT_OP_set_hll_global_s_p, /* 1185 */
+ PARROT_OP_set_hll_global_sc_p, /* 1186 */
+ PARROT_OP_set_hll_global_p_s_p, /* 1187 */
+ PARROT_OP_set_hll_global_pc_s_p, /* 1188 */
+ PARROT_OP_set_hll_global_p_sc_p, /* 1189 */
+ PARROT_OP_set_hll_global_pc_sc_p, /* 1190 */
+ PARROT_OP_set_root_global_s_p, /* 1191 */
+ PARROT_OP_set_root_global_sc_p, /* 1192 */
+ PARROT_OP_set_root_global_p_s_p, /* 1193 */
+ PARROT_OP_set_root_global_pc_s_p, /* 1194 */
+ PARROT_OP_set_root_global_p_sc_p, /* 1195 */
+ PARROT_OP_set_root_global_pc_sc_p, /* 1196 */
+ PARROT_OP_find_name_p_s, /* 1197 */
+ PARROT_OP_find_name_p_sc, /* 1198 */
+ PARROT_OP_find_sub_not_null_p_s, /* 1199 */
+ PARROT_OP_find_sub_not_null_p_sc, /* 1200 */
+ PARROT_OP_trap, /* 1201 */
+ PARROT_OP_set_label_p_ic, /* 1202 */
+ PARROT_OP_get_label_i_p, /* 1203 */
+ PARROT_OP_fetch_p_p_p_p, /* 1204 */
+ PARROT_OP_fetch_p_pc_p_p, /* 1205 */
+ PARROT_OP_fetch_p_p_pc_p, /* 1206 */
+ PARROT_OP_fetch_p_pc_pc_p, /* 1207 */
+ PARROT_OP_fetch_p_p_p_pc, /* 1208 */
+ PARROT_OP_fetch_p_pc_p_pc, /* 1209 */
+ PARROT_OP_fetch_p_p_pc_pc, /* 1210 */
+ PARROT_OP_fetch_p_pc_pc_pc, /* 1211 */
+ PARROT_OP_fetch_p_p_i_p, /* 1212 */
+ PARROT_OP_fetch_p_pc_i_p, /* 1213 */
+ PARROT_OP_fetch_p_p_ic_p, /* 1214 */
+ PARROT_OP_fetch_p_pc_ic_p, /* 1215 */
+ PARROT_OP_fetch_p_p_i_pc, /* 1216 */
+ PARROT_OP_fetch_p_pc_i_pc, /* 1217 */
+ PARROT_OP_fetch_p_p_ic_pc, /* 1218 */
+ PARROT_OP_fetch_p_pc_ic_pc, /* 1219 */
+ PARROT_OP_fetch_p_p_s_p, /* 1220 */
+ PARROT_OP_fetch_p_pc_s_p, /* 1221 */
+ PARROT_OP_fetch_p_p_sc_p, /* 1222 */
+ PARROT_OP_fetch_p_pc_sc_p, /* 1223 */
+ PARROT_OP_fetch_p_p_s_pc, /* 1224 */
+ PARROT_OP_fetch_p_pc_s_pc, /* 1225 */
+ PARROT_OP_fetch_p_p_sc_pc, /* 1226 */
+ PARROT_OP_fetch_p_pc_sc_pc, /* 1227 */
+ PARROT_OP_vivify_p_p_p_p, /* 1228 */
+ PARROT_OP_vivify_p_pc_p_p, /* 1229 */
+ PARROT_OP_vivify_p_p_pc_p, /* 1230 */
+ PARROT_OP_vivify_p_pc_pc_p, /* 1231 */
+ PARROT_OP_vivify_p_p_p_pc, /* 1232 */
+ PARROT_OP_vivify_p_pc_p_pc, /* 1233 */
+ PARROT_OP_vivify_p_p_pc_pc, /* 1234 */
+ PARROT_OP_vivify_p_pc_pc_pc, /* 1235 */
+ PARROT_OP_vivify_p_p_i_p, /* 1236 */
+ PARROT_OP_vivify_p_pc_i_p, /* 1237 */
+ PARROT_OP_vivify_p_p_ic_p, /* 1238 */
+ PARROT_OP_vivify_p_pc_ic_p, /* 1239 */
+ PARROT_OP_vivify_p_p_i_pc, /* 1240 */
+ PARROT_OP_vivify_p_pc_i_pc, /* 1241 */
+ PARROT_OP_vivify_p_p_ic_pc, /* 1242 */
+ PARROT_OP_vivify_p_pc_ic_pc, /* 1243 */
+ PARROT_OP_vivify_p_p_s_p, /* 1244 */
+ PARROT_OP_vivify_p_pc_s_p, /* 1245 */
+ PARROT_OP_vivify_p_p_sc_p, /* 1246 */
+ PARROT_OP_vivify_p_pc_sc_p, /* 1247 */
+ PARROT_OP_vivify_p_p_s_pc, /* 1248 */
+ PARROT_OP_vivify_p_pc_s_pc, /* 1249 */
+ PARROT_OP_vivify_p_p_sc_pc, /* 1250 */
+ PARROT_OP_vivify_p_pc_sc_pc, /* 1251 */
+ PARROT_OP_new_p_s_i, /* 1252 */
+ PARROT_OP_new_p_sc_i, /* 1253 */
+ PARROT_OP_new_p_s_ic, /* 1254 */
+ PARROT_OP_new_p_sc_ic, /* 1255 */
+ PARROT_OP_new_p_p_i, /* 1256 */
+ PARROT_OP_new_p_pc_i, /* 1257 */
+ PARROT_OP_new_p_p_ic, /* 1258 */
+ PARROT_OP_new_p_pc_ic, /* 1259 */
+ PARROT_OP_root_new_p_p_i, /* 1260 */
+ PARROT_OP_root_new_p_pc_i, /* 1261 */
+ PARROT_OP_root_new_p_p_ic, /* 1262 */
+ PARROT_OP_root_new_p_pc_ic, /* 1263 */
+ PARROT_OP_find_codepoint_i_s, /* 1264 */
+ PARROT_OP_find_codepoint_i_sc, /* 1265 */
+ PARROT_OP_unroll_p, /* 1266 */
+ PARROT_OP_unroll_pc /* 1267 */
+
+} parrot_opcode_enums;
+
+
+#endif /* PARROT_OPLIB_OPS_H_GUARD */
+
+
+/*
+ * Local variables:
+ * c-file-style: "parrot"
+ * buffer-read-only: t
+ * End:
+ * vim: expandtab shiftwidth=4:
+ */
Added: trunk/include/parrot/opsenum.h
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/include/parrot/opsenum.h Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,1226 @@
+
+/* $Id$ */
+
+#ifndef PARROT_OPSENUM_H_GUARD
+#define PARROT_OPSENUM_H_GUARD
+
+
+/* ex: set ro:
+ * !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
+ *
+ * This file is generated automatically from 'src/ops/core.ops' (and possibly other
+ * .ops files). by ops2c.nqp.
+ *
+ * Any changes made here will be lost!
+ *
+ */
+enum OPS_ENUM {
+ enum_ops_load_bytecode_s = 5,
+ enum_ops_load_bytecode_sc = 6,
+ enum_ops_load_language_s = 7,
+ enum_ops_load_language_sc = 8,
+ enum_ops_branch_i = 9,
+ enum_ops_branch_ic = 10,
+ enum_ops_local_branch_p_i = 11,
+ enum_ops_local_branch_p_ic = 12,
+ enum_ops_local_return_p = 13,
+ enum_ops_jump_i = 14,
+ enum_ops_jump_ic = 15,
+ enum_ops_enternative = 16,
+ enum_ops_if_i_ic = 17,
+ enum_ops_if_n_ic = 18,
+ enum_ops_if_s_ic = 19,
+ enum_ops_if_p_ic = 20,
+ enum_ops_unless_i_ic = 21,
+ enum_ops_unless_n_ic = 22,
+ enum_ops_unless_s_ic = 23,
+ enum_ops_unless_p_ic = 24,
+ enum_ops_invokecc_p = 25,
+ enum_ops_invoke_p_p = 26,
+ enum_ops_yield = 27,
+ enum_ops_tailcall_p = 28,
+ enum_ops_returncc = 29,
+ enum_ops_capture_lex_p = 30,
+ enum_ops_newclosure_p_p = 31,
+ enum_ops_set_args_pc = 32,
+ enum_ops_get_params_pc = 33,
+ enum_ops_set_returns_pc = 34,
+ enum_ops_get_results_pc = 35,
+ enum_ops_set_result_info_p = 36,
+ enum_ops_set_result_info_pc = 37,
+ enum_ops_result_info_p = 38,
+ enum_ops_set_addr_i_ic = 39,
+ enum_ops_set_addr_p_ic = 40,
+ enum_ops_set_addr_p_i = 41,
+ enum_ops_get_addr_i_p = 42,
+ enum_ops_schedule_p = 43,
+ enum_ops_addhandler_p = 44,
+ enum_ops_push_eh_ic = 45,
+ enum_ops_push_eh_p = 46,
+ enum_ops_pop_eh = 47,
+ enum_ops_throw_p = 48,
+ enum_ops_throw_p_p = 49,
+ enum_ops_rethrow_p = 50,
+ enum_ops_count_eh_i = 51,
+ enum_ops_die_s = 52,
+ enum_ops_die_sc = 53,
+ enum_ops_die_p = 54,
+ enum_ops_die_pc = 55,
+ enum_ops_die_i_i = 56,
+ enum_ops_die_ic_i = 57,
+ enum_ops_die_i_ic = 58,
+ enum_ops_die_ic_ic = 59,
+ enum_ops_exit_i = 60,
+ enum_ops_exit_ic = 61,
+ enum_ops_debug_i = 62,
+ enum_ops_debug_ic = 63,
+ enum_ops_bounds_i = 64,
+ enum_ops_bounds_ic = 65,
+ enum_ops_profile_i = 66,
+ enum_ops_profile_ic = 67,
+ enum_ops_trace_i = 68,
+ enum_ops_trace_ic = 69,
+ enum_ops_gc_debug_i = 70,
+ enum_ops_gc_debug_ic = 71,
+ enum_ops_interpinfo_i_i = 72,
+ enum_ops_interpinfo_i_ic = 73,
+ enum_ops_interpinfo_p_i = 74,
+ enum_ops_interpinfo_p_ic = 75,
+ enum_ops_interpinfo_s_i = 76,
+ enum_ops_interpinfo_s_ic = 77,
+ enum_ops_warningson_i = 78,
+ enum_ops_warningson_ic = 79,
+ enum_ops_warningsoff_i = 80,
+ enum_ops_warningsoff_ic = 81,
+ enum_ops_errorson_i = 82,
+ enum_ops_errorson_ic = 83,
+ enum_ops_errorsoff_i = 84,
+ enum_ops_errorsoff_ic = 85,
+ enum_ops_runinterp_p_i = 86,
+ enum_ops_runinterp_p_ic = 87,
+ enum_ops_getinterp_p = 88,
+ enum_ops_sweep_ic = 89,
+ enum_ops_collect = 90,
+ enum_ops_sweepoff = 91,
+ enum_ops_sweepon = 92,
+ enum_ops_collectoff = 93,
+ enum_ops_collecton = 94,
+ enum_ops_needs_destroy_p = 95,
+ enum_ops_loadlib_p_s = 96,
+ enum_ops_loadlib_p_sc = 97,
+ enum_ops_loadlib_p_s_p = 98,
+ enum_ops_loadlib_p_sc_p = 99,
+ enum_ops_loadlib_p_s_pc = 100,
+ enum_ops_loadlib_p_sc_pc = 101,
+ enum_ops_dlfunc_p_p_s_s = 102,
+ enum_ops_dlfunc_p_p_sc_s = 103,
+ enum_ops_dlfunc_p_p_s_sc = 104,
+ enum_ops_dlfunc_p_p_sc_sc = 105,
+ enum_ops_dlvar_p_p_s = 106,
+ enum_ops_dlvar_p_p_sc = 107,
+ enum_ops_compreg_s_p = 108,
+ enum_ops_compreg_sc_p = 109,
+ enum_ops_compreg_p_s = 110,
+ enum_ops_compreg_p_sc = 111,
+ enum_ops_new_callback_p_p_p_s = 112,
+ enum_ops_new_callback_p_p_p_sc = 113,
+ enum_ops_annotations_p = 114,
+ enum_ops_annotations_p_s = 115,
+ enum_ops_annotations_p_sc = 116,
+ enum_ops_band_i_i = 117,
+ enum_ops_band_i_ic = 118,
+ enum_ops_band_p_i = 119,
+ enum_ops_band_p_ic = 120,
+ enum_ops_band_p_p = 121,
+ enum_ops_band_i_i_i = 122,
+ enum_ops_band_i_ic_i = 123,
+ enum_ops_band_i_i_ic = 124,
+ enum_ops_band_p_p_i = 125,
+ enum_ops_band_p_p_ic = 126,
+ enum_ops_band_p_p_p = 127,
+ enum_ops_bands_p_s = 128,
+ enum_ops_bands_p_sc = 129,
+ enum_ops_bands_p_p = 130,
+ enum_ops_bands_s_s_s = 131,
+ enum_ops_bands_s_sc_s = 132,
+ enum_ops_bands_s_s_sc = 133,
+ enum_ops_bands_p_p_s = 134,
+ enum_ops_bands_p_p_sc = 135,
+ enum_ops_bands_p_p_p = 136,
+ enum_ops_bnot_i = 137,
+ enum_ops_bnot_i_i = 138,
+ enum_ops_bnot_p = 139,
+ enum_ops_bnot_p_p = 140,
+ enum_ops_bnots_s_s = 141,
+ enum_ops_bnots_s_sc = 142,
+ enum_ops_bnots_p = 143,
+ enum_ops_bnots_p_p = 144,
+ enum_ops_bor_i_i = 145,
+ enum_ops_bor_i_ic = 146,
+ enum_ops_bor_p_i = 147,
+ enum_ops_bor_p_ic = 148,
+ enum_ops_bor_p_p = 149,
+ enum_ops_bor_i_i_i = 150,
+ enum_ops_bor_i_ic_i = 151,
+ enum_ops_bor_i_i_ic = 152,
+ enum_ops_bor_p_p_i = 153,
+ enum_ops_bor_p_p_ic = 154,
+ enum_ops_bor_p_p_p = 155,
+ enum_ops_bors_p_s = 156,
+ enum_ops_bors_p_sc = 157,
+ enum_ops_bors_p_p = 158,
+ enum_ops_bors_s_s_s = 159,
+ enum_ops_bors_s_sc_s = 160,
+ enum_ops_bors_s_s_sc = 161,
+ enum_ops_bors_p_p_s = 162,
+ enum_ops_bors_p_p_sc = 163,
+ enum_ops_bors_p_p_p = 164,
+ enum_ops_shl_i_i = 165,
+ enum_ops_shl_i_ic = 166,
+ enum_ops_shl_p_i = 167,
+ enum_ops_shl_p_ic = 168,
+ enum_ops_shl_p_p = 169,
+ enum_ops_shl_i_i_i = 170,
+ enum_ops_shl_i_ic_i = 171,
+ enum_ops_shl_i_i_ic = 172,
+ enum_ops_shl_p_p_i = 173,
+ enum_ops_shl_p_p_ic = 174,
+ enum_ops_shl_p_p_p = 175,
+ enum_ops_shr_i_i = 176,
+ enum_ops_shr_i_ic = 177,
+ enum_ops_shr_p_i = 178,
+ enum_ops_shr_p_ic = 179,
+ enum_ops_shr_p_p = 180,
+ enum_ops_shr_i_i_i = 181,
+ enum_ops_shr_i_ic_i = 182,
+ enum_ops_shr_i_i_ic = 183,
+ enum_ops_shr_p_p_i = 184,
+ enum_ops_shr_p_p_ic = 185,
+ enum_ops_shr_p_p_p = 186,
+ enum_ops_lsr_i_i = 187,
+ enum_ops_lsr_i_ic = 188,
+ enum_ops_lsr_p_i = 189,
+ enum_ops_lsr_p_ic = 190,
+ enum_ops_lsr_p_p = 191,
+ enum_ops_lsr_i_i_i = 192,
+ enum_ops_lsr_i_ic_i = 193,
+ enum_ops_lsr_i_i_ic = 194,
+ enum_ops_lsr_p_p_i = 195,
+ enum_ops_lsr_p_p_ic = 196,
+ enum_ops_lsr_p_p_p = 197,
+ enum_ops_rot_i_i_i_ic = 198,
+ enum_ops_rot_i_ic_i_ic = 199,
+ enum_ops_rot_i_i_ic_ic = 200,
+ enum_ops_bxor_i_i = 201,
+ enum_ops_bxor_i_ic = 202,
+ enum_ops_bxor_p_i = 203,
+ enum_ops_bxor_p_ic = 204,
+ enum_ops_bxor_p_p = 205,
+ enum_ops_bxor_i_i_i = 206,
+ enum_ops_bxor_i_ic_i = 207,
+ enum_ops_bxor_i_i_ic = 208,
+ enum_ops_bxor_p_p_i = 209,
+ enum_ops_bxor_p_p_ic = 210,
+ enum_ops_bxor_p_p_p = 211,
+ enum_ops_bxors_p_s = 212,
+ enum_ops_bxors_p_sc = 213,
+ enum_ops_bxors_p_p = 214,
+ enum_ops_bxors_s_s_s = 215,
+ enum_ops_bxors_s_sc_s = 216,
+ enum_ops_bxors_s_s_sc = 217,
+ enum_ops_bxors_p_p_s = 218,
+ enum_ops_bxors_p_p_sc = 219,
+ enum_ops_bxors_p_p_p = 220,
+ enum_ops_eq_i_i_ic = 221,
+ enum_ops_eq_ic_i_ic = 222,
+ enum_ops_eq_i_ic_ic = 223,
+ enum_ops_eq_n_n_ic = 224,
+ enum_ops_eq_nc_n_ic = 225,
+ enum_ops_eq_n_nc_ic = 226,
+ enum_ops_eq_s_s_ic = 227,
+ enum_ops_eq_sc_s_ic = 228,
+ enum_ops_eq_s_sc_ic = 229,
+ enum_ops_eq_p_p_ic = 230,
+ enum_ops_eq_p_i_ic = 231,
+ enum_ops_eq_p_ic_ic = 232,
+ enum_ops_eq_p_n_ic = 233,
+ enum_ops_eq_p_nc_ic = 234,
+ enum_ops_eq_p_s_ic = 235,
+ enum_ops_eq_p_sc_ic = 236,
+ enum_ops_eq_str_p_p_ic = 237,
+ enum_ops_eq_num_p_p_ic = 238,
+ enum_ops_eq_addr_s_s_ic = 239,
+ enum_ops_eq_addr_sc_s_ic = 240,
+ enum_ops_eq_addr_s_sc_ic = 241,
+ enum_ops_eq_addr_sc_sc_ic = 242,
+ enum_ops_eq_addr_p_p_ic = 243,
+ enum_ops_ne_i_i_ic = 244,
+ enum_ops_ne_ic_i_ic = 245,
+ enum_ops_ne_i_ic_ic = 246,
+ enum_ops_ne_n_n_ic = 247,
+ enum_ops_ne_nc_n_ic = 248,
+ enum_ops_ne_n_nc_ic = 249,
+ enum_ops_ne_s_s_ic = 250,
+ enum_ops_ne_sc_s_ic = 251,
+ enum_ops_ne_s_sc_ic = 252,
+ enum_ops_ne_p_p_ic = 253,
+ enum_ops_ne_p_i_ic = 254,
+ enum_ops_ne_p_ic_ic = 255,
+ enum_ops_ne_p_n_ic = 256,
+ enum_ops_ne_p_nc_ic = 257,
+ enum_ops_ne_p_s_ic = 258,
+ enum_ops_ne_p_sc_ic = 259,
+ enum_ops_ne_str_p_p_ic = 260,
+ enum_ops_ne_num_p_p_ic = 261,
+ enum_ops_ne_addr_s_s_ic = 262,
+ enum_ops_ne_addr_sc_s_ic = 263,
+ enum_ops_ne_addr_s_sc_ic = 264,
+ enum_ops_ne_addr_sc_sc_ic = 265,
+ enum_ops_ne_addr_p_p_ic = 266,
+ enum_ops_lt_i_i_ic = 267,
+ enum_ops_lt_ic_i_ic = 268,
+ enum_ops_lt_i_ic_ic = 269,
+ enum_ops_lt_n_n_ic = 270,
+ enum_ops_lt_nc_n_ic = 271,
+ enum_ops_lt_n_nc_ic = 272,
+ enum_ops_lt_s_s_ic = 273,
+ enum_ops_lt_sc_s_ic = 274,
+ enum_ops_lt_s_sc_ic = 275,
+ enum_ops_lt_p_p_ic = 276,
+ enum_ops_lt_p_i_ic = 277,
+ enum_ops_lt_p_ic_ic = 278,
+ enum_ops_lt_p_n_ic = 279,
+ enum_ops_lt_p_nc_ic = 280,
+ enum_ops_lt_p_s_ic = 281,
+ enum_ops_lt_p_sc_ic = 282,
+ enum_ops_lt_str_p_p_ic = 283,
+ enum_ops_lt_num_p_p_ic = 284,
+ enum_ops_le_i_i_ic = 285,
+ enum_ops_le_ic_i_ic = 286,
+ enum_ops_le_i_ic_ic = 287,
+ enum_ops_le_n_n_ic = 288,
+ enum_ops_le_nc_n_ic = 289,
+ enum_ops_le_n_nc_ic = 290,
+ enum_ops_le_s_s_ic = 291,
+ enum_ops_le_sc_s_ic = 292,
+ enum_ops_le_s_sc_ic = 293,
+ enum_ops_le_p_p_ic = 294,
+ enum_ops_le_p_i_ic = 295,
+ enum_ops_le_p_ic_ic = 296,
+ enum_ops_le_p_n_ic = 297,
+ enum_ops_le_p_nc_ic = 298,
+ enum_ops_le_p_s_ic = 299,
+ enum_ops_le_p_sc_ic = 300,
+ enum_ops_le_str_p_p_ic = 301,
+ enum_ops_le_num_p_p_ic = 302,
+ enum_ops_gt_p_p_ic = 303,
+ enum_ops_gt_p_i_ic = 304,
+ enum_ops_gt_p_ic_ic = 305,
+ enum_ops_gt_p_n_ic = 306,
+ enum_ops_gt_p_nc_ic = 307,
+ enum_ops_gt_p_s_ic = 308,
+ enum_ops_gt_p_sc_ic = 309,
+ enum_ops_gt_str_p_p_ic = 310,
+ enum_ops_gt_num_p_p_ic = 311,
+ enum_ops_ge_p_p_ic = 312,
+ enum_ops_ge_p_i_ic = 313,
+ enum_ops_ge_p_ic_ic = 314,
+ enum_ops_ge_p_n_ic = 315,
+ enum_ops_ge_p_nc_ic = 316,
+ enum_ops_ge_p_s_ic = 317,
+ enum_ops_ge_p_sc_ic = 318,
+ enum_ops_ge_str_p_p_ic = 319,
+ enum_ops_ge_num_p_p_ic = 320,
+ enum_ops_if_null_p_ic = 321,
+ enum_ops_if_null_s_ic = 322,
+ enum_ops_unless_null_p_ic = 323,
+ enum_ops_unless_null_s_ic = 324,
+ enum_ops_cmp_i_i_i = 325,
+ enum_ops_cmp_i_ic_i = 326,
+ enum_ops_cmp_i_i_ic = 327,
+ enum_ops_cmp_i_n_n = 328,
+ enum_ops_cmp_i_nc_n = 329,
+ enum_ops_cmp_i_n_nc = 330,
+ enum_ops_cmp_i_s_s = 331,
+ enum_ops_cmp_i_sc_s = 332,
+ enum_ops_cmp_i_s_sc = 333,
+ enum_ops_cmp_i_p_p = 334,
+ enum_ops_cmp_i_p_i = 335,
+ enum_ops_cmp_i_p_ic = 336,
+ enum_ops_cmp_i_p_n = 337,
+ enum_ops_cmp_i_p_nc = 338,
+ enum_ops_cmp_i_p_s = 339,
+ enum_ops_cmp_i_p_sc = 340,
+ enum_ops_cmp_str_i_p_p = 341,
+ enum_ops_cmp_num_i_p_p = 342,
+ enum_ops_cmp_pmc_p_p_p = 343,
+ enum_ops_issame_i_p_p = 344,
+ enum_ops_issame_i_s_s = 345,
+ enum_ops_issame_i_sc_s = 346,
+ enum_ops_issame_i_s_sc = 347,
+ enum_ops_issame_i_sc_sc = 348,
+ enum_ops_isntsame_i_p_p = 349,
+ enum_ops_isntsame_i_s_s = 350,
+ enum_ops_isntsame_i_sc_s = 351,
+ enum_ops_isntsame_i_s_sc = 352,
+ enum_ops_isntsame_i_sc_sc = 353,
+ enum_ops_istrue_i_p = 354,
+ enum_ops_isfalse_i_p = 355,
+ enum_ops_isnull_i_p = 356,
+ enum_ops_isnull_i_pc = 357,
+ enum_ops_isnull_i_s = 358,
+ enum_ops_isnull_i_sc = 359,
+ enum_ops_isgt_i_p_p = 360,
+ enum_ops_isge_i_p_p = 361,
+ enum_ops_isle_i_i_i = 362,
+ enum_ops_isle_i_ic_i = 363,
+ enum_ops_isle_i_i_ic = 364,
+ enum_ops_isle_i_n_n = 365,
+ enum_ops_isle_i_nc_n = 366,
+ enum_ops_isle_i_n_nc = 367,
+ enum_ops_isle_i_s_s = 368,
+ enum_ops_isle_i_sc_s = 369,
+ enum_ops_isle_i_s_sc = 370,
+ enum_ops_isle_i_p_p = 371,
+ enum_ops_islt_i_i_i = 372,
+ enum_ops_islt_i_ic_i = 373,
+ enum_ops_islt_i_i_ic = 374,
+ enum_ops_islt_i_n_n = 375,
+ enum_ops_islt_i_nc_n = 376,
+ enum_ops_islt_i_n_nc = 377,
+ enum_ops_islt_i_s_s = 378,
+ enum_ops_islt_i_sc_s = 379,
+ enum_ops_islt_i_s_sc = 380,
+ enum_ops_islt_i_p_p = 381,
+ enum_ops_iseq_i_i_i = 382,
+ enum_ops_iseq_i_ic_i = 383,
+ enum_ops_iseq_i_i_ic = 384,
+ enum_ops_iseq_i_n_n = 385,
+ enum_ops_iseq_i_nc_n = 386,
+ enum_ops_iseq_i_n_nc = 387,
+ enum_ops_iseq_i_s_s = 388,
+ enum_ops_iseq_i_sc_s = 389,
+ enum_ops_iseq_i_s_sc = 390,
+ enum_ops_iseq_i_p_p = 391,
+ enum_ops_isne_i_i_i = 392,
+ enum_ops_isne_i_ic_i = 393,
+ enum_ops_isne_i_i_ic = 394,
+ enum_ops_isne_i_n_n = 395,
+ enum_ops_isne_i_nc_n = 396,
+ enum_ops_isne_i_n_nc = 397,
+ enum_ops_isne_i_s_s = 398,
+ enum_ops_isne_i_sc_s = 399,
+ enum_ops_isne_i_s_sc = 400,
+ enum_ops_isne_i_p_p = 401,
+ enum_ops_and_i_i_i = 402,
+ enum_ops_and_i_ic_i = 403,
+ enum_ops_and_i_i_ic = 404,
+ enum_ops_and_p_p_p = 405,
+ enum_ops_not_i = 406,
+ enum_ops_not_i_i = 407,
+ enum_ops_not_p = 408,
+ enum_ops_not_p_p = 409,
+ enum_ops_or_i_i_i = 410,
+ enum_ops_or_i_ic_i = 411,
+ enum_ops_or_i_i_ic = 412,
+ enum_ops_or_p_p_p = 413,
+ enum_ops_xor_i_i_i = 414,
+ enum_ops_xor_i_ic_i = 415,
+ enum_ops_xor_i_i_ic = 416,
+ enum_ops_xor_p_p_p = 417,
+ enum_ops_debug_init = 418,
+ enum_ops_debug_load_sc = 419,
+ enum_ops_debug_break = 420,
+ enum_ops_debug_print = 421,
+ enum_ops_backtrace = 422,
+ enum_ops_getline_i = 423,
+ enum_ops_getfile_s = 424,
+ enum_ops_close_p = 425,
+ enum_ops_fdopen_p_i_s = 426,
+ enum_ops_fdopen_p_ic_s = 427,
+ enum_ops_fdopen_p_i_sc = 428,
+ enum_ops_fdopen_p_ic_sc = 429,
+ enum_ops_getstdin_p = 430,
+ enum_ops_getstdout_p = 431,
+ enum_ops_getstderr_p = 432,
+ enum_ops_setstdin_p = 433,
+ enum_ops_setstdout_p = 434,
+ enum_ops_setstderr_p = 435,
+ enum_ops_open_p_s_s = 436,
+ enum_ops_open_p_sc_s = 437,
+ enum_ops_open_p_s_sc = 438,
+ enum_ops_open_p_sc_sc = 439,
+ enum_ops_open_p_s = 440,
+ enum_ops_open_p_sc = 441,
+ enum_ops_print_i = 442,
+ enum_ops_print_ic = 443,
+ enum_ops_print_n = 444,
+ enum_ops_print_nc = 445,
+ enum_ops_print_s = 446,
+ enum_ops_print_sc = 447,
+ enum_ops_print_p = 448,
+ enum_ops_say_i = 449,
+ enum_ops_say_ic = 450,
+ enum_ops_say_n = 451,
+ enum_ops_say_nc = 452,
+ enum_ops_say_s = 453,
+ enum_ops_say_sc = 454,
+ enum_ops_say_p = 455,
+ enum_ops_printerr_i = 456,
+ enum_ops_printerr_ic = 457,
+ enum_ops_printerr_n = 458,
+ enum_ops_printerr_nc = 459,
+ enum_ops_printerr_s = 460,
+ enum_ops_printerr_sc = 461,
+ enum_ops_printerr_p = 462,
+ enum_ops_print_p_i = 463,
+ enum_ops_print_p_ic = 464,
+ enum_ops_print_p_n = 465,
+ enum_ops_print_p_nc = 466,
+ enum_ops_print_p_s = 467,
+ enum_ops_print_p_sc = 468,
+ enum_ops_print_p_p = 469,
+ enum_ops_read_s_i = 470,
+ enum_ops_read_s_ic = 471,
+ enum_ops_read_s_p_i = 472,
+ enum_ops_read_s_p_ic = 473,
+ enum_ops_readline_s_p = 474,
+ enum_ops_peek_s = 475,
+ enum_ops_peek_s_p = 476,
+ enum_ops_stat_i_s_i = 477,
+ enum_ops_stat_i_sc_i = 478,
+ enum_ops_stat_i_s_ic = 479,
+ enum_ops_stat_i_sc_ic = 480,
+ enum_ops_stat_i_i_i = 481,
+ enum_ops_stat_i_ic_i = 482,
+ enum_ops_stat_i_i_ic = 483,
+ enum_ops_stat_i_ic_ic = 484,
+ enum_ops_seek_p_i_i = 485,
+ enum_ops_seek_p_ic_i = 486,
+ enum_ops_seek_p_i_ic = 487,
+ enum_ops_seek_p_ic_ic = 488,
+ enum_ops_seek_p_i_i_i = 489,
+ enum_ops_seek_p_ic_i_i = 490,
+ enum_ops_seek_p_i_ic_i = 491,
+ enum_ops_seek_p_ic_ic_i = 492,
+ enum_ops_seek_p_i_i_ic = 493,
+ enum_ops_seek_p_ic_i_ic = 494,
+ enum_ops_seek_p_i_ic_ic = 495,
+ enum_ops_seek_p_ic_ic_ic = 496,
+ enum_ops_tell_i_p = 497,
+ enum_ops_tell_i_i_p = 498,
+ enum_ops_abs_i = 499,
+ enum_ops_abs_n = 500,
+ enum_ops_abs_i_i = 501,
+ enum_ops_abs_n_n = 502,
+ enum_ops_abs_p = 503,
+ enum_ops_abs_p_p = 504,
+ enum_ops_add_i_i = 505,
+ enum_ops_add_i_ic = 506,
+ enum_ops_add_n_n = 507,
+ enum_ops_add_n_nc = 508,
+ enum_ops_add_p_p = 509,
+ enum_ops_add_p_i = 510,
+ enum_ops_add_p_ic = 511,
+ enum_ops_add_p_n = 512,
+ enum_ops_add_p_nc = 513,
+ enum_ops_add_i_i_i = 514,
+ enum_ops_add_i_ic_i = 515,
+ enum_ops_add_i_i_ic = 516,
+ enum_ops_add_n_n_n = 517,
+ enum_ops_add_n_nc_n = 518,
+ enum_ops_add_n_n_nc = 519,
+ enum_ops_add_p_p_p = 520,
+ enum_ops_add_p_p_i = 521,
+ enum_ops_add_p_p_ic = 522,
+ enum_ops_add_p_p_n = 523,
+ enum_ops_add_p_p_nc = 524,
+ enum_ops_cmod_i_i_i = 525,
+ enum_ops_cmod_i_ic_i = 526,
+ enum_ops_cmod_i_i_ic = 527,
+ enum_ops_cmod_p_p_i = 528,
+ enum_ops_cmod_p_p_ic = 529,
+ enum_ops_cmod_p_p_p = 530,
+ enum_ops_cmod_n_n_n = 531,
+ enum_ops_cmod_n_nc_n = 532,
+ enum_ops_cmod_n_n_nc = 533,
+ enum_ops_cmod_p_p_n = 534,
+ enum_ops_cmod_p_p_nc = 535,
+ enum_ops_dec_i = 536,
+ enum_ops_dec_n = 537,
+ enum_ops_dec_p = 538,
+ enum_ops_div_i_i = 539,
+ enum_ops_div_i_ic = 540,
+ enum_ops_div_n_n = 541,
+ enum_ops_div_n_nc = 542,
+ enum_ops_div_p_p = 543,
+ enum_ops_div_p_i = 544,
+ enum_ops_div_p_ic = 545,
+ enum_ops_div_p_n = 546,
+ enum_ops_div_p_nc = 547,
+ enum_ops_div_i_i_i = 548,
+ enum_ops_div_i_ic_i = 549,
+ enum_ops_div_i_i_ic = 550,
+ enum_ops_div_i_ic_ic = 551,
+ enum_ops_div_n_n_n = 552,
+ enum_ops_div_n_nc_n = 553,
+ enum_ops_div_n_n_nc = 554,
+ enum_ops_div_n_nc_nc = 555,
+ enum_ops_div_p_p_p = 556,
+ enum_ops_div_p_p_i = 557,
+ enum_ops_div_p_p_ic = 558,
+ enum_ops_div_p_p_n = 559,
+ enum_ops_div_p_p_nc = 560,
+ enum_ops_fdiv_i_i = 561,
+ enum_ops_fdiv_i_ic = 562,
+ enum_ops_fdiv_n_n = 563,
+ enum_ops_fdiv_n_nc = 564,
+ enum_ops_fdiv_p_p = 565,
+ enum_ops_fdiv_p_i = 566,
+ enum_ops_fdiv_p_ic = 567,
+ enum_ops_fdiv_p_n = 568,
+ enum_ops_fdiv_p_nc = 569,
+ enum_ops_fdiv_i_i_i = 570,
+ enum_ops_fdiv_i_ic_i = 571,
+ enum_ops_fdiv_i_i_ic = 572,
+ enum_ops_fdiv_n_n_n = 573,
+ enum_ops_fdiv_n_nc_n = 574,
+ enum_ops_fdiv_n_n_nc = 575,
+ enum_ops_fdiv_p_p_p = 576,
+ enum_ops_fdiv_p_p_i = 577,
+ enum_ops_fdiv_p_p_ic = 578,
+ enum_ops_fdiv_p_p_n = 579,
+ enum_ops_fdiv_p_p_nc = 580,
+ enum_ops_ceil_n = 581,
+ enum_ops_ceil_i_n = 582,
+ enum_ops_ceil_n_n = 583,
+ enum_ops_floor_n = 584,
+ enum_ops_floor_i_n = 585,
+ enum_ops_floor_n_n = 586,
+ enum_ops_inc_i = 587,
+ enum_ops_inc_n = 588,
+ enum_ops_inc_p = 589,
+ enum_ops_mod_i_i = 590,
+ enum_ops_mod_i_ic = 591,
+ enum_ops_mod_n_n = 592,
+ enum_ops_mod_n_nc = 593,
+ enum_ops_mod_p_p = 594,
+ enum_ops_mod_p_i = 595,
+ enum_ops_mod_p_ic = 596,
+ enum_ops_mod_p_n = 597,
+ enum_ops_mod_p_nc = 598,
+ enum_ops_mod_i_i_i = 599,
+ enum_ops_mod_i_ic_i = 600,
+ enum_ops_mod_i_i_ic = 601,
+ enum_ops_mod_n_n_n = 602,
+ enum_ops_mod_n_nc_n = 603,
+ enum_ops_mod_n_n_nc = 604,
+ enum_ops_mod_p_p_p = 605,
+ enum_ops_mod_p_p_i = 606,
+ enum_ops_mod_p_p_ic = 607,
+ enum_ops_mod_p_p_n = 608,
+ enum_ops_mod_p_p_nc = 609,
+ enum_ops_mul_i_i = 610,
+ enum_ops_mul_i_ic = 611,
+ enum_ops_mul_n_n = 612,
+ enum_ops_mul_n_nc = 613,
+ enum_ops_mul_p_p = 614,
+ enum_ops_mul_p_i = 615,
+ enum_ops_mul_p_ic = 616,
+ enum_ops_mul_p_n = 617,
+ enum_ops_mul_p_nc = 618,
+ enum_ops_mul_i_i_i = 619,
+ enum_ops_mul_i_ic_i = 620,
+ enum_ops_mul_i_i_ic = 621,
+ enum_ops_mul_n_n_n = 622,
+ enum_ops_mul_n_nc_n = 623,
+ enum_ops_mul_n_n_nc = 624,
+ enum_ops_mul_p_p_p = 625,
+ enum_ops_mul_p_p_i = 626,
+ enum_ops_mul_p_p_ic = 627,
+ enum_ops_mul_p_p_n = 628,
+ enum_ops_mul_p_p_nc = 629,
+ enum_ops_neg_i = 630,
+ enum_ops_neg_n = 631,
+ enum_ops_neg_p = 632,
+ enum_ops_neg_i_i = 633,
+ enum_ops_neg_n_n = 634,
+ enum_ops_neg_p_p = 635,
+ enum_ops_pow_n_n_n = 636,
+ enum_ops_pow_n_nc_n = 637,
+ enum_ops_pow_n_n_nc = 638,
+ enum_ops_pow_p_p_p = 639,
+ enum_ops_pow_p_p_i = 640,
+ enum_ops_pow_p_p_ic = 641,
+ enum_ops_pow_p_p_n = 642,
+ enum_ops_pow_p_p_nc = 643,
+ enum_ops_pow_n_n_i = 644,
+ enum_ops_pow_n_nc_i = 645,
+ enum_ops_pow_n_n_ic = 646,
+ enum_ops_pow_n_nc_ic = 647,
+ enum_ops_sub_i_i = 648,
+ enum_ops_sub_i_ic = 649,
+ enum_ops_sub_n_n = 650,
+ enum_ops_sub_n_nc = 651,
+ enum_ops_sub_p_p = 652,
+ enum_ops_sub_p_i = 653,
+ enum_ops_sub_p_ic = 654,
+ enum_ops_sub_p_n = 655,
+ enum_ops_sub_p_nc = 656,
+ enum_ops_sub_i_i_i = 657,
+ enum_ops_sub_i_ic_i = 658,
+ enum_ops_sub_i_i_ic = 659,
+ enum_ops_sub_n_n_n = 660,
+ enum_ops_sub_n_nc_n = 661,
+ enum_ops_sub_n_n_nc = 662,
+ enum_ops_sub_p_p_p = 663,
+ enum_ops_sub_p_p_i = 664,
+ enum_ops_sub_p_p_ic = 665,
+ enum_ops_sub_p_p_n = 666,
+ enum_ops_sub_p_p_nc = 667,
+ enum_ops_sqrt_n_n = 668,
+ enum_ops_acos_n_n = 669,
+ enum_ops_asec_n_n = 670,
+ enum_ops_asin_n_n = 671,
+ enum_ops_atan_n_n = 672,
+ enum_ops_atan_n_n_n = 673,
+ enum_ops_atan_n_nc_n = 674,
+ enum_ops_atan_n_n_nc = 675,
+ enum_ops_cos_n_n = 676,
+ enum_ops_cosh_n_n = 677,
+ enum_ops_exp_n_n = 678,
+ enum_ops_ln_n_n = 679,
+ enum_ops_log10_n_n = 680,
+ enum_ops_log2_n_n = 681,
+ enum_ops_sec_n_n = 682,
+ enum_ops_sech_n_n = 683,
+ enum_ops_sin_n_n = 684,
+ enum_ops_sinh_n_n = 685,
+ enum_ops_tan_n_n = 686,
+ enum_ops_tanh_n_n = 687,
+ enum_ops_callmethodcc_p_s = 688,
+ enum_ops_callmethodcc_p_sc = 689,
+ enum_ops_callmethodcc_p_p = 690,
+ enum_ops_callmethod_p_s_p = 691,
+ enum_ops_callmethod_p_sc_p = 692,
+ enum_ops_callmethod_p_p_p = 693,
+ enum_ops_tailcallmethod_p_s = 694,
+ enum_ops_tailcallmethod_p_sc = 695,
+ enum_ops_tailcallmethod_p_p = 696,
+ enum_ops_addmethod_p_s_p = 697,
+ enum_ops_addmethod_p_sc_p = 698,
+ enum_ops_can_i_p_s = 699,
+ enum_ops_can_i_p_sc = 700,
+ enum_ops_does_i_p_s = 701,
+ enum_ops_does_i_p_sc = 702,
+ enum_ops_does_i_p_p = 703,
+ enum_ops_does_i_p_pc = 704,
+ enum_ops_isa_i_p_s = 705,
+ enum_ops_isa_i_p_sc = 706,
+ enum_ops_isa_i_p_p = 707,
+ enum_ops_isa_i_p_pc = 708,
+ enum_ops_newclass_p_s = 709,
+ enum_ops_newclass_p_sc = 710,
+ enum_ops_newclass_p_p = 711,
+ enum_ops_newclass_p_pc = 712,
+ enum_ops_subclass_p_p = 713,
+ enum_ops_subclass_p_pc = 714,
+ enum_ops_subclass_p_p_s = 715,
+ enum_ops_subclass_p_pc_s = 716,
+ enum_ops_subclass_p_p_sc = 717,
+ enum_ops_subclass_p_pc_sc = 718,
+ enum_ops_subclass_p_p_p = 719,
+ enum_ops_subclass_p_pc_p = 720,
+ enum_ops_subclass_p_p_pc = 721,
+ enum_ops_subclass_p_pc_pc = 722,
+ enum_ops_subclass_p_s = 723,
+ enum_ops_subclass_p_sc = 724,
+ enum_ops_subclass_p_s_s = 725,
+ enum_ops_subclass_p_sc_s = 726,
+ enum_ops_subclass_p_s_sc = 727,
+ enum_ops_subclass_p_sc_sc = 728,
+ enum_ops_subclass_p_s_p = 729,
+ enum_ops_subclass_p_sc_p = 730,
+ enum_ops_subclass_p_s_pc = 731,
+ enum_ops_subclass_p_sc_pc = 732,
+ enum_ops_get_class_p_s = 733,
+ enum_ops_get_class_p_sc = 734,
+ enum_ops_get_class_p_p = 735,
+ enum_ops_get_class_p_pc = 736,
+ enum_ops_class_p_p = 737,
+ enum_ops_addparent_p_p = 738,
+ enum_ops_removeparent_p_p = 739,
+ enum_ops_addrole_p_p = 740,
+ enum_ops_addattribute_p_s = 741,
+ enum_ops_addattribute_p_sc = 742,
+ enum_ops_removeattribute_p_s = 743,
+ enum_ops_removeattribute_p_sc = 744,
+ enum_ops_getattribute_p_p_s = 745,
+ enum_ops_getattribute_p_p_sc = 746,
+ enum_ops_getattribute_p_p_p_s = 747,
+ enum_ops_getattribute_p_p_pc_s = 748,
+ enum_ops_getattribute_p_p_p_sc = 749,
+ enum_ops_getattribute_p_p_pc_sc = 750,
+ enum_ops_setattribute_p_s_p = 751,
+ enum_ops_setattribute_p_sc_p = 752,
+ enum_ops_setattribute_p_p_s_p = 753,
+ enum_ops_setattribute_p_pc_s_p = 754,
+ enum_ops_setattribute_p_p_sc_p = 755,
+ enum_ops_setattribute_p_pc_sc_p = 756,
+ enum_ops_inspect_p_p = 757,
+ enum_ops_inspect_p_pc = 758,
+ enum_ops_inspect_p_p_s = 759,
+ enum_ops_inspect_p_pc_s = 760,
+ enum_ops_inspect_p_p_sc = 761,
+ enum_ops_inspect_p_pc_sc = 762,
+ enum_ops_new_p_s = 763,
+ enum_ops_new_p_sc = 764,
+ enum_ops_new_p_s_p = 765,
+ enum_ops_new_p_sc_p = 766,
+ enum_ops_new_p_s_pc = 767,
+ enum_ops_new_p_sc_pc = 768,
+ enum_ops_new_p_p = 769,
+ enum_ops_new_p_pc = 770,
+ enum_ops_new_p_p_p = 771,
+ enum_ops_new_p_pc_p = 772,
+ enum_ops_new_p_p_pc = 773,
+ enum_ops_new_p_pc_pc = 774,
+ enum_ops_root_new_p_p = 775,
+ enum_ops_root_new_p_pc = 776,
+ enum_ops_root_new_p_p_p = 777,
+ enum_ops_root_new_p_pc_p = 778,
+ enum_ops_root_new_p_p_pc = 779,
+ enum_ops_root_new_p_pc_pc = 780,
+ enum_ops_typeof_s_p = 781,
+ enum_ops_typeof_p_p = 782,
+ enum_ops_get_repr_s_p = 783,
+ enum_ops_find_method_p_p_s = 784,
+ enum_ops_find_method_p_p_sc = 785,
+ enum_ops_defined_i_p = 786,
+ enum_ops_defined_i_p_ki = 787,
+ enum_ops_defined_i_p_kic = 788,
+ enum_ops_defined_i_p_k = 789,
+ enum_ops_defined_i_p_kc = 790,
+ enum_ops_exists_i_p_ki = 791,
+ enum_ops_exists_i_p_kic = 792,
+ enum_ops_exists_i_p_k = 793,
+ enum_ops_exists_i_p_kc = 794,
+ enum_ops_delete_p_k = 795,
+ enum_ops_delete_p_kc = 796,
+ enum_ops_delete_p_ki = 797,
+ enum_ops_delete_p_kic = 798,
+ enum_ops_elements_i_p = 799,
+ enum_ops_push_p_i = 800,
+ enum_ops_push_p_ic = 801,
+ enum_ops_push_p_n = 802,
+ enum_ops_push_p_nc = 803,
+ enum_ops_push_p_s = 804,
+ enum_ops_push_p_sc = 805,
+ enum_ops_push_p_p = 806,
+ enum_ops_pop_i_p = 807,
+ enum_ops_pop_n_p = 808,
+ enum_ops_pop_s_p = 809,
+ enum_ops_pop_p_p = 810,
+ enum_ops_unshift_p_i = 811,
+ enum_ops_unshift_p_ic = 812,
+ enum_ops_unshift_p_n = 813,
+ enum_ops_unshift_p_nc = 814,
+ enum_ops_unshift_p_s = 815,
+ enum_ops_unshift_p_sc = 816,
+ enum_ops_unshift_p_p = 817,
+ enum_ops_shift_i_p = 818,
+ enum_ops_shift_n_p = 819,
+ enum_ops_shift_s_p = 820,
+ enum_ops_shift_p_p = 821,
+ enum_ops_splice_p_p_i_i = 822,
+ enum_ops_splice_p_p_ic_i = 823,
+ enum_ops_splice_p_p_i_ic = 824,
+ enum_ops_splice_p_p_ic_ic = 825,
+ enum_ops_setprop_p_s_p = 826,
+ enum_ops_setprop_p_sc_p = 827,
+ enum_ops_getprop_p_s_p = 828,
+ enum_ops_getprop_p_sc_p = 829,
+ enum_ops_delprop_p_s = 830,
+ enum_ops_delprop_p_sc = 831,
+ enum_ops_prophash_p_p = 832,
+ enum_ops_freeze_s_p = 833,
+ enum_ops_thaw_p_s = 834,
+ enum_ops_thaw_p_sc = 835,
+ enum_ops_add_multi_s_s_p = 836,
+ enum_ops_add_multi_sc_s_p = 837,
+ enum_ops_add_multi_s_sc_p = 838,
+ enum_ops_add_multi_sc_sc_p = 839,
+ enum_ops_find_multi_p_s_s = 840,
+ enum_ops_find_multi_p_sc_s = 841,
+ enum_ops_find_multi_p_s_sc = 842,
+ enum_ops_find_multi_p_sc_sc = 843,
+ enum_ops_register_p = 844,
+ enum_ops_unregister_p = 845,
+ enum_ops_box_p_i = 846,
+ enum_ops_box_p_ic = 847,
+ enum_ops_box_p_n = 848,
+ enum_ops_box_p_nc = 849,
+ enum_ops_box_p_s = 850,
+ enum_ops_box_p_sc = 851,
+ enum_ops_iter_p_p = 852,
+ enum_ops_morph_p_p = 853,
+ enum_ops_morph_p_pc = 854,
+ enum_ops_clone_s_s = 855,
+ enum_ops_clone_s_sc = 856,
+ enum_ops_set_i_i = 857,
+ enum_ops_set_i_ic = 858,
+ enum_ops_set_i_n = 859,
+ enum_ops_set_i_nc = 860,
+ enum_ops_set_i_s = 861,
+ enum_ops_set_i_sc = 862,
+ enum_ops_set_n_n = 863,
+ enum_ops_set_n_nc = 864,
+ enum_ops_set_n_i = 865,
+ enum_ops_set_n_ic = 866,
+ enum_ops_set_n_s = 867,
+ enum_ops_set_n_sc = 868,
+ enum_ops_set_n_p = 869,
+ enum_ops_set_s_p = 870,
+ enum_ops_set_s_s = 871,
+ enum_ops_set_s_sc = 872,
+ enum_ops_set_s_i = 873,
+ enum_ops_set_s_ic = 874,
+ enum_ops_set_s_n = 875,
+ enum_ops_set_s_nc = 876,
+ enum_ops_set_p_pc = 877,
+ enum_ops_set_p_p = 878,
+ enum_ops_set_p_i = 879,
+ enum_ops_set_p_ic = 880,
+ enum_ops_set_p_n = 881,
+ enum_ops_set_p_nc = 882,
+ enum_ops_set_p_s = 883,
+ enum_ops_set_p_sc = 884,
+ enum_ops_set_i_p = 885,
+ enum_ops_assign_p_p = 886,
+ enum_ops_assign_p_i = 887,
+ enum_ops_assign_p_ic = 888,
+ enum_ops_assign_p_n = 889,
+ enum_ops_assign_p_nc = 890,
+ enum_ops_assign_p_s = 891,
+ enum_ops_assign_p_sc = 892,
+ enum_ops_assign_s_s = 893,
+ enum_ops_assign_s_sc = 894,
+ enum_ops_setref_p_p = 895,
+ enum_ops_deref_p_p = 896,
+ enum_ops_set_p_ki_i = 897,
+ enum_ops_set_p_kic_i = 898,
+ enum_ops_set_p_ki_ic = 899,
+ enum_ops_set_p_kic_ic = 900,
+ enum_ops_set_p_ki_n = 901,
+ enum_ops_set_p_kic_n = 902,
+ enum_ops_set_p_ki_nc = 903,
+ enum_ops_set_p_kic_nc = 904,
+ enum_ops_set_p_ki_s = 905,
+ enum_ops_set_p_kic_s = 906,
+ enum_ops_set_p_ki_sc = 907,
+ enum_ops_set_p_kic_sc = 908,
+ enum_ops_set_p_ki_p = 909,
+ enum_ops_set_p_kic_p = 910,
+ enum_ops_set_i_p_ki = 911,
+ enum_ops_set_i_p_kic = 912,
+ enum_ops_set_n_p_ki = 913,
+ enum_ops_set_n_p_kic = 914,
+ enum_ops_set_s_p_ki = 915,
+ enum_ops_set_s_p_kic = 916,
+ enum_ops_set_p_p_ki = 917,
+ enum_ops_set_p_p_kic = 918,
+ enum_ops_set_p_k_i = 919,
+ enum_ops_set_p_kc_i = 920,
+ enum_ops_set_p_k_ic = 921,
+ enum_ops_set_p_kc_ic = 922,
+ enum_ops_set_p_k_n = 923,
+ enum_ops_set_p_kc_n = 924,
+ enum_ops_set_p_k_nc = 925,
+ enum_ops_set_p_kc_nc = 926,
+ enum_ops_set_p_k_s = 927,
+ enum_ops_set_p_kc_s = 928,
+ enum_ops_set_p_k_sc = 929,
+ enum_ops_set_p_kc_sc = 930,
+ enum_ops_set_p_k_p = 931,
+ enum_ops_set_p_kc_p = 932,
+ enum_ops_set_i_p_k = 933,
+ enum_ops_set_i_p_kc = 934,
+ enum_ops_set_n_p_k = 935,
+ enum_ops_set_n_p_kc = 936,
+ enum_ops_set_s_p_k = 937,
+ enum_ops_set_s_p_kc = 938,
+ enum_ops_set_p_p_k = 939,
+ enum_ops_set_p_p_kc = 940,
+ enum_ops_clone_p_p = 941,
+ enum_ops_clone_p_p_p = 942,
+ enum_ops_clone_p_p_pc = 943,
+ enum_ops_copy_p_p = 944,
+ enum_ops_null_s = 945,
+ enum_ops_null_i = 946,
+ enum_ops_null_p = 947,
+ enum_ops_null_n = 948,
+ enum_ops_ord_i_s = 949,
+ enum_ops_ord_i_sc = 950,
+ enum_ops_ord_i_s_i = 951,
+ enum_ops_ord_i_sc_i = 952,
+ enum_ops_ord_i_s_ic = 953,
+ enum_ops_ord_i_sc_ic = 954,
+ enum_ops_chr_s_i = 955,
+ enum_ops_chr_s_ic = 956,
+ enum_ops_chopn_s_s_i = 957,
+ enum_ops_chopn_s_sc_i = 958,
+ enum_ops_chopn_s_s_ic = 959,
+ enum_ops_chopn_s_sc_ic = 960,
+ enum_ops_concat_s_s = 961,
+ enum_ops_concat_s_sc = 962,
+ enum_ops_concat_p_p = 963,
+ enum_ops_concat_p_s = 964,
+ enum_ops_concat_p_sc = 965,
+ enum_ops_concat_s_s_s = 966,
+ enum_ops_concat_s_sc_s = 967,
+ enum_ops_concat_s_s_sc = 968,
+ enum_ops_concat_p_p_s = 969,
+ enum_ops_concat_p_p_sc = 970,
+ enum_ops_concat_p_p_p = 971,
+ enum_ops_repeat_s_s_i = 972,
+ enum_ops_repeat_s_sc_i = 973,
+ enum_ops_repeat_s_s_ic = 974,
+ enum_ops_repeat_s_sc_ic = 975,
+ enum_ops_repeat_p_p_i = 976,
+ enum_ops_repeat_p_p_ic = 977,
+ enum_ops_repeat_p_p_p = 978,
+ enum_ops_repeat_p_i = 979,
+ enum_ops_repeat_p_ic = 980,
+ enum_ops_repeat_p_p = 981,
+ enum_ops_length_i_s = 982,
+ enum_ops_length_i_sc = 983,
+ enum_ops_bytelength_i_s = 984,
+ enum_ops_bytelength_i_sc = 985,
+ enum_ops_pin_s = 986,
+ enum_ops_unpin_s = 987,
+ enum_ops_substr_s_s_i = 988,
+ enum_ops_substr_s_sc_i = 989,
+ enum_ops_substr_s_s_ic = 990,
+ enum_ops_substr_s_sc_ic = 991,
+ enum_ops_substr_s_s_i_i = 992,
+ enum_ops_substr_s_sc_i_i = 993,
+ enum_ops_substr_s_s_ic_i = 994,
+ enum_ops_substr_s_sc_ic_i = 995,
+ enum_ops_substr_s_s_i_ic = 996,
+ enum_ops_substr_s_sc_i_ic = 997,
+ enum_ops_substr_s_s_ic_ic = 998,
+ enum_ops_substr_s_sc_ic_ic = 999,
+ enum_ops_substr_s_p_i_i = 1000,
+ enum_ops_substr_s_p_ic_i = 1001,
+ enum_ops_substr_s_p_i_ic = 1002,
+ enum_ops_substr_s_p_ic_ic = 1003,
+ enum_ops_replace_s_s_i_i_s = 1004,
+ enum_ops_replace_s_sc_i_i_s = 1005,
+ enum_ops_replace_s_s_ic_i_s = 1006,
+ enum_ops_replace_s_sc_ic_i_s = 1007,
+ enum_ops_replace_s_s_i_ic_s = 1008,
+ enum_ops_replace_s_sc_i_ic_s = 1009,
+ enum_ops_replace_s_s_ic_ic_s = 1010,
+ enum_ops_replace_s_sc_ic_ic_s = 1011,
+ enum_ops_replace_s_s_i_i_sc = 1012,
+ enum_ops_replace_s_sc_i_i_sc = 1013,
+ enum_ops_replace_s_s_ic_i_sc = 1014,
+ enum_ops_replace_s_sc_ic_i_sc = 1015,
+ enum_ops_replace_s_s_i_ic_sc = 1016,
+ enum_ops_replace_s_sc_i_ic_sc = 1017,
+ enum_ops_replace_s_s_ic_ic_sc = 1018,
+ enum_ops_replace_s_sc_ic_ic_sc = 1019,
+ enum_ops_index_i_s_s = 1020,
+ enum_ops_index_i_sc_s = 1021,
+ enum_ops_index_i_s_sc = 1022,
+ enum_ops_index_i_sc_sc = 1023,
+ enum_ops_index_i_s_s_i = 1024,
+ enum_ops_index_i_sc_s_i = 1025,
+ enum_ops_index_i_s_sc_i = 1026,
+ enum_ops_index_i_sc_sc_i = 1027,
+ enum_ops_index_i_s_s_ic = 1028,
+ enum_ops_index_i_sc_s_ic = 1029,
+ enum_ops_index_i_s_sc_ic = 1030,
+ enum_ops_index_i_sc_sc_ic = 1031,
+ enum_ops_sprintf_s_s_p = 1032,
+ enum_ops_sprintf_s_sc_p = 1033,
+ enum_ops_sprintf_p_p_p = 1034,
+ enum_ops_new_s = 1035,
+ enum_ops_new_s_i = 1036,
+ enum_ops_new_s_ic = 1037,
+ enum_ops_stringinfo_i_s_i = 1038,
+ enum_ops_stringinfo_i_sc_i = 1039,
+ enum_ops_stringinfo_i_s_ic = 1040,
+ enum_ops_stringinfo_i_sc_ic = 1041,
+ enum_ops_upcase_s_s = 1042,
+ enum_ops_upcase_s_sc = 1043,
+ enum_ops_downcase_s_s = 1044,
+ enum_ops_downcase_s_sc = 1045,
+ enum_ops_titlecase_s_s = 1046,
+ enum_ops_titlecase_s_sc = 1047,
+ enum_ops_join_s_s_p = 1048,
+ enum_ops_join_s_sc_p = 1049,
+ enum_ops_split_p_s_s = 1050,
+ enum_ops_split_p_sc_s = 1051,
+ enum_ops_split_p_s_sc = 1052,
+ enum_ops_split_p_sc_sc = 1053,
+ enum_ops_charset_i_s = 1054,
+ enum_ops_charset_i_sc = 1055,
+ enum_ops_charsetname_s_i = 1056,
+ enum_ops_charsetname_s_ic = 1057,
+ enum_ops_find_charset_i_s = 1058,
+ enum_ops_find_charset_i_sc = 1059,
+ enum_ops_trans_charset_s_s_i = 1060,
+ enum_ops_trans_charset_s_sc_i = 1061,
+ enum_ops_trans_charset_s_s_ic = 1062,
+ enum_ops_trans_charset_s_sc_ic = 1063,
+ enum_ops_encoding_i_s = 1064,
+ enum_ops_encoding_i_sc = 1065,
+ enum_ops_encodingname_s_i = 1066,
+ enum_ops_encodingname_s_ic = 1067,
+ enum_ops_find_encoding_i_s = 1068,
+ enum_ops_find_encoding_i_sc = 1069,
+ enum_ops_trans_encoding_s_s_i = 1070,
+ enum_ops_trans_encoding_s_sc_i = 1071,
+ enum_ops_trans_encoding_s_s_ic = 1072,
+ enum_ops_trans_encoding_s_sc_ic = 1073,
+ enum_ops_is_cclass_i_i_s_i = 1074,
+ enum_ops_is_cclass_i_ic_s_i = 1075,
+ enum_ops_is_cclass_i_i_sc_i = 1076,
+ enum_ops_is_cclass_i_ic_sc_i = 1077,
+ enum_ops_is_cclass_i_i_s_ic = 1078,
+ enum_ops_is_cclass_i_ic_s_ic = 1079,
+ enum_ops_is_cclass_i_i_sc_ic = 1080,
+ enum_ops_is_cclass_i_ic_sc_ic = 1081,
+ enum_ops_find_cclass_i_i_s_i_i = 1082,
+ enum_ops_find_cclass_i_ic_s_i_i = 1083,
+ enum_ops_find_cclass_i_i_sc_i_i = 1084,
+ enum_ops_find_cclass_i_ic_sc_i_i = 1085,
+ enum_ops_find_cclass_i_i_s_ic_i = 1086,
+ enum_ops_find_cclass_i_ic_s_ic_i = 1087,
+ enum_ops_find_cclass_i_i_sc_ic_i = 1088,
+ enum_ops_find_cclass_i_ic_sc_ic_i = 1089,
+ enum_ops_find_cclass_i_i_s_i_ic = 1090,
+ enum_ops_find_cclass_i_ic_s_i_ic = 1091,
+ enum_ops_find_cclass_i_i_sc_i_ic = 1092,
+ enum_ops_find_cclass_i_ic_sc_i_ic = 1093,
+ enum_ops_find_cclass_i_i_s_ic_ic = 1094,
+ enum_ops_find_cclass_i_ic_s_ic_ic = 1095,
+ enum_ops_find_cclass_i_i_sc_ic_ic = 1096,
+ enum_ops_find_cclass_i_ic_sc_ic_ic = 1097,
+ enum_ops_find_not_cclass_i_i_s_i_i = 1098,
+ enum_ops_find_not_cclass_i_ic_s_i_i = 1099,
+ enum_ops_find_not_cclass_i_i_sc_i_i = 1100,
+ enum_ops_find_not_cclass_i_ic_sc_i_i = 1101,
+ enum_ops_find_not_cclass_i_i_s_ic_i = 1102,
+ enum_ops_find_not_cclass_i_ic_s_ic_i = 1103,
+ enum_ops_find_not_cclass_i_i_sc_ic_i = 1104,
+ enum_ops_find_not_cclass_i_ic_sc_ic_i = 1105,
+ enum_ops_find_not_cclass_i_i_s_i_ic = 1106,
+ enum_ops_find_not_cclass_i_ic_s_i_ic = 1107,
+ enum_ops_find_not_cclass_i_i_sc_i_ic = 1108,
+ enum_ops_find_not_cclass_i_ic_sc_i_ic = 1109,
+ enum_ops_find_not_cclass_i_i_s_ic_ic = 1110,
+ enum_ops_find_not_cclass_i_ic_s_ic_ic = 1111,
+ enum_ops_find_not_cclass_i_i_sc_ic_ic = 1112,
+ enum_ops_find_not_cclass_i_ic_sc_ic_ic = 1113,
+ enum_ops_escape_s_s = 1114,
+ enum_ops_compose_s_s = 1115,
+ enum_ops_compose_s_sc = 1116,
+ enum_ops_spawnw_i_s = 1117,
+ enum_ops_spawnw_i_sc = 1118,
+ enum_ops_spawnw_i_p = 1119,
+ enum_ops_err_i = 1120,
+ enum_ops_err_s = 1121,
+ enum_ops_err_s_i = 1122,
+ enum_ops_err_s_ic = 1123,
+ enum_ops_time_i = 1124,
+ enum_ops_time_n = 1125,
+ enum_ops_gmtime_s_i = 1126,
+ enum_ops_gmtime_s_ic = 1127,
+ enum_ops_localtime_s_i = 1128,
+ enum_ops_localtime_s_ic = 1129,
+ enum_ops_decodetime_p_i = 1130,
+ enum_ops_decodetime_p_ic = 1131,
+ enum_ops_decodelocaltime_p_i = 1132,
+ enum_ops_decodelocaltime_p_ic = 1133,
+ enum_ops_sysinfo_s_i = 1134,
+ enum_ops_sysinfo_s_ic = 1135,
+ enum_ops_sysinfo_i_i = 1136,
+ enum_ops_sysinfo_i_ic = 1137,
+ enum_ops_sleep_i = 1138,
+ enum_ops_sleep_ic = 1139,
+ enum_ops_sleep_n = 1140,
+ enum_ops_sleep_nc = 1141,
+ enum_ops_store_lex_s_p = 1142,
+ enum_ops_store_lex_sc_p = 1143,
+ enum_ops_store_dynamic_lex_s_p = 1144,
+ enum_ops_store_dynamic_lex_sc_p = 1145,
+ enum_ops_find_lex_p_s = 1146,
+ enum_ops_find_lex_p_sc = 1147,
+ enum_ops_find_dynamic_lex_p_s = 1148,
+ enum_ops_find_dynamic_lex_p_sc = 1149,
+ enum_ops_find_caller_lex_p_s = 1150,
+ enum_ops_find_caller_lex_p_sc = 1151,
+ enum_ops_get_namespace_p = 1152,
+ enum_ops_get_namespace_p_p = 1153,
+ enum_ops_get_namespace_p_pc = 1154,
+ enum_ops_get_hll_namespace_p = 1155,
+ enum_ops_get_hll_namespace_p_p = 1156,
+ enum_ops_get_hll_namespace_p_pc = 1157,
+ enum_ops_get_root_namespace_p = 1158,
+ enum_ops_get_root_namespace_p_p = 1159,
+ enum_ops_get_root_namespace_p_pc = 1160,
+ enum_ops_get_global_p_s = 1161,
+ enum_ops_get_global_p_sc = 1162,
+ enum_ops_get_global_p_p_s = 1163,
+ enum_ops_get_global_p_pc_s = 1164,
+ enum_ops_get_global_p_p_sc = 1165,
+ enum_ops_get_global_p_pc_sc = 1166,
+ enum_ops_get_hll_global_p_s = 1167,
+ enum_ops_get_hll_global_p_sc = 1168,
+ enum_ops_get_hll_global_p_p_s = 1169,
+ enum_ops_get_hll_global_p_pc_s = 1170,
+ enum_ops_get_hll_global_p_p_sc = 1171,
+ enum_ops_get_hll_global_p_pc_sc = 1172,
+ enum_ops_get_root_global_p_s = 1173,
+ enum_ops_get_root_global_p_sc = 1174,
+ enum_ops_get_root_global_p_p_s = 1175,
+ enum_ops_get_root_global_p_pc_s = 1176,
+ enum_ops_get_root_global_p_p_sc = 1177,
+ enum_ops_get_root_global_p_pc_sc = 1178,
+ enum_ops_set_global_s_p = 1179,
+ enum_ops_set_global_sc_p = 1180,
+ enum_ops_set_global_p_s_p = 1181,
+ enum_ops_set_global_pc_s_p = 1182,
+ enum_ops_set_global_p_sc_p = 1183,
+ enum_ops_set_global_pc_sc_p = 1184,
+ enum_ops_set_hll_global_s_p = 1185,
+ enum_ops_set_hll_global_sc_p = 1186,
+ enum_ops_set_hll_global_p_s_p = 1187,
+ enum_ops_set_hll_global_pc_s_p = 1188,
+ enum_ops_set_hll_global_p_sc_p = 1189,
+ enum_ops_set_hll_global_pc_sc_p = 1190,
+ enum_ops_set_root_global_s_p = 1191,
+ enum_ops_set_root_global_sc_p = 1192,
+ enum_ops_set_root_global_p_s_p = 1193,
+ enum_ops_set_root_global_pc_s_p = 1194,
+ enum_ops_set_root_global_p_sc_p = 1195,
+ enum_ops_set_root_global_pc_sc_p = 1196,
+ enum_ops_find_name_p_s = 1197,
+ enum_ops_find_name_p_sc = 1198,
+ enum_ops_find_sub_not_null_p_s = 1199,
+ enum_ops_find_sub_not_null_p_sc = 1200,
+};
+
+
+#endif /* PARROT_OPSENUM_H_GUARD */
+
+
+/*
+ * Local variables:
+ * c-file-style: "parrot"
+ * buffer-read-only: t
+ * End:
+ * vim: expandtab shiftwidth=4:
+ */
Modified: trunk/lib/Parrot/Distribution.pm
==============================================================================
--- trunk/lib/Parrot/Distribution.pm Sun May 23 21:12:16 2010 (r46921)
+++ trunk/lib/Parrot/Distribution.pm Sun May 23 21:38:28 2010 (r46922)
@@ -430,7 +430,11 @@
compilers/pirc/macro/macroparser.h
include/parrot/config.h
include/parrot/has_header.h
+ include/parrot/oplib/core_ops.h
+ include/parrot/oplib/ops.h
+ include/parrot/opsenum.h
src/gc/malloc.c
+ src/ops/core_ops.c
} unless @exemptions;
my $path = -f $file ? $file : $file->path;
Modified: trunk/lib/Parrot/Harness/DefaultTests.pm
==============================================================================
--- trunk/lib/Parrot/Harness/DefaultTests.pm Sun May 23 21:12:16 2010 (r46921)
+++ trunk/lib/Parrot/Harness/DefaultTests.pm Sun May 23 21:38:28 2010 (r46922)
@@ -66,7 +66,6 @@
t/oo/*.t
t/native_pbc/*.t
t/dynpmc/*.t
- t/dynoplibs/*.t
);
# core tests are run unless --runcore-tests is present. Typically
@@ -85,7 +84,9 @@
t/compilers/pge/p5regex/*.t
t/compilers/pge/perl6regex/*.t
t/compilers/tge/*.t
+ t/compilers/opsc/*.t
t/compilers/data_json/*.t
+ t/dynoplibs/*.t
t/library/*.t
t/tools/*.t
t/profiling/*.t
Modified: trunk/lib/Parrot/Ops2c/Utils.pm
==============================================================================
--- trunk/lib/Parrot/Ops2c/Utils.pm Sun May 23 21:12:16 2010 (r46921)
+++ trunk/lib/Parrot/Ops2c/Utils.pm Sun May 23 21:38:28 2010 (r46922)
@@ -607,7 +607,7 @@
foreach my $op ( $self->{ops}->ops ) {
my $func_name = $op->func_name( $self->{trans} );
my $prototype =
- "$self->{sym_export} opcode_t * $func_name (opcode_t *, PARROT_INTERP)";
+ "$self->{sym_export} opcode_t * $func_name(opcode_t *, PARROT_INTERP)";
my $definition;
my $comment = '';
my $one_op = "";
@@ -621,7 +621,7 @@
$comment = "/* " . $op->full_name() . " */";
}
else {
- $definition = "opcode_t *\n$func_name (opcode_t *cur_opcode, PARROT_INTERP)";
+ $definition = "opcode_t *\n$func_name(opcode_t *cur_opcode, PARROT_INTERP)";
}
my $src = $op->source( $self->{trans} );
Modified: trunk/lib/Parrot/Test/Pod.pm
==============================================================================
--- trunk/lib/Parrot/Test/Pod.pm Sun May 23 21:12:16 2010 (r46921)
+++ trunk/lib/Parrot/Test/Pod.pm Sun May 23 21:38:28 2010 (r46922)
@@ -72,11 +72,23 @@
| t/configure/testlib/cdefectivefoobar
| t/configure/testlib/bdefectivefoobar
| examples/config/file/configwithfatalstep
+ | compilers/opsc
}x
) {
delete $files_needing_analysis->{ $file };
next SECOND_FILE;
}
+
+ # read first line. If it contains "nqp" remove file from test.
+ my $fh;
+ open $fh, '<', $full_file or croak "Can't opend file $full_file $!";
+ my $line = <$fh>;
+ close $fh;
+
+ if ($line =~ m/ nqp | use \s v6 /x) {
+ delete $files_needing_analysis->{ $file };
+ next SECOND_FILE;
+ }
}
}
nstore $files_needing_analysis, $sto;
Modified: trunk/runtime/parrot/library/distutils.pir
==============================================================================
--- trunk/runtime/parrot/library/distutils.pir Sun May 23 21:12:16 2010 (r46921)
+++ trunk/runtime/parrot/library/distutils.pir Sun May 23 21:38:28 2010 (r46922)
@@ -1057,8 +1057,6 @@
.param string cflags
.param string ldflags
mkpath('dynext', 1 :named('verbose'))
- .local pmc cores
- cores = get_cores()
.local string load_ext
load_ext = get_load_ext()
$P0 = iter hash
@@ -1067,18 +1065,10 @@
.local string ops, src
ops = shift $P0
src = hash[ops]
- $P1 = iter cores
- L3:
- unless $P1 goto L4
- .local string core, suffix
- core = shift $P1
- suffix = cores[core]
- $S0 = _mk_path_dynops(ops, suffix, load_ext)
+ $S0 = _mk_path_dynops(ops, load_ext)
$I0 = newer($S0, src)
- if $I0 goto L3
- __build_dynops(src, ops, core, suffix, cflags, ldflags)
- goto L3
- L4:
+ if $I0 goto L1
+ __build_dynops(src, ops, cflags, ldflags)
goto L1
L2:
.end
@@ -1086,31 +1076,24 @@
.sub '__build_dynops' :anon
.param string src
.param string ops
- .param string core
- .param string suffix
.param string cflags
.param string ldflags
.local pmc config
config = get_config()
.local string cmd
- cmd = config['perl']
- cmd .= " "
- $S0 = get_tool('build/ops2c.pl')
- cmd .= $S0
- cmd .= " "
- cmd .= core
+ cmd = get_executable('ops2c')
cmd .= " --dynamic "
cmd .= src
system(cmd, 1 :named('verbose'))
$S0 = config['o']
- $S1 = _mk_path_gen_dynops(src, ops, suffix, $S0)
- $S2 = _mk_path_gen_dynops(src, ops, suffix, '.c')
+ $S1 = _mk_path_gen_dynops(src, ops, $S0)
+ $S2 = _mk_path_gen_dynops(src, ops, '.c')
__compile_cc($S1, $S2, cflags)
.local string dynext
$S0 = config['load_ext']
- dynext = _mk_path_dynops(ops, suffix, $S0)
+ dynext = _mk_path_dynops(ops, $S0)
cmd = config['ld']
cmd .= " "
$S0 = config['ld_out']
@@ -1118,7 +1101,7 @@
cmd .= dynext
cmd .= " "
$S0 = config['o']
- $S0 = _mk_path_gen_dynops(src, ops, suffix, $S0)
+ $S0 = _mk_path_gen_dynops(src, ops, $S0)
cmd .= $S0
cmd .= " "
$S0 = get_ldflags()
@@ -1176,10 +1159,8 @@
.sub '_mk_path_dynops' :anon
.param string ops
- .param string suffix
.param string load_ext
$S0 = "dynext/" . ops
- $S0 .= suffix
$S0 .= load_ext
.return ($S0)
.end
@@ -1187,22 +1168,14 @@
.sub '_mk_path_gen_dynops' :anon
.param string src
.param string ops
- .param string suffix
.param string ext
$S0 = dirname(src)
$S0 .= "/"
$S0 .= ops
- $S0 .= suffix
$S0 .= ext
.return ($S0)
.end
-.sub 'get_cores'
- $P0 = new 'Hash'
- $P0['C'] = ''
- .return ($P0)
-.end
-
=item dynpmc
hash
@@ -1711,8 +1684,6 @@
.sub 'clean_dynops'
.param pmc hash
- .local pmc cores
- cores = get_cores()
.local string load_ext, obj
load_ext = get_load_ext()
obj = get_obj()
@@ -1722,22 +1693,14 @@
.local string ops, src
ops = shift $P0
src = hash[ops]
- $P1 = iter cores
- L3:
- unless $P1 goto L4
- .local string core, suffix
- core = shift $P1
- suffix = cores[core]
- $S0 = _mk_path_dynops(ops, suffix, load_ext)
+ $S0 = _mk_path_dynops(ops, load_ext)
unlink($S0, 1 :named('verbose'))
- $S0 = _mk_path_gen_dynops(src, ops, suffix, '.c')
+ $S0 = _mk_path_gen_dynops(src, ops, '.c')
unlink($S0, 1 :named('verbose'))
- $S0 = _mk_path_gen_dynops(src, ops, suffix, '.h')
+ $S0 = _mk_path_gen_dynops(src, ops, '.h')
unlink($S0, 1 :named('verbose'))
- $S0 = _mk_path_gen_dynops(src, ops, suffix, obj)
+ $S0 = _mk_path_gen_dynops(src, ops, obj)
unlink($S0, 1 :named('verbose'))
- goto L3
- L4:
goto L1
L2:
.end
@@ -2407,26 +2370,17 @@
.sub 'get_install_dynops' :anon
.param pmc files
.param pmc hash
- .local string libdir, load_ext, ops, suffix
+ .local string libdir, load_ext, ops
libdir = get_libdir()
load_ext = get_load_ext()
- .local pmc cores
- cores = get_cores()
$P0 = iter hash
L1:
unless $P0 goto L2
ops = shift $P0
- $P1 = iter cores
- L3:
- unless $P1 goto L4
- $S0 = shift $P1
- suffix = cores[$S0]
- $S1 = _mk_path_dynops(ops, suffix, load_ext)
+ $S1 = _mk_path_dynops(ops, load_ext)
$S2 = libdir . "/"
$S2 .= $S1
files[$S2] = $S1
- goto L3
- L4:
goto L1
L2:
.end
Modified: trunk/src/dynoplibs/Rules.in
==============================================================================
--- trunk/src/dynoplibs/Rules.in Sun May 23 21:12:16 2010 (r46921)
+++ trunk/src/dynoplibs/Rules.in Sun May 23 21:38:28 2010 (r46922)
@@ -17,8 +17,8 @@
src/dynoplibs/obscure_ops.h: src/dynoplibs/obscure_ops.c
-src/dynoplibs/obscure_ops.c: src/dynoplibs/obscure.ops $(BUILD_TOOLS_DIR)/ops2c.pl
- $(PERL) $(BUILD_TOOLS_DIR)/ops2c.pl C --dynamic src/dynoplibs/obscure.ops
+src/dynoplibs/obscure_ops.c: src/dynoplibs/obscure.ops $(OPS2C)
+ $(OPS2C) --dynamic src/dynoplibs/obscure.ops
$(DYNEXT_DIR)/math_ops$(LOAD_EXT): src/dynoplibs/math_ops$(O) $(LIBPARROT)
@@ -26,8 +26,8 @@
#IF(win32): if exist $@.manifest mt.exe -nologo -manifest $@.manifest -outputresource:$@;2
#IF(cygwin or hpux): $(CHMOD) 0775 $@
-src/dynoplibs/math_ops.c: src/dynoplibs/math.ops $(BUILD_TOOLS_DIR)/ops2c.pl
- $(PERL) $(BUILD_TOOLS_DIR)/ops2c.pl C --dynamic src/dynoplibs/math.ops
+src/dynoplibs/math_ops.c: src/dynoplibs/math.ops $(OPS2C)
+ $(OPS2C) --dynamic src/dynoplibs/math.ops
src/dynoplibs/math_ops$(O): $(DYNOP_O_DEPS) \
src/dynoplibs/math_ops.c src/dynoplibs/math_ops.h
@@ -45,5 +45,5 @@
src/dynoplibs/deprecated_ops.h: src/dynoplibs/deprecated_ops.c
-src/dynoplibs/deprecated_ops.c: src/dynoplibs/deprecated.ops $(BUILD_TOOLS_DIR)/ops2c.pl
- $(PERL) $(BUILD_TOOLS_DIR)/ops2c.pl C --dynamic src/dynoplibs/deprecated.ops
+src/dynoplibs/deprecated_ops.c: src/dynoplibs/deprecated.ops $(OPS2C)
+ $(OPS2C) --dynamic src/dynoplibs/deprecated.ops
Added: trunk/src/ops/core_ops.c
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/src/ops/core_ops.c Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,29804 @@
+
+/* ex: set ro:
+ * !!!!!!! DO NOT EDIT THIS FILE !!!!!!!
+ *
+ * This file is generated automatically from 'src/ops/core.ops' (and possibly other
+ * .ops files). by ops2c.nqp.
+ *
+ * Any changes made here will be lost!
+ *
+ */
+
+#include "parrot/oplib/core_ops.h"
+#include "pmc/pmc_parrotlibrary.h"
+#include "pmc/pmc_callcontext.h"
+
+
+/* defines - Ops::Trans::C */
+#undef CONST
+#define REL_PC ((size_t)(cur_opcode - (opcode_t *)interp->code->base.data))
+#define CUR_OPCODE cur_opcode
+#define IREG(i) (CUR_CTX->bp.regs_i[cur_opcode[i]])
+#define NREG(i) (CUR_CTX->bp.regs_n[-1L - cur_opcode[i]])
+#define PREG(i) (CUR_CTX->bp_ps.regs_p[-1L - cur_opcode[i]])
+#define SREG(i) (CUR_CTX->bp_ps.regs_s[cur_opcode[i]])
+#define CONST(i) Parrot_pcc_get_constants(interp, interp->ctx)[cur_opcode[i]]
+
+static int get_op(PARROT_INTERP, const char * name, int full);
+
+
+
+
+#include "parrot/dynext.h"
+#include "parrot/embed.h"
+#include "parrot/runcore_api.h"
+#include "pmc/pmc_continuation.h"
+#include "pmc/pmc_parrotlibrary.h"
+
+
+ /* Signed shift operator that is compatible with PMC shifts. This is
+ * guaranteed to produce the same result as bitwise_left_shift_internal modulo
+ * word size, ignoring the fact that Parrot integers are always signed. This
+ * usually gives the same answer regardless whether you shift PMC operands and
+ * then assign to an I-reg, or move the operands to I-regs and do the shift
+ * there -- except when the true result is between 2^{w-1} and 2^w (where w is
+ * the word size), in which case the high order bit is taken as the sign,
+ * giving a truncated result that is 2^w lower.
+ */
+#define bit_shift_left(number, bits) \
+ ((bits) >= 8*INTVAL_SIZE ? 0 \
+ : (bits) >= 0 ? (number) << (bits) \
+ : (bits) > -8*INTVAL_SIZE ? (number) >> -(bits) \
+ : 0)
+
+
+#include "../io/io_private.h"
+
+
+#if PARROT_HAS_ICU
+# include <unicode/uchar.h>
+#endif
+
+
+
+INTVAL core_numops = 1269;
+
+/*
+** Op Function Table:
+*/
+
+static op_func_t core_op_func_table[1269] = { Parrot_end, /* 0 */
+ Parrot_noop, /* 1 */
+ Parrot_check_events, /* 2 */
+ Parrot_check_events__, /* 3 */
+ Parrot_wrapper__, /* 4 */
+ Parrot_load_bytecode_s, /* 5 */
+ Parrot_load_bytecode_sc, /* 6 */
+ Parrot_load_language_s, /* 7 */
+ Parrot_load_language_sc, /* 8 */
+ Parrot_branch_i, /* 9 */
+ Parrot_branch_ic, /* 10 */
+ Parrot_local_branch_p_i, /* 11 */
+ Parrot_local_branch_p_ic, /* 12 */
+ Parrot_local_return_p, /* 13 */
+ Parrot_jump_i, /* 14 */
+ Parrot_jump_ic, /* 15 */
+ Parrot_enternative, /* 16 */
+ Parrot_if_i_ic, /* 17 */
+ Parrot_if_n_ic, /* 18 */
+ Parrot_if_s_ic, /* 19 */
+ Parrot_if_p_ic, /* 20 */
+ Parrot_unless_i_ic, /* 21 */
+ Parrot_unless_n_ic, /* 22 */
+ Parrot_unless_s_ic, /* 23 */
+ Parrot_unless_p_ic, /* 24 */
+ Parrot_invokecc_p, /* 25 */
+ Parrot_invoke_p_p, /* 26 */
+ Parrot_yield, /* 27 */
+ Parrot_tailcall_p, /* 28 */
+ Parrot_returncc, /* 29 */
+ Parrot_capture_lex_p, /* 30 */
+ Parrot_newclosure_p_p, /* 31 */
+ Parrot_set_args_pc, /* 32 */
+ Parrot_get_params_pc, /* 33 */
+ Parrot_set_returns_pc, /* 34 */
+ Parrot_get_results_pc, /* 35 */
+ Parrot_set_result_info_p, /* 36 */
+ Parrot_set_result_info_pc, /* 37 */
+ Parrot_result_info_p, /* 38 */
+ Parrot_set_addr_i_ic, /* 39 */
+ Parrot_set_addr_p_ic, /* 40 */
+ Parrot_set_addr_p_i, /* 41 */
+ Parrot_get_addr_i_p, /* 42 */
+ Parrot_schedule_p, /* 43 */
+ Parrot_addhandler_p, /* 44 */
+ Parrot_push_eh_ic, /* 45 */
+ Parrot_push_eh_p, /* 46 */
+ Parrot_pop_eh, /* 47 */
+ Parrot_throw_p, /* 48 */
+ Parrot_throw_p_p, /* 49 */
+ Parrot_rethrow_p, /* 50 */
+ Parrot_count_eh_i, /* 51 */
+ Parrot_die_s, /* 52 */
+ Parrot_die_sc, /* 53 */
+ Parrot_die_p, /* 54 */
+ Parrot_die_pc, /* 55 */
+ Parrot_die_i_i, /* 56 */
+ Parrot_die_ic_i, /* 57 */
+ Parrot_die_i_ic, /* 58 */
+ Parrot_die_ic_ic, /* 59 */
+ Parrot_exit_i, /* 60 */
+ Parrot_exit_ic, /* 61 */
+ Parrot_debug_i, /* 62 */
+ Parrot_debug_ic, /* 63 */
+ Parrot_bounds_i, /* 64 */
+ Parrot_bounds_ic, /* 65 */
+ Parrot_profile_i, /* 66 */
+ Parrot_profile_ic, /* 67 */
+ Parrot_trace_i, /* 68 */
+ Parrot_trace_ic, /* 69 */
+ Parrot_gc_debug_i, /* 70 */
+ Parrot_gc_debug_ic, /* 71 */
+ Parrot_interpinfo_i_i, /* 72 */
+ Parrot_interpinfo_i_ic, /* 73 */
+ Parrot_interpinfo_p_i, /* 74 */
+ Parrot_interpinfo_p_ic, /* 75 */
+ Parrot_interpinfo_s_i, /* 76 */
+ Parrot_interpinfo_s_ic, /* 77 */
+ Parrot_warningson_i, /* 78 */
+ Parrot_warningson_ic, /* 79 */
+ Parrot_warningsoff_i, /* 80 */
+ Parrot_warningsoff_ic, /* 81 */
+ Parrot_errorson_i, /* 82 */
+ Parrot_errorson_ic, /* 83 */
+ Parrot_errorsoff_i, /* 84 */
+ Parrot_errorsoff_ic, /* 85 */
+ Parrot_runinterp_p_i, /* 86 */
+ Parrot_runinterp_p_ic, /* 87 */
+ Parrot_getinterp_p, /* 88 */
+ Parrot_sweep_ic, /* 89 */
+ Parrot_collect, /* 90 */
+ Parrot_sweepoff, /* 91 */
+ Parrot_sweepon, /* 92 */
+ Parrot_collectoff, /* 93 */
+ Parrot_collecton, /* 94 */
+ Parrot_needs_destroy_p, /* 95 */
+ Parrot_loadlib_p_s, /* 96 */
+ Parrot_loadlib_p_sc, /* 97 */
+ Parrot_loadlib_p_s_p, /* 98 */
+ Parrot_loadlib_p_sc_p, /* 99 */
+ Parrot_loadlib_p_s_pc, /* 100 */
+ Parrot_loadlib_p_sc_pc, /* 101 */
+ Parrot_dlfunc_p_p_s_s, /* 102 */
+ Parrot_dlfunc_p_p_sc_s, /* 103 */
+ Parrot_dlfunc_p_p_s_sc, /* 104 */
+ Parrot_dlfunc_p_p_sc_sc, /* 105 */
+ Parrot_dlvar_p_p_s, /* 106 */
+ Parrot_dlvar_p_p_sc, /* 107 */
+ Parrot_compreg_s_p, /* 108 */
+ Parrot_compreg_sc_p, /* 109 */
+ Parrot_compreg_p_s, /* 110 */
+ Parrot_compreg_p_sc, /* 111 */
+ Parrot_new_callback_p_p_p_s, /* 112 */
+ Parrot_new_callback_p_p_p_sc, /* 113 */
+ Parrot_annotations_p, /* 114 */
+ Parrot_annotations_p_s, /* 115 */
+ Parrot_annotations_p_sc, /* 116 */
+ Parrot_band_i_i, /* 117 */
+ Parrot_band_i_ic, /* 118 */
+ Parrot_band_p_i, /* 119 */
+ Parrot_band_p_ic, /* 120 */
+ Parrot_band_p_p, /* 121 */
+ Parrot_band_i_i_i, /* 122 */
+ Parrot_band_i_ic_i, /* 123 */
+ Parrot_band_i_i_ic, /* 124 */
+ Parrot_band_p_p_i, /* 125 */
+ Parrot_band_p_p_ic, /* 126 */
+ Parrot_band_p_p_p, /* 127 */
+ Parrot_bands_p_s, /* 128 */
+ Parrot_bands_p_sc, /* 129 */
+ Parrot_bands_p_p, /* 130 */
+ Parrot_bands_s_s_s, /* 131 */
+ Parrot_bands_s_sc_s, /* 132 */
+ Parrot_bands_s_s_sc, /* 133 */
+ Parrot_bands_p_p_s, /* 134 */
+ Parrot_bands_p_p_sc, /* 135 */
+ Parrot_bands_p_p_p, /* 136 */
+ Parrot_bnot_i, /* 137 */
+ Parrot_bnot_i_i, /* 138 */
+ Parrot_bnot_p, /* 139 */
+ Parrot_bnot_p_p, /* 140 */
+ Parrot_bnots_s_s, /* 141 */
+ Parrot_bnots_s_sc, /* 142 */
+ Parrot_bnots_p, /* 143 */
+ Parrot_bnots_p_p, /* 144 */
+ Parrot_bor_i_i, /* 145 */
+ Parrot_bor_i_ic, /* 146 */
+ Parrot_bor_p_i, /* 147 */
+ Parrot_bor_p_ic, /* 148 */
+ Parrot_bor_p_p, /* 149 */
+ Parrot_bor_i_i_i, /* 150 */
+ Parrot_bor_i_ic_i, /* 151 */
+ Parrot_bor_i_i_ic, /* 152 */
+ Parrot_bor_p_p_i, /* 153 */
+ Parrot_bor_p_p_ic, /* 154 */
+ Parrot_bor_p_p_p, /* 155 */
+ Parrot_bors_p_s, /* 156 */
+ Parrot_bors_p_sc, /* 157 */
+ Parrot_bors_p_p, /* 158 */
+ Parrot_bors_s_s_s, /* 159 */
+ Parrot_bors_s_sc_s, /* 160 */
+ Parrot_bors_s_s_sc, /* 161 */
+ Parrot_bors_p_p_s, /* 162 */
+ Parrot_bors_p_p_sc, /* 163 */
+ Parrot_bors_p_p_p, /* 164 */
+ Parrot_shl_i_i, /* 165 */
+ Parrot_shl_i_ic, /* 166 */
+ Parrot_shl_p_i, /* 167 */
+ Parrot_shl_p_ic, /* 168 */
+ Parrot_shl_p_p, /* 169 */
+ Parrot_shl_i_i_i, /* 170 */
+ Parrot_shl_i_ic_i, /* 171 */
+ Parrot_shl_i_i_ic, /* 172 */
+ Parrot_shl_p_p_i, /* 173 */
+ Parrot_shl_p_p_ic, /* 174 */
+ Parrot_shl_p_p_p, /* 175 */
+ Parrot_shr_i_i, /* 176 */
+ Parrot_shr_i_ic, /* 177 */
+ Parrot_shr_p_i, /* 178 */
+ Parrot_shr_p_ic, /* 179 */
+ Parrot_shr_p_p, /* 180 */
+ Parrot_shr_i_i_i, /* 181 */
+ Parrot_shr_i_ic_i, /* 182 */
+ Parrot_shr_i_i_ic, /* 183 */
+ Parrot_shr_p_p_i, /* 184 */
+ Parrot_shr_p_p_ic, /* 185 */
+ Parrot_shr_p_p_p, /* 186 */
+ Parrot_lsr_i_i, /* 187 */
+ Parrot_lsr_i_ic, /* 188 */
+ Parrot_lsr_p_i, /* 189 */
+ Parrot_lsr_p_ic, /* 190 */
+ Parrot_lsr_p_p, /* 191 */
+ Parrot_lsr_i_i_i, /* 192 */
+ Parrot_lsr_i_ic_i, /* 193 */
+ Parrot_lsr_i_i_ic, /* 194 */
+ Parrot_lsr_p_p_i, /* 195 */
+ Parrot_lsr_p_p_ic, /* 196 */
+ Parrot_lsr_p_p_p, /* 197 */
+ Parrot_rot_i_i_i_ic, /* 198 */
+ Parrot_rot_i_ic_i_ic, /* 199 */
+ Parrot_rot_i_i_ic_ic, /* 200 */
+ Parrot_bxor_i_i, /* 201 */
+ Parrot_bxor_i_ic, /* 202 */
+ Parrot_bxor_p_i, /* 203 */
+ Parrot_bxor_p_ic, /* 204 */
+ Parrot_bxor_p_p, /* 205 */
+ Parrot_bxor_i_i_i, /* 206 */
+ Parrot_bxor_i_ic_i, /* 207 */
+ Parrot_bxor_i_i_ic, /* 208 */
+ Parrot_bxor_p_p_i, /* 209 */
+ Parrot_bxor_p_p_ic, /* 210 */
+ Parrot_bxor_p_p_p, /* 211 */
+ Parrot_bxors_p_s, /* 212 */
+ Parrot_bxors_p_sc, /* 213 */
+ Parrot_bxors_p_p, /* 214 */
+ Parrot_bxors_s_s_s, /* 215 */
+ Parrot_bxors_s_sc_s, /* 216 */
+ Parrot_bxors_s_s_sc, /* 217 */
+ Parrot_bxors_p_p_s, /* 218 */
+ Parrot_bxors_p_p_sc, /* 219 */
+ Parrot_bxors_p_p_p, /* 220 */
+ Parrot_eq_i_i_ic, /* 221 */
+ Parrot_eq_ic_i_ic, /* 222 */
+ Parrot_eq_i_ic_ic, /* 223 */
+ Parrot_eq_n_n_ic, /* 224 */
+ Parrot_eq_nc_n_ic, /* 225 */
+ Parrot_eq_n_nc_ic, /* 226 */
+ Parrot_eq_s_s_ic, /* 227 */
+ Parrot_eq_sc_s_ic, /* 228 */
+ Parrot_eq_s_sc_ic, /* 229 */
+ Parrot_eq_p_p_ic, /* 230 */
+ Parrot_eq_p_i_ic, /* 231 */
+ Parrot_eq_p_ic_ic, /* 232 */
+ Parrot_eq_p_n_ic, /* 233 */
+ Parrot_eq_p_nc_ic, /* 234 */
+ Parrot_eq_p_s_ic, /* 235 */
+ Parrot_eq_p_sc_ic, /* 236 */
+ Parrot_eq_str_p_p_ic, /* 237 */
+ Parrot_eq_num_p_p_ic, /* 238 */
+ Parrot_eq_addr_s_s_ic, /* 239 */
+ Parrot_eq_addr_sc_s_ic, /* 240 */
+ Parrot_eq_addr_s_sc_ic, /* 241 */
+ Parrot_eq_addr_sc_sc_ic, /* 242 */
+ Parrot_eq_addr_p_p_ic, /* 243 */
+ Parrot_ne_i_i_ic, /* 244 */
+ Parrot_ne_ic_i_ic, /* 245 */
+ Parrot_ne_i_ic_ic, /* 246 */
+ Parrot_ne_n_n_ic, /* 247 */
+ Parrot_ne_nc_n_ic, /* 248 */
+ Parrot_ne_n_nc_ic, /* 249 */
+ Parrot_ne_s_s_ic, /* 250 */
+ Parrot_ne_sc_s_ic, /* 251 */
+ Parrot_ne_s_sc_ic, /* 252 */
+ Parrot_ne_p_p_ic, /* 253 */
+ Parrot_ne_p_i_ic, /* 254 */
+ Parrot_ne_p_ic_ic, /* 255 */
+ Parrot_ne_p_n_ic, /* 256 */
+ Parrot_ne_p_nc_ic, /* 257 */
+ Parrot_ne_p_s_ic, /* 258 */
+ Parrot_ne_p_sc_ic, /* 259 */
+ Parrot_ne_str_p_p_ic, /* 260 */
+ Parrot_ne_num_p_p_ic, /* 261 */
+ Parrot_ne_addr_s_s_ic, /* 262 */
+ Parrot_ne_addr_sc_s_ic, /* 263 */
+ Parrot_ne_addr_s_sc_ic, /* 264 */
+ Parrot_ne_addr_sc_sc_ic, /* 265 */
+ Parrot_ne_addr_p_p_ic, /* 266 */
+ Parrot_lt_i_i_ic, /* 267 */
+ Parrot_lt_ic_i_ic, /* 268 */
+ Parrot_lt_i_ic_ic, /* 269 */
+ Parrot_lt_n_n_ic, /* 270 */
+ Parrot_lt_nc_n_ic, /* 271 */
+ Parrot_lt_n_nc_ic, /* 272 */
+ Parrot_lt_s_s_ic, /* 273 */
+ Parrot_lt_sc_s_ic, /* 274 */
+ Parrot_lt_s_sc_ic, /* 275 */
+ Parrot_lt_p_p_ic, /* 276 */
+ Parrot_lt_p_i_ic, /* 277 */
+ Parrot_lt_p_ic_ic, /* 278 */
+ Parrot_lt_p_n_ic, /* 279 */
+ Parrot_lt_p_nc_ic, /* 280 */
+ Parrot_lt_p_s_ic, /* 281 */
+ Parrot_lt_p_sc_ic, /* 282 */
+ Parrot_lt_str_p_p_ic, /* 283 */
+ Parrot_lt_num_p_p_ic, /* 284 */
+ Parrot_le_i_i_ic, /* 285 */
+ Parrot_le_ic_i_ic, /* 286 */
+ Parrot_le_i_ic_ic, /* 287 */
+ Parrot_le_n_n_ic, /* 288 */
+ Parrot_le_nc_n_ic, /* 289 */
+ Parrot_le_n_nc_ic, /* 290 */
+ Parrot_le_s_s_ic, /* 291 */
+ Parrot_le_sc_s_ic, /* 292 */
+ Parrot_le_s_sc_ic, /* 293 */
+ Parrot_le_p_p_ic, /* 294 */
+ Parrot_le_p_i_ic, /* 295 */
+ Parrot_le_p_ic_ic, /* 296 */
+ Parrot_le_p_n_ic, /* 297 */
+ Parrot_le_p_nc_ic, /* 298 */
+ Parrot_le_p_s_ic, /* 299 */
+ Parrot_le_p_sc_ic, /* 300 */
+ Parrot_le_str_p_p_ic, /* 301 */
+ Parrot_le_num_p_p_ic, /* 302 */
+ Parrot_gt_p_p_ic, /* 303 */
+ Parrot_gt_p_i_ic, /* 304 */
+ Parrot_gt_p_ic_ic, /* 305 */
+ Parrot_gt_p_n_ic, /* 306 */
+ Parrot_gt_p_nc_ic, /* 307 */
+ Parrot_gt_p_s_ic, /* 308 */
+ Parrot_gt_p_sc_ic, /* 309 */
+ Parrot_gt_str_p_p_ic, /* 310 */
+ Parrot_gt_num_p_p_ic, /* 311 */
+ Parrot_ge_p_p_ic, /* 312 */
+ Parrot_ge_p_i_ic, /* 313 */
+ Parrot_ge_p_ic_ic, /* 314 */
+ Parrot_ge_p_n_ic, /* 315 */
+ Parrot_ge_p_nc_ic, /* 316 */
+ Parrot_ge_p_s_ic, /* 317 */
+ Parrot_ge_p_sc_ic, /* 318 */
+ Parrot_ge_str_p_p_ic, /* 319 */
+ Parrot_ge_num_p_p_ic, /* 320 */
+ Parrot_if_null_p_ic, /* 321 */
+ Parrot_if_null_s_ic, /* 322 */
+ Parrot_unless_null_p_ic, /* 323 */
+ Parrot_unless_null_s_ic, /* 324 */
+ Parrot_cmp_i_i_i, /* 325 */
+ Parrot_cmp_i_ic_i, /* 326 */
+ Parrot_cmp_i_i_ic, /* 327 */
+ Parrot_cmp_i_n_n, /* 328 */
+ Parrot_cmp_i_nc_n, /* 329 */
+ Parrot_cmp_i_n_nc, /* 330 */
+ Parrot_cmp_i_s_s, /* 331 */
+ Parrot_cmp_i_sc_s, /* 332 */
+ Parrot_cmp_i_s_sc, /* 333 */
+ Parrot_cmp_i_p_p, /* 334 */
+ Parrot_cmp_i_p_i, /* 335 */
+ Parrot_cmp_i_p_ic, /* 336 */
+ Parrot_cmp_i_p_n, /* 337 */
+ Parrot_cmp_i_p_nc, /* 338 */
+ Parrot_cmp_i_p_s, /* 339 */
+ Parrot_cmp_i_p_sc, /* 340 */
+ Parrot_cmp_str_i_p_p, /* 341 */
+ Parrot_cmp_num_i_p_p, /* 342 */
+ Parrot_cmp_pmc_p_p_p, /* 343 */
+ Parrot_issame_i_p_p, /* 344 */
+ Parrot_issame_i_s_s, /* 345 */
+ Parrot_issame_i_sc_s, /* 346 */
+ Parrot_issame_i_s_sc, /* 347 */
+ Parrot_issame_i_sc_sc, /* 348 */
+ Parrot_isntsame_i_p_p, /* 349 */
+ Parrot_isntsame_i_s_s, /* 350 */
+ Parrot_isntsame_i_sc_s, /* 351 */
+ Parrot_isntsame_i_s_sc, /* 352 */
+ Parrot_isntsame_i_sc_sc, /* 353 */
+ Parrot_istrue_i_p, /* 354 */
+ Parrot_isfalse_i_p, /* 355 */
+ Parrot_isnull_i_p, /* 356 */
+ Parrot_isnull_i_pc, /* 357 */
+ Parrot_isnull_i_s, /* 358 */
+ Parrot_isnull_i_sc, /* 359 */
+ Parrot_isgt_i_p_p, /* 360 */
+ Parrot_isge_i_p_p, /* 361 */
+ Parrot_isle_i_i_i, /* 362 */
+ Parrot_isle_i_ic_i, /* 363 */
+ Parrot_isle_i_i_ic, /* 364 */
+ Parrot_isle_i_n_n, /* 365 */
+ Parrot_isle_i_nc_n, /* 366 */
+ Parrot_isle_i_n_nc, /* 367 */
+ Parrot_isle_i_s_s, /* 368 */
+ Parrot_isle_i_sc_s, /* 369 */
+ Parrot_isle_i_s_sc, /* 370 */
+ Parrot_isle_i_p_p, /* 371 */
+ Parrot_islt_i_i_i, /* 372 */
+ Parrot_islt_i_ic_i, /* 373 */
+ Parrot_islt_i_i_ic, /* 374 */
+ Parrot_islt_i_n_n, /* 375 */
+ Parrot_islt_i_nc_n, /* 376 */
+ Parrot_islt_i_n_nc, /* 377 */
+ Parrot_islt_i_s_s, /* 378 */
+ Parrot_islt_i_sc_s, /* 379 */
+ Parrot_islt_i_s_sc, /* 380 */
+ Parrot_islt_i_p_p, /* 381 */
+ Parrot_iseq_i_i_i, /* 382 */
+ Parrot_iseq_i_ic_i, /* 383 */
+ Parrot_iseq_i_i_ic, /* 384 */
+ Parrot_iseq_i_n_n, /* 385 */
+ Parrot_iseq_i_nc_n, /* 386 */
+ Parrot_iseq_i_n_nc, /* 387 */
+ Parrot_iseq_i_s_s, /* 388 */
+ Parrot_iseq_i_sc_s, /* 389 */
+ Parrot_iseq_i_s_sc, /* 390 */
+ Parrot_iseq_i_p_p, /* 391 */
+ Parrot_isne_i_i_i, /* 392 */
+ Parrot_isne_i_ic_i, /* 393 */
+ Parrot_isne_i_i_ic, /* 394 */
+ Parrot_isne_i_n_n, /* 395 */
+ Parrot_isne_i_nc_n, /* 396 */
+ Parrot_isne_i_n_nc, /* 397 */
+ Parrot_isne_i_s_s, /* 398 */
+ Parrot_isne_i_sc_s, /* 399 */
+ Parrot_isne_i_s_sc, /* 400 */
+ Parrot_isne_i_p_p, /* 401 */
+ Parrot_and_i_i_i, /* 402 */
+ Parrot_and_i_ic_i, /* 403 */
+ Parrot_and_i_i_ic, /* 404 */
+ Parrot_and_p_p_p, /* 405 */
+ Parrot_not_i, /* 406 */
+ Parrot_not_i_i, /* 407 */
+ Parrot_not_p, /* 408 */
+ Parrot_not_p_p, /* 409 */
+ Parrot_or_i_i_i, /* 410 */
+ Parrot_or_i_ic_i, /* 411 */
+ Parrot_or_i_i_ic, /* 412 */
+ Parrot_or_p_p_p, /* 413 */
+ Parrot_xor_i_i_i, /* 414 */
+ Parrot_xor_i_ic_i, /* 415 */
+ Parrot_xor_i_i_ic, /* 416 */
+ Parrot_xor_p_p_p, /* 417 */
+ Parrot_debug_init, /* 418 */
+ Parrot_debug_load_sc, /* 419 */
+ Parrot_debug_break, /* 420 */
+ Parrot_debug_print, /* 421 */
+ Parrot_backtrace, /* 422 */
+ Parrot_getline_i, /* 423 */
+ Parrot_getfile_s, /* 424 */
+ Parrot_close_p, /* 425 */
+ Parrot_fdopen_p_i_s, /* 426 */
+ Parrot_fdopen_p_ic_s, /* 427 */
+ Parrot_fdopen_p_i_sc, /* 428 */
+ Parrot_fdopen_p_ic_sc, /* 429 */
+ Parrot_getstdin_p, /* 430 */
+ Parrot_getstdout_p, /* 431 */
+ Parrot_getstderr_p, /* 432 */
+ Parrot_setstdin_p, /* 433 */
+ Parrot_setstdout_p, /* 434 */
+ Parrot_setstderr_p, /* 435 */
+ Parrot_open_p_s_s, /* 436 */
+ Parrot_open_p_sc_s, /* 437 */
+ Parrot_open_p_s_sc, /* 438 */
+ Parrot_open_p_sc_sc, /* 439 */
+ Parrot_open_p_s, /* 440 */
+ Parrot_open_p_sc, /* 441 */
+ Parrot_print_i, /* 442 */
+ Parrot_print_ic, /* 443 */
+ Parrot_print_n, /* 444 */
+ Parrot_print_nc, /* 445 */
+ Parrot_print_s, /* 446 */
+ Parrot_print_sc, /* 447 */
+ Parrot_print_p, /* 448 */
+ Parrot_say_i, /* 449 */
+ Parrot_say_ic, /* 450 */
+ Parrot_say_n, /* 451 */
+ Parrot_say_nc, /* 452 */
+ Parrot_say_s, /* 453 */
+ Parrot_say_sc, /* 454 */
+ Parrot_say_p, /* 455 */
+ Parrot_printerr_i, /* 456 */
+ Parrot_printerr_ic, /* 457 */
+ Parrot_printerr_n, /* 458 */
+ Parrot_printerr_nc, /* 459 */
+ Parrot_printerr_s, /* 460 */
+ Parrot_printerr_sc, /* 461 */
+ Parrot_printerr_p, /* 462 */
+ Parrot_print_p_i, /* 463 */
+ Parrot_print_p_ic, /* 464 */
+ Parrot_print_p_n, /* 465 */
+ Parrot_print_p_nc, /* 466 */
+ Parrot_print_p_s, /* 467 */
+ Parrot_print_p_sc, /* 468 */
+ Parrot_print_p_p, /* 469 */
+ Parrot_read_s_i, /* 470 */
+ Parrot_read_s_ic, /* 471 */
+ Parrot_read_s_p_i, /* 472 */
+ Parrot_read_s_p_ic, /* 473 */
+ Parrot_readline_s_p, /* 474 */
+ Parrot_peek_s, /* 475 */
+ Parrot_peek_s_p, /* 476 */
+ Parrot_stat_i_s_i, /* 477 */
+ Parrot_stat_i_sc_i, /* 478 */
+ Parrot_stat_i_s_ic, /* 479 */
+ Parrot_stat_i_sc_ic, /* 480 */
+ Parrot_stat_i_i_i, /* 481 */
+ Parrot_stat_i_ic_i, /* 482 */
+ Parrot_stat_i_i_ic, /* 483 */
+ Parrot_stat_i_ic_ic, /* 484 */
+ Parrot_seek_p_i_i, /* 485 */
+ Parrot_seek_p_ic_i, /* 486 */
+ Parrot_seek_p_i_ic, /* 487 */
+ Parrot_seek_p_ic_ic, /* 488 */
+ Parrot_seek_p_i_i_i, /* 489 */
+ Parrot_seek_p_ic_i_i, /* 490 */
+ Parrot_seek_p_i_ic_i, /* 491 */
+ Parrot_seek_p_ic_ic_i, /* 492 */
+ Parrot_seek_p_i_i_ic, /* 493 */
+ Parrot_seek_p_ic_i_ic, /* 494 */
+ Parrot_seek_p_i_ic_ic, /* 495 */
+ Parrot_seek_p_ic_ic_ic, /* 496 */
+ Parrot_tell_i_p, /* 497 */
+ Parrot_tell_i_i_p, /* 498 */
+ Parrot_abs_i, /* 499 */
+ Parrot_abs_n, /* 500 */
+ Parrot_abs_i_i, /* 501 */
+ Parrot_abs_n_n, /* 502 */
+ Parrot_abs_p, /* 503 */
+ Parrot_abs_p_p, /* 504 */
+ Parrot_add_i_i, /* 505 */
+ Parrot_add_i_ic, /* 506 */
+ Parrot_add_n_n, /* 507 */
+ Parrot_add_n_nc, /* 508 */
+ Parrot_add_p_p, /* 509 */
+ Parrot_add_p_i, /* 510 */
+ Parrot_add_p_ic, /* 511 */
+ Parrot_add_p_n, /* 512 */
+ Parrot_add_p_nc, /* 513 */
+ Parrot_add_i_i_i, /* 514 */
+ Parrot_add_i_ic_i, /* 515 */
+ Parrot_add_i_i_ic, /* 516 */
+ Parrot_add_n_n_n, /* 517 */
+ Parrot_add_n_nc_n, /* 518 */
+ Parrot_add_n_n_nc, /* 519 */
+ Parrot_add_p_p_p, /* 520 */
+ Parrot_add_p_p_i, /* 521 */
+ Parrot_add_p_p_ic, /* 522 */
+ Parrot_add_p_p_n, /* 523 */
+ Parrot_add_p_p_nc, /* 524 */
+ Parrot_cmod_i_i_i, /* 525 */
+ Parrot_cmod_i_ic_i, /* 526 */
+ Parrot_cmod_i_i_ic, /* 527 */
+ Parrot_cmod_p_p_i, /* 528 */
+ Parrot_cmod_p_p_ic, /* 529 */
+ Parrot_cmod_p_p_p, /* 530 */
+ Parrot_cmod_n_n_n, /* 531 */
+ Parrot_cmod_n_nc_n, /* 532 */
+ Parrot_cmod_n_n_nc, /* 533 */
+ Parrot_cmod_p_p_n, /* 534 */
+ Parrot_cmod_p_p_nc, /* 535 */
+ Parrot_dec_i, /* 536 */
+ Parrot_dec_n, /* 537 */
+ Parrot_dec_p, /* 538 */
+ Parrot_div_i_i, /* 539 */
+ Parrot_div_i_ic, /* 540 */
+ Parrot_div_n_n, /* 541 */
+ Parrot_div_n_nc, /* 542 */
+ Parrot_div_p_p, /* 543 */
+ Parrot_div_p_i, /* 544 */
+ Parrot_div_p_ic, /* 545 */
+ Parrot_div_p_n, /* 546 */
+ Parrot_div_p_nc, /* 547 */
+ Parrot_div_i_i_i, /* 548 */
+ Parrot_div_i_ic_i, /* 549 */
+ Parrot_div_i_i_ic, /* 550 */
+ Parrot_div_i_ic_ic, /* 551 */
+ Parrot_div_n_n_n, /* 552 */
+ Parrot_div_n_nc_n, /* 553 */
+ Parrot_div_n_n_nc, /* 554 */
+ Parrot_div_n_nc_nc, /* 555 */
+ Parrot_div_p_p_p, /* 556 */
+ Parrot_div_p_p_i, /* 557 */
+ Parrot_div_p_p_ic, /* 558 */
+ Parrot_div_p_p_n, /* 559 */
+ Parrot_div_p_p_nc, /* 560 */
+ Parrot_fdiv_i_i, /* 561 */
+ Parrot_fdiv_i_ic, /* 562 */
+ Parrot_fdiv_n_n, /* 563 */
+ Parrot_fdiv_n_nc, /* 564 */
+ Parrot_fdiv_p_p, /* 565 */
+ Parrot_fdiv_p_i, /* 566 */
+ Parrot_fdiv_p_ic, /* 567 */
+ Parrot_fdiv_p_n, /* 568 */
+ Parrot_fdiv_p_nc, /* 569 */
+ Parrot_fdiv_i_i_i, /* 570 */
+ Parrot_fdiv_i_ic_i, /* 571 */
+ Parrot_fdiv_i_i_ic, /* 572 */
+ Parrot_fdiv_n_n_n, /* 573 */
+ Parrot_fdiv_n_nc_n, /* 574 */
+ Parrot_fdiv_n_n_nc, /* 575 */
+ Parrot_fdiv_p_p_p, /* 576 */
+ Parrot_fdiv_p_p_i, /* 577 */
+ Parrot_fdiv_p_p_ic, /* 578 */
+ Parrot_fdiv_p_p_n, /* 579 */
+ Parrot_fdiv_p_p_nc, /* 580 */
+ Parrot_ceil_n, /* 581 */
+ Parrot_ceil_i_n, /* 582 */
+ Parrot_ceil_n_n, /* 583 */
+ Parrot_floor_n, /* 584 */
+ Parrot_floor_i_n, /* 585 */
+ Parrot_floor_n_n, /* 586 */
+ Parrot_inc_i, /* 587 */
+ Parrot_inc_n, /* 588 */
+ Parrot_inc_p, /* 589 */
+ Parrot_mod_i_i, /* 590 */
+ Parrot_mod_i_ic, /* 591 */
+ Parrot_mod_n_n, /* 592 */
+ Parrot_mod_n_nc, /* 593 */
+ Parrot_mod_p_p, /* 594 */
+ Parrot_mod_p_i, /* 595 */
+ Parrot_mod_p_ic, /* 596 */
+ Parrot_mod_p_n, /* 597 */
+ Parrot_mod_p_nc, /* 598 */
+ Parrot_mod_i_i_i, /* 599 */
+ Parrot_mod_i_ic_i, /* 600 */
+ Parrot_mod_i_i_ic, /* 601 */
+ Parrot_mod_n_n_n, /* 602 */
+ Parrot_mod_n_nc_n, /* 603 */
+ Parrot_mod_n_n_nc, /* 604 */
+ Parrot_mod_p_p_p, /* 605 */
+ Parrot_mod_p_p_i, /* 606 */
+ Parrot_mod_p_p_ic, /* 607 */
+ Parrot_mod_p_p_n, /* 608 */
+ Parrot_mod_p_p_nc, /* 609 */
+ Parrot_mul_i_i, /* 610 */
+ Parrot_mul_i_ic, /* 611 */
+ Parrot_mul_n_n, /* 612 */
+ Parrot_mul_n_nc, /* 613 */
+ Parrot_mul_p_p, /* 614 */
+ Parrot_mul_p_i, /* 615 */
+ Parrot_mul_p_ic, /* 616 */
+ Parrot_mul_p_n, /* 617 */
+ Parrot_mul_p_nc, /* 618 */
+ Parrot_mul_i_i_i, /* 619 */
+ Parrot_mul_i_ic_i, /* 620 */
+ Parrot_mul_i_i_ic, /* 621 */
+ Parrot_mul_n_n_n, /* 622 */
+ Parrot_mul_n_nc_n, /* 623 */
+ Parrot_mul_n_n_nc, /* 624 */
+ Parrot_mul_p_p_p, /* 625 */
+ Parrot_mul_p_p_i, /* 626 */
+ Parrot_mul_p_p_ic, /* 627 */
+ Parrot_mul_p_p_n, /* 628 */
+ Parrot_mul_p_p_nc, /* 629 */
+ Parrot_neg_i, /* 630 */
+ Parrot_neg_n, /* 631 */
+ Parrot_neg_p, /* 632 */
+ Parrot_neg_i_i, /* 633 */
+ Parrot_neg_n_n, /* 634 */
+ Parrot_neg_p_p, /* 635 */
+ Parrot_pow_n_n_n, /* 636 */
+ Parrot_pow_n_nc_n, /* 637 */
+ Parrot_pow_n_n_nc, /* 638 */
+ Parrot_pow_p_p_p, /* 639 */
+ Parrot_pow_p_p_i, /* 640 */
+ Parrot_pow_p_p_ic, /* 641 */
+ Parrot_pow_p_p_n, /* 642 */
+ Parrot_pow_p_p_nc, /* 643 */
+ Parrot_pow_n_n_i, /* 644 */
+ Parrot_pow_n_nc_i, /* 645 */
+ Parrot_pow_n_n_ic, /* 646 */
+ Parrot_pow_n_nc_ic, /* 647 */
+ Parrot_sub_i_i, /* 648 */
+ Parrot_sub_i_ic, /* 649 */
+ Parrot_sub_n_n, /* 650 */
+ Parrot_sub_n_nc, /* 651 */
+ Parrot_sub_p_p, /* 652 */
+ Parrot_sub_p_i, /* 653 */
+ Parrot_sub_p_ic, /* 654 */
+ Parrot_sub_p_n, /* 655 */
+ Parrot_sub_p_nc, /* 656 */
+ Parrot_sub_i_i_i, /* 657 */
+ Parrot_sub_i_ic_i, /* 658 */
+ Parrot_sub_i_i_ic, /* 659 */
+ Parrot_sub_n_n_n, /* 660 */
+ Parrot_sub_n_nc_n, /* 661 */
+ Parrot_sub_n_n_nc, /* 662 */
+ Parrot_sub_p_p_p, /* 663 */
+ Parrot_sub_p_p_i, /* 664 */
+ Parrot_sub_p_p_ic, /* 665 */
+ Parrot_sub_p_p_n, /* 666 */
+ Parrot_sub_p_p_nc, /* 667 */
+ Parrot_sqrt_n_n, /* 668 */
+ Parrot_acos_n_n, /* 669 */
+ Parrot_asec_n_n, /* 670 */
+ Parrot_asin_n_n, /* 671 */
+ Parrot_atan_n_n, /* 672 */
+ Parrot_atan_n_n_n, /* 673 */
+ Parrot_atan_n_nc_n, /* 674 */
+ Parrot_atan_n_n_nc, /* 675 */
+ Parrot_cos_n_n, /* 676 */
+ Parrot_cosh_n_n, /* 677 */
+ Parrot_exp_n_n, /* 678 */
+ Parrot_ln_n_n, /* 679 */
+ Parrot_log10_n_n, /* 680 */
+ Parrot_log2_n_n, /* 681 */
+ Parrot_sec_n_n, /* 682 */
+ Parrot_sech_n_n, /* 683 */
+ Parrot_sin_n_n, /* 684 */
+ Parrot_sinh_n_n, /* 685 */
+ Parrot_tan_n_n, /* 686 */
+ Parrot_tanh_n_n, /* 687 */
+ Parrot_callmethodcc_p_s, /* 688 */
+ Parrot_callmethodcc_p_sc, /* 689 */
+ Parrot_callmethodcc_p_p, /* 690 */
+ Parrot_callmethod_p_s_p, /* 691 */
+ Parrot_callmethod_p_sc_p, /* 692 */
+ Parrot_callmethod_p_p_p, /* 693 */
+ Parrot_tailcallmethod_p_s, /* 694 */
+ Parrot_tailcallmethod_p_sc, /* 695 */
+ Parrot_tailcallmethod_p_p, /* 696 */
+ Parrot_addmethod_p_s_p, /* 697 */
+ Parrot_addmethod_p_sc_p, /* 698 */
+ Parrot_can_i_p_s, /* 699 */
+ Parrot_can_i_p_sc, /* 700 */
+ Parrot_does_i_p_s, /* 701 */
+ Parrot_does_i_p_sc, /* 702 */
+ Parrot_does_i_p_p, /* 703 */
+ Parrot_does_i_p_pc, /* 704 */
+ Parrot_isa_i_p_s, /* 705 */
+ Parrot_isa_i_p_sc, /* 706 */
+ Parrot_isa_i_p_p, /* 707 */
+ Parrot_isa_i_p_pc, /* 708 */
+ Parrot_newclass_p_s, /* 709 */
+ Parrot_newclass_p_sc, /* 710 */
+ Parrot_newclass_p_p, /* 711 */
+ Parrot_newclass_p_pc, /* 712 */
+ Parrot_subclass_p_p, /* 713 */
+ Parrot_subclass_p_pc, /* 714 */
+ Parrot_subclass_p_p_s, /* 715 */
+ Parrot_subclass_p_pc_s, /* 716 */
+ Parrot_subclass_p_p_sc, /* 717 */
+ Parrot_subclass_p_pc_sc, /* 718 */
+ Parrot_subclass_p_p_p, /* 719 */
+ Parrot_subclass_p_pc_p, /* 720 */
+ Parrot_subclass_p_p_pc, /* 721 */
+ Parrot_subclass_p_pc_pc, /* 722 */
+ Parrot_subclass_p_s, /* 723 */
+ Parrot_subclass_p_sc, /* 724 */
+ Parrot_subclass_p_s_s, /* 725 */
+ Parrot_subclass_p_sc_s, /* 726 */
+ Parrot_subclass_p_s_sc, /* 727 */
+ Parrot_subclass_p_sc_sc, /* 728 */
+ Parrot_subclass_p_s_p, /* 729 */
+ Parrot_subclass_p_sc_p, /* 730 */
+ Parrot_subclass_p_s_pc, /* 731 */
+ Parrot_subclass_p_sc_pc, /* 732 */
+ Parrot_get_class_p_s, /* 733 */
+ Parrot_get_class_p_sc, /* 734 */
+ Parrot_get_class_p_p, /* 735 */
+ Parrot_get_class_p_pc, /* 736 */
+ Parrot_class_p_p, /* 737 */
+ Parrot_addparent_p_p, /* 738 */
+ Parrot_removeparent_p_p, /* 739 */
+ Parrot_addrole_p_p, /* 740 */
+ Parrot_addattribute_p_s, /* 741 */
+ Parrot_addattribute_p_sc, /* 742 */
+ Parrot_removeattribute_p_s, /* 743 */
+ Parrot_removeattribute_p_sc, /* 744 */
+ Parrot_getattribute_p_p_s, /* 745 */
+ Parrot_getattribute_p_p_sc, /* 746 */
+ Parrot_getattribute_p_p_p_s, /* 747 */
+ Parrot_getattribute_p_p_pc_s, /* 748 */
+ Parrot_getattribute_p_p_p_sc, /* 749 */
+ Parrot_getattribute_p_p_pc_sc, /* 750 */
+ Parrot_setattribute_p_s_p, /* 751 */
+ Parrot_setattribute_p_sc_p, /* 752 */
+ Parrot_setattribute_p_p_s_p, /* 753 */
+ Parrot_setattribute_p_pc_s_p, /* 754 */
+ Parrot_setattribute_p_p_sc_p, /* 755 */
+ Parrot_setattribute_p_pc_sc_p, /* 756 */
+ Parrot_inspect_p_p, /* 757 */
+ Parrot_inspect_p_pc, /* 758 */
+ Parrot_inspect_p_p_s, /* 759 */
+ Parrot_inspect_p_pc_s, /* 760 */
+ Parrot_inspect_p_p_sc, /* 761 */
+ Parrot_inspect_p_pc_sc, /* 762 */
+ Parrot_new_p_s, /* 763 */
+ Parrot_new_p_sc, /* 764 */
+ Parrot_new_p_s_p, /* 765 */
+ Parrot_new_p_sc_p, /* 766 */
+ Parrot_new_p_s_pc, /* 767 */
+ Parrot_new_p_sc_pc, /* 768 */
+ Parrot_new_p_p, /* 769 */
+ Parrot_new_p_pc, /* 770 */
+ Parrot_new_p_p_p, /* 771 */
+ Parrot_new_p_pc_p, /* 772 */
+ Parrot_new_p_p_pc, /* 773 */
+ Parrot_new_p_pc_pc, /* 774 */
+ Parrot_root_new_p_p, /* 775 */
+ Parrot_root_new_p_pc, /* 776 */
+ Parrot_root_new_p_p_p, /* 777 */
+ Parrot_root_new_p_pc_p, /* 778 */
+ Parrot_root_new_p_p_pc, /* 779 */
+ Parrot_root_new_p_pc_pc, /* 780 */
+ Parrot_typeof_s_p, /* 781 */
+ Parrot_typeof_p_p, /* 782 */
+ Parrot_get_repr_s_p, /* 783 */
+ Parrot_find_method_p_p_s, /* 784 */
+ Parrot_find_method_p_p_sc, /* 785 */
+ Parrot_defined_i_p, /* 786 */
+ Parrot_defined_i_p_ki, /* 787 */
+ Parrot_defined_i_p_kic, /* 788 */
+ Parrot_defined_i_p_k, /* 789 */
+ Parrot_defined_i_p_kc, /* 790 */
+ Parrot_exists_i_p_ki, /* 791 */
+ Parrot_exists_i_p_kic, /* 792 */
+ Parrot_exists_i_p_k, /* 793 */
+ Parrot_exists_i_p_kc, /* 794 */
+ Parrot_delete_p_k, /* 795 */
+ Parrot_delete_p_kc, /* 796 */
+ Parrot_delete_p_ki, /* 797 */
+ Parrot_delete_p_kic, /* 798 */
+ Parrot_elements_i_p, /* 799 */
+ Parrot_push_p_i, /* 800 */
+ Parrot_push_p_ic, /* 801 */
+ Parrot_push_p_n, /* 802 */
+ Parrot_push_p_nc, /* 803 */
+ Parrot_push_p_s, /* 804 */
+ Parrot_push_p_sc, /* 805 */
+ Parrot_push_p_p, /* 806 */
+ Parrot_pop_i_p, /* 807 */
+ Parrot_pop_n_p, /* 808 */
+ Parrot_pop_s_p, /* 809 */
+ Parrot_pop_p_p, /* 810 */
+ Parrot_unshift_p_i, /* 811 */
+ Parrot_unshift_p_ic, /* 812 */
+ Parrot_unshift_p_n, /* 813 */
+ Parrot_unshift_p_nc, /* 814 */
+ Parrot_unshift_p_s, /* 815 */
+ Parrot_unshift_p_sc, /* 816 */
+ Parrot_unshift_p_p, /* 817 */
+ Parrot_shift_i_p, /* 818 */
+ Parrot_shift_n_p, /* 819 */
+ Parrot_shift_s_p, /* 820 */
+ Parrot_shift_p_p, /* 821 */
+ Parrot_splice_p_p_i_i, /* 822 */
+ Parrot_splice_p_p_ic_i, /* 823 */
+ Parrot_splice_p_p_i_ic, /* 824 */
+ Parrot_splice_p_p_ic_ic, /* 825 */
+ Parrot_setprop_p_s_p, /* 826 */
+ Parrot_setprop_p_sc_p, /* 827 */
+ Parrot_getprop_p_s_p, /* 828 */
+ Parrot_getprop_p_sc_p, /* 829 */
+ Parrot_delprop_p_s, /* 830 */
+ Parrot_delprop_p_sc, /* 831 */
+ Parrot_prophash_p_p, /* 832 */
+ Parrot_freeze_s_p, /* 833 */
+ Parrot_thaw_p_s, /* 834 */
+ Parrot_thaw_p_sc, /* 835 */
+ Parrot_add_multi_s_s_p, /* 836 */
+ Parrot_add_multi_sc_s_p, /* 837 */
+ Parrot_add_multi_s_sc_p, /* 838 */
+ Parrot_add_multi_sc_sc_p, /* 839 */
+ Parrot_find_multi_p_s_s, /* 840 */
+ Parrot_find_multi_p_sc_s, /* 841 */
+ Parrot_find_multi_p_s_sc, /* 842 */
+ Parrot_find_multi_p_sc_sc, /* 843 */
+ Parrot_register_p, /* 844 */
+ Parrot_unregister_p, /* 845 */
+ Parrot_box_p_i, /* 846 */
+ Parrot_box_p_ic, /* 847 */
+ Parrot_box_p_n, /* 848 */
+ Parrot_box_p_nc, /* 849 */
+ Parrot_box_p_s, /* 850 */
+ Parrot_box_p_sc, /* 851 */
+ Parrot_iter_p_p, /* 852 */
+ Parrot_morph_p_p, /* 853 */
+ Parrot_morph_p_pc, /* 854 */
+ Parrot_clone_s_s, /* 855 */
+ Parrot_clone_s_sc, /* 856 */
+ Parrot_set_i_i, /* 857 */
+ Parrot_set_i_ic, /* 858 */
+ Parrot_set_i_n, /* 859 */
+ Parrot_set_i_nc, /* 860 */
+ Parrot_set_i_s, /* 861 */
+ Parrot_set_i_sc, /* 862 */
+ Parrot_set_n_n, /* 863 */
+ Parrot_set_n_nc, /* 864 */
+ Parrot_set_n_i, /* 865 */
+ Parrot_set_n_ic, /* 866 */
+ Parrot_set_n_s, /* 867 */
+ Parrot_set_n_sc, /* 868 */
+ Parrot_set_n_p, /* 869 */
+ Parrot_set_s_p, /* 870 */
+ Parrot_set_s_s, /* 871 */
+ Parrot_set_s_sc, /* 872 */
+ Parrot_set_s_i, /* 873 */
+ Parrot_set_s_ic, /* 874 */
+ Parrot_set_s_n, /* 875 */
+ Parrot_set_s_nc, /* 876 */
+ Parrot_set_p_pc, /* 877 */
+ Parrot_set_p_p, /* 878 */
+ Parrot_set_p_i, /* 879 */
+ Parrot_set_p_ic, /* 880 */
+ Parrot_set_p_n, /* 881 */
+ Parrot_set_p_nc, /* 882 */
+ Parrot_set_p_s, /* 883 */
+ Parrot_set_p_sc, /* 884 */
+ Parrot_set_i_p, /* 885 */
+ Parrot_assign_p_p, /* 886 */
+ Parrot_assign_p_i, /* 887 */
+ Parrot_assign_p_ic, /* 888 */
+ Parrot_assign_p_n, /* 889 */
+ Parrot_assign_p_nc, /* 890 */
+ Parrot_assign_p_s, /* 891 */
+ Parrot_assign_p_sc, /* 892 */
+ Parrot_assign_s_s, /* 893 */
+ Parrot_assign_s_sc, /* 894 */
+ Parrot_setref_p_p, /* 895 */
+ Parrot_deref_p_p, /* 896 */
+ Parrot_set_p_ki_i, /* 897 */
+ Parrot_set_p_kic_i, /* 898 */
+ Parrot_set_p_ki_ic, /* 899 */
+ Parrot_set_p_kic_ic, /* 900 */
+ Parrot_set_p_ki_n, /* 901 */
+ Parrot_set_p_kic_n, /* 902 */
+ Parrot_set_p_ki_nc, /* 903 */
+ Parrot_set_p_kic_nc, /* 904 */
+ Parrot_set_p_ki_s, /* 905 */
+ Parrot_set_p_kic_s, /* 906 */
+ Parrot_set_p_ki_sc, /* 907 */
+ Parrot_set_p_kic_sc, /* 908 */
+ Parrot_set_p_ki_p, /* 909 */
+ Parrot_set_p_kic_p, /* 910 */
+ Parrot_set_i_p_ki, /* 911 */
+ Parrot_set_i_p_kic, /* 912 */
+ Parrot_set_n_p_ki, /* 913 */
+ Parrot_set_n_p_kic, /* 914 */
+ Parrot_set_s_p_ki, /* 915 */
+ Parrot_set_s_p_kic, /* 916 */
+ Parrot_set_p_p_ki, /* 917 */
+ Parrot_set_p_p_kic, /* 918 */
+ Parrot_set_p_k_i, /* 919 */
+ Parrot_set_p_kc_i, /* 920 */
+ Parrot_set_p_k_ic, /* 921 */
+ Parrot_set_p_kc_ic, /* 922 */
+ Parrot_set_p_k_n, /* 923 */
+ Parrot_set_p_kc_n, /* 924 */
+ Parrot_set_p_k_nc, /* 925 */
+ Parrot_set_p_kc_nc, /* 926 */
+ Parrot_set_p_k_s, /* 927 */
+ Parrot_set_p_kc_s, /* 928 */
+ Parrot_set_p_k_sc, /* 929 */
+ Parrot_set_p_kc_sc, /* 930 */
+ Parrot_set_p_k_p, /* 931 */
+ Parrot_set_p_kc_p, /* 932 */
+ Parrot_set_i_p_k, /* 933 */
+ Parrot_set_i_p_kc, /* 934 */
+ Parrot_set_n_p_k, /* 935 */
+ Parrot_set_n_p_kc, /* 936 */
+ Parrot_set_s_p_k, /* 937 */
+ Parrot_set_s_p_kc, /* 938 */
+ Parrot_set_p_p_k, /* 939 */
+ Parrot_set_p_p_kc, /* 940 */
+ Parrot_clone_p_p, /* 941 */
+ Parrot_clone_p_p_p, /* 942 */
+ Parrot_clone_p_p_pc, /* 943 */
+ Parrot_copy_p_p, /* 944 */
+ Parrot_null_s, /* 945 */
+ Parrot_null_i, /* 946 */
+ Parrot_null_p, /* 947 */
+ Parrot_null_n, /* 948 */
+ Parrot_ord_i_s, /* 949 */
+ Parrot_ord_i_sc, /* 950 */
+ Parrot_ord_i_s_i, /* 951 */
+ Parrot_ord_i_sc_i, /* 952 */
+ Parrot_ord_i_s_ic, /* 953 */
+ Parrot_ord_i_sc_ic, /* 954 */
+ Parrot_chr_s_i, /* 955 */
+ Parrot_chr_s_ic, /* 956 */
+ Parrot_chopn_s_s_i, /* 957 */
+ Parrot_chopn_s_sc_i, /* 958 */
+ Parrot_chopn_s_s_ic, /* 959 */
+ Parrot_chopn_s_sc_ic, /* 960 */
+ Parrot_concat_s_s, /* 961 */
+ Parrot_concat_s_sc, /* 962 */
+ Parrot_concat_p_p, /* 963 */
+ Parrot_concat_p_s, /* 964 */
+ Parrot_concat_p_sc, /* 965 */
+ Parrot_concat_s_s_s, /* 966 */
+ Parrot_concat_s_sc_s, /* 967 */
+ Parrot_concat_s_s_sc, /* 968 */
+ Parrot_concat_p_p_s, /* 969 */
+ Parrot_concat_p_p_sc, /* 970 */
+ Parrot_concat_p_p_p, /* 971 */
+ Parrot_repeat_s_s_i, /* 972 */
+ Parrot_repeat_s_sc_i, /* 973 */
+ Parrot_repeat_s_s_ic, /* 974 */
+ Parrot_repeat_s_sc_ic, /* 975 */
+ Parrot_repeat_p_p_i, /* 976 */
+ Parrot_repeat_p_p_ic, /* 977 */
+ Parrot_repeat_p_p_p, /* 978 */
+ Parrot_repeat_p_i, /* 979 */
+ Parrot_repeat_p_ic, /* 980 */
+ Parrot_repeat_p_p, /* 981 */
+ Parrot_length_i_s, /* 982 */
+ Parrot_length_i_sc, /* 983 */
+ Parrot_bytelength_i_s, /* 984 */
+ Parrot_bytelength_i_sc, /* 985 */
+ Parrot_pin_s, /* 986 */
+ Parrot_unpin_s, /* 987 */
+ Parrot_substr_s_s_i, /* 988 */
+ Parrot_substr_s_sc_i, /* 989 */
+ Parrot_substr_s_s_ic, /* 990 */
+ Parrot_substr_s_sc_ic, /* 991 */
+ Parrot_substr_s_s_i_i, /* 992 */
+ Parrot_substr_s_sc_i_i, /* 993 */
+ Parrot_substr_s_s_ic_i, /* 994 */
+ Parrot_substr_s_sc_ic_i, /* 995 */
+ Parrot_substr_s_s_i_ic, /* 996 */
+ Parrot_substr_s_sc_i_ic, /* 997 */
+ Parrot_substr_s_s_ic_ic, /* 998 */
+ Parrot_substr_s_sc_ic_ic, /* 999 */
+ Parrot_substr_s_p_i_i, /* 1000 */
+ Parrot_substr_s_p_ic_i, /* 1001 */
+ Parrot_substr_s_p_i_ic, /* 1002 */
+ Parrot_substr_s_p_ic_ic, /* 1003 */
+ Parrot_replace_s_s_i_i_s, /* 1004 */
+ Parrot_replace_s_sc_i_i_s, /* 1005 */
+ Parrot_replace_s_s_ic_i_s, /* 1006 */
+ Parrot_replace_s_sc_ic_i_s, /* 1007 */
+ Parrot_replace_s_s_i_ic_s, /* 1008 */
+ Parrot_replace_s_sc_i_ic_s, /* 1009 */
+ Parrot_replace_s_s_ic_ic_s, /* 1010 */
+ Parrot_replace_s_sc_ic_ic_s, /* 1011 */
+ Parrot_replace_s_s_i_i_sc, /* 1012 */
+ Parrot_replace_s_sc_i_i_sc, /* 1013 */
+ Parrot_replace_s_s_ic_i_sc, /* 1014 */
+ Parrot_replace_s_sc_ic_i_sc, /* 1015 */
+ Parrot_replace_s_s_i_ic_sc, /* 1016 */
+ Parrot_replace_s_sc_i_ic_sc, /* 1017 */
+ Parrot_replace_s_s_ic_ic_sc, /* 1018 */
+ Parrot_replace_s_sc_ic_ic_sc, /* 1019 */
+ Parrot_index_i_s_s, /* 1020 */
+ Parrot_index_i_sc_s, /* 1021 */
+ Parrot_index_i_s_sc, /* 1022 */
+ Parrot_index_i_sc_sc, /* 1023 */
+ Parrot_index_i_s_s_i, /* 1024 */
+ Parrot_index_i_sc_s_i, /* 1025 */
+ Parrot_index_i_s_sc_i, /* 1026 */
+ Parrot_index_i_sc_sc_i, /* 1027 */
+ Parrot_index_i_s_s_ic, /* 1028 */
+ Parrot_index_i_sc_s_ic, /* 1029 */
+ Parrot_index_i_s_sc_ic, /* 1030 */
+ Parrot_index_i_sc_sc_ic, /* 1031 */
+ Parrot_sprintf_s_s_p, /* 1032 */
+ Parrot_sprintf_s_sc_p, /* 1033 */
+ Parrot_sprintf_p_p_p, /* 1034 */
+ Parrot_new_s, /* 1035 */
+ Parrot_new_s_i, /* 1036 */
+ Parrot_new_s_ic, /* 1037 */
+ Parrot_stringinfo_i_s_i, /* 1038 */
+ Parrot_stringinfo_i_sc_i, /* 1039 */
+ Parrot_stringinfo_i_s_ic, /* 1040 */
+ Parrot_stringinfo_i_sc_ic, /* 1041 */
+ Parrot_upcase_s_s, /* 1042 */
+ Parrot_upcase_s_sc, /* 1043 */
+ Parrot_downcase_s_s, /* 1044 */
+ Parrot_downcase_s_sc, /* 1045 */
+ Parrot_titlecase_s_s, /* 1046 */
+ Parrot_titlecase_s_sc, /* 1047 */
+ Parrot_join_s_s_p, /* 1048 */
+ Parrot_join_s_sc_p, /* 1049 */
+ Parrot_split_p_s_s, /* 1050 */
+ Parrot_split_p_sc_s, /* 1051 */
+ Parrot_split_p_s_sc, /* 1052 */
+ Parrot_split_p_sc_sc, /* 1053 */
+ Parrot_charset_i_s, /* 1054 */
+ Parrot_charset_i_sc, /* 1055 */
+ Parrot_charsetname_s_i, /* 1056 */
+ Parrot_charsetname_s_ic, /* 1057 */
+ Parrot_find_charset_i_s, /* 1058 */
+ Parrot_find_charset_i_sc, /* 1059 */
+ Parrot_trans_charset_s_s_i, /* 1060 */
+ Parrot_trans_charset_s_sc_i, /* 1061 */
+ Parrot_trans_charset_s_s_ic, /* 1062 */
+ Parrot_trans_charset_s_sc_ic, /* 1063 */
+ Parrot_encoding_i_s, /* 1064 */
+ Parrot_encoding_i_sc, /* 1065 */
+ Parrot_encodingname_s_i, /* 1066 */
+ Parrot_encodingname_s_ic, /* 1067 */
+ Parrot_find_encoding_i_s, /* 1068 */
+ Parrot_find_encoding_i_sc, /* 1069 */
+ Parrot_trans_encoding_s_s_i, /* 1070 */
+ Parrot_trans_encoding_s_sc_i, /* 1071 */
+ Parrot_trans_encoding_s_s_ic, /* 1072 */
+ Parrot_trans_encoding_s_sc_ic, /* 1073 */
+ Parrot_is_cclass_i_i_s_i, /* 1074 */
+ Parrot_is_cclass_i_ic_s_i, /* 1075 */
+ Parrot_is_cclass_i_i_sc_i, /* 1076 */
+ Parrot_is_cclass_i_ic_sc_i, /* 1077 */
+ Parrot_is_cclass_i_i_s_ic, /* 1078 */
+ Parrot_is_cclass_i_ic_s_ic, /* 1079 */
+ Parrot_is_cclass_i_i_sc_ic, /* 1080 */
+ Parrot_is_cclass_i_ic_sc_ic, /* 1081 */
+ Parrot_find_cclass_i_i_s_i_i, /* 1082 */
+ Parrot_find_cclass_i_ic_s_i_i, /* 1083 */
+ Parrot_find_cclass_i_i_sc_i_i, /* 1084 */
+ Parrot_find_cclass_i_ic_sc_i_i, /* 1085 */
+ Parrot_find_cclass_i_i_s_ic_i, /* 1086 */
+ Parrot_find_cclass_i_ic_s_ic_i, /* 1087 */
+ Parrot_find_cclass_i_i_sc_ic_i, /* 1088 */
+ Parrot_find_cclass_i_ic_sc_ic_i, /* 1089 */
+ Parrot_find_cclass_i_i_s_i_ic, /* 1090 */
+ Parrot_find_cclass_i_ic_s_i_ic, /* 1091 */
+ Parrot_find_cclass_i_i_sc_i_ic, /* 1092 */
+ Parrot_find_cclass_i_ic_sc_i_ic, /* 1093 */
+ Parrot_find_cclass_i_i_s_ic_ic, /* 1094 */
+ Parrot_find_cclass_i_ic_s_ic_ic, /* 1095 */
+ Parrot_find_cclass_i_i_sc_ic_ic, /* 1096 */
+ Parrot_find_cclass_i_ic_sc_ic_ic, /* 1097 */
+ Parrot_find_not_cclass_i_i_s_i_i, /* 1098 */
+ Parrot_find_not_cclass_i_ic_s_i_i, /* 1099 */
+ Parrot_find_not_cclass_i_i_sc_i_i, /* 1100 */
+ Parrot_find_not_cclass_i_ic_sc_i_i, /* 1101 */
+ Parrot_find_not_cclass_i_i_s_ic_i, /* 1102 */
+ Parrot_find_not_cclass_i_ic_s_ic_i, /* 1103 */
+ Parrot_find_not_cclass_i_i_sc_ic_i, /* 1104 */
+ Parrot_find_not_cclass_i_ic_sc_ic_i, /* 1105 */
+ Parrot_find_not_cclass_i_i_s_i_ic, /* 1106 */
+ Parrot_find_not_cclass_i_ic_s_i_ic, /* 1107 */
+ Parrot_find_not_cclass_i_i_sc_i_ic, /* 1108 */
+ Parrot_find_not_cclass_i_ic_sc_i_ic, /* 1109 */
+ Parrot_find_not_cclass_i_i_s_ic_ic, /* 1110 */
+ Parrot_find_not_cclass_i_ic_s_ic_ic, /* 1111 */
+ Parrot_find_not_cclass_i_i_sc_ic_ic, /* 1112 */
+ Parrot_find_not_cclass_i_ic_sc_ic_ic, /* 1113 */
+ Parrot_escape_s_s, /* 1114 */
+ Parrot_compose_s_s, /* 1115 */
+ Parrot_compose_s_sc, /* 1116 */
+ Parrot_spawnw_i_s, /* 1117 */
+ Parrot_spawnw_i_sc, /* 1118 */
+ Parrot_spawnw_i_p, /* 1119 */
+ Parrot_err_i, /* 1120 */
+ Parrot_err_s, /* 1121 */
+ Parrot_err_s_i, /* 1122 */
+ Parrot_err_s_ic, /* 1123 */
+ Parrot_time_i, /* 1124 */
+ Parrot_time_n, /* 1125 */
+ Parrot_gmtime_s_i, /* 1126 */
+ Parrot_gmtime_s_ic, /* 1127 */
+ Parrot_localtime_s_i, /* 1128 */
+ Parrot_localtime_s_ic, /* 1129 */
+ Parrot_decodetime_p_i, /* 1130 */
+ Parrot_decodetime_p_ic, /* 1131 */
+ Parrot_decodelocaltime_p_i, /* 1132 */
+ Parrot_decodelocaltime_p_ic, /* 1133 */
+ Parrot_sysinfo_s_i, /* 1134 */
+ Parrot_sysinfo_s_ic, /* 1135 */
+ Parrot_sysinfo_i_i, /* 1136 */
+ Parrot_sysinfo_i_ic, /* 1137 */
+ Parrot_sleep_i, /* 1138 */
+ Parrot_sleep_ic, /* 1139 */
+ Parrot_sleep_n, /* 1140 */
+ Parrot_sleep_nc, /* 1141 */
+ Parrot_store_lex_s_p, /* 1142 */
+ Parrot_store_lex_sc_p, /* 1143 */
+ Parrot_store_dynamic_lex_s_p, /* 1144 */
+ Parrot_store_dynamic_lex_sc_p, /* 1145 */
+ Parrot_find_lex_p_s, /* 1146 */
+ Parrot_find_lex_p_sc, /* 1147 */
+ Parrot_find_dynamic_lex_p_s, /* 1148 */
+ Parrot_find_dynamic_lex_p_sc, /* 1149 */
+ Parrot_find_caller_lex_p_s, /* 1150 */
+ Parrot_find_caller_lex_p_sc, /* 1151 */
+ Parrot_get_namespace_p, /* 1152 */
+ Parrot_get_namespace_p_p, /* 1153 */
+ Parrot_get_namespace_p_pc, /* 1154 */
+ Parrot_get_hll_namespace_p, /* 1155 */
+ Parrot_get_hll_namespace_p_p, /* 1156 */
+ Parrot_get_hll_namespace_p_pc, /* 1157 */
+ Parrot_get_root_namespace_p, /* 1158 */
+ Parrot_get_root_namespace_p_p, /* 1159 */
+ Parrot_get_root_namespace_p_pc, /* 1160 */
+ Parrot_get_global_p_s, /* 1161 */
+ Parrot_get_global_p_sc, /* 1162 */
+ Parrot_get_global_p_p_s, /* 1163 */
+ Parrot_get_global_p_pc_s, /* 1164 */
+ Parrot_get_global_p_p_sc, /* 1165 */
+ Parrot_get_global_p_pc_sc, /* 1166 */
+ Parrot_get_hll_global_p_s, /* 1167 */
+ Parrot_get_hll_global_p_sc, /* 1168 */
+ Parrot_get_hll_global_p_p_s, /* 1169 */
+ Parrot_get_hll_global_p_pc_s, /* 1170 */
+ Parrot_get_hll_global_p_p_sc, /* 1171 */
+ Parrot_get_hll_global_p_pc_sc, /* 1172 */
+ Parrot_get_root_global_p_s, /* 1173 */
+ Parrot_get_root_global_p_sc, /* 1174 */
+ Parrot_get_root_global_p_p_s, /* 1175 */
+ Parrot_get_root_global_p_pc_s, /* 1176 */
+ Parrot_get_root_global_p_p_sc, /* 1177 */
+ Parrot_get_root_global_p_pc_sc, /* 1178 */
+ Parrot_set_global_s_p, /* 1179 */
+ Parrot_set_global_sc_p, /* 1180 */
+ Parrot_set_global_p_s_p, /* 1181 */
+ Parrot_set_global_pc_s_p, /* 1182 */
+ Parrot_set_global_p_sc_p, /* 1183 */
+ Parrot_set_global_pc_sc_p, /* 1184 */
+ Parrot_set_hll_global_s_p, /* 1185 */
+ Parrot_set_hll_global_sc_p, /* 1186 */
+ Parrot_set_hll_global_p_s_p, /* 1187 */
+ Parrot_set_hll_global_pc_s_p, /* 1188 */
+ Parrot_set_hll_global_p_sc_p, /* 1189 */
+ Parrot_set_hll_global_pc_sc_p, /* 1190 */
+ Parrot_set_root_global_s_p, /* 1191 */
+ Parrot_set_root_global_sc_p, /* 1192 */
+ Parrot_set_root_global_p_s_p, /* 1193 */
+ Parrot_set_root_global_pc_s_p, /* 1194 */
+ Parrot_set_root_global_p_sc_p, /* 1195 */
+ Parrot_set_root_global_pc_sc_p, /* 1196 */
+ Parrot_find_name_p_s, /* 1197 */
+ Parrot_find_name_p_sc, /* 1198 */
+ Parrot_find_sub_not_null_p_s, /* 1199 */
+ Parrot_find_sub_not_null_p_sc, /* 1200 */
+ Parrot_trap, /* 1201 */
+ Parrot_set_label_p_ic, /* 1202 */
+ Parrot_get_label_i_p, /* 1203 */
+ Parrot_fetch_p_p_p_p, /* 1204 */
+ Parrot_fetch_p_pc_p_p, /* 1205 */
+ Parrot_fetch_p_p_pc_p, /* 1206 */
+ Parrot_fetch_p_pc_pc_p, /* 1207 */
+ Parrot_fetch_p_p_p_pc, /* 1208 */
+ Parrot_fetch_p_pc_p_pc, /* 1209 */
+ Parrot_fetch_p_p_pc_pc, /* 1210 */
+ Parrot_fetch_p_pc_pc_pc, /* 1211 */
+ Parrot_fetch_p_p_i_p, /* 1212 */
+ Parrot_fetch_p_pc_i_p, /* 1213 */
+ Parrot_fetch_p_p_ic_p, /* 1214 */
+ Parrot_fetch_p_pc_ic_p, /* 1215 */
+ Parrot_fetch_p_p_i_pc, /* 1216 */
+ Parrot_fetch_p_pc_i_pc, /* 1217 */
+ Parrot_fetch_p_p_ic_pc, /* 1218 */
+ Parrot_fetch_p_pc_ic_pc, /* 1219 */
+ Parrot_fetch_p_p_s_p, /* 1220 */
+ Parrot_fetch_p_pc_s_p, /* 1221 */
+ Parrot_fetch_p_p_sc_p, /* 1222 */
+ Parrot_fetch_p_pc_sc_p, /* 1223 */
+ Parrot_fetch_p_p_s_pc, /* 1224 */
+ Parrot_fetch_p_pc_s_pc, /* 1225 */
+ Parrot_fetch_p_p_sc_pc, /* 1226 */
+ Parrot_fetch_p_pc_sc_pc, /* 1227 */
+ Parrot_vivify_p_p_p_p, /* 1228 */
+ Parrot_vivify_p_pc_p_p, /* 1229 */
+ Parrot_vivify_p_p_pc_p, /* 1230 */
+ Parrot_vivify_p_pc_pc_p, /* 1231 */
+ Parrot_vivify_p_p_p_pc, /* 1232 */
+ Parrot_vivify_p_pc_p_pc, /* 1233 */
+ Parrot_vivify_p_p_pc_pc, /* 1234 */
+ Parrot_vivify_p_pc_pc_pc, /* 1235 */
+ Parrot_vivify_p_p_i_p, /* 1236 */
+ Parrot_vivify_p_pc_i_p, /* 1237 */
+ Parrot_vivify_p_p_ic_p, /* 1238 */
+ Parrot_vivify_p_pc_ic_p, /* 1239 */
+ Parrot_vivify_p_p_i_pc, /* 1240 */
+ Parrot_vivify_p_pc_i_pc, /* 1241 */
+ Parrot_vivify_p_p_ic_pc, /* 1242 */
+ Parrot_vivify_p_pc_ic_pc, /* 1243 */
+ Parrot_vivify_p_p_s_p, /* 1244 */
+ Parrot_vivify_p_pc_s_p, /* 1245 */
+ Parrot_vivify_p_p_sc_p, /* 1246 */
+ Parrot_vivify_p_pc_sc_p, /* 1247 */
+ Parrot_vivify_p_p_s_pc, /* 1248 */
+ Parrot_vivify_p_pc_s_pc, /* 1249 */
+ Parrot_vivify_p_p_sc_pc, /* 1250 */
+ Parrot_vivify_p_pc_sc_pc, /* 1251 */
+ Parrot_new_p_s_i, /* 1252 */
+ Parrot_new_p_sc_i, /* 1253 */
+ Parrot_new_p_s_ic, /* 1254 */
+ Parrot_new_p_sc_ic, /* 1255 */
+ Parrot_new_p_p_i, /* 1256 */
+ Parrot_new_p_pc_i, /* 1257 */
+ Parrot_new_p_p_ic, /* 1258 */
+ Parrot_new_p_pc_ic, /* 1259 */
+ Parrot_root_new_p_p_i, /* 1260 */
+ Parrot_root_new_p_pc_i, /* 1261 */
+ Parrot_root_new_p_p_ic, /* 1262 */
+ Parrot_root_new_p_pc_ic, /* 1263 */
+ Parrot_find_codepoint_i_s, /* 1264 */
+ Parrot_find_codepoint_i_sc, /* 1265 */
+ Parrot_unroll_p, /* 1266 */
+ Parrot_unroll_pc, /* 1267 */
+
+ NULL /* NULL function pointer */
+};
+
+
+
+/*
+** Op Info Table:
+*/
+
+static op_info_t core_op_info_table[1269] = {
+ { /* 0 */
+ /* type PARROT_INLINE_OP, */
+ "end",
+ "end",
+ "Parrot_end",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 1 */
+ /* type PARROT_INLINE_OP, */
+ "noop",
+ "noop",
+ "Parrot_noop",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 2 */
+ /* type PARROT_INLINE_OP, */
+ "check_events",
+ "check_events",
+ "Parrot_check_events",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 3 */
+ /* type PARROT_INLINE_OP, */
+ "check_events__",
+ "check_events__",
+ "Parrot_check_events__",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 4 */
+ /* type PARROT_INLINE_OP, */
+ "wrapper__",
+ "wrapper__",
+ "Parrot_wrapper__",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 5 */
+ /* type PARROT_INLINE_OP, */
+ "load_bytecode",
+ "load_bytecode_s",
+ "Parrot_load_bytecode_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 6 */
+ /* type PARROT_INLINE_OP, */
+ "load_bytecode",
+ "load_bytecode_sc",
+ "Parrot_load_bytecode_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 7 */
+ /* type PARROT_INLINE_OP, */
+ "load_language",
+ "load_language_s",
+ "Parrot_load_language_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 8 */
+ /* type PARROT_INLINE_OP, */
+ "load_language",
+ "load_language_sc",
+ "Parrot_load_language_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 9 */
+ /* type PARROT_INLINE_OP, */
+ "branch",
+ "branch_i",
+ "Parrot_branch_i",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 1 }
+ },
+ { /* 10 */
+ /* type PARROT_INLINE_OP, */
+ "branch",
+ "branch_ic",
+ "Parrot_branch_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 1 }
+ },
+ { /* 11 */
+ /* type PARROT_INLINE_OP, */
+ "local_branch",
+ "local_branch_p_i",
+ "Parrot_local_branch_p_i",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 12 */
+ /* type PARROT_INLINE_OP, */
+ "local_branch",
+ "local_branch_p_ic",
+ "Parrot_local_branch_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 13 */
+ /* type PARROT_INLINE_OP, */
+ "local_return",
+ "local_return_p",
+ "Parrot_local_return_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 14 */
+ /* type PARROT_INLINE_OP, */
+ "jump",
+ "jump_i",
+ "Parrot_jump_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 1 }
+ },
+ { /* 15 */
+ /* type PARROT_INLINE_OP, */
+ "jump",
+ "jump_ic",
+ "Parrot_jump_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 1 }
+ },
+ { /* 16 */
+ /* type PARROT_FUNCTION_OP, */
+ "enternative",
+ "enternative",
+ "Parrot_enternative",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 17 */
+ /* type PARROT_INLINE_OP, */
+ "if",
+ "if_i_ic",
+ "Parrot_if_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 18 */
+ /* type PARROT_INLINE_OP, */
+ "if",
+ "if_n_ic",
+ "Parrot_if_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 19 */
+ /* type PARROT_FUNCTION_OP, */
+ "if",
+ "if_s_ic",
+ "Parrot_if_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 20 */
+ /* type PARROT_FUNCTION_OP, */
+ "if",
+ "if_p_ic",
+ "Parrot_if_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 21 */
+ /* type PARROT_INLINE_OP, */
+ "unless",
+ "unless_i_ic",
+ "Parrot_unless_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 22 */
+ /* type PARROT_INLINE_OP, */
+ "unless",
+ "unless_n_ic",
+ "Parrot_unless_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 23 */
+ /* type PARROT_FUNCTION_OP, */
+ "unless",
+ "unless_s_ic",
+ "Parrot_unless_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 24 */
+ /* type PARROT_FUNCTION_OP, */
+ "unless",
+ "unless_p_ic",
+ "Parrot_unless_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 25 */
+ /* type PARROT_INLINE_OP, */
+ "invokecc",
+ "invokecc_p",
+ "Parrot_invokecc_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 26 */
+ /* type PARROT_INLINE_OP, */
+ "invoke",
+ "invoke_p_p",
+ "Parrot_invoke_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 27 */
+ /* type PARROT_INLINE_OP, */
+ "yield",
+ "yield",
+ "Parrot_yield",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 28 */
+ /* type PARROT_INLINE_OP, */
+ "tailcall",
+ "tailcall_p",
+ "Parrot_tailcall_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 29 */
+ /* type PARROT_INLINE_OP, */
+ "returncc",
+ "returncc",
+ "Parrot_returncc",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 30 */
+ /* type PARROT_INLINE_OP, */
+ "capture_lex",
+ "capture_lex_p",
+ "Parrot_capture_lex_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 31 */
+ /* type PARROT_INLINE_OP, */
+ "newclosure",
+ "newclosure_p_p",
+ "Parrot_newclosure_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 32 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_args",
+ "set_args_pc",
+ "Parrot_set_args_pc",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 33 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_params",
+ "get_params_pc",
+ "Parrot_get_params_pc",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 34 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_returns",
+ "set_returns_pc",
+ "Parrot_set_returns_pc",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 35 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_results",
+ "get_results_pc",
+ "Parrot_get_results_pc",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 36 */
+ /* type PARROT_INLINE_OP, */
+ "set_result_info",
+ "set_result_info_p",
+ "Parrot_set_result_info_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 37 */
+ /* type PARROT_INLINE_OP, */
+ "set_result_info",
+ "set_result_info_pc",
+ "Parrot_set_result_info_pc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 38 */
+ /* type PARROT_INLINE_OP, */
+ "result_info",
+ "result_info_p",
+ "Parrot_result_info_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 39 */
+ /* type PARROT_INLINE_OP, */
+ "set_addr",
+ "set_addr_i_ic",
+ "Parrot_set_addr_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 40 */
+ /* type PARROT_INLINE_OP, */
+ "set_addr",
+ "set_addr_p_ic",
+ "Parrot_set_addr_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 41 */
+ /* type PARROT_INLINE_OP, */
+ "set_addr",
+ "set_addr_p_i",
+ "Parrot_set_addr_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 42 */
+ /* type PARROT_INLINE_OP, */
+ "get_addr",
+ "get_addr_i_p",
+ "Parrot_get_addr_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 43 */
+ /* type PARROT_INLINE_OP, */
+ "schedule",
+ "schedule_p",
+ "Parrot_schedule_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 44 */
+ /* type PARROT_INLINE_OP, */
+ "addhandler",
+ "addhandler_p",
+ "Parrot_addhandler_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 45 */
+ /* type PARROT_INLINE_OP, */
+ "push_eh",
+ "push_eh_ic",
+ "Parrot_push_eh_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 1 }
+ },
+ { /* 46 */
+ /* type PARROT_INLINE_OP, */
+ "push_eh",
+ "push_eh_p",
+ "Parrot_push_eh_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 47 */
+ /* type PARROT_INLINE_OP, */
+ "pop_eh",
+ "pop_eh",
+ "Parrot_pop_eh",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 48 */
+ /* type PARROT_INLINE_OP, */
+ "throw",
+ "throw_p",
+ "Parrot_throw_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 49 */
+ /* type PARROT_INLINE_OP, */
+ "throw",
+ "throw_p_p",
+ "Parrot_throw_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 50 */
+ /* type PARROT_INLINE_OP, */
+ "rethrow",
+ "rethrow_p",
+ "Parrot_rethrow_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 51 */
+ /* type PARROT_INLINE_OP, */
+ "count_eh",
+ "count_eh_i",
+ "Parrot_count_eh_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 52 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_s",
+ "Parrot_die_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 53 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_sc",
+ "Parrot_die_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 54 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_p",
+ "Parrot_die_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 55 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_pc",
+ "Parrot_die_pc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 56 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_i_i",
+ "Parrot_die_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 57 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_ic_i",
+ "Parrot_die_ic_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 58 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_i_ic",
+ "Parrot_die_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 59 */
+ /* type PARROT_INLINE_OP, */
+ "die",
+ "die_ic_ic",
+ "Parrot_die_ic_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 60 */
+ /* type PARROT_INLINE_OP, */
+ "exit",
+ "exit_i",
+ "Parrot_exit_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 61 */
+ /* type PARROT_INLINE_OP, */
+ "exit",
+ "exit_ic",
+ "Parrot_exit_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 62 */
+ /* type PARROT_INLINE_OP, */
+ "debug",
+ "debug_i",
+ "Parrot_debug_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 63 */
+ /* type PARROT_INLINE_OP, */
+ "debug",
+ "debug_ic",
+ "Parrot_debug_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 64 */
+ /* type PARROT_INLINE_OP, */
+ "bounds",
+ "bounds_i",
+ "Parrot_bounds_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 65 */
+ /* type PARROT_INLINE_OP, */
+ "bounds",
+ "bounds_ic",
+ "Parrot_bounds_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 66 */
+ /* type PARROT_INLINE_OP, */
+ "profile",
+ "profile_i",
+ "Parrot_profile_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 67 */
+ /* type PARROT_INLINE_OP, */
+ "profile",
+ "profile_ic",
+ "Parrot_profile_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 68 */
+ /* type PARROT_INLINE_OP, */
+ "trace",
+ "trace_i",
+ "Parrot_trace_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 69 */
+ /* type PARROT_INLINE_OP, */
+ "trace",
+ "trace_ic",
+ "Parrot_trace_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 70 */
+ /* type PARROT_INLINE_OP, */
+ "gc_debug",
+ "gc_debug_i",
+ "Parrot_gc_debug_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 71 */
+ /* type PARROT_INLINE_OP, */
+ "gc_debug",
+ "gc_debug_ic",
+ "Parrot_gc_debug_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 72 */
+ /* type PARROT_FUNCTION_OP, */
+ "interpinfo",
+ "interpinfo_i_i",
+ "Parrot_interpinfo_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 73 */
+ /* type PARROT_FUNCTION_OP, */
+ "interpinfo",
+ "interpinfo_i_ic",
+ "Parrot_interpinfo_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 74 */
+ /* type PARROT_FUNCTION_OP, */
+ "interpinfo",
+ "interpinfo_p_i",
+ "Parrot_interpinfo_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 75 */
+ /* type PARROT_FUNCTION_OP, */
+ "interpinfo",
+ "interpinfo_p_ic",
+ "Parrot_interpinfo_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 76 */
+ /* type PARROT_FUNCTION_OP, */
+ "interpinfo",
+ "interpinfo_s_i",
+ "Parrot_interpinfo_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 77 */
+ /* type PARROT_FUNCTION_OP, */
+ "interpinfo",
+ "interpinfo_s_ic",
+ "Parrot_interpinfo_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 78 */
+ /* type PARROT_INLINE_OP, */
+ "warningson",
+ "warningson_i",
+ "Parrot_warningson_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 79 */
+ /* type PARROT_INLINE_OP, */
+ "warningson",
+ "warningson_ic",
+ "Parrot_warningson_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 80 */
+ /* type PARROT_INLINE_OP, */
+ "warningsoff",
+ "warningsoff_i",
+ "Parrot_warningsoff_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 81 */
+ /* type PARROT_INLINE_OP, */
+ "warningsoff",
+ "warningsoff_ic",
+ "Parrot_warningsoff_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 82 */
+ /* type PARROT_INLINE_OP, */
+ "errorson",
+ "errorson_i",
+ "Parrot_errorson_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 83 */
+ /* type PARROT_INLINE_OP, */
+ "errorson",
+ "errorson_ic",
+ "Parrot_errorson_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 84 */
+ /* type PARROT_INLINE_OP, */
+ "errorsoff",
+ "errorsoff_i",
+ "Parrot_errorsoff_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 85 */
+ /* type PARROT_INLINE_OP, */
+ "errorsoff",
+ "errorsoff_ic",
+ "Parrot_errorsoff_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 86 */
+ /* type PARROT_FUNCTION_OP, */
+ "runinterp",
+ "runinterp_p_i",
+ "Parrot_runinterp_p_i",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 87 */
+ /* type PARROT_FUNCTION_OP, */
+ "runinterp",
+ "runinterp_p_ic",
+ "Parrot_runinterp_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 88 */
+ /* type PARROT_FUNCTION_OP, */
+ "getinterp",
+ "getinterp_p",
+ "Parrot_getinterp_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 89 */
+ /* type PARROT_FUNCTION_OP, */
+ "sweep",
+ "sweep_ic",
+ "Parrot_sweep_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 90 */
+ /* type PARROT_FUNCTION_OP, */
+ "collect",
+ "collect",
+ "Parrot_collect",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 91 */
+ /* type PARROT_FUNCTION_OP, */
+ "sweepoff",
+ "sweepoff",
+ "Parrot_sweepoff",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 92 */
+ /* type PARROT_FUNCTION_OP, */
+ "sweepon",
+ "sweepon",
+ "Parrot_sweepon",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 93 */
+ /* type PARROT_FUNCTION_OP, */
+ "collectoff",
+ "collectoff",
+ "Parrot_collectoff",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 94 */
+ /* type PARROT_FUNCTION_OP, */
+ "collecton",
+ "collecton",
+ "Parrot_collecton",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 95 */
+ /* type PARROT_FUNCTION_OP, */
+ "needs_destroy",
+ "needs_destroy_p",
+ "Parrot_needs_destroy_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 96 */
+ /* type PARROT_INLINE_OP, */
+ "loadlib",
+ "loadlib_p_s",
+ "Parrot_loadlib_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 97 */
+ /* type PARROT_INLINE_OP, */
+ "loadlib",
+ "loadlib_p_sc",
+ "Parrot_loadlib_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 98 */
+ /* type PARROT_INLINE_OP, */
+ "loadlib",
+ "loadlib_p_s_p",
+ "Parrot_loadlib_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 99 */
+ /* type PARROT_INLINE_OP, */
+ "loadlib",
+ "loadlib_p_sc_p",
+ "Parrot_loadlib_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 100 */
+ /* type PARROT_INLINE_OP, */
+ "loadlib",
+ "loadlib_p_s_pc",
+ "Parrot_loadlib_p_s_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 101 */
+ /* type PARROT_INLINE_OP, */
+ "loadlib",
+ "loadlib_p_sc_pc",
+ "Parrot_loadlib_p_sc_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 102 */
+ /* type PARROT_FUNCTION_OP, */
+ "dlfunc",
+ "dlfunc_p_p_s_s",
+ "Parrot_dlfunc_p_p_s_s",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 103 */
+ /* type PARROT_FUNCTION_OP, */
+ "dlfunc",
+ "dlfunc_p_p_sc_s",
+ "Parrot_dlfunc_p_p_sc_s",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 104 */
+ /* type PARROT_FUNCTION_OP, */
+ "dlfunc",
+ "dlfunc_p_p_s_sc",
+ "Parrot_dlfunc_p_p_s_sc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 105 */
+ /* type PARROT_FUNCTION_OP, */
+ "dlfunc",
+ "dlfunc_p_p_sc_sc",
+ "Parrot_dlfunc_p_p_sc_sc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 106 */
+ /* type PARROT_FUNCTION_OP, */
+ "dlvar",
+ "dlvar_p_p_s",
+ "Parrot_dlvar_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 107 */
+ /* type PARROT_FUNCTION_OP, */
+ "dlvar",
+ "dlvar_p_p_sc",
+ "Parrot_dlvar_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 108 */
+ /* type PARROT_INLINE_OP, */
+ "compreg",
+ "compreg_s_p",
+ "Parrot_compreg_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 109 */
+ /* type PARROT_INLINE_OP, */
+ "compreg",
+ "compreg_sc_p",
+ "Parrot_compreg_sc_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 110 */
+ /* type PARROT_INLINE_OP, */
+ "compreg",
+ "compreg_p_s",
+ "Parrot_compreg_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 111 */
+ /* type PARROT_INLINE_OP, */
+ "compreg",
+ "compreg_p_sc",
+ "Parrot_compreg_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 112 */
+ /* type PARROT_FUNCTION_OP, */
+ "new_callback",
+ "new_callback_p_p_p_s",
+ "Parrot_new_callback_p_p_p_s",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 113 */
+ /* type PARROT_FUNCTION_OP, */
+ "new_callback",
+ "new_callback_p_p_p_sc",
+ "Parrot_new_callback_p_p_p_sc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 114 */
+ /* type PARROT_INLINE_OP, */
+ "annotations",
+ "annotations_p",
+ "Parrot_annotations_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 115 */
+ /* type PARROT_INLINE_OP, */
+ "annotations",
+ "annotations_p_s",
+ "Parrot_annotations_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 116 */
+ /* type PARROT_INLINE_OP, */
+ "annotations",
+ "annotations_p_sc",
+ "Parrot_annotations_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 117 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_i_i",
+ "Parrot_band_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 118 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_i_ic",
+ "Parrot_band_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 119 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_p_i",
+ "Parrot_band_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 120 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_p_ic",
+ "Parrot_band_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 121 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_p_p",
+ "Parrot_band_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 122 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_i_i_i",
+ "Parrot_band_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 123 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_i_ic_i",
+ "Parrot_band_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 124 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_i_i_ic",
+ "Parrot_band_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 125 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_p_p_i",
+ "Parrot_band_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 126 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_p_p_ic",
+ "Parrot_band_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 127 */
+ /* type PARROT_INLINE_OP, */
+ "band",
+ "band_p_p_p",
+ "Parrot_band_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 128 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_p_s",
+ "Parrot_bands_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 129 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_p_sc",
+ "Parrot_bands_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 130 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_p_p",
+ "Parrot_bands_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 131 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_s_s_s",
+ "Parrot_bands_s_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 132 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_s_sc_s",
+ "Parrot_bands_s_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 133 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_s_s_sc",
+ "Parrot_bands_s_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 134 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_p_p_s",
+ "Parrot_bands_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 135 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_p_p_sc",
+ "Parrot_bands_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 136 */
+ /* type PARROT_INLINE_OP, */
+ "bands",
+ "bands_p_p_p",
+ "Parrot_bands_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 137 */
+ /* type PARROT_INLINE_OP, */
+ "bnot",
+ "bnot_i",
+ "Parrot_bnot_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 138 */
+ /* type PARROT_INLINE_OP, */
+ "bnot",
+ "bnot_i_i",
+ "Parrot_bnot_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 139 */
+ /* type PARROT_INLINE_OP, */
+ "bnot",
+ "bnot_p",
+ "Parrot_bnot_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 140 */
+ /* type PARROT_INLINE_OP, */
+ "bnot",
+ "bnot_p_p",
+ "Parrot_bnot_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 141 */
+ /* type PARROT_INLINE_OP, */
+ "bnots",
+ "bnots_s_s",
+ "Parrot_bnots_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 142 */
+ /* type PARROT_INLINE_OP, */
+ "bnots",
+ "bnots_s_sc",
+ "Parrot_bnots_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 143 */
+ /* type PARROT_INLINE_OP, */
+ "bnots",
+ "bnots_p",
+ "Parrot_bnots_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 144 */
+ /* type PARROT_INLINE_OP, */
+ "bnots",
+ "bnots_p_p",
+ "Parrot_bnots_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 145 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_i_i",
+ "Parrot_bor_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 146 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_i_ic",
+ "Parrot_bor_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 147 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_p_i",
+ "Parrot_bor_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 148 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_p_ic",
+ "Parrot_bor_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 149 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_p_p",
+ "Parrot_bor_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 150 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_i_i_i",
+ "Parrot_bor_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 151 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_i_ic_i",
+ "Parrot_bor_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 152 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_i_i_ic",
+ "Parrot_bor_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 153 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_p_p_i",
+ "Parrot_bor_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 154 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_p_p_ic",
+ "Parrot_bor_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 155 */
+ /* type PARROT_INLINE_OP, */
+ "bor",
+ "bor_p_p_p",
+ "Parrot_bor_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 156 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_p_s",
+ "Parrot_bors_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 157 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_p_sc",
+ "Parrot_bors_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 158 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_p_p",
+ "Parrot_bors_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 159 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_s_s_s",
+ "Parrot_bors_s_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 160 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_s_sc_s",
+ "Parrot_bors_s_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 161 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_s_s_sc",
+ "Parrot_bors_s_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 162 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_p_p_s",
+ "Parrot_bors_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 163 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_p_p_sc",
+ "Parrot_bors_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 164 */
+ /* type PARROT_INLINE_OP, */
+ "bors",
+ "bors_p_p_p",
+ "Parrot_bors_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 165 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_i_i",
+ "Parrot_shl_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 166 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_i_ic",
+ "Parrot_shl_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 167 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_p_i",
+ "Parrot_shl_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 168 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_p_ic",
+ "Parrot_shl_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 169 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_p_p",
+ "Parrot_shl_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 170 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_i_i_i",
+ "Parrot_shl_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 171 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_i_ic_i",
+ "Parrot_shl_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 172 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_i_i_ic",
+ "Parrot_shl_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 173 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_p_p_i",
+ "Parrot_shl_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 174 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_p_p_ic",
+ "Parrot_shl_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 175 */
+ /* type PARROT_INLINE_OP, */
+ "shl",
+ "shl_p_p_p",
+ "Parrot_shl_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 176 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_i_i",
+ "Parrot_shr_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 177 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_i_ic",
+ "Parrot_shr_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 178 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_p_i",
+ "Parrot_shr_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 179 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_p_ic",
+ "Parrot_shr_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 180 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_p_p",
+ "Parrot_shr_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 181 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_i_i_i",
+ "Parrot_shr_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 182 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_i_ic_i",
+ "Parrot_shr_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 183 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_i_i_ic",
+ "Parrot_shr_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 184 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_p_p_i",
+ "Parrot_shr_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 185 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_p_p_ic",
+ "Parrot_shr_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 186 */
+ /* type PARROT_INLINE_OP, */
+ "shr",
+ "shr_p_p_p",
+ "Parrot_shr_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 187 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_i_i",
+ "Parrot_lsr_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 188 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_i_ic",
+ "Parrot_lsr_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 189 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_p_i",
+ "Parrot_lsr_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 190 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_p_ic",
+ "Parrot_lsr_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 191 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_p_p",
+ "Parrot_lsr_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 192 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_i_i_i",
+ "Parrot_lsr_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 193 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_i_ic_i",
+ "Parrot_lsr_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 194 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_i_i_ic",
+ "Parrot_lsr_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 195 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_p_p_i",
+ "Parrot_lsr_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 196 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_p_p_ic",
+ "Parrot_lsr_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 197 */
+ /* type PARROT_INLINE_OP, */
+ "lsr",
+ "lsr_p_p_p",
+ "Parrot_lsr_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 198 */
+ /* type PARROT_INLINE_OP, */
+ "rot",
+ "rot_i_i_i_ic",
+ "Parrot_rot_i_i_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 199 */
+ /* type PARROT_INLINE_OP, */
+ "rot",
+ "rot_i_ic_i_ic",
+ "Parrot_rot_i_ic_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 200 */
+ /* type PARROT_INLINE_OP, */
+ "rot",
+ "rot_i_i_ic_ic",
+ "Parrot_rot_i_i_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 201 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_i_i",
+ "Parrot_bxor_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 202 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_i_ic",
+ "Parrot_bxor_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 203 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_p_i",
+ "Parrot_bxor_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 204 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_p_ic",
+ "Parrot_bxor_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 205 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_p_p",
+ "Parrot_bxor_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 206 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_i_i_i",
+ "Parrot_bxor_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 207 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_i_ic_i",
+ "Parrot_bxor_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 208 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_i_i_ic",
+ "Parrot_bxor_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 209 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_p_p_i",
+ "Parrot_bxor_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 210 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_p_p_ic",
+ "Parrot_bxor_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 211 */
+ /* type PARROT_INLINE_OP, */
+ "bxor",
+ "bxor_p_p_p",
+ "Parrot_bxor_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 212 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_p_s",
+ "Parrot_bxors_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 213 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_p_sc",
+ "Parrot_bxors_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 214 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_p_p",
+ "Parrot_bxors_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 215 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_s_s_s",
+ "Parrot_bxors_s_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 216 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_s_sc_s",
+ "Parrot_bxors_s_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 217 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_s_s_sc",
+ "Parrot_bxors_s_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 218 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_p_p_s",
+ "Parrot_bxors_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 219 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_p_p_sc",
+ "Parrot_bxors_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 220 */
+ /* type PARROT_INLINE_OP, */
+ "bxors",
+ "bxors_p_p_p",
+ "Parrot_bxors_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 221 */
+ /* type PARROT_INLINE_OP, */
+ "eq",
+ "eq_i_i_ic",
+ "Parrot_eq_i_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 222 */
+ /* type PARROT_INLINE_OP, */
+ "eq",
+ "eq_ic_i_ic",
+ "Parrot_eq_ic_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 223 */
+ /* type PARROT_INLINE_OP, */
+ "eq",
+ "eq_i_ic_ic",
+ "Parrot_eq_i_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 224 */
+ /* type PARROT_INLINE_OP, */
+ "eq",
+ "eq_n_n_ic",
+ "Parrot_eq_n_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 225 */
+ /* type PARROT_INLINE_OP, */
+ "eq",
+ "eq_nc_n_ic",
+ "Parrot_eq_nc_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_NC, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 226 */
+ /* type PARROT_INLINE_OP, */
+ "eq",
+ "eq_n_nc_ic",
+ "Parrot_eq_n_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 227 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_s_s_ic",
+ "Parrot_eq_s_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 228 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_sc_s_ic",
+ "Parrot_eq_sc_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 229 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_s_sc_ic",
+ "Parrot_eq_s_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 230 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_p_ic",
+ "Parrot_eq_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 231 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_i_ic",
+ "Parrot_eq_p_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 232 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_ic_ic",
+ "Parrot_eq_p_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 233 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_n_ic",
+ "Parrot_eq_p_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 234 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_nc_ic",
+ "Parrot_eq_p_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 235 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_s_ic",
+ "Parrot_eq_p_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 236 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq",
+ "eq_p_sc_ic",
+ "Parrot_eq_p_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 237 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_str",
+ "eq_str_p_p_ic",
+ "Parrot_eq_str_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 238 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_num",
+ "eq_num_p_p_ic",
+ "Parrot_eq_num_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 239 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_addr",
+ "eq_addr_s_s_ic",
+ "Parrot_eq_addr_s_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 240 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_addr",
+ "eq_addr_sc_s_ic",
+ "Parrot_eq_addr_sc_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 241 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_addr",
+ "eq_addr_s_sc_ic",
+ "Parrot_eq_addr_s_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 242 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_addr",
+ "eq_addr_sc_sc_ic",
+ "Parrot_eq_addr_sc_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 243 */
+ /* type PARROT_FUNCTION_OP, */
+ "eq_addr",
+ "eq_addr_p_p_ic",
+ "Parrot_eq_addr_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 244 */
+ /* type PARROT_INLINE_OP, */
+ "ne",
+ "ne_i_i_ic",
+ "Parrot_ne_i_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 245 */
+ /* type PARROT_INLINE_OP, */
+ "ne",
+ "ne_ic_i_ic",
+ "Parrot_ne_ic_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 246 */
+ /* type PARROT_INLINE_OP, */
+ "ne",
+ "ne_i_ic_ic",
+ "Parrot_ne_i_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 247 */
+ /* type PARROT_INLINE_OP, */
+ "ne",
+ "ne_n_n_ic",
+ "Parrot_ne_n_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 248 */
+ /* type PARROT_INLINE_OP, */
+ "ne",
+ "ne_nc_n_ic",
+ "Parrot_ne_nc_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_NC, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 249 */
+ /* type PARROT_INLINE_OP, */
+ "ne",
+ "ne_n_nc_ic",
+ "Parrot_ne_n_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 250 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_s_s_ic",
+ "Parrot_ne_s_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 251 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_sc_s_ic",
+ "Parrot_ne_sc_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 252 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_s_sc_ic",
+ "Parrot_ne_s_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 253 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_p_ic",
+ "Parrot_ne_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 254 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_i_ic",
+ "Parrot_ne_p_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 255 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_ic_ic",
+ "Parrot_ne_p_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 256 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_n_ic",
+ "Parrot_ne_p_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 257 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_nc_ic",
+ "Parrot_ne_p_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 258 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_s_ic",
+ "Parrot_ne_p_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 259 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne",
+ "ne_p_sc_ic",
+ "Parrot_ne_p_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 260 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_str",
+ "ne_str_p_p_ic",
+ "Parrot_ne_str_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 261 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_num",
+ "ne_num_p_p_ic",
+ "Parrot_ne_num_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 262 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_addr",
+ "ne_addr_s_s_ic",
+ "Parrot_ne_addr_s_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 263 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_addr",
+ "ne_addr_sc_s_ic",
+ "Parrot_ne_addr_sc_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 264 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_addr",
+ "ne_addr_s_sc_ic",
+ "Parrot_ne_addr_s_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 265 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_addr",
+ "ne_addr_sc_sc_ic",
+ "Parrot_ne_addr_sc_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 266 */
+ /* type PARROT_FUNCTION_OP, */
+ "ne_addr",
+ "ne_addr_p_p_ic",
+ "Parrot_ne_addr_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 267 */
+ /* type PARROT_INLINE_OP, */
+ "lt",
+ "lt_i_i_ic",
+ "Parrot_lt_i_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 268 */
+ /* type PARROT_INLINE_OP, */
+ "lt",
+ "lt_ic_i_ic",
+ "Parrot_lt_ic_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 269 */
+ /* type PARROT_INLINE_OP, */
+ "lt",
+ "lt_i_ic_ic",
+ "Parrot_lt_i_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 270 */
+ /* type PARROT_INLINE_OP, */
+ "lt",
+ "lt_n_n_ic",
+ "Parrot_lt_n_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 271 */
+ /* type PARROT_INLINE_OP, */
+ "lt",
+ "lt_nc_n_ic",
+ "Parrot_lt_nc_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_NC, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 272 */
+ /* type PARROT_INLINE_OP, */
+ "lt",
+ "lt_n_nc_ic",
+ "Parrot_lt_n_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 273 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_s_s_ic",
+ "Parrot_lt_s_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 274 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_sc_s_ic",
+ "Parrot_lt_sc_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 275 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_s_sc_ic",
+ "Parrot_lt_s_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 276 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_p_ic",
+ "Parrot_lt_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 277 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_i_ic",
+ "Parrot_lt_p_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 278 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_ic_ic",
+ "Parrot_lt_p_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 279 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_n_ic",
+ "Parrot_lt_p_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 280 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_nc_ic",
+ "Parrot_lt_p_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 281 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_s_ic",
+ "Parrot_lt_p_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 282 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt",
+ "lt_p_sc_ic",
+ "Parrot_lt_p_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 283 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt_str",
+ "lt_str_p_p_ic",
+ "Parrot_lt_str_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 284 */
+ /* type PARROT_FUNCTION_OP, */
+ "lt_num",
+ "lt_num_p_p_ic",
+ "Parrot_lt_num_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 285 */
+ /* type PARROT_INLINE_OP, */
+ "le",
+ "le_i_i_ic",
+ "Parrot_le_i_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 286 */
+ /* type PARROT_INLINE_OP, */
+ "le",
+ "le_ic_i_ic",
+ "Parrot_le_ic_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 287 */
+ /* type PARROT_INLINE_OP, */
+ "le",
+ "le_i_ic_ic",
+ "Parrot_le_i_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 288 */
+ /* type PARROT_INLINE_OP, */
+ "le",
+ "le_n_n_ic",
+ "Parrot_le_n_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 289 */
+ /* type PARROT_INLINE_OP, */
+ "le",
+ "le_nc_n_ic",
+ "Parrot_le_nc_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_NC, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 290 */
+ /* type PARROT_INLINE_OP, */
+ "le",
+ "le_n_nc_ic",
+ "Parrot_le_n_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 291 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_s_s_ic",
+ "Parrot_le_s_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 292 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_sc_s_ic",
+ "Parrot_le_sc_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 293 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_s_sc_ic",
+ "Parrot_le_s_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 294 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_p_ic",
+ "Parrot_le_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 295 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_i_ic",
+ "Parrot_le_p_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 296 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_ic_ic",
+ "Parrot_le_p_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 297 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_n_ic",
+ "Parrot_le_p_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 298 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_nc_ic",
+ "Parrot_le_p_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 299 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_s_ic",
+ "Parrot_le_p_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 300 */
+ /* type PARROT_FUNCTION_OP, */
+ "le",
+ "le_p_sc_ic",
+ "Parrot_le_p_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 301 */
+ /* type PARROT_FUNCTION_OP, */
+ "le_str",
+ "le_str_p_p_ic",
+ "Parrot_le_str_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 302 */
+ /* type PARROT_FUNCTION_OP, */
+ "le_num",
+ "le_num_p_p_ic",
+ "Parrot_le_num_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 303 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_p_ic",
+ "Parrot_gt_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 304 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_i_ic",
+ "Parrot_gt_p_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 305 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_ic_ic",
+ "Parrot_gt_p_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 306 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_n_ic",
+ "Parrot_gt_p_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 307 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_nc_ic",
+ "Parrot_gt_p_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 308 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_s_ic",
+ "Parrot_gt_p_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 309 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt",
+ "gt_p_sc_ic",
+ "Parrot_gt_p_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 310 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt_str",
+ "gt_str_p_p_ic",
+ "Parrot_gt_str_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 311 */
+ /* type PARROT_FUNCTION_OP, */
+ "gt_num",
+ "gt_num_p_p_ic",
+ "Parrot_gt_num_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 312 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_p_ic",
+ "Parrot_ge_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 313 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_i_ic",
+ "Parrot_ge_p_i_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 314 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_ic_ic",
+ "Parrot_ge_p_ic_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 315 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_n_ic",
+ "Parrot_ge_p_n_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 316 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_nc_ic",
+ "Parrot_ge_p_nc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 317 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_s_ic",
+ "Parrot_ge_p_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 318 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge",
+ "ge_p_sc_ic",
+ "Parrot_ge_p_sc_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 319 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge_str",
+ "ge_str_p_p_ic",
+ "Parrot_ge_str_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 320 */
+ /* type PARROT_FUNCTION_OP, */
+ "ge_num",
+ "ge_num_p_p_ic",
+ "Parrot_ge_num_p_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 1 }
+ },
+ { /* 321 */
+ /* type PARROT_FUNCTION_OP, */
+ "if_null",
+ "if_null_p_ic",
+ "Parrot_if_null_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 322 */
+ /* type PARROT_FUNCTION_OP, */
+ "if_null",
+ "if_null_s_ic",
+ "Parrot_if_null_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 323 */
+ /* type PARROT_FUNCTION_OP, */
+ "unless_null",
+ "unless_null_p_ic",
+ "Parrot_unless_null_p_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 324 */
+ /* type PARROT_FUNCTION_OP, */
+ "unless_null",
+ "unless_null_s_ic",
+ "Parrot_unless_null_s_ic",
+ /* "", body */
+ PARROT_JUMP_RELATIVE,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 325 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_i_i",
+ "Parrot_cmp_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 326 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_ic_i",
+ "Parrot_cmp_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 327 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_i_ic",
+ "Parrot_cmp_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 328 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_n_n",
+ "Parrot_cmp_i_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 329 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_nc_n",
+ "Parrot_cmp_i_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 330 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_n_nc",
+ "Parrot_cmp_i_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 331 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_s_s",
+ "Parrot_cmp_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 332 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_sc_s",
+ "Parrot_cmp_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 333 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_s_sc",
+ "Parrot_cmp_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 334 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_p",
+ "Parrot_cmp_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 335 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_i",
+ "Parrot_cmp_i_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 336 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_ic",
+ "Parrot_cmp_i_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 337 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_n",
+ "Parrot_cmp_i_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 338 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_nc",
+ "Parrot_cmp_i_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 339 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_s",
+ "Parrot_cmp_i_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 340 */
+ /* type PARROT_INLINE_OP, */
+ "cmp",
+ "cmp_i_p_sc",
+ "Parrot_cmp_i_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 341 */
+ /* type PARROT_INLINE_OP, */
+ "cmp_str",
+ "cmp_str_i_p_p",
+ "Parrot_cmp_str_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 342 */
+ /* type PARROT_INLINE_OP, */
+ "cmp_num",
+ "cmp_num_i_p_p",
+ "Parrot_cmp_num_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 343 */
+ /* type PARROT_INLINE_OP, */
+ "cmp_pmc",
+ "cmp_pmc_p_p_p",
+ "Parrot_cmp_pmc_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 344 */
+ /* type PARROT_INLINE_OP, */
+ "issame",
+ "issame_i_p_p",
+ "Parrot_issame_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 345 */
+ /* type PARROT_INLINE_OP, */
+ "issame",
+ "issame_i_s_s",
+ "Parrot_issame_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 346 */
+ /* type PARROT_INLINE_OP, */
+ "issame",
+ "issame_i_sc_s",
+ "Parrot_issame_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 347 */
+ /* type PARROT_INLINE_OP, */
+ "issame",
+ "issame_i_s_sc",
+ "Parrot_issame_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 348 */
+ /* type PARROT_INLINE_OP, */
+ "issame",
+ "issame_i_sc_sc",
+ "Parrot_issame_i_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 349 */
+ /* type PARROT_INLINE_OP, */
+ "isntsame",
+ "isntsame_i_p_p",
+ "Parrot_isntsame_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 350 */
+ /* type PARROT_INLINE_OP, */
+ "isntsame",
+ "isntsame_i_s_s",
+ "Parrot_isntsame_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 351 */
+ /* type PARROT_INLINE_OP, */
+ "isntsame",
+ "isntsame_i_sc_s",
+ "Parrot_isntsame_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 352 */
+ /* type PARROT_INLINE_OP, */
+ "isntsame",
+ "isntsame_i_s_sc",
+ "Parrot_isntsame_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 353 */
+ /* type PARROT_INLINE_OP, */
+ "isntsame",
+ "isntsame_i_sc_sc",
+ "Parrot_isntsame_i_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 354 */
+ /* type PARROT_INLINE_OP, */
+ "istrue",
+ "istrue_i_p",
+ "Parrot_istrue_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 355 */
+ /* type PARROT_INLINE_OP, */
+ "isfalse",
+ "isfalse_i_p",
+ "Parrot_isfalse_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 356 */
+ /* type PARROT_INLINE_OP, */
+ "isnull",
+ "isnull_i_p",
+ "Parrot_isnull_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 357 */
+ /* type PARROT_INLINE_OP, */
+ "isnull",
+ "isnull_i_pc",
+ "Parrot_isnull_i_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 358 */
+ /* type PARROT_INLINE_OP, */
+ "isnull",
+ "isnull_i_s",
+ "Parrot_isnull_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 359 */
+ /* type PARROT_INLINE_OP, */
+ "isnull",
+ "isnull_i_sc",
+ "Parrot_isnull_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 360 */
+ /* type PARROT_INLINE_OP, */
+ "isgt",
+ "isgt_i_p_p",
+ "Parrot_isgt_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 361 */
+ /* type PARROT_INLINE_OP, */
+ "isge",
+ "isge_i_p_p",
+ "Parrot_isge_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 362 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_i_i",
+ "Parrot_isle_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 363 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_ic_i",
+ "Parrot_isle_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 364 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_i_ic",
+ "Parrot_isle_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 365 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_n_n",
+ "Parrot_isle_i_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 366 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_nc_n",
+ "Parrot_isle_i_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 367 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_n_nc",
+ "Parrot_isle_i_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 368 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_s_s",
+ "Parrot_isle_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 369 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_sc_s",
+ "Parrot_isle_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 370 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_s_sc",
+ "Parrot_isle_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 371 */
+ /* type PARROT_INLINE_OP, */
+ "isle",
+ "isle_i_p_p",
+ "Parrot_isle_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 372 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_i_i",
+ "Parrot_islt_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 373 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_ic_i",
+ "Parrot_islt_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 374 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_i_ic",
+ "Parrot_islt_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 375 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_n_n",
+ "Parrot_islt_i_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 376 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_nc_n",
+ "Parrot_islt_i_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 377 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_n_nc",
+ "Parrot_islt_i_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 378 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_s_s",
+ "Parrot_islt_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 379 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_sc_s",
+ "Parrot_islt_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 380 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_s_sc",
+ "Parrot_islt_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 381 */
+ /* type PARROT_INLINE_OP, */
+ "islt",
+ "islt_i_p_p",
+ "Parrot_islt_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 382 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_i_i",
+ "Parrot_iseq_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 383 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_ic_i",
+ "Parrot_iseq_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 384 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_i_ic",
+ "Parrot_iseq_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 385 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_n_n",
+ "Parrot_iseq_i_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 386 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_nc_n",
+ "Parrot_iseq_i_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 387 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_n_nc",
+ "Parrot_iseq_i_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 388 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_s_s",
+ "Parrot_iseq_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 389 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_sc_s",
+ "Parrot_iseq_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 390 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_s_sc",
+ "Parrot_iseq_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 391 */
+ /* type PARROT_INLINE_OP, */
+ "iseq",
+ "iseq_i_p_p",
+ "Parrot_iseq_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 392 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_i_i",
+ "Parrot_isne_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 393 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_ic_i",
+ "Parrot_isne_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 394 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_i_ic",
+ "Parrot_isne_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 395 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_n_n",
+ "Parrot_isne_i_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 396 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_nc_n",
+ "Parrot_isne_i_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 397 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_n_nc",
+ "Parrot_isne_i_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 398 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_s_s",
+ "Parrot_isne_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 399 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_sc_s",
+ "Parrot_isne_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 400 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_s_sc",
+ "Parrot_isne_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 401 */
+ /* type PARROT_INLINE_OP, */
+ "isne",
+ "isne_i_p_p",
+ "Parrot_isne_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 402 */
+ /* type PARROT_INLINE_OP, */
+ "and",
+ "and_i_i_i",
+ "Parrot_and_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 403 */
+ /* type PARROT_INLINE_OP, */
+ "and",
+ "and_i_ic_i",
+ "Parrot_and_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 404 */
+ /* type PARROT_INLINE_OP, */
+ "and",
+ "and_i_i_ic",
+ "Parrot_and_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 405 */
+ /* type PARROT_INLINE_OP, */
+ "and",
+ "and_p_p_p",
+ "Parrot_and_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 406 */
+ /* type PARROT_INLINE_OP, */
+ "not",
+ "not_i",
+ "Parrot_not_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 407 */
+ /* type PARROT_INLINE_OP, */
+ "not",
+ "not_i_i",
+ "Parrot_not_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 408 */
+ /* type PARROT_INLINE_OP, */
+ "not",
+ "not_p",
+ "Parrot_not_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 409 */
+ /* type PARROT_INLINE_OP, */
+ "not",
+ "not_p_p",
+ "Parrot_not_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 410 */
+ /* type PARROT_INLINE_OP, */
+ "or",
+ "or_i_i_i",
+ "Parrot_or_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 411 */
+ /* type PARROT_INLINE_OP, */
+ "or",
+ "or_i_ic_i",
+ "Parrot_or_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 412 */
+ /* type PARROT_INLINE_OP, */
+ "or",
+ "or_i_i_ic",
+ "Parrot_or_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 413 */
+ /* type PARROT_INLINE_OP, */
+ "or",
+ "or_p_p_p",
+ "Parrot_or_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 414 */
+ /* type PARROT_INLINE_OP, */
+ "xor",
+ "xor_i_i_i",
+ "Parrot_xor_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 415 */
+ /* type PARROT_INLINE_OP, */
+ "xor",
+ "xor_i_ic_i",
+ "Parrot_xor_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 416 */
+ /* type PARROT_INLINE_OP, */
+ "xor",
+ "xor_i_i_ic",
+ "Parrot_xor_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 417 */
+ /* type PARROT_INLINE_OP, */
+ "xor",
+ "xor_p_p_p",
+ "Parrot_xor_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 418 */
+ /* type PARROT_FUNCTION_OP, */
+ "debug_init",
+ "debug_init",
+ "Parrot_debug_init",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 419 */
+ /* type PARROT_FUNCTION_OP, */
+ "debug_load",
+ "debug_load_sc",
+ "Parrot_debug_load_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 420 */
+ /* type PARROT_FUNCTION_OP, */
+ "debug_break",
+ "debug_break",
+ "Parrot_debug_break",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 421 */
+ /* type PARROT_FUNCTION_OP, */
+ "debug_print",
+ "debug_print",
+ "Parrot_debug_print",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 422 */
+ /* type PARROT_FUNCTION_OP, */
+ "backtrace",
+ "backtrace",
+ "Parrot_backtrace",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 423 */
+ /* type PARROT_INLINE_OP, */
+ "getline",
+ "getline_i",
+ "Parrot_getline_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 424 */
+ /* type PARROT_INLINE_OP, */
+ "getfile",
+ "getfile_s",
+ "Parrot_getfile_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 425 */
+ /* type PARROT_INLINE_OP, */
+ "close",
+ "close_p",
+ "Parrot_close_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 426 */
+ /* type PARROT_INLINE_OP, */
+ "fdopen",
+ "fdopen_p_i_s",
+ "Parrot_fdopen_p_i_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 427 */
+ /* type PARROT_INLINE_OP, */
+ "fdopen",
+ "fdopen_p_ic_s",
+ "Parrot_fdopen_p_ic_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 428 */
+ /* type PARROT_INLINE_OP, */
+ "fdopen",
+ "fdopen_p_i_sc",
+ "Parrot_fdopen_p_i_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 429 */
+ /* type PARROT_INLINE_OP, */
+ "fdopen",
+ "fdopen_p_ic_sc",
+ "Parrot_fdopen_p_ic_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 430 */
+ /* type PARROT_INLINE_OP, */
+ "getstdin",
+ "getstdin_p",
+ "Parrot_getstdin_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 431 */
+ /* type PARROT_INLINE_OP, */
+ "getstdout",
+ "getstdout_p",
+ "Parrot_getstdout_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 432 */
+ /* type PARROT_INLINE_OP, */
+ "getstderr",
+ "getstderr_p",
+ "Parrot_getstderr_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 433 */
+ /* type PARROT_INLINE_OP, */
+ "setstdin",
+ "setstdin_p",
+ "Parrot_setstdin_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 434 */
+ /* type PARROT_INLINE_OP, */
+ "setstdout",
+ "setstdout_p",
+ "Parrot_setstdout_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 435 */
+ /* type PARROT_INLINE_OP, */
+ "setstderr",
+ "setstderr_p",
+ "Parrot_setstderr_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 436 */
+ /* type PARROT_INLINE_OP, */
+ "open",
+ "open_p_s_s",
+ "Parrot_open_p_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 437 */
+ /* type PARROT_INLINE_OP, */
+ "open",
+ "open_p_sc_s",
+ "Parrot_open_p_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 438 */
+ /* type PARROT_INLINE_OP, */
+ "open",
+ "open_p_s_sc",
+ "Parrot_open_p_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 439 */
+ /* type PARROT_INLINE_OP, */
+ "open",
+ "open_p_sc_sc",
+ "Parrot_open_p_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 440 */
+ /* type PARROT_INLINE_OP, */
+ "open",
+ "open_p_s",
+ "Parrot_open_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 441 */
+ /* type PARROT_INLINE_OP, */
+ "open",
+ "open_p_sc",
+ "Parrot_open_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 442 */
+ /* type PARROT_INLINE_OP, */
+ "print",
+ "print_i",
+ "Parrot_print_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 443 */
+ /* type PARROT_INLINE_OP, */
+ "print",
+ "print_ic",
+ "Parrot_print_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 444 */
+ /* type PARROT_INLINE_OP, */
+ "print",
+ "print_n",
+ "Parrot_print_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 445 */
+ /* type PARROT_INLINE_OP, */
+ "print",
+ "print_nc",
+ "Parrot_print_nc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 446 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_s",
+ "Parrot_print_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 447 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_sc",
+ "Parrot_print_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 448 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p",
+ "Parrot_print_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 449 */
+ /* type PARROT_INLINE_OP, */
+ "say",
+ "say_i",
+ "Parrot_say_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 450 */
+ /* type PARROT_INLINE_OP, */
+ "say",
+ "say_ic",
+ "Parrot_say_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 451 */
+ /* type PARROT_INLINE_OP, */
+ "say",
+ "say_n",
+ "Parrot_say_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 452 */
+ /* type PARROT_INLINE_OP, */
+ "say",
+ "say_nc",
+ "Parrot_say_nc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 453 */
+ /* type PARROT_FUNCTION_OP, */
+ "say",
+ "say_s",
+ "Parrot_say_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 454 */
+ /* type PARROT_FUNCTION_OP, */
+ "say",
+ "say_sc",
+ "Parrot_say_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 455 */
+ /* type PARROT_FUNCTION_OP, */
+ "say",
+ "say_p",
+ "Parrot_say_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 456 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_i",
+ "Parrot_printerr_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 457 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_ic",
+ "Parrot_printerr_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 458 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_n",
+ "Parrot_printerr_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 459 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_nc",
+ "Parrot_printerr_nc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 460 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_s",
+ "Parrot_printerr_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 461 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_sc",
+ "Parrot_printerr_sc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 462 */
+ /* type PARROT_FUNCTION_OP, */
+ "printerr",
+ "printerr_p",
+ "Parrot_printerr_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 463 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_i",
+ "Parrot_print_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 464 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_ic",
+ "Parrot_print_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 465 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_n",
+ "Parrot_print_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 466 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_nc",
+ "Parrot_print_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 467 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_s",
+ "Parrot_print_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 468 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_sc",
+ "Parrot_print_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 469 */
+ /* type PARROT_FUNCTION_OP, */
+ "print",
+ "print_p_p",
+ "Parrot_print_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 470 */
+ /* type PARROT_FUNCTION_OP, */
+ "read",
+ "read_s_i",
+ "Parrot_read_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 471 */
+ /* type PARROT_FUNCTION_OP, */
+ "read",
+ "read_s_ic",
+ "Parrot_read_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 472 */
+ /* type PARROT_FUNCTION_OP, */
+ "read",
+ "read_s_p_i",
+ "Parrot_read_s_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 473 */
+ /* type PARROT_FUNCTION_OP, */
+ "read",
+ "read_s_p_ic",
+ "Parrot_read_s_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 474 */
+ /* type PARROT_INLINE_OP, */
+ "readline",
+ "readline_s_p",
+ "Parrot_readline_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 475 */
+ /* type PARROT_FUNCTION_OP, */
+ "peek",
+ "peek_s",
+ "Parrot_peek_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 476 */
+ /* type PARROT_FUNCTION_OP, */
+ "peek",
+ "peek_s_p",
+ "Parrot_peek_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 477 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_s_i",
+ "Parrot_stat_i_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 478 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_sc_i",
+ "Parrot_stat_i_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 479 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_s_ic",
+ "Parrot_stat_i_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 480 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_sc_ic",
+ "Parrot_stat_i_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 481 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_i_i",
+ "Parrot_stat_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 482 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_ic_i",
+ "Parrot_stat_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 483 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_i_ic",
+ "Parrot_stat_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 484 */
+ /* type PARROT_FUNCTION_OP, */
+ "stat",
+ "stat_i_ic_ic",
+ "Parrot_stat_i_ic_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 485 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_i_i",
+ "Parrot_seek_p_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 486 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_ic_i",
+ "Parrot_seek_p_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 487 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_i_ic",
+ "Parrot_seek_p_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 488 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_ic_ic",
+ "Parrot_seek_p_ic_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 489 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_i_i_i",
+ "Parrot_seek_p_i_i_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 490 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_ic_i_i",
+ "Parrot_seek_p_ic_i_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 491 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_i_ic_i",
+ "Parrot_seek_p_i_ic_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 492 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_ic_ic_i",
+ "Parrot_seek_p_ic_ic_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 493 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_i_i_ic",
+ "Parrot_seek_p_i_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 494 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_ic_i_ic",
+ "Parrot_seek_p_ic_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 495 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_i_ic_ic",
+ "Parrot_seek_p_i_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 496 */
+ /* type PARROT_FUNCTION_OP, */
+ "seek",
+ "seek_p_ic_ic_ic",
+ "Parrot_seek_p_ic_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 497 */
+ /* type PARROT_FUNCTION_OP, */
+ "tell",
+ "tell_i_p",
+ "Parrot_tell_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 498 */
+ /* type PARROT_FUNCTION_OP, */
+ "tell",
+ "tell_i_i_p",
+ "Parrot_tell_i_i_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 499 */
+ /* type PARROT_INLINE_OP, */
+ "abs",
+ "abs_i",
+ "Parrot_abs_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 500 */
+ /* type PARROT_INLINE_OP, */
+ "abs",
+ "abs_n",
+ "Parrot_abs_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 501 */
+ /* type PARROT_INLINE_OP, */
+ "abs",
+ "abs_i_i",
+ "Parrot_abs_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 502 */
+ /* type PARROT_INLINE_OP, */
+ "abs",
+ "abs_n_n",
+ "Parrot_abs_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 503 */
+ /* type PARROT_INLINE_OP, */
+ "abs",
+ "abs_p",
+ "Parrot_abs_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 504 */
+ /* type PARROT_INLINE_OP, */
+ "abs",
+ "abs_p_p",
+ "Parrot_abs_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 505 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_i_i",
+ "Parrot_add_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 506 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_i_ic",
+ "Parrot_add_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 507 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_n_n",
+ "Parrot_add_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 508 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_n_nc",
+ "Parrot_add_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 509 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_p",
+ "Parrot_add_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 510 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_i",
+ "Parrot_add_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 511 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_ic",
+ "Parrot_add_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 512 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_n",
+ "Parrot_add_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 513 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_nc",
+ "Parrot_add_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 514 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_i_i_i",
+ "Parrot_add_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 515 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_i_ic_i",
+ "Parrot_add_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 516 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_i_i_ic",
+ "Parrot_add_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 517 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_n_n_n",
+ "Parrot_add_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 518 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_n_nc_n",
+ "Parrot_add_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 519 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_n_n_nc",
+ "Parrot_add_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 520 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_p_p",
+ "Parrot_add_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 521 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_p_i",
+ "Parrot_add_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 522 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_p_ic",
+ "Parrot_add_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 523 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_p_n",
+ "Parrot_add_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 524 */
+ /* type PARROT_INLINE_OP, */
+ "add",
+ "add_p_p_nc",
+ "Parrot_add_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 525 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_i_i_i",
+ "Parrot_cmod_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 526 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_i_ic_i",
+ "Parrot_cmod_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 527 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_i_i_ic",
+ "Parrot_cmod_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 528 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_p_p_i",
+ "Parrot_cmod_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 529 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_p_p_ic",
+ "Parrot_cmod_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 530 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_p_p_p",
+ "Parrot_cmod_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 531 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_n_n_n",
+ "Parrot_cmod_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 532 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_n_nc_n",
+ "Parrot_cmod_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 533 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_n_n_nc",
+ "Parrot_cmod_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 534 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_p_p_n",
+ "Parrot_cmod_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 535 */
+ /* type PARROT_INLINE_OP, */
+ "cmod",
+ "cmod_p_p_nc",
+ "Parrot_cmod_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 536 */
+ /* type PARROT_INLINE_OP, */
+ "dec",
+ "dec_i",
+ "Parrot_dec_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 537 */
+ /* type PARROT_INLINE_OP, */
+ "dec",
+ "dec_n",
+ "Parrot_dec_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 538 */
+ /* type PARROT_INLINE_OP, */
+ "dec",
+ "dec_p",
+ "Parrot_dec_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 539 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_i_i",
+ "Parrot_div_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 540 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_i_ic",
+ "Parrot_div_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 541 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_n_n",
+ "Parrot_div_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 542 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_n_nc",
+ "Parrot_div_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 543 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_p",
+ "Parrot_div_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 544 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_i",
+ "Parrot_div_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 545 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_ic",
+ "Parrot_div_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 546 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_n",
+ "Parrot_div_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 547 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_nc",
+ "Parrot_div_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 548 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_i_i_i",
+ "Parrot_div_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 549 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_i_ic_i",
+ "Parrot_div_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 550 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_i_i_ic",
+ "Parrot_div_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 551 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_i_ic_ic",
+ "Parrot_div_i_ic_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 552 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_n_n_n",
+ "Parrot_div_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 553 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_n_nc_n",
+ "Parrot_div_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 554 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_n_n_nc",
+ "Parrot_div_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 555 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_n_nc_nc",
+ "Parrot_div_n_nc_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 556 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_p_p",
+ "Parrot_div_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 557 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_p_i",
+ "Parrot_div_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 558 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_p_ic",
+ "Parrot_div_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 559 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_p_n",
+ "Parrot_div_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 560 */
+ /* type PARROT_INLINE_OP, */
+ "div",
+ "div_p_p_nc",
+ "Parrot_div_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 561 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_i_i",
+ "Parrot_fdiv_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 562 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_i_ic",
+ "Parrot_fdiv_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 563 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_n_n",
+ "Parrot_fdiv_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 564 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_n_nc",
+ "Parrot_fdiv_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 565 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_p",
+ "Parrot_fdiv_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 566 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_i",
+ "Parrot_fdiv_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 567 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_ic",
+ "Parrot_fdiv_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 568 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_n",
+ "Parrot_fdiv_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 569 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_nc",
+ "Parrot_fdiv_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 570 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_i_i_i",
+ "Parrot_fdiv_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 571 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_i_ic_i",
+ "Parrot_fdiv_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 572 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_i_i_ic",
+ "Parrot_fdiv_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 573 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_n_n_n",
+ "Parrot_fdiv_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 574 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_n_nc_n",
+ "Parrot_fdiv_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 575 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_n_n_nc",
+ "Parrot_fdiv_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 576 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_p_p",
+ "Parrot_fdiv_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 577 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_p_i",
+ "Parrot_fdiv_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 578 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_p_ic",
+ "Parrot_fdiv_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 579 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_p_n",
+ "Parrot_fdiv_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 580 */
+ /* type PARROT_INLINE_OP, */
+ "fdiv",
+ "fdiv_p_p_nc",
+ "Parrot_fdiv_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 581 */
+ /* type PARROT_INLINE_OP, */
+ "ceil",
+ "ceil_n",
+ "Parrot_ceil_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 582 */
+ /* type PARROT_INLINE_OP, */
+ "ceil",
+ "ceil_i_n",
+ "Parrot_ceil_i_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 583 */
+ /* type PARROT_INLINE_OP, */
+ "ceil",
+ "ceil_n_n",
+ "Parrot_ceil_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 584 */
+ /* type PARROT_INLINE_OP, */
+ "floor",
+ "floor_n",
+ "Parrot_floor_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 585 */
+ /* type PARROT_INLINE_OP, */
+ "floor",
+ "floor_i_n",
+ "Parrot_floor_i_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 586 */
+ /* type PARROT_INLINE_OP, */
+ "floor",
+ "floor_n_n",
+ "Parrot_floor_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 587 */
+ /* type PARROT_INLINE_OP, */
+ "inc",
+ "inc_i",
+ "Parrot_inc_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 588 */
+ /* type PARROT_INLINE_OP, */
+ "inc",
+ "inc_n",
+ "Parrot_inc_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 589 */
+ /* type PARROT_INLINE_OP, */
+ "inc",
+ "inc_p",
+ "Parrot_inc_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 590 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_i_i",
+ "Parrot_mod_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 591 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_i_ic",
+ "Parrot_mod_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 592 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_n_n",
+ "Parrot_mod_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 593 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_n_nc",
+ "Parrot_mod_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 594 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_p",
+ "Parrot_mod_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 595 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_i",
+ "Parrot_mod_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 596 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_ic",
+ "Parrot_mod_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 597 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_n",
+ "Parrot_mod_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 598 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_nc",
+ "Parrot_mod_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 599 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_i_i_i",
+ "Parrot_mod_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 600 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_i_ic_i",
+ "Parrot_mod_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 601 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_i_i_ic",
+ "Parrot_mod_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 602 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_n_n_n",
+ "Parrot_mod_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 603 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_n_nc_n",
+ "Parrot_mod_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 604 */
+ /* type PARROT_FUNCTION_OP, */
+ "mod",
+ "mod_n_n_nc",
+ "Parrot_mod_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 605 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_p_p",
+ "Parrot_mod_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 606 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_p_i",
+ "Parrot_mod_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 607 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_p_ic",
+ "Parrot_mod_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 608 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_p_n",
+ "Parrot_mod_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 609 */
+ /* type PARROT_INLINE_OP, */
+ "mod",
+ "mod_p_p_nc",
+ "Parrot_mod_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 610 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_i_i",
+ "Parrot_mul_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 611 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_i_ic",
+ "Parrot_mul_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 612 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_n_n",
+ "Parrot_mul_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 613 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_n_nc",
+ "Parrot_mul_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 614 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_p",
+ "Parrot_mul_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 615 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_i",
+ "Parrot_mul_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 616 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_ic",
+ "Parrot_mul_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 617 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_n",
+ "Parrot_mul_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 618 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_nc",
+ "Parrot_mul_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 619 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_i_i_i",
+ "Parrot_mul_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 620 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_i_ic_i",
+ "Parrot_mul_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 621 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_i_i_ic",
+ "Parrot_mul_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 622 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_n_n_n",
+ "Parrot_mul_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 623 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_n_nc_n",
+ "Parrot_mul_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 624 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_n_n_nc",
+ "Parrot_mul_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 625 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_p_p",
+ "Parrot_mul_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 626 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_p_i",
+ "Parrot_mul_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 627 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_p_ic",
+ "Parrot_mul_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 628 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_p_n",
+ "Parrot_mul_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 629 */
+ /* type PARROT_INLINE_OP, */
+ "mul",
+ "mul_p_p_nc",
+ "Parrot_mul_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 630 */
+ /* type PARROT_INLINE_OP, */
+ "neg",
+ "neg_i",
+ "Parrot_neg_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 631 */
+ /* type PARROT_INLINE_OP, */
+ "neg",
+ "neg_n",
+ "Parrot_neg_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 632 */
+ /* type PARROT_INLINE_OP, */
+ "neg",
+ "neg_p",
+ "Parrot_neg_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 633 */
+ /* type PARROT_INLINE_OP, */
+ "neg",
+ "neg_i_i",
+ "Parrot_neg_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 634 */
+ /* type PARROT_INLINE_OP, */
+ "neg",
+ "neg_n_n",
+ "Parrot_neg_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 635 */
+ /* type PARROT_INLINE_OP, */
+ "neg",
+ "neg_p_p",
+ "Parrot_neg_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 636 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_n_n",
+ "Parrot_pow_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 637 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_nc_n",
+ "Parrot_pow_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 638 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_n_nc",
+ "Parrot_pow_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 639 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_p_p_p",
+ "Parrot_pow_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 640 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_p_p_i",
+ "Parrot_pow_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 641 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_p_p_ic",
+ "Parrot_pow_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 642 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_p_p_n",
+ "Parrot_pow_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 643 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_p_p_nc",
+ "Parrot_pow_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 644 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_n_i",
+ "Parrot_pow_n_n_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 645 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_nc_i",
+ "Parrot_pow_n_nc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 646 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_n_ic",
+ "Parrot_pow_n_n_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 647 */
+ /* type PARROT_INLINE_OP, */
+ "pow",
+ "pow_n_nc_ic",
+ "Parrot_pow_n_nc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 648 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_i_i",
+ "Parrot_sub_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 649 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_i_ic",
+ "Parrot_sub_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 650 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_n_n",
+ "Parrot_sub_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 651 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_n_nc",
+ "Parrot_sub_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 652 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_p",
+ "Parrot_sub_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 653 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_i",
+ "Parrot_sub_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 654 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_ic",
+ "Parrot_sub_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 655 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_n",
+ "Parrot_sub_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 656 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_nc",
+ "Parrot_sub_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 657 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_i_i_i",
+ "Parrot_sub_i_i_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 658 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_i_ic_i",
+ "Parrot_sub_i_ic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 659 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_i_i_ic",
+ "Parrot_sub_i_i_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 660 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_n_n_n",
+ "Parrot_sub_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 661 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_n_nc_n",
+ "Parrot_sub_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 662 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_n_n_nc",
+ "Parrot_sub_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 663 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_p_p",
+ "Parrot_sub_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 664 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_p_i",
+ "Parrot_sub_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 665 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_p_ic",
+ "Parrot_sub_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 666 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_p_n",
+ "Parrot_sub_p_p_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 667 */
+ /* type PARROT_INLINE_OP, */
+ "sub",
+ "sub_p_p_nc",
+ "Parrot_sub_p_p_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 668 */
+ /* type PARROT_INLINE_OP, */
+ "sqrt",
+ "sqrt_n_n",
+ "Parrot_sqrt_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 669 */
+ /* type PARROT_INLINE_OP, */
+ "acos",
+ "acos_n_n",
+ "Parrot_acos_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 670 */
+ /* type PARROT_INLINE_OP, */
+ "asec",
+ "asec_n_n",
+ "Parrot_asec_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 671 */
+ /* type PARROT_INLINE_OP, */
+ "asin",
+ "asin_n_n",
+ "Parrot_asin_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 672 */
+ /* type PARROT_INLINE_OP, */
+ "atan",
+ "atan_n_n",
+ "Parrot_atan_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 673 */
+ /* type PARROT_INLINE_OP, */
+ "atan",
+ "atan_n_n_n",
+ "Parrot_atan_n_n_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 674 */
+ /* type PARROT_INLINE_OP, */
+ "atan",
+ "atan_n_nc_n",
+ "Parrot_atan_n_nc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_NC, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 675 */
+ /* type PARROT_INLINE_OP, */
+ "atan",
+ "atan_n_n_nc",
+ "Parrot_atan_n_n_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 676 */
+ /* type PARROT_INLINE_OP, */
+ "cos",
+ "cos_n_n",
+ "Parrot_cos_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 677 */
+ /* type PARROT_INLINE_OP, */
+ "cosh",
+ "cosh_n_n",
+ "Parrot_cosh_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 678 */
+ /* type PARROT_INLINE_OP, */
+ "exp",
+ "exp_n_n",
+ "Parrot_exp_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 679 */
+ /* type PARROT_INLINE_OP, */
+ "ln",
+ "ln_n_n",
+ "Parrot_ln_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 680 */
+ /* type PARROT_INLINE_OP, */
+ "log10",
+ "log10_n_n",
+ "Parrot_log10_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 681 */
+ /* type PARROT_FUNCTION_OP, */
+ "log2",
+ "log2_n_n",
+ "Parrot_log2_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 682 */
+ /* type PARROT_INLINE_OP, */
+ "sec",
+ "sec_n_n",
+ "Parrot_sec_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 683 */
+ /* type PARROT_INLINE_OP, */
+ "sech",
+ "sech_n_n",
+ "Parrot_sech_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 684 */
+ /* type PARROT_INLINE_OP, */
+ "sin",
+ "sin_n_n",
+ "Parrot_sin_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 685 */
+ /* type PARROT_INLINE_OP, */
+ "sinh",
+ "sinh_n_n",
+ "Parrot_sinh_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 686 */
+ /* type PARROT_INLINE_OP, */
+ "tan",
+ "tan_n_n",
+ "Parrot_tan_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 687 */
+ /* type PARROT_INLINE_OP, */
+ "tanh",
+ "tanh_n_n",
+ "Parrot_tanh_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 688 */
+ /* type PARROT_FUNCTION_OP, */
+ "callmethodcc",
+ "callmethodcc_p_s",
+ "Parrot_callmethodcc_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 689 */
+ /* type PARROT_FUNCTION_OP, */
+ "callmethodcc",
+ "callmethodcc_p_sc",
+ "Parrot_callmethodcc_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 690 */
+ /* type PARROT_FUNCTION_OP, */
+ "callmethodcc",
+ "callmethodcc_p_p",
+ "Parrot_callmethodcc_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 691 */
+ /* type PARROT_FUNCTION_OP, */
+ "callmethod",
+ "callmethod_p_s_p",
+ "Parrot_callmethod_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 692 */
+ /* type PARROT_FUNCTION_OP, */
+ "callmethod",
+ "callmethod_p_sc_p",
+ "Parrot_callmethod_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 693 */
+ /* type PARROT_FUNCTION_OP, */
+ "callmethod",
+ "callmethod_p_p_p",
+ "Parrot_callmethod_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 694 */
+ /* type PARROT_FUNCTION_OP, */
+ "tailcallmethod",
+ "tailcallmethod_p_s",
+ "Parrot_tailcallmethod_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 695 */
+ /* type PARROT_FUNCTION_OP, */
+ "tailcallmethod",
+ "tailcallmethod_p_sc",
+ "Parrot_tailcallmethod_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 696 */
+ /* type PARROT_FUNCTION_OP, */
+ "tailcallmethod",
+ "tailcallmethod_p_p",
+ "Parrot_tailcallmethod_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 697 */
+ /* type PARROT_INLINE_OP, */
+ "addmethod",
+ "addmethod_p_s_p",
+ "Parrot_addmethod_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 698 */
+ /* type PARROT_INLINE_OP, */
+ "addmethod",
+ "addmethod_p_sc_p",
+ "Parrot_addmethod_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 699 */
+ /* type PARROT_INLINE_OP, */
+ "can",
+ "can_i_p_s",
+ "Parrot_can_i_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 700 */
+ /* type PARROT_INLINE_OP, */
+ "can",
+ "can_i_p_sc",
+ "Parrot_can_i_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 701 */
+ /* type PARROT_INLINE_OP, */
+ "does",
+ "does_i_p_s",
+ "Parrot_does_i_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 702 */
+ /* type PARROT_INLINE_OP, */
+ "does",
+ "does_i_p_sc",
+ "Parrot_does_i_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 703 */
+ /* type PARROT_INLINE_OP, */
+ "does",
+ "does_i_p_p",
+ "Parrot_does_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 704 */
+ /* type PARROT_INLINE_OP, */
+ "does",
+ "does_i_p_pc",
+ "Parrot_does_i_p_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 705 */
+ /* type PARROT_INLINE_OP, */
+ "isa",
+ "isa_i_p_s",
+ "Parrot_isa_i_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 706 */
+ /* type PARROT_INLINE_OP, */
+ "isa",
+ "isa_i_p_sc",
+ "Parrot_isa_i_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 707 */
+ /* type PARROT_INLINE_OP, */
+ "isa",
+ "isa_i_p_p",
+ "Parrot_isa_i_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 708 */
+ /* type PARROT_INLINE_OP, */
+ "isa",
+ "isa_i_p_pc",
+ "Parrot_isa_i_p_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 709 */
+ /* type PARROT_INLINE_OP, */
+ "newclass",
+ "newclass_p_s",
+ "Parrot_newclass_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 710 */
+ /* type PARROT_INLINE_OP, */
+ "newclass",
+ "newclass_p_sc",
+ "Parrot_newclass_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 711 */
+ /* type PARROT_INLINE_OP, */
+ "newclass",
+ "newclass_p_p",
+ "Parrot_newclass_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 712 */
+ /* type PARROT_INLINE_OP, */
+ "newclass",
+ "newclass_p_pc",
+ "Parrot_newclass_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 713 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_p",
+ "Parrot_subclass_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 714 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_pc",
+ "Parrot_subclass_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 715 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_p_s",
+ "Parrot_subclass_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 716 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_pc_s",
+ "Parrot_subclass_p_pc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 717 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_p_sc",
+ "Parrot_subclass_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 718 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_pc_sc",
+ "Parrot_subclass_p_pc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 719 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_p_p",
+ "Parrot_subclass_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 720 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_pc_p",
+ "Parrot_subclass_p_pc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 721 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_p_pc",
+ "Parrot_subclass_p_p_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 722 */
+ /* type PARROT_INLINE_OP, */
+ "subclass",
+ "subclass_p_pc_pc",
+ "Parrot_subclass_p_pc_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 723 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_s",
+ "Parrot_subclass_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 724 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_sc",
+ "Parrot_subclass_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 725 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_s_s",
+ "Parrot_subclass_p_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 726 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_sc_s",
+ "Parrot_subclass_p_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 727 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_s_sc",
+ "Parrot_subclass_p_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 728 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_sc_sc",
+ "Parrot_subclass_p_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 729 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_s_p",
+ "Parrot_subclass_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 730 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_sc_p",
+ "Parrot_subclass_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 731 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_s_pc",
+ "Parrot_subclass_p_s_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 732 */
+ /* type PARROT_FUNCTION_OP, */
+ "subclass",
+ "subclass_p_sc_pc",
+ "Parrot_subclass_p_sc_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 733 */
+ /* type PARROT_INLINE_OP, */
+ "get_class",
+ "get_class_p_s",
+ "Parrot_get_class_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 734 */
+ /* type PARROT_INLINE_OP, */
+ "get_class",
+ "get_class_p_sc",
+ "Parrot_get_class_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 735 */
+ /* type PARROT_INLINE_OP, */
+ "get_class",
+ "get_class_p_p",
+ "Parrot_get_class_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 736 */
+ /* type PARROT_INLINE_OP, */
+ "get_class",
+ "get_class_p_pc",
+ "Parrot_get_class_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 737 */
+ /* type PARROT_INLINE_OP, */
+ "class",
+ "class_p_p",
+ "Parrot_class_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 738 */
+ /* type PARROT_INLINE_OP, */
+ "addparent",
+ "addparent_p_p",
+ "Parrot_addparent_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 739 */
+ /* type PARROT_INLINE_OP, */
+ "removeparent",
+ "removeparent_p_p",
+ "Parrot_removeparent_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 740 */
+ /* type PARROT_INLINE_OP, */
+ "addrole",
+ "addrole_p_p",
+ "Parrot_addrole_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 741 */
+ /* type PARROT_INLINE_OP, */
+ "addattribute",
+ "addattribute_p_s",
+ "Parrot_addattribute_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 742 */
+ /* type PARROT_INLINE_OP, */
+ "addattribute",
+ "addattribute_p_sc",
+ "Parrot_addattribute_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 743 */
+ /* type PARROT_FUNCTION_OP, */
+ "removeattribute",
+ "removeattribute_p_s",
+ "Parrot_removeattribute_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 744 */
+ /* type PARROT_FUNCTION_OP, */
+ "removeattribute",
+ "removeattribute_p_sc",
+ "Parrot_removeattribute_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 745 */
+ /* type PARROT_INLINE_OP, */
+ "getattribute",
+ "getattribute_p_p_s",
+ "Parrot_getattribute_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 746 */
+ /* type PARROT_INLINE_OP, */
+ "getattribute",
+ "getattribute_p_p_sc",
+ "Parrot_getattribute_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 747 */
+ /* type PARROT_INLINE_OP, */
+ "getattribute",
+ "getattribute_p_p_p_s",
+ "Parrot_getattribute_p_p_p_s",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 748 */
+ /* type PARROT_INLINE_OP, */
+ "getattribute",
+ "getattribute_p_p_pc_s",
+ "Parrot_getattribute_p_p_pc_s",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 749 */
+ /* type PARROT_INLINE_OP, */
+ "getattribute",
+ "getattribute_p_p_p_sc",
+ "Parrot_getattribute_p_p_p_sc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 750 */
+ /* type PARROT_INLINE_OP, */
+ "getattribute",
+ "getattribute_p_p_pc_sc",
+ "Parrot_getattribute_p_p_pc_sc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 751 */
+ /* type PARROT_INLINE_OP, */
+ "setattribute",
+ "setattribute_p_s_p",
+ "Parrot_setattribute_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 752 */
+ /* type PARROT_INLINE_OP, */
+ "setattribute",
+ "setattribute_p_sc_p",
+ "Parrot_setattribute_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 753 */
+ /* type PARROT_INLINE_OP, */
+ "setattribute",
+ "setattribute_p_p_s_p",
+ "Parrot_setattribute_p_p_s_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 754 */
+ /* type PARROT_INLINE_OP, */
+ "setattribute",
+ "setattribute_p_pc_s_p",
+ "Parrot_setattribute_p_pc_s_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 755 */
+ /* type PARROT_INLINE_OP, */
+ "setattribute",
+ "setattribute_p_p_sc_p",
+ "Parrot_setattribute_p_p_sc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 756 */
+ /* type PARROT_INLINE_OP, */
+ "setattribute",
+ "setattribute_p_pc_sc_p",
+ "Parrot_setattribute_p_pc_sc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 757 */
+ /* type PARROT_INLINE_OP, */
+ "inspect",
+ "inspect_p_p",
+ "Parrot_inspect_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 758 */
+ /* type PARROT_INLINE_OP, */
+ "inspect",
+ "inspect_p_pc",
+ "Parrot_inspect_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 759 */
+ /* type PARROT_INLINE_OP, */
+ "inspect",
+ "inspect_p_p_s",
+ "Parrot_inspect_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 760 */
+ /* type PARROT_INLINE_OP, */
+ "inspect",
+ "inspect_p_pc_s",
+ "Parrot_inspect_p_pc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 761 */
+ /* type PARROT_INLINE_OP, */
+ "inspect",
+ "inspect_p_p_sc",
+ "Parrot_inspect_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 762 */
+ /* type PARROT_INLINE_OP, */
+ "inspect",
+ "inspect_p_pc_sc",
+ "Parrot_inspect_p_pc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 763 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_s",
+ "Parrot_new_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 764 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_sc",
+ "Parrot_new_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 765 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_s_p",
+ "Parrot_new_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 766 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_sc_p",
+ "Parrot_new_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 767 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_s_pc",
+ "Parrot_new_p_s_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 768 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_sc_pc",
+ "Parrot_new_p_sc_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 769 */
+ /* type PARROT_INLINE_OP, */
+ "new",
+ "new_p_p",
+ "Parrot_new_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 770 */
+ /* type PARROT_INLINE_OP, */
+ "new",
+ "new_p_pc",
+ "Parrot_new_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 771 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_p_p",
+ "Parrot_new_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 772 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_pc_p",
+ "Parrot_new_p_pc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 773 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_p_pc",
+ "Parrot_new_p_p_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 774 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_pc_pc",
+ "Parrot_new_p_pc_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 775 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_p",
+ "Parrot_root_new_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 776 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_pc",
+ "Parrot_root_new_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 777 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_p_p",
+ "Parrot_root_new_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 778 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_pc_p",
+ "Parrot_root_new_p_pc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 779 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_p_pc",
+ "Parrot_root_new_p_p_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 780 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_pc_pc",
+ "Parrot_root_new_p_pc_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 781 */
+ /* type PARROT_INLINE_OP, */
+ "typeof",
+ "typeof_s_p",
+ "Parrot_typeof_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 782 */
+ /* type PARROT_INLINE_OP, */
+ "typeof",
+ "typeof_p_p",
+ "Parrot_typeof_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 783 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_repr",
+ "get_repr_s_p",
+ "Parrot_get_repr_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 784 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_method",
+ "find_method_p_p_s",
+ "Parrot_find_method_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 785 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_method",
+ "find_method_p_p_sc",
+ "Parrot_find_method_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 786 */
+ /* type PARROT_INLINE_OP, */
+ "defined",
+ "defined_i_p",
+ "Parrot_defined_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 787 */
+ /* type PARROT_INLINE_OP, */
+ "defined",
+ "defined_i_p_ki",
+ "Parrot_defined_i_p_ki",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 788 */
+ /* type PARROT_INLINE_OP, */
+ "defined",
+ "defined_i_p_kic",
+ "Parrot_defined_i_p_kic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 789 */
+ /* type PARROT_INLINE_OP, */
+ "defined",
+ "defined_i_p_k",
+ "Parrot_defined_i_p_k",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 790 */
+ /* type PARROT_INLINE_OP, */
+ "defined",
+ "defined_i_p_kc",
+ "Parrot_defined_i_p_kc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 791 */
+ /* type PARROT_INLINE_OP, */
+ "exists",
+ "exists_i_p_ki",
+ "Parrot_exists_i_p_ki",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 792 */
+ /* type PARROT_INLINE_OP, */
+ "exists",
+ "exists_i_p_kic",
+ "Parrot_exists_i_p_kic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 793 */
+ /* type PARROT_INLINE_OP, */
+ "exists",
+ "exists_i_p_k",
+ "Parrot_exists_i_p_k",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 794 */
+ /* type PARROT_INLINE_OP, */
+ "exists",
+ "exists_i_p_kc",
+ "Parrot_exists_i_p_kc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 795 */
+ /* type PARROT_INLINE_OP, */
+ "delete",
+ "delete_p_k",
+ "Parrot_delete_p_k",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 796 */
+ /* type PARROT_INLINE_OP, */
+ "delete",
+ "delete_p_kc",
+ "Parrot_delete_p_kc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 797 */
+ /* type PARROT_INLINE_OP, */
+ "delete",
+ "delete_p_ki",
+ "Parrot_delete_p_ki",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 798 */
+ /* type PARROT_INLINE_OP, */
+ "delete",
+ "delete_p_kic",
+ "Parrot_delete_p_kic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 799 */
+ /* type PARROT_INLINE_OP, */
+ "elements",
+ "elements_i_p",
+ "Parrot_elements_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 800 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_i",
+ "Parrot_push_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 801 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_ic",
+ "Parrot_push_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 802 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_n",
+ "Parrot_push_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 803 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_nc",
+ "Parrot_push_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 804 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_s",
+ "Parrot_push_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 805 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_sc",
+ "Parrot_push_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 806 */
+ /* type PARROT_INLINE_OP, */
+ "push",
+ "push_p_p",
+ "Parrot_push_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 807 */
+ /* type PARROT_INLINE_OP, */
+ "pop",
+ "pop_i_p",
+ "Parrot_pop_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 808 */
+ /* type PARROT_INLINE_OP, */
+ "pop",
+ "pop_n_p",
+ "Parrot_pop_n_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 809 */
+ /* type PARROT_INLINE_OP, */
+ "pop",
+ "pop_s_p",
+ "Parrot_pop_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 810 */
+ /* type PARROT_INLINE_OP, */
+ "pop",
+ "pop_p_p",
+ "Parrot_pop_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 811 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_i",
+ "Parrot_unshift_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 812 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_ic",
+ "Parrot_unshift_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 813 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_n",
+ "Parrot_unshift_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 814 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_nc",
+ "Parrot_unshift_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 815 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_s",
+ "Parrot_unshift_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 816 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_sc",
+ "Parrot_unshift_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 817 */
+ /* type PARROT_INLINE_OP, */
+ "unshift",
+ "unshift_p_p",
+ "Parrot_unshift_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 818 */
+ /* type PARROT_INLINE_OP, */
+ "shift",
+ "shift_i_p",
+ "Parrot_shift_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 819 */
+ /* type PARROT_INLINE_OP, */
+ "shift",
+ "shift_n_p",
+ "Parrot_shift_n_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 820 */
+ /* type PARROT_INLINE_OP, */
+ "shift",
+ "shift_s_p",
+ "Parrot_shift_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 821 */
+ /* type PARROT_INLINE_OP, */
+ "shift",
+ "shift_p_p",
+ "Parrot_shift_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 822 */
+ /* type PARROT_INLINE_OP, */
+ "splice",
+ "splice_p_p_i_i",
+ "Parrot_splice_p_p_i_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 823 */
+ /* type PARROT_INLINE_OP, */
+ "splice",
+ "splice_p_p_ic_i",
+ "Parrot_splice_p_p_ic_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 824 */
+ /* type PARROT_INLINE_OP, */
+ "splice",
+ "splice_p_p_i_ic",
+ "Parrot_splice_p_p_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 825 */
+ /* type PARROT_INLINE_OP, */
+ "splice",
+ "splice_p_p_ic_ic",
+ "Parrot_splice_p_p_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 826 */
+ /* type PARROT_FUNCTION_OP, */
+ "setprop",
+ "setprop_p_s_p",
+ "Parrot_setprop_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 827 */
+ /* type PARROT_FUNCTION_OP, */
+ "setprop",
+ "setprop_p_sc_p",
+ "Parrot_setprop_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 828 */
+ /* type PARROT_FUNCTION_OP, */
+ "getprop",
+ "getprop_p_s_p",
+ "Parrot_getprop_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 829 */
+ /* type PARROT_FUNCTION_OP, */
+ "getprop",
+ "getprop_p_sc_p",
+ "Parrot_getprop_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 830 */
+ /* type PARROT_FUNCTION_OP, */
+ "delprop",
+ "delprop_p_s",
+ "Parrot_delprop_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 831 */
+ /* type PARROT_FUNCTION_OP, */
+ "delprop",
+ "delprop_p_sc",
+ "Parrot_delprop_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 832 */
+ /* type PARROT_FUNCTION_OP, */
+ "prophash",
+ "prophash_p_p",
+ "Parrot_prophash_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 833 */
+ /* type PARROT_FUNCTION_OP, */
+ "freeze",
+ "freeze_s_p",
+ "Parrot_freeze_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 834 */
+ /* type PARROT_FUNCTION_OP, */
+ "thaw",
+ "thaw_p_s",
+ "Parrot_thaw_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 835 */
+ /* type PARROT_FUNCTION_OP, */
+ "thaw",
+ "thaw_p_sc",
+ "Parrot_thaw_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 836 */
+ /* type PARROT_INLINE_OP, */
+ "add_multi",
+ "add_multi_s_s_p",
+ "Parrot_add_multi_s_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 837 */
+ /* type PARROT_INLINE_OP, */
+ "add_multi",
+ "add_multi_sc_s_p",
+ "Parrot_add_multi_sc_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 838 */
+ /* type PARROT_INLINE_OP, */
+ "add_multi",
+ "add_multi_s_sc_p",
+ "Parrot_add_multi_s_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 839 */
+ /* type PARROT_INLINE_OP, */
+ "add_multi",
+ "add_multi_sc_sc_p",
+ "Parrot_add_multi_sc_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_SC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 840 */
+ /* type PARROT_INLINE_OP, */
+ "find_multi",
+ "find_multi_p_s_s",
+ "Parrot_find_multi_p_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 841 */
+ /* type PARROT_INLINE_OP, */
+ "find_multi",
+ "find_multi_p_sc_s",
+ "Parrot_find_multi_p_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 842 */
+ /* type PARROT_INLINE_OP, */
+ "find_multi",
+ "find_multi_p_s_sc",
+ "Parrot_find_multi_p_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 843 */
+ /* type PARROT_INLINE_OP, */
+ "find_multi",
+ "find_multi_p_sc_sc",
+ "Parrot_find_multi_p_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 844 */
+ /* type PARROT_FUNCTION_OP, */
+ "register",
+ "register_p",
+ "Parrot_register_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 845 */
+ /* type PARROT_FUNCTION_OP, */
+ "unregister",
+ "unregister_p",
+ "Parrot_unregister_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 846 */
+ /* type PARROT_FUNCTION_OP, */
+ "box",
+ "box_p_i",
+ "Parrot_box_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 847 */
+ /* type PARROT_FUNCTION_OP, */
+ "box",
+ "box_p_ic",
+ "Parrot_box_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 848 */
+ /* type PARROT_FUNCTION_OP, */
+ "box",
+ "box_p_n",
+ "Parrot_box_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 849 */
+ /* type PARROT_FUNCTION_OP, */
+ "box",
+ "box_p_nc",
+ "Parrot_box_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 850 */
+ /* type PARROT_FUNCTION_OP, */
+ "box",
+ "box_p_s",
+ "Parrot_box_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 851 */
+ /* type PARROT_FUNCTION_OP, */
+ "box",
+ "box_p_sc",
+ "Parrot_box_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 852 */
+ /* type PARROT_INLINE_OP, */
+ "iter",
+ "iter_p_p",
+ "Parrot_iter_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 853 */
+ /* type PARROT_INLINE_OP, */
+ "morph",
+ "morph_p_p",
+ "Parrot_morph_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 854 */
+ /* type PARROT_INLINE_OP, */
+ "morph",
+ "morph_p_pc",
+ "Parrot_morph_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 855 */
+ /* type PARROT_INLINE_OP, */
+ "clone",
+ "clone_s_s",
+ "Parrot_clone_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 856 */
+ /* type PARROT_INLINE_OP, */
+ "clone",
+ "clone_s_sc",
+ "Parrot_clone_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 857 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_i",
+ "Parrot_set_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 858 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_ic",
+ "Parrot_set_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 859 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_n",
+ "Parrot_set_i_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 860 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_nc",
+ "Parrot_set_i_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 861 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_s",
+ "Parrot_set_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 862 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_sc",
+ "Parrot_set_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 863 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_n",
+ "Parrot_set_n_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 864 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_nc",
+ "Parrot_set_n_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 865 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_i",
+ "Parrot_set_n_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 866 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_ic",
+ "Parrot_set_n_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 867 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_s",
+ "Parrot_set_n_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 868 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_sc",
+ "Parrot_set_n_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 869 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_p",
+ "Parrot_set_n_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_N, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 870 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_p",
+ "Parrot_set_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 871 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_s",
+ "Parrot_set_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 872 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_sc",
+ "Parrot_set_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 873 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_i",
+ "Parrot_set_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 874 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_ic",
+ "Parrot_set_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 875 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_n",
+ "Parrot_set_s_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 876 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_nc",
+ "Parrot_set_s_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_NC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 877 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_pc",
+ "Parrot_set_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 878 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_p",
+ "Parrot_set_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 879 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_i",
+ "Parrot_set_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 880 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ic",
+ "Parrot_set_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 881 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_n",
+ "Parrot_set_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 882 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_nc",
+ "Parrot_set_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 883 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_s",
+ "Parrot_set_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 884 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_sc",
+ "Parrot_set_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 885 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_p",
+ "Parrot_set_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 886 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_p",
+ "Parrot_assign_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 887 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_i",
+ "Parrot_assign_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 888 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_ic",
+ "Parrot_assign_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 889 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_n",
+ "Parrot_assign_p_n",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 890 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_nc",
+ "Parrot_assign_p_nc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 891 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_s",
+ "Parrot_assign_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 892 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_p_sc",
+ "Parrot_assign_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 893 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_s_s",
+ "Parrot_assign_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 894 */
+ /* type PARROT_INLINE_OP, */
+ "assign",
+ "assign_s_sc",
+ "Parrot_assign_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 895 */
+ /* type PARROT_INLINE_OP, */
+ "setref",
+ "setref_p_p",
+ "Parrot_setref_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 896 */
+ /* type PARROT_INLINE_OP, */
+ "deref",
+ "deref_p_p",
+ "Parrot_deref_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 897 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_i",
+ "Parrot_set_p_ki_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 898 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_i",
+ "Parrot_set_p_kic_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 899 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_ic",
+ "Parrot_set_p_ki_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 900 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_ic",
+ "Parrot_set_p_kic_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 901 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_n",
+ "Parrot_set_p_ki_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 902 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_n",
+ "Parrot_set_p_kic_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 903 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_nc",
+ "Parrot_set_p_ki_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 904 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_nc",
+ "Parrot_set_p_kic_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 905 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_s",
+ "Parrot_set_p_ki_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 906 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_s",
+ "Parrot_set_p_kic_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 907 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_sc",
+ "Parrot_set_p_ki_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 908 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_sc",
+ "Parrot_set_p_kic_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 909 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_ki_p",
+ "Parrot_set_p_ki_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KI, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 910 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kic_p",
+ "Parrot_set_p_kic_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KIC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 911 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_p_ki",
+ "Parrot_set_i_p_ki",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 912 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_p_kic",
+ "Parrot_set_i_p_kic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 913 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_p_ki",
+ "Parrot_set_n_p_ki",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 914 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_p_kic",
+ "Parrot_set_n_p_kic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 915 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_p_ki",
+ "Parrot_set_s_p_ki",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 916 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_p_kic",
+ "Parrot_set_s_p_kic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 917 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_p_ki",
+ "Parrot_set_p_p_ki",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_KI },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 918 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_p_kic",
+ "Parrot_set_p_p_kic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_KIC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 919 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_i",
+ "Parrot_set_p_k_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 920 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_i",
+ "Parrot_set_p_kc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 921 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_ic",
+ "Parrot_set_p_k_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 922 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_ic",
+ "Parrot_set_p_kc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 923 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_n",
+ "Parrot_set_p_k_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 924 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_n",
+ "Parrot_set_p_kc_n",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_N },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 925 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_nc",
+ "Parrot_set_p_k_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 926 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_nc",
+ "Parrot_set_p_kc_nc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 927 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_s",
+ "Parrot_set_p_k_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 928 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_s",
+ "Parrot_set_p_kc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 929 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_sc",
+ "Parrot_set_p_k_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 930 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_sc",
+ "Parrot_set_p_kc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 931 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_k_p",
+ "Parrot_set_p_k_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_K, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 932 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_kc_p",
+ "Parrot_set_p_kc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_KC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 933 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_p_k",
+ "Parrot_set_i_p_k",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 934 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_i_p_kc",
+ "Parrot_set_i_p_kc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 935 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_p_k",
+ "Parrot_set_n_p_k",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 936 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_n_p_kc",
+ "Parrot_set_n_p_kc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_N, PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 937 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_p_k",
+ "Parrot_set_s_p_k",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 938 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_s_p_kc",
+ "Parrot_set_s_p_kc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 939 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_p_k",
+ "Parrot_set_p_p_k",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_K },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 940 */
+ /* type PARROT_INLINE_OP, */
+ "set",
+ "set_p_p_kc",
+ "Parrot_set_p_p_kc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_KC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 941 */
+ /* type PARROT_INLINE_OP, */
+ "clone",
+ "clone_p_p",
+ "Parrot_clone_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 942 */
+ /* type PARROT_INLINE_OP, */
+ "clone",
+ "clone_p_p_p",
+ "Parrot_clone_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 943 */
+ /* type PARROT_INLINE_OP, */
+ "clone",
+ "clone_p_p_pc",
+ "Parrot_clone_p_p_pc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 944 */
+ /* type PARROT_INLINE_OP, */
+ "copy",
+ "copy_p_p",
+ "Parrot_copy_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 945 */
+ /* type PARROT_INLINE_OP, */
+ "null",
+ "null_s",
+ "Parrot_null_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 946 */
+ /* type PARROT_INLINE_OP, */
+ "null",
+ "null_i",
+ "Parrot_null_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 947 */
+ /* type PARROT_INLINE_OP, */
+ "null",
+ "null_p",
+ "Parrot_null_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 948 */
+ /* type PARROT_INLINE_OP, */
+ "null",
+ "null_n",
+ "Parrot_null_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 949 */
+ /* type PARROT_INLINE_OP, */
+ "ord",
+ "ord_i_s",
+ "Parrot_ord_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 950 */
+ /* type PARROT_INLINE_OP, */
+ "ord",
+ "ord_i_sc",
+ "Parrot_ord_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 951 */
+ /* type PARROT_INLINE_OP, */
+ "ord",
+ "ord_i_s_i",
+ "Parrot_ord_i_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 952 */
+ /* type PARROT_INLINE_OP, */
+ "ord",
+ "ord_i_sc_i",
+ "Parrot_ord_i_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 953 */
+ /* type PARROT_INLINE_OP, */
+ "ord",
+ "ord_i_s_ic",
+ "Parrot_ord_i_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 954 */
+ /* type PARROT_INLINE_OP, */
+ "ord",
+ "ord_i_sc_ic",
+ "Parrot_ord_i_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 955 */
+ /* type PARROT_INLINE_OP, */
+ "chr",
+ "chr_s_i",
+ "Parrot_chr_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 956 */
+ /* type PARROT_INLINE_OP, */
+ "chr",
+ "chr_s_ic",
+ "Parrot_chr_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 957 */
+ /* type PARROT_INLINE_OP, */
+ "chopn",
+ "chopn_s_s_i",
+ "Parrot_chopn_s_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 958 */
+ /* type PARROT_INLINE_OP, */
+ "chopn",
+ "chopn_s_sc_i",
+ "Parrot_chopn_s_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 959 */
+ /* type PARROT_INLINE_OP, */
+ "chopn",
+ "chopn_s_s_ic",
+ "Parrot_chopn_s_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 960 */
+ /* type PARROT_INLINE_OP, */
+ "chopn",
+ "chopn_s_sc_ic",
+ "Parrot_chopn_s_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 961 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_s_s",
+ "Parrot_concat_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 962 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_s_sc",
+ "Parrot_concat_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_INOUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 963 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_p_p",
+ "Parrot_concat_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 964 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_p_s",
+ "Parrot_concat_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 965 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_p_sc",
+ "Parrot_concat_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 966 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_s_s_s",
+ "Parrot_concat_s_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 967 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_s_sc_s",
+ "Parrot_concat_s_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 968 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_s_s_sc",
+ "Parrot_concat_s_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 969 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_p_p_s",
+ "Parrot_concat_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 970 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_p_p_sc",
+ "Parrot_concat_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 971 */
+ /* type PARROT_INLINE_OP, */
+ "concat",
+ "concat_p_p_p",
+ "Parrot_concat_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 972 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_s_s_i",
+ "Parrot_repeat_s_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 973 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_s_sc_i",
+ "Parrot_repeat_s_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 974 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_s_s_ic",
+ "Parrot_repeat_s_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 975 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_s_sc_ic",
+ "Parrot_repeat_s_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 976 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_p_p_i",
+ "Parrot_repeat_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 977 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_p_p_ic",
+ "Parrot_repeat_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 978 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_p_p_p",
+ "Parrot_repeat_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 979 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_p_i",
+ "Parrot_repeat_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 980 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_p_ic",
+ "Parrot_repeat_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 981 */
+ /* type PARROT_INLINE_OP, */
+ "repeat",
+ "repeat_p_p",
+ "Parrot_repeat_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 982 */
+ /* type PARROT_INLINE_OP, */
+ "length",
+ "length_i_s",
+ "Parrot_length_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 983 */
+ /* type PARROT_INLINE_OP, */
+ "length",
+ "length_i_sc",
+ "Parrot_length_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 984 */
+ /* type PARROT_INLINE_OP, */
+ "bytelength",
+ "bytelength_i_s",
+ "Parrot_bytelength_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 985 */
+ /* type PARROT_INLINE_OP, */
+ "bytelength",
+ "bytelength_i_sc",
+ "Parrot_bytelength_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 986 */
+ /* type PARROT_FUNCTION_OP, */
+ "pin",
+ "pin_s",
+ "Parrot_pin_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 987 */
+ /* type PARROT_FUNCTION_OP, */
+ "unpin",
+ "unpin_s",
+ "Parrot_unpin_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_INOUT },
+ { 0 }
+ },
+ { /* 988 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_s_i",
+ "Parrot_substr_s_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 989 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_sc_i",
+ "Parrot_substr_s_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 990 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_s_ic",
+ "Parrot_substr_s_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 991 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_sc_ic",
+ "Parrot_substr_s_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 992 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_s_i_i",
+ "Parrot_substr_s_s_i_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 993 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_sc_i_i",
+ "Parrot_substr_s_sc_i_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 994 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_s_ic_i",
+ "Parrot_substr_s_s_ic_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 995 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_sc_ic_i",
+ "Parrot_substr_s_sc_ic_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 996 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_s_i_ic",
+ "Parrot_substr_s_s_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 997 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_sc_i_ic",
+ "Parrot_substr_s_sc_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 998 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_s_ic_ic",
+ "Parrot_substr_s_s_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 999 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_sc_ic_ic",
+ "Parrot_substr_s_sc_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1000 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_p_i_i",
+ "Parrot_substr_s_p_i_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1001 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_p_ic_i",
+ "Parrot_substr_s_p_ic_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1002 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_p_i_ic",
+ "Parrot_substr_s_p_i_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1003 */
+ /* type PARROT_INLINE_OP, */
+ "substr",
+ "substr_s_p_ic_ic",
+ "Parrot_substr_s_p_ic_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_S, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1004 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_i_i_s",
+ "Parrot_replace_s_s_i_i_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1005 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_i_i_s",
+ "Parrot_replace_s_sc_i_i_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1006 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_ic_i_s",
+ "Parrot_replace_s_s_ic_i_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1007 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_ic_i_s",
+ "Parrot_replace_s_sc_ic_i_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1008 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_i_ic_s",
+ "Parrot_replace_s_s_i_ic_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1009 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_i_ic_s",
+ "Parrot_replace_s_sc_i_ic_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1010 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_ic_ic_s",
+ "Parrot_replace_s_s_ic_ic_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1011 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_ic_ic_s",
+ "Parrot_replace_s_sc_ic_ic_s",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1012 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_i_i_sc",
+ "Parrot_replace_s_s_i_i_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1013 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_i_i_sc",
+ "Parrot_replace_s_sc_i_i_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1014 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_ic_i_sc",
+ "Parrot_replace_s_s_ic_i_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1015 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_ic_i_sc",
+ "Parrot_replace_s_sc_ic_i_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1016 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_i_ic_sc",
+ "Parrot_replace_s_s_i_ic_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1017 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_i_ic_sc",
+ "Parrot_replace_s_sc_i_ic_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1018 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_s_ic_ic_sc",
+ "Parrot_replace_s_s_ic_ic_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1019 */
+ /* type PARROT_INLINE_OP, */
+ "replace",
+ "replace_s_sc_ic_ic_sc",
+ "Parrot_replace_s_sc_ic_ic_sc",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1020 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_s_s",
+ "Parrot_index_i_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1021 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_sc_s",
+ "Parrot_index_i_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1022 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_s_sc",
+ "Parrot_index_i_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1023 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_sc_sc",
+ "Parrot_index_i_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1024 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_s_s_i",
+ "Parrot_index_i_s_s_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1025 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_sc_s_i",
+ "Parrot_index_i_sc_s_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1026 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_s_sc_i",
+ "Parrot_index_i_s_sc_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1027 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_sc_sc_i",
+ "Parrot_index_i_sc_sc_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1028 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_s_s_ic",
+ "Parrot_index_i_s_s_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1029 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_sc_s_ic",
+ "Parrot_index_i_sc_s_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1030 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_s_sc_ic",
+ "Parrot_index_i_s_sc_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1031 */
+ /* type PARROT_INLINE_OP, */
+ "index",
+ "index_i_sc_sc_ic",
+ "Parrot_index_i_sc_sc_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1032 */
+ /* type PARROT_INLINE_OP, */
+ "sprintf",
+ "sprintf_s_s_p",
+ "Parrot_sprintf_s_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1033 */
+ /* type PARROT_INLINE_OP, */
+ "sprintf",
+ "sprintf_s_sc_p",
+ "Parrot_sprintf_s_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1034 */
+ /* type PARROT_INLINE_OP, */
+ "sprintf",
+ "sprintf_p_p_p",
+ "Parrot_sprintf_p_p_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1035 */
+ /* type PARROT_INLINE_OP, */
+ "new",
+ "new_s",
+ "Parrot_new_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1036 */
+ /* type PARROT_INLINE_OP, */
+ "new",
+ "new_s_i",
+ "Parrot_new_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1037 */
+ /* type PARROT_INLINE_OP, */
+ "new",
+ "new_s_ic",
+ "Parrot_new_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1038 */
+ /* type PARROT_INLINE_OP, */
+ "stringinfo",
+ "stringinfo_i_s_i",
+ "Parrot_stringinfo_i_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1039 */
+ /* type PARROT_INLINE_OP, */
+ "stringinfo",
+ "stringinfo_i_sc_i",
+ "Parrot_stringinfo_i_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1040 */
+ /* type PARROT_INLINE_OP, */
+ "stringinfo",
+ "stringinfo_i_s_ic",
+ "Parrot_stringinfo_i_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1041 */
+ /* type PARROT_INLINE_OP, */
+ "stringinfo",
+ "stringinfo_i_sc_ic",
+ "Parrot_stringinfo_i_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1042 */
+ /* type PARROT_INLINE_OP, */
+ "upcase",
+ "upcase_s_s",
+ "Parrot_upcase_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1043 */
+ /* type PARROT_INLINE_OP, */
+ "upcase",
+ "upcase_s_sc",
+ "Parrot_upcase_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1044 */
+ /* type PARROT_INLINE_OP, */
+ "downcase",
+ "downcase_s_s",
+ "Parrot_downcase_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1045 */
+ /* type PARROT_INLINE_OP, */
+ "downcase",
+ "downcase_s_sc",
+ "Parrot_downcase_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1046 */
+ /* type PARROT_INLINE_OP, */
+ "titlecase",
+ "titlecase_s_s",
+ "Parrot_titlecase_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1047 */
+ /* type PARROT_INLINE_OP, */
+ "titlecase",
+ "titlecase_s_sc",
+ "Parrot_titlecase_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1048 */
+ /* type PARROT_FUNCTION_OP, */
+ "join",
+ "join_s_s_p",
+ "Parrot_join_s_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1049 */
+ /* type PARROT_FUNCTION_OP, */
+ "join",
+ "join_s_sc_p",
+ "Parrot_join_s_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1050 */
+ /* type PARROT_FUNCTION_OP, */
+ "split",
+ "split_p_s_s",
+ "Parrot_split_p_s_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1051 */
+ /* type PARROT_FUNCTION_OP, */
+ "split",
+ "split_p_sc_s",
+ "Parrot_split_p_sc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1052 */
+ /* type PARROT_FUNCTION_OP, */
+ "split",
+ "split_p_s_sc",
+ "Parrot_split_p_s_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1053 */
+ /* type PARROT_FUNCTION_OP, */
+ "split",
+ "split_p_sc_sc",
+ "Parrot_split_p_sc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1054 */
+ /* type PARROT_FUNCTION_OP, */
+ "charset",
+ "charset_i_s",
+ "Parrot_charset_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1055 */
+ /* type PARROT_FUNCTION_OP, */
+ "charset",
+ "charset_i_sc",
+ "Parrot_charset_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1056 */
+ /* type PARROT_FUNCTION_OP, */
+ "charsetname",
+ "charsetname_s_i",
+ "Parrot_charsetname_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1057 */
+ /* type PARROT_FUNCTION_OP, */
+ "charsetname",
+ "charsetname_s_ic",
+ "Parrot_charsetname_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1058 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_charset",
+ "find_charset_i_s",
+ "Parrot_find_charset_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1059 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_charset",
+ "find_charset_i_sc",
+ "Parrot_find_charset_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1060 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_charset",
+ "trans_charset_s_s_i",
+ "Parrot_trans_charset_s_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1061 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_charset",
+ "trans_charset_s_sc_i",
+ "Parrot_trans_charset_s_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1062 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_charset",
+ "trans_charset_s_s_ic",
+ "Parrot_trans_charset_s_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1063 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_charset",
+ "trans_charset_s_sc_ic",
+ "Parrot_trans_charset_s_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1064 */
+ /* type PARROT_FUNCTION_OP, */
+ "encoding",
+ "encoding_i_s",
+ "Parrot_encoding_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1065 */
+ /* type PARROT_FUNCTION_OP, */
+ "encoding",
+ "encoding_i_sc",
+ "Parrot_encoding_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1066 */
+ /* type PARROT_FUNCTION_OP, */
+ "encodingname",
+ "encodingname_s_i",
+ "Parrot_encodingname_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1067 */
+ /* type PARROT_FUNCTION_OP, */
+ "encodingname",
+ "encodingname_s_ic",
+ "Parrot_encodingname_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1068 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_encoding",
+ "find_encoding_i_s",
+ "Parrot_find_encoding_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1069 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_encoding",
+ "find_encoding_i_sc",
+ "Parrot_find_encoding_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1070 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_encoding",
+ "trans_encoding_s_s_i",
+ "Parrot_trans_encoding_s_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1071 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_encoding",
+ "trans_encoding_s_sc_i",
+ "Parrot_trans_encoding_s_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1072 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_encoding",
+ "trans_encoding_s_s_ic",
+ "Parrot_trans_encoding_s_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1073 */
+ /* type PARROT_FUNCTION_OP, */
+ "trans_encoding",
+ "trans_encoding_s_sc_ic",
+ "Parrot_trans_encoding_s_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_S, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1074 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_i_s_i",
+ "Parrot_is_cclass_i_i_s_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1075 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_ic_s_i",
+ "Parrot_is_cclass_i_ic_s_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1076 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_i_sc_i",
+ "Parrot_is_cclass_i_i_sc_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1077 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_ic_sc_i",
+ "Parrot_is_cclass_i_ic_sc_i",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1078 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_i_s_ic",
+ "Parrot_is_cclass_i_i_s_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1079 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_ic_s_ic",
+ "Parrot_is_cclass_i_ic_s_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1080 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_i_sc_ic",
+ "Parrot_is_cclass_i_i_sc_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1081 */
+ /* type PARROT_INLINE_OP, */
+ "is_cclass",
+ "is_cclass_i_ic_sc_ic",
+ "Parrot_is_cclass_i_ic_sc_ic",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1082 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_s_i_i",
+ "Parrot_find_cclass_i_i_s_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1083 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_s_i_i",
+ "Parrot_find_cclass_i_ic_s_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1084 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_sc_i_i",
+ "Parrot_find_cclass_i_i_sc_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1085 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_sc_i_i",
+ "Parrot_find_cclass_i_ic_sc_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1086 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_s_ic_i",
+ "Parrot_find_cclass_i_i_s_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1087 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_s_ic_i",
+ "Parrot_find_cclass_i_ic_s_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1088 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_sc_ic_i",
+ "Parrot_find_cclass_i_i_sc_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1089 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_sc_ic_i",
+ "Parrot_find_cclass_i_ic_sc_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1090 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_s_i_ic",
+ "Parrot_find_cclass_i_i_s_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1091 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_s_i_ic",
+ "Parrot_find_cclass_i_ic_s_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1092 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_sc_i_ic",
+ "Parrot_find_cclass_i_i_sc_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1093 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_sc_i_ic",
+ "Parrot_find_cclass_i_ic_sc_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1094 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_s_ic_ic",
+ "Parrot_find_cclass_i_i_s_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1095 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_s_ic_ic",
+ "Parrot_find_cclass_i_ic_s_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1096 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_i_sc_ic_ic",
+ "Parrot_find_cclass_i_i_sc_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1097 */
+ /* type PARROT_INLINE_OP, */
+ "find_cclass",
+ "find_cclass_i_ic_sc_ic_ic",
+ "Parrot_find_cclass_i_ic_sc_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1098 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_s_i_i",
+ "Parrot_find_not_cclass_i_i_s_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1099 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_s_i_i",
+ "Parrot_find_not_cclass_i_ic_s_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1100 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_sc_i_i",
+ "Parrot_find_not_cclass_i_i_sc_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1101 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_sc_i_i",
+ "Parrot_find_not_cclass_i_ic_sc_i_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1102 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_s_ic_i",
+ "Parrot_find_not_cclass_i_i_s_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1103 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_s_ic_i",
+ "Parrot_find_not_cclass_i_ic_s_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1104 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_sc_ic_i",
+ "Parrot_find_not_cclass_i_i_sc_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1105 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_sc_ic_i",
+ "Parrot_find_not_cclass_i_ic_sc_ic_i",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1106 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_s_i_ic",
+ "Parrot_find_not_cclass_i_i_s_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1107 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_s_i_ic",
+ "Parrot_find_not_cclass_i_ic_s_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1108 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_sc_i_ic",
+ "Parrot_find_not_cclass_i_i_sc_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1109 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_sc_i_ic",
+ "Parrot_find_not_cclass_i_ic_sc_i_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1110 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_s_ic_ic",
+ "Parrot_find_not_cclass_i_i_s_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1111 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_s_ic_ic",
+ "Parrot_find_not_cclass_i_ic_s_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_S, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1112 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_i_sc_ic_ic",
+ "Parrot_find_not_cclass_i_i_sc_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_I, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1113 */
+ /* type PARROT_INLINE_OP, */
+ "find_not_cclass",
+ "find_not_cclass_i_ic_sc_ic_ic",
+ "Parrot_find_not_cclass_i_ic_sc_ic_ic",
+ /* "", body */
+ 0,
+ 6,
+ { PARROT_ARG_I, PARROT_ARG_IC, PARROT_ARG_SC, PARROT_ARG_IC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0, 0 }
+ },
+ { /* 1114 */
+ /* type PARROT_FUNCTION_OP, */
+ "escape",
+ "escape_s_s",
+ "Parrot_escape_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1115 */
+ /* type PARROT_FUNCTION_OP, */
+ "compose",
+ "compose_s_s",
+ "Parrot_compose_s_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1116 */
+ /* type PARROT_FUNCTION_OP, */
+ "compose",
+ "compose_s_sc",
+ "Parrot_compose_s_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1117 */
+ /* type PARROT_INLINE_OP, */
+ "spawnw",
+ "spawnw_i_s",
+ "Parrot_spawnw_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1118 */
+ /* type PARROT_INLINE_OP, */
+ "spawnw",
+ "spawnw_i_sc",
+ "Parrot_spawnw_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1119 */
+ /* type PARROT_INLINE_OP, */
+ "spawnw",
+ "spawnw_i_p",
+ "Parrot_spawnw_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1120 */
+ /* type PARROT_INLINE_OP, */
+ "err",
+ "err_i",
+ "Parrot_err_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1121 */
+ /* type PARROT_FUNCTION_OP, */
+ "err",
+ "err_s",
+ "Parrot_err_s",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1122 */
+ /* type PARROT_FUNCTION_OP, */
+ "err",
+ "err_s_i",
+ "Parrot_err_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1123 */
+ /* type PARROT_FUNCTION_OP, */
+ "err",
+ "err_s_ic",
+ "Parrot_err_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1124 */
+ /* type PARROT_INLINE_OP, */
+ "time",
+ "time_i",
+ "Parrot_time_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1125 */
+ /* type PARROT_INLINE_OP, */
+ "time",
+ "time_n",
+ "Parrot_time_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1126 */
+ /* type PARROT_FUNCTION_OP, */
+ "gmtime",
+ "gmtime_s_i",
+ "Parrot_gmtime_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1127 */
+ /* type PARROT_FUNCTION_OP, */
+ "gmtime",
+ "gmtime_s_ic",
+ "Parrot_gmtime_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1128 */
+ /* type PARROT_FUNCTION_OP, */
+ "localtime",
+ "localtime_s_i",
+ "Parrot_localtime_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1129 */
+ /* type PARROT_FUNCTION_OP, */
+ "localtime",
+ "localtime_s_ic",
+ "Parrot_localtime_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1130 */
+ /* type PARROT_FUNCTION_OP, */
+ "decodetime",
+ "decodetime_p_i",
+ "Parrot_decodetime_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1131 */
+ /* type PARROT_FUNCTION_OP, */
+ "decodetime",
+ "decodetime_p_ic",
+ "Parrot_decodetime_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1132 */
+ /* type PARROT_FUNCTION_OP, */
+ "decodelocaltime",
+ "decodelocaltime_p_i",
+ "Parrot_decodelocaltime_p_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1133 */
+ /* type PARROT_FUNCTION_OP, */
+ "decodelocaltime",
+ "decodelocaltime_p_ic",
+ "Parrot_decodelocaltime_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1134 */
+ /* type PARROT_INLINE_OP, */
+ "sysinfo",
+ "sysinfo_s_i",
+ "Parrot_sysinfo_s_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1135 */
+ /* type PARROT_INLINE_OP, */
+ "sysinfo",
+ "sysinfo_s_ic",
+ "Parrot_sysinfo_s_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1136 */
+ /* type PARROT_INLINE_OP, */
+ "sysinfo",
+ "sysinfo_i_i",
+ "Parrot_sysinfo_i_i",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1137 */
+ /* type PARROT_INLINE_OP, */
+ "sysinfo",
+ "sysinfo_i_ic",
+ "Parrot_sysinfo_i_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1138 */
+ /* type PARROT_INLINE_OP, */
+ "sleep",
+ "sleep_i",
+ "Parrot_sleep_i",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_I },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 1139 */
+ /* type PARROT_INLINE_OP, */
+ "sleep",
+ "sleep_ic",
+ "Parrot_sleep_ic",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 1140 */
+ /* type PARROT_INLINE_OP, */
+ "sleep",
+ "sleep_n",
+ "Parrot_sleep_n",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_N },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 1141 */
+ /* type PARROT_INLINE_OP, */
+ "sleep",
+ "sleep_nc",
+ "Parrot_sleep_nc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_NC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 1142 */
+ /* type PARROT_FUNCTION_OP, */
+ "store_lex",
+ "store_lex_s_p",
+ "Parrot_store_lex_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1143 */
+ /* type PARROT_FUNCTION_OP, */
+ "store_lex",
+ "store_lex_sc_p",
+ "Parrot_store_lex_sc_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1144 */
+ /* type PARROT_FUNCTION_OP, */
+ "store_dynamic_lex",
+ "store_dynamic_lex_s_p",
+ "Parrot_store_dynamic_lex_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1145 */
+ /* type PARROT_FUNCTION_OP, */
+ "store_dynamic_lex",
+ "store_dynamic_lex_sc_p",
+ "Parrot_store_dynamic_lex_sc_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1146 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_lex",
+ "find_lex_p_s",
+ "Parrot_find_lex_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1147 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_lex",
+ "find_lex_p_sc",
+ "Parrot_find_lex_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1148 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_dynamic_lex",
+ "find_dynamic_lex_p_s",
+ "Parrot_find_dynamic_lex_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1149 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_dynamic_lex",
+ "find_dynamic_lex_p_sc",
+ "Parrot_find_dynamic_lex_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1150 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_caller_lex",
+ "find_caller_lex_p_s",
+ "Parrot_find_caller_lex_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1151 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_caller_lex",
+ "find_caller_lex_p_sc",
+ "Parrot_find_caller_lex_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1152 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_namespace",
+ "get_namespace_p",
+ "Parrot_get_namespace_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1153 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_namespace",
+ "get_namespace_p_p",
+ "Parrot_get_namespace_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1154 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_namespace",
+ "get_namespace_p_pc",
+ "Parrot_get_namespace_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1155 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_namespace",
+ "get_hll_namespace_p",
+ "Parrot_get_hll_namespace_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1156 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_namespace",
+ "get_hll_namespace_p_p",
+ "Parrot_get_hll_namespace_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1157 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_namespace",
+ "get_hll_namespace_p_pc",
+ "Parrot_get_hll_namespace_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1158 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_namespace",
+ "get_root_namespace_p",
+ "Parrot_get_root_namespace_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT },
+ { 0 }
+ },
+ { /* 1159 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_namespace",
+ "get_root_namespace_p_p",
+ "Parrot_get_root_namespace_p_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1160 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_namespace",
+ "get_root_namespace_p_pc",
+ "Parrot_get_root_namespace_p_pc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1161 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_global",
+ "get_global_p_s",
+ "Parrot_get_global_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1162 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_global",
+ "get_global_p_sc",
+ "Parrot_get_global_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1163 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_global",
+ "get_global_p_p_s",
+ "Parrot_get_global_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1164 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_global",
+ "get_global_p_pc_s",
+ "Parrot_get_global_p_pc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1165 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_global",
+ "get_global_p_p_sc",
+ "Parrot_get_global_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1166 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_global",
+ "get_global_p_pc_sc",
+ "Parrot_get_global_p_pc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1167 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_global",
+ "get_hll_global_p_s",
+ "Parrot_get_hll_global_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1168 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_global",
+ "get_hll_global_p_sc",
+ "Parrot_get_hll_global_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1169 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_global",
+ "get_hll_global_p_p_s",
+ "Parrot_get_hll_global_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1170 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_global",
+ "get_hll_global_p_pc_s",
+ "Parrot_get_hll_global_p_pc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1171 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_global",
+ "get_hll_global_p_p_sc",
+ "Parrot_get_hll_global_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1172 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_hll_global",
+ "get_hll_global_p_pc_sc",
+ "Parrot_get_hll_global_p_pc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1173 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_global",
+ "get_root_global_p_s",
+ "Parrot_get_root_global_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1174 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_global",
+ "get_root_global_p_sc",
+ "Parrot_get_root_global_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1175 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_global",
+ "get_root_global_p_p_s",
+ "Parrot_get_root_global_p_p_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1176 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_global",
+ "get_root_global_p_pc_s",
+ "Parrot_get_root_global_p_pc_s",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1177 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_global",
+ "get_root_global_p_p_sc",
+ "Parrot_get_root_global_p_p_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1178 */
+ /* type PARROT_FUNCTION_OP, */
+ "get_root_global",
+ "get_root_global_p_pc_sc",
+ "Parrot_get_root_global_p_pc_sc",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1179 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_global",
+ "set_global_s_p",
+ "Parrot_set_global_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1180 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_global",
+ "set_global_sc_p",
+ "Parrot_set_global_sc_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1181 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_global",
+ "set_global_p_s_p",
+ "Parrot_set_global_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1182 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_global",
+ "set_global_pc_s_p",
+ "Parrot_set_global_pc_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1183 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_global",
+ "set_global_p_sc_p",
+ "Parrot_set_global_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1184 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_global",
+ "set_global_pc_sc_p",
+ "Parrot_set_global_pc_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1185 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_hll_global",
+ "set_hll_global_s_p",
+ "Parrot_set_hll_global_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1186 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_hll_global",
+ "set_hll_global_sc_p",
+ "Parrot_set_hll_global_sc_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1187 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_hll_global",
+ "set_hll_global_p_s_p",
+ "Parrot_set_hll_global_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1188 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_hll_global",
+ "set_hll_global_pc_s_p",
+ "Parrot_set_hll_global_pc_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1189 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_hll_global",
+ "set_hll_global_p_sc_p",
+ "Parrot_set_hll_global_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1190 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_hll_global",
+ "set_hll_global_pc_sc_p",
+ "Parrot_set_hll_global_pc_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1191 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_root_global",
+ "set_root_global_s_p",
+ "Parrot_set_root_global_s_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1192 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_root_global",
+ "set_root_global_sc_p",
+ "Parrot_set_root_global_sc_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1193 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_root_global",
+ "set_root_global_p_s_p",
+ "Parrot_set_root_global_p_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1194 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_root_global",
+ "set_root_global_pc_s_p",
+ "Parrot_set_root_global_pc_s_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1195 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_root_global",
+ "set_root_global_p_sc_p",
+ "Parrot_set_root_global_p_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1196 */
+ /* type PARROT_FUNCTION_OP, */
+ "set_root_global",
+ "set_root_global_pc_sc_p",
+ "Parrot_set_root_global_pc_sc_p",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1197 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_name",
+ "find_name_p_s",
+ "Parrot_find_name_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1198 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_name",
+ "find_name_p_sc",
+ "Parrot_find_name_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1199 */
+ /* type PARROT_INLINE_OP, */
+ "find_sub_not_null",
+ "find_sub_not_null_p_s",
+ "Parrot_find_sub_not_null_p_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1200 */
+ /* type PARROT_INLINE_OP, */
+ "find_sub_not_null",
+ "find_sub_not_null_p_sc",
+ "Parrot_find_sub_not_null_p_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1201 */
+ /* type PARROT_FUNCTION_OP, */
+ "trap",
+ "trap",
+ "Parrot_trap",
+ /* "", body */
+ 0,
+ 1,
+ { (arg_type_t) 0 },
+ { (arg_dir_t) 0 },
+ { 0 }
+ },
+ { /* 1202 */
+ /* type PARROT_INLINE_OP, */
+ "set_label",
+ "set_label_p_ic",
+ "Parrot_set_label_p_ic",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 1 }
+ },
+ { /* 1203 */
+ /* type PARROT_INLINE_OP, */
+ "get_label",
+ "get_label_i_p",
+ "Parrot_get_label_i_p",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1204 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_p_p",
+ "Parrot_fetch_p_p_p_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1205 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_p_p",
+ "Parrot_fetch_p_pc_p_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1206 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_pc_p",
+ "Parrot_fetch_p_p_pc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1207 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_pc_p",
+ "Parrot_fetch_p_pc_pc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1208 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_p_pc",
+ "Parrot_fetch_p_p_p_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1209 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_p_pc",
+ "Parrot_fetch_p_pc_p_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1210 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_pc_pc",
+ "Parrot_fetch_p_p_pc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1211 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_pc_pc",
+ "Parrot_fetch_p_pc_pc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1212 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_i_p",
+ "Parrot_fetch_p_p_i_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1213 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_i_p",
+ "Parrot_fetch_p_pc_i_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1214 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_ic_p",
+ "Parrot_fetch_p_p_ic_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1215 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_ic_p",
+ "Parrot_fetch_p_pc_ic_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_IC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1216 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_i_pc",
+ "Parrot_fetch_p_p_i_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1217 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_i_pc",
+ "Parrot_fetch_p_pc_i_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_I, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1218 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_ic_pc",
+ "Parrot_fetch_p_p_ic_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1219 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_ic_pc",
+ "Parrot_fetch_p_pc_ic_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_IC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1220 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_s_p",
+ "Parrot_fetch_p_p_s_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1221 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_s_p",
+ "Parrot_fetch_p_pc_s_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1222 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_sc_p",
+ "Parrot_fetch_p_p_sc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1223 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_sc_p",
+ "Parrot_fetch_p_pc_sc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1224 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_s_pc",
+ "Parrot_fetch_p_p_s_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1225 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_s_pc",
+ "Parrot_fetch_p_pc_s_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1226 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_p_sc_pc",
+ "Parrot_fetch_p_p_sc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1227 */
+ /* type PARROT_INLINE_OP, */
+ "fetch",
+ "fetch_p_pc_sc_pc",
+ "Parrot_fetch_p_pc_sc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1228 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_p_p",
+ "Parrot_vivify_p_p_p_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1229 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_p_p",
+ "Parrot_vivify_p_pc_p_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1230 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_pc_p",
+ "Parrot_vivify_p_p_pc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1231 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_pc_p",
+ "Parrot_vivify_p_pc_pc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1232 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_p_pc",
+ "Parrot_vivify_p_p_p_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1233 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_p_pc",
+ "Parrot_vivify_p_pc_p_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_P, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1234 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_pc_pc",
+ "Parrot_vivify_p_p_pc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1235 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_pc_pc",
+ "Parrot_vivify_p_pc_pc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_PC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1236 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_i_p",
+ "Parrot_vivify_p_p_i_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1237 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_i_p",
+ "Parrot_vivify_p_pc_i_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_I, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1238 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_ic_p",
+ "Parrot_vivify_p_p_ic_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1239 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_ic_p",
+ "Parrot_vivify_p_pc_ic_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_IC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1240 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_i_pc",
+ "Parrot_vivify_p_p_i_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1241 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_i_pc",
+ "Parrot_vivify_p_pc_i_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_I, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1242 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_ic_pc",
+ "Parrot_vivify_p_p_ic_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1243 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_ic_pc",
+ "Parrot_vivify_p_pc_ic_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_IC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1244 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_s_p",
+ "Parrot_vivify_p_p_s_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1245 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_s_p",
+ "Parrot_vivify_p_pc_s_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1246 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_sc_p",
+ "Parrot_vivify_p_p_sc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1247 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_sc_p",
+ "Parrot_vivify_p_pc_sc_p",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_P },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1248 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_s_pc",
+ "Parrot_vivify_p_p_s_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1249 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_s_pc",
+ "Parrot_vivify_p_pc_s_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_S, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1250 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_p_sc_pc",
+ "Parrot_vivify_p_p_sc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1251 */
+ /* type PARROT_INLINE_OP, */
+ "vivify",
+ "vivify_p_pc_sc_pc",
+ "Parrot_vivify_p_pc_sc_pc",
+ /* "", body */
+ 0,
+ 5,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_SC, PARROT_ARG_PC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0, 0 }
+ },
+ { /* 1252 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_s_i",
+ "Parrot_new_p_s_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1253 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_sc_i",
+ "Parrot_new_p_sc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1254 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_s_ic",
+ "Parrot_new_p_s_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_S, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1255 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_sc_ic",
+ "Parrot_new_p_sc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_SC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1256 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_p_i",
+ "Parrot_new_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1257 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_pc_i",
+ "Parrot_new_p_pc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1258 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_p_ic",
+ "Parrot_new_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1259 */
+ /* type PARROT_FUNCTION_OP, */
+ "new",
+ "new_p_pc_ic",
+ "Parrot_new_p_pc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1260 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_p_i",
+ "Parrot_root_new_p_p_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1261 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_pc_i",
+ "Parrot_root_new_p_pc_i",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_I },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1262 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_p_ic",
+ "Parrot_root_new_p_p_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_P, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1263 */
+ /* type PARROT_FUNCTION_OP, */
+ "root_new",
+ "root_new_p_pc_ic",
+ "Parrot_root_new_p_pc_ic",
+ /* "", body */
+ 0,
+ 4,
+ { PARROT_ARG_P, PARROT_ARG_PC, PARROT_ARG_IC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN, PARROT_ARGDIR_IN },
+ { 0, 0, 0 }
+ },
+ { /* 1264 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_codepoint",
+ "find_codepoint_i_s",
+ "Parrot_find_codepoint_i_s",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_S },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1265 */
+ /* type PARROT_FUNCTION_OP, */
+ "find_codepoint",
+ "find_codepoint_i_sc",
+ "Parrot_find_codepoint_i_sc",
+ /* "", body */
+ 0,
+ 3,
+ { PARROT_ARG_I, PARROT_ARG_SC },
+ { PARROT_ARGDIR_OUT, PARROT_ARGDIR_IN },
+ { 0, 0 }
+ },
+ { /* 1266 */
+ /* type PARROT_FUNCTION_OP, */
+ "unroll",
+ "unroll_p",
+ "Parrot_unroll_p",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_P },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+ { /* 1267 */
+ /* type PARROT_FUNCTION_OP, */
+ "unroll",
+ "unroll_pc",
+ "Parrot_unroll_pc",
+ /* "", body */
+ 0,
+ 2,
+ { PARROT_ARG_PC },
+ { PARROT_ARGDIR_IN },
+ { 0 }
+ },
+
+};
+
+
+/*
+** Op Function Definitions:
+*/
+
+opcode_t *
+Parrot_end(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_noop(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_check_events(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const next = cur_opcode + 1;
+ Parrot_cx_check_tasks(interp, interp->scheduler);
+ return (opcode_t *)next; /* force this being a branch op */
+}
+
+opcode_t *
+Parrot_check_events__(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const _this = CUR_OPCODE;
+ /* Restore op_func_table. */
+ disable_event_checking(interp);
+ Parrot_cx_handle_tasks(interp, interp->scheduler);
+ return (opcode_t *)_this; /* force this being a branch op */
+}
+
+opcode_t *
+Parrot_wrapper__(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *pc = CUR_OPCODE;
+ DO_OP(pc, interp);
+ return (opcode_t *)pc;
+}
+
+opcode_t *
+Parrot_load_bytecode_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_load_bytecode(interp, SREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_load_bytecode_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_load_bytecode(interp, CONST(1)->u.string);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_load_language_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_load_language(interp, SREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_load_language_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_load_language(interp, CONST(1)->u.string);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_branch_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ return (opcode_t *)cur_opcode + IREG(1);
+}
+
+opcode_t *
+Parrot_branch_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ return (opcode_t *)cur_opcode + cur_opcode[1];
+}
+
+opcode_t *
+Parrot_local_branch_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL return_addr;
+ opcode_t * const dest = cur_opcode + 3;
+
+ if (PMC_IS_NULL(PREG(1)) || PREG(1)->vtable->base_type != enum_class_ResizableIntegerArray) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_INVALID_OPERATION,
+ "Must pass a valid integer array to 'local_branch'");
+ return (opcode_t *)handler;
+ }
+
+ return_addr = PTR2INTVAL(dest);
+ VTABLE_push_integer(interp, PREG(1), return_addr);
+
+ return (opcode_t *)cur_opcode + IREG(2);
+}
+
+opcode_t *
+Parrot_local_branch_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL return_addr;
+ opcode_t * const dest = cur_opcode + 3;
+
+ if (PMC_IS_NULL(PREG(1)) || PREG(1)->vtable->base_type != enum_class_ResizableIntegerArray) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_INVALID_OPERATION,
+ "Must pass a valid integer array to 'local_branch'");
+ return (opcode_t *)handler;
+ }
+
+ return_addr = PTR2INTVAL(dest);
+ VTABLE_push_integer(interp, PREG(1), return_addr);
+
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+}
+
+opcode_t *
+Parrot_local_return_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL return_addr;
+ opcode_t *next;
+ opcode_t * const dest = cur_opcode + 2;
+
+ if (PMC_IS_NULL(PREG(1)) || PREG(1)->vtable->base_type != enum_class_ResizableIntegerArray) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_INVALID_OPERATION,
+ "Must pass a valid integer array to 'local_return'");
+ return (opcode_t *)handler;
+ }
+
+ return_addr = VTABLE_pop_integer(interp, PREG(1));
+ next = INTVAL2PTR(opcode_t *, return_addr);
+
+ /* The return address must be within the current code segment. */
+ if (! (next >= interp->code->base.data
+ && next < (interp->code->base.data + interp->code->base.size))) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_INVALID_OPERATION,
+ "Address for 'local_return' must be within the current code segment");
+ return (opcode_t *)handler;
+ }
+
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_jump_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const loc = INTVAL2PTR(opcode_t *, IREG(1));
+ return (opcode_t *)loc;
+}
+
+opcode_t *
+Parrot_jump_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const loc = INTVAL2PTR(opcode_t *, cur_opcode[1]);
+ return (opcode_t *)loc;
+}
+
+opcode_t *
+Parrot_enternative(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const addr = run_native(interp, CUR_OPCODE,
+ interp->code->base.data);
+ return (opcode_t *)addr;
+}
+
+opcode_t *
+Parrot_if_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != 0)
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_if_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!FLOAT_IS_ZERO(NREG(1)))
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_if_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_boolean(interp, SREG(1)))
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_if_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_bool(interp, PREG(1)))
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unless_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) == 0)
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unless_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (FLOAT_IS_ZERO(NREG(1)))
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unless_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!Parrot_str_boolean(interp, SREG(1)))
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unless_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!VTABLE_get_bool(interp, PREG(1)))
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_invokecc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const p = PREG(1);
+ opcode_t *dest = cur_opcode + 2;
+ PMC * const signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, NULL);
+ interp->current_cont = NEED_CONTINUATION;
+ dest = VTABLE_invoke(interp, p, dest);
+
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_invoke_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest = cur_opcode + 3;
+ PMC * const p = PREG(1);
+ PMC * const signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, NULL);
+ interp->current_cont = PREG(2);
+
+ dest = VTABLE_invoke(interp, p, dest);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_yield(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest = cur_opcode + 1;
+ PMC * const p = Parrot_pcc_get_sub(interp, CURRENT_CONTEXT(interp));
+
+ VTABLE_increment(interp, p);
+ dest = VTABLE_invoke(interp, p, dest);
+
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_tailcall_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const p = PREG(1);
+ opcode_t *dest = cur_opcode + 2;
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+ PMC * const parent_ctx = Parrot_pcc_get_caller_ctx(interp, ctx);
+ PMC * const this_call_sig = Parrot_pcc_get_signature(interp, ctx);
+ PMC * const parent_call_sig = Parrot_pcc_get_signature(interp, parent_ctx);
+ interp->current_cont = Parrot_pcc_get_continuation(interp, ctx);
+
+ Parrot_pcc_merge_signature_for_tailcall(interp, parent_call_sig, this_call_sig);
+
+ SUB_FLAG_TAILCALL_SET(interp->current_cont);
+ dest = VTABLE_invoke(interp, p, dest);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_returncc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const p = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
+ opcode_t * const dest = VTABLE_invoke(interp, p, cur_opcode + 1);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_capture_lex_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_capture_lex(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_newclosure_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = parrot_new_closure(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_args_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const raw_args = CUR_OPCODE;
+ PMC * const signature = CONST(1)->u.key;
+ PMC * const call_sig = Parrot_pcc_build_sig_object_from_op(interp,
+ PMCNULL, signature, raw_args);
+ const INTVAL argc = VTABLE_elements(interp, signature);
+ Parrot_pcc_set_signature(interp, CURRENT_CONTEXT(interp), call_sig);
+ return (opcode_t *)cur_opcode + argc + 2;
+}
+
+opcode_t *
+Parrot_get_params_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const raw_params = CUR_OPCODE;
+ PMC * const signature = CONST(1)->u.key;
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+ PMC * const ccont = Parrot_pcc_get_continuation(interp, ctx);
+ PMC * const caller_ctx = Parrot_pcc_get_caller_ctx(interp, ctx);
+ PMC * const call_object = Parrot_pcc_get_signature(interp, caller_ctx);
+ INTVAL argc;
+
+ Parrot_pcc_fill_params_from_op(interp, call_object, signature, raw_params,
+ PARROT_ERRORS_PARAM_COUNT_FLAG);
+
+ /* TODO Factor out with Sub.invoke */
+ if (PObj_get_FLAGS(ccont) & SUB_FLAG_TAILCALL) {
+ PObj_get_FLAGS(ccont) &= ~SUB_FLAG_TAILCALL;
+ Parrot_pcc_dec_recursion_depth(interp, ctx);
+ Parrot_pcc_set_caller_ctx(interp, ctx, Parrot_pcc_get_caller_ctx(interp, caller_ctx));
+ }
+ argc = VTABLE_elements(interp, signature);
+ return (opcode_t *)cur_opcode + argc + 2;
+}
+
+opcode_t *
+Parrot_set_returns_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const raw_args = CUR_OPCODE;
+ PMC * const signature = CONST(1)->u.key;
+ PMC * const call_sig = Parrot_pcc_build_sig_object_from_op(interp,
+ Parrot_pcc_get_signature(interp,
+ Parrot_pcc_get_caller_ctx(interp, CURRENT_CONTEXT(interp))),
+ signature, raw_args);
+ INTVAL argc;
+
+ Parrot_pcc_set_signature(interp, CURRENT_CONTEXT(interp), call_sig);
+
+ argc = VTABLE_elements(interp, signature);
+ return (opcode_t *)cur_opcode + argc + 2;
+}
+
+opcode_t *
+Parrot_get_results_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const raw_params = CUR_OPCODE;
+ PMC * const signature = CONST(1)->u.key;
+ PMC *ctx = CURRENT_CONTEXT(interp);
+ PMC *ccont = Parrot_pcc_get_continuation(interp, ctx);
+ PMC *call_object = Parrot_pcc_get_signature(interp, ctx);
+
+ INTVAL argc;
+
+ Parrot_pcc_fill_params_from_op(interp, call_object, signature, raw_params,
+ PARROT_ERRORS_RESULT_COUNT_FLAG);
+
+ argc = VTABLE_elements(interp, signature);
+ return (opcode_t *)cur_opcode + argc + 2;
+}
+
+opcode_t *
+Parrot_set_result_info_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+
+ VTABLE_set_attr_str(interp, ctx,
+ Parrot_str_new_constant(interp, "return_flags"),
+ PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_set_result_info_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+
+ VTABLE_set_attr_str(interp, ctx,
+ Parrot_str_new_constant(interp, "return_flags"),
+ CONST(1)->u.key);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_result_info_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const caller_ctx = Parrot_pcc_get_caller_ctx(interp, CURRENT_CONTEXT(interp));
+ PMC * const sig = VTABLE_get_attr_str(interp, caller_ctx,
+ Parrot_str_new_constant(interp, "return_flags"));
+
+ /* If no elements, hand back empty array; otherwise PMC. */
+ if (!sig)
+ PREG(1) = Parrot_pmc_new(interp, enum_class_FixedIntegerArray);
+ else
+ PREG(1) = sig;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_set_addr_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PTR2INTVAL(CUR_OPCODE + cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_addr_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pointer(interp, PREG(1), (CUR_OPCODE + cur_opcode[2]));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_addr_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pointer(interp, PREG(1), (void*)IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_addr_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ void *ptr = VTABLE_get_pointer(interp, PREG(2));
+ IREG(1) = (INTVAL)ptr;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_schedule_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_cx_schedule_task(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_addhandler_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_cx_add_handler(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_push_eh_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const eh = Parrot_pmc_new(interp, enum_class_ExceptionHandler);
+ VTABLE_set_pointer(interp, eh, CUR_OPCODE + cur_opcode[1]);
+ Parrot_cx_add_handler_local(interp, eh);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_push_eh_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_cx_add_handler_local(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_pop_eh(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_cx_delete_handler_local(interp,
+ Parrot_str_new_constant(interp, "exception"));
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_throw_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * except = PREG(1);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ if (PMC_IS_NULL(except) || except->vtable->base_type != enum_class_Exception)
+ except = Parrot_ex_build_exception(interp, EXCEPT_fatal,
+ EXCEPTION_UNIMPLEMENTED,
+ Parrot_str_new_constant(interp, "Not a throwable object"));
+
+ VTABLE_set_attr_str(interp, except, Parrot_str_new_constant(interp, "resume"), resume);
+ dest = Parrot_ex_throw_from_op(interp, except, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_throw_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * dest;
+ PMC * except = PREG(1);
+ if (PMC_IS_NULL(except) || except->vtable->base_type != enum_class_Exception)
+ except = Parrot_ex_build_exception(interp, EXCEPT_fatal,
+ EXCEPTION_UNIMPLEMENTED,
+ Parrot_str_new_constant(interp, "Not a throwable object"));
+ dest = Parrot_ex_throw_from_op(interp, PREG(1),
+ VTABLE_get_pointer(interp, PREG(2)));
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_rethrow_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * dest;
+ if (PMC_IS_NULL(PREG(1)) || PREG(1)->vtable->base_type != enum_class_Exception) {
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const except = Parrot_ex_build_exception(interp, EXCEPT_fatal,
+ EXCEPTION_UNIMPLEMENTED,
+ Parrot_str_new_constant(interp, "Not a throwable object"));
+ dest = Parrot_ex_throw_from_op(interp, except, ret);
+ return (opcode_t *)dest;
+ }
+ dest = Parrot_ex_rethrow_from_op(interp, PREG(1));
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_count_eh_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_cx_count_handlers_local(interp,
+ Parrot_str_new_constant(interp, "exception"));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_die_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+ PMC * const exception = Parrot_ex_build_exception(interp, EXCEPT_error,
+ CONTROL_ERROR, SREG(1));
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ VTABLE_set_attr_str(interp, exception,
+ Parrot_str_new_constant(interp, "resume"), resume);
+ dest = Parrot_ex_throw_from_op(interp, exception, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_die_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+ PMC * const exception = Parrot_ex_build_exception(interp, EXCEPT_error,
+ CONTROL_ERROR, CONST(1)->u.string);
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ VTABLE_set_attr_str(interp, exception,
+ Parrot_str_new_constant(interp, "resume"), resume);
+ dest = Parrot_ex_throw_from_op(interp, exception, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_die_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+ STRING * const msg = PMC_IS_NULL(PREG(1)) ? NULL : VTABLE_get_string(interp, PREG(1));
+ PMC * const exception =
+ Parrot_ex_build_exception(interp, EXCEPT_error, CONTROL_ERROR, msg);
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ VTABLE_set_attr_str(interp, exception,
+ Parrot_str_new_constant(interp, "resume"), resume);
+ dest = Parrot_ex_throw_from_op(interp, exception, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_die_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+ STRING * const msg = PMC_IS_NULL(CONST(1)->u.key) ? NULL : VTABLE_get_string(interp, CONST(1)->u.key);
+ PMC * const exception =
+ Parrot_ex_build_exception(interp, EXCEPT_error, CONTROL_ERROR, msg);
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ VTABLE_set_attr_str(interp, exception,
+ Parrot_str_new_constant(interp, "resume"), resume);
+ dest = Parrot_ex_throw_from_op(interp, exception, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_die_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) == EXCEPT_doomed)
+ _exit(IREG(2));
+ else {
+ opcode_t * const ret = cur_opcode + 3;
+ PMC * const exception = Parrot_ex_build_exception(interp, IREG(1), IREG(2), NULL);
+ opcode_t * const dest = Parrot_ex_throw_from_op(interp, exception, ret);
+
+ return (opcode_t *)dest;
+ }
+}
+
+opcode_t *
+Parrot_die_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] == EXCEPT_doomed)
+ _exit(IREG(2));
+ else {
+ opcode_t * const ret = cur_opcode + 3;
+ PMC * const exception = Parrot_ex_build_exception(interp, cur_opcode[1], IREG(2), NULL);
+ opcode_t * const dest = Parrot_ex_throw_from_op(interp, exception, ret);
+
+ return (opcode_t *)dest;
+ }
+}
+
+opcode_t *
+Parrot_die_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) == EXCEPT_doomed)
+ _exit(cur_opcode[2]);
+ else {
+ opcode_t * const ret = cur_opcode + 3;
+ PMC * const exception = Parrot_ex_build_exception(interp, IREG(1), cur_opcode[2], NULL);
+ opcode_t * const dest = Parrot_ex_throw_from_op(interp, exception, ret);
+
+ return (opcode_t *)dest;
+ }
+}
+
+opcode_t *
+Parrot_die_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] == EXCEPT_doomed)
+ _exit(cur_opcode[2]);
+ else {
+ opcode_t * const ret = cur_opcode + 3;
+ PMC * const exception = Parrot_ex_build_exception(interp, cur_opcode[1], cur_opcode[2], NULL);
+ opcode_t * const dest = Parrot_ex_throw_from_op(interp, exception, ret);
+
+ return (opcode_t *)dest;
+ }
+}
+
+opcode_t *
+Parrot_exit_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+ PMC * const exception = Parrot_ex_build_exception(interp, EXCEPT_exit, IREG(1), NULL);
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ VTABLE_set_attr_str(interp, exception,
+ Parrot_str_new_constant(interp, "resume"), resume);
+ VTABLE_set_integer_keyed_str(interp, exception,
+ Parrot_str_new_constant(interp, "exit_code"), IREG(1));
+ dest = Parrot_ex_throw_from_op(interp, exception, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_exit_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const ret = cur_opcode + 2;
+ PMC * const resume = pmc_new(interp, enum_class_Continuation);
+ PMC * const exception = Parrot_ex_build_exception(interp, EXCEPT_exit, cur_opcode[1], NULL);
+
+ VTABLE_set_pointer(interp, resume, ret);
+
+ VTABLE_set_attr_str(interp, exception,
+ Parrot_str_new_constant(interp, "resume"), resume);
+ VTABLE_set_integer_keyed_str(interp, exception,
+ Parrot_str_new_constant(interp, "exit_code"), cur_opcode[1]);
+ dest = Parrot_ex_throw_from_op(interp, exception, ret);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_debug_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != 0) { Interp_debug_SET(interp, IREG(1)); }
+ else { Interp_debug_CLEAR(interp, PARROT_ALL_DEBUG_FLAGS); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_debug_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] != 0) { Interp_debug_SET(interp, cur_opcode[1]); }
+ else { Interp_debug_CLEAR(interp, PARROT_ALL_DEBUG_FLAGS); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_bounds_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != 0) { Parrot_set_flag(interp, PARROT_BOUNDS_FLAG); }
+ else { Interp_flags_CLEAR(interp, PARROT_BOUNDS_FLAG); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_bounds_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] != 0) { Parrot_set_flag(interp, PARROT_BOUNDS_FLAG); }
+ else { Interp_flags_CLEAR(interp, PARROT_BOUNDS_FLAG); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_profile_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != 0) { Parrot_set_flag(interp, PARROT_PROFILE_FLAG); }
+ else { Interp_flags_CLEAR(interp, PARROT_PROFILE_FLAG); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_profile_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] != 0) { Parrot_set_flag(interp, PARROT_PROFILE_FLAG); }
+ else { Interp_flags_CLEAR(interp, PARROT_PROFILE_FLAG); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_trace_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != 0) { Parrot_set_trace(interp, IREG(1)); }
+ else { Parrot_clear_trace(interp, PARROT_ALL_TRACE_FLAGS); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_trace_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] != 0) { Parrot_set_trace(interp, cur_opcode[1]); }
+ else { Parrot_clear_trace(interp, PARROT_ALL_TRACE_FLAGS); }
+ interp->resume_offset = REL_PC + 2; interp->resume_flag = 1;return (opcode_t *)0;
+}
+
+opcode_t *
+Parrot_gc_debug_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != 0) { Interp_flags_SET(interp, PARROT_GC_DEBUG_FLAG); }
+ else { Interp_flags_CLEAR(interp, PARROT_GC_DEBUG_FLAG); }
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_gc_debug_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] != 0) { Interp_flags_SET(interp, PARROT_GC_DEBUG_FLAG); }
+ else { Interp_flags_CLEAR(interp, PARROT_GC_DEBUG_FLAG); }
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_interpinfo_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = interpinfo(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_interpinfo_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = interpinfo(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_interpinfo_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = interpinfo_p(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_interpinfo_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = interpinfo_p(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_interpinfo_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = interpinfo_s(interp, IREG(2));
+ SREG(1) = s;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_interpinfo_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = interpinfo_s(interp, cur_opcode[2]);
+ SREG(1) = s;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_warningson_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_WARNINGS_on(interp, IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_warningson_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_WARNINGS_on(interp, cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_warningsoff_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_WARNINGS_off(interp, IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_warningsoff_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_WARNINGS_off(interp, cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_errorson_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_ERRORS_on(interp, IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_errorson_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_ERRORS_on(interp, cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_errorsoff_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_ERRORS_off(interp, IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_errorsoff_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PARROT_ERRORS_off(interp, cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_runinterp_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Interp * const new_interp = (Interp *)VTABLE_get_pointer(interp, PREG(1));
+ Interp_flags_SET(new_interp, PARROT_EXTERN_CODE_FLAG);
+ Parrot_switch_to_cs(new_interp, interp->code, 1);
+ runops(new_interp, REL_PC + IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_runinterp_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Interp * const new_interp = (Interp *)VTABLE_get_pointer(interp, PREG(1));
+ Interp_flags_SET(new_interp, PARROT_EXTERN_CODE_FLAG);
+ Parrot_switch_to_cs(new_interp, interp->code, 1);
+ runops(new_interp, REL_PC + cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_getinterp_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, interp->iglobals,
+ IGLOBALS_INTERPRETER);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_sweep_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1])
+ Parrot_gc_mark_and_sweep(interp, 0);
+ else
+ if (Parrot_gc_impatient_pmcs(interp))
+ Parrot_gc_mark_and_sweep(interp, GC_lazy_FLAG);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_collect(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_gc_compact_memory_pool(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_sweepoff(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_block_GC_mark(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_sweepon(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_unblock_GC_mark(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_collectoff(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_block_GC_sweep(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_collecton(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_unblock_GC_sweep(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_needs_destroy_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_gc_pmc_needs_early_collection(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_loadlib_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_load_lib(interp, SREG(2), NULL);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_loadlib_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_load_lib(interp, CONST(2)->u.string, NULL);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_loadlib_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_load_lib(interp, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_loadlib_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_load_lib(interp, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_loadlib_p_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_load_lib(interp, SREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_loadlib_p_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_load_lib(interp, CONST(2)->u.string, CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_dlfunc_p_p_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ char * const name = Parrot_str_to_cstring(interp, (SREG(3)));
+ void *dl_handle = NULL;
+ void *ptr = NULL;
+ funcptr_t p;
+
+ if (!PMC_IS_NULL(PREG(2))
+ && PREG(2)->vtable->base_type == enum_class_ParrotLibrary
+ && VTABLE_defined(interp, PREG(2))) {
+ dl_handle = ((Parrot_ParrotLibrary_attributes*)PMC_data(PREG(2)))->dl_handle;
+ }
+
+ ptr = Parrot_dlsym(dl_handle, name);
+ p = D2FPTR(ptr);
+
+ if (p == NULLfunc) {
+ const char * err = Parrot_dlerror();
+ Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+ }
+ else {
+ PREG(1) = Parrot_pmc_new(interp, enum_class_NCI);
+ VTABLE_set_pointer_keyed_str(interp, PREG(1), SREG(4), F2DPTR(p));
+ }
+ Parrot_str_free_cstring(name);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_dlfunc_p_p_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ char * const name = Parrot_str_to_cstring(interp, (CONST(3)->u.string));
+ void *dl_handle = NULL;
+ void *ptr = NULL;
+ funcptr_t p;
+
+ if (!PMC_IS_NULL(PREG(2))
+ && PREG(2)->vtable->base_type == enum_class_ParrotLibrary
+ && VTABLE_defined(interp, PREG(2))) {
+ dl_handle = ((Parrot_ParrotLibrary_attributes*)PMC_data(PREG(2)))->dl_handle;
+ }
+
+ ptr = Parrot_dlsym(dl_handle, name);
+ p = D2FPTR(ptr);
+
+ if (p == NULLfunc) {
+ const char * err = Parrot_dlerror();
+ Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+ }
+ else {
+ PREG(1) = Parrot_pmc_new(interp, enum_class_NCI);
+ VTABLE_set_pointer_keyed_str(interp, PREG(1), SREG(4), F2DPTR(p));
+ }
+ Parrot_str_free_cstring(name);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_dlfunc_p_p_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ char * const name = Parrot_str_to_cstring(interp, (SREG(3)));
+ void *dl_handle = NULL;
+ void *ptr = NULL;
+ funcptr_t p;
+
+ if (!PMC_IS_NULL(PREG(2))
+ && PREG(2)->vtable->base_type == enum_class_ParrotLibrary
+ && VTABLE_defined(interp, PREG(2))) {
+ dl_handle = ((Parrot_ParrotLibrary_attributes*)PMC_data(PREG(2)))->dl_handle;
+ }
+
+ ptr = Parrot_dlsym(dl_handle, name);
+ p = D2FPTR(ptr);
+
+ if (p == NULLfunc) {
+ const char * err = Parrot_dlerror();
+ Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+ }
+ else {
+ PREG(1) = Parrot_pmc_new(interp, enum_class_NCI);
+ VTABLE_set_pointer_keyed_str(interp, PREG(1), CONST(4)->u.string, F2DPTR(p));
+ }
+ Parrot_str_free_cstring(name);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_dlfunc_p_p_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ char * const name = Parrot_str_to_cstring(interp, (CONST(3)->u.string));
+ void *dl_handle = NULL;
+ void *ptr = NULL;
+ funcptr_t p;
+
+ if (!PMC_IS_NULL(PREG(2))
+ && PREG(2)->vtable->base_type == enum_class_ParrotLibrary
+ && VTABLE_defined(interp, PREG(2))) {
+ dl_handle = ((Parrot_ParrotLibrary_attributes*)PMC_data(PREG(2)))->dl_handle;
+ }
+
+ ptr = Parrot_dlsym(dl_handle, name);
+ p = D2FPTR(ptr);
+
+ if (p == NULLfunc) {
+ const char * err = Parrot_dlerror();
+ Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+ }
+ else {
+ PREG(1) = Parrot_pmc_new(interp, enum_class_NCI);
+ VTABLE_set_pointer_keyed_str(interp, PREG(1), CONST(4)->u.string, F2DPTR(p));
+ }
+ Parrot_str_free_cstring(name);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_dlvar_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ char * const name = Parrot_str_to_cstring(interp, (SREG(3)));
+ void * dl_handle = NULL;
+ void * p = NULL;
+
+ if (!PMC_IS_NULL(PREG(2))
+ && PREG(2)->vtable->base_type == enum_class_ParrotLibrary
+ && VTABLE_defined(interp, PREG(2))) {
+ dl_handle = ((Parrot_ParrotLibrary_attributes*)PMC_data(PREG(2)))->dl_handle;
+ }
+
+ p = Parrot_dlsym(dl_handle, name);
+
+ if (p == NULL) {
+ const char * const err = Parrot_dlerror();
+ Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+ }
+ else {
+ /* At this point we have the symbol's address. We just need to build
+ a PMC with it so we can get and set the value */
+ PREG(1) = Parrot_pmc_new(interp, enum_class_UnManagedStruct);
+ VTABLE_set_pointer(interp, PREG(1), p);
+ }
+ Parrot_str_free_cstring(name);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_dlvar_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ char * const name = Parrot_str_to_cstring(interp, (CONST(3)->u.string));
+ void * dl_handle = NULL;
+ void * p = NULL;
+
+ if (!PMC_IS_NULL(PREG(2))
+ && PREG(2)->vtable->base_type == enum_class_ParrotLibrary
+ && VTABLE_defined(interp, PREG(2))) {
+ dl_handle = ((Parrot_ParrotLibrary_attributes*)PMC_data(PREG(2)))->dl_handle;
+ }
+
+ p = Parrot_dlsym(dl_handle, name);
+
+ if (p == NULL) {
+ const char * const err = Parrot_dlerror();
+ Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
+ "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+ }
+ else {
+ /* At this point we have the symbol's address. We just need to build
+ a PMC with it so we can get and set the value */
+ PREG(1) = Parrot_pmc_new(interp, enum_class_UnManagedStruct);
+ VTABLE_set_pointer(interp, PREG(1), p);
+ }
+ Parrot_str_free_cstring(name);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_compreg_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const compreg_hash = VTABLE_get_pmc_keyed_int(interp,
+ interp->iglobals, IGLOBALS_COMPREG_HASH);
+ VTABLE_set_pmc_keyed_str(interp, compreg_hash, SREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_compreg_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const compreg_hash = VTABLE_get_pmc_keyed_int(interp,
+ interp->iglobals, IGLOBALS_COMPREG_HASH);
+ VTABLE_set_pmc_keyed_str(interp, compreg_hash, CONST(1)->u.string, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_compreg_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const compreg_hash = VTABLE_get_pmc_keyed_int(interp,
+ interp->iglobals, IGLOBALS_COMPREG_HASH);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, compreg_hash, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_compreg_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const compreg_hash = VTABLE_get_pmc_keyed_int(interp,
+ interp->iglobals, IGLOBALS_COMPREG_HASH);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, compreg_hash, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_new_callback_p_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_make_cb(interp, PREG(2), PREG(3), SREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_new_callback_p_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_make_cb(interp, PREG(2), PREG(3), CONST(4)->u.string);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_annotations_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (interp->code->annotations) {
+ const opcode_t cur_pos = (cur_opcode + 2) - interp->code->base.data;
+ PREG(1) = PackFile_Annotations_lookup(interp, interp->code->annotations,
+ cur_pos, NULL);
+ }
+ else {
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Hash);
+ }
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_annotations_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (interp->code->annotations) {
+ const opcode_t cur_pos = (cur_opcode + 3) - interp->code->base.data;
+ PREG(1) = PackFile_Annotations_lookup(interp, interp->code->annotations,
+ cur_pos, SREG(2));
+ }
+ else {
+ PREG(1) = PMCNULL;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_annotations_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (interp->code->annotations) {
+ const opcode_t cur_pos = (cur_opcode + 3) - interp->code->base.data;
+ PREG(1) = PackFile_Annotations_lookup(interp, interp->code->annotations,
+ cur_pos, CONST(2)->u.string);
+ }
+ else {
+ PREG(1) = PMCNULL;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_band_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) &= IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_band_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) &= cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_band_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = a & IREG(2);
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_band_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = a & cur_opcode[2];
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_band_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), a & b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_band_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) & IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_band_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] & IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_band_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) & cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_band_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), a & IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_band_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), a & cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_band_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(3));
+ VTABLE_set_integer_native(interp, PREG(1), a & b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bands_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_and(interp, a, SREG(2));
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bands_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_and(interp, a, CONST(2)->u.string);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bands_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = VTABLE_get_string(interp, PREG(2));
+ a = Parrot_str_bitwise_and(interp, a, b);
+ VTABLE_set_string_native(interp, PREG(1), a);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bands_s_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_and(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bands_s_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_and(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bands_s_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_and(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bands_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = Parrot_str_bitwise_and(interp, a, SREG(3));
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bands_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = Parrot_str_bitwise_and(interp, a, CONST(3)->u.string);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bands_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = VTABLE_get_string(interp, PREG(3));
+ STRING * const c = Parrot_str_bitwise_and(interp, a, b);
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bnot_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = ~ IREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_bnot_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = ~ IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bnot_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ VTABLE_set_integer_native(interp, PREG(1), ~a);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_bnot_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ PMC * const b = Parrot_pmc_new(interp, VTABLE_type(interp, PREG(2)));
+ VTABLE_set_integer_native(interp, b, ~a);
+ PREG(1) = b;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bnots_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_not(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bnots_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_not(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bnots_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_not(interp, a);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_bnots_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = Parrot_str_bitwise_not(interp, a);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bor_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) |= IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bor_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) |= cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bor_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ VTABLE_set_integer_native(interp, PREG(1), a | IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bor_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ VTABLE_set_integer_native(interp, PREG(1), a | cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bor_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), a | b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bor_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) | IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bor_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] | IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bor_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) | cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bor_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), a | IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bor_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), a | cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bor_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(3));
+ VTABLE_set_integer_native(interp, PREG(1), a | b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bors_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_or(interp, a, SREG(2));
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bors_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_or(interp, a, CONST(2)->u.string);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bors_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = VTABLE_get_string(interp, PREG(2));
+ STRING * const c = Parrot_str_bitwise_or(interp, a, b);
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bors_s_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_or(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bors_s_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_or(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bors_s_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_or(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bors_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const b = VTABLE_get_string(interp, PREG(2));
+ STRING * const c = Parrot_str_bitwise_or(interp, b, SREG(3));
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bors_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const b = VTABLE_get_string(interp, PREG(2));
+ STRING * const c = Parrot_str_bitwise_or(interp, b, CONST(3)->u.string);
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bors_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = VTABLE_get_string(interp, PREG(3));
+ STRING * const c = Parrot_str_bitwise_or(interp, a, b);
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shl_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = bit_shift_left(IREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shl_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = bit_shift_left(IREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shl_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = bit_shift_left(a, IREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shl_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = bit_shift_left(a, cur_opcode[2]);
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shl_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL c = bit_shift_left(a, b);
+ VTABLE_set_integer_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shl_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = bit_shift_left(IREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shl_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = bit_shift_left(cur_opcode[2], IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shl_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = bit_shift_left(IREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shl_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL b = bit_shift_left(a, IREG(3));
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shl_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL b = bit_shift_left(a, cur_opcode[3]);
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shl_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(3));
+ const INTVAL c = bit_shift_left(a, b);
+ VTABLE_set_integer_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shr_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL signed_shift = -IREG(2);
+ IREG(1) = bit_shift_left(IREG(1), signed_shift);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shr_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL signed_shift = -cur_opcode[2];
+ IREG(1) = bit_shift_left(IREG(1), signed_shift);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shr_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = bit_shift_left(a, -IREG(2));
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shr_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = bit_shift_left(a, -cur_opcode[2]);
+ VTABLE_set_integer_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shr_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(1));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL c = bit_shift_left(a, -b);
+ VTABLE_set_integer_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shr_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL signed_shift = -IREG(3);
+ IREG(1) = bit_shift_left(IREG(2), signed_shift);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shr_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL signed_shift = -IREG(3);
+ IREG(1) = bit_shift_left(cur_opcode[2], signed_shift);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shr_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL signed_shift = -cur_opcode[3];
+ IREG(1) = bit_shift_left(IREG(2), signed_shift);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shr_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL c = bit_shift_left(a, -IREG(3));
+ VTABLE_set_integer_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shr_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL c = bit_shift_left(a, -cur_opcode[3]);
+ VTABLE_set_integer_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_shr_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL a = VTABLE_get_integer(interp, PREG(2));
+ const INTVAL b = VTABLE_get_integer(interp, PREG(3));
+ const INTVAL c = bit_shift_left(a, -b);
+ VTABLE_set_integer_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lsr_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)IREG(1);
+ const UINTVAL b = a >> IREG(2);
+ IREG(1) = (INTVAL)b;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_lsr_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)IREG(1);
+ const UINTVAL b = a >> cur_opcode[2];
+ IREG(1) = (INTVAL)b;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_lsr_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(1));
+ const UINTVAL b = a >> IREG(2);
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_lsr_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(1));
+ const UINTVAL b = a >> cur_opcode[2];
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_lsr_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(1));
+ const UINTVAL b = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL c = a >> b;
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)c);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_lsr_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (INTVAL)((UINTVAL)IREG(2) >> IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lsr_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (INTVAL)((UINTVAL)cur_opcode[2] >> IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lsr_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (INTVAL)((UINTVAL)IREG(2) >> cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lsr_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL b = (UINTVAL)IREG(3);
+ const UINTVAL c = a >> b;
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lsr_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL b = (UINTVAL)cur_opcode[3];
+ const UINTVAL c = a >> b;
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lsr_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL b = (UINTVAL)VTABLE_get_integer(interp, PREG(3));
+ const UINTVAL c = a >> b;
+ VTABLE_set_integer_native(interp, PREG(3), (INTVAL)c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_rot_i_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL r = IREG(2);
+ INTVAL s = IREG(3);
+ const INTVAL w = cur_opcode[4];
+ INTVAL d, t;
+ if (s < 0)
+ s += w;
+ d = r << s;
+ t = w - s;
+ t = (INTVAL)((UINTVAL)r >> t);
+ d |= t;
+ IREG(1) = d;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_rot_i_ic_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL r = cur_opcode[2];
+ INTVAL s = IREG(3);
+ const INTVAL w = cur_opcode[4];
+ INTVAL d, t;
+ if (s < 0)
+ s += w;
+ d = r << s;
+ t = w - s;
+ t = (INTVAL)((UINTVAL)r >> t);
+ d |= t;
+ IREG(1) = d;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_rot_i_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL r = IREG(2);
+ INTVAL s = cur_opcode[3];
+ const INTVAL w = cur_opcode[4];
+ INTVAL d, t;
+ if (s < 0)
+ s += w;
+ d = r << s;
+ t = w - s;
+ t = (INTVAL)((UINTVAL)r >> t);
+ d |= t;
+ IREG(1) = d;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_bxor_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) ^= IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxor_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) ^= cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxor_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(1));
+ const UINTVAL b = a ^ IREG(2);
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxor_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(1));
+ const UINTVAL b = a ^ cur_opcode[2];
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxor_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(1));
+ const UINTVAL b = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL c = a ^ b;
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)c);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxor_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) ^ IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxor_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] ^ IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxor_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) ^ cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxor_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL b = a ^ IREG(3);
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxor_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL b = a ^ cur_opcode[3];
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxor_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const UINTVAL a = (UINTVAL)VTABLE_get_integer(interp, PREG(2));
+ const UINTVAL b = (UINTVAL)VTABLE_get_integer(interp, PREG(3));
+ const UINTVAL c = a ^ b;
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL)c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxors_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_xor(interp, a, SREG(2));
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxors_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = Parrot_str_bitwise_xor(interp, a, CONST(2)->u.string);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxors_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(1));
+ STRING * const b = VTABLE_get_string(interp, PREG(2));
+ STRING * const c = Parrot_str_bitwise_xor(interp, a, b);
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bxors_s_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_xor(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxors_s_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_xor(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxors_s_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_bitwise_xor(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxors_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = Parrot_str_bitwise_xor(interp, a, SREG(3));
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxors_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = Parrot_str_bitwise_xor(interp, a, CONST(3)->u.string);
+ VTABLE_set_string_native(interp, PREG(1), b);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_bxors_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const a = VTABLE_get_string(interp, PREG(2));
+ STRING * const b = VTABLE_get_string(interp, PREG(3));
+ STRING * const c = Parrot_str_bitwise_xor(interp, a, b);
+ VTABLE_set_string_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) == IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_ic_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] == IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) == cur_opcode[2]) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_n_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) == NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_nc_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.number == NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_n_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) == CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_equal(interp, SREG(1), SREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_equal(interp, CONST(1)->u.string, SREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_equal(interp, SREG(1), CONST(2)->u.string)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_is_equal(interp, PREG(1), PREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, IREG(2));
+
+ if (VTABLE_is_equal(interp, PREG(1), temp)) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, cur_opcode[2]);
+
+ if (VTABLE_is_equal(interp, PREG(1), temp)) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ /*
+ * the get_number and get_string should probably
+ * be also replaced with code like above, as
+ * overriding the compare multi subs wouldn't
+ * have any effect with the current code
+ */
+ if (VTABLE_get_number(interp, PREG(1)) == NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ /*
+ * the get_number and get_string should probably
+ * be also replaced with code like above, as
+ * overriding the compare multi subs wouldn't
+ * have any effect with the current code
+ */
+ if (VTABLE_get_number(interp, PREG(1)) == CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_equal(interp, VTABLE_get_string(interp, PREG(1)), SREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_equal(interp, VTABLE_get_string(interp, PREG(1)), CONST(2)->u.string)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_str_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_is_equal_string(interp, PREG(1), PREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_num_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_is_equal_num(interp, PREG(1), PREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_addr_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(1) == SREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_addr_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.string == SREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_addr_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(1) == CONST(2)->u.string) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_addr_sc_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.string == CONST(2)->u.string) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_eq_addr_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1) == PREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_ic_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] != IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) != cur_opcode[2]) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_n_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) != NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_nc_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.number != NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_n_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) != CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_not_equal(interp, SREG(1), SREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_not_equal(interp, CONST(1)->u.string, SREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_not_equal(interp, SREG(1), CONST(2)->u.string)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!VTABLE_is_equal(interp, PREG(1), PREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, IREG(2));
+
+ if (!VTABLE_is_equal(interp, PREG(1), temp)) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, cur_opcode[2]);
+
+ if (!VTABLE_is_equal(interp, PREG(1), temp)) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) != NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) != CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_not_equal(interp, VTABLE_get_string(interp, PREG(1)), SREG(2))) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_not_equal(interp, VTABLE_get_string(interp, PREG(1)), CONST(2)->u.string)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_str_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_string(interp, PREG(1), PREG(2)) != 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_num_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_num(interp, PREG(1), PREG(2)) != 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_addr_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(1) != SREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_addr_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.string != SREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_addr_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(1) != CONST(2)->u.string) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_addr_sc_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.string != CONST(2)->u.string) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ne_addr_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1) != PREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) < IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_ic_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] < IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) < cur_opcode[2]) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_n_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) < NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_nc_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.number < NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_n_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) < CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, SREG(1), SREG(2)) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, CONST(1)->u.string, SREG(2)) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, SREG(1), CONST(2)->u.string) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp(interp, PREG(1), PREG(2)) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, IREG(2));
+
+ if (VTABLE_cmp(interp, PREG(1), temp) < 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, cur_opcode[2]);
+
+ if (VTABLE_cmp(interp, PREG(1), temp) < 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) < NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) < CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), SREG(2)) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), CONST(2)->u.string) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_str_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_string(interp, PREG(1), PREG(2)) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_lt_num_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_num(interp, PREG(1), PREG(2)) < 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) <= IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_ic_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[1] <= IREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(1) <= cur_opcode[2]) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_n_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) <= NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_nc_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(1)->u.number <= NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_n_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (NREG(1) <= CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, SREG(1), SREG(2)) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, CONST(1)->u.string, SREG(2)) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, SREG(1), CONST(2)->u.string) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp(interp, PREG(1), PREG(2)) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, IREG(2));
+
+ if (VTABLE_cmp(interp, PREG(1), temp) <= 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, cur_opcode[2]);
+
+ if (VTABLE_cmp(interp, PREG(1), temp) <= 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) <= NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) <= CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), SREG(2)) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), CONST(2)->u.string) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_str_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_string(interp, PREG(1), PREG(2)) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_le_num_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_num(interp, PREG(1), PREG(2)) <= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp(interp, PREG(1), PREG(2)) > 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, IREG(2));
+
+ if (VTABLE_cmp(interp, PREG(1), temp) > 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, cur_opcode[2]);
+
+ if (VTABLE_cmp(interp, PREG(1), temp) > 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) > NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) > CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), SREG(2)) > 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), CONST(2)->u.string) > 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_str_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_string(interp, PREG(1), PREG(2)) > 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_gt_num_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_num(interp, PREG(1), PREG(2)) > 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp(interp, PREG(1), PREG(2)) >= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, IREG(2));
+
+ if (VTABLE_cmp(interp, PREG(1), temp) >= 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const temp = Parrot_pmc_new_temporary(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, temp, cur_opcode[2]);
+
+ if (VTABLE_cmp(interp, PREG(1), temp) >= 0) {
+ Parrot_pmc_free_temporary(interp, temp);
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+ Parrot_pmc_free_temporary(interp, temp);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) >= NREG(2)) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_number(interp, PREG(1)) >= CONST(2)->u.number) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), SREG(2)) >= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (Parrot_str_compare(interp, VTABLE_get_string(interp, PREG(1)), CONST(2)->u.string) >= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_str_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_string(interp, PREG(1), PREG(2)) >= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ge_num_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_cmp_num(interp, PREG(1), PREG(2)) >= 0) {
+ return (opcode_t *)cur_opcode + cur_opcode[3];
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_if_null_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PMC_IS_NULL(PREG(1))) {
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_if_null_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(SREG(1))) {
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unless_null_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!PMC_IS_NULL(PREG(1))) {
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unless_null_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!STRING_IS_NULL(SREG(1))) {
+ return (opcode_t *)cur_opcode + cur_opcode[2];
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_cmp_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) < IREG(3) ? -1 :
+ IREG(2) > IREG(3) ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] < IREG(3) ? -1 :
+ cur_opcode[2] > IREG(3) ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) < cur_opcode[3] ? -1 :
+ IREG(2) > cur_opcode[3] ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) < NREG(3) ? -1 :
+ NREG(2) > NREG(3) ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.number < NREG(3) ? -1 :
+ CONST(2)->u.number > NREG(3) ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) < CONST(3)->u.number ? -1 :
+ NREG(2) > CONST(3)->u.number ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_cmp(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL l = VTABLE_get_integer(interp, PREG(2));
+ IREG(1) = l < IREG(3) ? -1 :
+ l > IREG(3) ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL l = VTABLE_get_integer(interp, PREG(2));
+ IREG(1) = l < cur_opcode[3] ? -1 :
+ l > cur_opcode[3] ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL l = VTABLE_get_number(interp, PREG(2));
+ IREG(1) = l < NREG(3) ? -1 :
+ l > NREG(3) ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL l = VTABLE_get_number(interp, PREG(2));
+ IREG(1) = l < CONST(3)->u.number ? -1 :
+ l > CONST(3)->u.number ? +1 :
+ 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING* const l = VTABLE_get_string(interp, PREG(2));
+ IREG(1) = Parrot_str_compare(interp, l, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_i_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING* const l = VTABLE_get_string(interp, PREG(2));
+ IREG(1) = Parrot_str_compare(interp, l, CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_str_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_cmp_string(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_num_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_cmp_num(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmp_pmc_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_cmp_pmc(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_issame_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(2) == PREG(3))
+ IREG(1) = 1;
+ else
+ IREG(1) = VTABLE_is_same(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_issame_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = SREG(2) == SREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_issame_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.string == SREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_issame_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = SREG(2) == CONST(3)->u.string;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_issame_i_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.string == CONST(3)->u.string;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isntsame_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(2) == PREG(3))
+ IREG(1) = 0;
+ else
+ IREG(1) = !VTABLE_is_same(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isntsame_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = SREG(2) != SREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isntsame_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.string != SREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isntsame_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = SREG(2) != CONST(3)->u.string;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isntsame_i_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.string != CONST(3)->u.string;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_istrue_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_get_bool(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_isfalse_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = !VTABLE_get_bool(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_isnull_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_isnull_i_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(CONST(2)->u.key);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_isnull_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = STRING_IS_NULL(SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_isnull_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = STRING_IS_NULL(CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_isgt_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (VTABLE_cmp(interp, PREG(2), PREG(3)) > 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isge_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (VTABLE_cmp(interp, PREG(2), PREG(3)) >= 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) <= IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] <= IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) <= cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) <= NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.number <= NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) <= CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, SREG(2), SREG(3)) <= 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, CONST(2)->u.string, SREG(3)) <= 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, SREG(2), CONST(3)->u.string) <= 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isle_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (VTABLE_cmp(interp, PREG(2), PREG(3)) <= 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) < IREG(3)) ? 1 : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (cur_opcode[2] < IREG(3)) ? 1 : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) < cur_opcode[3]) ? 1 : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) < NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.number < NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) < CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, SREG(2), SREG(3)) < 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, CONST(2)->u.string, SREG(3)) < 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_compare(interp, SREG(2), CONST(3)->u.string) < 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_islt_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (VTABLE_cmp(interp, PREG(2), PREG(3)) < 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) == IREG(3)) ? 1 : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (cur_opcode[2] == IREG(3)) ? 1 : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) == cur_opcode[3]) ? 1 : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) == NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.number == NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) == CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (Parrot_str_equal(interp, SREG(2), SREG(3)) ? 1 : 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (Parrot_str_equal(interp, CONST(2)->u.string, SREG(3)) ? 1 : 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (Parrot_str_equal(interp, SREG(2), CONST(3)->u.string) ? 1 : 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_iseq_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (&PREG(2) == &PREG(3))
+ IREG(1) = 1;
+ else
+ IREG(1) = VTABLE_is_equal(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) == IREG(3)) ? 0 : 1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (cur_opcode[2] == IREG(3)) ? 0 : 1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) == cur_opcode[3]) ? 0 : 1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) != NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(2)->u.number != NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = NREG(2) != CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (Parrot_str_not_equal(interp, SREG(2), SREG(3)) ? 1 : 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (Parrot_str_not_equal(interp, CONST(2)->u.string, SREG(3)) ? 1 : 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (Parrot_str_not_equal(interp, SREG(2), CONST(3)->u.string) ? 1 : 0);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isne_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (&PREG(2) == &PREG(3))
+ IREG(1) = 0;
+ else
+ IREG(1) = !VTABLE_is_equal(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_and_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) ? IREG(3) : IREG(2);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_and_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] ? IREG(3) : cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_and_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) ? cur_opcode[3] : IREG(2);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_and_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_logical_and(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_not_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = ! IREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_not_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = ! IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_not_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_logical_not(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_not_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_logical_not(interp, PREG(2), PREG(1));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_or_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) ? IREG(2) : IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_or_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] ? cur_opcode[2] : IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_or_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) ? IREG(2) : cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_or_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_logical_or(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_xor_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) && ! IREG(3)) ? IREG(2) : (IREG(3) && ! IREG(2)) ? IREG(3) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_xor_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (cur_opcode[2] && ! IREG(3)) ? cur_opcode[2] : (IREG(3) && ! cur_opcode[2]) ? IREG(3) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_xor_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (IREG(2) && ! cur_opcode[3]) ? IREG(2) : (cur_opcode[3] && ! IREG(2)) ? cur_opcode[3] : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_xor_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_logical_xor(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_debug_init(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_debugger_init(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_debug_load_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_debugger_load(interp, CONST(1)->u.string);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_debug_break(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_debugger_break(interp, cur_opcode);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_debug_print(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!interp->pdb) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 1,
+ EXCEPTION_INVALID_OPERATION,
+ "Initialize debugger with debug_init before using debug_print");
+ return (opcode_t *)handler;
+ }
+
+ if (!(interp->pdb->state & PDB_BREAK)) {
+ PDB_print(interp, "I");
+ PDB_print(interp, "N");
+ PDB_print(interp, "S");
+ PDB_print(interp, "P");
+ }
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_backtrace(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PDB_backtrace(interp);
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_getline_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_Context_info info;
+ Parrot_Context_get_info(interp, CURRENT_CONTEXT(interp), &info);
+ IREG(1) = info.line;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_getfile_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_Context_info info;
+ Parrot_Context_get_info(interp, CURRENT_CONTEXT(interp), &info);
+ SREG(1) = info.file;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_close_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_close(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_fdopen_p_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_io_fdopen(interp, PMCNULL, (PIOHANDLE)IREG(2), SREG(3));
+ if (!PREG(1))
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdopen_p_ic_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_io_fdopen(interp, PMCNULL, (PIOHANDLE)cur_opcode[2], SREG(3));
+ if (!PREG(1))
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdopen_p_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_io_fdopen(interp, PMCNULL, (PIOHANDLE)IREG(2), CONST(3)->u.string);
+ if (!PREG(1))
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdopen_p_ic_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_io_fdopen(interp, PMCNULL, (PIOHANDLE)cur_opcode[2], CONST(3)->u.string);
+ if (!PREG(1))
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Undef);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_getstdin_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = _PIO_STDIN(interp);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_getstdout_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = _PIO_STDOUT(interp);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_getstderr_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = _PIO_STDERR(interp);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_setstdin_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ _PIO_STDIN(interp) = PREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_setstdout_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ _PIO_STDOUT(interp) = PREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_setstderr_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ _PIO_STDERR(interp) = PREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_open_p_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(SREG(2)) || STRING_IS_NULL(SREG(3))) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_UNEXPECTED_NULL, "Invalid open");
+ return (opcode_t *)handler;
+ }
+ else {
+ PREG(1) = Parrot_io_open(interp, PMCNULL, SREG(2), SREG(3));
+ PARROT_ASSERT(! PMC_IS_NULL(PREG(1)));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_open_p_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(CONST(2)->u.string) || STRING_IS_NULL(SREG(3))) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_UNEXPECTED_NULL, "Invalid open");
+ return (opcode_t *)handler;
+ }
+ else {
+ PREG(1) = Parrot_io_open(interp, PMCNULL, CONST(2)->u.string, SREG(3));
+ PARROT_ASSERT(! PMC_IS_NULL(PREG(1)));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_open_p_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(SREG(2)) || STRING_IS_NULL(CONST(3)->u.string)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_UNEXPECTED_NULL, "Invalid open");
+ return (opcode_t *)handler;
+ }
+ else {
+ PREG(1) = Parrot_io_open(interp, PMCNULL, SREG(2), CONST(3)->u.string);
+ PARROT_ASSERT(! PMC_IS_NULL(PREG(1)));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_open_p_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(CONST(2)->u.string) || STRING_IS_NULL(CONST(3)->u.string)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_UNEXPECTED_NULL, "Invalid open");
+ return (opcode_t *)handler;
+ }
+ else {
+ PREG(1) = Parrot_io_open(interp, PMCNULL, CONST(2)->u.string, CONST(3)->u.string);
+ PARROT_ASSERT(! PMC_IS_NULL(PREG(1)));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_open_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(SREG(2))) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_UNEXPECTED_NULL, "Invalid open");
+ return (opcode_t *)handler;
+ }
+ else {
+ PREG(1) = Parrot_io_open(interp, PMCNULL, SREG(2), NULL);
+ PARROT_ASSERT(! PMC_IS_NULL(PREG(1)));
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_open_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (STRING_IS_NULL(CONST(2)->u.string)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_UNEXPECTED_NULL, "Invalid open");
+ return (opcode_t *)handler;
+ }
+ else {
+ PREG(1) = Parrot_io_open(interp, PMCNULL, CONST(2)->u.string, NULL);
+ PARROT_ASSERT(! PMC_IS_NULL(PREG(1)));
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_printf(interp, INTVAL_FMT, (INTVAL)IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_printf(interp, INTVAL_FMT, (INTVAL)cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#ifdef PARROT_HAS_NEGATIVE_ZERO
+ Parrot_io_printf(interp, FLOATVAL_FMT, NREG(1));
+#else
+ /* Workaround for older msvcrt and openbsd. TT #313 */
+ if (Parrot_is_nzero(NREG(1))) {
+ Parrot_io_printf(interp, "-0");
+ }
+ else {
+ Parrot_io_printf(interp, FLOATVAL_FMT, NREG(1));
+ }
+#endif
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#ifdef PARROT_HAS_NEGATIVE_ZERO
+ Parrot_io_printf(interp, FLOATVAL_FMT, CONST(1)->u.number);
+#else
+ /* Workaround for older msvcrt and openbsd. TT #313 */
+ if (Parrot_is_nzero(CONST(1)->u.number)) {
+ Parrot_io_printf(interp, "-0");
+ }
+ else {
+ Parrot_io_printf(interp, FLOATVAL_FMT, CONST(1)->u.number);
+ }
+#endif
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = SREG(1);
+ if (s && Parrot_str_byte_length(interp, s))
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), s);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = CONST(1)->u.string;
+ if (s && Parrot_str_byte_length(interp, s))
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), s);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const p = PREG(1);
+ STRING * const s = (VTABLE_get_string(interp, p));
+ if (s)
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), s);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_printf(interp, INTVAL_FMT "\n", (INTVAL)IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_printf(interp, INTVAL_FMT "\n", (INTVAL)cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#ifdef PARROT_HAS_NEGATIVE_ZERO
+ Parrot_io_printf(interp, FLOATVAL_FMT "\n", NREG(1));
+#else
+ /* Workaround for older msvcrt and openbsd. TT #313 */
+ if (Parrot_is_nzero(NREG(1))) {
+ Parrot_io_printf(interp, "-0\n");
+ }
+ else {
+ Parrot_io_printf(interp, FLOATVAL_FMT "\n", NREG(1));
+ }
+#endif
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#ifdef PARROT_HAS_NEGATIVE_ZERO
+ Parrot_io_printf(interp, FLOATVAL_FMT "\n", CONST(1)->u.number);
+#else
+ /* Workaround for older msvcrt and openbsd. TT #313 */
+ if (Parrot_is_nzero(CONST(1)->u.number)) {
+ Parrot_io_printf(interp, "-0\n");
+ }
+ else {
+ Parrot_io_printf(interp, FLOATVAL_FMT "\n", CONST(1)->u.number);
+ }
+#endif
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = SREG(1);
+ if (s && Parrot_str_byte_length(interp, s))
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), s);
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), Parrot_str_new_constant(interp, "\n"));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = CONST(1)->u.string;
+ if (s && Parrot_str_byte_length(interp, s))
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), s);
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), Parrot_str_new_constant(interp, "\n"));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_say_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const p = PREG(1);
+
+ if (PMC_IS_NULL(p)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 2,
+ EXCEPTION_UNEXPECTED_NULL,
+ "Null PMC in say");
+ return (opcode_t *)handler;
+ }
+ else {
+ STRING * const s = VTABLE_get_string(interp, p);
+ if (s)
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), s);
+ Parrot_io_putps(interp, _PIO_STDOUT(interp), Parrot_str_new_constant(interp, "\n"));
+ }
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_eprintf(interp, INTVAL_FMT, IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_eprintf(interp, INTVAL_FMT, cur_opcode[1]);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_eprintf(interp, FLOATVAL_FMT, NREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_io_eprintf(interp, FLOATVAL_FMT, CONST(1)->u.number);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = SREG(1);
+ if (s && Parrot_str_byte_length(interp, s))
+ Parrot_io_putps(interp, _PIO_STDERR(interp), s);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = CONST(1)->u.string;
+ if (s && Parrot_str_byte_length(interp, s))
+ Parrot_io_putps(interp, _PIO_STDERR(interp), s);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_printerr_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const p = PREG(1);
+ STRING * const s = (VTABLE_get_string(interp, p));
+ if (s)
+ Parrot_io_putps(interp, _PIO_STDERR(interp), s);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_print_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ STRING * const s = Parrot_str_from_int(interp, IREG(2));
+ Parrot_io_putps(interp, PREG(1), s);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ STRING * const s = Parrot_str_from_int(interp, cur_opcode[2]);
+ Parrot_io_putps(interp, PREG(1), s);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ STRING * const s = Parrot_sprintf_c(interp, FLOATVAL_FMT, NREG(2));
+ Parrot_io_putps(interp, PREG(1), s);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ STRING * const s = Parrot_sprintf_c(interp, FLOATVAL_FMT, CONST(2)->u.number);
+ Parrot_io_putps(interp, PREG(1), s);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(2) && PREG(1)) {
+ Parrot_io_putps(interp, PREG(1), SREG(2));
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(2)->u.string && PREG(1)) {
+ Parrot_io_putps(interp, PREG(1), CONST(2)->u.string);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_print_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(2) && PREG(1)) {
+ STRING * const s = VTABLE_get_string(interp, PREG(2));
+ Parrot_io_putps(interp, PREG(1), s);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_read_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_io_reads(interp, _PIO_STDIN(interp), (size_t)IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_read_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_io_reads(interp, _PIO_STDIN(interp), (size_t)cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_read_s_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_io_reads(interp, PREG(2), (size_t)IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_read_s_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_io_reads(interp, PREG(2), (size_t)cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_readline_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_io_readline(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_peek_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING ** const s = &SREG(1);
+
+ *s = NULL;
+ if (Parrot_io_peek(interp, _PIO_STDIN(interp), s) < 0) {
+ SREG(1) = STRINGNULL;
+ }
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_peek_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING ** const s = &SREG(1);
+
+ *s = NULL;
+ if (Parrot_io_peek(interp, PREG(2), s) < 0) {
+ SREG(1) = STRINGNULL;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_stat_i_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_stat_info_intval(interp, SREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_stat_info_intval(interp, CONST(2)->u.string, IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_stat_info_intval(interp, SREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_stat_info_intval(interp, CONST(2)->u.string, cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_fstat_info_intval(interp, IREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_fstat_info_intval(interp, cur_opcode[2], IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_fstat_info_intval(interp, IREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stat_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_fstat_info_intval(interp, cur_opcode[2], cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_seek_p_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset(IREG(2)), IREG(3)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (32bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_seek_p_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset(cur_opcode[2]), IREG(3)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (32bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_seek_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset(IREG(2)), cur_opcode[3]) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (32bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_seek_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset(cur_opcode[2]), cur_opcode[3]) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (32bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_seek_p_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(IREG(2), IREG(3)), IREG(4)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_ic_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(cur_opcode[2], IREG(3)), IREG(4)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(IREG(2), cur_opcode[3]), IREG(4)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_ic_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(cur_opcode[2], cur_opcode[3]), IREG(4)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(IREG(2), IREG(3)), cur_opcode[4]) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_ic_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(cur_opcode[2], IREG(3)), cur_opcode[4]) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(IREG(2), cur_opcode[3]), cur_opcode[4]) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_seek_p_ic_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(1)) {
+ if (Parrot_io_seek(interp, PREG(1), Parrot_io_make_offset32(cur_opcode[2], cur_opcode[3]), cur_opcode[4]) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 5,
+ EXCEPTION_PIO_ERROR,
+ "seek failed (64bit)");
+ return (opcode_t *)handler;
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_tell_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(2))
+ IREG(1) = (INTVAL)Parrot_io_tell(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_tell_i_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PREG(3)) {
+ PIOOFF_T pos;
+ pos = Parrot_io_tell(interp, PREG(3));
+ IREG(1) = (INTVAL)(pos >> 31);
+ IREG(2) = (INTVAL)(pos & 0xffffffff);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_abs_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = abs(IREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_abs_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = fabs(NREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_abs_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = abs(IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_abs_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = fabs(NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_abs_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_absolute(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_abs_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_absolute(interp, PREG(2), PREG(1));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) += IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) += cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) += NREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) += CONST(2)->u.number;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_add(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_add_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_add_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_add_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_add_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) + IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] + IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) + cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2) + NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = CONST(2)->u.number + NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2) + CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_add(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_add_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_add_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_add_float(interp, PREG(2), NREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_add_float(interp, PREG(2), CONST(3)->u.number, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(3);
+ if (IREG(3) == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = IREG(2) % den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(3);
+ if (IREG(3) == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = cur_opcode[2] % den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = cur_opcode[3];
+ if (cur_opcode[3] == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = IREG(2) % den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL result;
+
+ if (IREG(3) == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ result = VTABLE_get_integer(interp, PREG(2)) % IREG(3);
+
+ PREG(1) = Parrot_pmc_new(interp, VTABLE_type(interp, PREG(2)));
+ VTABLE_set_integer_native(interp, PREG(1), result);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL result;
+
+ if (cur_opcode[3] == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ result = VTABLE_get_integer(interp, PREG(2)) % cur_opcode[3];
+
+ PREG(1) = Parrot_pmc_new(interp, VTABLE_type(interp, PREG(2)));
+ VTABLE_set_integer_native(interp, PREG(1), result);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL result;
+ INTVAL value = VTABLE_get_integer(interp, PREG(3));
+
+ if (value == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ result = VTABLE_get_integer(interp, PREG(2)) % value;
+
+ PREG(1) = Parrot_pmc_new(interp, VTABLE_type(interp, PREG(2)));
+ VTABLE_set_integer_native(interp, PREG(1), result);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(3);
+ if (FLOAT_IS_ZERO(NREG(3))) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = fmod(NREG(2), den);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(3);
+ if (FLOAT_IS_ZERO(NREG(3))) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = fmod(CONST(2)->u.number, den);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = CONST(3)->u.number;
+ if (FLOAT_IS_ZERO(CONST(3)->u.number)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = fmod(NREG(2), den);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL result;
+ FLOATVAL value = NREG(3);
+
+ if (FLOAT_IS_ZERO(value)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ result = fmod(VTABLE_get_integer(interp, PREG(2)), value);
+
+ PREG(1) = Parrot_pmc_new(interp, VTABLE_type(interp, PREG(2)));
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL) result);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cmod_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL result;
+ FLOATVAL value = CONST(3)->u.number;
+
+ if (FLOAT_IS_ZERO(value)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ result = fmod(VTABLE_get_integer(interp, PREG(2)), value);
+
+ PREG(1) = Parrot_pmc_new(interp, VTABLE_type(interp, PREG(2)));
+ VTABLE_set_integer_native(interp, PREG(1), (INTVAL) result);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_dec_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1)--;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_dec_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1)--;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_dec_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_decrement(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_div_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(2);
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) /= den;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = cur_opcode[2];
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) /= den;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(2);
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) /= den;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = CONST(2)->u.number;
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) /= den;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_divide(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_divide_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_divide_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_divide_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_divide_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_div_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(3);
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = IREG(2) / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(3);
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = cur_opcode[2] / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = cur_opcode[3];
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = IREG(2) / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_i_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = cur_opcode[3];
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ IREG(1) = cur_opcode[2] / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(3);
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = NREG(2) / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(3);
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = CONST(2)->u.number / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = CONST(3)->u.number;
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = NREG(2) / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_n_nc_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = CONST(3)->u.number;
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = CONST(2)->u.number / den;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_divide(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_divide_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_divide_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_divide_float(interp, PREG(2), NREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_div_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_divide_float(interp, PREG(2), CONST(3)->u.number, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(2);
+ FLOATVAL f;
+
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ f = floor(IREG(1) / den);
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = cur_opcode[2];
+ FLOATVAL f;
+
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ f = floor(IREG(1) / den);
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(2);
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = floor(NREG(1) / den);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = CONST(2)->u.number;
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = floor(NREG(1) / den);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_floor_divide(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_floor_divide_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_floor_divide_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_floor_divide_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_floor_divide_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fdiv_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(3);
+ FLOATVAL f;
+
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ f = floor(IREG(2) / den);
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = IREG(3);
+ FLOATVAL f;
+
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ f = floor(cur_opcode[2] / den);
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ INTVAL den = cur_opcode[3];
+ FLOATVAL f;
+
+ if (den == 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+
+ f = floor(IREG(2) / den);
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(3);
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = floor(NREG(2) / den);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = NREG(3);
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = floor(CONST(2)->u.number / den);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL den = CONST(3)->u.number;
+ if (FLOAT_IS_ZERO(den)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_DIV_BY_ZERO,
+ "Divide by zero");
+ return (opcode_t *)handler;
+ }
+ NREG(1) = floor(NREG(2) / den);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_floor_divide(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_floor_divide_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_floor_divide_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_floor_divide_float(interp, PREG(2), NREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_fdiv_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_floor_divide_float(interp, PREG(2), CONST(3)->u.number, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ceil_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = ceil(NREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_ceil_i_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL f = ceil(NREG(2));
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_ceil_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = ceil(NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_floor_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floor(NREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_floor_i_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL f = floor(NREG(2));
+ IREG(1) = (INTVAL)f;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_floor_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floor(NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_inc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1)++;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_inc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1)++;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_inc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_increment(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_mod_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = intval_mod(IREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = intval_mod(IREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floatval_mod(NREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floatval_mod(NREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_modulus(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_modulus_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_modulus_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_modulus_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_modulus_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mod_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = intval_mod(IREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = intval_mod(cur_opcode[2], IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = intval_mod(IREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floatval_mod(NREG(2), NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floatval_mod(CONST(2)->u.number, NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = floatval_mod(NREG(2), CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_modulus(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_modulus_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_modulus_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_modulus_float(interp, PREG(2), NREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mod_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_modulus_float(interp, PREG(2), CONST(3)->u.number, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) *= IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) *= cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) *= NREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) *= CONST(2)->u.number;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_multiply(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_multiply_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_multiply_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_multiply_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_multiply_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_mul_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) * IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] * IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) * cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2) * NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = CONST(2)->u.number * NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2) * CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_multiply(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_multiply_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_multiply_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_multiply_float(interp, PREG(2), NREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_mul_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_multiply_float(interp, PREG(2), CONST(3)->u.number, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_neg_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = - IREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_neg_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = - NREG(1);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_neg_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_neg(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_neg_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = - IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_neg_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = - NREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_neg_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_neg(interp, PREG(2), PREG(1));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_pow_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = pow((FLOATVAL)NREG(2), (FLOATVAL)NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = pow((FLOATVAL)CONST(2)->u.number, (FLOATVAL)NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = pow((FLOATVAL)NREG(2), (FLOATVAL)CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL a = VTABLE_get_number(interp, PREG(2));
+ const FLOATVAL b = VTABLE_get_number(interp, PREG(3));
+ const FLOATVAL c = pow(a, b);
+ if (PMC_IS_NULL(PREG(1)))
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ else
+ PREG(1) = Parrot_pmc_new(interp, PREG(1)->vtable->base_type);
+ VTABLE_set_number_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL a = VTABLE_get_number(interp, PREG(2));
+ const FLOATVAL b = (FLOATVAL)IREG(3);
+ const FLOATVAL c = pow(a, b);
+ if (PMC_IS_NULL(PREG(1)))
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ else
+ PREG(1) = Parrot_pmc_new(interp, PREG(1)->vtable->base_type);
+ VTABLE_set_number_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL a = VTABLE_get_number(interp, PREG(2));
+ const FLOATVAL b = (FLOATVAL)cur_opcode[3];
+ const FLOATVAL c = pow(a, b);
+ if (PMC_IS_NULL(PREG(1)))
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ else
+ PREG(1) = Parrot_pmc_new(interp, PREG(1)->vtable->base_type);
+ VTABLE_set_number_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL a = VTABLE_get_number(interp, PREG(2));
+ const FLOATVAL c = pow(a, NREG(3));
+ if (PMC_IS_NULL(PREG(1)))
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ else
+ PREG(1) = Parrot_pmc_new(interp, PREG(1)->vtable->base_type);
+ VTABLE_set_number_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const FLOATVAL a = VTABLE_get_number(interp, PREG(2));
+ const FLOATVAL c = pow(a, CONST(3)->u.number);
+ if (PMC_IS_NULL(PREG(1)))
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ else
+ PREG(1) = Parrot_pmc_new(interp, PREG(1)->vtable->base_type);
+ VTABLE_set_number_native(interp, PREG(1), c);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_n_n_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL n2 = NREG(2);
+ FLOATVAL res = 1.0;
+ INTVAL e = IREG(3);
+ int s = 1;
+ if (e != 0) {
+ if (e < 0) {
+ s = -1;
+ e = -e;
+ }
+ }
+ while (e) {
+ if (e & 1) {
+ res *= n2;
+ }
+ n2 *= n2;
+ e >>= 1;
+ }
+ if (s < 0) {
+ res = 1.0/res;
+ }
+ NREG(1) = res;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_n_nc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL n2 = CONST(2)->u.number;
+ FLOATVAL res = 1.0;
+ INTVAL e = IREG(3);
+ int s = 1;
+ if (e != 0) {
+ if (e < 0) {
+ s = -1;
+ e = -e;
+ }
+ }
+ while (e) {
+ if (e & 1) {
+ res *= n2;
+ }
+ n2 *= n2;
+ e >>= 1;
+ }
+ if (s < 0) {
+ res = 1.0/res;
+ }
+ NREG(1) = res;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_n_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL n2 = NREG(2);
+ FLOATVAL res = 1.0;
+ INTVAL e = cur_opcode[3];
+ int s = 1;
+ if (e != 0) {
+ if (e < 0) {
+ s = -1;
+ e = -e;
+ }
+ }
+ while (e) {
+ if (e & 1) {
+ res *= n2;
+ }
+ n2 *= n2;
+ e >>= 1;
+ }
+ if (s < 0) {
+ res = 1.0/res;
+ }
+ NREG(1) = res;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_pow_n_nc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL n2 = CONST(2)->u.number;
+ FLOATVAL res = 1.0;
+ INTVAL e = cur_opcode[3];
+ int s = 1;
+ if (e != 0) {
+ if (e < 0) {
+ s = -1;
+ e = -e;
+ }
+ }
+ while (e) {
+ if (e & 1) {
+ res *= n2;
+ }
+ n2 *= n2;
+ e >>= 1;
+ }
+ if (s < 0) {
+ res = 1.0/res;
+ }
+ NREG(1) = res;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) -= IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) -= cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) -= NREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) -= CONST(2)->u.number;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_subtract(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_subtract_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_subtract_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_subtract_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_subtract_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sub_i_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) - IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_i_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2] - IREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_i_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2) - cur_opcode[3];
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2) - NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = CONST(2)->u.number - NREG(3);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2) - CONST(3)->u.number;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_subtract(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_subtract_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_subtract_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_p_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_subtract_float(interp, PREG(2), NREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sub_p_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_subtract_float(interp, PREG(2), CONST(3)->u.number, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sqrt_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = sqrt((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_acos_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = acos((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_asec_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = acos(((FLOATVAL)1) / ((FLOATVAL)NREG(2)));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_asin_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = asin((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_atan_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = atan((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_atan_n_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = atan2((FLOATVAL)NREG(2), (FLOATVAL)NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_atan_n_nc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = atan2((FLOATVAL)CONST(2)->u.number, (FLOATVAL)NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_atan_n_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = atan2((FLOATVAL)NREG(2), (FLOATVAL)CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_cos_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = cos((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_cosh_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = cosh((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_exp_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = exp((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_ln_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = log((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_log10_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = log10((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_log2_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ FLOATVAL temp = log((FLOATVAL)2.0);
+ NREG(1) = log((FLOATVAL)NREG(2)) / temp;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sec_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = ((FLOATVAL)1) / cos((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sech_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = ((FLOATVAL)1) / cosh((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sin_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = sin((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sinh_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = sinh((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_tan_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = tan((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_tanh_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = tanh((FLOATVAL)NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_callmethodcc_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const object = PREG(1);
+ STRING * const meth = SREG(2);
+ opcode_t * const next = cur_opcode + 3;
+
+ PMC * const method_pmc = VTABLE_find_method(interp, object, meth);
+ opcode_t *dest = NULL;
+ PMC * const signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (PMC_IS_NULL(method_pmc)) {
+ PMC * const _class = VTABLE_get_class(interp, object);
+ if (PMC_IS_NULL(_class)) {
+ dest = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for non-object", meth);
+ }
+ else {
+ dest = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", meth,
+ VTABLE_get_string(interp, _class));
+ }
+ }
+ else {
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ interp->current_cont = NEED_CONTINUATION;
+ dest = VTABLE_invoke(interp, method_pmc, next);
+ }
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_callmethodcc_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const object = PREG(1);
+ STRING * const meth = CONST(2)->u.string;
+ opcode_t * const next = cur_opcode + 3;
+
+ PMC * const method_pmc = VTABLE_find_method(interp, object, meth);
+ opcode_t *dest = NULL;
+ PMC * const signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (PMC_IS_NULL(method_pmc)) {
+ PMC * const _class = VTABLE_get_class(interp, object);
+ if (PMC_IS_NULL(_class)) {
+ dest = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for non-object", meth);
+ }
+ else {
+ dest = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", meth,
+ VTABLE_get_string(interp, _class));
+ }
+ }
+ else {
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ interp->current_cont = NEED_CONTINUATION;
+ dest = VTABLE_invoke(interp, method_pmc, next);
+ }
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_callmethodcc_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest;
+ opcode_t * const next = cur_opcode + 3;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, PREG(1));
+ interp->current_cont = NEED_CONTINUATION;
+ dest = VTABLE_invoke(interp, PREG(2), next);
+
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_callmethod_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const object = PREG(1);
+ STRING * const meth = SREG(2);
+ opcode_t * const next = cur_opcode + 4;
+
+ PMC * const method_pmc = VTABLE_find_method(interp, object, meth);
+ opcode_t *dest = NULL;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+
+ if (PMC_IS_NULL(method_pmc)) {
+ dest = Parrot_ex_throw_from_op_args(interp, next, EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", meth,
+ VTABLE_get_string(interp, VTABLE_get_class(interp, object)));
+ }
+ else {
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ interp->current_cont = PREG(3);
+ dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
+ }
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_callmethod_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const object = PREG(1);
+ STRING * const meth = CONST(2)->u.string;
+ opcode_t * const next = cur_opcode + 4;
+
+ PMC * const method_pmc = VTABLE_find_method(interp, object, meth);
+ opcode_t *dest = NULL;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+
+ if (PMC_IS_NULL(method_pmc)) {
+ dest = Parrot_ex_throw_from_op_args(interp, next, EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", meth,
+ VTABLE_get_string(interp, VTABLE_get_class(interp, object)));
+ }
+ else {
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ interp->current_cont = PREG(3);
+ dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
+ }
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_callmethod_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const object = PREG(1);
+ PMC * const method_pmc = PREG(2);
+ opcode_t * const next = cur_opcode + 4;
+
+ opcode_t *dest;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ interp->current_cont = PREG(3);
+ dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_tailcallmethod_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const next = cur_opcode + 3;
+ PMC * const object = PREG(1);
+ STRING * const meth = SREG(2);
+ PMC * const method_pmc = VTABLE_find_method(interp, object, meth);
+
+ opcode_t *dest;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (PMC_IS_NULL(method_pmc)) {
+ dest = Parrot_ex_throw_from_op_args(interp, next, EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", meth,
+ VTABLE_get_string(interp, VTABLE_get_class(interp, object)));
+ }
+ else {
+ interp->current_cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
+ PObj_get_FLAGS(interp->current_cont) |= SUB_FLAG_TAILCALL;
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
+ }
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_tailcallmethod_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const next = cur_opcode + 3;
+ PMC * const object = PREG(1);
+ STRING * const meth = CONST(2)->u.string;
+ PMC * const method_pmc = VTABLE_find_method(interp, object, meth);
+
+ opcode_t *dest;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ if (PMC_IS_NULL(method_pmc)) {
+ dest = Parrot_ex_throw_from_op_args(interp, next, EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", meth,
+ VTABLE_get_string(interp, VTABLE_get_class(interp, object)));
+ }
+ else {
+ interp->current_cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
+ PObj_get_FLAGS(interp->current_cont) |= SUB_FLAG_TAILCALL;
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
+ }
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_tailcallmethod_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const next = cur_opcode + 3;
+ PMC * const object = PREG(1);
+ PMC * const method_pmc = PREG(2);
+
+ opcode_t *dest;
+ PMC * signature = Parrot_pcc_get_signature(interp,
+ CURRENT_CONTEXT(interp));
+
+ interp->current_cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
+ PObj_get_FLAGS(interp->current_cont) |= SUB_FLAG_TAILCALL;
+
+ if (!PMC_IS_NULL(signature))
+ Parrot_pcc_set_object(interp, signature, object);
+ dest = (opcode_t *)VTABLE_invoke(interp, method_pmc, next);
+ return (opcode_t *)dest;
+}
+
+opcode_t *
+Parrot_addmethod_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_add_method(interp, PREG(1), SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_addmethod_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_add_method(interp, PREG(1), CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_can_i_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_can(interp, PREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_can_i_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_can(interp, PREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_does_i_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = SREG(3) ? VTABLE_does(interp, PREG(2), SREG(3)) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_does_i_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(3)->u.string ? VTABLE_does(interp, PREG(2), CONST(3)->u.string) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_does_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PREG(3) ? VTABLE_does_pmc(interp, PREG(2), PREG(3)) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_does_i_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(3)->u.key ? VTABLE_does_pmc(interp, PREG(2), CONST(3)->u.key) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isa_i_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = SREG(3) ? VTABLE_isa(interp, PREG(2), SREG(3)) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isa_i_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(3)->u.string ? VTABLE_isa(interp, PREG(2), CONST(3)->u.string) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isa_i_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PREG(3) ? VTABLE_isa_pmc(interp, PREG(2), PREG(3)) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_isa_i_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = CONST(3)->u.key ? VTABLE_isa_pmc(interp, PREG(2), CONST(3)->u.key) : 0;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_newclass_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name = Parrot_pmc_new(interp, enum_class_String);
+ VTABLE_set_string_native(interp, name, SREG(2));
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, name);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_newclass_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name = Parrot_pmc_new(interp, enum_class_String);
+ VTABLE_set_string_native(interp, name, CONST(2)->u.string);
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, name);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_newclass_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_newclass_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, CONST(2)->u.key);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_subclass_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, PREG(2));
+ opcode_t * const next = cur_opcode + 3;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, PREG(2)));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Class);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, CONST(2)->u.key);
+ opcode_t * const next = cur_opcode + 3;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, CONST(2)->u.key));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Class);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, PREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t * handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, PREG(2)));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_oo_newclass_from_str(interp, SREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_pc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, CONST(2)->u.key);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t * handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, CONST(2)->u.key));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_oo_newclass_from_str(interp, SREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, PREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t * handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, PREG(2)));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_oo_newclass_from_str(interp, CONST(3)->u.string);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_pc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, CONST(2)->u.key);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t * handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, CONST(2)->u.key));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_oo_newclass_from_str(interp, CONST(3)->u.string);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, PREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, PREG(2)));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, PREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, CONST(2)->u.key);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, CONST(2)->u.key));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, PREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, PREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, PREG(2)));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, CONST(3)->u.key);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class(interp, CONST(2)->u.key);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", VTABLE_get_string(interp, CONST(2)->u.key));
+ return (opcode_t *)handler;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, CONST(3)->u.key);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, SREG(2));
+ opcode_t * const next = cur_opcode + 3;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", SREG(2));
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Class);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, CONST(2)->u.string);
+ opcode_t * const next = cur_opcode + 3;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, enum_class_Class);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, SREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", SREG(2));
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_oo_newclass_from_str(interp, SREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, CONST(2)->u.string);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_oo_newclass_from_str(interp, SREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, SREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", SREG(2));
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_oo_newclass_from_str(interp, CONST(3)->u.string);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, CONST(2)->u.string);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_oo_newclass_from_str(interp, CONST(3)->u.string);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, SREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", SREG(2));
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, PREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, CONST(2)->u.string);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, PREG(3));
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, SREG(2));
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", SREG(2));
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, CONST(3)->u.key);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_subclass_p_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const parent_class = Parrot_oo_get_class_str(interp, CONST(2)->u.string);
+ opcode_t * const next = cur_opcode + 4;
+
+ if (PMC_IS_NULL(parent_class)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' doesn't exist", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_pmc_new_init(interp, enum_class_Class, CONST(3)->u.key);
+ VTABLE_add_parent(interp, PREG(1), parent_class);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_get_class_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_oo_get_class_str(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_class_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_oo_get_class_str(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_class_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_oo_get_class(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_class_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_oo_get_class(interp, CONST(2)->u.key);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_class_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_class(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_addparent_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_add_parent(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_removeparent_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_remove_parent(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_addrole_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_add_role(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_addattribute_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const class_name = string_from_literal(interp, "Class");
+ STRING * const role_name = string_from_literal(interp, "Role");
+
+ if (VTABLE_isa(interp, PREG(1), class_name) || VTABLE_isa(interp, PREG(1), role_name))
+ VTABLE_add_attribute(interp, PREG(1), SREG(2), PMCNULL);
+ else {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "Cannot add attribute to non-class");
+ return (opcode_t *)handler;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_addattribute_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const class_name = string_from_literal(interp, "Class");
+ STRING * const role_name = string_from_literal(interp, "Role");
+
+ if (VTABLE_isa(interp, PREG(1), class_name) || VTABLE_isa(interp, PREG(1), role_name))
+ VTABLE_add_attribute(interp, PREG(1), CONST(2)->u.string, PMCNULL);
+ else {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "Cannot add attribute to non-class");
+ return (opcode_t *)handler;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_removeattribute_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_remove_attribute(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_removeattribute_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_remove_attribute(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_getattribute_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_attr_str(interp, PREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_getattribute_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_attr_str(interp, PREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_getattribute_p_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_attr_keyed(interp, PREG(2), PREG(3), SREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_getattribute_p_p_pc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_attr_keyed(interp, PREG(2), CONST(3)->u.key, SREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_getattribute_p_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_attr_keyed(interp, PREG(2), PREG(3), CONST(4)->u.string);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_getattribute_p_p_pc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_attr_keyed(interp, PREG(2), CONST(3)->u.key, CONST(4)->u.string);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_setattribute_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_attr_str(interp, PREG(1), SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_setattribute_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_attr_str(interp, PREG(1), CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_setattribute_p_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_attr_keyed(interp, PREG(1), PREG(2), SREG(3), PREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_setattribute_p_pc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_attr_keyed(interp, PREG(1), CONST(2)->u.key, SREG(3), PREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_setattribute_p_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_attr_keyed(interp, PREG(1), PREG(2), CONST(3)->u.string, PREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_setattribute_p_pc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_attr_keyed(interp, PREG(1), CONST(2)->u.key, CONST(3)->u.string, PREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_inspect_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_inspect(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_inspect_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_inspect(interp, CONST(2)->u.key);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_inspect_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_inspect_str(interp, PREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_inspect_p_pc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_inspect_str(interp, CONST(2)->u.key, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_inspect_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_inspect_str(interp, PREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_inspect_p_pc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_inspect_str(interp, CONST(2)->u.key, CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = SREG(2);
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_new_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = CONST(2)->u.string;
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_new_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = SREG(2);
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PREG(3));
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, PREG(3));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = CONST(2)->u.string;
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PREG(3));
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, PREG(3));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = SREG(2);
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, CONST(3)->u.key);
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, CONST(3)->u.key);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = CONST(2)->u.string;
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, CONST(3)->u.key);
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, CONST(3)->u.key);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_new_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_new_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PREG(3));
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, PREG(3));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, PREG(3));
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, PREG(3));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, CONST(3)->u.key);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, CONST(3)->u.key);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+
+ if (!PMC_IS_NULL(_class))
+ PREG(1) = VTABLE_instantiate(interp, _class, CONST(3)->u.key);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+ if (type <= 0) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init(interp, type, CONST(3)->u.key);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const key = PREG(2);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, key);
+ PMC * classobj = PMCNULL;
+
+ if (!PMC_IS_NULL(ns))
+ classobj = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_root_new_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const key = CONST(2)->u.key;
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, key);
+ PMC * classobj = PMCNULL;
+
+ if (!PMC_IS_NULL(ns))
+ classobj = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 3,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_root_new_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const key = PREG(2);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, key);
+ PMC * classobj = PMCNULL;
+
+ if (!PMC_IS_NULL(ns))
+ classobj = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PREG(3));
+ else {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const key = CONST(2)->u.key;
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, key);
+ PMC * classobj = PMCNULL;
+
+ if (!PMC_IS_NULL(ns))
+ classobj = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PREG(3));
+ else {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const key = PREG(2);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, key);
+ PMC * classobj = PMCNULL;
+
+ if (!PMC_IS_NULL(ns))
+ classobj = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, CONST(3)->u.key);
+ else {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const key = CONST(2)->u.key;
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, key);
+ PMC * classobj = PMCNULL;
+
+ if (!PMC_IS_NULL(ns))
+ classobj = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, CONST(3)->u.key);
+ else {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_typeof_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_name(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_typeof_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_class(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_repr_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_get_repr(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_method_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const resume = cur_opcode + 4;
+ PREG(1) = VTABLE_find_method(interp, PREG(2), SREG(3));
+ if (PMC_IS_NULL(PREG(1)) || !VTABLE_defined(interp, PREG(1))) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, resume,
+ EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", SREG(3),
+ VTABLE_get_string(interp, VTABLE_get_class(interp, PREG(2))));
+ return (opcode_t *)dest;
+ }
+ return (opcode_t *)resume;
+}
+
+opcode_t *
+Parrot_find_method_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t * const resume = cur_opcode + 4;
+ PREG(1) = VTABLE_find_method(interp, PREG(2), CONST(3)->u.string);
+ if (PMC_IS_NULL(PREG(1)) || !VTABLE_defined(interp, PREG(1))) {
+ opcode_t * const dest = Parrot_ex_throw_from_op_args(interp, resume,
+ EXCEPTION_METHOD_NOT_FOUND,
+ "Method '%Ss' not found for invocant of class '%Ss'", CONST(3)->u.string,
+ VTABLE_get_string(interp, VTABLE_get_class(interp, PREG(2))));
+ return (opcode_t *)dest;
+ }
+ return (opcode_t *)resume;
+}
+
+opcode_t *
+Parrot_defined_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_defined(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_defined_i_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_defined_keyed_int(interp, PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_defined_i_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_defined_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_defined_i_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_defined_keyed(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_defined_i_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_defined_keyed(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_exists_i_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_exists_keyed_int(interp, PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_exists_i_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0 : VTABLE_exists_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_exists_i_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0: VTABLE_exists_keyed(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_exists_i_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = PMC_IS_NULL(PREG(2)) ? 0: VTABLE_exists_keyed(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_delete_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_delete_keyed(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_delete_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_delete_keyed(interp, PREG(1), CONST(2)->u.key);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_delete_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_delete_keyed_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_delete_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_delete_keyed_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_elements_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_elements(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_integer(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_integer(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_string(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_string(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_push_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_push_pmc(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_pop_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_pop_integer(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_pop_n_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_pop_float(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_pop_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_pop_string(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_pop_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_pop_pmc(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_integer(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_integer(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_float(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_float(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_string(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_string(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unshift_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_unshift_pmc(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shift_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_shift_integer(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shift_n_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_shift_float(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shift_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_shift_string(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_shift_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_shift_pmc(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_splice_p_p_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_splice(interp, PREG(1), PREG(2), IREG(3), IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_splice_p_p_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_splice(interp, PREG(1), PREG(2), cur_opcode[3], IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_splice_p_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_splice(interp, PREG(1), PREG(2), IREG(3), cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_splice_p_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_splice(interp, PREG(1), PREG(2), cur_opcode[3], cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_setprop_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_setprop(interp, PREG(1), SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_setprop_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_setprop(interp, PREG(1), CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_getprop_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_getprop(interp, PREG(3), SREG(2));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_getprop_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_getprop(interp, PREG(3), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_delprop_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_delprop(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_delprop_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_delprop(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_prophash_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_getprops(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_freeze_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_freeze(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_thaw_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_thaw(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_thaw_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_thaw(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_add_multi_s_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_mmd_add_multi_from_long_sig(interp, SREG(1), SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_multi_sc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_mmd_add_multi_from_long_sig(interp, CONST(1)->u.string, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_multi_s_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_mmd_add_multi_from_long_sig(interp, SREG(1), CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_add_multi_sc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_mmd_add_multi_from_long_sig(interp, CONST(1)->u.string, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_find_multi_p_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_mmd_find_multi_from_long_sig(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_find_multi_p_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_mmd_find_multi_from_long_sig(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_find_multi_p_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_mmd_find_multi_from_long_sig(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_find_multi_p_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_mmd_find_multi_from_long_sig(interp, CONST(2)->u.string, CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_register_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_pmc_gc_register(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_unregister_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_pmc_gc_unregister(interp, PREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_box_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_box_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_box_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ VTABLE_set_number_native(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_box_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Float));
+ VTABLE_set_number_native(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_box_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_String));
+ VTABLE_set_string_native(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_box_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_String));
+ VTABLE_set_string_native(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_iter_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_iter(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_morph_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_morph(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_morph_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_morph(interp, PREG(1), CONST(2)->u.key);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_clone_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ /* cloning a NULL STRING produces an empty STRING; TT #964 */
+ SREG(1) = STRING_IS_NULL(SREG(2))
+ ? Parrot_str_new(interp, NULL, 0)
+ : SREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_clone_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ /* cloning a NULL STRING produces an empty STRING; TT #964 */
+ SREG(1) = STRING_IS_NULL(CONST(2)->u.string)
+ ? Parrot_str_new(interp, NULL, 0)
+ : CONST(2)->u.string;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (INTVAL)(NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (INTVAL)(CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_to_int(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_to_int(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = NREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = CONST(2)->u.number;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = (FLOATVAL)IREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = (FLOATVAL)cur_opcode[2];
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = Parrot_str_to_num(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = Parrot_str_to_num(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_n_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_get_number(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_get_string(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = SREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = CONST(2)->u.string;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_from_int(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_from_int(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_from_num(interp, NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_s_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_from_num(interp, CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = CONST(2)->u.key;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = PREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_native(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_native(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_native(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_native(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_native(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_native(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_get_integer(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_assign_pmc(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_native(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_native(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_native(interp, PREG(1), NREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_native(interp, PREG(1), CONST(2)->u.number);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_assign_string_native(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_assign_string_native(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = SREG(2);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_assign_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = CONST(2)->u.string;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_setref_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pmc(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_deref_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_p_ki_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed_int(interp, PREG(1), IREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed_int(interp, PREG(1), cur_opcode[2], IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_ki_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed_int(interp, PREG(1), IREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed_int(interp, PREG(1), cur_opcode[2], cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_ki_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed_int(interp, PREG(1), IREG(2), NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed_int(interp, PREG(1), cur_opcode[2], NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_ki_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed_int(interp, PREG(1), IREG(2), CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed_int(interp, PREG(1), cur_opcode[2], CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_ki_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed_int(interp, PREG(1), IREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed_int(interp, PREG(1), cur_opcode[2], SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_ki_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed_int(interp, PREG(1), IREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed_int(interp, PREG(1), cur_opcode[2], CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_ki_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pmc_keyed_int(interp, PREG(1), IREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kic_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pmc_keyed_int(interp, PREG(1), cur_opcode[2], PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_i_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_get_integer_keyed_int(interp, PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_i_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_get_integer_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_n_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_get_number_keyed_int(interp, PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_n_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_get_number_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_s_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_get_string_keyed_int(interp, PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_s_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_get_string_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_p_ki(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_p_kic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed(interp, PREG(1), PREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed(interp, PREG(1), CONST(2)->u.key, IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed(interp, PREG(1), PREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_integer_keyed(interp, PREG(1), CONST(2)->u.key, cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed(interp, PREG(1), PREG(2), NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed(interp, PREG(1), CONST(2)->u.key, NREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed(interp, PREG(1), PREG(2), CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_number_keyed(interp, PREG(1), CONST(2)->u.key, CONST(3)->u.number);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed(interp, PREG(1), PREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed(interp, PREG(1), CONST(2)->u.key, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed(interp, PREG(1), PREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_keyed(interp, PREG(1), CONST(2)->u.key, CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_k_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pmc_keyed(interp, PREG(1), PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_kc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pmc_keyed(interp, PREG(1), CONST(2)->u.key, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_i_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_get_integer_keyed(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_i_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = VTABLE_get_integer_keyed(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_n_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_get_number_keyed(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_n_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = VTABLE_get_number_keyed(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_s_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_get_string_keyed(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_s_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_get_string_keyed(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_p_k(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_p_p_kc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_clone_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_clone(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_clone_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_clone_pmc(interp, PREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_clone_p_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_clone_pmc(interp, PREG(2), CONST(3)->u.key);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_copy_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (PMC_IS_NULL(PREG(1))) {
+ opcode_t * const dest = cur_opcode + 3;
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_NULL_REG_ACCESS, "Null PMC in copy");
+ return (opcode_t *)handler;
+ }
+ else {
+ PMC * const clone = VTABLE_clone(interp, PREG(2));
+ /* Preserve the metadata on the destination. */
+ PMC * const meta = VTABLE_getprops(interp, PREG(1));
+
+ /* avoid leaks and unreachable memory by destroying the destination PMC */
+ Parrot_pmc_destroy(interp, PREG(1));
+
+ /* the source PMC knows how to clone itself, but we must reuse the
+ * destination header */
+ memmove(PREG(1), clone, sizeof (PMC));
+
+ /* don't let the clone's destruction destroy the destination's data */
+ PObj_custom_destroy_CLEAR(clone);
+ PMC_data(clone) = NULL;
+ PMC_metadata(clone) = NULL;
+
+ /* Restore metadata. */
+ if (!PMC_IS_NULL(meta)) {
+ PMC * const iter = VTABLE_get_iter(interp, meta);
+ while (VTABLE_get_bool(interp, iter)) {
+ STRING * const key = VTABLE_shift_string(interp, iter);
+ PMC * const value = VTABLE_get_pmc_keyed_str(interp, meta, key);
+ VTABLE_setprop(interp, PREG(1), key, value);
+ }
+ }
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_null_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = STRINGNULL;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_null_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = 0;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_null_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = PMCNULL;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_null_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = 0;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_ord_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = string_ord(interp, SREG(2), 0);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_ord_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = string_ord(interp, CONST(2)->u.string, 0);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_ord_i_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = string_ord(interp, SREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ord_i_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = string_ord(interp, CONST(2)->u.string, IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ord_i_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = string_ord(interp, SREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_ord_i_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = string_ord(interp, CONST(2)->u.string, cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_chr_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = string_chr(interp, (UINTVAL)IREG(2));
+ SREG(1) = s;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_chr_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const s = string_chr(interp, (UINTVAL)cur_opcode[2]);
+ SREG(1) = s;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_chopn_s_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_chopn(interp, SREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_chopn_s_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_chopn(interp, CONST(2)->u.string, IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_chopn_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_chopn(interp, SREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_chopn_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_chopn(interp, CONST(2)->u.string, cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_concat_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_concat(interp, SREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_concat_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_concat(interp, SREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_concat_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_concatenate(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_concat_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_concatenate_str(interp, PREG(1), SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_concat_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_concatenate_str(interp, PREG(1), CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_concat_s_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_concat(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_concat_s_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_concat(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_concat_s_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_concat(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_concat_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_concatenate_str(interp, PREG(2), SREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_concat_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_concatenate_str(interp, PREG(2), CONST(3)->u.string, PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_concat_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_concatenate(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_s_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(3) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ SREG(1) = Parrot_str_repeat(interp, SREG(2), (UINTVAL)IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_s_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(3) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ SREG(1) = Parrot_str_repeat(interp, CONST(2)->u.string, (UINTVAL)IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[3] < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ SREG(1) = Parrot_str_repeat(interp, SREG(2), (UINTVAL)cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[3] < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ SREG(1) = Parrot_str_repeat(interp, CONST(2)->u.string, (UINTVAL)cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (IREG(3) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ PREG(1) = VTABLE_repeat_int(interp, PREG(2), IREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (cur_opcode[3] < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ PREG(1) = VTABLE_repeat_int(interp, PREG(2), cur_opcode[3], PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (VTABLE_get_integer(interp, PREG(3)) < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_NEG_REPEAT,
+ "Cannot repeat with negative arg");
+ return (opcode_t *)handler;
+ }
+ PREG(1) = VTABLE_repeat(interp, PREG(2), PREG(3), PREG(1));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_repeat_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_repeat_int(interp, PREG(1), IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_repeat_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_repeat_int(interp, PREG(1), cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_repeat_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_i_repeat(interp, PREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_length_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_length(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_length_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_length(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bytelength_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_byte_length(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_bytelength_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_byte_length(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_pin_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_str_pin(interp, SREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_unpin_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ Parrot_str_unpin(interp, SREG(1));
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_substr_s_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL len = Parrot_str_byte_length(interp, SREG(2));
+ SREG(1) = Parrot_str_substr(interp, SREG(2), IREG(3), len);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_substr_s_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL len = Parrot_str_byte_length(interp, CONST(2)->u.string);
+ SREG(1) = Parrot_str_substr(interp, CONST(2)->u.string, IREG(3), len);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_substr_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL len = Parrot_str_byte_length(interp, SREG(2));
+ SREG(1) = Parrot_str_substr(interp, SREG(2), cur_opcode[3], len);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_substr_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL len = Parrot_str_byte_length(interp, CONST(2)->u.string);
+ SREG(1) = Parrot_str_substr(interp, CONST(2)->u.string, cur_opcode[3], len);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_substr_s_s_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, SREG(2), IREG(3), IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_sc_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, CONST(2)->u.string, IREG(3), IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_s_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, SREG(2), cur_opcode[3], IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_sc_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, CONST(2)->u.string, cur_opcode[3], IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_s_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, SREG(2), IREG(3), cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_sc_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, CONST(2)->u.string, IREG(3), cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_s_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, SREG(2), cur_opcode[3], cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_sc_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_substr(interp, CONST(2)->u.string, cur_opcode[3], cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_p_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_substr_str(interp, PREG(2), IREG(3), IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_p_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_substr_str(interp, PREG(2), cur_opcode[3], IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_p_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_substr_str(interp, PREG(2), IREG(3), cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_substr_s_p_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = VTABLE_substr_str(interp, PREG(2), cur_opcode[3], cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_replace_s_s_i_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), IREG(3), IREG(4), SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_i_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, IREG(3), IREG(4), SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_ic_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), cur_opcode[3], IREG(4), SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_ic_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, cur_opcode[3], IREG(4), SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_i_ic_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), IREG(3), cur_opcode[4], SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_i_ic_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, IREG(3), cur_opcode[4], SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_ic_ic_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), cur_opcode[3], cur_opcode[4], SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_ic_ic_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, cur_opcode[3], cur_opcode[4], SREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_i_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), IREG(3), IREG(4), CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_i_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, IREG(3), IREG(4), CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_ic_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), cur_opcode[3], IREG(4), CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_ic_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, cur_opcode[3], IREG(4), CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_i_ic_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), IREG(3), cur_opcode[4], CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_i_ic_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, IREG(3), cur_opcode[4], CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_s_ic_ic_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, SREG(2), cur_opcode[3], cur_opcode[4], CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_replace_s_sc_ic_ic_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_replace(interp, CONST(2)->u.string, cur_opcode[3], cur_opcode[4], CONST(5)->u.string);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_index_i_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (SREG(2) && SREG(3)) ? Parrot_str_find_index(interp, SREG(2), SREG(3), 0) : -1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_index_i_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (CONST(2)->u.string && SREG(3)) ? Parrot_str_find_index(interp, CONST(2)->u.string, SREG(3), 0) : -1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_index_i_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (SREG(2) && CONST(3)->u.string) ? Parrot_str_find_index(interp, SREG(2), CONST(3)->u.string, 0) : -1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_index_i_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (CONST(2)->u.string && CONST(3)->u.string) ? Parrot_str_find_index(interp, CONST(2)->u.string, CONST(3)->u.string, 0) : -1;
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_index_i_s_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (SREG(2) && SREG(3)) ? Parrot_str_find_index(interp, SREG(2), SREG(3), IREG(4)) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_sc_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (CONST(2)->u.string && SREG(3)) ? Parrot_str_find_index(interp, CONST(2)->u.string, SREG(3), IREG(4)) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_s_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (SREG(2) && CONST(3)->u.string) ? Parrot_str_find_index(interp, SREG(2), CONST(3)->u.string, IREG(4)) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_sc_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (CONST(2)->u.string && CONST(3)->u.string) ? Parrot_str_find_index(interp, CONST(2)->u.string, CONST(3)->u.string, IREG(4)) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (SREG(2) && SREG(3)) ? Parrot_str_find_index(interp, SREG(2), SREG(3), cur_opcode[4]) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_sc_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (CONST(2)->u.string && SREG(3)) ? Parrot_str_find_index(interp, CONST(2)->u.string, SREG(3), cur_opcode[4]) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (SREG(2) && CONST(3)->u.string) ? Parrot_str_find_index(interp, SREG(2), CONST(3)->u.string, cur_opcode[4]) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_index_i_sc_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = (CONST(2)->u.string && CONST(3)->u.string) ? Parrot_str_find_index(interp, CONST(2)->u.string, CONST(3)->u.string, cur_opcode[4]) : -1;
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_sprintf_s_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1)=Parrot_psprintf(interp, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sprintf_s_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1)=Parrot_psprintf(interp, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_sprintf_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_string_native(interp, PREG(1),
+ Parrot_psprintf(interp, VTABLE_get_string(interp, PREG(2)), PREG(3)));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_new_noinit(interp, enum_stringrep_one, 0);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_new_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_new_noinit(interp, enum_stringrep_one, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_new_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_new_noinit(interp, enum_stringrep_one, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_stringinfo_i_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(2) == NULL)
+ IREG(1) = 0;
+ else {
+ switch (IREG(3)) {
+ case STRINGINFO_HEADER:
+ IREG(1) = PTR2UINTVAL(SREG(2));
+ break;
+ case STRINGINFO_STRSTART:
+ IREG(1) = PTR2UINTVAL(SREG(2)->strstart);
+ break;
+ case STRINGINFO_BUFLEN:
+ IREG(1) = Buffer_buflen(SREG(2));
+ break;
+ case STRINGINFO_FLAGS:
+ IREG(1) = PObj_get_FLAGS(SREG(2));
+ break;
+ case STRINGINFO_BUFUSED:
+ IREG(1) = SREG(2)->bufused;
+ break;
+ case STRINGINFO_STRLEN:
+ IREG(1) = SREG(2)->strlen;
+ break;
+ default:
+ {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "stringinfo: unknown info type: %d", IREG(3));
+ return (opcode_t *)handler;
+ }
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stringinfo_i_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(2)->u.string == NULL)
+ IREG(1) = 0;
+ else {
+ switch (IREG(3)) {
+ case STRINGINFO_HEADER:
+ IREG(1) = PTR2UINTVAL(CONST(2)->u.string);
+ break;
+ case STRINGINFO_STRSTART:
+ IREG(1) = PTR2UINTVAL(CONST(2)->u.string->strstart);
+ break;
+ case STRINGINFO_BUFLEN:
+ IREG(1) = Buffer_buflen(CONST(2)->u.string);
+ break;
+ case STRINGINFO_FLAGS:
+ IREG(1) = PObj_get_FLAGS(CONST(2)->u.string);
+ break;
+ case STRINGINFO_BUFUSED:
+ IREG(1) = CONST(2)->u.string->bufused;
+ break;
+ case STRINGINFO_STRLEN:
+ IREG(1) = CONST(2)->u.string->strlen;
+ break;
+ default:
+ {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "stringinfo: unknown info type: %d", IREG(3));
+ return (opcode_t *)handler;
+ }
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stringinfo_i_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (SREG(2) == NULL)
+ IREG(1) = 0;
+ else {
+ switch (cur_opcode[3]) {
+ case STRINGINFO_HEADER:
+ IREG(1) = PTR2UINTVAL(SREG(2));
+ break;
+ case STRINGINFO_STRSTART:
+ IREG(1) = PTR2UINTVAL(SREG(2)->strstart);
+ break;
+ case STRINGINFO_BUFLEN:
+ IREG(1) = Buffer_buflen(SREG(2));
+ break;
+ case STRINGINFO_FLAGS:
+ IREG(1) = PObj_get_FLAGS(SREG(2));
+ break;
+ case STRINGINFO_BUFUSED:
+ IREG(1) = SREG(2)->bufused;
+ break;
+ case STRINGINFO_STRLEN:
+ IREG(1) = SREG(2)->strlen;
+ break;
+ default:
+ {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "stringinfo: unknown info type: %d", cur_opcode[3]);
+ return (opcode_t *)handler;
+ }
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_stringinfo_i_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (CONST(2)->u.string == NULL)
+ IREG(1) = 0;
+ else {
+ switch (cur_opcode[3]) {
+ case STRINGINFO_HEADER:
+ IREG(1) = PTR2UINTVAL(CONST(2)->u.string);
+ break;
+ case STRINGINFO_STRSTART:
+ IREG(1) = PTR2UINTVAL(CONST(2)->u.string->strstart);
+ break;
+ case STRINGINFO_BUFLEN:
+ IREG(1) = Buffer_buflen(CONST(2)->u.string);
+ break;
+ case STRINGINFO_FLAGS:
+ IREG(1) = PObj_get_FLAGS(CONST(2)->u.string);
+ break;
+ case STRINGINFO_BUFUSED:
+ IREG(1) = CONST(2)->u.string->bufused;
+ break;
+ case STRINGINFO_STRLEN:
+ IREG(1) = CONST(2)->u.string->strlen;
+ break;
+ default:
+ {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "stringinfo: unknown info type: %d", cur_opcode[3]);
+ return (opcode_t *)handler;
+ }
+ }
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_upcase_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_upcase(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_upcase_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_upcase(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_downcase_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_downcase(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_downcase_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_downcase(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_titlecase_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_titlecase(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_titlecase_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_titlecase(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_join_s_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_join(interp, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_join_s_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_join(interp, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_split_p_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_str_split(interp, SREG(2), SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_split_p_sc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_str_split(interp, CONST(2)->u.string, SREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_split_p_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_str_split(interp, SREG(2), CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_split_p_sc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = Parrot_str_split(interp, CONST(2)->u.string, CONST(3)->u.string);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_charset_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_charset_number_of_str(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_charset_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_charset_number_of_str(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_charsetname_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_charset_name(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_charsetname_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_charset_name(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_charset_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL n = Parrot_charset_number(interp, SREG(2));
+ if (n < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_CHARTYPE,
+ "charset '%Ss' not found", SREG(2));
+ return (opcode_t *)handler;
+ }
+ IREG(1) = n;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_charset_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL n = Parrot_charset_number(interp, CONST(2)->u.string);
+ if (n < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_CHARTYPE,
+ "charset '%Ss' not found", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+ IREG(1) = n;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_trans_charset_s_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_charset(interp, SREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_trans_charset_s_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_charset(interp, CONST(2)->u.string, IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_trans_charset_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_charset(interp, SREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_trans_charset_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_charset(interp, CONST(2)->u.string, cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_encoding_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_encoding_number_of_str(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_encoding_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_encoding_number_of_str(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_encodingname_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_encoding_name(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_encodingname_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_encoding_name(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_encoding_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL n = Parrot_encoding_number(interp, SREG(2));
+ if (n < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_ENCODING,
+ "encoding '%Ss' not found", SREG(2));
+ return (opcode_t *)handler;
+ }
+ IREG(1) = n;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_encoding_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const INTVAL n = Parrot_encoding_number(interp, CONST(2)->u.string);
+ if (n < 0) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_ENCODING,
+ "encoding '%Ss' not found", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+ IREG(1) = n;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_trans_encoding_s_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_encoding(interp, SREG(2), IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_trans_encoding_s_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_encoding(interp, CONST(2)->u.string, IREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_trans_encoding_s_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_encoding(interp, SREG(2), cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_trans_encoding_s_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_change_encoding(interp, CONST(2)->u.string, cur_opcode[3]);
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_is_cclass_i_i_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, IREG(2), SREG(3), IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_ic_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, cur_opcode[2], SREG(3), IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_i_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, IREG(2), CONST(3)->u.string, IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_ic_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, cur_opcode[2], CONST(3)->u.string, IREG(4));
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_i_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, IREG(2), SREG(3), cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_ic_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, cur_opcode[2], SREG(3), cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_i_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, IREG(2), CONST(3)->u.string, cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_is_cclass_i_ic_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_is_cclass(interp, cur_opcode[2], CONST(3)->u.string, cur_opcode[4]);
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_find_cclass_i_i_s_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), SREG(3), IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_s_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], SREG(3), IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_sc_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), CONST(3)->u.string, IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_sc_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], CONST(3)->u.string, IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_s_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), SREG(3), cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_s_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], SREG(3), cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_sc_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), CONST(3)->u.string, cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_sc_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], CONST(3)->u.string, cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_s_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), SREG(3), IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_s_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], SREG(3), IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_sc_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), CONST(3)->u.string, IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_sc_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], CONST(3)->u.string, IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_s_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), SREG(3), cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_s_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], SREG(3), cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_i_sc_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, IREG(2), CONST(3)->u.string, cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_cclass_i_ic_sc_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_cclass(interp, cur_opcode[2], CONST(3)->u.string, cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_s_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), SREG(3), IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_s_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], SREG(3), IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_sc_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), CONST(3)->u.string, IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_sc_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], CONST(3)->u.string, IREG(4), IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_s_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), SREG(3), cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_s_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], SREG(3), cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_sc_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), CONST(3)->u.string, cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_sc_ic_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], CONST(3)->u.string, cur_opcode[4], IREG(5));
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_s_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), SREG(3), IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_s_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], SREG(3), IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_sc_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), CONST(3)->u.string, IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_sc_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], CONST(3)->u.string, IREG(4), cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_s_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), SREG(3), cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_s_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], SREG(3), cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_i_sc_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, IREG(2), CONST(3)->u.string, cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_find_not_cclass_i_ic_sc_ic_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_str_find_not_cclass(interp, cur_opcode[2], CONST(3)->u.string, cur_opcode[4], cur_opcode[5]);
+
+return (opcode_t *)cur_opcode + 6;}
+
+opcode_t *
+Parrot_escape_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_escape(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_compose_s_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_compose(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_compose_s_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = Parrot_str_compose(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_spawnw_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_Run_OS_Command(interp, SREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_spawnw_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_Run_OS_Command(interp, CONST(2)->u.string);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_spawnw_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_Run_OS_Command_Argv(interp, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_err_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = errno;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_err_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const char * const tmp = strerror(errno);
+ SREG(1) = string_make(interp, tmp, strlen(tmp), "ascii", 0);
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_err_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const char * const tmp = strerror(IREG(2));
+ SREG(1) = string_make(interp, tmp, strlen(tmp), "ascii", 0);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_err_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ const char * const tmp = strerror(cur_opcode[2]);
+ SREG(1) = string_make(interp, tmp, strlen(tmp), "ascii", 0);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_time_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = Parrot_intval_time();
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_time_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ NREG(1) = Parrot_floatval_time();
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_gmtime_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) IREG(2);
+ char resultbuffer[26];
+ Parrot_gmtime_r(&t, &tm);
+ Parrot_asctime_r(&tm, resultbuffer);
+ SREG(1) = Parrot_str_new(interp, resultbuffer, 25);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_gmtime_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) cur_opcode[2];
+ char resultbuffer[26];
+ Parrot_gmtime_r(&t, &tm);
+ Parrot_asctime_r(&tm, resultbuffer);
+ SREG(1) = Parrot_str_new(interp, resultbuffer, 25);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_localtime_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) IREG(2);
+ char resultbuffer[26];
+ Parrot_localtime_r(&t, &tm);
+ Parrot_asctime_r(&tm, resultbuffer);
+ SREG(1) = Parrot_str_new(interp, resultbuffer, 25);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_localtime_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) cur_opcode[2];
+ char resultbuffer[26];
+ Parrot_localtime_r(&t, &tm);
+ Parrot_asctime_r(&tm, resultbuffer);
+ SREG(1) = Parrot_str_new(interp, resultbuffer, 25);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_decodetime_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) IREG(2);
+ Parrot_gmtime_r(&t, &tm);
+ PREG(1) = tm_to_array(interp, &tm);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_decodetime_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) cur_opcode[2];
+ Parrot_gmtime_r(&t, &tm);
+ PREG(1) = tm_to_array(interp, &tm);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_decodelocaltime_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) IREG(2);
+ Parrot_localtime_r(&t, &tm);
+ PREG(1) = tm_to_array(interp, &tm);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_decodelocaltime_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ struct tm tm;
+ const time_t t = (time_t) cur_opcode[2];
+ Parrot_localtime_r(&t, &tm);
+ PREG(1) = tm_to_array(interp, &tm);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sysinfo_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = sysinfo_s(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sysinfo_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ SREG(1) = sysinfo_s(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sysinfo_i_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = sysinfo_i(interp, IREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sysinfo_i_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ IREG(1) = sysinfo_i(interp, cur_opcode[2]);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_sleep_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *next = cur_opcode + 2;
+ if (IREG(1) < 0) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NEG_SLEEP,
+ "Cannot go back in time");
+ return (opcode_t *)handler;
+ }
+ next = (opcode_t *)Parrot_cx_schedule_sleep(interp, (FLOATVAL) IREG(1), next);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_sleep_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *next = cur_opcode + 2;
+ if (cur_opcode[1] < 0) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NEG_SLEEP,
+ "Cannot go back in time");
+ return (opcode_t *)handler;
+ }
+ next = (opcode_t *)Parrot_cx_schedule_sleep(interp, (FLOATVAL) cur_opcode[1], next);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_sleep_n(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *next = cur_opcode + 2;
+ if (NREG(1) < 0.0) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NEG_SLEEP,
+ "Cannot go back in time");
+ return (opcode_t *)handler;
+ }
+ next = (opcode_t *)Parrot_cx_schedule_sleep(interp, NREG(1), next);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_sleep_nc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *next = cur_opcode + 2;
+ if (CONST(1)->u.number < 0.0) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, next,
+ EXCEPTION_NEG_SLEEP,
+ "Cannot go back in time");
+ return (opcode_t *)handler;
+ }
+ next = (opcode_t *)Parrot_cx_schedule_sleep(interp, CONST(1)->u.number, next);
+ return (opcode_t *)next;
+}
+
+opcode_t *
+Parrot_store_lex_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+ STRING * const lex_name = SREG(1);
+ PMC * const lex_pad = Parrot_find_pad(interp, lex_name, ctx);
+
+ if (PMC_IS_NULL(lex_pad)) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_LEX_NOT_FOUND,
+ "Lexical '%Ss' not found", lex_name);
+ return (opcode_t *)handler;
+ }
+ VTABLE_set_pmc_keyed_str(interp, lex_pad, lex_name, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_store_lex_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+ STRING * const lex_name = CONST(1)->u.string;
+ PMC * const lex_pad = Parrot_find_pad(interp, lex_name, ctx);
+
+ if (PMC_IS_NULL(lex_pad)) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_LEX_NOT_FOUND,
+ "Lexical '%Ss' not found", lex_name);
+ return (opcode_t *)handler;
+ }
+ VTABLE_set_pmc_keyed_str(interp, lex_pad, lex_name, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_store_dynamic_lex_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const lex_name = SREG(1);
+ PMC * const ctx =
+ Parrot_pcc_get_caller_ctx(interp, CURRENT_CONTEXT(interp));
+ PMC * const lex_pad =
+ PMC_IS_NULL(ctx)
+ ? PMCNULL
+ : Parrot_find_dynamic_pad(interp, lex_name, ctx);
+
+ if (PMC_IS_NULL(lex_pad)) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_LEX_NOT_FOUND,
+ "Lexical '%Ss' not found in dynamic scope", lex_name);
+ return (opcode_t *)handler;
+ }
+ VTABLE_set_pmc_keyed_str(interp, lex_pad, lex_name, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_store_dynamic_lex_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const lex_name = CONST(1)->u.string;
+ PMC * const ctx =
+ Parrot_pcc_get_caller_ctx(interp, CURRENT_CONTEXT(interp));
+ PMC * const lex_pad =
+ PMC_IS_NULL(ctx)
+ ? PMCNULL
+ : Parrot_find_dynamic_pad(interp, lex_name, ctx);
+
+ if (PMC_IS_NULL(lex_pad)) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_LEX_NOT_FOUND,
+ "Lexical '%Ss' not found in dynamic scope", lex_name);
+ return (opcode_t *)handler;
+ }
+ VTABLE_set_pmc_keyed_str(interp, lex_pad, lex_name, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_lex_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+ STRING * const lex_name = SREG(2);
+ PMC * const lex_pad = Parrot_find_pad(interp, lex_name, ctx);
+
+ PMC * const result =
+ PMC_IS_NULL(lex_pad)
+ ? NULL
+ : VTABLE_get_pmc_keyed_str(interp, lex_pad, lex_name);
+ if (!result) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_LEX_NOT_FOUND,
+ "Lexical '%Ss' not found", lex_name);
+ return (opcode_t *)handler;
+ }
+ PREG(1) = result;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_lex_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const ctx = CURRENT_CONTEXT(interp);
+ STRING * const lex_name = CONST(2)->u.string;
+ PMC * const lex_pad = Parrot_find_pad(interp, lex_name, ctx);
+
+ PMC * const result =
+ PMC_IS_NULL(lex_pad)
+ ? NULL
+ : VTABLE_get_pmc_keyed_str(interp, lex_pad, lex_name);
+ if (!result) {
+ opcode_t * const handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_LEX_NOT_FOUND,
+ "Lexical '%Ss' not found", lex_name);
+ return (opcode_t *)handler;
+ }
+ PREG(1) = result;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_dynamic_lex_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const lex_name = SREG(2);
+ PMC * const ctx =
+ Parrot_pcc_get_caller_ctx(interp, CURRENT_CONTEXT(interp));
+ PMC * const lex_pad =
+ PMC_IS_NULL(ctx)
+ ? PMCNULL
+ : Parrot_find_dynamic_pad(interp, lex_name, ctx);
+ PMC * const result =
+ PMC_IS_NULL(lex_pad)
+ ? PMCNULL
+ : VTABLE_get_pmc_keyed_str(interp, lex_pad, lex_name);
+ PREG(1) = result;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_dynamic_lex_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const lex_name = CONST(2)->u.string;
+ PMC * const ctx =
+ Parrot_pcc_get_caller_ctx(interp, CURRENT_CONTEXT(interp));
+ PMC * const lex_pad =
+ PMC_IS_NULL(ctx)
+ ? PMCNULL
+ : Parrot_find_dynamic_pad(interp, lex_name, ctx);
+ PMC * const result =
+ PMC_IS_NULL(lex_pad)
+ ? PMCNULL
+ : VTABLE_get_pmc_keyed_str(interp, lex_pad, lex_name);
+ PREG(1) = result;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_caller_lex_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const lex_name = SREG(2);
+ PMC * ctx = CURRENT_CONTEXT(interp);
+ PMC * result = PMCNULL;
+
+ for (ctx = Parrot_pcc_get_caller_ctx(interp, ctx);
+ !PMC_IS_NULL(ctx) && PMC_IS_NULL(result);
+ ctx = Parrot_pcc_get_caller_ctx(interp, ctx))
+ {
+ PMC * const lex_pad = Parrot_find_pad(interp, lex_name, ctx);
+ if (!PMC_IS_NULL(lex_pad)) {
+ result = VTABLE_get_pmc_keyed_str(interp, lex_pad, lex_name);
+ }
+ if (!result) result = PMCNULL;
+ }
+ PREG(1) = result;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_caller_lex_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const lex_name = CONST(2)->u.string;
+ PMC * ctx = CURRENT_CONTEXT(interp);
+ PMC * result = PMCNULL;
+
+ for (ctx = Parrot_pcc_get_caller_ctx(interp, ctx);
+ !PMC_IS_NULL(ctx) && PMC_IS_NULL(result);
+ ctx = Parrot_pcc_get_caller_ctx(interp, ctx))
+ {
+ PMC * const lex_pad = Parrot_find_pad(interp, lex_name, ctx);
+ if (!PMC_IS_NULL(lex_pad)) {
+ result = VTABLE_get_pmc_keyed_str(interp, lex_pad, lex_name);
+ }
+ if (!result) result = PMCNULL;
+ }
+ PREG(1) = result;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_namespace_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PREG(1) = cur_ns;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_get_namespace_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PMC * const ns = Parrot_get_namespace_keyed(interp, cur_ns, PREG(2));
+
+ PREG(1) = PMC_IS_NULL(ns) ? PMCNULL : ns;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_namespace_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PMC * const ns = Parrot_get_namespace_keyed(interp, cur_ns, CONST(2)->u.key);
+
+ PREG(1) = PMC_IS_NULL(ns) ? PMCNULL : ns;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_hll_namespace_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PREG(1) = hll_ns;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_get_hll_namespace_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ if (PMC_IS_NULL(hll_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, hll_ns, PREG(2));
+ PREG(1) = ns;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_hll_namespace_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ if (PMC_IS_NULL(hll_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, hll_ns, CONST(2)->u.key);
+ PREG(1) = ns;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_root_namespace_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PREG(1) = root_ns;
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_get_root_namespace_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ if (PMC_IS_NULL(root_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, PREG(2));
+ PREG(1) = ns;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_root_namespace_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ if (PMC_IS_NULL(root_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, CONST(2)->u.key);
+ PREG(1) = ns;
+ }
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_global_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PREG(1) = Parrot_find_global_op(interp, cur_ns, SREG(2), cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_global_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PREG(1) = Parrot_find_global_op(interp, cur_ns, CONST(2)->u.string, cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_global_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ if (PMC_IS_NULL(cur_ns)) {
+ PREG(1) = PMCNULL;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, cur_ns, PREG(2));
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, SREG(3), cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_global_p_pc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ if (PMC_IS_NULL(cur_ns)) {
+ PREG(1) = PMCNULL;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, cur_ns, CONST(2)->u.key);
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, SREG(3), cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_global_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ if (PMC_IS_NULL(cur_ns)) {
+ PREG(1) = PMCNULL;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, cur_ns, PREG(2));
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, CONST(3)->u.string, cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_global_p_pc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ if (PMC_IS_NULL(cur_ns)) {
+ PREG(1) = PMCNULL;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, cur_ns, CONST(2)->u.key);
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, CONST(3)->u.string, cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_hll_global_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PREG(1) = Parrot_find_global_op(interp, hll_ns, SREG(2), cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_hll_global_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PREG(1) = Parrot_find_global_op(interp, hll_ns, CONST(2)->u.string, cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_hll_global_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ if (PMC_IS_NULL(hll_ns)) {
+ PREG(1) = hll_ns;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, hll_ns, PREG(2));
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, SREG(3), cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_hll_global_p_pc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ if (PMC_IS_NULL(hll_ns)) {
+ PREG(1) = hll_ns;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, hll_ns, CONST(2)->u.key);
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, SREG(3), cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_hll_global_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ if (PMC_IS_NULL(hll_ns)) {
+ PREG(1) = hll_ns;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, hll_ns, PREG(2));
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, CONST(3)->u.string, cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_hll_global_p_pc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ if (PMC_IS_NULL(hll_ns)) {
+ PREG(1) = hll_ns;
+ }
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, hll_ns, CONST(2)->u.key);
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, CONST(3)->u.string, cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_root_global_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PREG(1) = Parrot_find_global_op(interp, root_ns, SREG(2), cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_root_global_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PREG(1) = Parrot_find_global_op(interp, root_ns, CONST(2)->u.string, cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_root_global_p_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ if (PMC_IS_NULL(root_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, PREG(2));
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, SREG(3), cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_root_global_p_pc_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ if (PMC_IS_NULL(root_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, CONST(2)->u.key);
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, SREG(3), cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_root_global_p_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ if (PMC_IS_NULL(root_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, PREG(2));
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, CONST(3)->u.string, cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_get_root_global_p_pc_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ if (PMC_IS_NULL(root_ns))
+ PREG(1) = PMCNULL;
+ else {
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, CONST(2)->u.key);
+ if (PMC_IS_NULL(ns))
+ PREG(1) = PMCNULL;
+ else
+ PREG(1) = Parrot_find_global_op(interp, ns, CONST(3)->u.string, cur_opcode + 4);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_global_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ Parrot_set_global(interp, cur_ns, SREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_global_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ Parrot_set_global(interp, cur_ns, CONST(1)->u.string, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_global_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PMC * const ns = Parrot_make_namespace_keyed(interp, cur_ns, PREG(1));
+
+ Parrot_set_global(interp, ns, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_global_pc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PMC * const ns = Parrot_make_namespace_keyed(interp, cur_ns, CONST(1)->u.key);
+
+ Parrot_set_global(interp, ns, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_global_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PMC * const ns = Parrot_make_namespace_keyed(interp, cur_ns, PREG(1));
+
+ Parrot_set_global(interp, ns, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_global_pc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const cur_ns = Parrot_pcc_get_namespace(interp, CURRENT_CONTEXT(interp));
+ PMC * const ns = Parrot_make_namespace_keyed(interp, cur_ns, CONST(1)->u.key);
+
+ Parrot_set_global(interp, ns, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_hll_global_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ Parrot_set_global(interp, hll_ns, SREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_hll_global_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ Parrot_set_global(interp, hll_ns, CONST(1)->u.string, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_hll_global_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PMC * const ns = Parrot_make_namespace_keyed(interp, hll_ns, PREG(1));
+
+ Parrot_set_global(interp, ns, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_hll_global_pc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PMC * const ns = Parrot_make_namespace_keyed(interp, hll_ns, CONST(1)->u.key);
+
+ Parrot_set_global(interp, ns, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_hll_global_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PMC * const ns = Parrot_make_namespace_keyed(interp, hll_ns, PREG(1));
+
+ Parrot_set_global(interp, ns, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_hll_global_pc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const hll_ns = Parrot_get_ctx_HLL_namespace(interp);
+ PMC * const ns = Parrot_make_namespace_keyed(interp, hll_ns, CONST(1)->u.key);
+
+ Parrot_set_global(interp, ns, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_root_global_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ Parrot_set_global(interp, root_ns, SREG(1), PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_root_global_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ Parrot_set_global(interp, root_ns, CONST(1)->u.string, PREG(2));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_set_root_global_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_make_namespace_keyed(interp, root_ns, PREG(1));
+
+ Parrot_set_global(interp, ns, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_root_global_pc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_make_namespace_keyed(interp, root_ns, CONST(1)->u.key);
+
+ Parrot_set_global(interp, ns, SREG(2), PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_root_global_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_make_namespace_keyed(interp, root_ns, PREG(1));
+
+ Parrot_set_global(interp, ns, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_set_root_global_pc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_make_namespace_keyed(interp, root_ns, CONST(1)->u.key);
+
+ Parrot_set_global(interp, ns, CONST(2)->u.string, PREG(3));
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_find_name_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!SREG(2)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "Tried to find null name");
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_find_name_op(interp, SREG(2), cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_name_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ if (!CONST(2)->u.string) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "Tried to find null name");
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = Parrot_find_name_op(interp, CONST(2)->u.string, cur_opcode + 3);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_sub_not_null_p_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest = cur_opcode + 3;
+ PMC *sub = Parrot_find_name_op(interp, SREG(2), dest);
+
+ if (PMC_IS_NULL(sub)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_GLOBAL_NOT_FOUND,
+ "Could not find sub %Ss", SREG(2));
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = sub;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_sub_not_null_p_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ opcode_t *dest = cur_opcode + 3;
+ PMC *sub = Parrot_find_name_op(interp, CONST(2)->u.string, dest);
+
+ if (PMC_IS_NULL(sub)) {
+ opcode_t *handler = Parrot_ex_throw_from_op_args(interp, dest,
+ EXCEPTION_GLOBAL_NOT_FOUND,
+ "Could not find sub %Ss", CONST(2)->u.string);
+ return (opcode_t *)handler;
+ }
+
+ PREG(1) = sub;
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_trap(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#if defined(__GNUC__) && defined(i386)
+ __asm__("int3"); /* opcode 0xcc */
+#endif
+#if defined(__GNUC__) && defined(PPC)
+ __asm__("trap"); /* opcode tr 31, 0, 0 */
+#endif
+
+return (opcode_t *)cur_opcode + 1;}
+
+opcode_t *
+Parrot_set_label_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ VTABLE_set_pointer(interp, PREG(1), (CUR_OPCODE + cur_opcode[2]));
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_get_label_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ void * const ptr = VTABLE_get_pointer(interp, PREG(2));
+ IREG(1) = PTR2INTVAL(ptr);
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_fetch_p_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), PREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, PREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), CONST(3)->u.key);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, CONST(3)->u.key);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), PREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, PREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), CONST(3)->u.key);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, CONST(3)->u.key);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), IREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, IREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_ic_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), cur_opcode[3]);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_ic_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, cur_opcode[3]);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_i_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), IREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_i_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, IREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_ic_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), cur_opcode[3]);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_ic_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, cur_opcode[3]);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), SREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, SREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), CONST(3)->u.string);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, CONST(3)->u.string);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), SREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, SREG(3));
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_p_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), CONST(3)->u.string);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_fetch_p_pc_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, CONST(3)->u.string);
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), PREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, PREG(2), PREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_p_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, PREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, CONST(2)->u.key, PREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), CONST(3)->u.key);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, PREG(2), CONST(3)->u.key, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_pc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, CONST(3)->u.key);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, CONST(2)->u.key, CONST(3)->u.key, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), PREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, PREG(2), PREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_p_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, PREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, CONST(2)->u.key, PREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, PREG(2), CONST(3)->u.key);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, PREG(2), CONST(3)->u.key, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_pc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed(interp, CONST(2)->u.key, CONST(3)->u.key);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+ VTABLE_set_pmc_keyed(interp, CONST(2)->u.key, CONST(3)->u.key, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), IREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, PREG(2), IREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_i_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, IREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, CONST(2)->u.key, IREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_ic_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, PREG(2), cur_opcode[3], PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_ic_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, cur_opcode[3]);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, CONST(2)->u.key, cur_opcode[3], PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_i_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), IREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, PREG(2), IREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_i_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, IREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, CONST(2)->u.key, IREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_ic_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, PREG(2), cur_opcode[3]);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, PREG(2), cur_opcode[3], PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_ic_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_int(interp, CONST(2)->u.key, cur_opcode[3]);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_int(interp, CONST(2)->u.key, cur_opcode[3], PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), SREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, PREG(2), SREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_s_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, SREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, CONST(2)->u.key, SREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), CONST(3)->u.string);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, PREG(2), CONST(3)->u.string, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_sc_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, CONST(3)->u.string);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, PREG(4));
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, PREG(4));
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, PREG(4)));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, CONST(2)->u.key, CONST(3)->u.string, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), SREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, PREG(2), SREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_s_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, SREG(3));
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, CONST(2)->u.key, SREG(3), PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_p_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, PREG(2), CONST(3)->u.string);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, PREG(2), CONST(3)->u.string, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_vivify_p_pc_sc_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PREG(1) = VTABLE_get_pmc_keyed_str(interp, CONST(2)->u.key, CONST(3)->u.string);
+
+ if (PMC_IS_NULL(PREG(1))) {
+ PMC * const classobj = Parrot_oo_get_class(interp, CONST(4)->u.key);
+ if (!PMC_IS_NULL(classobj))
+ PREG(1) = VTABLE_instantiate(interp, classobj, PMCNULL);
+ else {
+ const INTVAL type = Parrot_pmc_get_type(interp, CONST(4)->u.key);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(
+ interp, cur_opcode + 5, EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, CONST(4)->u.key));
+ return (opcode_t *)dest;
+ }
+
+ PREG(1) = Parrot_pmc_new(interp, type);
+ }
+
+ VTABLE_set_pmc_keyed_str(interp, CONST(2)->u.key, CONST(3)->u.string, PREG(1));
+ }
+
+return (opcode_t *)cur_opcode + 5;}
+
+opcode_t *
+Parrot_new_p_s_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = SREG(2);
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, IREG(3));
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, IREG(3));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_sc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = CONST(2)->u.string;
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, IREG(3));
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, IREG(3));
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_s_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = SREG(2);
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, cur_opcode[3]);
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, cur_opcode[3]);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_sc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ STRING * const name = CONST(2)->u.string;
+ PMC * const _class = Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp))
+ ? Parrot_oo_get_class_str(interp, name)
+ : PMCNULL;
+
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp, Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, cur_opcode[3]);
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ else {
+ const INTVAL type = Parrot_pmc_get_type_str(interp, name);
+ if (type <= 0) {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", name);
+ return (opcode_t *)dest;
+ }
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, cur_opcode[3]);
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, IREG(3));
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, IREG(3));
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_pc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, IREG(3));
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, IREG(3));
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, cur_opcode[3]);
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, cur_opcode[3]);
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_new_p_pc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const _class = Parrot_oo_get_class(interp, name_key);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, cur_opcode[3]);
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, cur_opcode[3]);
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_p_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, name_key);
+ PMC * const _class = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, IREG(3));
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, IREG(3));
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_pc_i(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, name_key);
+ PMC * const _class = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, IREG(3));
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, IREG(3));
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_p_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = PREG(2);
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, name_key);
+ PMC * const _class = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, cur_opcode[3]);
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, cur_opcode[3]);
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_root_new_p_pc_ic(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ PMC * const name_key = CONST(2)->u.key;
+
+ /* get_class() returns a PMCProxy for core types, so check for core PMCs */
+ const INTVAL type = Parrot_pmc_get_type(interp, name_key);
+
+ /* if it's clearly a PIR-level PMC */
+ if (type > enum_class_core_max) {
+ PMC * const root_ns = interp->root_namespace;
+ PMC * const ns = Parrot_get_namespace_keyed(interp, root_ns, name_key);
+ PMC * const _class = Parrot_oo_get_class(interp, ns);
+ if (!PMC_IS_NULL(_class)) {
+ PMC *initial = Parrot_pmc_new(interp,
+ Parrot_get_ctx_HLL_type(interp, enum_class_Integer));
+ VTABLE_set_integer_native(interp, initial, cur_opcode[3]);
+ PREG(1) = VTABLE_instantiate(interp, _class, initial);
+ }
+ }
+
+ /* if it's a core PMC */
+ else if (type > enum_class_default)
+ PREG(1) = Parrot_pmc_new_init_int(interp, type, cur_opcode[3]);
+
+ /* it's a typo */
+ else {
+ opcode_t *dest = Parrot_ex_throw_from_op_args(interp, cur_opcode + 4,
+ EXCEPTION_NO_CLASS,
+ "Class '%Ss' not found", VTABLE_get_repr(interp, name_key));
+ return (opcode_t *)dest;
+ }
+
+return (opcode_t *)cur_opcode + 4;}
+
+opcode_t *
+Parrot_find_codepoint_i_s(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#if PARROT_HAS_ICU
+ UErrorCode err = U_ZERO_ERROR;
+ char * const cstr = Parrot_str_to_cstring(interp, SREG(2));
+ UChar32 codepoint = u_charFromName(U_EXTENDED_CHAR_NAME, cstr, &err);
+ Parrot_str_free_cstring(cstr);
+ IREG(1) = U_SUCCESS(err) ? (INTVAL) codepoint : -1;
+#else
+ opcode_t * const dest = cur_opcode + 3;
+ Parrot_ex_throw_from_op_args(interp, dest, EXCEPTION_LIBRARY_ERROR,
+ "no ICU lib loaded");
+#endif
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_find_codepoint_i_sc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+#if PARROT_HAS_ICU
+ UErrorCode err = U_ZERO_ERROR;
+ char * const cstr = Parrot_str_to_cstring(interp, CONST(2)->u.string);
+ UChar32 codepoint = u_charFromName(U_EXTENDED_CHAR_NAME, cstr, &err);
+ Parrot_str_free_cstring(cstr);
+ IREG(1) = U_SUCCESS(err) ? (INTVAL) codepoint : -1;
+#else
+ opcode_t * const dest = cur_opcode + 3;
+ Parrot_ex_throw_from_op_args(interp, dest, EXCEPTION_LIBRARY_ERROR,
+ "no ICU lib loaded");
+#endif
+
+return (opcode_t *)cur_opcode + 3;}
+
+opcode_t *
+Parrot_unroll_p(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ /* Go to the next op after loop unrolling */
+ opcode_t * const dest = cur_opcode + 2;
+ PMC *eh = PMCNULL;
+ if (!PMC_IS_NULL(PREG(1))) {
+ /* If isa ExceptionHandler, use it. If isa Exception, get its active handler */
+ if (VTABLE_isa(interp, PREG(1), Parrot_str_new_constant(interp, "ExceptionHandler")))
+ eh = PREG(1);
+ else if (VTABLE_isa(interp, PREG(1), Parrot_str_new_constant(interp, "Exception"))) {
+ PMC *iter = VTABLE_get_attr_str(interp,
+ PREG(1), Parrot_str_new_constant(interp, "handler_iter"));
+ if (!PMC_IS_NULL(iter))
+ eh = VTABLE_get_pmc_keyed_int(interp, iter, -1);
+ }
+ }
+ if (!PMC_IS_NULL(eh)) {
+ /* Get the runloop_id from the continuation and jump to it. */
+ Parrot_runloop *rl = interp->current_runloop;
+ INTVAL rid;
+ Parrot_pcc_invoke_method_from_c_args(interp,
+ eh, Parrot_str_new_constant(interp, "rid"),
+ "->I", &rid);
+ while (rl && rl->id != rid)
+ rl = rl->prev;
+ if (rl) {
+ if (rl != interp->current_runloop) {
+ rl->handler_start = dest;
+ longjmp(rl->resume, 3);
+ }
+ }
+ else
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION, "missing runloop");
+ }
+
+return (opcode_t *)cur_opcode + 2;}
+
+opcode_t *
+Parrot_unroll_pc(opcode_t *cur_opcode, PARROT_INTERP) {
+ const Parrot_Context * const CUR_CTX = Parrot_pcc_get_context_struct(interp, interp->ctx);
+ /* Go to the next op after loop unrolling */
+ opcode_t * const dest = cur_opcode + 2;
+ PMC *eh = PMCNULL;
+ if (!PMC_IS_NULL(CONST(1)->u.key)) {
+ /* If isa ExceptionHandler, use it. If isa Exception, get its active handler */
+ if (VTABLE_isa(interp, CONST(1)->u.key, Parrot_str_new_constant(interp, "ExceptionHandler")))
+ eh = CONST(1)->u.key;
+ else if (VTABLE_isa(interp, CONST(1)->u.key, Parrot_str_new_constant(interp, "Exception"))) {
+ PMC *iter = VTABLE_get_attr_str(interp,
+ CONST(1)->u.key, Parrot_str_new_constant(interp, "handler_iter"));
+ if (!PMC_IS_NULL(iter))
+ eh = VTABLE_get_pmc_keyed_int(interp, iter, -1);
+ }
+ }
+ if (!PMC_IS_NULL(eh)) {
+ /* Get the runloop_id from the continuation and jump to it. */
+ Parrot_runloop *rl = interp->current_runloop;
+ INTVAL rid;
+ Parrot_pcc_invoke_method_from_c_args(interp,
+ eh, Parrot_str_new_constant(interp, "rid"),
+ "->I", &rid);
+ while (rl && rl->id != rid)
+ rl = rl->prev;
+ if (rl) {
+ if (rl != interp->current_runloop) {
+ rl->handler_start = dest;
+ longjmp(rl->resume, 3);
+ }
+ }
+ else
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION, "missing runloop");
+ }
+
+return (opcode_t *)cur_opcode + 2;}
+
+
+/*
+** op lib descriptor:
+*/
+
+static op_lib_t core_op_lib = {
+ "core", /* name */
+ "", /* suffix */
+ PARROT_FUNCTION_CORE, /* core_type = PARROT_XX_CORE */
+ 0, /* flags */
+ 2, /* major_version */
+ 4, /* minor_version */
+ 0, /* patch_version */
+ 1268, /* op_count */
+ core_op_info_table, /* op_info_table */
+ core_op_func_table, /* op_func_table */
+ get_op /* op_code() */
+};
+
+/*
+** Op lookup function:
+*/
+
+#define OP_HASH_SIZE 3041
+
+/* we could calculate a prime somewhat bigger than
+ * n of fullnames + n of names
+ * for now this should be ok
+ *
+ * look up an op_code: at first call to op_code() a hash
+ * of short and full opcode names is created
+ * hash functions are from imcc, thanks to Melvin.
+ */
+
+
+typedef struct hop {
+ op_info_t * info;
+ struct hop *next;
+} HOP;
+static HOP **hop;
+
+static void hop_init(PARROT_INTERP);
+static size_t hash_str(const char *str);
+static void store_op(PARROT_INTERP, op_info_t *info, int full);
+
+/* XXX on changing interpreters, this should be called,
+ through a hook */
+
+static void hop_deinit(PARROT_INTERP);
+
+/*
+ * find a short or full opcode
+ * usage:
+ *
+ * interp->op_lib->op_code("set", 0)
+ * interp->op_lib->op_code("set_i_i", 1)
+ *
+ * returns >= 0 (found idx into info_table), -1 if not
+ */
+
+static size_t hash_str(const char *str) {
+ size_t key = 0;
+ const char *s = str;
+
+ while (*s) {
+ key *= 65599;
+ key += *s++;
+ }
+
+ return key;
+}
+
+static void store_op(PARROT_INTERP, op_info_t *info, int full) {
+ HOP * const p = mem_gc_allocate_zeroed_typed(interp, HOP);
+ const size_t hidx =
+ hash_str(full ? info->full_name : info->name) % OP_HASH_SIZE;
+
+ p->info = info;
+ p->next = hop[hidx];
+ hop[hidx] = p;
+}
+static int get_op(PARROT_INTERP, const char * name, int full) {
+ const HOP * p;
+ const size_t hidx = hash_str(name) % OP_HASH_SIZE;
+ if (!hop) {
+ hop = mem_gc_allocate_n_zeroed_typed(interp, OP_HASH_SIZE,HOP *);
+ hop_init(interp);
+ }
+ for (p = hop[hidx]; p; p = p->next) {
+ if(STREQ(name, full ? p->info->full_name : p->info->name))
+ return p->info - core_op_lib.op_info_table;
+ }
+ return -1;
+}
+static void hop_init(PARROT_INTERP) {
+ size_t i;
+ op_info_t * const info = core_op_lib.op_info_table;
+ /* store full names */
+ for (i = 0; i < core_op_lib.op_count; i++)
+ store_op(interp, info + i, 1);
+ /* plus one short name */
+ for (i = 0; i < core_op_lib.op_count; i++)
+ if (get_op(interp, info[i].name, 0) == -1)
+ store_op(interp, info + i, 0);
+}
+static void hop_deinit(PARROT_INTERP)
+{
+ if (hop) {
+ size_t i;
+ for (i = 0; i < OP_HASH_SIZE; i++) {
+ HOP *p = hop[i];
+ while (p) {
+ HOP * const next = p->next;
+ mem_gc_free(interp, p);
+ p = next;
+ }
+ }
+ mem_sys_free(hop);
+ hop = NULL;
+ }
+}
+op_lib_t *
+Parrot_DynOp_core_2_4_0(PARROT_INTERP, long init) {
+ /* initialize and return op_lib ptr */
+ if (init == 1) {
+
+ return &core_op_lib;
+ }
+ /* set op_lib to the passed ptr (in init) */
+ else if (init) {
+
+ }
+ /* deinit - free resources */
+ else {
+ hop_deinit(interp);
+ }
+ return NULL;
+}
+
+
+/*
+ * dynamic lib load function - called once
+ */
+ PMC*
+Parrot_lib_core_ops_load(PARROT_INTERP);
+
+ PMC*
+Parrot_lib_core_ops_load(PARROT_INTERP)
+
+{
+ PMC *const lib = Parrot_pmc_new(interp, enum_class_ParrotLibrary);
+ ((Parrot_ParrotLibrary_attributes*)PMC_data(lib))->oplib_init = (void *) Parrot_DynOp_core_2_4_0;
+ dynop_register(interp, lib);
+ return lib;
+}
+
+
+/*
+ * Local variables:
+ * c-file-style: "parrot"
+ * buffer-read-only: t
+ * End:
+ * vim: expandtab shiftwidth=4:
+ */
Modified: trunk/src/ops/var.ops
==============================================================================
--- trunk/src/ops/var.ops Sun May 23 21:12:16 2010 (r46921)
+++ trunk/src/ops/var.ops Sun May 23 21:38:28 2010 (r46922)
@@ -496,7 +496,7 @@
=head1 COPYRIGHT
-Copyright (C) 2001-2009, Parrot Foundation.
+Copyright (C) 2001-2010, Parrot Foundation.
=head1 LICENSE
Modified: trunk/src/pmc/nci.pmc
==============================================================================
--- trunk/src/pmc/nci.pmc Sun May 23 21:12:16 2010 (r46921)
+++ trunk/src/pmc/nci.pmc Sun May 23 21:38:28 2010 (r46922)
@@ -169,6 +169,7 @@
pmclass NCI auto_attrs provides invokable {
/* NCI thunk handling attributes */
+ /* NCI thunk handling attributes */
ATTR STRING *signature; /* The signature. */
ATTR void *func; /* Function pointer to call. */
ATTR PMC *fb_info; /* Frame-builder info */
Modified: trunk/t/codingstd/linelength.t
==============================================================================
--- trunk/t/codingstd/linelength.t Sun May 23 21:12:16 2010 (r46921)
+++ trunk/t/codingstd/linelength.t Sun May 23 21:38:28 2010 (r46922)
@@ -125,6 +125,8 @@
compilers/pirc/macro/macroparser.h
compilers/pirc/src/hdocprep.l
compilers/pirc/src/hdocprep.c
+# generated files
+src/ops/core_ops.c
# generated by tools/dev/nci_thunk_gen.pir
src/nci/core_thunks.c
src/nci/extra_thunks.c
Modified: trunk/t/codingstd/perlcritic.t
==============================================================================
--- trunk/t/codingstd/perlcritic.t Sun May 23 21:12:16 2010 (r46921)
+++ trunk/t/codingstd/perlcritic.t Sun May 23 21:38:28 2010 (r46922)
@@ -1,5 +1,5 @@
#! perl
-# Copyright (C) 2008-2009, Parrot Foundation.
+# Copyright (C) 2008-2010, Parrot Foundation.
# $Id$
=head1 NAME
@@ -85,6 +85,7 @@
@files = grep {! m/$filter_languages/}
map { $_->path }
grep { $_->read !~ m/use v6;/ }
+ grep { $_->read !~ m/#! nqp/ }
$dist->get_perl_language_files();
}
else {
Added: trunk/t/compilers/opsc/01-parse.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/01-parse.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,205 @@
+#! parrot
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+.include 't/compilers/opsc/common.pir'
+
+.sub 'main' :main
+
+ .include 'test_more.pir'
+ load_bytecode 'opsc.pbc'
+
+ plan(12)
+
+ test_parse_basic_op()
+ test_parse_many_ops()
+ test_parse_header()
+ test_parse_params()
+ test_parse_flags()
+.end
+
+.sub "test_parse_basic_op"
+ .local string buf
+ .local pmc res
+
+ buf = <<"END"
+inline op noop() {
+}
+END
+
+ "_parse_buffer"(buf)
+ is(1, 1, "Simple noop parsed")
+
+ buf = <<"END"
+inline op noop() {
+ foo
+}
+END
+
+ "_parse_buffer"(buf)
+ is(1, 1, "noop body parsed")
+
+ buf = <<"END"
+inline op noop() {
+ foo {
+ bar{};
+ }
+}
+END
+
+ "_parse_buffer"(buf)
+ is(1, 1, "noop nested body parsed")
+
+
+.end
+
+.sub "test_parse_many_ops"
+ .local string buf
+ .local pmc res
+
+ buf = <<"END"
+
+
+=item noop
+
+asdfs
+
+=cut
+
+inline op noop() {
+}
+
+=item halt
+
+asdsad
+
+=cut
+
+inline op halt() {
+}
+
+=head2
+
+ads
+
+=cut
+
+inline op rule_the_world() {
+}
+
+
+END
+
+ res = "_parse_buffer"(buf)
+ is(1, 1, "Multiple ops parsed")
+
+ $I0 = res['body';'op']
+ is($I0, 3, "...and we have 3 ops")
+
+.end
+
+# test parsing ops file header.
+.sub "test_parse_header"
+ .local string buf
+ .local pmc res
+
+ buf = <<"END"
+/*
+ * $Id$
+** core.ops
+*/
+
+BEGIN_OPS_PREAMBLE
+
+#include "parrot/dynext.h"
+#include "parrot/embed.h"
+#include "parrot/runcore_api.h"
+#include "../pmc/pmc_continuation.h"
+#include "../pmc/pmc_parrotlibrary.h"
+
+END_OPS_PREAMBLE
+
+=head1 NAME
+
+core.ops - Core Opcodes
+
+=cut
+
+=head1 DESCRIPTION
+
+Parrot's core library of ops.
+
+Core operations are primarily flow control and interpreter
+introspection.
+
+=cut
+
+inline op noop() {
+}
+
+END
+
+ res = "_parse_buffer"(buf)
+ is(1, 1, "Header parsed")
+
+ $I0 = res['body';'op']
+ is($I0, 1, "...and we have our op")
+
+.end
+
+.sub "test_parse_params"
+ .local string buf
+ .local pmc res
+
+ buf = <<"END"
+
+inline op reserved(inconst INT) {
+ /* reserve 1 entries */
+}
+
+END
+
+ "_parse_buffer"(buf)
+ is(1, 1, "Op with single param parsed")
+
+ buf = <<"END"
+
+inline op add(out INT, inconst INT, inconst INT) {
+}
+
+END
+
+ "_parse_buffer"(buf)
+ is(1, 1, "Op with multiple param parsed")
+
+.end
+
+.sub "test_parse_flags"
+ .local string buf
+ .local pmc res
+
+ buf = <<"END"
+
+inline op hcf() :flow :deprecated {
+}
+
+END
+
+ res = "_parse_buffer"(buf)
+ is(1, 1, "Op with flags parsed")
+
+ .local pmc op
+ op = res['body';'op';0;'op_flag']
+ $S0 = op[0]
+ is($S0, ":flow ", "First flag parsed")
+ $S0 = op[1]
+ is($S0, ":deprecated ", "Second flag parsed")
+.end
+
+# Don't forget to update plan!
+
+# Local Variables:
+# mode: pir
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=pir:
Added: trunk/t/compilers/opsc/02-parse-all-ops.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/02-parse-all-ops.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,90 @@
+#! parrot
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+.include 't/compilers/opsc/common.pir'
+
+.sub 'main' :main
+ .include 'test_more.pir'
+ load_bytecode 'opsc.pbc'
+
+ .local int total
+ .local pmc os, all_files, ops_files, dynops_files
+
+ all_files = new ['ResizablePMCArray']
+ ops_files = get_ops_from_dir('./src/ops/')
+ dynops_files = get_ops_from_dir('./src/dynoplibs/')
+
+ #prepend the arrays to all_files
+ splice all_files, ops_files, 0, 0
+ splice all_files, dynops_files, 0, 0
+
+ total = elements all_files
+ all_files.'sort'()
+
+ plan(total)
+ test_parse(all_files)
+.end
+
+.sub get_ops_from_dir
+ .param string dir
+ .local pmc files, filtered_files, os, it
+
+ $P0 = loadlib 'os'
+ os = new ['OS']
+ files = os.'readdir'(dir)
+ filtered_files = new ['ResizablePMCArray']
+
+ .local int len, is_pmc, total
+ .local string filename, filename_end
+
+ #filter out anything that doesn't end in .ops
+ it = iter files
+ iter_start:
+ unless it goto iter_done
+ filename = shift it
+
+ len = length filename
+ unless len > 4 goto iter_start
+
+ filename_end = substr filename, -4
+ is_pmc = iseq filename_end, ".ops"
+ unless is_pmc goto iter_start
+
+ filename = dir . filename
+ push filtered_files, filename
+ goto iter_start
+
+ iter_done:
+ .return (filtered_files)
+.end
+
+.sub 'test_parse'
+ .param pmc list
+ .local int i
+ .local pmc it
+
+ it = iter list
+ iter_start:
+ unless it goto iter_done
+ $S0 = shift it
+ push_eh fail
+ _parse_one_file($S0)
+ pop_eh
+ ok(1, $S0)
+ goto iter_start
+ fail:
+ ok(0, $S0)
+ goto iter_start
+
+ iter_done:
+
+.end
+
+# Don't forget to update plan!
+
+# Local Variables:
+# mode: pir
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=pir:
Added: trunk/t/compilers/opsc/03-past.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/03-past.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,110 @@
+#! ./parrot-nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+
+# "Comprehensive" test for creating PAST for op.
+# Parse single op and check various aspects of created PAST.
+
+pir::load_bytecode('opsc.pbc');
+pir::load_bytecode('dumper.pbc');
+
+plan(26);
+
+my $buf := q|
+BEGIN_OPS_PREAMBLE
+/*
+THE HEADER
+*/
+END_OPS_PREAMBLE
+
+op bar() {
+ # Nothing here
+}
+
+inline op foo(out INT, in PMC, inconst NUM) :flow :deprecated {
+ foo # We don't handle anything in C<body> during parse/past.
+}
+
+|;
+my $compiler := pir::compreg__Ps('Ops');
+
+my $past := $compiler.compile($buf, target => 'past');
+
+ok(1, "PAST::Node created");
+
+my $preambles := $past<preamble>;
+
+ok(~$preambles[0] ~~ /HEADER/, 'Header parsed');
+
+my @ops := @($past<ops>);
+# One "bar" and two "foo"
+ok(+ at ops == 3, 'We have 3 ops');
+
+my $op := @ops[1];
+ok($op.name == 'foo', "Name parsed");
+
+my %flags := $op<flags>;
+ok(%flags<flow>, ':flow flag parsed');
+ok(%flags<deprecated>, ':deprecated flag parsed');
+ok(%flags == 2, "And there are only 2 flags");
+
+# Check op params
+my @args := $op<args>;
+ok(+ at args == 3, "Got 3 parameters");
+
+my $arg;
+
+$arg := @args[0];
+ok($arg<direction> eq 'out', 'First direction is correct');
+ok($arg<type> eq 'INT', 'First type is correct');
+
+$arg := @args[1];
+ok($arg<direction> eq 'in', 'Second direction is correct');
+ok($arg<type> eq 'PMC', 'Second type is correct');
+
+$arg := @args[2];
+ok($arg<direction> eq 'inconst', 'Third direction is correct');
+ok($arg<type> eq 'NUM', 'Third type is correct');
+
+# Check normalization
+ at args := $op<normalized_args>;
+$arg := @args[0];
+ok($arg<direction> eq 'o', 'First direction is correct');
+ok($arg<type> eq 'i', 'First type is correct');
+ok(!($arg<variant>), 'First arg without variant');
+
+$arg := @args[1];
+ok($arg<direction> eq 'i', 'Second direction is correct');
+ok($arg<type> eq 'p', 'Second type is correct');
+ok($arg<variant> eq 'pc', 'Second variant is correct');
+
+$arg := @args[2];
+ok($arg<direction> eq 'i', 'Third direction is correct');
+ok($arg<type> eq 'nc', 'Third type is correct');
+ok(!($arg<variant>), 'Third arg without variant');
+
+ok( ($op.arg_types).join('_') eq 'i_p_nc', "First variant correct");
+
+
+# Second created op should have _pc_
+$op := @ops[2];
+ok( $op.arg_types.join('_') eq 'i_pc_nc', "Second variant correct");
+
+# Check body munching.
+$op := @ops[0];
+my $goto_offset := 0;
+for @($op) {
+ $goto_offset := $goto_offset || $_<name> eq 'goto_offset';
+}
+ok( $goto_offset, "goto NEXT appended for non :flow ops");
+
+
+# Don't forget to update plan!
+
+# Local Variables:
+# mode: cperl
+# cperl-indent-level: 4
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/t/compilers/opsc/04-op.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/04-op.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,36 @@
+#!./parrot-nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+# Checking Ops::Op
+
+pir::load_bytecode("opsc.pbc");
+
+plan(7);
+
+my $op := Ops::Op.new(
+ code => 42,
+ name => 'set',
+ type => 'inline',
+ args => <foo bar baz>,
+ flags => hash(),
+ arg_types => <i i ic>,
+);
+
+ok( 1, "Op created");
+
+ok( $op.code == 42, "... with proper code");
+ok( $op.name eq 'set', "... with proper name");
+ok( $op.type eq 'inline', "... with proper type");
+ok( +$op.arg_types == 3, "... with proper arg_types");
+say('# ' ~ $op.arg_types);
+
+ok( $op.full_name eq 'set_i_i_ic', "full_name is correct");
+
+$op := Ops::Op.new(
+ name => 'set',
+ type => 'inline',
+);
+ok( $op.full_name eq 'set', "Argless op's full_name is correct");
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/t/compilers/opsc/05-oplib.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/05-oplib.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,28 @@
+#!./parrot-nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+# Checking for OpLib num and skip files parsing.
+
+pir::load_bytecode("opsc.pbc");
+
+plan(5);
+
+my $lib := Ops::OpLib.new(
+ :num_file('src/ops/ops.num'),
+ :skip_file('src/ops/ops.skip'),
+);
+
+# It's 1200 currently. But testing for exact match isn't nessary.
+ok( $lib.max_op_num > 1000, "ops.num file parsed");
+say('# ' ~ $lib.max_op_num);
+
+# Check couple random ops.
+ok( $lib.op_num_table<end> == 0, "'end' has code 0");
+ok( $lib.op_num_table<set_addr_p_i> != 42, "'set_addr_p_i' have non 0 code");
+
+ok( $lib.op_skip_table<abs_i_ic>, "'abs_i_ic' in skiptable");
+ok( $lib.op_skip_table<ne_nc_nc_ic>, "'ne_nc_nc_ic' in skiptable");
+#_dumper($lib.skiptable);
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/t/compilers/opsc/06-opsfile.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/06-opsfile.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,45 @@
+#!./parrot-nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+pir::load_bytecode("opsc.pbc");
+pir::load_bytecode("nqp-setting.pbc");
+
+plan(7);
+
+my $oplib := Ops::OpLib.new;
+my @files := <
+ src/ops/core.ops
+ src/ops/math.ops
+>;
+
+my $f := Ops::File.new(:oplib($oplib), |@files, :core(1));
+
+my @ops := $f.ops;
+# 84 core
+# 116 math
+# We can generate more than 1 Ops::Op per op due args expansion.
+say( "# Parsed " ~ + at ops);
+# There is more than 300 ops in this 2 files.
+# Feel free to update number if you change them.
+ok(+ at ops == 306, "Ops parsed correctly");
+say('# ' ~ + at ops);
+
+my $op := @ops[0];
+#_dumper($op);
+# First op should be C<end> and has code 0.
+ok($op.name eq 'end', "First op is end");
+ok($op<code> == 0, "... with code 0");
+
+$op := @ops[(+ at ops)-1];
+ok($op.name eq 'tanh', "Last op is tanh");
+say('# ' ~ $op.name);
+ok($op<code> > 84 + 116, "... with non zero code");
+
+my $version := join(' ', |$f.version);
+ok( $version ~~ /^\d+ \s \d+ \s \d+$/, "Version parsed");
+say("# $version");
+
+ok( $f.preamble ~~ /pmc_parrotlibrary.h/, "Preamble preserved");
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/t/compilers/opsc/07-emitter.t
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/07-emitter.t Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,129 @@
+#! ./parrot-nqp
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+pir::load_bytecode("opsc.pbc");
+
+plan(22);
+
+my $trans := Ops::Trans::C.new();
+
+my @files := <
+ src/ops/io.ops
+ src/ops/sys.ops
+ src/ops/cmp.ops
+>;
+
+my $lib := Ops::OpLib.new();
+my $emitter := Ops::Emitter.new(
+ :ops_file(Ops::File.new(
+ :oplib($lib),
+ :core(1),
+ |@files)
+ ),
+ :trans($trans),
+ :script('ops2c'),
+ :flags(
+ hash( dir => 'tmp/', core => 1 )
+ ),
+);
+
+ok( $emitter, "Emitter created");
+ok( $emitter<include> eq 'parrot/oplib/core_ops.h', 'Include is correct');
+say('# ' ~ $emitter<include>);
+ok( $emitter<func_header> ~~ /^tmp/, 'header file in tmp');
+say('# ' ~ $emitter<func_header>);
+
+#$emitter.print_c_header_file();
+
+my $fh := pir::new__Ps('StringHandle');
+$fh.open('header.h', 'w');
+$emitter.emit_c_op_func_header($fh);
+
+$fh.close();
+my $header := $fh.readall();
+
+ok($header ~~ /define \s PARROT_OPLIB_CORE_OPS_H_GUARD/, 'Guard generated');
+ok($header ~~ /endif/, 'Close guard generated');
+ok($header ~~ /DO \s NOT \s EDIT \s THIS \s FILE/, 'Preamble generated');
+ok($header ~~ /Parrot_DynOp_core_ \d+ _ \d+ _ \d+/, '... and contains init_func');
+ok($header ~~ /Parrot_sysinfo_s_i/, 'We have proper names of ops functions');
+
+# Testing C emitting.
+#$emitter.print_c_source_file();
+
+$fh := pir::new__Ps('StringHandle');
+$fh.open('core.c', 'w');
+$emitter.emit_c_source_file($fh);
+
+$fh.close();
+my $source := $fh.readall();
+
+ok($source ~~ /DO \s NOT \s EDIT \s THIS \s FILE/, 'Preamble generated');
+ok($source ~~ /Parrot_pcc_get_constants/, 'defines from Trans::C generated');
+ok($source ~~ /io_private.h/, 'Preamble from io.ops preserved');
+
+ok($source ~~ /static \s int \s get_op/, 'Trans::C preamble generated');
+
+ok($source ~~ /PARROT_FUNCTION_CORE/, 'Trans::C core_type preserved');
+ok($source ~~ /static \s size_t \s hash_str/, 'Trans::C op_lookup preserved');
+
+ok($source ~~ /'PREG(1)'/, 'Trans::C arg translation works');
+ok($source ~! /'OP_SIZE'/, 'Trans::C translates OP_SIZE');
+
+# "eq"
+ok($source ~~ /'0,' \s '0,' \s '1'/, "Labels handled correctly");
+
+my $op_body := '
+inline op do_stuff(invar PMC)
+{
+ restart ADDRESS(234);
+}';
+my $new_body := translate_op_body($trans, $op_body);
+my $restart_addr_ok := $new_body ~~ /'return' \s '(' 'opcode_t' \s '*' ')' \s? '234'/;
+ok($restart_addr_ok, "restart ADDRESS() translated ok");
+
+$op_body := '
+inline op branch(in LABEL) :base_loop :flow {
+ goto OFFSET($1);
+}';
+$new_body := translate_op_body($trans, $op_body);
+$restart_addr_ok := $new_body ~~ /'return (opcode_t *)cur_opcode + IREG(1);'/;
+ok($restart_addr_ok, "goto OFFSET() and \$1 translated ok");
+ok($new_body ~~ /'PARROT_JUMP_RELATIVE'/, "jump flags generated");
+
+$op_body := '
+inline op thingy(in PMC) {
+ opcode * next = expr NEXT();
+}';
+$new_body := translate_op_body($trans, $op_body);
+$restart_addr_ok := $new_body ~~ /'cur_opcode + 2;'/;
+ok($restart_addr_ok, "expr NEXT() translated ok");
+
+$op_body := '
+inline op runinterp(in PMC) {
+}';
+$new_body := translate_op_body($trans, $op_body);
+$restart_addr_ok := $new_body ~~ /'PARROT_JUMP_RELATIVE'/;
+ok($restart_addr_ok, "runinterp has PARROT_JUMP_RELATIVE");
+
+#say($source);
+
+sub translate_op_body($trans, $body) {
+ my $file := Ops::File.new_str(
+ :oplib($lib), $body);
+ my $emitter := Ops::Emitter.new(
+ :ops_file($file),
+ :trans($trans),
+ :script("opsc"),
+ :flags( hash(core => '1') )
+ );
+
+ my $sh := pir::new__Ps('StringHandle');
+ $sh.open('your_bank_account_information.txt', 'w');
+ $emitter.emit_c_source_file($sh);
+ $sh.close();
+ $sh.readall();
+}
+
+# vim: expandtab shiftwidth=4 ft=perl6:
Added: trunk/t/compilers/opsc/common.pir
==============================================================================
--- /dev/null 00:00:00 1970 (empty, because file is newly added)
+++ trunk/t/compilers/opsc/common.pir Sun May 23 21:38:28 2010 (r46922)
@@ -0,0 +1,39 @@
+#! parrot
+# Copyright (C) 2010, Parrot Foundation.
+# $Id$
+
+=head1 COMMON FUNCTIONS FOR TESTING
+
+=cut
+
+.sub '_parse_buffer'
+ .param string buffer
+
+ .local pmc compiler
+ compiler = compreg 'Ops'
+ .tailcall compiler.'parse'(buffer, 'target'=>'parse')
+.end
+
+.sub '_parse_one_file'
+ .param string filename
+ .local string buf
+
+ buf = '_slurp'(filename)
+ .tailcall '_parse_buffer'(buf)
+.end
+
+
+.sub '_slurp'
+ .param string file
+ .local pmc pio
+ pio = open file
+ $S0 = pio.'readall'()
+ close pio
+ .return ($S0)
+.end
+
+# Local Variables:
+# mode: pir
+# fill-column: 100
+# End:
+# vim: expandtab shiftwidth=4 ft=pir:
Modified: trunk/t/harness.pir
==============================================================================
--- trunk/t/harness.pir Sun May 23 21:12:16 2010 (r46921)
+++ trunk/t/harness.pir Sun May 23 21:38:28 2010 (r46922)
@@ -297,7 +297,7 @@
$I1 = index $S0, '/branches/'
unless $I1 >= 0 goto L2
$I1 += 10
- $I2 = find_not_cclass .CCLASS_WHITESPACE, $S0, $I1, $I0
+ $I2 = find_cclass .CCLASS_WHITESPACE, $S0, $I1, $I0
$I3 = $I2 - $I1
$S1 = substr $S0, $I1, $I3
L2:
Deleted: trunk/t/op/01-parse_ops.t
==============================================================================
--- trunk/t/op/01-parse_ops.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,105 +0,0 @@
-#! perl
-# Copyright (C) 2006-2008, Parrot Foundation.
-# $Id$
-
-use strict;
-use warnings;
-use lib qw( . lib ../lib ../../lib );
-use Parrot::Test;
-use Parrot::Op;
-use Parrot::OpLib::core;
-
-=head1 NAME
-
-t/op/01-parse_ops.t - Parse core opcodes
-
-=head1 SYNOPSIS
-
- % prove t/op/01-parse_ops.t
-
-=head1 DESCRIPTION
-
-Tests that all parrot opcodes are parsed properly.
-
-=cut
-
-my $object_map = {
- i => q<I0>,
- ic => q<42>,
- k => q<P0>,
- kc => q<[ 'foo' ; 'bar' ]>,
- kic => q<[ 1 ]>,
- ks => q<P0>,
- ksc => q<[ 'foo' ; 'bar' ]>,
- n => q<N0>,
- nc => q<13.013>,
- p => q<P0>,
- pc => undef, ## TT #1158 figure out how to test this type
- s => q<S0>,
- sc => q<'foo'>,
-};
-
-my %parse_errors = map { $_ => 1 } qw(
- defined
- delete
- eq
- exists
- le
- lt
- ne
- set
- slice
- yield
-);
-
-my %cmds;
-
-## extract the register types from each opcode
-for my $op (@$Parrot::OpLib::core::ops) {
- my @regtypes = $op->arg_types;
-
- ## for now, avoid opcodes with regtypes i do not know how to represent
- next unless @regtypes == grep { defined $$object_map{$_} } @regtypes;
-
- ## extract the basename of the opcode
- my $basename = $op->name;
-
- ## create the argument list
- my $args = join ', ' => map $$object_map{$_}, @regtypes;
-
- ## store the test commands
- $cmds{$basename}{ $basename . ' ' . $args }++;
-}
-
-$ENV{TEST_PROG_ARGS} ||= '';
-
-plan skip_all => 'IMCC cannot do parse-only with JIT enabled'
- if $ENV{TEST_PROG_ARGS} =~ /--runcore=jit/;
-
-plan skip_all => 'IMCC cannot do parse-only with switched core'
- if $ENV{TEST_PROG_ARGS} =~ /--runcore=switch/;
-
-plan tests => scalar keys %cmds;
-
-for my $cmd ( sort keys %cmds ) {
- my @args = (
- ## retrieve the test commands, and trick IMCC to parse only
- join( $/ => 'end', sort( keys %{ $cmds{$cmd} } ), '' ),
- qr/^(?!error:imcc:syntax error,)/,
- "parsing: $cmd"
- );
-
- if ( $parse_errors{$cmd} ) {
- pasm_error_output_like(@args);
- }
- else {
- pasm_output_like(@args);
- }
-}
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/01-new.t
==============================================================================
--- trunk/t/tools/ops2cutils/01-new.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,197 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 01-new.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 15;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-use IO::CaptureOutput qw| capture |;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-my ( $msg, $tie );
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- {
- local @ARGV = qw();
- my $self;
- my ($stdout, $stderr);
- my $ret = capture(
- sub {
- $self = Parrot::Ops2c::Utils->new(
- { argv => [@ARGV], flag => {} }
- );
- },
- \$stdout,
- \$stderr
- );
- ok( !defined $self,
- "Constructor correctly returned undef due to lack of command-line arguments" );
- like(
- $stderr,
- qr/^Parrot::Ops2c::Utils::new\(\) requires 'trans' options/,
- "Error message is correct"
- );
- }
-
- {
- local @ARGV = qw( gobbledygook );
- my $self;
- my ($stdout, $stderr);
- my $ret = capture(
- sub {
- $self = Parrot::Ops2c::Utils->new(
- { argv => [@ARGV], flag => {}, }
- );
- },
- \$stdout,
- \$stderr
- );
- ok( !defined $self,
- "Constructor correctly returned undef due to bad class name command-line argument" );
- like(
- $stderr,
- qr/Parrot::Ops2c::Utils::new\(\) requires C/,
- "Got correct error message"
- );
- }
-
- test_single_trans(q{C});
-
- {
- local @ARGV = qw( C );
- my $self = Parrot::Ops2c::Utils->new(
- { argv => [@ARGV], flag => { core => 1 } }
- );
- ok( defined $self, "Constructor correctly returned when provided >= 1 arguments" );
- }
-
- {
- local @ARGV = qw( C );
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [@ARGV],
- flag => { core => 1 },
- script => "tools/build/ops2c.pl",
- }
- );
- ok( defined $self,
- "Constructor correctly returned when provided with explicit 'script' argument" );
- }
-
- {
- local @ARGV = qw( C );
- my $self;
- my ($stdout, $stderr);
- my $ret = capture(
- sub {
- $self = Parrot::Ops2c::Utils->new( { argv => [@ARGV], });
- },
- \$stdout,
- \$stderr
- );
- ok( !defined $self,
- "Constructor correctly returned undef when lacking reference to options" );
- like(
- $stderr,
- qr/^Parrot::Ops2c::Utils::new\(\) requires reference to hash of command-line options/,
- "Error message correctly returned"
- );
- }
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-sub test_single_trans {
- my $trans = shift;
- my %available = map { $_, 1 } qw( C );
- croak "Bad argument $trans to test_single_trans()"
- unless $available{$trans};
-
- my $self = Parrot::Ops2c::Utils->new(
- { argv => [$trans], flag => { core => 1 }, }
- );
- ok( defined $self, "Constructor correct when provided with single argument $trans" );
-}
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-01-new.t - test C<Parrot::Ops2c::Utils::new()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/01-new.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<01-new.t> tests whether C<Parrot::Ops2c::Utils::new()>
-works properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/02-usage.t
==============================================================================
--- trunk/t/tools/ops2cutils/02-usage.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,146 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 02-usage.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 29;
-use Carp;
-use Cwd;
-use_ok( 'Parrot::Ops2c::Auxiliary', qw| Usage getoptions | );
-use IO::CaptureOutput qw | capture |;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-my ( $msg, $tie, @lines );
-{
- my ($rv, $stdout, $stderr);
- capture( sub { $rv = Usage(); }, \$stdout, \$stderr );
- is( $rv, 1, "Usage() returned" );
- like(
- $stderr,
- qr|^
- \s*%\sperl\stools\/build\/ops2c\.pl\strans.*
- trans\s:=.*
- For\sexample.*
- core.*
- dynamic.*
- |msx,
- "Got expected usage message"
- );
-}
-
-{
- local @ARGV = qw( --no-lines );
- my $flagsref = getoptions();
- ok( $flagsref->{nolines}, "no-lines option detected" );
- ok( !defined $flagsref->{help}, "help option not defined" );
- ok( !defined $flagsref->{dynamic}, "dynamic option not defined" );
- ok( !defined $flagsref->{core}, "core option not defined" );
-}
-
-{
- local @ARGV = ();
- my $flagsref = getoptions();
- ok( !defined $flagsref->{nolines}, "no-lines option not defined" );
- ok( !defined $flagsref->{help}, "help option not defined" );
- ok( !defined $flagsref->{dynamic}, "dynamic option not defined" );
- ok( !defined $flagsref->{core}, "core option not defined" );
-}
-
-{
- local @ARGV = qw( --no-lines --help --core );
- my $flagsref = getoptions();
- ok( $flagsref->{nolines}, "no-lines option detected" );
- ok( $flagsref->{help}, "help option detected" );
- ok( !defined $flagsref->{dynamic}, "dynamic option not defined" );
- ok( $flagsref->{core}, "core option detected" );
-}
-
-{
- local @ARGV = qw( --dynamic );
- my $flagsref = getoptions();
- ok( !defined $flagsref->{nolines}, "no-lines option not defined" );
- ok( !defined $flagsref->{help}, "help option not defined" );
- ok( defined $flagsref->{dynamic}, "dynamic option defined" );
- ok( !defined $flagsref->{core}, "core option not defined" );
-}
-
-{
- local @ARGV = qw( --d );
- my $flagsref = getoptions();
- ok( !defined $flagsref->{nolines}, "no-lines option not defined" );
- ok( !defined $flagsref->{help}, "help option not defined" );
- ok( defined $flagsref->{dynamic}, "dynamic option defined" );
- ok( !defined $flagsref->{core}, "core option not defined" );
-}
-
-{
- local @ARGV = qw( --no-lines --help --core --d );
- my $flagsref = getoptions();
- ok( $flagsref->{nolines}, "no-lines option detected" );
- ok( $flagsref->{help}, "help option detected" );
- ok( defined $flagsref->{dynamic}, "dynamic option defined" );
- ok( $flagsref->{core}, "core option detected" );
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-02-usage.t - test C<Parrot::Ops2c::Auxiliary::Usage()> and <getoptions()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/02-usage.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<02-usage.t> tests whether C<Parrot::Ops2c::Auxiliary::Usage()>
-and F<getoptions()> work properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/03-print_c_header_file.t
==============================================================================
--- trunk/t/tools/ops2cutils/03-print_c_header_file.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,131 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 03-print_c_header_file.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 12;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- test_single_trans_and_header(q{C});
-
- {
- local @ARGV = qw( C );
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [@ARGV],
- flag => { core => 1 },
- }
- );
- ok( defined $self, "Constructor correctly returned when provided >= 1 arguments" );
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
- }
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-sub test_single_trans_and_header {
- my $trans = shift;
- my %available = map { $_, 1 } qw( C );
- croak "Bad argument $trans to test_single_trans()"
- unless $available{$trans};
-
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [$trans],
- flag => { core => 1 },
- }
- );
- ok( defined $self, "Constructor correct when provided with single argument $trans" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-}
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-03-print_c_header_file.t - test C<Parrot::Ops2c::Utils::new()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/03-print_c_header_file.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<03-print_c_header_file.t> tests whether
-C<Parrot::Ops2c::Utils::print_c_header_file()> works properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/04-print_c_source_top.t
==============================================================================
--- trunk/t/tools/ops2cutils/04-print_c_source_top.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,120 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 04-print_c_source_top.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 10;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- test_print_c_source_top( [qw( C )] );
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-sub test_print_c_source_top {
- my $local_argv_ref = shift;
- {
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => $local_argv_ref,
- flag => { core => 1 },
- }
- );
- ok( defined $self,
- "Constructor correctly returned when provided with argument(s): @{$local_argv_ref}" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-
- my $source = IO::File->new('>' . $$self{source});
- $self->print_c_source_top($source);
- ok( -s $source, "print_c_source_top printed something to the file" );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-04-print_c_source_top.t - test C<Parrot::Ops2c::Utils::print_c_source_top()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/04-print_c_source_top.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<04-print_c_source_top.t> tests whether
-C<Parrot::Ops2c::Utils::print_c_source_top()> work properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/05-print_c_source_bottom.t
==============================================================================
--- trunk/t/tools/ops2cutils/05-print_c_source_bottom.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,123 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 05-print_c_source_bottom.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 10;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-my ( $msg, $tie );
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- test_print_c_source_bottom( [qw( C )] );
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-sub test_print_c_source_bottom {
- my $local_argv_ref = shift;
- {
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => $local_argv_ref,
- flag => { core => 1 },
- }
- );
- ok( defined $self,
- "Constructor correctly returned when provided with argument(s): @{$local_argv_ref}" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-
- my $source = IO::File->new('>' . $$self{source});
- $self->print_c_source_bottom($source);
- $source->close();
- ok( -s $$self{source}, "print_c_source_bottom printed something to the file $$self{source}" );
- }
-}
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-05-print_c_source_bottom.t - test
-C<Parrot::Ops2c::Utils::print_c_source_bottom()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/05-print_c_source_bottom.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<05-print_c_source_bottom.t> tests whether
-C<Parrot::Ops2c::Utils::print_c_source_bottom()> work properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/06-dynamic.t
==============================================================================
--- trunk/t/tools/ops2cutils/06-dynamic.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,157 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 06-dynamic.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 15;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-use IO::CaptureOutput qw | capture |;
-
-my @dynopsfiles = qw( src/dynoplibs/obscure.ops );
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-my ( $msg, $tie );
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- foreach my $f (@dynopsfiles) {
- copy( qq{$cwd/$f}, qq{$tdir/$f} );
- }
- chdir "src/dynoplibs" or croak "Unable to change to src/dynoplibs: $!";
-
- test_dynops( [qw( C obscure.ops )] );
-
- {
- my ($self, $stdout, $stderr);
- capture(
- sub { $self = Parrot::Ops2c::Utils->new( {
- argv => [qw( C obscure.ops obscure.ops )],
- flag => { dynamic => 1 },
- } ); },
- \$stdout,
- \$stderr,
- );
- ok( defined $self,
- "Constructor correctly returned when provided >= 1 arguments" );
- like( $stderr,
- qr/Ops file 'obscure\.ops' mentioned more than once!/, "Error message is correct" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-
- my $source = IO::File->new('>' . $$self{source});
- $self->print_c_source_top($source);
- $self->print_c_source_bottom($source);
- $source->close();
- ok( -s $$self{source}, "file was written" );
- }
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-sub test_dynops {
- my $local_argv_ref = shift;
- {
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => $local_argv_ref,
- flag => { dynamic => 1 },
- }
- );
- ok( defined $self, "Constructor correctly returned when provided >= 1 arguments" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-
- my $source = IO::File->new('>' . $$self{source});
- $self->print_c_source_top($source);
- $self->print_c_source_bottom($source);
- $source->close();
- ok( -s $$self{source}, "file was written" );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-06-dynamic.t - test C<--dynamic> flag to F<tools/build/ops2c.pl>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/06-dynamic.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<06-dynamic.t> tests how well
-C<Parrot::Ops2c::Utils()> works when the C<--dynamic> flag is passed to
-F<tools/build/ops2c.pl>.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/07-make_incdir.t
==============================================================================
--- trunk/t/tools/ops2cutils/07-make_incdir.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,156 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 07-make_incdir.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 7;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ( "$main::topdir/t/tools/ops2cutils/testlib", "./lib" );
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- mkdir qq{$tdir/src};
- mkdir qq{$tdir/src/ops};
- mkdir qq{$tdir/src/dynoplibs};
-
- foreach my $f (@srcopsfiles) {
- copy( qq{$cwd/$f}, qq{$tdir/$f} );
- }
- copy( qq{$cwd/$num}, qq{$tdir/$num} );
- copy( qq{$cwd/$skip}, qq{$tdir/$skip} );
- my @opsfiles = glob("./src/ops/*.ops");
-
- mkdir qq{$tdir/lib};
- mkdir qq{$tdir/lib/Parrot};
- mkdir qq{$tdir/lib/Parrot/Ops2c};
- mkdir qq{$tdir/include};
- mkdir qq{$tdir/include/parrot};
-
- my $o2p = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- moddir => "lib/Parrot/OpLib",
- module => "core.pm",
- }
- );
-
- $o2p->prepare_ops();
- $o2p->load_op_map_files();
- $o2p->sort_ops();
- $o2p->prepare_real_ops();
- $o2p->print_module();
-
- croak "Temporary core.pm file not written"
- unless ( -f qq|$tdir/$o2p->{moddir}/$o2p->{module}| );
-
- my $tlib = qq{$tdir/lib};
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- {
- local @ARGV = qw( C );
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [@ARGV],
- flag => { core => 1 },
- }
- );
- ok( defined $self,
- "Constructor correctly returned even though include/parrot/oplib had to be created" );
- }
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-sub test_single_trans {
- my $trans = shift;
- my %available = map { $_, 1 } qw( C );
- croak "Bad argument $trans to test_single_trans()"
- unless $available{$trans};
-
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [$trans],
- flag => { core => 1 },
- }
- );
- ok( defined $self, "Constructor correct when provided with single argument $trans" );
-}
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-07-make_incdir.t - test C<Parrot::Ops2c::Utils::new()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/07-make_incdir.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<07-make_incdir.t> tests whether C<Parrot::Ops2c::Utils::new()>
-works properly when F<include/parrot/oplib> was not previously created..
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/08-nolines.t
==============================================================================
--- trunk/t/tools/ops2cutils/08-nolines.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,118 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 08-nolines.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 10;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- {
- local @ARGV = qw( C );
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [@ARGV],
- flag => { core => 1, nolines => 1 },
- }
- );
- ok( defined $self, "Constructor correctly returned when provided >= 1 arguments" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-
- my $source = IO::File->new('>' . $$self{source});
- $self->print_c_source_top($source);
- $self->print_c_source_bottom($source);
- $source->close();
- ok( -s $$self{source}, "file was written" );
- }
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-08-nolines.t - test C<--nolines> option to F<tools/build/ops2c.pl>.
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/08-nolines.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<08-nolines.t> tests whether
-C<Parrot::Ops2c::Utils::new()> work properly when C<--nolines> option
-is passed to F<tools/build/ops2c.pl>.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/09-dynamic_nolines.t
==============================================================================
--- trunk/t/tools/ops2cutils/09-dynamic_nolines.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,128 +0,0 @@
-#! perl
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-# 09-dynamic_nolines.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 10;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-my @dynopsfiles = qw( src/dynoplibs/obscure.ops );
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- foreach my $f (@dynopsfiles) {
- copy( qq{$cwd/$f}, qq{$tdir/$f} );
- }
- chdir "src/dynoplibs" or croak "Unable to change to src/dynoplibs: $!";
-
- test_dynops_nolines( [qw( C obscure.ops )] );
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-sub test_dynops_nolines {
- my $local_argv_ref = shift;
- {
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => $local_argv_ref,
- flag => { dynamic => 1, nolines => 1 },
- }
- );
- ok( defined $self, "Constructor correctly returned when provided >= 1 arguments" );
-
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
-
- my $source = IO::File->new('>' . $$self{source});
- $self->print_c_source_top($source);
- $self->print_c_source_bottom($source);
- $source->close();
- ok( -s $$self{source}, "file was written" );
- }
-}
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-09-dynamic_nolines.t - test C<--nolines> option to F<tools/build/ops2c.pl>.
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/09-dynamic_nolines.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<09-dynamic_nolines.t> tests whether
-C<Parrot::Ops2c::Utils::new()> work properly when the C<--nolines> and
-C<--dynamic> options are passed to F<tools/build/ops2c.pl>.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/10-print_c_source_file.t
==============================================================================
--- trunk/t/tools/ops2cutils/10-print_c_source_file.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,131 +0,0 @@
-#! perl
-# Copyright (C) 2008, Parrot Foundation.
-# $Id$
-# 10-print_c_source_file.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 12;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use_ok('Parrot::Ops2pm');
-use lib ("$main::topdir/t/tools/ops2cutils/testlib");
-use GenerateCore qw|
- generate_core
- @srcopsfiles
- $num
- $skip
-|;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-
-{
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
-
- my $tlib = generate_core( $cwd, $tdir, \@srcopsfiles, $num, $skip );
-
- ok( -d $tlib, "lib directory created under tempdir" );
- unshift @INC, $tlib;
- require Parrot::Ops2c::Utils;
-
- test_single_trans_and_source(q{C});
-
- {
- local @ARGV = qw( C );
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [@ARGV],
- flag => { core => 1 },
- }
- );
- ok( defined $self, "Constructor correctly returned when provided >= 1 arguments" );
- my $c_header_file = $self->print_c_header_file();
- ok( -e $c_header_file, "$c_header_file created" );
- ok( -s $c_header_file, "$c_header_file has non-zero size" );
- }
-
- ok( chdir($cwd), "returned to starting directory" );
-}
-
-pass("Completed all tests in $0");
-
-sub test_single_trans_and_source {
- my $trans = shift;
- my %available = map { $_, 1 } qw( C );
- croak "Bad argument $trans to test_single_trans()"
- unless $available{$trans};
-
- my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [$trans],
- flag => { core => 1 },
- }
- );
- ok( defined $self, "Constructor correct when provided with single argument $trans" );
-
- my $c_source_file = $self->print_c_source_file();
- ok( -e $c_source_file, "$c_source_file created" );
- ok( -s $c_source_file, "$c_source_file has non-zero size" );
-}
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-10-print_c_source_file.t - test C<Parrot::Ops2c::Utils::new()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2cutils/10-print_c_source_file.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2c/Utils.pm> and F<lib/Parrot/Ops2c/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2c.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-All the files in this directory are intended to be run B<after>
-F<Configure.pl> has been run but before F<make> has been called. Hence, they
-are B<not> part of the test suite run by F<make test>. Once you have run
-F<Configure.pl>, however, you may run these tests as part of F<make
-buildtools_tests>.
-
-F<10-print_c_source_file.t> tests whether
-C<Parrot::Ops2c::Utils::print_c_source_file()> works properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2c::Auxiliary, F<ops2c.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2cutils/testlib/GenerateCore.pm
==============================================================================
--- trunk/t/tools/ops2cutils/testlib/GenerateCore.pm Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,185 +0,0 @@
-# Copyright (C) 2007, Parrot Foundation.
-# $Id$
-package GenerateCore;
-use strict;
-use warnings;
-our ( @ISA, @EXPORT_OK );
- at ISA = qw(Exporter);
-
-our @srcopsfiles = qw( src/ops/core.ops src/ops/bit.ops src/ops/cmp.ops
- src/ops/debug.ops src/ops/experimental.ops src/ops/io.ops src/ops/math.ops
- src/ops/object.ops src/ops/pic.ops src/ops/pmc.ops src/ops/set.ops
- src/ops/stack.ops src/ops/stm.ops src/ops/string.ops src/ops/sys.ops
- src/ops/var.ops );
-our $num = "src/ops/ops.num";
-our $skip = "src/ops/ops.skip";
-
- at EXPORT_OK = qw(
- generate_core
- @srcopsfiles
- $num
- $skip
-);
-use Carp;
-use File::Copy;
-use lib ("./lib");
-use Parrot::Ops2pm;
-
-
-sub generate_core {
- my ( $cwd, $tdir, $srcopsref, $num_file, $skip_file ) = @_;
- my @srcopsfiles = @$srcopsref;
- mkdir qq{$tdir/src};
- mkdir qq{$tdir/src/ops};
- mkdir qq{$tdir/src/dynoplibs};
-
- foreach my $f (@srcopsfiles) {
- copy( qq{$cwd/$f}, qq{$tdir/$f} );
- }
- copy( qq{$cwd/$num}, qq{$tdir/$num} );
- copy( qq{$cwd/$skip}, qq{$tdir/$skip} );
- my @opsfiles = glob("./src/ops/*.ops");
-
- mkdir qq{$tdir/lib};
- mkdir qq{$tdir/lib/Parrot};
- mkdir qq{$tdir/lib/Parrot/Ops2c};
- mkdir qq{$tdir/include};
- mkdir qq{$tdir/include/parrot};
- mkdir qq{$tdir/include/parrot/oplib};
-
- my $o2p = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- moddir => "lib/Parrot/OpLib",
- module => "core.pm",
- }
- );
-
- $o2p->prepare_ops();
- $o2p->load_op_map_files();
- $o2p->sort_ops();
- $o2p->prepare_real_ops();
- $o2p->print_module();
-
- croak "Temporary core.pm file not written"
- unless ( -f qq|$tdir/$o2p->{moddir}/$o2p->{module}| );
- return qq{$tdir/lib};
-}
-
-1;
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-GenerateCore - functionality used in testing Parrot::Ops2c::Utils
-
-=head1 SYNOPSIS
-
- use lib ("t/tools/ops2cutils/testlib");
- use GenerateCore qw| generate_core |;
-
- @srcopsfiles = qw(
- src/ops/core.ops src/ops/bit.ops src/ops/cmp.ops
- src/ops/debug.ops src/ops/experimental.ops src/ops/io.ops
- src/ops/math.ops src/ops/object.ops src/ops/pic.ops
- src/ops/pmc.ops src/ops/set.ops src/ops/stack.ops
- src/ops/stm.ops src/ops/string.ops src/ops/sys.ops
- src/ops/var.ops
- );
-
- $num = "src/ops/ops.num";
- $skip = "src/ops/ops.skip";
-
- $cwd = cwd();
- $tdir = tempdir( CLEANUP => 1 );
-
- $tlib = generate_core(
- $cwd, $tdir, \@srcopsfiles, $num, $skip);
-
-=head1 DESCRIPTION
-
-The test suite found in F<t/tools/ops2cutils/> tests the methods of
-Parrot::Ops2c::Utils. Those methods are invoked by Parrot build tool
-F<tools/build/ops2c.pl>, which in turn is invoked several times by F<make>.
-Parrot::Ops2c::Utils has as a prerequisite Parrot::OpLib::core. But
-Parrot::OpLib::core is not part of the Parrot distribution, nor does it exist
-at the point F<make> is called. Rather, it is created
-during the Parrot build process prior to the first call to F<ops2c.pl>.
-
-To test Parrot::Ops2c::Utils therefore requires a module which does not exist
-'pre-F<make>'. The tests in this suite, however, are designed to be run when
-your filesystem is in a 'post-F<Configure.pl>, pre-F<make>' state. The
-solution to this conundrum is to create a copy of Parrot::OpLib::core which
-exists only for the duration of a single test file.
-
-This package, GenerateCore, exports upon request a single subroutine,
-C<generate_core>, which (a) creates subdirectories needed underneath a
-temporary directory created solely for testing purposes; then
-(b) creates a temporary copy of Parrot::OpLib::core such that
-C<Parrot::Ops2c::Utils::new()> can successfully execute.
-
-=head1 SUBROUTINES
-
-=head2 C<generate_core()>
-
-=over 4
-
-=item * B<Purpose:> (See above.)
-
-=item * B<Arguments:> Five scalar arguments, in this order:
-
- cwd : String with full path of directory from which
- tests are invoked (generally, the top-level
- Parrot directory).
- tdir : String holding full path of temporary
- directory into which you have changed for
- testing.
- \@srcopsfiles : Reference to an array of F<.ops> files
- (generally, the list of arguments to ops2c.pl
- as invoked by make).
- $num : Path to ops.num file.
- $skip : Path to ops.skip file.
-
-=item * B<Return Value:> String holding full path to a directory F<lib/>
-found one level underneath the temporary directory denoted by F<tdir> above.
-(This is the directory underneath which the temporary copy of
-Parrot::OpLib::core is created.) The return value may be used in testing as a
-marker for the creation of all the needed temporary subdirectories and the
-temporary copy of Parrot::OpLib::core.
-
-=back
-
-=head1 DEPENDENCIES
-
-=over 4
-
-=item * File::Copy
-
-=item * Parrot::Ops2c::Utils
-
-=back
-
-=head1 AUTHOR
-
-James E Keenan (jkeenan at cpan.org).
-
-=head1 SEE ALSO
-
-=over 4
-
-=item * Parrot::Ops2c::Utils
-
-=item * F<tools/build/ops2c.pl>
-
-=back
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/00-qualify.t
==============================================================================
--- trunk/t/tools/ops2pm/00-qualify.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,66 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 00-qualify.t
-
-use strict;
-use warnings;
-use Test::More tests => 8;
-use FindBin;
-use lib ( "$FindBin::Bin/../../../lib", );
-use_ok('Parrot::Ops2pm');
-
-ok( -f "$FindBin::Bin/../../../Makefile", "Makefile located" );
-ok( -f "$FindBin::Bin/../../../myconfig", "myconfig located" );
-ok( -f "$FindBin::Bin/../../../lib/Parrot/OpsFile.pm", "lib/Parrot/OpsFile.pm located" );
-ok( -f "$FindBin::Bin/../../../src/ops/core.ops", "src/ops/core.ops located" );
-ok( -f "$FindBin::Bin/../../../src/ops/ops.num", "src/ops/ops.num located" );
-ok( -f "$FindBin::Bin/../../../src/ops/ops.skip", "src/ops/ops.skip located" );
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-00-qualify.t - Is this the right point to test Parrot build tools?
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/00-qualify.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2pm.pm>and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-Since F<ops2pm.pl> is invoked near the beginning of the build process,
-tests of its functionality can give meaningful results only if they
-are run in a way that simulates the status of the file system at the point
-at which F<make> invokes F<ops2pm.pl>. The tests in F<00-qualify.t> attempt
-to confirm that you are at that point. They test for the presence or
-absence of certain files to form a judgment as to whether F<Configure.pl>
-has been run (it should have been) and whether F<make> has been run
-(it should I<not> have been). The tests make certain assumptions
-about what files should be present or not -- assumptions which may be
-invalid if the Parrot build process changes in the future.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/01-ops2pm.t
==============================================================================
--- trunk/t/tools/ops2pm/01-ops2pm.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,64 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 01-ops2pm.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 3;
-
-use_ok('Parrot::Ops2pm');
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-01-ops2pm.t - test importability of Parrot::Ops2pm subroutines
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/01-ops2pm.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>. By doing so,
-they test the functionality of the F<ops2pm.pl> utility. That functionality
-has largely been extracted into the methods of F<Ops2pm.pm>.
-
-F<01-ops2pm.t> tests whether Parrot::Ops2pm is exporting the
-subroutines in its C<@EXPORT_OK>.:
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/02-usage.t
==============================================================================
--- trunk/t/tools/ops2pm/02-usage.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,106 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 02-usage.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 13;
-use Carp;
-use Cwd;
-use IO::CaptureOutput qw| capture |;
-use_ok( 'Parrot::Ops2pm::Auxiliary', qw| Usage getoptions | );
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-my $cwd = cwd();
-{
- my ($stdout, $stderr);
- my $ret = capture(
- sub { Usage(); },
- \$stdout,
- \$stderr
- );
- like(
- $stderr,
-qr|^usage: tools/build/ops2pm\.pl \[--help\] \[--no-lines\] input\.ops \[input2\.ops \.\.\.\]|,
- "Got expected usage message"
- );
-}
-
-{
- local @ARGV = qw( --no-lines );
- my $flagsref = getoptions();
- ok( $flagsref->{nolines}, "no-lines option detected" );
- ok( !defined $flagsref->{help}, "help option not defined" );
- ok( !defined $flagsref->{renum}, "renum option not defined" );
-}
-
-{
- local @ARGV = ();
- my $flagsref = getoptions();
- ok( !defined $flagsref->{nolines}, "no-lines option not defined" );
- ok( !defined $flagsref->{help}, "help option not defined" );
- ok( !defined $flagsref->{renum}, "renum option not defined" );
-}
-
-{
- local @ARGV = qw( --no-lines --help --renum );
- my $flagsref = getoptions();
- ok( $flagsref->{nolines}, "no-lines option detected" );
- ok( $flagsref->{help}, "help option detected" );
- ok( $flagsref->{renum}, "renum option detected" );
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-02-usage.t - test C<Parrot::Ops2pm::Usage()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/02-usage.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<02-usage.t> tests whether C<Parrot::Ops2pm::Auxiliary::Usage()>
-works properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm::Auxiliary, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/03-new.t
==============================================================================
--- trunk/t/tools/ops2pm/03-new.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,99 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 03-new.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 5;
-
-use_ok('Parrot::Ops2pm');
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-{
- local @ARGV = qw( fkadfudofyufyd );
- eval {
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- }
- );
- };
- like(
- $@,
- qr/Could not find ops file/,
- "Got expected error message when file could not be found"
- );
-}
-
-{
- local @ARGV = qw( src/ops/core.ops
- src/ops/bit.ops src/ops/cmp.ops src/ops/debug.ops
- src/ops/experimental.ops src/ops/io.ops src/ops/math.ops
- src/ops/object.ops src/ops/pic.ops src/ops/pmc.ops
- src/ops/set.ops src/ops/stack.ops src/ops/stm.ops
- src/ops/string.ops src/ops/sys.ops src/ops/var.ops
- );
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-03-new.t - test C<Parrot::Ops2pm::new()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/03-new.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<03-new.t> tests whether Parrot::Ops2pm::new()
-works properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/04-prepare_ops.t
==============================================================================
--- trunk/t/tools/ops2pm/04-prepare_ops.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,304 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 04-prepare_ops.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 70;
-use Carp;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use IO::File;
-
-use_ok('Parrot::Ops2pm::Base');
-use IO::CaptureOutput qw| capture |;
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-
-# regular case
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $self = Parrot::Ops2pm::Base->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm::Base} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- # The following tests will break if the output of Parrot::OpsFile changes
- my %temp = %{ $self->{ops} };
- is( scalar( keys %temp ), 4, "4 keys in object's internal hash" );
- ok( defined( $temp{FILE} ), "FILE key in object is defined" );
- ok( defined( $temp{OPS} ), "OPS key in object is defined" );
- ok( defined( $temp{PREAMBLE} ), "PREAMBLE key in object is defined" );
- ok( defined( $temp{VERSION} ), "VERSION key in object is defined" );
- ok( !ref( $temp{FILE} ), "FILE key in object is not a reference" );
- ok( ref( $temp{OPS} ), "OPS key in object is a reference" );
- is( ref( $temp{OPS} ), q{ARRAY}, "OPS key in object is an array reference" );
- ok( !ref( $temp{PREAMBLE} ), "PREAMBLE key in object is not a reference" );
- ok( !ref( $temp{VERSION} ), "VERSION key in object is not a reference" );
-}
-
-# nolines option is set true
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $self = Parrot::Ops2pm::Base->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- nolines => 1,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm::Base} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- # The following tests will break if the output of Parrot::OpsFile changes
- my %temp = %{ $self->{ops} };
- is( scalar( keys %temp ), 4, "4 keys in object's internal hash" );
- ok( defined( $temp{FILE} ), "FILE key in object is defined" );
- ok( defined( $temp{OPS} ), "OPS key in object is defined" );
- ok( defined( $temp{PREAMBLE} ), "PREAMBLE key in object is defined" );
- ok( defined( $temp{VERSION} ), "VERSION key in object is defined" );
- ok( !ref( $temp{FILE} ), "FILE key in object is not a reference" );
- ok( ref( $temp{OPS} ), "OPS key in object is a reference" );
- is( ref( $temp{OPS} ), q{ARRAY}, "OPS key in object is an array reference" );
- ok( !ref( $temp{PREAMBLE} ), "PREAMBLE key in object is not a reference" );
- ok( !ref( $temp{VERSION} ), "VERSION key in object is not a reference" );
-}
-
-# mistakenly list an ops file twice; confirm warning is correct
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- src/ops/bit.ops
- );
- my $self = Parrot::Ops2pm::Base->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm::Base} );
-
- my ($stdout, $stderr);
- my $ret = capture(
- sub { $self->prepare_ops },
- \$stdout,
- \$stderr
- );
- ok($ret, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
- like(
- $stderr,
- qr|Ops file 'src/ops/bit.ops' mentioned more than once!|,
- "Got expected message about .ops file being mentioned twice"
- );
-
- # The following tests will break if the output of Parrot::OpsFile changes
- my %temp = %{ $self->{ops} };
- is( scalar( keys %temp ), 4, "4 keys in object's internal hash" );
- ok( defined( $temp{FILE} ), "FILE key in object is defined" );
- ok( defined( $temp{OPS} ), "OPS key in object is defined" );
- ok( defined( $temp{PREAMBLE} ), "PREAMBLE key in object is defined" );
- ok( defined( $temp{VERSION} ), "VERSION key in object is defined" );
- ok( !ref( $temp{FILE} ), "FILE key in object is not a reference" );
- ok( ref( $temp{OPS} ), "OPS key in object is a reference" );
- is( ref( $temp{OPS} ), q{ARRAY}, "OPS key in object is an array reference" );
- ok( !ref( $temp{PREAMBLE} ), "PREAMBLE key in object is not a reference" );
- ok( !ref( $temp{VERSION} ), "VERSION key in object is not a reference" );
-}
-
-# mistakenly provide a non-existent ops file; catch fatal error
-{
- my $phony = q{src/ops/sdifupasdufisduuapsdfi.ops};
- local @ARGV = ( "src/ops/core.ops", $phony );
-
- my $self = Parrot::Ops2pm::Base->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm::Base} );
- eval { $self->prepare_ops; };
- like(
- $@,
- qr/Could not find ops file '$phony'!/,
- "Got expected error message re missing .ops file"
- );
-}
-
-# provide experimental.ops as one argument
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- src/ops/experimental.ops
- );
- my $self = Parrot::Ops2pm::Base->new(
- {
- argv => [@ARGV],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm::Base} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- # The following tests will break if the output of Parrot::OpsFile changes
- my %temp = %{ $self->{ops} };
- is( scalar( keys %temp ), 4, "4 keys in object's internal hash" );
- ok( defined( $temp{FILE} ), "FILE key in object is defined" );
- ok( defined( $temp{OPS} ), "OPS key in object is defined" );
- ok( defined( $temp{PREAMBLE} ), "PREAMBLE key in object is defined" );
- ok( defined( $temp{VERSION} ), "VERSION key in object is defined" );
- ok( !ref( $temp{FILE} ), "FILE key in object is not a reference" );
- ok( ref( $temp{OPS} ), "OPS key in object is a reference" );
- is( ref( $temp{OPS} ), q{ARRAY}, "OPS key in object is an array reference" );
- ok( !ref( $temp{PREAMBLE} ), "PREAMBLE key in object is not a reference" );
- ok( !ref( $temp{VERSION} ), "VERSION key in object is not a reference" );
-}
-
-# provide a file with good name but bad content
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $badops = qq{$tdir/src/ops/cmp.ops};
- my $fh = IO::File->new();
- ok( ( $fh->open(">$badops") ), "Able to open file for writing" );
- ok( ( $fh->print("alpha\nbeta\n") ), "Able to print to file" );
- ok( ( $fh->close ), "Able to close file after writing" );
-
- my $num = qq{src/ops/ops.num};
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm::Base->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm::Base} );
-
- eval { $self->prepare_ops; };
- like( $@, qr/OPS invalid for.*?cmp\.ops/, "ops file with bad content correctly detected" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-04-prepare_ops.t - test C<Parrot::Ops2pm::Base::prepare_ops()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/04-prepare_ops.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable methods of
-F<lib/Parrot/Ops2pm::Base.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<04-prepare_ops.t> tests whether C<Parrot::Ops2pm::Base::prepare_ops()>
-works properly.
-
-=head1 COMMENT
-
-The following statements and branches in C<prepare_ops()> are as yet uncovered:
-
-=over 4
-
-=item *
-
-Can C<$ops> be undefined as a result of a call to C<Parrot::OpsFile->new()>?
-
- my $ops = Parrot::OpsFile->new( [$self->{file}], $self->{nolines} );
- die "$self->{script}: Could not read ops file '$self->{file}'!\n"
- unless defined $ops;
-
-Probably not, because the existence of C<$self->{file} has already been
-checked. But it never hurts to check whether a constructor has returned a
-defined value.
-
-=item *
-
-Can I provoke this C<die> message?
-
- my $temp_ops = Parrot::OpsFile->new( [$f], $self->{nolines} );
- die "$self->{script}: Could not read ops file '$f'!\n"
- unless defined $temp_ops;
-
-Probably not, for same reason as above.
-
-=back
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm::Base, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/05-renum_op_map_file.t
==============================================================================
--- trunk/t/tools/ops2pm/05-renum_op_map_file.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,138 +0,0 @@
-#! perl
-# Copyright (C) 2007-2010, Parrot Foundation.
-# $Id$
-# 05-renum_op_map_file.t
-
-use strict;
-use warnings;
-
-use Test::More tests => 6;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Path qw( mkpath );
-use File::Spec;
-use File::Temp qw( tempdir );
-use Tie::File;
-use lib 'lib';
-use Parrot::OpsRenumber;
-
-my ($self, @opsfiles);
-my ($lastcode, $lastnumber);
-my $numoutput = q{src/ops/ops.num};
-my $cwd = cwd();
-my $samplesdir = File::Spec->catdir( $cwd,
- ( qw| t tools ops2pm samples | )
-);;
-ok(-d $samplesdir, "Able to locate samples directory");
-
-{
- ##### Prepare temporary directory for testing #####
-
- my $tdir = tempdir( CLEANUP => 1 );
- chdir $tdir or croak "Unable to change to testing directory: $!";
- my $opsdir = File::Spec->catdir ( $tdir, 'src', 'ops' );
- mkpath( [ $opsdir ], 0, 0755 ) or croak "Unable to make testing directory";
- my $incpardir = File::Spec->catdir ( $tdir, 'include', 'parrot' );
- mkpath( [ $incpardir ], 0, 0755 ) or croak "Unable to make testing directory";
-
- ##### Stage 1: Generate ops.num de novo #####
-
- my @stage1 = qw(
- core_ops.original
- bit_ops.original
- ops_num.original
- );
- copy_into_position($samplesdir, \@stage1, q{original}, $opsdir);
- foreach my $f ( qw| core bit | ) {
- copy qq{$samplesdir/${f}_ops.original}, qq{src/ops/$f.ops.post}
- or croak "Unable to store $f for later testing: $!";
- }
- ($lastcode, $lastnumber) = run_test_stage(
- [ qw(
- src/ops/core.ops
- src/ops/bit.ops
- ) ],
- $numoutput,
- );
- is($lastcode, q{bxors_s_s_sc},
- "Stage 1: Got expected last opcode");
- is($lastnumber, 177,
- "Stage 1: Got expected last opcode number");
-
- ###### Stage 2: Delete some opcodes and regenerate ops.num #####
-
- my @stage2 = qw( bit_ops.second );
- copy_into_position($samplesdir, \@stage2, q{second}, $opsdir);
- ($lastcode, $lastnumber) = run_test_stage(
- [ qw(
- src/ops/core.ops
- src/ops/bit.ops
- ) ],
- $numoutput,
- );
-
- is($lastcode, q{bxor_i_i_ic},
- "Stage 2: Got expected last opcode");
- is($lastnumber, 172,
- "Stage 2: Got expected last opcode number");
-
- # Go back where we started to activate cleanup
- chdir $cwd or croak "Unable to change back to starting directory: $!";
-}
-
-pass("Completed all tests in $0");
-
-#################### SUBROUTINES ####################
-
-sub run_test_stage {
- my ($opsfilesref, $numoutput) = @_;
- my $self = Parrot::OpsRenumber->new(
- {
- argv => $opsfilesref,
- moddir => "lib/Parrot/OpLib",
- module => "core.pm",
- inc_dir => "include/parrot/oplib",
- inc_f => "ops.h",
- script => $0,
- }
- );
-
- $self->prepare_ops();
- $self->renum_op_map_file();
- my ($lastcode, $lastnumber) = get_last_opcode($numoutput);
- return ($lastcode, $lastnumber);
-}
-
-sub copy_into_position {
- my ($samplesdir, $stageref, $ext, $opsdir) = @_;
- foreach my $or ( @{ $stageref } ) {
- my $fullor = File::Spec->catfile( $samplesdir, $or );
- my $real;
- ($real = $or) =~ s/\.$ext$//;
- $real =~ s/_/\./g;
- my $fullreal = File::Spec->catfile( $opsdir, $real );
- copy $fullor, $fullreal or croak "Unable to copy $or";
- }
-}
-
-sub get_last_opcode {
- my $file = shift;
- croak "$file not found: $!" unless -f $file;
- my (@lines, $lastline);
- tie @lines, 'Tie::File', $file or croak "Unable to tie to $file: $!";
- $lastline = $lines[-1];
- untie @lines or croak "Unable to untie from $file: $!";
- my ($lastcode, $lastnumber) = split /\s+/, $lastline, 2;
- croak "Couldn't parse last line of $file: $!"
- unless (defined $lastcode and defined $lastnumber);
- return ($lastcode, $lastnumber);
-}
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
-
Deleted: trunk/t/tools/ops2pm/06-load_op_map_files.t
==============================================================================
--- trunk/t/tools/ops2pm/06-load_op_map_files.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,371 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 06-load_op_map_files.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 76;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use IO::File;
-
-use_ok('Parrot::Ops2pm');
-
-use constant NUM_FILE => "src/ops/ops.num";
-use constant SKIP_FILE => "src/ops/ops.skip";
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-## fail to provide ops.num file
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
-
- # ok(copy(qq{$cwd/$num}, qq{$tdir/$num}), "copied ops.num file");
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- eval { $self->load_op_map_files(); };
- like(
- $@, qr|^Can't open.*src/ops/ops\.num|, #'
- "Failure to prove ops.num correctly detected"
- );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# provide defective ops.num file: hole: missing number
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- my $realnum = qq{$tdir/$num};
- my $tmpnum = $realnum . q{.tmp};
- ok( copy( qq{$cwd/$num}, $tmpnum ), "copied ops.num file to temporary file" );
-
- my $fhin = IO::File->new();
- ok( ( $fhin->open("<$tmpnum") ), "Able to open file for reading" );
- my $fhout = IO::File->new();
- ok( ( $fhout->open(">$realnum") ), "Able to open file for writing" );
- while ( defined( my $line = <$fhin> ) ) {
- chomp $line;
- next if $line =~ /^#/;
- next if $line =~ /^\s*$/;
- next if $line =~ /^c/; # to create holes
- $fhout->print("$line\n");
- }
- ok( $fhout->close(), "Able to close file after writing" );
- ok( $fhin->close(), "Able to close file after reading" );
-
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- eval { $self->load_op_map_files(); };
- like( $@, qr|^hole in ops\.num before|, "Holes in ops.num correctly detected" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# provide defective ops.num file: opname mentioned twice
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- my $realnum = qq{$tdir/$num};
- my $tmpnum = $realnum . q{.tmp};
- ok( copy( qq{$cwd/$num}, $tmpnum ), "copied ops.num file to temporary file" );
-
- my $fhin = IO::File->new();
- ok( ( $fhin->open("<$tmpnum") ), "Able to open file for reading" );
- my @outopnames;
- while ( defined( my $line = <$fhin> ) ) {
- chomp $line;
- next if $line =~ /^#/;
- next if $line =~ /^\s*$/;
- my ( $name, $number ) = split /\s+/, $line, 2;
- push @outopnames, $name;
- }
- ok( $fhin->close(), "Able to close file after reading" );
- my $fhout = IO::File->new();
- ok( ( $fhout->open(">$realnum") ), "Able to open file for writing" );
- for ( my $n = 0 ; $n < 3 ; $n++ ) {
- $fhout->print("$outopnames[$n]\t$n\n");
- }
- my $i = 3;
- $fhout->print("$outopnames[3]\t$i\n");
- $i++;
- for ( my $m = 3 ; $m <= $#outopnames ; $m++ ) {
- $fhout->print("$outopnames[$m]\t$i\n");
- $i++;
- }
- ok( $fhout->close(), "Able to close file after writing" );
-
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- eval { $self->load_op_map_files(); };
- like( $@, qr|^duplicate opcode|, "Duplicate opcode correctly detected" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# provide defective ops.skip file: opname also found in ops.num
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
-
- # ok(copy(qq{$cwd/$skip}, qq{$tdir/$skip}), "copied ops.skip file");
-
- my $realskip = qq{$tdir/$skip};
- my $tmpskip = $realskip . q{.tmp};
- ok( copy( qq{$cwd/$skip}, $tmpskip ), "copied ops.skip file to temporary file" );
-
- my $fhin = IO::File->new();
- ok( ( $fhin->open("<$tmpskip") ), "Able to open file for reading" );
- my @outopnames;
- while ( defined( my $line = <$fhin> ) ) {
- chomp $line;
- next if $line =~ /^#/;
- next if $line =~ /^\s*$/;
- $line =~ s/\s+$//;
- $line =~ s/^\s+//;
- push @outopnames, $line;
- }
- ok( $fhin->close(), "Able to close file after reading" );
- my $fhout = IO::File->new();
- ok( ( $fhout->open(">$realskip") ), "Able to open file for writing" );
- $fhout->print("noop\n");
- for my $l (@outopnames) {
- $fhout->print("$l\n");
- }
- ok( $fhout->close(), "Able to close file after writing" );
-
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- eval { $self->load_op_map_files(); };
- like( $@, qr|^skipped opcode is also in|, "Opcode detected in both ops.num and ops.skip" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-06-load_op_map_files.t - test C<Parrot::Ops2pm::load_op_map_files()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/06-load_op_map_files.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable methods of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<06-load_op_map_files.t> tests whether
-C<Parrot::Ops2pm::load_op_map_files()> works properly.
-
-=head1 TODO
-
-The following statements, branches and conditions in C<load_op_map_files()>
-are as yet uncovered:
-
-=over 4
-
-=item *
-
-Uncovered implicit 'else':
-
- $self->{max_op_num} ||= 0;
-
-Real questions: Can C<$self->{max_op_num}> ever be C<undef>, C<0>
-or empty string? Is there any place prior to this where
-C<$self->{max_op_num}> can be assigned to?
-
-=back
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/07-no_ops_skip.t
==============================================================================
--- trunk/t/tools/ops2pm/07-no_ops_skip.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,117 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 07-no_ops_skip.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 14;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-
-use_ok('Parrot::Ops2pm');
-
-use constant NUM_FILE => "src/ops/ops.num";
-use constant SKIP_FILE => "src/ops/ops.skip";
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-
-# fail to provide ops.skip file
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
-
- # ok(copy(qq{$cwd/$skip}, qq{$tdir/$skip}), "copied ops.skip file");
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- eval { $self->load_op_map_files(); };
- like(
- $@, qr|^Can't open.*src/ops/ops\.skip|, #'
- "Failure to prove ops.skip correctly detected"
- );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-07-no_ops_skip.t - test C<Parrot::Ops2pm::no_ops_skip()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/07-no_ops_skip.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<07-no_ops_skip.t> tests what happens when there is no F<src/ops/ops.skip>
-available for C<load_op_map_files()> to evaluate.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/08-sort_ops.t
==============================================================================
--- trunk/t/tools/ops2pm/08-sort_ops.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,353 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 08-sort_ops.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More;
-use Carp;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-
-my $cwd = cwd();
-plan -e "$cwd/DEVELOPING" ? ( tests => 86 ) :
- ( skip_all => 'Requires DEVELOPING file' );
-
-use_ok('Parrot::Ops2pm');
-use IO::CaptureOutput qw| capture |;
-
-use constant NUM_FILE => "src/ops/ops.num";
-use constant SKIP_FILE => "src/ops/ops.skip";
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-
-# regular case
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- # To do: Test that the sorting was correct.
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# include experimental.ops in @ARGV
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- src/ops/experimental.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- # To do: Test that the sorting was correct.
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# include experimental.ops in @ARGV; use 'DEVELOPING' to trigger warning
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- src/ops/experimental.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- ok( copy( qq{$cwd/DEVELOPING}, qq{$tdir/DEVELOPING} ), "copied DEVELOPING file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- my ($stdout, $stderr);
- my $ret = capture(
- sub { $self->sort_ops() },
- \$stdout,
- \$stderr
- );
- ok($ret, "sort_ops returned successfully" );
-
- like(
- $stderr,
- qr|experimental, not in ops\.num|,
- "Got expected warning about experimental ops"
- );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# include object.ops in @ARGV; use 'DEVELOPING' to trigger warning
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- src/ops/object.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- ok( copy( qq{$cwd/DEVELOPING}, qq{$tdir/DEVELOPING} ), "copied DEVELOPING file" );
- my $dummyops = "./src/ops/dummy.ops";
- open my $FH, ">", $dummyops
- or croak "Unable to open handle to create dummy ops file: $!";
- print $FH <<DUMMYOPS;
-/*
-** dummy.ops
-*/
-
-inline op zzzzzz(inout INT, in INT) :base_core {
- goto NEXT();
-}
-DUMMYOPS
- close $FH or croak "Unable to close handle after writing: $!";
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- my ($stdout, $stderr);
- eval { $self->sort_ops() };
- like(
- $@,
- qr|not in ops\.num nor ops\.skip|,
- "Got expected failure about ops in neither ops.num or ops.skip"
- );
-
- # To do: Test that the sorting was correct.
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# include object.ops in @ARGV; do not use 'DEVELOPING' to trigger warning
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- src/ops/object.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
-
- # ok(copy(qq{$cwd/DEVELOPING}, qq{$tdir/DEVELOPING}),
- # "copied DEVELOPING file");
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- my ($stdout, $stderr);
- my $ret = capture(
- sub { $self->sort_ops() },
- \$stdout,
- \$stderr
- );
- ok($ret, "sort_ops returned successfully" );
- ok( ! $stderr, "Got no warning, as expected" );
-
- # To do: Test that the sorting was correct.
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-08-sort_ops.t - test C<Parrot::Ops2pm::sort_ops()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/08-sort_ops.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable subroutines of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<08-sort_ops.t> tests whether
-C<Parrot::Ops2pm::sort_ops()> works properly.
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/09-prepare_real_ops.t
==============================================================================
--- trunk/t/tools/ops2pm/09-prepare_real_ops.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,215 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 09-prepare_real_ops.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 38;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use IO::File;
-
-use_ok('Parrot::Ops2pm');
-
-use constant NUM_FILE => "src/ops/ops.num";
-use constant SKIP_FILE => "src/ops/ops.skip";
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- ok( $self->prepare_real_ops(), "prepare_real_ops() returned successfully" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
-
- # ok(copy(qq{$cwd/$num}, qq{$tdir/$num}), "copied ops.num file");
-
- my $realnum = qq{$tdir/$num};
- my $tmpnum = $realnum . q{.tmp};
- ok( copy( qq{$cwd/$num}, $tmpnum ), "copied ops.num file to temporary file" );
-
- my $fhin = IO::File->new();
- ok( ( $fhin->open("<$tmpnum") ), "Able to open file for reading" );
- my @outlines;
- while ( defined( my $line = <$fhin> ) ) {
- chomp $line;
- next if $line =~ /^#/;
- next if $line =~ /^\s*$/;
- my ( $name, $number ) = split /\s+/, $line, 2;
- push @outlines, [ $name, $number ];
- }
- ok( $fhin->close(), "Able to close file after reading" );
- my $fhout = IO::File->new();
- ok( ( $fhout->open(">$realnum") ), "Able to open file for writing" );
- $fhout->print("$outlines[0]->[0]\t$outlines[0]->[1]\n");
-
- # This misnumbering is not generating an error.
- # Reversing the order generated "hole in" error from load_op_map_files().
- $fhout->print("$outlines[2]->[0]\t$outlines[1]->[1]\n");
- $fhout->print("$outlines[1]->[0]\t$outlines[2]->[1]\n");
- for ( my $n = 3 ; $n <= $#outlines ; $n++ ) {
- $fhout->print("$outlines[$n]->[0]\t$outlines[$n]->[1]\n");
- }
- ok( $fhout->close(), "Able to close file after writing" );
-
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- eval { $self->prepare_real_ops(); };
-
- # like($@, qr/number mismatch/,
- # "Number mismatch correctly detected");
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-09-prepare_real_ops.t - test C<Parrot::Ops2pm::prepare_real_ops()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/09-prepare_real_ops.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable methods of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<09-prepare_real_ops.t> tests whether
-C<Parrot::Ops2pm::prepare_real_ops()> works properly.
-
-=head1 TODO
-
-The following statements, branches and conditions in C<prepare_real_ops()>
-are as yet uncovered:
-
-=over 4
-
-=item *
-
-Can these two C<die> statements be provoked?
-
- if ( $n != $el->{CODE} ) {
- die "op $opname: number mismatch: ops.num $n vs. core.ops $el->{CODE}";
- }
- if ( $seq != $el->{CODE} ) {
- die "op $opname: sequence mismatch: ops.num $seq vs. core.ops $el->{CODE}";
- }
-
-=back
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/10-print_module.t
==============================================================================
--- trunk/t/tools/ops2pm/10-print_module.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,212 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 10-print_module.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 42;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-use IO::File;
-
-use_ok('Parrot::Ops2pm');
-
-use constant NUM_FILE => "src/ops/ops.num";
-use constant SKIP_FILE => "src/ops/ops.skip";
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- moddir => "lib/Parrot/OpLib",
- module => "core.pm",
-
- # inc_dir => "include/parrot/oplib",
- # inc_f => "ops.h",
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- ok( $self->prepare_real_ops(), "prepare_real_ops() returned successfully" );
-
- ok( $self->print_module(), "print_module() returned true" );
- ok( -f qq{$tdir/$self->{moddir}/$self->{module}}, "core.pm file written" );
-
- # Todo: test characteristics of .pm file written
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-# --no-lines command-line option
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => 1,
- renum => undef,
- moddir => "lib/Parrot/OpLib",
- module => "core.pm",
-
- # inc_dir => "include/parrot/oplib",
- # inc_f => "ops.h",
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- ok( $self->prepare_real_ops(), "prepare_real_ops() returned successfully" );
-
- ok( $self->print_module(), "print_module() returned true" );
- ok( -f qq{$tdir/$self->{moddir}/$self->{module}}, "core.pm file written" );
-
- my $fhin = IO::File->new();
- ok( ( $fhin->open("<$tdir/$self->{moddir}/$self->{module}") ),
- "Able to open file for reading" );
- my $corepm;
- {
- local $/;
- $corepm = <$fhin>;
- }
- ok( $fhin->close(), "Able to close file after reading" );
- unlike( $corepm, qr/#line/, "No '#line' directives found in generated C code" );
-
- # Todo: more tests of characteristics of .pm file written
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-10-print_module.t - test C<Parrot::Ops2pm::print_module()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/10-print_module.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable methods of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<10-print_module.t> tests whether
-C<Parrot::Ops2pm::print_module()> works properly.
-
-=head1 TODO
-
-The following statements, branches and conditions in C<print_module()>
-are as yet uncovered:
-
-=over 4
-
-=item *
-
-Directory failure: can it be provoked?
-
- if ( !-d $fulldir ) {
- File::Path::mkpath( [ $fulldir ], 0, 0755 )
- or die "$self->{script}: Could not mkdir $fulldir: $!!\n";
- }
-
-=back
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/11-print_h.t
==============================================================================
--- trunk/t/tools/ops2pm/11-print_h.t Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,144 +0,0 @@
-#! perl
-# Copyright (C) 2007-2008, Parrot Foundation.
-# $Id$
-# 11-print_h.t
-
-use strict;
-use warnings;
-
-BEGIN {
- use FindBin qw($Bin);
- use Cwd qw(cwd realpath);
- realpath($Bin) =~ m{^(.*\/parrot)\/[^/]*\/[^/]*\/[^/]*$};
- our $topdir = $1;
- if ( defined $topdir ) {
- print "\nOK: Parrot top directory located\n";
- }
- else {
- $topdir = realpath($Bin) . "/../../..";
- }
- unshift @INC, qq{$topdir/lib};
-}
-use Test::More tests => 23;
-use Cwd;
-use File::Copy;
-use File::Temp (qw| tempdir |);
-
-use_ok('Parrot::Ops2pm');
-
-use constant NUM_FILE => "src/ops/ops.num";
-use constant SKIP_FILE => "src/ops/ops.skip";
-
-ok( chdir $main::topdir, "Positioned at top-level Parrot directory" );
-{
- local @ARGV = qw(
- src/ops/core.ops
- src/ops/bit.ops
- );
- my $cwd = cwd();
- {
- my $tdir = tempdir( CLEANUP => 1 );
- ok( chdir $tdir, 'changed to temp directory for testing' );
- ok( ( mkdir qq{$tdir/src} ), "able to make tempdir/src" );
- ok( ( mkdir qq{$tdir/src/ops} ), "able to make tempdir/src" );
- foreach my $f (@ARGV) {
- ok( copy( qq{$cwd/$f}, qq{$tdir/$f} ), "copied .ops file" );
- }
- my $num = NUM_FILE;
- my $skip = SKIP_FILE;
- ok( copy( qq{$cwd/$num}, qq{$tdir/$num} ), "copied ops.num file" );
- ok( copy( qq{$cwd/$skip}, qq{$tdir/$skip} ), "copied ops.skip file" );
- my @opsfiles = glob("./src/ops/*.ops");
-
- my $self = Parrot::Ops2pm->new(
- {
- argv => [@opsfiles],
- script => "tools/build/ops2pm.pl",
- nolines => undef,
- renum => undef,
- moddir => "lib/Parrot/OpLib",
- module => "core.pm",
- inc_dir => "include/parrot/oplib",
- inc_f => "ops.h",
- }
- );
- isa_ok( $self, q{Parrot::Ops2pm} );
-
- ok( $self->prepare_ops, "prepare_ops() returned successfully" );
- ok( defined( $self->{ops} ), "'ops' key has been defined" );
-
- ok( $self->load_op_map_files(), "load_op_map_files() completed successfully" );
- ok( -f $num, "ops.num located after renumbering" );
- ok( -f $skip, "ops.skip located after renumbering" );
-
- ok( $self->sort_ops(), "sort_ops returned successfully" );
-
- ok( $self->prepare_real_ops(), "prepare_real_ops() returned successfully" );
-
- ok( $self->print_module(), "print_module() returned true" );
- ok( -f qq{$tdir/$self->{moddir}/$self->{module}}, "core.pm file written" );
-
- ok( $self->print_h(), "print_h() returned true" );
- ok( -f qq{$tdir/$self->{inc_dir}/$self->{inc_f}}, "$self->{inc_f} created" );
-
- ok( chdir $cwd, 'changed back to starting directory after testing' );
- }
-}
-
-pass("Completed all tests in $0");
-
-################### DOCUMENTATION ###################
-
-=head1 NAME
-
-11-print_h.t - test C<Parrot::Ops2pm::print_h()>
-
-=head1 SYNOPSIS
-
- % prove t/tools/ops2pm/11-print_h.t
-
-=head1 DESCRIPTION
-
-The files in this directory test the publicly callable methods of
-F<lib/Parrot/Ops2pm.pm> and F<lib/Parrot/Ops2pm/Auxiliary.pm>.
-By doing so, they test the functionality of the F<ops2pm.pl> utility.
-That functionality has largely been extracted
-into the methods of F<Utils.pm>.
-
-F<11-print_h.t> tests whether
-C<Parrot::Ops2pm::print_h()> works properly.
-
-=head1 TODO
-
-The following statements, branches and conditions in C<print_h()>
-are as yet uncovered:
-
-=over 4
-
-=item *
-
-Directory failure: can it be provoked?
-
- if ( !-d $fulldir ) {
- File::Path::mkpath( [ $fulldir ], 0, 0755 )
- or die "$self->{script}: Could not mkdir $fulldir: $!!\n";
- }
-
-=back
-
-=head1 AUTHOR
-
-James E Keenan
-
-=head1 SEE ALSO
-
-Parrot::Ops2pm, F<ops2pm.pl>.
-
-=cut
-
-# Local Variables:
-# mode: cperl
-# cperl-indent-level: 4
-# fill-column: 100
-# End:
-# vim: expandtab shiftwidth=4:
Deleted: trunk/t/tools/ops2pm/samples/bit_ops.original
==============================================================================
--- trunk/t/tools/ops2pm/samples/bit_ops.original Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,353 +0,0 @@
-/*
- * $Id$
-** bit.ops
-*/
-
- /* Signed shift operator that is compatible with PMC shifts. This is
- * guaranteed to produce the same result as bitwise_left_shift_internal modulo
- * word size, ignoring the fact that Parrot integers are always signed. This
- * usually gives the same answer regardless whether you shift PMC operands and
- * then assign to an I-reg, or move the operands to I-regs and do the shift
- * there -- except when the true result is between 2^{w-1} and 2^w (where w is
- * the word size), in which case the high order bit is taken as the sign,
- * giving a truncated result that is 2^w lower.
- */
-#define bit_shift_left(number, bits) \
- ((bits) >= 8*INTVAL_SIZE ? 0 \
- : (bits) >= 0 ? (number) << (bits) \
- : (bits) > -8*INTVAL_SIZE ? (number) >> -(bits) \
- : 0)
-
-VERSION = PARROT_VERSION;
-
-=head1 NAME
-
-bit.ops - Bitwise Operations
-
-=head1 DESCRIPTION
-
-Operations that deal with bits directly, either individually
-or in groups.
-
-The variant with an appended B<s> like B<bands> work on strings.
-
-The variants with a prepended B<n_> like <n_bnot> generate a new target PMC.
-If possible, they use the appropriate language type, specified with C<.HLL>.
-
-=over 4
-
-=cut
-
-###############################################################################
-
-=item B<band>(inout INT, in INT)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $1 and $2.
-
-=item B<band>(out INT, in INT, in INT)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op band(inout INT, in INT) :base_core {
- $1 &= $2;
-}
-
-inline op band(out INT, in INT, in INT) :base_core {
- $1 = $2 & $3;
-}
-
-=item B<bands>(inout STR, in STR)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $1 and $2.
-
-=item B<bands>(out STR, in STR, in STR)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bands(inout STR, in STR) :base_core {
- Parrot_str_bitwise_and(interp, $1, $2, &$1);
-}
-
-inline op bands(out STR, in STR, in STR) :base_core {
- $1 = Parrot_str_bitwise_and(interp, $2, $3, NULL);
-}
-
-########################################
-
-=item B<bnot>(inout INT)
-
-=item B<bnot>(invar PMC)
-
-Sets $1 to C<bitwise not> $1 inplace.
-
-=item B<bnot>(out INT, in INT)
-
-=item B<bnot>(out PMC, invar PMC)
-
-=item B<n_bnot>(out PMC, invar PMC)
-
-Set the bits of $1 to the B<not> of the corresponding bits from $2.
-
-=cut
-
-inline op bnot(inout INT) :base_core {
- $1 = ~ $1;
-}
-
-inline op bnot(out INT, in INT) :base_core {
- $1 = ~ $2;
-}
-
-inline op bnot(invar PMC) :base_core {
- VTABLE_i_bitwise_not(interp, $1);
-}
-
-inline op bnot(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_not(interp, $2, $1);
-}
-
-inline op n_bnot(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_not(interp, $2, NULL);
-}
-
-=item B<bnots>(inout STR)
-
-=item B<bnots>(invar PMC)
-
-=item B<bnots>(out STR, in STR)
-
-=item B<bnots>(out PMC, invar PMC)
-
-=item B<n_bnots>(out PMC, invar PMC)
-
-Set the bits of $1 to the B<not> of the corresponding bits from $2.
-
-=cut
-
-inline op bnots(inout STR) :base_core {
- Parrot_str_bitwise_not(interp, $1, &$1);
-}
-
-inline op bnots(out STR, in STR) :base_core {
- Parrot_str_bitwise_not(interp, $2, &$1);
-}
-
-inline op bnots(invar PMC) :base_core {
- VTABLE_i_bitwise_nots(interp, $1);
-}
-
-inline op bnots(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_nots(interp, $2, $1);
-}
-
-inline op n_bnots(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_nots(interp, $2, NULL);
-}
-
-########################################
-
-=item B<bor>(inout INT, in INT)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $1 and $2.
-
-=item B<bor>(out INT, in INT, in INT)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bor(inout INT, in INT) :base_core {
- $1 |= $2;
-}
-
-inline op bor(out INT, in INT, in INT) :base_core {
- $1 = $2 | $3;
-}
-
-=item B<bors>(inout STR, in STR)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $1 and $2.
-
-=item B<bors>(out STR, in STR, in STR)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bors(inout STR, in STR) :base_core {
- Parrot_str_bitwise_or(interp, $1, $2, &$1);
-}
-
-inline op bors(out STR, in STR, in STR) :base_core {
- $1 = Parrot_str_bitwise_or(interp, $2, $3, NULL);
-}
-
-########################################
-
-=item B<shl>(inout INT, in INT)
-
-Shift left $1 by $2 bits.
-
-=item B<shl>(out INT, in INT, in INT)
-
-Set $1 to the value of $2 shifted left by $3 bits.
-
-=cut
-
-inline op shl(inout INT, in INT) :base_core {
- $1 = bit_shift_left($1, $2);
-}
-
-inline op shl(out INT, in INT, in INT) :base_core {
- $1 = bit_shift_left($2, $3);
-}
-
-########################################
-
-=item B<shr>(inout INT, in INT)
-
-Shift right $1 by $2 bits.
-
-=item B<shr>(out INT, in INT, in INT)
-
-Set $1 to the value of $2 shifted right by $3 bits.
-
-=cut
-
-inline op shr(inout INT, in INT) :base_core {
- INTVAL signed_shift = -$2;
- $1 = bit_shift_left($1, signed_shift);
-}
-
-inline op shr(out INT, in INT, in INT) :base_core {
- INTVAL signed_shift = -$3;
- $1 = bit_shift_left($2, signed_shift);
-}
-
-########################################
-
-=item B<lsr>(out INT, in INT)
-
-Shift $1 logically shifted right by $2 bits.
-
-=item B<lsr>(out INT, in INT, in INT)
-
-Set $1 to the value of $2 logically shifted right by $3 bits.
-
-=cut
-
-inline op lsr(out INT, in INT) :base_core {
- /*
- * lvalue casts are evil, but this one isn't evil enough to kill.
- * it's just casting a signed integral to the equivalent unsigned.
- */
- LVALUE_CAST(UINTVAL, $1) >>= $2;
-}
-
-inline op lsr(out INT, in INT, in INT) :base_core {
- $1 = (INTVAL)((UINTVAL)$2 >> $3);
-}
-
-=item B<rot>(out INT, in INT, in INT, inconst INT)
-
-Rotate $2 left or right by $3 and place result in $1.
-$4 is the amount of bits to rotate, 32 bit on a 32-bit CPU and 32 or 64
-on a 64-bit CPU. If the rotate count is negative a rotate right by ($3+$4)
-is performed.
-
-=cut
-
-inline op rot(out INT, in INT, in INT, inconst INT) {
- const INTVAL r = $2;
- INTVAL s = $3;
- const INTVAL w = $4;
- INTVAL d, t;
- if (s < 0)
- s += w;
- d = r << s;
- t = w - s;
- t = (INTVAL)((UINTVAL)r >> t);
- d |= t;
- $1 = d;
-}
-
-
-}
-
-########################################
-
-=item B<bxor>(inout INT, in INT)
-
-Set the bits of $1 according to the B<xor> of the corresponding bits
-from $1 and $2.
-
-=item B<bxor>(out INT, in INT, in INT)
-
-Set the bits of $1 according to the B<xor> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bxor(inout INT, in INT) :base_core {
- $1 ^= $2;
-}
-
-inline op bxor(out INT, in INT, in INT) :base_core {
- $1 = $2 ^ $3;
-}
-
-=item B<bxors>(inout STR, in STR)
-
-Set the bits of $1 according to the B<xor> of the corresponding bits
-from $1 and $2.
-
-=item B<bxors>(out STR, in STR, in STR)
-
-Set the bits of $1 according to the B<xor> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bxors(inout STR, in STR) :base_core {
- Parrot_str_bitwise_xor(interp, $1, $2, &$1);
-}
-
-inline op bxors(out STR, in STR, in STR) :base_core {
- $1 = Parrot_str_bitwise_xor(interp, $2, $3, NULL);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head1 COPYRIGHT
-
-Copyright (C) 2001-2008, Parrot Foundation.
-
-=head1 LICENSE
-
-This program is free software. It is subject to the same license
-as the Parrot interpreter itself.
-
-=cut
-
-/*
- * Local variables:
- * c-file-style: "parrot"
- * End:
- * vim: expandtab shiftwidth=4:
- */
Deleted: trunk/t/tools/ops2pm/samples/bit_ops.second
==============================================================================
--- trunk/t/tools/ops2pm/samples/bit_ops.second Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,333 +0,0 @@
-/*
- * $Id$
-** bit.ops
-*/
-
- /* Signed shift operator that is compatible with PMC shifts. This is
- * guaranteed to produce the same result as bitwise_left_shift_internal modulo
- * word size, ignoring the fact that Parrot integers are always signed. This
- * usually gives the same answer regardless whether you shift PMC operands and
- * then assign to an I-reg, or move the operands to I-regs and do the shift
- * there -- except when the true result is between 2^{w-1} and 2^w (where w is
- * the word size), in which case the high order bit is taken as the sign,
- * giving a truncated result that is 2^w lower.
- */
-#define bit_shift_left(number, bits) \
- ((bits) >= 8*INTVAL_SIZE ? 0 \
- : (bits) >= 0 ? (number) << (bits) \
- : (bits) > -8*INTVAL_SIZE ? (number) >> -(bits) \
- : 0)
-
-VERSION = PARROT_VERSION;
-
-=head1 NAME
-
-bit.ops - Bitwise Operations
-
-=head1 DESCRIPTION
-
-Operations that deal with bits directly, either individually
-or in groups.
-
-The variant with an appended B<s> like B<bands> work on strings.
-
-The variants with a prepended B<n_> like <n_bnot> generate a new target PMC.
-If possible, they use the appropriate language type, specified with C<.HLL>.
-
-=over 4
-
-=cut
-
-###############################################################################
-
-=item B<band>(inout INT, in INT)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $1 and $2.
-
-=item B<band>(out INT, in INT, in INT)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op band(inout INT, in INT) :base_core {
- $1 &= $2;
-}
-
-inline op band(out INT, in INT, in INT) :base_core {
- $1 = $2 & $3;
-}
-
-=item B<bands>(inout STR, in STR)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $1 and $2.
-
-=item B<bands>(out STR, in STR, in STR)
-
-Set the bits of $1 according to the B<and> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bands(inout STR, in STR) :base_core {
- Parrot_str_bitwise_and(interp, $1, $2, &$1);
-}
-
-inline op bands(out STR, in STR, in STR) :base_core {
- $1 = Parrot_str_bitwise_and(interp, $2, $3, NULL);
-}
-
-########################################
-
-=item B<bnot>(inout INT)
-
-=item B<bnot>(invar PMC)
-
-Sets $1 to C<bitwise not> $1 inplace.
-
-=item B<bnot>(out INT, in INT)
-
-=item B<bnot>(out PMC, invar PMC)
-
-=item B<n_bnot>(out PMC, invar PMC)
-
-Set the bits of $1 to the B<not> of the corresponding bits from $2.
-
-=cut
-
-inline op bnot(inout INT) :base_core {
- $1 = ~ $1;
-}
-
-inline op bnot(out INT, in INT) :base_core {
- $1 = ~ $2;
-}
-
-inline op bnot(invar PMC) :base_core {
- VTABLE_i_bitwise_not(interp, $1);
-}
-
-inline op bnot(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_not(interp, $2, $1);
-}
-
-inline op n_bnot(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_not(interp, $2, NULL);
-}
-
-=item B<bnots>(inout STR)
-
-=item B<bnots>(invar PMC)
-
-=item B<bnots>(out STR, in STR)
-
-=item B<bnots>(out PMC, invar PMC)
-
-=item B<n_bnots>(out PMC, invar PMC)
-
-Set the bits of $1 to the B<not> of the corresponding bits from $2.
-
-=cut
-
-inline op bnots(inout STR) :base_core {
- Parrot_str_bitwise_not(interp, $1, &$1);
-}
-
-inline op bnots(out STR, in STR) :base_core {
- Parrot_str_bitwise_not(interp, $2, &$1);
-}
-
-inline op bnots(invar PMC) :base_core {
- VTABLE_i_bitwise_nots(interp, $1);
-}
-
-inline op bnots(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_nots(interp, $2, $1);
-}
-
-inline op n_bnots(out PMC, invar PMC) :base_core {
- $1 = VTABLE_bitwise_nots(interp, $2, NULL);
-}
-
-########################################
-
-=item B<bor>(inout INT, in INT)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $1 and $2.
-
-=item B<bor>(out INT, in INT, in INT)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bor(inout INT, in INT) :base_core {
- $1 |= $2;
-}
-
-inline op bor(out INT, in INT, in INT) :base_core {
- $1 = $2 | $3;
-}
-
-=item B<bors>(inout STR, in STR)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $1 and $2.
-
-=item B<bors>(out STR, in STR, in STR)
-
-Set the bits of $1 according to the B<or> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bors(inout STR, in STR) :base_core {
- Parrot_str_bitwise_or(interp, $1, $2, &$1);
-}
-
-inline op bors(out STR, in STR, in STR) :base_core {
- $1 = Parrot_str_bitwise_or(interp, $2, $3, NULL);
-}
-
-########################################
-
-=item B<shl>(inout INT, in INT)
-
-Shift left $1 by $2 bits.
-
-=item B<shl>(out INT, in INT, in INT)
-
-Set $1 to the value of $2 shifted left by $3 bits.
-
-=cut
-
-inline op shl(inout INT, in INT) :base_core {
- $1 = bit_shift_left($1, $2);
-}
-
-inline op shl(out INT, in INT, in INT) :base_core {
- $1 = bit_shift_left($2, $3);
-}
-
-########################################
-
-=item B<shr>(inout INT, in INT)
-
-Shift right $1 by $2 bits.
-
-=item B<shr>(out INT, in INT, in INT)
-
-Set $1 to the value of $2 shifted right by $3 bits.
-
-=cut
-
-inline op shr(inout INT, in INT) :base_core {
- INTVAL signed_shift = -$2;
- $1 = bit_shift_left($1, signed_shift);
-}
-
-inline op shr(out INT, in INT, in INT) :base_core {
- INTVAL signed_shift = -$3;
- $1 = bit_shift_left($2, signed_shift);
-}
-
-########################################
-
-=item B<lsr>(out INT, in INT)
-
-Shift $1 logically shifted right by $2 bits.
-
-=item B<lsr>(out INT, in INT, in INT)
-
-Set $1 to the value of $2 logically shifted right by $3 bits.
-
-=cut
-
-inline op lsr(out INT, in INT) :base_core {
- /*
- * lvalue casts are evil, but this one isn't evil enough to kill.
- * it's just casting a signed integral to the equivalent unsigned.
- */
- LVALUE_CAST(UINTVAL, $1) >>= $2;
-}
-
-inline op lsr(out INT, in INT, in INT) :base_core {
- $1 = (INTVAL)((UINTVAL)$2 >> $3);
-}
-
-=item B<rot>(out INT, in INT, in INT, inconst INT)
-
-Rotate $2 left or right by $3 and place result in $1.
-$4 is the amount of bits to rotate, 32 bit on a 32-bit CPU and 32 or 64
-on a 64-bit CPU. If the rotate count is negative a rotate right by ($3+$4)
-is performed.
-
-=cut
-
-inline op rot(out INT, in INT, in INT, inconst INT) {
- const INTVAL r = $2;
- INTVAL s = $3;
- const INTVAL w = $4;
- INTVAL d, t;
- if (s < 0)
- s += w;
- d = r << s;
- t = w - s;
- t = (INTVAL)((UINTVAL)r >> t);
- d |= t;
- $1 = d;
-}
-
-
-}
-
-########################################
-
-=item B<bxor>(inout INT, in INT)
-
-Set the bits of $1 according to the B<xor> of the corresponding bits
-from $1 and $2.
-
-=item B<bxor>(out INT, in INT, in INT)
-
-Set the bits of $1 according to the B<xor> of the corresponding bits
-from $2 and $3.
-
-=cut
-
-inline op bxor(inout INT, in INT) :base_core {
- $1 ^= $2;
-}
-
-inline op bxor(out INT, in INT, in INT) :base_core {
- $1 = $2 ^ $3;
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head1 COPYRIGHT
-
-Copyright (C) 2001-2008, Parrot Foundation.
-
-=head1 LICENSE
-
-This program is free software. It is subject to the same license
-as the Parrot interpreter itself.
-
-=cut
-
-/*
- * Local variables:
- * c-file-style: "parrot"
- * End:
- * vim: expandtab shiftwidth=4:
- */
Deleted: trunk/t/tools/ops2pm/samples/core_ops.original
==============================================================================
--- trunk/t/tools/ops2pm/samples/core_ops.original Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,1326 +0,0 @@
-/*
- * $Id$
-** core.ops
-*/
-
-#include "parrot/dynext.h"
-#include "parrot/embed.h"
-#include "../interp/interp_guts.h"
-
-VERSION = PARROT_VERSION;
-
-=head1 NAME
-
-core.ops - Parrot Core Ops
-
-=cut
-
-=head1 DESCRIPTION
-
-Parrot's core library of ops.
-
-Core operations are primarily flow control and interpreter
-introspection.
-
-=cut
-
-# ' for emacs
-
-###############################################################################
-
-=head2 Basic ops
-
-These are the fundamental operations.
-Please note: These opcodes must not be moved; they must have
-exactly these opcode numbers. Opcodes ending with underscores are for
-internal use only; don't emit these opcodes.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<end>()
-
-Halts the interpreter. (Must be op #0, CORE_OPS_end). See also B<exit>.
-
-=cut
-
-inline op end() :base_core :check_event :flow {
- HALT();
-}
-
-
-########################################
-
-=item B<noop>()
-
-Does nothing other than waste an iota of time and 32 bits of bytecode space.
-(Must be op #1, CORE_OPS_noop)
-
-=item B<cpu_ret>()
-
-Emit a cpu return instruction. This is used to return from CGP core
-to JIT code. Note: Do B<not> use this opcode. It is for internal use only.
-(Must be op #2, CORE_OPS_cpu_ret)
-
-=item B<check_events>()
-
-Check the event queue and run event handlers if there are unhandled events.
-Note: This opcode is mainly for testing. It should not be necessary to ever
-use it explicitly.
-(Must be op #3, CORE_OPS_check_events).
-
-=item B<check_events__>()
-
-Check the event queue and run event handlers if there are unhandled events.
-Note: Do B<not> use this opcode. It is for internal use only.
-(Must be op #4, CORE_OPS_check_events__).
-
-=item B<wrapper__>()
-
-Internal opcode to wrap unknown ops from loaded opcode libs.
-Don't use.
-(Must be op #5, CORE_OPS_wrapper__).
-
-=item B<prederef__>()
-
-Internal opcode to prederef opcodes on the fly.
-Don't use.
-(Must be op #6, CORE_OPS_prederef__).
-
-=item B<reserved>(inconst INT)
-
-Reserve 1 more fix entry.
-
-=item B<load_bytecode>(in STR)
-
-Load Parrot bytecode from file $1, and search the library path to locate the
-file.
-
-=cut
-
-inline op noop() :base_core {
-}
-
-inline op cpu_ret() {
-#ifdef __GNUC__
-# ifdef I386
- __asm__("ret");
-# endif
-#endif
-}
-
-inline op check_events() :base_core :flow {
- opcode_t *next = expr NEXT();
- Parrot_cx_check_tasks(interp, interp->scheduler);
- goto ADDRESS(next); /* force this being a branch op */
-}
-
-inline op check_events__() :internal :flow {
- opcode_t *_this = CUR_OPCODE;
- /* Restore op_func_table. */
- disable_event_checking(interp);
- Parrot_cx_handle_tasks(interp, interp->scheduler);
- goto ADDRESS(_this); /* force this being a branch op */
-}
-
-inline op wrapper__() :internal :flow {
- opcode_t *pc = CUR_OPCODE;
- DO_OP(pc, interp);
- goto ADDRESS(pc);
-}
-
-inline op prederef__() :internal :flow {
- opcode_t *_this = CUR_OPCODE;
- if (interp->run_core & PARROT_CGOTO_CORE) {
- /* must be CGP then - check for events in not yet prederefed code */
- Parrot_cx_runloop_wake(interp, interp->scheduler);
- /* _this = CHECK_EVENTS(interp, _this); */
- }
- do_prederef((void**)cur_opcode, interp, op_lib.core_type);
- goto ADDRESS(_this); /* force this being a branch op */
-}
-
-inline op reserved(inconst INT) {
- /* reserve 1 entries */
-}
-
-inline op load_bytecode(in STR) :load_file {
- Parrot_load_bytecode(interp, $1);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head2 Control flow
-
-The control flow opcodes check conditions and manage program flow.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<branch>(in LABEL)
-
-Branch forward or backward by the amount in $1.
-
-=cut
-
-inline op branch(in LABEL) :base_loop :flow {
- goto OFFSET($1);
-}
-
-
-=item B<branch_cs>(in STR)
-
-Intersegment branch to location in fixup table named $1.
-
-=cut
-
-inline op branch_cs(in STR) :base_loop :check_event :flow {
- char * const label = string_to_cstring(interp, $1);
- PackFile_FixupEntry * const fe =
- PackFile_find_fixup_entry(interp, enum_fixup_label, label);
-
- if (!fe) {
- Parrot_str_free_cstring(label);
- real_exception(interp, NULL, 1, "branch_cs: fixup for '%Ss' not found",
- $1);
- }
- else {
- interp->resume_offset = fe->offset;
- Parrot_switch_to_cs(interp, fe->seg, 1);
- }
- mem_sys_free(fe);
- Parrot_str_free_cstring(label);
- interp->resume_flag = 2;
- goto ADDRESS(0);
-}
-
-########################################
-
-=item B<bsr>(in LABEL)
-
-Branch to the location specified by $1. Push the current location onto the call
-stack for later returning.
-
-=cut
-
-inline op bsr(in LABEL) :base_core :check_event :flow {
- stack_push(interp, &interp->dynamic_env,
- expr NEXT(), STACK_ENTRY_DESTINATION, STACK_CLEANUP_NULL);
- goto OFFSET($1);
-}
-
-=item B<ret>()
-
-Pop the location off the top of the call stack and go there.
-
-=cut
-
-inline op ret() :flow {
- goto POP();
-}
-
-
-########################################
-
-=item B<jsr>(in LABEL)
-
-Jump to the location specified by register $1. Push the current
-location onto the call stack for later returning.
-
-=cut
-
-inline op jsr(in LABEL) :base_core :check_event :flow {
- opcode_t * loc;
- stack_push(interp, &interp->dynamic_env,
- expr NEXT(), STACK_ENTRY_DESTINATION, STACK_CLEANUP_NULL);
- loc = INTVAL2PTR(opcode_t *, $1);
- goto ADDRESS(loc);
-}
-
-
-########################################
-
-=item B<jump>(in LABEL)
-
-Jump to the address held in register $1.
-
-=cut
-
-inline op jump(in LABEL) :base_loop :flow {
- opcode_t * const loc = INTVAL2PTR(opcode_t *, $1);
- goto ADDRESS(loc);
-}
-
-########################################
-
-=item B<enternative>()
-
-Internal opcode used to jump from normal bytecode into a JITted version.
-
-=cut
-
-op enternative() :flow {
- opcode_t * const addr = run_native(interp, CUR_OPCODE,
- interp->code->base.data);
- goto ADDRESS(addr);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head2 Conditional branch operations
-
-These operations perform a conditional relative branch. If the condition is
-met, the branch happens. Otherwise control falls to the next operation.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<if>(invar INT, inconst LABEL)
-
-=item B<if>(invar NUM, inconst LABEL)
-
-=item B<if>(invar PMC, inconst LABEL)
-
-=item B<if>(invar STR, inconst LABEL)
-
-Check register $1. If true, branch by $2.
-
-=cut
-
-inline op if(invar INT, inconst LABEL) {
- if ($1 != 0)
- goto OFFSET($2);
-}
-
-inline op if(invar NUM, inconst LABEL) {
- if (!FLOAT_IS_ZERO($1))
- goto OFFSET($2);
-}
-
-op if (invar STR, inconst LABEL) {
- if (string_bool(interp, $1))
- goto OFFSET($2);
-}
-
-op if(invar PMC, inconst LABEL) {
- if (VTABLE_get_bool(interp, $1))
- goto OFFSET($2);
-}
-
-########################################
-
-=item B<unless>(invar INT, inconst LABEL)
-
-=item B<unless>(invar NUM, inconst LABEL)
-
-=item B<unless>(invar PMC, inconst LABEL)
-
-=item B<unless>(invar STR, inconst LABEL)
-
-Check register $1. If false, branch by $2.
-
-=cut
-
-inline op unless(invar INT, inconst LABEL) {
- if ($1 == 0)
- goto OFFSET($2);
-}
-
-inline op unless(invar NUM, inconst LABEL) {
- if (FLOAT_IS_ZERO($1))
- goto OFFSET($2);
-}
-
-op unless(invar STR, inconst LABEL) {
- if (!string_bool(interp, $1))
- goto OFFSET($2);
-}
-
-op unless(invar PMC, inconst LABEL) {
- if (!VTABLE_get_bool(interp, $1))
- goto OFFSET($2);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head2 Subroutine operations
-
-These operations are used to generate and call subroutines and
-continuations.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<invokecc>(invar PMC)
-
-Call the subroutine in $1 and generate a new return continuation, if needed.
-For example, a NCI subroutine which executes code in some C library will not
-create a continuation, nor will anything but the first call to a coroutine.
-
-=item B<invoke>(invar PMC, invar PMC)
-
-Call the subroutine in $1 and use continuation $2.
-
-=item B<yield>()
-
-Yield results from a coroutine.
-
-=item B<tailcall>(invar PMC)
-
-Call the subroutine in $1 and use the current continuation as the subs
-continuation.
-
-=item B<returncc>()
-
-Return from the sub or method via the current continuation.
-
-=item B<newclosure>(out PMC, invar PMC)
-
-Create a closure of the given subroutine PMC by cloning the sub's state.
-
-=cut
-
-inline op invokecc(invar PMC) :flow {
- PMC * const p = $1;
- opcode_t *dest = expr NEXT();
-
- interp->current_object = NULL;
- interp->current_cont = NEED_CONTINUATION;
- dest = (opcode_t *)p->vtable->invoke(interp, p, dest);
-
- goto ADDRESS(dest);
-}
-
-inline op invoke(invar PMC, invar PMC) :flow {
- opcode_t *dest;
- PMC * const p = $1;
-
- interp->current_object = NULL;
- interp->current_cont = $2;
- dest = (opcode_t *)p->vtable->invoke(interp, p, expr NEXT());
- goto ADDRESS(dest);
-}
-
-inline op yield() :flow {
- opcode_t *dest = expr NEXT();
- PMC * const p = CONTEXT(interp)->current_sub;
- dest = (opcode_t *)p->vtable->invoke(interp, p, dest);
- goto ADDRESS(dest);
-}
-
-inline op tailcall(invar PMC) :flow {
- opcode_t *dest;
- PMC * const p = $1;
- dest = expr NEXT();
- interp->current_cont = CONTEXT(interp)->current_cont;
- PObj_get_FLAGS(interp->current_cont) |= SUB_FLAG_TAILCALL;
- dest = (opcode_t *)p->vtable->invoke(interp, p, dest);
- goto ADDRESS(dest);
-}
-
-inline op returncc() :flow {
- PMC * const p = CONTEXT(interp)->current_cont;
- opcode_t * const dest = (opcode_t *)p->vtable->invoke(interp,
- p, expr NEXT());
- goto ADDRESS(dest);
-}
-
-inline op newclosure(out PMC, invar PMC) {
- $1 = parrot_new_closure(interp, $2);
-}
-
-=back
-
-=head2 Function argument opcode
-
-Implementations of function argument and params handling
-
-=over 4
-
-=item B<set_args>(inconst PMC /* , ... */)
-
-Define arguments for the next function call.
-
-=item B<get_results>(inconst PMC /* , ... */)
-
-Define return values for the next function call.
-
-=item B<get_params>(inconst PMC /* , ... */)
-
-Define function parameters for this subroutine.
-
-=item B<set_returns>(inconst PMC /* , ... */)
-
-Define return results for the subroutine return statement.
-
-For all of these opcodes the passed invar PMC constant is the string
-representation of a FixedIntegerArray with one flag word per argument.
-The flags are documented currently in F<include/parrot/enum.h> only.
-
-After this argument a variable amount of arguments must follow according
-to the elements of the signature array.
-
-=cut
-
-
-op set_args(inconst PMC) :flow {
- opcode_t * const _this = CUR_OPCODE;
- PMC * const signature = $1;
- INTVAL argc;
-
- /* for now just point to the opcode */
- interp->current_args = _this;
- argc = VTABLE_elements(interp, signature);
- goto OFFSET(argc + 2);
-}
-
-op get_results(inconst PMC) :flow {
- opcode_t * const _this = CUR_OPCODE;
- PMC * const signature = $1;
- INTVAL argc;
-
- CONTEXT(interp)->current_results = _this;
- argc = VTABLE_elements(interp, signature);
- goto OFFSET(argc + 2);
-}
-
-op get_params(inconst PMC) :flow {
- opcode_t * const _this = CUR_OPCODE;
- parrot_context_t *caller_ctx, *ctx;
- PMC * ccont;
- PMC * const signature = $1;
- INTVAL argc;
- opcode_t *src_indexes, *dst_indexes;
-
- interp->current_params = _this;
- ctx = CONTEXT(interp);
- ccont = ctx->current_cont;
-
- caller_ctx = ctx->caller_ctx;
-
- src_indexes = interp->current_args;
- dst_indexes = interp->current_params;
- /* the args and params are now 'used.' */
- interp->current_args = NULL;
- interp->current_params = NULL;
-
- parrot_pass_args(interp, caller_ctx, ctx, src_indexes, dst_indexes, PARROT_PASS_PARAMS);
- if (PObj_get_FLAGS(ccont) & SUB_FLAG_TAILCALL) {
- PObj_get_FLAGS(ccont) &= ~SUB_FLAG_TAILCALL;
- --ctx->recursion_depth;
- ctx->caller_ctx = caller_ctx->caller_ctx;
- /* ordinarily, this will free the context immediately, but not if the
- sub created a closure (or continuation, or . . .). */
- Parrot_free_context(interp, caller_ctx, 0);
- interp->current_args = NULL;
- }
- argc = VTABLE_elements(interp, signature);
- goto OFFSET(argc + 2);
-}
-
-op set_returns(inconst PMC) :flow {
- opcode_t * const _this = CUR_OPCODE;
- parrot_context_t *ctx;
- PMC *ccont;
- PMC *signature = $1;
- INTVAL argc;
- opcode_t *src_indexes, *dest_indexes;
-
- interp->current_returns = _this;
- ctx = CONTEXT(interp);
- ccont = ctx->current_cont;
-
- if (PMC_cont(ccont)->address) {
- /* else it's from runops_fromc */
- parrot_context_t * const caller_ctx = PMC_cont(ccont)->to_ctx;
- if (! caller_ctx) {
- /* there is no point calling real_exception here, because
- PDB_backtrace can't deal with a missing to_ctx either. */
- internal_exception(1, "No caller_ctx for continuation %p.", ccont);
- }
-
- src_indexes = interp->current_returns;
- dest_indexes = caller_ctx->current_results;
- interp->current_returns = NULL;
- /* does this need to be here */
- interp->current_args = NULL;
-
- parrot_pass_args(interp, ctx, caller_ctx, src_indexes, dest_indexes, PARROT_PASS_RESULTS);
- }
- argc = VTABLE_elements(interp, signature);
- goto OFFSET(argc + 2);
-}
-
-=item B<result_info>(out PMC)
-
-Returns the get_results signature PMC of the caller. This PMC is a
-FixedIntegerPMCArray. The number of elements of this PMC is equal to the number
-of return values that are expected. The individual bits per entry are
-specified in F<docs/pdds/pdd03_calling_conventions.pod>.
-
-=cut
-
-inline op result_info(out PMC) {
- /* Get context of callee from return continuation. */
- PMC * const cc = CONTEXT(interp)->current_cont;
- PMC *sig = NULL;
- if (cc && PMC_cont(cc)->to_ctx) {
- /* caller context has results */
- opcode_t * const results = PMC_cont(cc)->to_ctx->current_results;
- if (results) {
- /* get results PMC index and get PMC. */
- sig = PF_CONST(PMC_cont(cc)->seg, results[1])->u.key;
- }
- }
-
- /* If no elements, hand back empty array; otherwise PMC. */
- if (!sig)
- $1 = pmc_new(interp, enum_class_FixedIntegerArray);
- else
- $1 = sig;
-}
-
-=back
-
-=head2 Address manipulation
-
-=for clarity
-
-=cut
-
-=over 4
-
-=item B<set_addr>(out INT, inconst LABEL)
-
-Sets register $1 to the current address plus the offset $2.
-
-=item B<set_addr>(invar PMC, inconst LABEL)
-
-Sets PMC in register $1 to the current address plus the offset $2.
-
-=item B<set_addr>(invar PMC, invar LABEL)
-
-Sets PMC in register $1 to the absolute address $2 obtained from B<get_addr>.
-
-=item B<get_addr>(out INT, invar PMC)
-
-Sets $1 to the absolute address of the Sub PMC $2.
-
-=cut
-
-inline op set_addr(out INT, inconst LABEL) {
- $1 = PTR2OPCODE_T(CUR_OPCODE + $2);
-}
-
-inline op set_addr(invar PMC, inconst LABEL) {
- VTABLE_set_pointer(interp, $1, (CUR_OPCODE + $2));
-}
-
-inline op set_addr(invar PMC, invar LABEL) {
- VTABLE_set_pointer(interp, $1, (void*)$2);
-}
-
-inline op get_addr(out INT, invar PMC) {
- void *ptr = VTABLE_get_pointer(interp, $2);
- $1 = (INTVAL)ptr;
-}
-
-=back
-
-=cut
-
-########################################
-
-=head2 Concurrency operations
-
-=over 4
-
-=item B<schedule>(invar PMC)
-
-Register a task with the concurrency scheduler. Details about the task are
-stored within the task PMC.
-
-inline op schedule(invar PMC) {
- Parrot_cx_schedule_task(interp, $1);
-}
-
-=item B<addhandler>(invar PMC)
-
-Add an event or exception handler to the concurrency scheduler. Details about
-the handler are stored within the handler PMC.
-
-inline op addhandler(invar PMC) {
- Parrot_cx_add_handler(interp, $1);
-}
-
-=back
-
-=cut
-
-########################################
-
-=head2 Exception handling
-
-=over 4
-
-=item B<push_eh>(inconst LABEL)
-
-Create an exception handler for the given catch label and push it onto
-the exception handler stack.
-
-=item B<push_eh>(invar PMC)
-
-Push an invokable PMC onto the exception handler stack.
-
-=item B<pop_eh>()
-
-Pop the most recently placed exception off the handler stack.
-
-=item B<throw>(invar PMC)
-
-Throw the exception in $1.
-
-=item B<throwcc>(invar PMC)
-
-Throw the exception in $1 with current continuation. Identical to
-B<throw> in its one-argument form.
-
-=item B<throwcc>(invar PMC, invar PMC)
-
-Throw the exception in $1 with continuation from $2.
-
-=item B<rethrow>(invar PMC)
-
-Only valid inside an exception handler. Rethrow the exception $1.
-
-=item B<count_eh>(out INT)
-
-Get a count of currently active exception handlers on the stack.
-
-=item B<get_eh>(out PMC, in INT)
-
-Return the exception handler at I<index>. The index is an offset from the top
-of the stack, with '0' being the top.
-
-=item B<get_all_eh>(out PMC)
-
-Return an array of all current exception handlers.
-
-=item B<die>(in STR)
-=item B<die>(in PMC)
-
-Die with message $1
-
-=item B<die>(in INT, in INT)
-
-Die with severity $1 and error $2. If severity is .EXCEPT_DOOMED,
-call _exit($2). The latter isn't catchable.
-
-=item B<exit>(in INT)
-
-Exit the interpreter with exit_status $1. If you want to communicate an
-extended exit status, create an exception with severity B<EXCEPT_exit>
-and throw it.
-
-=item B<pushmark>(in INT)
-
-Push a mark labeled $1 onto the dynamic environment.
-
-=item B<popmark>(in INT)
-
-Pop all items off the dynamic environment to the given mark.
-
-=item B<pushaction>(invar PMC)
-
-Push the given Sub PMC $1 onto the dynamic environment. If the dynamic
-environment is unwound due to a C<popmark>, subroutine return, or an exception,
-the subroutine will be invoked with an integer argument: C<0> means a normal
-return; C<1> means an exception has been raised.
-
-=cut
-
-inline op push_eh(inconst LABEL) {
- PMC * const eh = pmc_new(interp, enum_class_Exception_Handler);
- VTABLE_set_pointer(interp, eh, CUR_OPCODE + $1);
- push_exception(interp, eh);
-}
-
-inline op push_eh(invar PMC) {
- push_exception(interp, $1);
-}
-
-inline op pop_eh() {
- pop_exception(interp);
-}
-
-inline op throw(invar PMC) :flow {
- opcode_t * const ret = expr NEXT();
- opcode_t * const dest = (opcode_t *)throw_exception(interp, $1, ret);
- goto ADDRESS(dest);
-}
-
-inline op throwcc(invar PMC) :flow {
- opcode_t * const ret = expr NEXT();
- opcode_t * const dest = (opcode_t *)throw_exception(interp, $1, ret);
- goto ADDRESS(dest);
-}
-
-inline op throwcc(invar PMC, invar PMC) :flow {
- opcode_t * const dest = (opcode_t *)throw_exception(interp, $1, $2);
- goto ADDRESS(dest);
-}
-
-inline op rethrow(invar PMC) :flow {
- opcode_t * const dest = (opcode_t *)rethrow_exception(interp, $1);
- goto ADDRESS(dest);
-}
-
-inline op count_eh(out INT) {
- $1 = count_exception_handlers(interp);
-}
-
-inline op get_eh(out PMC, in INT) {
- $1 = get_exception_handler(interp, $2);
-}
-
-inline op get_all_eh(out PMC) {
- $1 = get_all_exception_handlers(interp);
-}
-
-
-inline op die(in STR) :flow {
- do_str_exception(interp, $1);
-}
-
-inline op die(in PMC) :flow {
- do_pmc_exception(interp, $1);
-}
-
-inline op die(in INT, in INT) :flow {
- if ($1 == EXCEPT_doomed)
- _exit($2);
- do_exception(interp, $1, $2);
-}
-
-inline op exit(in INT) :flow {
- do_exception(interp, EXCEPT_exit, $1);
-}
-
-inline op pushmark(in INT) {
- Parrot_push_mark(interp, $1);
-}
-
-inline op popmark(in INT) {
- Parrot_pop_mark(interp, $1);
-}
-
-inline op pushaction(invar PMC) {
- Parrot_push_action(interp, $1);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head2 Interpreter operations
-
-These operations inspect or modify the interpreter itself, possibly
-affecting its subsequent operation.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<debug>(in INT)
-
-If $1 is zero, turn off debugging. Otherwise turn debug flag $1 on.
-
-=cut
-
-inline op debug(in INT) :flow {
- if ($1 != 0) { Interp_debug_SET(interp, $1); }
- else { Interp_debug_CLEAR(interp, PARROT_ALL_DEBUG_FLAGS); }
- restart NEXT();
-}
-
-
-########################################
-
-=item B<bounds>(in INT)
-
-If $1 is zero, turn off byte code bounds checking. Otherwise turn it on.
-
-=cut
-
-inline op bounds(in INT) :flow {
- if ($1 != 0) { Parrot_set_flag(interp, PARROT_BOUNDS_FLAG); }
- else { Interp_flags_CLEAR(interp, PARROT_BOUNDS_FLAG); }
- restart NEXT();
-}
-
-
-########################################
-
-=item B<profile>(in INT)
-
-If $1 is zero, turn off profiling. Otherwise turn it on.
-
-=cut
-
-inline op profile(in INT) :flow {
- if ($1 != 0) { Parrot_set_flag(interp, PARROT_PROFILE_FLAG); }
- else { Interp_flags_CLEAR(interp, PARROT_PROFILE_FLAG); }
- restart NEXT();
-}
-
-
-########################################
-
-=item B<trace>(in INT)
-
-If $1 is zero, turn off tracing. Otherwise turn trace flag $1 on.
-
-=cut
-
-inline op trace(in INT) :flow {
- if ($1 != 0) { Parrot_set_trace(interp, $1); }
- else { Parrot_clear_trace(interp, PARROT_ALL_TRACE_FLAGS); }
- restart NEXT();
-}
-
-########################################
-
-=item B<gc_debug>(in INT)
-
-If $1 is zero, turn off GC_DEBUG. Otherwise turn it on.
-
-=cut
-
-inline op gc_debug(in INT) {
- if ($1 != 0) { Interp_flags_SET(interp, PARROT_GC_DEBUG_FLAG); }
- else { Interp_flags_CLEAR(interp, PARROT_GC_DEBUG_FLAG); }
-}
-
-########################################
-
-=item B<interpinfo>
-
-Fetch some piece of information about the interpreter and put it in $1.
-Possible values for $2 are defined in F<runtime/parrot/include/interpinfo.pasm>.
-The valid constants for each return value are:
-
-=over 4
-
-=item B<interpinfo>(out INT, in INT)
-
-.TOTAL_MEM_ALLOC, .DOD_RUNS, .COLLECT_RUNS, .ACTIVE_PMCS, .ACTIVE_BUFFERS,
-.TOTAL_PMCS, .TOTAL_BUFFERS, .HEADER_ALLOCS_SINCE_COLLECT,
-.MEM_ALLOCS_SINCE_COLLECT, .TOTAL_COPIED, .IMPATIENT_PMCS, .LAZY_DOD_RUNS,
-.EXTENDED_PMCS, .RUNCORE
-
-=item B<interpinfo>(out PMC, in INT)
-
-.CURRENT_SUB, .CURRENT_CONT, .CURRENT_OBJECT, .CURRENT_LEXPAD
-
-=item B<interpinfo>(out STR, in INT)
-
-.EXECUTABLE_FULLNAME, .EXECUTABLE_BASENAME, .RUNTIME_PREFIX
-
-=back
-
-=cut
-
-op interpinfo(out INT, in INT) {
- $1 = interpinfo(interp, $2);
-}
-
-op interpinfo(out PMC, in INT) {
- $1 = interpinfo_p(interp, $2);
-}
-
-op interpinfo(out STR, in INT) {
- $1 = interpinfo_s(interp, $2);
-}
-
-=item B<warningson>(in INT)
-
-Turns on warnings categories. Categories already turned on will stay on.
-Initial setting is currently all warnings off. Include F<warnings.pasm> to
-access the categories. They are:
-
-=over 4
-
-=item .PARROT_WARNINGS_UNDEF_FLAG
-
-=item .PARROT_WARNINGS_IO_FLAG
-
-=item .PARROT_WARNINGS_PLATFORM_FLAG
-
-=item .PARROT_WARNINGS_ALL_FLAG
-
-=back
-
-To turn on multiple categories, OR the category numbers together.
-
-=cut
-
-inline op warningson(in INT) {
- PARROT_WARNINGS_on(interp, $1);
-}
-
-=item B<warningsoff>(in INT)
-
-Turns off warnings categories. Categories already turned off will
-stay off. See the documentation for B<warningson> for category
-numbers.
-
-=cut
-
-inline op warningsoff(in INT) {
- PARROT_WARNINGS_off(interp, $1);
-}
-
-=item B<errorson>(in INT)
-
-Turns on error categories. Categories already turned on will stay on. To
-access these from PASM, include F<errors.pasm>. The current categories are:
-
-=over 4
-
-=item .PARROT_ERRORS_GLOBALS_FLAG
-
-Throw an exception if global doesn't exist. Default: on.
-
-=item .PARROT_ERRORS_OVERFLOW_FLAG
-
-Throw math overflow instead of promoting to BigInt. Default: off.
-
-=item .PARROT_ERRORS_PARAM_COUNT_FLAG
-
-Throw exception on argument <-> param count mismatch. Default: off.
-
-=item .PARROT_ERRORS_RESULT_COUNT_FLAG
-
-Throw exception on return <-> result count mismatch. Default: off.
-
-=item .PARROT_ERRORS_ALL_FLAG
-
-=back
-
-To turn on multiple categories, OR the category numbers together.
-
-=cut
-
-inline op errorson(in INT) {
- PARROT_ERRORS_on(interp, $1);
-}
-
-=item B<errorsoff>(in INT)
-
-Turns off errors categories. Categories already turned off will
-stay off. See the documentation for B<errorson> for category
-numbers.
-
-=cut
-
-inline op errorsoff(in INT) {
- PARROT_ERRORS_off(interp, $1);
-}
-
-########################################
-
-=item B<runinterp>(invar PMC, in LABEL)
-
-Run the code starting at offset $2 within interpreter $1.
-
-=item B<getinterp>(out PMC)
-
-Get the current ParrotInterpreter.
-
-=cut
-
-op runinterp(invar PMC, in LABEL) {
- Interp * const new_interp = (Interp *)PMC_data($1);
- Interp_flags_SET(new_interp, PARROT_EXTERN_CODE_FLAG);
- new_interp->code = interp->code;
- runops(new_interp, REL_PC + $2);
-}
-
-op getinterp(out PMC) {
- $1 = VTABLE_get_pmc_keyed_int(interp, interp->iglobals,
- IGLOBALS_INTERPRETER);
-}
-
-#######################################
-
-
-
-=back
-
-=cut
-
-###############################################################################
-
-=head2 Dead Object Detection/Garbage Collection
-
-Opcodes that interact with the DOD and GC subsystems.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<sweep>(inconst INT)
-
-Triggers a DOD run, based on the value of $1, where:
-
-=over
-
-=item * 0
-
-Trigger a DOD run only if there are things that have flagged themselves as
-really needing to be collected.
-
-=item * 1
-
-Trigger a dead object detection (DOD) sweep unconditionally.
-
-=back
-
-=cut
-
-op sweep(inconst INT) {
- if ($1)
- Parrot_do_dod_run(interp, 0);
- else
- if (interp->mem_pools->num_early_DOD_PMCs)
- Parrot_do_dod_run(interp, GC_lazy_FLAG);
-}
-
-=item B<collect>()
-
-Trigger a garbage collection.
-
-=cut
-
-op collect() {
- Parrot_go_collect(interp);
-}
-
-=item B<sweepoff>()
-
-Disable DOD sweeps. (Nestable)
-
-=cut
-
-op sweepoff() {
- Parrot_block_GC_mark(interp);
-}
-
-=item B<sweepon>()
-
-Re-enable DOD sweeps.
-
-=cut
-
-op sweepon() {
- Parrot_unblock_GC_mark(interp);
-}
-
-=item B<collectoff>()
-
-Disable GC runs (nestable).
-
-=cut
-
-op collectoff() {
- Parrot_block_GC_sweep(interp);
-}
-
-=item B<collecton>()
-
-Re-enable GC.
-
-=cut
-
-op collecton() {
- Parrot_unblock_GC_sweep(interp);
-}
-
-=item B<needs_destroy>(invar PMC)
-
-Mark the PMC wanting destruction as soon as possible, for example
-when unused during the lazy sweep, triggered by C<sweep 0>.
-
-=cut
-
-op needs_destroy(invar PMC) {
- PObj_needs_early_DOD_SET($1);
- ++interp->mem_pools->num_early_DOD_PMCs;
-}
-
-=back
-
-=head2 Native Call Interface
-
-Opcodes for interfacing with C functions in shared libraries.
-
-=over 4
-
-=cut
-
-########################################
-
-=item B<loadlib>(out PMC, in STR)
-
-Load a dynamic link library named $2 and store it in $1.
-
-=item B<dlfunc>(out PMC, invar PMC, in STR, in STR)
-
-Look up symbol $3 in library $2 with signature $4, and put the
-corresponding sub object in $1. Note that you need the signature so we
-can build or find an appropriate thunking function.
-
-=item B<dlvar>(out PMC, invar PMC, in STR)
-
-Look up symbol $3 in library $2. We assume that this is actually a
-variable address rather than a function address, and build an
-UnManagedStruct PMC and stick the address into its data pointer.
-
-=item B<compreg>(out PMC, in STR)
-
-Get the compiler object for source type $2. The returned compiler
-object should provide a C<compile> method for translating code
-in the source type. However, some Parrot compilers such as
-C<PIR> and C<PASM> currently return a sub that is to be
-invoked directly on the source.
-
-=item B<compreg>(in STR, invar PMC)
-
-Register $2 as the compiler object for source type $1.
-
-=item B<new_callback>(out PMC, invar PMC, invar PMC, in STR)
-
-Create a callback stub $1 for PASM subroutine $2 with userdata $3 and
-callback function signature $4. Only 2 argument signatures with
-signature chars I<U[1iscpt]> or I<[1iscpt]U> are handled currently.
-But these cover a lot of callback signatures. Please note that the
-userdata PMC I<U> has to be handled transparently by the caller of
-the callback function.
-
-=cut
-
-inline op loadlib(out PMC, in STR) {
- $1 = Parrot_load_lib(interp, $2, NULL);
-}
-
-op dlfunc(out PMC, invar PMC, in STR, in STR) {
- char * const name = string_to_cstring(interp, ($3));
- void *ptr = Parrot_dlsym(
- PMC_IS_NULL($2) ? NULL :
- VTABLE_defined(interp, $2) ? PMC_data($2) :
- NULL,
- name);
-
- funcptr_t p = D2FPTR(ptr);
-
- if (p == NULLfunc) {
- const char * err = Parrot_dlerror();
- Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
- "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
- $1 = pmc_new(interp, enum_class_Undef);
- }
- else {
- $1 = pmc_new(interp, enum_class_NCI);
- VTABLE_set_pointer_keyed_str(interp, $1, $4, F2DPTR(p));
- PObj_get_FLAGS($1) |= PObj_private1_FLAG;
- }
- Parrot_str_free_cstring(name);
-}
-
-op dlvar(out PMC, invar PMC, in STR) {
- char * const name = string_to_cstring(interp, ($3));
- void * const p = Parrot_dlsym(PMC_IS_NULL($2) ? NULL : PMC_data($2), name);
- Parrot_str_free_cstring(name);
- if (p == NULL) {
- const char * const err = Parrot_dlerror();
- Parrot_warn(interp, PARROT_WARNINGS_UNDEF_FLAG,
- "Symbol '%s' not found: %s\n", name, err ? err : "unknown reason");
- $1 = pmc_new(interp, enum_class_Undef);
- }
- else {
- /* At this point we have the symbol's address. We just need to build
- a PMC with it so we can get and set the value */
- $1 = pmc_new(interp, enum_class_UnManagedStruct);
- PMC_data($1) = p;
- }
-}
-
-inline op compreg(in STR, invar PMC) {
- PMC * const compreg_hash = VTABLE_get_pmc_keyed_int(interp,
- interp->iglobals, IGLOBALS_COMPREG_HASH);
- VTABLE_set_pmc_keyed_str(interp, compreg_hash, $1, $2);
-}
-
-inline op compreg(out PMC, in STR) {
- PMC * const compreg_hash = VTABLE_get_pmc_keyed_int(interp,
- interp->iglobals, IGLOBALS_COMPREG_HASH);
- $1 = VTABLE_get_pmc_keyed_str(interp, compreg_hash, $2);
-}
-
-op new_callback(out PMC, invar PMC, invar PMC, in STR) {
- $1 = Parrot_make_cb(interp, $2, $3, $4);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head1 COPYRIGHT
-
-Copyright (C) 2001-2008, Parrot Foundation.
-
-=head1 LICENSE
-
-This program is free software. It is subject to the same license
-as the Parrot interpreter itself.
-
-=cut
-
-/*
- * Local variables:
- * c-file-style: "parrot"
- * End:
- * vim: expandtab shiftwidth=4:
- */
Deleted: trunk/t/tools/ops2pm/samples/ops_num.original
==============================================================================
--- trunk/t/tools/ops2pm/samples/ops_num.original Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,1223 +0,0 @@
-# This file provides opcode name->number mapping, so we can nail down
-# the op numbers for the core opcodes and provide
-# backward-compatibility for bytecode.
-#
-# The format of this file is simple:
-#
-# opcode_name (whitespace) opcode_number
-#
-# The opcode name is the full and complete name of the
-# opcode--i.e. for the "add N1, N2, N3" op the name is add_n_n_n, not
-# add.
-#
-# once an opcode is added to this file it should never be
-# removed. Opcodes that are in here but that have no corresponding
-# function backing them (because, for example, they've been deleted,
-# which shouldn't ever happen once we hit production) should be mapped
-# by the ops processing programs to an exception op
-#
-# The numbering of opcodes whose names are *not* in this file begins
-# immediately after the highest-numbered opcode in this file,
-# regardless of what order it is found in. There should be *no* holes
-# in the numbering!
-
-# Please note that only opcodes from experimental.ops are included
-# in the core.pm, if they are missing here.
-
-# Note that end must always be op 0.
-end 0
-# the following ops are enums in oplib.h
-noop 1
-cpu_ret 2
-check_events 3
-check_events__ 4
-wrapper__ 5
-prederef__ 6
-reserved_ic 7
-###DYNAMIC### other ops
-load_bytecode_s 8
-load_bytecode_sc 9
-branch_i 10
-branch_ic 11
-branch_cs_s 12
-branch_cs_sc 13
-bsr_i 14
-bsr_ic 15
-ret 16
-jsr_i 17
-jsr_ic 18
-jump_i 19
-jump_ic 20
-enternative 21
-if_i_ic 22
-if_n_ic 23
-if_s_ic 24
-if_p_ic 25
-unless_i_ic 26
-unless_n_ic 27
-unless_s_ic 28
-unless_p_ic 29
-invokecc_p 30
-invoke_p_p 31
-yield 32
-tailcall_p 33
-returncc 34
-newclosure_p_p 35
-set_args_pc 36
-get_results_pc 37
-get_params_pc 38
-set_returns_pc 39
-result_info_p 40
-set_addr_i_ic 41
-set_addr_p_ic 42
-set_addr_p_i 43
-get_addr_i_p 44
-schedule_p 45
-addhandler_p 46
-push_eh_ic 47
-push_eh_p 48
-pop_eh 49
-throw_p 50
-rethrow_p 51
-count_eh_i 52
-get_eh_p_i 53
-get_eh_p_ic 54
-get_all_eh_p 55
-die_s 56
-die_sc 57
-die_p 58
-die_pc 59
-die_i_i 60
-die_ic_i 61
-die_i_ic 62
-die_ic_ic 63
-exit_i 64
-exit_ic 65
-pushmark_i 66
-pushmark_ic 67
-popmark_i 68
-popmark_ic 69
-pushaction_p 70
-debug_i 71
-debug_ic 72
-bounds_i 73
-bounds_ic 74
-profile_i 75
-profile_ic 76
-trace_i 77
-trace_ic 78
-gc_debug_i 79
-gc_debug_ic 80
-interpinfo_i_i 81
-interpinfo_i_ic 82
-interpinfo_p_i 83
-interpinfo_p_ic 84
-interpinfo_s_i 85
-interpinfo_s_ic 86
-warningson_i 87
-warningson_ic 88
-warningsoff_i 89
-warningsoff_ic 90
-errorson_i 91
-errorson_ic 92
-errorsoff_i 93
-errorsoff_ic 94
-runinterp_p_i 95
-runinterp_p_ic 96
-getinterp_p 97
-sweep_ic 98
-collect 99
-sweepoff 100
-sweepon 101
-collectoff 102
-collecton 103
-needs_destroy_p 104
-loadlib_p_s 105
-loadlib_p_sc 106
-dlfunc_p_p_s_s 107
-dlfunc_p_p_sc_s 108
-dlfunc_p_p_s_sc 109
-dlfunc_p_p_sc_sc 110
-dlvar_p_p_s 111
-dlvar_p_p_sc 112
-compreg_s_p 113
-compreg_sc_p 114
-compreg_p_s 115
-compreg_p_sc 116
-new_callback_p_p_p_s 117
-new_callback_p_p_p_sc 118
-band_i_i 119
-band_i_ic 120
-band_i_i_i 121
-band_i_ic_i 122
-band_i_i_ic 123
-bands_s_s 124
-bands_s_sc 125
-bands_s_s_s 126
-bands_s_sc_s 127
-bands_s_s_sc 128
-bnot_i 129
-bnot_i_i 130
-bnot_p 131
-bnot_p_p 132
-n_bnot_p_p 133
-bnots_s 134
-bnots_s_s 135
-bnots_s_sc 136
-bnots_p 137
-bnots_p_p 138
-n_bnots_p_p 139
-bor_i_i 140
-bor_i_ic 141
-bor_i_i_i 142
-bor_i_ic_i 143
-bor_i_i_ic 144
-bors_s_s 145
-bors_s_sc 146
-bors_s_s_s 147
-bors_s_sc_s 148
-bors_s_s_sc 149
-shl_i_i 150
-shl_i_ic 151
-shl_i_i_i 152
-shl_i_ic_i 153
-shl_i_i_ic 154
-shr_i_i 155
-shr_i_ic 156
-shr_i_i_i 157
-shr_i_ic_i 158
-shr_i_i_ic 159
-lsr_i_i 160
-lsr_i_ic 161
-lsr_i_i_i 162
-lsr_i_ic_i 163
-lsr_i_i_ic 164
-rot_i_i_i_ic 165
-rot_i_ic_i_ic 166
-rot_i_i_ic_ic 167
-bxor_i_i 168
-bxor_i_ic 169
-bxor_i_i_i 170
-bxor_i_ic_i 171
-bxor_i_i_ic 172
-bxors_s_s 173
-bxors_s_sc 174
-bxors_s_s_s 175
-bxors_s_sc_s 176
-bxors_s_s_sc 177
-eq_i_i_ic 178
-eq_ic_i_ic 179
-eq_i_ic_ic 180
-eq_n_n_ic 181
-eq_nc_n_ic 182
-eq_n_nc_ic 183
-eq_s_s_ic 184
-eq_sc_s_ic 185
-eq_s_sc_ic 186
-eq_p_p_ic 187
-eq_p_i_ic 188
-eq_p_ic_ic 189
-eq_p_n_ic 190
-eq_p_nc_ic 191
-eq_p_s_ic 192
-eq_p_sc_ic 193
-eq_str_p_p_ic 194
-eq_num_p_p_ic 195
-eq_addr_s_s_ic 196
-eq_addr_sc_s_ic 197
-eq_addr_s_sc_ic 198
-eq_addr_sc_sc_ic 199
-eq_addr_p_p_ic 200
-ne_i_i_ic 201
-ne_ic_i_ic 202
-ne_i_ic_ic 203
-ne_n_n_ic 204
-ne_nc_n_ic 205
-ne_n_nc_ic 206
-ne_s_s_ic 207
-ne_sc_s_ic 208
-ne_s_sc_ic 209
-ne_p_p_ic 210
-ne_p_i_ic 211
-ne_p_ic_ic 212
-ne_p_n_ic 213
-ne_p_nc_ic 214
-ne_p_s_ic 215
-ne_p_sc_ic 216
-ne_str_p_p_ic 217
-ne_num_p_p_ic 218
-ne_addr_s_s_ic 219
-ne_addr_sc_s_ic 220
-ne_addr_s_sc_ic 221
-ne_addr_sc_sc_ic 222
-ne_addr_p_p_ic 223
-lt_i_i_ic 224
-lt_ic_i_ic 225
-lt_i_ic_ic 226
-lt_n_n_ic 227
-lt_nc_n_ic 228
-lt_n_nc_ic 229
-lt_s_s_ic 230
-lt_sc_s_ic 231
-lt_s_sc_ic 232
-lt_p_p_ic 233
-lt_p_i_ic 234
-lt_p_ic_ic 235
-lt_p_n_ic 236
-lt_p_nc_ic 237
-lt_p_s_ic 238
-lt_p_sc_ic 239
-lt_str_p_p_ic 240
-lt_num_p_p_ic 241
-le_i_i_ic 242
-le_ic_i_ic 243
-le_i_ic_ic 244
-le_n_n_ic 245
-le_nc_n_ic 246
-le_n_nc_ic 247
-le_s_s_ic 248
-le_sc_s_ic 249
-le_s_sc_ic 250
-le_p_p_ic 251
-le_p_i_ic 252
-le_p_ic_ic 253
-le_p_n_ic 254
-le_p_nc_ic 255
-le_p_s_ic 256
-le_p_sc_ic 257
-le_str_p_p_ic 258
-le_num_p_p_ic 259
-gt_p_p_ic 260
-gt_p_i_ic 261
-gt_p_ic_ic 262
-gt_p_n_ic 263
-gt_p_nc_ic 264
-gt_p_s_ic 265
-gt_p_sc_ic 266
-gt_str_p_p_ic 267
-gt_num_p_p_ic 268
-ge_p_p_ic 269
-ge_p_i_ic 270
-ge_p_ic_ic 271
-ge_p_n_ic 272
-ge_p_nc_ic 273
-ge_p_s_ic 274
-ge_p_sc_ic 275
-ge_str_p_p_ic 276
-ge_num_p_p_ic 277
-if_null_p_ic 278
-if_null_s_ic 279
-unless_null_p_ic 280
-unless_null_s_ic 281
-cmp_i_i_i 282
-cmp_i_ic_i 283
-cmp_i_i_ic 284
-cmp_i_n_n 285
-cmp_i_nc_n 286
-cmp_i_n_nc 287
-cmp_i_s_s 288
-cmp_i_sc_s 289
-cmp_i_s_sc 290
-cmp_i_p_p 291
-cmp_i_p_i 292
-cmp_i_p_ic 293
-cmp_i_p_n 294
-cmp_i_p_nc 295
-cmp_i_p_s 296
-cmp_i_p_sc 297
-cmp_str_i_p_p 298
-cmp_num_i_p_p 299
-issame_i_p_p 300
-issame_i_s_s 301
-issame_i_sc_s 302
-issame_i_s_sc 303
-issame_i_sc_sc 304
-isntsame_i_p_p 305
-isntsame_i_s_s 306
-isntsame_i_sc_s 307
-isntsame_i_s_sc 308
-isntsame_i_sc_sc 309
-istrue_i_p 310
-isfalse_i_p 311
-isnull_i_p 312
-isnull_i_pc 313
-isgt_i_p_p 314
-isge_i_p_p 315
-isle_i_i_i 316
-isle_i_ic_i 317
-isle_i_i_ic 318
-isle_i_n_n 319
-isle_i_nc_n 320
-isle_i_n_nc 321
-isle_i_s_s 322
-isle_i_sc_s 323
-isle_i_s_sc 324
-isle_i_p_p 325
-islt_i_i_i 326
-islt_i_ic_i 327
-islt_i_i_ic 328
-islt_i_n_n 329
-islt_i_nc_n 330
-islt_i_n_nc 331
-islt_i_s_s 332
-islt_i_sc_s 333
-islt_i_s_sc 334
-islt_i_p_p 335
-iseq_i_i_i 336
-iseq_i_ic_i 337
-iseq_i_i_ic 338
-iseq_i_n_n 339
-iseq_i_nc_n 340
-iseq_i_n_nc 341
-iseq_i_s_s 342
-iseq_i_sc_s 343
-iseq_i_s_sc 344
-iseq_i_p_p 345
-isne_i_i_i 346
-isne_i_ic_i 347
-isne_i_i_ic 348
-isne_i_n_n 349
-isne_i_nc_n 350
-isne_i_n_nc 351
-isne_i_s_s 352
-isne_i_sc_s 353
-isne_i_s_sc 354
-isne_i_p_p 355
-and_i_i_i 356
-and_i_ic_i 357
-and_i_i_ic 358
-not_i 359
-not_i_i 360
-not_p 361
-not_p_p 362
-n_not_p_p 363
-or_i_i_i 364
-or_i_ic_i 365
-or_i_i_ic 366
-xor_i_i_i 367
-xor_i_ic_i 368
-xor_i_i_ic 369
-debug_init 370
-debug_load_sc 371
-debug_break 372
-debug_print 373
-backtrace 374
-getline_i 375
-getfile_s 376
-close_p 377
-fdopen_p_i_s 378
-fdopen_p_ic_s 379
-fdopen_p_i_sc 380
-fdopen_p_ic_sc 381
-getfd_i_p 382
-getstdin_p 383
-getstdout_p 384
-getstderr_p 385
-pioctl_i_p_i_i 386
-pioctl_i_p_ic_i 387
-pioctl_i_p_i_ic 388
-pioctl_i_p_ic_ic 389
-open_p_s_s 390
-open_p_sc_s 391
-open_p_s_sc 392
-open_p_sc_sc 393
-open_p_s 394
-open_p_sc 395
-print_i 396
-print_ic 397
-print_n 398
-print_nc 399
-print_s 400
-print_sc 401
-print_p 402
-printerr_i 403
-printerr_ic 404
-printerr_n 405
-printerr_nc 406
-printerr_s 407
-printerr_sc 408
-printerr_p 409
-print_p_i 410
-print_p_ic 411
-print_p_n 412
-print_p_nc 413
-print_p_s 414
-print_p_sc 415
-print_p_p 416
-read_s_i 417
-read_s_ic 418
-read_s_p_i 419
-read_s_p_ic 420
-readline_s_p 421
-peek_s 422
-peek_s_p 423
-stat_i_s_i 424
-stat_i_sc_i 425
-stat_i_s_ic 426
-stat_i_sc_ic 427
-stat_i_i_i 428
-stat_i_ic_i 429
-stat_i_i_ic 430
-stat_i_ic_ic 431
-seek_p_i_i 432
-seek_p_ic_i 433
-seek_p_i_ic 434
-seek_p_ic_ic 435
-seek_p_i_i_i 436
-seek_p_ic_i_i 437
-seek_p_i_ic_i 438
-seek_p_ic_ic_i 439
-seek_p_i_i_ic 440
-seek_p_ic_i_ic 441
-seek_p_i_ic_ic 442
-seek_p_ic_ic_ic 443
-tell_i_p 444
-tell_i_i_p 445
-socket_p_i_i_i 446
-socket_p_ic_i_i 447
-socket_p_i_ic_i 448
-socket_p_ic_ic_i 449
-socket_p_i_i_ic 450
-socket_p_ic_i_ic 451
-socket_p_i_ic_ic 452
-socket_p_ic_ic_ic 453
-sockaddr_s_i_s 454
-sockaddr_s_ic_s 455
-sockaddr_s_i_sc 456
-sockaddr_s_ic_sc 457
-connect_i_p_s 458
-connect_i_p_sc 459
-recv_i_p_s 460
-send_i_p_s 461
-send_i_p_sc 462
-poll_i_p_i_i_i 463
-poll_i_p_ic_i_i 464
-poll_i_p_i_ic_i 465
-poll_i_p_ic_ic_i 466
-poll_i_p_i_i_ic 467
-poll_i_p_ic_i_ic 468
-poll_i_p_i_ic_ic 469
-poll_i_p_ic_ic_ic 470
-bind_i_p_s 471
-bind_i_p_sc 472
-listen_i_p_i 473
-listen_i_p_ic 474
-accept_p_p 475
-infix_ic_p_i 476
-infix_ic_p_ic 477
-infix_ic_p_n 478
-infix_ic_p_nc 479
-infix_ic_p_s 480
-infix_ic_p_sc 481
-infix_ic_p_p 482
-infix_ic_p_p_i 483
-infix_ic_p_p_ic 484
-infix_ic_p_p_n 485
-infix_ic_p_p_nc 486
-infix_ic_p_p_s 487
-infix_ic_p_p_sc 488
-infix_ic_p_p_p 489
-n_infix_ic_p_p_i 490
-n_infix_ic_p_p_ic 491
-n_infix_ic_p_p_n 492
-n_infix_ic_p_p_nc 493
-n_infix_ic_p_p_s 494
-n_infix_ic_p_p_sc 495
-n_infix_ic_p_p_p 496
-abs_i 497
-abs_n 498
-abs_i_i 499
-abs_n_n 500
-abs_p 501
-abs_p_p 502
-n_abs_p_p 503
-add_i_i 504
-add_i_ic 505
-add_n_n 506
-add_n_nc 507
-add_i_i_i 508
-add_i_ic_i 509
-add_i_i_ic 510
-add_n_n_n 511
-add_n_nc_n 512
-add_n_n_nc 513
-cmod_i_i_i 514
-cmod_i_ic_i 515
-cmod_i_i_ic 516
-cmod_n_n_n 517
-cmod_n_nc_n 518
-cmod_n_n_nc 519
-dec_i 520
-dec_n 521
-dec_p 522
-div_i_i 523
-div_i_ic 524
-div_n_n 525
-div_n_nc 526
-div_i_i_i 527
-div_i_ic_i 528
-div_i_i_ic 529
-div_i_ic_ic 530
-div_n_n_n 531
-div_n_nc_n 532
-div_n_n_nc 533
-div_n_nc_nc 534
-fdiv_i_i 535
-fdiv_i_ic 536
-fdiv_n_n 537
-fdiv_n_nc 538
-fdiv_i_i_i 539
-fdiv_i_ic_i 540
-fdiv_i_i_ic 541
-fdiv_n_n_n 542
-fdiv_n_nc_n 543
-fdiv_n_n_nc 544
-ceil_n 545
-ceil_i_n 546
-ceil_n_n 547
-floor_n 548
-floor_i_n 549
-floor_n_n 550
-inc_i 551
-inc_n 552
-inc_p 553
-mod_i_i 554
-mod_i_ic 555
-mod_i_i_i 556
-mod_i_ic_i 557
-mod_i_i_ic 558
-mod_n_n_n 559
-mod_n_nc_n 560
-mod_n_n_nc 561
-mod_n_n 562
-mod_n_nc 563
-mul_i_i 564
-mul_i_ic 565
-mul_n_n 566
-mul_n_nc 567
-mul_i_i_i 568
-mul_i_ic_i 569
-mul_i_i_ic 570
-mul_n_n_n 571
-mul_n_nc_n 572
-mul_n_n_nc 573
-neg_i 574
-neg_n 575
-neg_p 576
-neg_i_i 577
-neg_n_n 578
-neg_p_p 579
-n_neg_p_p 580
-pow_n_n_n 581
-pow_n_nc_n 582
-pow_n_n_nc 583
-sub_i_i 584
-sub_i_ic 585
-sub_n_n 586
-sub_n_nc 587
-sub_i_i_i 588
-sub_i_ic_i 589
-sub_i_i_ic 590
-sub_n_n_n 591
-sub_n_nc_n 592
-sub_n_n_nc 593
-sqrt_n_n 594
-acos_n_n 595
-asec_n_n 596
-asin_n_n 597
-atan_n_n 598
-atan_n_n_n 599
-atan_n_nc_n 600
-atan_n_n_nc 601
-cos_n_n 602
-cosh_n_n 603
-exp_n_n 604
-ln_n_n 605
-log10_n_n 606
-log2_n_n 607
-sec_n_n 608
-sech_n_n 609
-sin_n_n 610
-sinh_n_n 611
-tan_n_n 612
-tanh_n_n 613
-gcd_i_i_i 614
-gcd_i_ic_i 615
-gcd_i_i_ic 616
-lcm_i_i_i 617
-lcm_i_ic_i 618
-lcm_i_i_ic 619
-fact_i_i 620
-fact_n_i 621
-callmethodcc_p_s 622
-callmethodcc_p_sc 623
-callmethodcc_p_p 624
-callmethod_p_s_p 625
-callmethod_p_sc_p 626
-callmethod_p_p_p 627
-tailcallmethod_p_s 628
-tailcallmethod_p_sc 629
-tailcallmethod_p_p 630
-addmethod_p_s_p 631
-addmethod_p_sc_p 632
-can_i_p_s 633
-can_i_p_sc 634
-does_i_p_s 635
-does_i_p_sc 636
-does_i_p_p 637
-does_i_p_pc 638
-isa_i_p_s 639
-isa_i_p_sc 640
-isa_i_p_p 641
-isa_i_p_pc 642
-newclass_p_s 643
-newclass_p_sc 644
-newclass_p_p 645
-newclass_p_pc 646
-subclass_p_p 647
-subclass_p_pc 648
-subclass_p_p_s 649
-subclass_p_pc_s 650
-subclass_p_p_sc 651
-subclass_p_pc_sc 652
-subclass_p_p_p 653
-subclass_p_pc_p 654
-subclass_p_p_pc 655
-subclass_p_pc_pc 656
-subclass_p_s 657
-subclass_p_sc 658
-subclass_p_s_s 659
-subclass_p_sc_s 660
-subclass_p_s_sc 661
-subclass_p_sc_sc 662
-subclass_p_s_p 663
-subclass_p_sc_p 664
-subclass_p_s_pc 665
-subclass_p_sc_pc 666
-getclass_p_s 667
-getclass_p_sc 668
-getclass_p_p 669
-getclass_p_pc 670
-get_class_p_s 671
-get_class_p_sc 672
-get_class_p_p 673
-get_class_p_pc 674
-class_p_p 675
-addparent_p_p 676
-removeparent_p_p 677
-addrole_p_p 678
-addattribute_p_s 679
-addattribute_p_sc 680
-removeattribute_p_s 681
-removeattribute_p_sc 682
-removeattribute_p_i 683
-removeattribute_p_ic 684
-getattribute_p_p_s 685
-getattribute_p_p_sc 686
-getattribute_p_p_p_s 687
-getattribute_p_p_pc_s 688
-getattribute_p_p_p_sc 689
-getattribute_p_p_pc_sc 690
-setattribute_p_s_p 691
-setattribute_p_sc_p 692
-setattribute_p_p_s_p 693
-setattribute_p_pc_s_p 694
-setattribute_p_p_sc_p 695
-setattribute_p_pc_sc_p 696
-inspect_p_p 697
-inspect_p_pc 698
-inspect_p_p_s 699
-inspect_p_pc_s 700
-inspect_p_p_sc 701
-inspect_p_pc_sc 702
-pic_infix___ic_p_p 703
-pic_inline_sub___ic_p_p 704
-pic_get_params___pc 705
-pic_set_returns___pc 706
-pic_callr___pc 707
-new_p_i 708
-new_p_ic 709
-new_p_i_p 710
-new_p_ic_p 711
-new_p_i_pc 712
-new_p_ic_pc 713
-new_p_s 714
-new_p_sc 715
-new_p_s_p 716
-new_p_sc_p 717
-new_p_s_pc 718
-new_p_sc_pc 719
-new_p_p 720
-new_p_pc 721
-new_p_p_p 722
-new_p_pc_p 723
-new_p_p_pc 724
-new_p_pc_pc 725
-typeof_s_p 726
-typeof_p_p 727
-typeof_i_p 728
-typeof_i_p_k 729
-typeof_i_p_kc 730
-typeof_i_p_ki 731
-typeof_i_p_kic 732
-typeof_s_i 733
-typeof_s_ic 734
-find_type_i_s 735
-find_type_i_sc 736
-find_type_i_p 737
-find_type_i_pc 738
-valid_type_i_i 739
-valid_type_i_ic 740
-get_repr_s_p 741
-find_method_p_p_s 742
-find_method_p_p_sc 743
-defined_i_p 744
-defined_i_p_ki 745
-defined_i_p_kic 746
-defined_i_p_k 747
-defined_i_p_kc 748
-exists_i_p_ki 749
-exists_i_p_kic 750
-exists_i_p_k 751
-exists_i_p_kc 752
-delete_p_k 753
-delete_p_kc 754
-delete_p_ki 755
-delete_p_kic 756
-elements_i_p 757
-push_p_i 758
-push_p_ic 759
-push_p_n 760
-push_p_nc 761
-push_p_s 762
-push_p_sc 763
-push_p_p 764
-pop_i_p 765
-pop_n_p 766
-pop_s_p 767
-pop_p_p 768
-unshift_p_i 769
-unshift_p_ic 770
-unshift_p_n 771
-unshift_p_nc 772
-unshift_p_s 773
-unshift_p_sc 774
-unshift_p_p 775
-shift_i_p 776
-shift_n_p 777
-shift_s_p 778
-shift_p_p 779
-setprop_p_s_p 780
-setprop_p_sc_p 781
-getprop_p_s_p 782
-getprop_p_sc_p 783
-delprop_p_s 784
-delprop_p_sc 785
-prophash_p_p 786
-freeze_s_p 787
-thaw_p_s 788
-thaw_p_sc 789
-mmdvtregister_i_i_i_p 790
-mmdvtregister_ic_i_i_p 791
-mmdvtregister_i_ic_i_p 792
-mmdvtregister_ic_ic_i_p 793
-mmdvtregister_i_i_ic_p 794
-mmdvtregister_ic_i_ic_p 795
-mmdvtregister_i_ic_ic_p 796
-mmdvtregister_ic_ic_ic_p 797
-mmdvtfind_p_i_i_i 798
-mmdvtfind_p_ic_i_i 799
-mmdvtfind_p_i_ic_i 800
-mmdvtfind_p_ic_ic_i 801
-mmdvtfind_p_i_i_ic 802
-mmdvtfind_p_ic_i_ic 803
-mmdvtfind_p_i_ic_ic 804
-mmdvtfind_p_ic_ic_ic 805
-register_p 806
-unregister_p 807
-get_mro_p_p 808
-clone_s_s 809
-clone_s_sc 810
-exchange_i_i 811
-exchange_p_p 812
-exchange_n_n 813
-exchange_s_s 814
-set_i_i 815
-set_i_ic 816
-set_i_n 817
-set_i_nc 818
-set_i_s 819
-set_i_sc 820
-set_n_n 821
-set_n_nc 822
-set_n_i 823
-set_n_ic 824
-set_n_s 825
-set_n_sc 826
-set_n_p 827
-set_s_p 828
-set_s_s 829
-set_s_sc 830
-set_s_i 831
-set_s_ic 832
-set_s_n 833
-set_s_nc 834
-set_p_pc 835
-set_p_p 836
-set_p_i 837
-set_p_ic 838
-set_p_n 839
-set_p_nc 840
-set_p_s 841
-set_p_sc 842
-set_i_p 843
-assign_p_p 844
-assign_p_i 845
-assign_p_ic 846
-assign_p_n 847
-assign_p_nc 848
-assign_p_s 849
-assign_p_sc 850
-assign_s_s 851
-assign_s_sc 852
-setref_p_p 853
-deref_p_p 854
-setp_ind_i_p 855
-setp_ind_ic_p 856
-setn_ind_i_n 857
-setn_ind_ic_n 858
-setn_ind_i_nc 859
-setn_ind_ic_nc 860
-sets_ind_i_s 861
-sets_ind_ic_s 862
-sets_ind_i_sc 863
-sets_ind_ic_sc 864
-seti_ind_i_i 865
-seti_ind_ic_i 866
-seti_ind_i_ic 867
-seti_ind_ic_ic 868
-set_p_ki_i 869
-set_p_kic_i 870
-set_p_ki_ic 871
-set_p_kic_ic 872
-set_p_ki_n 873
-set_p_kic_n 874
-set_p_ki_nc 875
-set_p_kic_nc 876
-set_p_ki_s 877
-set_p_kic_s 878
-set_p_ki_sc 879
-set_p_kic_sc 880
-set_p_ki_p 881
-set_p_kic_p 882
-set_i_p_ki 883
-set_i_p_kic 884
-set_n_p_ki 885
-set_n_p_kic 886
-set_s_p_ki 887
-set_s_p_kic 888
-set_p_p_ki 889
-set_p_p_kic 890
-set_p_k_i 891
-set_p_kc_i 892
-set_p_k_ic 893
-set_p_kc_ic 894
-set_p_k_n 895
-set_p_kc_n 896
-set_p_k_nc 897
-set_p_kc_nc 898
-set_p_k_s 899
-set_p_kc_s 900
-set_p_k_sc 901
-set_p_kc_sc 902
-set_p_k_p 903
-set_p_kc_p 904
-set_i_p_k 905
-set_i_p_kc 906
-set_n_p_k 907
-set_n_p_kc 908
-set_s_p_k 909
-set_s_p_kc 910
-set_p_p_k 911
-set_p_p_kc 912
-clone_p_p 913
-clone_p_p_p 914
-clone_p_p_pc 915
-copy_p_p 916
-null_s 917
-null_i 918
-null_p 919
-null_n 920
-cleari 921
-clearn 922
-clears 923
-clearp 924
-ord_i_s 925
-ord_i_sc 926
-ord_i_s_i 927
-ord_i_sc_i 928
-ord_i_s_ic 929
-ord_i_sc_ic 930
-chr_s_i 931
-chr_s_ic 932
-chopn_s_i 933
-chopn_s_ic 934
-chopn_s_s_i 935
-chopn_s_sc_i 936
-chopn_s_s_ic 937
-chopn_s_sc_ic 938
-concat_s_s 939
-concat_s_sc 940
-concat_s_s_s 941
-concat_s_sc_s 942
-concat_s_s_sc 943
-repeat_s_s_i 944
-repeat_s_sc_i 945
-repeat_s_s_ic 946
-repeat_s_sc_ic 947
-length_i_s 948
-length_i_sc 949
-bytelength_i_s 950
-bytelength_i_sc 951
-pin_s 952
-unpin_s 953
-substr_s_s_i 954
-substr_s_sc_i 955
-substr_s_s_ic 956
-substr_s_sc_ic 957
-substr_s_s_i_i 958
-substr_s_sc_i_i 959
-substr_s_s_ic_i 960
-substr_s_sc_ic_i 961
-substr_s_s_i_ic 962
-substr_s_sc_i_ic 963
-substr_s_s_ic_ic 964
-substr_s_sc_ic_ic 965
-substr_s_s_i_i_s 966
-substr_s_s_ic_i_s 967
-substr_s_s_i_ic_s 968
-substr_s_s_ic_ic_s 969
-substr_s_s_i_i_sc 970
-substr_s_s_ic_i_sc 971
-substr_s_s_i_ic_sc 972
-substr_s_s_ic_ic_sc 973
-substr_s_i_i_s 974
-substr_s_ic_i_s 975
-substr_s_i_ic_s 976
-substr_s_ic_ic_s 977
-substr_s_i_i_sc 978
-substr_s_ic_i_sc 979
-substr_s_i_ic_sc 980
-substr_s_ic_ic_sc 981
-substr_s_p_i_i 982
-substr_s_p_ic_i 983
-substr_s_p_i_ic 984
-substr_s_p_ic_ic 985
-index_i_s_s 986
-index_i_sc_s 987
-index_i_s_sc 988
-index_i_sc_sc 989
-index_i_s_s_i 990
-index_i_sc_s_i 991
-index_i_s_sc_i 992
-index_i_sc_sc_i 993
-index_i_s_s_ic 994
-index_i_sc_s_ic 995
-index_i_s_sc_ic 996
-index_i_sc_sc_ic 997
-sprintf_s_s_p 998
-sprintf_s_sc_p 999
-sprintf_p_p_p 1000
-new_s 1001
-new_s_i 1002
-new_s_ic 1003
-stringinfo_i_s_i 1004
-stringinfo_i_sc_i 1005
-stringinfo_i_s_ic 1006
-stringinfo_i_sc_ic 1007
-upcase_s_s 1008
-upcase_s_sc 1009
-upcase_s 1010
-downcase_s_s 1011
-downcase_s_sc 1012
-downcase_s 1013
-titlecase_s_s 1014
-titlecase_s_sc 1015
-titlecase_s 1016
-join_s_s_p 1017
-join_s_sc_p 1018
-split_p_s_s 1019
-split_p_sc_s 1020
-split_p_s_sc 1021
-split_p_sc_sc 1022
-charset_i_s 1023
-charset_i_sc 1024
-charsetname_s_i 1025
-charsetname_s_ic 1026
-find_charset_i_s 1027
-find_charset_i_sc 1028
-trans_charset_s_i 1029
-trans_charset_s_ic 1030
-trans_charset_s_s_i 1031
-trans_charset_s_sc_i 1032
-trans_charset_s_s_ic 1033
-trans_charset_s_sc_ic 1034
-encoding_i_s 1035
-encoding_i_sc 1036
-encodingname_s_i 1037
-encodingname_s_ic 1038
-find_encoding_i_s 1039
-find_encoding_i_sc 1040
-trans_encoding_s_i 1041
-trans_encoding_s_ic 1042
-trans_encoding_s_s_i 1043
-trans_encoding_s_sc_i 1044
-trans_encoding_s_s_ic 1045
-trans_encoding_s_sc_ic 1046
-is_cclass_i_i_s_i 1047
-is_cclass_i_ic_s_i 1048
-is_cclass_i_i_sc_i 1049
-is_cclass_i_ic_sc_i 1050
-is_cclass_i_i_s_ic 1051
-is_cclass_i_ic_s_ic 1052
-is_cclass_i_i_sc_ic 1053
-is_cclass_i_ic_sc_ic 1054
-find_cclass_i_i_s_i_i 1055
-find_cclass_i_ic_s_i_i 1056
-find_cclass_i_i_sc_i_i 1057
-find_cclass_i_ic_sc_i_i 1058
-find_cclass_i_i_s_ic_i 1059
-find_cclass_i_ic_s_ic_i 1060
-find_cclass_i_i_sc_ic_i 1061
-find_cclass_i_ic_sc_ic_i 1062
-find_cclass_i_i_s_i_ic 1063
-find_cclass_i_ic_s_i_ic 1064
-find_cclass_i_i_sc_i_ic 1065
-find_cclass_i_ic_sc_i_ic 1066
-find_cclass_i_i_s_ic_ic 1067
-find_cclass_i_ic_s_ic_ic 1068
-find_cclass_i_i_sc_ic_ic 1069
-find_cclass_i_ic_sc_ic_ic 1070
-find_not_cclass_i_i_s_i_i 1071
-find_not_cclass_i_ic_s_i_i 1072
-find_not_cclass_i_i_sc_i_i 1073
-find_not_cclass_i_ic_sc_i_i 1074
-find_not_cclass_i_i_s_ic_i 1075
-find_not_cclass_i_ic_s_ic_i 1076
-find_not_cclass_i_i_sc_ic_i 1077
-find_not_cclass_i_ic_sc_ic_i 1078
-find_not_cclass_i_i_s_i_ic 1079
-find_not_cclass_i_ic_s_i_ic 1080
-find_not_cclass_i_i_sc_i_ic 1081
-find_not_cclass_i_ic_sc_i_ic 1082
-find_not_cclass_i_i_s_ic_ic 1083
-find_not_cclass_i_ic_s_ic_ic 1084
-find_not_cclass_i_i_sc_ic_ic 1085
-find_not_cclass_i_ic_sc_ic_ic 1086
-escape_s_s 1087
-compose_s_s 1088
-compose_s_sc 1089
-spawnw_i_s 1090
-spawnw_i_sc 1091
-spawnw_i_p 1092
-err_i 1093
-err_s 1094
-err_s_i 1095
-err_s_ic 1096
-time_i 1097
-time_n 1098
-gmtime_s_i 1099
-gmtime_s_ic 1100
-localtime_s_i 1101
-localtime_s_ic 1102
-decodetime_p_i 1103
-decodetime_p_ic 1104
-decodelocaltime_p_i 1105
-decodelocaltime_p_ic 1106
-sysinfo_s_i 1107
-sysinfo_s_ic 1108
-sysinfo_i_i 1109
-sysinfo_i_ic 1110
-sleep_i 1111
-sleep_ic 1112
-sleep_n 1113
-sleep_nc 1114
-sizeof_i_i 1115
-sizeof_i_ic 1116
-store_lex_s_p 1117
-store_lex_sc_p 1118
-find_lex_p_s 1119
-find_lex_p_sc 1120
-get_namespace_p 1121
-get_namespace_p_p 1122
-get_namespace_p_pc 1123
-get_hll_namespace_p 1124
-get_hll_namespace_p_p 1125
-get_hll_namespace_p_pc 1126
-get_root_namespace_p 1127
-get_root_namespace_p_p 1128
-get_root_namespace_p_pc 1129
-get_global_p_s 1130
-get_global_p_sc 1131
-get_global_p_p_s 1132
-get_global_p_pc_s 1133
-get_global_p_p_sc 1134
-get_global_p_pc_sc 1135
-get_hll_global_p_s 1136
-get_hll_global_p_sc 1137
-get_hll_global_p_p_s 1138
-get_hll_global_p_pc_s 1139
-get_hll_global_p_p_sc 1140
-get_hll_global_p_pc_sc 1141
-get_root_global_p_s 1142
-get_root_global_p_sc 1143
-get_root_global_p_p_s 1144
-get_root_global_p_pc_s 1145
-get_root_global_p_p_sc 1146
-get_root_global_p_pc_sc 1147
-set_global_s_p 1148
-set_global_sc_p 1149
-set_global_p_s_p 1150
-set_global_pc_s_p 1151
-set_global_p_sc_p 1152
-set_global_pc_sc_p 1153
-set_hll_global_s_p 1154
-set_hll_global_sc_p 1155
-set_hll_global_p_s_p 1156
-set_hll_global_pc_s_p 1157
-set_hll_global_p_sc_p 1158
-set_hll_global_pc_sc_p 1159
-set_root_global_s_p 1160
-set_root_global_sc_p 1161
-set_root_global_p_s_p 1162
-set_root_global_pc_s_p 1163
-set_root_global_p_sc_p 1164
-set_root_global_pc_sc_p 1165
-store_global_s_p 1166
-store_global_sc_p 1167
-store_global_s_s_p 1168
-store_global_sc_s_p 1169
-store_global_s_sc_p 1170
-store_global_sc_sc_p 1171
-store_global_p_s_p 1172
-store_global_pc_s_p 1173
-store_global_p_sc_p 1174
-store_global_pc_sc_p 1175
-find_global_p_s 1176
-find_global_p_sc 1177
-find_global_p_s_s 1178
-find_global_p_sc_s 1179
-find_global_p_s_sc 1180
-find_global_p_sc_sc 1181
-find_global_p_p_s 1182
-find_global_p_pc_s 1183
-find_global_p_p_sc 1184
-find_global_p_pc_sc 1185
-find_name_p_s 1186
-find_name_p_sc 1187
-stm_start 1188
-stm_validate_ic 1189
-stm_commit_ic 1190
-stm_wait_ic 1191
-stm_abort 1192
-stm_depth_i 1193
Deleted: trunk/t/tools/ops2pm/samples/pic_ops.original
==============================================================================
--- trunk/t/tools/ops2pm/samples/pic_ops.original Sun May 23 21:38:28 2010 (r46921)
+++ /dev/null 00:00:00 1970 (deleted)
@@ -1,316 +0,0 @@
-/*
- * $Id$
-** pic.ops
-*/
-
-#include "parrot/oplib/ops.h"
-#include "../src/pmc/pmc_fixedintegerarray.h"
-
-typedef opcode_t* (*interface_f)(Interp*, INTVAL*, void **);
-
-VERSION = PARROT_VERSION;
-
-=head1 NAME
-
-pic.ops - PIC (Polymorphic Inline Cache) opcode variants
-
-=cut
-
-=head1 DESCRIPTION
-
-During predereferencing opcodes that allow caching are rewritten so that
-equivalent opcodes in this file are used. User code MUST never emit these
-opcodes directly.
-
-=head2 General infix operations
-
-These operations take an infix operation number and PMC arguments.
-
-=cut
-
-=over 4
-
-=item B<pic_infix__>(inconst INT, invar PMC, invar PMC)
-
-One for fun and MOPS.
-
-=cut
-
-inline op pic_infix__(inconst INT, invar PMC, invar PMC) :pic :flow {
- Parrot_MIC *mic;
- Parrot_PIC_lru *lru;
- PMC *left, *right;
- INTVAL lr_types;
-
- mic = (Parrot_MIC *) cur_opcode[1];
- left = $2;
- right = $3;
- lru = &mic->lru;
- lr_types = (VTABLE_type(interp, left) << 16) | VTABLE_type(interp, right);
- if (lru->u.type == lr_types) {
-runit_v_pp:
- ((mmd_f_v_pp)lru->f.real_function)(interp, left, right);
- goto NEXT();
- }
- if (mic->pic) {
- lru = mic->pic->lru;
- if (lru->u.type == lr_types)
- goto runit_v_pp;
- if (++lru->u.type == lr_types)
- goto runit_v_pp;
- if (++lru->u.type == lr_types)
- goto runit_v_pp;
- mic->pic->miss_count++;
- }
- parrot_pic_find_infix_v_pp(interp, left, right, mic, cur_opcode);
- /* rerun this opcode */
- goto OFFSET(0);
-}
-
-=item B<pic_inline_sub__>(inconst INT, invar PMC, invar PMC)
-
-And for more fun an inlined variant too.
-
-=cut
-
-inline op pic_inline_sub__(inconst INT, invar PMC, invar PMC) :pic {
- Parrot_MIC *mic;
- Parrot_PIC_lru *lru;
- PMC *left, *right;
- INTVAL lr_types, lt, rt;
-
- left = $2;
- mic = (Parrot_MIC *) cur_opcode[1];
- lt = VTABLE_type(interp, left);
- right = $3;
- lru = &mic->lru;
- rt = VTABLE_type(interp, right);
- lr_types = (lt << 16) | rt;
- if (lru->u.type == lr_types) {
- INTVAL a = lt == enum_class_Integer ? VTABLE_get_integer(interp, left) :
- VTABLE_get_integer(interp, left);
- INTVAL b = rt == enum_class_Integer ? VTABLE_get_integer(interp, right) :
- VTABLE_get_integer(interp, right);
- INTVAL c = a - b;
- if ((c^a) >= 0 || (c^~b) >= 0) {
- if (lt == enum_class_Integer)
- VTABLE_get_integer(interp, left) = c;
- else
- VTABLE_set_integer_native(interp, left, c);
- }
- else {
- if (PARROT_ERRORS_test(interp, PARROT_ERRORS_OVERFLOW_FLAG)) {
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
- "Integer overflow");
- }
- VTABLE_morph(interp, left, enum_class_BigInt);
- VTABLE_set_integer_native(interp, left, a);
- mmd_dispatch_p_pip(interp, left, b, left, MMD_SUBTRACT);
- }
- }
- else {
- ((void**)cur_opcode)[0] =
- parrot_pic_opcode(interp, PARROT_OP_pic_infix___ic_p_p);
- goto OFFSET(0);
- }
-}
-
-=item B<pic_get_params__>(inconst PMC /* , ... */)
-
-Fetch function parameters for this subroutine.
-
-=item B<pic_set_returns__>(inconst PMC /* , ... */)
-
-Return values to caller.
-
-=cut
-
-inline op pic_get_params__(inconst PMC) :pic :flow {
- Parrot_MIC *mic;
- Parrot_PIC_lru *lru;
- PMC *sig, *ccont;
- opcode_t *src_pc;
- void **src_pred;
- parrot_context_t *caller_ctx, *ctx;
- int n;
-
- /* avoid load dependencies - intermix derefs
- * - yes, confusing but faster
- */
- ctx = CONTEXT(interp);
- src_pc = interp->current_args;
- mic = (Parrot_MIC *) cur_opcode[1];
- caller_ctx = ctx->caller_ctx;
- if (src_pc) {
- src_pred = (void**) src_pc - caller_ctx->pred_offset;
- sig = (PMC*)(src_pred[1]);
- }
- else {
- sig = NULL;
- src_pred = NULL; /* just for gcc */
- }
- lru = &mic->lru;
- if (lru->u.signature == sig) {
- if (sig) {
- n = ((arg_pass_f)lru->f.real_function)(interp, sig,
- (char*)caller_ctx->bp.regs_i, src_pred,
- _reg_base, (void**)cur_opcode);
- }
- else
- n = 2;
- ccont = ctx->current_cont;
- if (PObj_get_FLAGS(ccont) & SUB_FLAG_TAILCALL) {
- PObj_get_FLAGS(ccont) &= ~SUB_FLAG_TAILCALL;
- --ctx->recursion_depth;
- ctx->caller_ctx = caller_ctx->caller_ctx;
- Parrot_free_context(interp, caller_ctx, 0);
- interp->current_args = NULL;
- }
-
- goto OFFSET(n);
- }
- /* no match redo plain opcode */
- ((void**)cur_opcode)[0] =
- parrot_pic_opcode(interp, PARROT_OP_get_params_pc);
- ((void**)cur_opcode)[1] = mic->m.sig;
- goto OFFSET(0);
-}
-
-inline op pic_set_returns__(inconst PMC) :pic :flow {
- Parrot_MIC *mic;
- Parrot_PIC_lru *lru;
- PMC *sig, *ccont;
- opcode_t *dest_pc;
- void **dest_pred;
- parrot_context_t *caller_ctx, *ctx;
- Parrot_cont *cc;
- int n;
-
- ctx = CONTEXT(interp);
- mic = (Parrot_MIC *) cur_opcode[1];
- ccont = ctx->current_cont;
- cc = PMC_cont(ccont);
- if (!cc->address) {
- interp->current_returns = CUR_OPCODE;
- n = VTABLE_get_integer(interp, mic->m.sig);
- goto OFFSET(n + 2);
- }
- caller_ctx = cc->to_ctx;
- interp->current_args = NULL;
- dest_pc = caller_ctx->current_results;
- if (dest_pc) {
- dest_pred = (void**) dest_pc - caller_ctx->pred_offset;
- sig = (PMC*)(dest_pred[1]);
- }
- else {
- sig = NULL;
- dest_pred = NULL;
- }
- lru = &mic->lru;
- if (lru->u.signature == sig) {
- if (sig) {
- n = ((arg_pass_f)lru->f.real_function)(interp, mic->m.sig,
- _reg_base, (void**)cur_opcode,
- (char*)caller_ctx->bp.regs_i, dest_pred);
- }
- else
- n = 2;
- goto OFFSET(n);
- }
- /* no match redo plain opcode */
- ((void**)cur_opcode)[0] =
- parrot_pic_opcode(interp, PARROT_OP_set_returns_pc);
- ((void**)cur_opcode)[1] = mic->m.sig;
- goto OFFSET(0);
-}
-
-=item B<pic_callr__>(inconst PMC)
-
-Call the function $1 as C<pc = func(interp, 0, **args)>. args[0] holds the
-address of the function result, args[1..] are function arguments, both
-according to the C<get_results> and C<set_args> opcodes. The function is
-a C interface function (or NCI) or a JITed PIR function. args[n+1] holds the
-C<pc> of the next opcode and is usually just returned.
-
-=cut
-
-inline op pic_callr__(inconst PMC) :pic :flow {
- Parrot_MIC *mic;
- Parrot_PIC_lru *lru;
- void *args[6];
- parrot_context_t *ctx;
- opcode_t *pc;
- void **pred_pc;
- INTVAL i, n_args, *sig_bits;
- PMC *sig;
-
- ctx = CONTEXT(interp);
- mic = (Parrot_MIC *) cur_opcode[1];
- /* get_results */
- pc = ctx->current_results;
- if (pc) {
- pred_pc = (void**) pc - ctx->pred_offset;
- sig = (PMC*)(pred_pc[1]);
- ASSERT_SIG_PMC(sig);
- PARROT_ASSERT(VTABLE_elements(interp, sig) <= 1);
- args[0] = VTABLE_elements(interp, sig) ?
- (_reg_base + ((opcode_t*)pred_pc)[2]) : NULL;
- }
- else
- args[0] = NULL;
- /* set_args */
- n_args = 0;
- sig = mic->m.sig;
- ASSERT_SIG_PMC(sig);
- n_args = VTABLE_elements(interp, sig);
- GETATTR_FixedIntegerArray_int_array(interp, sig, sig_bits);
- for (i = 0; i < n_args; ++i) {
- switch (sig_bits[i]) {
- case PARROT_ARG_INTVAL:
- args[1 + i] = (void*)*(INTVAL*)(_reg_base +
- ((opcode_t*)cur_opcode)[2 + i]);
- break;
- case PARROT_ARG_INTVAL|PARROT_ARG_CONSTANT:
- case PARROT_ARG_FLOATVAL|PARROT_ARG_CONSTANT:
- args[1 + i] = (void**)cur_opcode[2 + i];
- break;
- case PARROT_ARG_FLOATVAL:
- args[1 + i] = (_reg_base +
- ((opcode_t*)cur_opcode)[2 + i]);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1, "unhandled sig_bits");
- }
- }
- /* set_args(); set_p_pc; get_results(1), x; invokecc_p */
- pc = CUR_OPCODE + 2 + n_args + 3 + 3 + 2;
- args[1 + n_args] = pc;
- lru = &mic->lru;
- (void) ((interface_f)lru->f.real_function)(interp, sig_bits, args);
- goto ADDRESS(pc);
-}
-
-=back
-
-=cut
-
-###############################################################################
-
-=head1 COPYRIGHT
-
-Copyright (C) 2005-2008, Parrot Foundation.
-
-=head1 LICENSE
-
-This program is free software. It is subject to the same license
-as the Parrot interpreter itself.
-
-=cut
-
-
-/*
- * Local variables:
- * c-file-style: "parrot"
- * End:
- * vim: expandtab shiftwidth=4:
- */
Modified: trunk/tools/build/ops2c.pl
==============================================================================
--- trunk/tools/build/ops2c.pl Sun May 23 21:12:16 2010 (r46921)
+++ trunk/tools/build/ops2c.pl Sun May 23 21:38:28 2010 (r46922)
@@ -1,149 +1,14 @@
#! perl
-# Copyright (C) 2001-2008, Parrot Foundation.
+# Copyright (C) 2001-2010, Parrot Foundation.
# $Id$
-use warnings;
use strict;
-use FindBin qw($Bin);
-use lib "$Bin/../lib"; # install location
-use lib "$Bin/../../lib"; # build location
-use Parrot::Ops2c::Auxiliary qw( Usage getoptions );
-use Parrot::Ops2c::Utils ();
-
-my $flagref = getoptions();
-if ( ( not defined $flagref )
- or $flagref->{help}
- or ( not @ARGV ) )
-{
- Usage();
- exit 1;
-}
-
-my $self = Parrot::Ops2c::Utils->new(
- {
- argv => [@ARGV],
- flag => $flagref,
- script => $0,
- }
-);
-if ( not defined $self ) {
- Usage();
- exit 1;
-}
-
-$self->print_c_header_file();
-
-$self->print_c_source_file();
-
-exit 0;
-
-#################### DOCUMENTATION ####################
-
-=head1 NAME
-
-tools/build/ops2c.pl - Parser for .ops files
-
-=head1 SYNOPSIS
-
- % perl tools/build/ops2c.pl trans [--help] [--no-lines] [--dynamic]
- [--core | input.ops [input2.ops ...]]
- trans := C
-
-For example:
-
- % perl tools/build/ops2c.pl C --core
-
- % perl tools/build/ops2c.pl C --dynamic myops.ops
-
-=head1 DESCRIPTION
-
-This script uses a supplied transform to create a pair of C header and
-implementation files from the operation definitions found in one or more
-F<*.ops> files.
-
-=head2 Transforms
-
-The first command-line argument is the last package name component of a
-subclass of C<Parrot::OpTrans>. These subclasses all have full names of
-the form C<Parrot::OpTrans::*>. An instance of the class is created and
-later consulted for various bits of information needed to generate the C
-code. Each creates a different type of run loop.
-
-=over
-
-=item C<C>
-
-Create the function-based (slow or fast core) run loop.
-
-=back
-
-=head2 Options
-
-=over 4
-
-=item C<--help>
-
-Print synopsis.
-
-=item C<--dynamic>
-
-Indicate that the opcode library is dynamic.
-
-=item C<--core>
-
-Build the Parrot core opcode library.
-
-=item C<--no-lines>
-
-Do not generate C<#line> directives in the generated C code.
-
-=back
-
-=head1 NOTE
-
-Most of the functionality in F<tools/build/ops2c.pl> has been extracted into
-methods and subroutines found in Parrot::Ops2c::Utils and
-Parrot::Ops2c::Auxiliary. This refactoring facilitates unit testing and
-coverage analysis of that functionality. A test suite has been provided in
-F<t/tools/ops2cutils/>. It is recommended that future refactoring of this
-functionality proceed in a test-driven manner, I<i.e.,> tests should be
-written reflecting any changes to interface or functionality; the code should
-be written which implements the revisions; the code should be tested; and
-coverage analysis should be performed with Devel::Cover to measure the extent
-to which the tests exercise the code.
-
-=head1 AUTHORS
-
-Based on the commit logs, the following members of the Parrot project have
-contributed to this program:
-
- ambs bernhard boemmels brentdax chip
- coke dan gregor grunblatt jgoff
- jkeenan jonathan josh jrieks leo
- mikescott mrjoltcola nicholas particle paultcochrane
- petdance rgrjr robert simon
-
-=head1 SEE ALSO
-
-=over 4
-
-=item F<tools/build/ops2pm.pl>
-
-=item C<Parrot::OpsFile>
-
-=item C<Parrot::Op>
-
-=item C<Parrot::OpTrans>
-
-=item C<Parrot::OpTrans::C>
-
-=item C<Parrot::Ops2c::Utils>
-
-=item C<Parrot::Ops2c::Auxiliary>
-
-=back
+use warnings;
-=cut
+warn 'ops2c.pl is deprecated. Use ops2c$(EXE) instead';
+# Ignore "core"
+shift @ARGV;
+exec 'ops2c', @ARGV;
# Local Variables:
# mode: cperl
More information about the parrot-commits
mailing list