void setup(void) {
bank_init();
set_message("The following commands are available at the bank:\n" +
"\tbalance : Get your balance.\n" +
"\tdeposit # : Deposit # coins in the bank.\n" +
"\twithdraw # : Withdraw # coins from the bank.\n");
}
// main function - no asertions as this shall not crash
int
main( void ) {
bank schalterbank;
bank_init( &schalterbank, 50000.0 );
while( menue_hauptmenue( &schalterbank ) ); //infty-loop, its a "Bank-OS" after all
return 0;
}
// main function - no asertions as this shall not crash
int
main( void ) {
bank schalterbank;
bank_init( &schalterbank, 50000.0 );
//~ signal( SIGINT, menue_programmbeenden() );
while( menue_hauptmenue( &schalterbank ) ); //infty-loop, its a "Bank-OS" after all
//~ signal( SIGINT, SIG_DFL );
return 0;
}
int main(int argc, char *argv[])
{
int continuing = 0;
int count;
int scores_only = 0;
int i;
#ifndef NOGETOPT
while(( i= getopt( argc, argv, "dsh")) != -1)
{
switch (i)
{
case 'd':
#ifdef DEBUG
DG_debug_flag++;
#endif
break;
case 's':
scores_only = 1;
break;
case 'h':
#ifdef DEBUG
printf("Usage: omega [-shd] [savefile]\n");
#else
printf("Usage: omega [-sh] [savefile]\n");
#endif
printf("Options:\n");
printf(" -s Display high score list\n");
printf(" -h Display this message\n");
#ifdef DEBUG
printf(" -d Enable debug mode\n");
#endif
exit(0);
break;
case '?':
/* error parsing args... ignore? */
printf("'%c' is an invalid option, ignoring\n", optopt );
break;
}
}
if (optind >= argc ) {
/* no save file given */
#if defined( BSD ) || defined( SYSV )
sprintf( SaveFileName, "Omega%d", getuid() );
#else
strcpy( SaveFileName,"Omega");
#endif
} else {
/* savefile given */
continuing = 1;
strcpy(SaveFileName,argv[optind]);
}
#else
/* alternate code for people who don't support getopt() -- no enhancement */
if (argc ==2) {
strcpy( SaveFileName, argv[1]);
continuing = 1;
} else {
strcpy( SaveFileName,"Omega");
}
#endif
/* always catch ^c and hang-up signals */
#ifdef SIGINT
signal(SIGINT,signalquit);
#endif
#ifdef SIGHUP
signal(SIGHUP,signalsave);
#endif
#ifndef MSDOS
if (CATCH_SIGNALS) {
signal(SIGQUIT,signalexit);
signal(SIGILL,signalexit);
#ifdef DEBUG
if( DG_debug_flag ) {
#endif
signal(SIGTRAP,signalexit);
signal(SIGFPE,signalexit);
signal(SIGSEGV,signalexit);
#ifdef DEBUG
}
#endif
#ifdef SIGIOT
signal(SIGIOT,signalexit);
#endif
#ifdef SIGABRT
signal(SIGABRT,signalexit);
#endif
#ifdef SIGEMT
signal(SIGEMT,signalexit);
#endif
#ifdef SIGBUS
signal(SIGBUS,signalexit);
#endif
#ifdef SIGSYS
signal(SIGSYS,signalexit);
#endif
}
#endif
#ifndef FIXED_OMEGALIB
if (!(Omegalib = getenv("OMEGALIB")))
#endif
Omegalib = OMEGALIB;
/* if filecheck is 0, some necessary data files are missing */
if (filecheck() == 0) exit(0);
/* all kinds of initialization */
init_perms();
initgraf();
#ifndef MSDOS_SUPPORTED_ANTIQUE
initdirs();
#endif
initrand(E_RANDOM, 0);
initspells();
#ifdef DEBUG
/* initialize debug log file */
DG_debug_log = fopen( "/tmp/omega_dbg_log", "a" );
assert( DG_debug_log ); /* WDT :) */
setvbuf( DG_debug_log, NULL, _IOLBF, 0);
fprintf(DG_debug_log, "############## new game started ##############\n");
#endif
for (count = 0; count < STRING_BUFFER_SIZE; count++)
strcpy(Stringbuffer[count],"<nothing>");
#ifdef SAVE_LEVELS
msdos_init();
#endif
omega_title();
showscores();
if (scores_only ) {
endgraf();
exit(0);
}
/* game restore attempts to restore game if there is an argument */
if (continuing)
{
game_restore(SaveFileName);
mprint("Your adventure continues....");
}
else
{
/* monsters initialized in game_restore if game is being restored */
/* items initialized in game_restore if game is being restored */
inititem(TRUE);
Date = random_range(360);
Phase = random_range(24);
#ifdef NEW_BANK
bank_init();
#else
strcpy(Password,"");
#endif
continuing = initplayer(); /* RM: 04-19-2000 loading patch */
}
if (!continuing)
{
init_world(); /* RM: 04-19-2000 loading patch */
mprint("'?' for help or commandlist, 'Q' to quit.");
}
timeprint();
calc_melee();
if (Current_Environment != E_COUNTRYSIDE)
showroom(Level->site[Player.x][Player.y].roomnumber);
else
terrain_check(FALSE);
if (optionp(SHOW_COLOUR))
colour_on();
else
colour_off();
screencheck(Player.x,Player.y);
/* game cycle */
if (!continuing)
time_clock(TRUE);
while (TRUE) {
if (Current_Environment == E_COUNTRYSIDE)
p_country_process();
else time_clock(FALSE);
}
}
int main(int argc, char **argv) {
disnes_cfg_t *cfg = disnes_cfg_init(argc, argv);
FILE *in;
if(NULL == (in = fopen(cfg->rom, "rb"))) {
LOG_ERROR("disnes - cannot open input rom file %s.", cfg->rom);
return 1;
}
// creating output filename from input file
int out_length;
char out_filename[256] = {0};
out_length = snprintf(out_filename, 256, "%s", cfg->rom);
char *end = &out_filename[out_length];
while(end && *(--end) != '.') ;
if(end) {
*end = '\0';
out_length = strlen(out_filename);
}
u_int8_t page[cfg->bank_size];
ines_t header;
// loading header
ines_load(&header, in);
// covering banks
for(bank_no = 0; bank_no < BANK_LIST_SIZE; bank_no++) {
if(!cfg->banks[bank_no])
continue;
// skipping header
fseek(in, 0x10 + (bank_no * cfg->bank_size), SEEK_SET);
// reading one page
fread(page, sizeof(u_int8_t), cfg->bank_size, in);
// loading bank
bank_t *bank = bank_init();
bank_set_start_address(bank, cfg->bank_addr);
bank_load(bank, page, cfg->bank_size);
fprintf_data_t d = {
rom_fprintf,
basename(cfg->rom),
NULL,
NULL
};
snprintf(&out_filename[out_length], 256 - out_length, "_bank_%02X.6502", bank_no);
FILE *out;
LOG_DEBUG("disnes - opening output file %s...", out_filename);
if(NULL == (out = fopen(out_filename, "wt"))) {
LOG_ERROR("disnes - cannot open output file %s.", out_filename);
break;
}
// printing bank disassembled
ines_fprintf(out, &header, &d);
bank_fprintf(out, bank);
fclose(out);
bank_destroy(bank);
}
fclose(in);
disnes_cfg_uinit(cfg);
return 0;
}
int CALLBACK
WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR command_line, int show_code)
{
static Bank s_stack = {0};
static Bank s_storage = {0};
static Core s_core = {0};
static Bitmap s_canvas = {0};
WNDCLASSA window_class = {0};
u32 *window_buffer = NULL;
BITMAPINFO window_bmi = {0};
if (align_to(CANVAS_WIDTH, 16) != CANVAS_WIDTH) {
printf("CANVAS_WIDTH must be aligned to 16.\n");
return 1;
}
CORE = &s_core;
CORE->running = 1;
CORE->stack = &s_stack;
CORE->storage = &s_storage;
bank_init(CORE->stack, STACK_CAPACITY);
bank_init(CORE->storage, STORAGE_CAPACITY);
// TODO: Push canvas to storage? Storage is not initialized yet, so we cannot push it there.
CORE->canvas = &s_canvas;
bitmap_init(CORE->canvas, CANVAS_WIDTH, CANVAS_HEIGHT, 0, 0);
bitmap_clear(CORE->canvas, COLOR_TRANSPARENT);
clip_reset();
CORE->audio_volume = PUNP_SOUND_DEFAULT_MASTER_VOLUME;
//
//
//
punp_win32_instance = instance;
QueryPerformanceFrequency((LARGE_INTEGER *)&punp_win32_perf_counter_frequency);
// b32 sleep_is_granular = (timeBeginPeriod(1 /*ms*/) == TIMERR_NOERROR);
#ifndef RELEASE_BUILD
printf("Debug build...");
if (AttachConsole(ATTACH_PARENT_PROCESS) || AllocConsole()) {
freopen("CONOUT$", "w", stdout);
freopen("CONOUT$", "w", stderr);
}
#else
printf("Release build...");
#endif
window_class.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
window_class.lpfnWndProc = win32_window_callback;
window_class.hInstance = punp_win32_instance;
// window_class.hIcon = (HICON)LoadImage(0, "icon.ico", IMAGE_ICON, 0, 0, LR_LOADFROMFILE | LR_DEFAULTSIZE | LR_SHARED);
window_class.hIcon = (HICON)LoadIcon(instance, "icon.ico");
window_class.hCursor = LoadCursor(0, IDC_ARROW);
window_class.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
window_class.lpszClassName = "Punity";
if (!RegisterClassA(&window_class)) {
printf("RegisterClassA failed.\n");
return 1;
}
{
int screen_width = GetSystemMetrics(SM_CXSCREEN);
int screen_height = GetSystemMetrics(SM_CYSCREEN);
RECT rc;
DWORD style = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
rc.left = (screen_width - (PUNP_WINDOW_WIDTH)) / 2;
rc.top = (screen_height - (PUNP_WINDOW_HEIGHT)) / 2;
rc.right = rc.left + PUNP_WINDOW_WIDTH;
rc.bottom = rc.top + PUNP_WINDOW_HEIGHT;
ASSERT(AdjustWindowRect(&rc, style, FALSE) != 0);
// int window_width = rc.right - rc.left;
// int window_height = rc.bottom - rc.top;
// rc.left = (screen_width - width) / 2;
// rc.top = (screen_height - height) / 2;
punp_win32_window = CreateWindowExA(
0,
window_class.lpszClassName,
WINDOW_TITLE,
style,
rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top,
0, 0,
punp_win32_instance,
0);
}
if (!punp_win32_window) {
printf("CreateWindowExA failed.\n");
return 1;
}
// Canvas
window_bmi.bmiHeader.biSize = sizeof(window_bmi.bmiHeader);
window_bmi.bmiHeader.biWidth = CANVAS_WIDTH;
window_bmi.bmiHeader.biHeight = CANVAS_HEIGHT;
window_bmi.bmiHeader.biPlanes = 1;
window_bmi.bmiHeader.biBitCount = 32;
window_bmi.bmiHeader.biCompression = BI_RGB;
window_buffer = (u32 *)bank_push(CORE->stack, (CANVAS_WIDTH * 4) * CANVAS_HEIGHT);
ASSERT(window_buffer);
// Sound
if (punp_win32_sound_init() == 0) {
punp_win32_audio_buffer = 0;
}
init();
// TODO: Center window
ShowWindow(punp_win32_window, SW_SHOW);
{
f64 frame_time_stamp, frame_time_now, frame_time_delta;
int x, y;
u32 *window_row;
u8 *canvas_it;
MSG message;
perf_from(&CORE->perf_frame);
while (CORE->running) {
perf_to(&CORE->perf_frame);
perf_from(&CORE->perf_frame_inner);
memset(&CORE->key_deltas, 0, KEYS_MAX);
while (PeekMessage(&message, 0, 0, 0, PM_REMOVE)) {
if (message.message == WM_QUIT) {
CORE->running = 0;
}
TranslateMessage(&message);
DispatchMessageA(&message);
}
perf_from(&CORE->perf_step);
step();
perf_to(&CORE->perf_step);
perf_from(&CORE->perf_audio);
if (punp_win32_audio_buffer) {
punp_win32_sound_step();
}
perf_to(&CORE->perf_audio);
perf_from(&CORE->perf_blit);
perf_from(&CORE->perf_blit_cvt);
canvas_it = CORE->canvas->pixels;
for (y = CANVAS_HEIGHT; y != 0; --y) {
window_row = window_buffer + ((y - 1) * CANVAS_WIDTH);
for (x = 0; x != CANVAS_WIDTH; ++x) {
*(window_row++) = CORE->palette.colors[*canvas_it++].rgba;
}
}
perf_to(&CORE->perf_blit_cvt);
perf_from(&CORE->perf_blit_gdi);
{
HDC dc = GetDC(punp_win32_window);
#if 1
// TODO: This is sadly slow (50us on my machine), need to find a faster way to do this.
StretchDIBits(dc,
0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE,
0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
window_buffer,
&window_bmi,
DIB_RGB_COLORS,
SRCCOPY);
#else
#endif
ReleaseDC(punp_win32_window, dc);
}
perf_to(&CORE->perf_blit_gdi);
perf_to(&CORE->perf_blit);
perf_to(&CORE->perf_frame_inner);
{
f32 frame_delta = perf_delta(&CORE->perf_frame);
if (frame_delta < PUNP_FRAME_TIME) {
// printf("sleeping ... %.3f\n", (f32)PUNP_FRAME_TIME - frame_delta);
Sleep((PUNP_FRAME_TIME - frame_delta) * 1e3);
}
}
CORE->frame++;
#if 0
printf("stack %d storage %d\n",
CORE->stack->it - CORE->stack->begin,
CORE->storage->it - CORE->storage->begin);
#endif
}
}
#if PUNP_SOUND_DEBUG_FILE
fclose(punp_audio_buf_file);
#endif
return 0;
}
void
kernel_bootstrap(void)
{
kern_return_t result;
thread_t thread;
char namep[16];
printf("%s\n", version); /* log kernel version */
if (PE_parse_boot_argn("-l", namep, sizeof (namep))) /* leaks logging */
turn_on_log_leaks = 1;
PE_parse_boot_argn("trace", &new_nkdbufs, sizeof (new_nkdbufs));
PE_parse_boot_argn("trace_wake", &wake_nkdbufs, sizeof (wake_nkdbufs));
PE_parse_boot_argn("trace_panic", &write_trace_on_panic, sizeof(write_trace_on_panic));
PE_parse_boot_argn("trace_typefilter", &trace_typefilter, sizeof(trace_typefilter));
scale_setup();
kernel_bootstrap_log("vm_mem_bootstrap");
vm_mem_bootstrap();
kernel_bootstrap_log("cs_init");
cs_init();
kernel_bootstrap_log("vm_mem_init");
vm_mem_init();
machine_info.memory_size = (uint32_t)mem_size;
machine_info.max_mem = max_mem;
machine_info.major_version = version_major;
machine_info.minor_version = version_minor;
#if CONFIG_TELEMETRY
kernel_bootstrap_log("telemetry_init");
telemetry_init();
#endif
#if CONFIG_CSR
kernel_bootstrap_log("csr_init");
csr_init();
#endif
kernel_bootstrap_log("stackshot_lock_init");
stackshot_lock_init();
kernel_bootstrap_log("sched_init");
sched_init();
kernel_bootstrap_log("waitq_bootstrap");
waitq_bootstrap();
kernel_bootstrap_log("ipc_bootstrap");
ipc_bootstrap();
#if CONFIG_MACF
kernel_bootstrap_log("mac_policy_init");
mac_policy_init();
#endif
kernel_bootstrap_log("ipc_init");
ipc_init();
/*
* As soon as the virtual memory system is up, we record
* that this CPU is using the kernel pmap.
*/
kernel_bootstrap_log("PMAP_ACTIVATE_KERNEL");
PMAP_ACTIVATE_KERNEL(master_cpu);
kernel_bootstrap_log("mapping_free_prime");
mapping_free_prime(); /* Load up with temporary mapping blocks */
kernel_bootstrap_log("machine_init");
machine_init();
kernel_bootstrap_log("clock_init");
clock_init();
ledger_init();
/*
* Initialize the IPC, task, and thread subsystems.
*/
#if CONFIG_COALITIONS
kernel_bootstrap_log("coalitions_init");
coalitions_init();
#endif
kernel_bootstrap_log("task_init");
task_init();
kernel_bootstrap_log("thread_init");
thread_init();
#if CONFIG_ATM
/* Initialize the Activity Trace Resource Manager. */
kernel_bootstrap_log("atm_init");
atm_init();
#endif
#if CONFIG_BANK
/* Initialize the BANK Manager. */
kernel_bootstrap_log("bank_init");
bank_init();
#endif
/* initialize the corpse config based on boot-args */
corpses_init();
/*
* Create a kernel thread to execute the kernel bootstrap.
*/
kernel_bootstrap_log("kernel_thread_create");
result = kernel_thread_create((thread_continue_t)kernel_bootstrap_thread, NULL, MAXPRI_KERNEL, &thread);
if (result != KERN_SUCCESS) panic("kernel_bootstrap: result = %08X\n", result);
thread->state = TH_RUN;
thread->last_made_runnable_time = mach_absolute_time();
thread_deallocate(thread);
kernel_bootstrap_log("load_context - done");
load_context(thread);
/*NOTREACHED*/
}
