app_frontend* add_app_lb(provider *pv, struct application *app){
app_frontend *app_fe = malloc(sizeof(app_frontend));
app_fe->active = 1;
app_fe->id= app->id;
app_fe->pv = pv;
//app_fe->num_nodes_front_end = app->str.nodeslayer[0];
//app_fe->num_nodes_read = app->str.nodeslayer[1];
//app_fe->num_nodes_write = app->str.nodeslayer[2];
app_fe->app = app;
app_fe->rr = 0;
app_fe->vm = init_vm(app);
app_fe->next = NULL;
app_fe->prev = NULL;
if( pv->lb->app_num == 0){
pv->lb->first = app_fe;
pv->lb->last = app_fe;
}
else{
pv->lb->last->next = app_fe;
app_fe->prev = pv->lb->last;
pv->lb->last = app_fe;
}
pv->lb->app_num++;
return(app_fe);
}
//**************************************************
// セットアップします
//**************************************************
void setup()
{
pinMode(RB_LED, OUTPUT);
#if BOARD == BOARD_GR
pinMode(PIN_LED0, OUTPUT);
pinMode(PIN_LED1, OUTPUT);
pinMode(PIN_LED2, OUTPUT);
pinMode(PIN_LED3, OUTPUT);
#endif
//ピンモードを入力に初期化します
pinModeInit();
//シリアル通信の初期化
Serial.begin(115200); //仮想USBシリアル
//Serial.setDefault();
//sci_convert_crlf_ex(Serial.get_handle(), CRLF_NONE, CRLF_NONE); //バイナリを通せるようにする
//vmの初期化
init_vm();
//Port 3-5がHIGHだったら、EEPROMファイルローダーに飛ぶ
if( FILE_LOAD == 1 ){
fileloader((const char*)ProgVer,MRUBY_VERSION);
}
}
int main(int argc, char **argv)
{
if(argc == 1) {
fprintf(stderr, "Usage: %s FILE\n", argv[0]);
exit(1);
}
errno = 0;
size_t size;
int32_t *mem = read_file(argv[1], &size);
if(!mem) {
if(errno)
perror(argv[0]);
else
fprintf(stderr, "%s: The file was invalid.\n", argv[0]);
exit(1);
}
init_vm(mem, size);
while(1) {
run_vm();
render_screen();
process_events();
delay();
}
}
static ErlDrvData
emonk_start(ErlDrvPort port, char *cmd)
{
uint rt_max, gc_max, gc_last, ctx;
emonk_drv_t* drv = NULL;
ErlDrvData ret = ERL_DRV_ERROR_GENERAL;
emonk_settings_t settings;
if(parse_settings(cmd, &settings) < 0)
{
ret = ERL_DRV_ERROR_BADARG;
goto error;
}
drv = (emonk_drv_t*) driver_alloc(sizeof(emonk_drv_t));
if(drv == NULL) goto error;
drv->port = port;
drv->ok = driver_mk_atom("ok");
drv->error = driver_mk_atom("error");
drv->undefined = driver_mk_atom("undefined");
drv->bad_cmd = driver_mk_atom("bad_command");
drv->vm = init_vm(&settings);
if(drv->vm == NULL) goto error;
return (ErlDrvData) drv;
error:
if(drv != NULL) driver_free(drv);
return ret;
}
/* Main ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
int main(int argc, char **argv)
{
int i;
VM *vm = malloc(sizeof(VM));
strcpy(vm->filename, "retroImage");
init_vm(vm);
dev_init_input();
/* Parse the command line arguments */
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "--with") == 0)
dev_include(argv[++i]);
if (strcmp(argv[i], "--image") == 0)
strcpy(vm->filename, argv[++i]);
if (strcmp(argv[i], "--shrink") == 0)
vm->shrink = 1;
}
dev_init_output();
if (vm_load_image(vm, vm->filename) == -1) {
dev_cleanup();
printf("Sorry, unable to find %s\n", vm->filename);
exit(1);
}
for (vm->ip = 0; vm->ip < IMAGE_SIZE; vm->ip++)
vm_process(vm);
dev_cleanup();
return 0;
}
int main() {
VM* vm = init_vm(100,100);
do_main(vm, NULL);
printf("%ld\n", GETINT(RVAL));
printf("%d %d %d\n", vm->valstack, vm->valstack_base, vm->valstack_top);
}
VM* idris_vm() {
VM* vm = init_vm(4096000, 4096000, 1);
init_threadkeys();
init_threaddata(vm);
init_gmpalloc();
init_nullaries();
return vm;
}
errcode_t init_test(test_t * test, const char * programfile, const char * testfile)
{
errcode_t retval;
FILE * in;
uint16_t i;
uint16_t next_gpio_value;
char filename[256];
retval = init_vm(&test->uut);
CHECK_OK(retval, "Failed to init vm\n");
retval = load_program(&test->uut, programfile);
CHECK_OK(retval, "Failed to load program\n");
in = fopen(testfile, "r");
CHECK_NOT_NULL(in, IO, "Failed to open test file\n");
fscanf(in, "%u", &test->test_length);
CHECK_NOT_FERROR(in);
/*
test->uart_in = fopen("uartin.dat", "w");
CHECK_NOT_NULL(test->uart_in, IO, "Failed to open UART in file\n");
test->uart_out = fopen("uartout.dat", "w");
CHECK_NOT_NULL(test->uart_out, IO, "Failed to open UART out file\n");
*/
for (i = 0; i < TEST_PIN_COUNT; i++)
{
sprintf(filename, "gpio_%u.dat", i);
test->gpio_files[i] = fopen(filename, "w");
CHECK_NOT_NULL(test->gpio_files[i], IO, "Failed to open GPIO file\n");
}
test->input_size = 0;
while (!feof(in))
{
fscanf(in, "%u %u %hu", &test->gpio_input[test->input_size].time, &test->gpio_input[test->input_size].pin, &next_gpio_value);
test->gpio_input[test->input_size].value = (uint8_t)next_gpio_value;
test->input_size++;
}
test->input_size--; /* discard excessive read */
fclose(in);
for (i = 0; i < test->uut.proc_table_size; i++)
{
sprintf(filename, "sched_%u.dat", i);
test->schedules[i] = fopen(filename, "w");
CHECK_NOT_NULL(test->schedules[i], IO, "Failed to open schedule file\n");
}
return OK;
}
int main(int argc, const char *argv[])
{
init_vm();
switch (argc)
{
case 1:
repl();
break;
case 2:
runFile(argv[1]);
break;
default:
fprintf(stderr, "Usage: coil [path]\n");
exit(64);
}
free_vm();
return 0;
}
int main(int argc, char **argv)
{
t_vm *vm;
int dump;
if (argc > 1)
{
if (!(vm = init_vm()))
exit(write(2, "No memory\n", 10));
dump = -1;
parse_args(argc, argv, vm, &dump);
if (vm->nb_players < 1)
exit(write(2, "No players\n", 11));
vm->last_player = vm->players[vm->nb_players - 1]->number;
load_players_in_memory(vm);
run_vm(vm, dump);
print_winner(vm);
free_vm(vm);
}
return (0);
}
int main() {
int argc;
char **argv;
win32_get_argv_utf8(&argc, &argv);
#else
int main(int argc, char **argv) {
#endif
parse_shift_args(&opts, &argc, &argv);
__idris_argc = argc;
__idris_argv = argv;
VM* vm = init_vm(opts.max_stack_size, opts.init_heap_size, 1);
init_threadkeys();
init_threaddata(vm);
init_gmpalloc();
init_nullaries();
init_signals();
_idris__123_runMain0_125_(vm, NULL);
#ifdef IDRIS_DEBUG
if (opts.show_summary) {
idris_gcInfo(vm, 1);
}
#endif
Stats stats = terminate(vm);
if (opts.show_summary) {
print_stats(&stats);
}
free_nullaries();
return EXIT_SUCCESS;
}
/*===========================================================================*
* main *
*===========================================================================*/
int main(void)
{
message msg;
int result, who_e, rcv_sts;
int caller_slot;
/* Initialize system so that all processes are runnable */
init_vm();
/* Register init callbacks. */
sef_setcb_init_restart(sef_cb_init_fail);
sef_setcb_signal_handler(sef_cb_signal_handler);
/* Let SEF perform startup. */
sef_startup();
SANITYCHECK(SCL_TOP);
/* This is VM's main loop. */
while (TRUE) {
int r, c;
u32_t type, param;
SANITYCHECK(SCL_TOP);
if(missing_spares > 0) {
alloc_cycle(); /* mem alloc code wants to be called */
}
if ((r=sef_receive_status(ANY, &msg, &rcv_sts)) != OK)
panic("sef_receive_status() error: %d", r);
if (is_ipc_notify(rcv_sts)) {
/* Unexpected notify(). */
printf("VM: ignoring notify() from %d\n", msg.m_source);
continue;
}
who_e = msg.m_source;
if(vm_isokendpt(who_e, &caller_slot) != OK)
panic("invalid caller %d", who_e);
type = param = msg.m_type;
type &= 0x0000FFFF;
param >>= 16;
c = CALLNUMBER(type);
result = ENOSYS; /* Out of range or restricted calls return this. */
if(msg.m_type == RS_INIT && msg.m_source == RS_PROC_NR) {
result = do_rs_init(&msg);
} else if (msg.m_type == VM_PAGEFAULT) {
if (!IPC_STATUS_FLAGS_TEST(rcv_sts, IPC_FLG_MSG_FROM_KERNEL)) {
printf("VM: process %d faked VM_PAGEFAULT "
"message!\n", msg.m_source);
}
do_pagefaults(&msg);
/*
* do not reply to this call, the caller is unblocked by
* a sys_vmctl() call in do_pagefaults if success. VM panics
* otherwise
*/
continue;
} else if(c < 0 || !vm_calls[c].vmc_func) {
/* out of range or missing callnr */
} else {
if (acl_check(&vmproc[caller_slot], c) != OK) {
printf("VM: unauthorized %s by %d\n",
vm_calls[c].vmc_name, who_e);
} else {
SANITYCHECK(SCL_FUNCTIONS);
result = vm_calls[c].vmc_func(&msg);
SANITYCHECK(SCL_FUNCTIONS);
}
}
/* Send reply message, unless the return code is SUSPEND,
* which is a pseudo-result suppressing the reply message.
*/
if(result != SUSPEND) {
msg.m_type = result;
if((r=send(who_e, &msg)) != OK) {
printf("VM: couldn't send %d to %d (err %d)\n",
msg.m_type, who_e, r);
panic("send() error");
}
}
}
return(OK);
}
int main (int argc, char *argv[])
{
char *fn;
int f_ret, u_ret;
prog_name = argv[0];
tvm_argc = argc;
tvm_argv = argv;
if (argc < 2) {
usage (stderr);
return 1;
} else {
fn = argv[1];
}
init_vm ();
if (install_user_ctx (fn) < 0) {
error_out_no_errno ("failed to load user bytecode");
return 1;
}
if (install_firmware_ctx () < 0) {
error_out_no_errno ("failed to install firmware");
return 1;
}
kyb_channel = NOT_PROCESS_P;
scr_channel = NOT_PROCESS_P;
err_channel = NOT_PROCESS_P;
for (;;) {
f_ret = run_firmware ();
u_ret = run_user ();
if ((f_ret == ECTX_EMPTY || f_ret == ECTX_SLEEP) &&
(u_ret == ECTX_EMPTY || u_ret == ECTX_SLEEP)) {
if (firmware->fptr == NOT_PROCESS_P && user->fptr == NOT_PROCESS_P) {
tvm_sleep ();
}
} else if (f_ret == ECTX_ERROR || u_ret == ECTX_ERROR) {
break;
} else if (u_ret == ECTX_SHUTDOWN) {
/* Run firmware to clear buffers */
run_firmware ();
break;
}
}
if (u_ret == ECTX_ERROR) {
tbc_t *tbc = user->priv.bytecode->tbc;
if (tbc->debug) {
tbc_dbg_t *dbg = tbc->debug;
tbc_lnd_t *ln;
tenc_str_t *file;
int offset = user->iptr - tbc->bytecode;
int i = 0;
while (i < dbg->n_lnd) {
if (dbg->lnd[i].offset > offset) {
break;
}
i++;
}
ln = &(dbg->lnd[i - 1]);
file = dbg->files;
for (i = 0; i < ln->file; ++i) {
file = file->next;
}
fprintf (stderr,
"Error at %s:%d\n",
file->str, ln->line
);
}
/* FIXME: more debugging */
fprintf (stderr,
"Program failed, state = %c, eflags = %08x\n",
user->state, user->eflags
);
return 1;
}
free_ectx (firmware);
free_ectx (user);
free_bytecode (fw_bc);
free_bytecode (us_bc);
#ifdef TVM_PROFILING
output_profiling ();
#endif
return 0;
}
/******************************************************
* Main entry point into the VM
******************************************************/
int main(int argc, char **argv)
{
int a, i, endian;
char *opstat_path = 0;
FILE *opstats = 0;
VM *vm = malloc(sizeof(VM));
endian = 0;
strcpy(vm->filename, "retroImage");
init_vm(vm);
dev_init(INPUT);
vm->shrink = 0;
vm->trace = 0;
vm->trace_stacks = 0;
/* Parse the command line arguments */
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "--trace") == 0)
{
vm->trace = -1;
}
else if (strcmp(argv[i], "--trace-stacks") == 0)
{
vm->trace_stacks = -1;
}
else if (strcmp(argv[i], "--endian") == 0)
{
endian = -1;
}
else if (strcmp(argv[i], "--with") == 0)
{
i++; dev_include(argv[i]);
}
else if (strcmp(argv[i], "--opstats") == 0)
{
i++; opstat_path = argv[i];
init_stats(&opstats, opstat_path, call_stats_please);
}
else if (strcmp(argv[i], "--callstats") == 0)
{
call_stats_please = 1;
if (opstat_path)
{
init_stats(&opstats, opstat_path, call_stats_please);
}
}
else if (strcmp(argv[i], "--shrink") == 0)
{
vm->shrink = 1;
}
else if ((strcmp(argv[i], "--help") == 0) ||
(strcmp(argv[i], "-help") == 0) ||
(strcmp(argv[i], "/help") == 0) ||
(strcmp(argv[i], "/?") == 0) ||
(strcmp(argv[i], "/h") == 0) ||
(strcmp(argv[i], "-h") == 0))
{
fprintf(stderr, "%s [options] [imagename]\n", argv[0]);
fprintf(stderr, "Valid options are:\n");
fprintf(stderr, " --about Display some information about Ngaro\n");
fprintf(stderr, " --trace Trace instructions being executed\n");
fprintf(stderr, " --trace-stacks Also trace data and return stack contents\n");
fprintf(stderr, " --endian Load an image with a different endianness\n");
fprintf(stderr, " --shrink Shrink the image to the current heap size when saving\n");
fprintf(stderr, " --with [file] Treat [file] as an input source\n");
fprintf(stderr, " --opstats [file] Write statistics about VM operations to [file]\n");
fprintf(stderr, " --callstats Include how many times each address is called (slow)\n");
fprintf(stderr, " Also includes distribution of stack depths.\n");
exit(0);
}
else if ((strcmp(argv[i], "--about") == 0) ||
(strcmp(argv[i], "--version") == 0))
{
fprintf(stderr, "Retro Language [VM: C, console]\n\n");
exit(0);
}
else
{
strcpy(vm->filename, argv[i]);
}
}
dev_init(OUTPUT);
a = vm_load_image(vm, vm->filename);
if (a == -1)
{
dev_cleanup();
printf("Sorry, unable to find %s\n", vm->filename);
exit(1);
}
/* Swap endian if --endian was passed */
if (endian == -1)
swapEndian(vm);
/* Process the image */
if (opstats == 0)
{
for (vm->ip = 0; vm->ip < IMAGE_SIZE; vm->ip++)
vm_process(vm);
}
else
{
for (vm->ip = 0; vm->ip < IMAGE_SIZE; vm->ip++)
{
collect_stats(vm);
vm_process(vm);
}
report_stats(opstats);
}
/* Once done, cleanup */
dev_cleanup();
return 0;
}
int
start_live(struct radclock_handle *handle)
{
/* Threads */
void* thread_status;
int have_fixed_point_thread = 0;
int err;
JDEBUG
/*
* Handle first time run. If no time_server specified while we produce
* packets, we would be a nasty CPU hog. Better avoid creating problems and
* exit with an error message
*/
if ((handle->conf->synchro_type == SYNCTYPE_NTP) ||
(handle->conf->synchro_type == SYNCTYPE_1588)) {
if (strlen(handle->conf->time_server) == 0) {
verbose(LOG_ERR, "No time server specified on command line "
"or configuration file, attempting suicide.");
return (1);
}
}
/*
* This thread triggers the processing of data. It could be a dummy sleeping
* loop, an NTP client, a 1588 slave ...
*/
if (!VM_SLAVE(handle)) {
err = start_thread_TRIGGER(handle);
if (err < 0)
return (1);
}
/*
* This thread is in charge of processing the raw data collected, magically
* transform the data into stamps and give them to the sync algo for
* processing.
*/
if (handle->unix_signal == SIGHUP) {
/*
* This is not start, but HUP, the algo thread is still running
* Simply clear the flag and bypass
*/
handle->unix_signal = 0;
}
else {
if (VM_SLAVE(handle) || VM_MASTER(handle)) {
err = init_vm(handle);
if (err < 0){
verbose(LOG_ERR, "Failed to initialise VM communication");
return (1);
}
}
if (!VM_SLAVE(handle)) {
err = start_thread_DATA_PROC(handle);
if (err < 0)
return (1);
}
}
/* Are we running an NTP server for network clients ? */
switch (handle->conf->server_ntp) {
case BOOL_ON:
err = start_thread_NTP_SERV(handle);
if (err < 0)
return (1);
break;
case BOOL_OFF:
default:
/* do nothing */
break;
}
/* Are we running a VM UDP server for network guests ? */
switch (handle->conf->server_vm_udp) {
case BOOL_ON:
err = start_thread_VM_UDP_SERV(handle);
if (err < 0)
return (1);
break;
case BOOL_OFF:
default:
/* do nothing */
break;
}
/*
* To be able to provide the RADCLOCK timestamping mode, we need to refresh
* the fixed point data in the kernel. That's this guy's job.
* XXX Update: with kernel version 2, the overflow problem is taking care of
* by the kernel. The fixedpoint thread is deprecated and should be removed
* in the future
*/
if ((handle->run_mode == RADCLOCK_SYNC_LIVE) &&
(handle->clock->kernel_version < 2)) {
err = start_thread_FIXEDPOINT(handle);
if (err < 0)
return (1);
have_fixed_point_thread = 1;
}
else
have_fixed_point_thread = 0;
/*
* That's our main capture loop, it does not return until the end of
* input or if we explicitely break it
* XXX TODO XXX: a unique source is assumed !!
*/
err = capture_raw_data(handle);
if (err == -1) {
/* Yes, we abuse this a bit ... */
handle->unix_signal = SIGTERM;
verbose(LOG_NOTICE, "Reached end of input");
}
if (err == -2) {
verbose(LOG_NOTICE, "Breaking current capture loop for rehash");
}
/*
* pcap_break_loop() has been called or end of input. In both cases kill the
* threads. If we rehash, they will be restarted anyway.
*/
verbose(LOG_NOTICE, "Send killing signal to threads. Wait for stop message.");
handle->pthread_flag_stop = PTH_STOP_ALL;
/* Do not stop sync algo thread if we HUP */
if (handle->unix_signal == SIGHUP)
handle->pthread_flag_stop &= ~PTH_DATA_PROC_STOP;
if (handle->conf->server_ntp == BOOL_ON) {
pthread_join(handle->threads[PTH_NTP_SERV], &thread_status);
verbose(LOG_NOTICE, "NTP server thread is dead.");
}
pthread_join(handle->threads[PTH_TRIGGER], &thread_status);
verbose(LOG_NOTICE, "Trigger thread is dead.");
if (have_fixed_point_thread) {
pthread_join(handle->threads[PTH_FIXEDPOINT], &thread_status);
verbose(LOG_NOTICE, "Kernel fixedpoint thread is dead.");
}
/* Join on TERM since algo has been told to die */
if (handle->unix_signal != SIGHUP) {
pthread_join(handle->threads[PTH_DATA_PROC], &thread_status);
verbose(LOG_NOTICE, "Data processing thread is dead.");
/* Reinitialise flags */
handle->pthread_flag_stop = 0;
verbose(LOG_NOTICE, "Threads are dead.");
/* We received a SIGTERM, we exit the loop. */
return (1);
}
else {
handle->pthread_flag_stop = 0;
}
return (0);
}
int main(int argc, char *argv[])
{
int c;
int is_default_name = true;
int has_obj_name = false;
char fn_in[100];
char fn_out[100];
char temp_name[100];
// printf("%d",sizeof(OpCode));
if(!find_source_file(argc,argv,fn_in)){
fprintf(stderr,"no input file\n");
}
while((c=getopt(argc,argv,"xVvHhS:s:o:")) != -1){
switch (c) {
case 'S':
case 's':
strcpy(temp_name,fn_in);
str_find_replace(temp_name,'.','\0');
strcat(temp_name,".s");
strcpy(fn_out,temp_name);
gen_op_code = true;
goto end;
break;
case 'x':
break;
case 'o':
if(!file_name_vaild(optarg,'o')){
fprintf(stderr,"input file name is invaild\n");
return 0;
}
strcpy(fn_out,optarg);
is_default_name = false;
break;
case 'V':
case 'v':
version();
break;
case 'H':
case 'h':
help();
break;
default:
break;
}
}
end:
input_stream = fopen(fn_in,"r+");
if(gen_op_code){
output_stream = fopen(fn_out,"w+");
compile();
}else{
if(is_default_name){
//str_find_replace(fn_in,'.','\0');
//strcat(fn_in,".out");
//use fn_in to write file
output_stream = fopen("a.out","w+");
}else{
output_stream = fopen(fn_out,"w+");
}
compile();
process_struct_code();
//write_binary_struct_code();
init_vm();
start_vm();
}
return 0;
}
int run_vm(void) {
#if !defined(VM_CLOCKINTERRUPTHANDLER_INTERRUPT)
Object temp;
int32* mainMethodJavaStack;
#endif
int16 execp = 0;
/* Required for certain compilers. */
init_compiler_specifics();
/* Function below allocates the initial heap. This is done in
* initDefaultRAMAllocationPoint in allocation_point.c
*/
init_vm();
#if defined(ENABLE_DEBUG)
connectToDebugger();
sendStartEvent();
while (awaitCommandFromDebugger(0, 0, 0) != RESUME_EVENT) {;}
#endif
/* Allocating the main stack is delegated to the target specific function
* 'get_java_stack_base'. On some architectures/environments it is located
* at fixed positions in certain compiler specific sections. The implementor
* can allocate the stack in the heap if so desired.
* */
mainMethodJavaStack = get_java_stack_base(JAVA_STACK_SIZE);
#if defined(VM_CLOCKINTERRUPTHANDLER_INTERRUPT)
/* If more threads are started we give the main thread a new C stack pointer.
* In case of no other threads running the main thread just inherits the
* current C stack.
*
* In this case we save the current C stack so we may restore it later. This
* is required to terminate the process properly.
*/
mainStackPointer = (pointer) get_stack_pointer();
/* mainMethodJavaStack contains both Java and C stack. Java stack grows
* upwards from the beginning, C stack downwards from the end. */
stackPointer = (pointer) &mainMethodJavaStack[JAVA_STACK_SIZE - 2];
/* 'set_stack_pointer' sets the C stack */
stackPointer = (pointer) & mainMethodJavaStack[JAVA_STACK_SIZE - 2];
set_stack_pointer();
#endif
#if defined(REPORTCYCLES)
papi_start();
papi_mark();
papi_mark();
papi_mark();
papi_mark();
papi_mark();
papi_mark();
#endif
#if defined(LDC2_W_OPCODE_USED) || defined(LDC_W_OPCODE_USED) || defined(LDC_OPCODE_USED) || defined(HANDLELDCWITHINDEX_USED)
execp = initializeConstants(mainMethodJavaStack);
if (execp == -1) {
#endif
execp = initializeExceptions(mainMethodJavaStack);
if (execp == -1) {
#if defined(INVOKECLASSINITIALIZERS)
execp = invokeClassInitializers(mainMethodJavaStack);
if (execp == -1) {
#endif
/* This is only for testing. All tests will write 0 (null) to
* '*mainMethodJavaStack' if the test is successful.
*/
*mainMethodJavaStack = (int32) (pointer) &temp;
#if defined(VM_CLOCKINTERRUPTHANDLER_ENABLE_USED)
start_system_tick();
#endif
#if defined(DEVICES_SYSTEM_INITIALIZESYSTEMCLASS)
execp = enterMethodInterpreter(
DEVICES_SYSTEM_INITIALIZESYSTEMCLASS, mainMethodJavaStack);
if (execp == -1) {
#endif
/* Start the VM */
execp = enterMethodInterpreter(mainMethodIndex,
mainMethodJavaStack);
#if defined(VM_CLOCKINTERRUPTHANDLER_ENABLE_USED)
stop_system_tick();
#endif
#if defined(DEVICES_SYSTEM_INITIALIZESYSTEMCLASS)
}
#endif
}
/* TODO: use executeWithStack instead */
#if defined(INVOKECLASSINITIALIZERS)
}
#endif
#if defined(LDC2_W_OPCODE_USED) || defined(LDC_W_OPCODE_USED) || defined(LDC_OPCODE_USED) || defined(HANDLELDCWITHINDEX_USED)
}
#endif
#if defined(REPORTCYCLES)
papi_mark();
#endif
mark_error();
if (execp >= 0) {
#if defined(JAVA_LANG_THROWABLE_INIT_)
handleException(execp);
#endif
#if defined(VM_CLOCKINTERRUPTHANDLER_INTERRUPT)
/* Restore C stack pointer. Otherwise we could not return from here properly */
stackPointer = (pointer) mainStackPointer;
set_stack_pointer();
#endif
return ERROR;
}
#if defined(VM_CLOCKINTERRUPTHANDLER_INTERRUPT)
/* Restore C stack pointer. Otherwise we could not return from here properly */
stackPointer = (pointer) mainStackPointer;
set_stack_pointer();
#endif
#if defined(ENABLE_DEBUG)
disconnectFromDebugger();
#endif
if (*mainMethodJavaStack) {
return ERROR;
} else {
mark_success();
return SUCCESS;
}
return 0;
}
/******************************************************
*|F| int main(int argc, char **argv)
******************************************************/
int main(int argc, char **argv)
{
int a, i, trace, endian;
printf("Video @ %i\n", VIDEO_BASE);
trace = 0;
endian = 0;
strcpy(vm.filename, "retroImage");
init_vm();
init_devices();
vm.shrink = 0;
/* Parse the command line arguments */
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "--trace") == 0)
{
trace = 1;
}
else if (strcmp(argv[i], "--endian") == 0)
{
endian = 1;
}
else if (strcmp(argv[i], "--shrink") == 0)
{
vm.shrink = 1;
}
else if (strcmp(argv[i], "--help") == 0)
{
fprintf(stderr, "%s [options] [imagename]\n", argv[0]);
fprintf(stderr, "Valid options are:\n");
fprintf(stderr, " --trace Execution trace\n");
fprintf(stderr, " --endian Load an image with a different endianness\n");
fprintf(stderr, " --shrink Only save used heap during save operation\n");
exit(0);
}
else
{
strcpy(vm.filename, argv[i]);
}
}
/* Load the image */
a = vm_load_image(vm.filename);
/* Swap endian if --endian was passed */
if (endian == 1)
swapEndian();
/* Process the image */
if (trace == 0)
{
for (vm.ip = 0; vm.ip < IMAGE_SIZE; vm.ip++)
{
vm_process(vm.image[vm.ip]);
update_display(0);
}
}
else
{
for (vm.ip = 0; vm.ip < IMAGE_SIZE; vm.ip++)
{
display_instruction();
vm_process(vm.image[vm.ip]);
update_display(0);
}
}
/* Once done, cleanup */
cleanup_devices();
return 0;
}
PRIVATE void compile_main(FILE *conni, FILE *conno) {
REPL_DATA rd = allocmem(sizeof(repl_data));
VMstate vms;
rd->h1 = rd->h2 = NULL;
protect(&rd->h1);
protect(&rd->h2);
rd->vmregs = (VMREGS) newvector(NUM_VMREGS); /* dodgy casting :-) */
vms.r = rd->vmregs;
protect((OBJ *)(&rd->vmregs));
init_vm(&vms);
vms.c.vm_state = VM_STATE_NOQUOTA;
while (vms.c.vm_state != VM_STATE_DYING) {
ScanInst si;
char buf[16384];
rd->h1 = (OBJ) newbvector(0);
while (1) {
char *result;
result = fgets(buf, 256, conni);
if (result == NULL)
break;
while (1) {
int l = strlen(buf);
if (buf[l-1] == '\r' || buf[l-1] == '\n')
buf[l-1] = '\0';
else
break;
}
strcat(buf, "\n");
if (!strcmp(buf, ".\n"))
break;
rd->h2 = (OBJ) newstring(buf);
rd->h1 = (OBJ) bvector_concat((BVECTOR) rd->h1, (BVECTOR) rd->h2);
}
gc_reach_safepoint();
rd->h2 = (OBJ) newstringconn((BVECTOR) rd->h1);
fill_scaninst(&si, (OVECTOR) rd->h2);
while (!conn_closed((OVECTOR) rd->h2)) {
rd->h1 = (OBJ) parse(&vms, &si);
gc_reach_safepoint();
if (rd->h1 == NULL) {
sprintf(buf, "-->! the compiler returned NULL.\n");
} else {
vms.c.vm_state = VM_STATE_NOQUOTA;
ATPUT((OVECTOR) rd->h1, ME_OWNER, (OBJ) vms.r->vm_uid);
vms.r->vm_effuid = vms.r->vm_uid;
{
OVECTOR c = newovector_noinit(CL_MAXSLOTINDEX, T_CLOSURE);
ATPUT(c, CL_SELF, NULL);
ATPUT(c, CL_METHOD, rd->h1);
rd->h1 = (OBJ) c;
}
apply_closure(&vms, (OVECTOR) rd->h1, newvector_noinit(1));
while (!run_vm(&vms)) ;
rd->h1 = (OBJ) newvector(2);
ATPUT((VECTOR) rd->h1, 0, NULL);
ATPUT((VECTOR) rd->h1, 1, vms.r->vm_acc);
rd->h1 = lookup_prim(0x00001, NULL)(&vms, (VECTOR) rd->h1);
rd->h1 = (OBJ) bvector_concat((BVECTOR) rd->h1, newbvector(1));
/* terminates C-string */
gc_reach_safepoint();
sprintf(buf, "--> %s\n", ((BVECTOR) rd->h1)->vec);
}
fputs(buf, conno);
}
}
unprotect((OBJ *)(&rd->vmregs));
unprotect(&rd->h2);
unprotect(&rd->h1);
freemem(rd);
}
