int main()
{
int var_value;
var = &var_value;
*var = 100000000;
op = initops();
runops();
printf("%s", "pointer\n");
*var = 100000000;
runinsns(initinsns());
printf("%s", "switch\n");
return 0;
}
void
Parrot_run_native(Parrot_Interp interpreter, native_func_t func)
{
static opcode_t program_code[2];
struct PackFile * pf;
program_code[0] = interpreter->op_lib->op_code("enternative", 0);
program_code[1] = 0; /* end */
pf = PackFile_new(0);
pf->cur_cs = (struct PackFile_ByteCode *)
(pf->PackFuncs[PF_BYTEC_SEG].new_seg)(pf, "code", 1);
pf->byte_code = pf->cur_cs->base.data = program_code;
pf->cur_cs->base.size = 2;
Parrot_loadbc(interpreter, pf);
run_native = func;
runops(interpreter, interpreter->resume_offset);
}
void
Parrot_runcode(struct Parrot_Interp *interpreter, int argc, char *argv[])
{
/* Debugging mode nonsense. */
if (Interp_flags_TEST(interpreter, PARROT_DEBUG_FLAG)) {
if (Interp_flags_TEST(interpreter, PARROT_BOUNDS_FLAG)) {
PIO_eprintf(interpreter,
"*** Parrot VM: Bounds checking enabled. ***\n");
}
if (Interp_flags_TEST(interpreter, PARROT_TRACE_FLAG)) {
PIO_eprintf(interpreter, "*** Parrot VM: Tracing enabled. ***\n");
}
PIO_eprintf(interpreter, "*** Parrot VM: ");
switch (interpreter->run_core) {
case PARROT_SLOW_CORE:
PIO_eprintf(interpreter, "Slow core");
break;
case PARROT_FAST_CORE:
PIO_eprintf(interpreter, "Fast core");
break;
case PARROT_PREDEREF_CORE:
PIO_eprintf(interpreter, "Predereferencing core");
break;
case PARROT_SWITCH_CORE:
PIO_eprintf(interpreter, "Switch core");
break;
case PARROT_CGP_CORE:
PIO_eprintf(interpreter, "CGP core");
break;
case PARROT_CGOTO_CORE:
PIO_eprintf(interpreter, "CGoto core");
break;
case PARROT_JIT_CORE:
PIO_eprintf(interpreter, "JIT core");
break;
case PARROT_EXEC_CORE:
PIO_eprintf(interpreter, "EXEC core");
break;
}
PIO_eprintf(interpreter, " ***\n");
}
/* Set up @ARGS (or whatever this language calls it).
XXX Should this be Array or PerlArray? */
setup_argv(interpreter, argc, argv);
#if EXEC_CAPABLE
/* s. runops_exec interpreter.c */
if (Interp_core_TEST(interpreter, PARROT_EXEC_CORE)) {
extern int Parrot_exec_run;
Parrot_exec_run = 1;
}
#endif
/*
* If any profile information was gathered, print it out
* before exiting, then print debug infos if turned on
*/
Parrot_on_exit(print_debug, interpreter);
Parrot_on_exit(print_profile, interpreter);
/* Let's kick the tires and light the fires--call interpreter.c:runops. */
runops(interpreter, interpreter->resume_offset);
}
int
main(int argc, char **argv) {
long *opp;
int dummy_var;
struct Parrot_Interp * interpreter;
struct PackFile * pf;
opcode_t *code_start;
INTVAL i;
PMC *userargv;
extern char *program_code;
extern long opcode_map;
extern int bytecode_offset;
#if defined(JIT_CGP)
extern void * exec_prederef_code;
#endif
extern int Parrot_exec_run;
extern struct PackFile_Constant *exec_const_table;
extern struct PackFile_Constant const_table;
extern struct Parrot_Interp interpre;
/* s. exec.c */
Parrot_exec_run = 1;
/* s. packfile.c (PackFile_ConstTable_unpack()) */
exec_const_table = &const_table;
interpreter = Parrot_new(NULL);
if (!interpreter) {
return 1;
}
Parrot_init(interpreter);
run_native = run_compiled;
/* TODO make also a shared variant of PackFile_new */
pf = PackFile_new(0);
if (!PackFile_unpack(interpreter, pf, (opcode_t *)(&program_code),
sizeof(&program_code)))
{
printf( "Can't unpack.\n" );
return 1;
}
Parrot_loadbc(interpreter, pf);
setup_argv(interpreter, argc, argv);
/* opcode_map has the offset of each opcode in the compiled code
* this modifies it to be address of the opcode.
*/
opp = &opcode_map;
for (i = 0; i < (int)interpre.code->cur_cs->base.size; i++) {
opp[i] += (long)run_compiled;
}
#if defined(JIT_CGP)
exec_init_prederef(interpreter, &exec_prederef_code);
#endif
Parrot_set_run_core(interpreter, PARROT_EXEC_CORE);
interpreter->code->byte_code =
(opcode_t *)&((&program_code)[bytecode_offset]);
Parrot_exec_run = 0;
runops(interpreter, 0);
/*
run_compiled(interpreter,
(opcode_t *)&((&program_code)[bytecode_offset]));
*/
exit(0);
}
