Mercurial > repos > blastem
view menu.c @ 1363:df6af7187b36
Fix to M68K interrupt latency for most instructions. Still needs some work for RAW_IMPL instructions besides move
author | Michael Pavone <pavone@retrodev.com> |
---|---|
date | Fri, 19 May 2017 20:27:35 -0700 |
parents | 071e761bcdcf |
children | e6efe6b2aee9 |
line wrap: on
line source
#include <stdint.h> #include <stdlib.h> #include <string.h> #include <stdio.h> #include <errno.h> #include "genesis.h" #include "menu.h" #include "backend.h" #include "util.h" #include "gst.h" #include "m68k_internal.h" //needed for get_native_address_trans, should be eliminated once handling of PC is cleaned up uint16_t menu_read_w(uint32_t address, void * context) { //This should return the status of the last request with 0 //meaning either the request is complete or no request is pending //in the current implementation, the operations happen instantly //in emulated time so we can always return 0 return 0; } int menu_dir_sort(const void *a, const void *b) { const dir_entry *da, *db; da = a; db = b; if (da->is_dir != db->is_dir) { return db->is_dir - da->is_dir; } return strcasecmp(((dir_entry *)a)->name, ((dir_entry *)b)->name); } void copy_string_from_guest(m68k_context *m68k, uint32_t guest_addr, char *buf, size_t maxchars) { char *cur; char *src = NULL; for (cur = buf; cur < buf+maxchars; cur+=2, guest_addr+=2, src+=2) { if (!src || !(guest_addr & 0xFFFF)) { //we may have walked off the end of a memory block, get a fresh native pointer src = get_native_pointer(guest_addr, (void **)m68k->mem_pointers, &m68k->options->gen); if (!src) { break; } } *cur = src[1]; cur[1] = *src; if (!*src || !src[1]) { break; } } //make sure we terminate the string even if we did not hit a null terminator in the source buf[maxchars-1] = 0; } void copy_to_guest(m68k_context *m68k, uint32_t guest_addr, char *src, size_t tocopy) { char *dst = NULL; for (char *cur = src; cur < src+tocopy; cur+=2, guest_addr+=2, dst+=2) { if (!dst || !(guest_addr & 0xFFFF)) { //we may have walked off the end of a memory block, get a fresh native pointer dst = get_native_pointer(guest_addr, (void **)m68k->mem_pointers, &m68k->options->gen); if (!dst) { break; } } dst[1] = *cur; *dst = cur[1]; } } #define SAVE_INFO_BUFFER_SIZE (11*40) #ifdef __ANDROID__ #include <SDL.h> #include <jni.h> char *get_external_storage_path() { static char *ret; if (ret) { return ret; } JNIEnv *env = SDL_AndroidGetJNIEnv(); if ((*env)->PushLocalFrame(env, 8) < 0) { return NULL; } jclass Environment = (*env)->FindClass(env, "android/os/Environment"); jmethodID getExternalStorageDirectory = (*env)->GetStaticMethodID(env, Environment, "getExternalStorageDirectory", "()Ljava/io/File;"); jobject file = (*env)->CallStaticObjectMethod(env, Environment, getExternalStorageDirectory); if (!file) { goto cleanup; } jmethodID getAbsolutePath = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, file), "getAbsolutePath", "()Ljava/lang/String;"); jstring path = (*env)->CallObjectMethod(env, file, getAbsolutePath); char const *tmp = (*env)->GetStringUTFChars(env, path, NULL); ret = strdup(tmp); (*env)->ReleaseStringUTFChars(env, path, tmp); cleanup: (*env)->PopLocalFrame(env, NULL); return ret; } #endif #ifdef _WIN32 #define localtime_r(a,b) localtime(a) //windows inclues seem not to like certain single letter defines from m68k_internal.h //get rid of them here #undef X #undef N #undef Z #undef V #undef C #include <windows.h> #endif uint32_t copy_dir_entry_to_guest(uint32_t dst, m68k_context *m68k, char *name, uint8_t is_dir) { uint8_t *dest = get_native_pointer(dst, (void **)m68k->mem_pointers, &m68k->options->gen); if (!dest) { return 0; } *(dest++) = is_dir; *(dest++) = 1; dst += 2; uint8_t term = 0; for (char *cpos = name; *cpos; cpos++) { dest[1] = *cpos; dest[0] = cpos[1]; if (cpos[1]) { cpos++; } else { term = 1; } dst += 2; if (!(dst & 0xFFFF)) { //we may have walked off the end of a memory block, get a fresh native pointer dest = get_native_pointer(dst, (void **)m68k->mem_pointers, &m68k->options->gen); if (!dest) { break; } } else { dest += 2; } } if (!term) { *(dest++) = 0; *dest = 0; dst += 2; } return dst; } void * menu_write_w(uint32_t address, void * context, uint16_t value) { m68k_context *m68k = context; genesis_context *gen = m68k->system; menu_context *menu = gen->extra; if (!menu) { gen->extra = menu = calloc(1, sizeof(menu_context)); menu->curpath = tern_find_path(config, "ui\0initial_path\0", TVAL_PTR).ptrval; if (!menu->curpath){ #ifdef __ANDROID__ menu->curpath = get_external_storage_path(); #else menu->curpath = "$HOME"; #endif } tern_node *vars = tern_insert_ptr(NULL, "HOME", get_home_dir()); vars = tern_insert_ptr(vars, "EXEDIR", get_exe_dir()); menu->curpath = replace_vars(menu->curpath, vars, 1); tern_free(vars); } if (menu->state) { uint32_t dst = menu->latch << 16 | value; switch (address >> 2) { case 0: { #ifdef _WIN32 //handle virtual "drives" directory if (menu->curpath[0] == PATH_SEP[0]) { char drivestrings[4096]; if (sizeof(drivestrings) >= GetLogicalDriveStrings(sizeof(drivestrings), drivestrings)) { for (char *cur = drivestrings; *cur; cur += strlen(cur) + 1) { dst = copy_dir_entry_to_guest(dst, m68k, cur, 1); } } //terminate list uint8_t *dest = get_native_pointer(dst, (void **)m68k->mem_pointers, &m68k->options->gen); if (dest) { *dest = dest[1] = 0; } break; } #endif size_t num_entries; dir_entry *entries = get_dir_list(menu->curpath, &num_entries); if (entries) { qsort(entries, num_entries, sizeof(dir_entry), menu_dir_sort); } else { warning("Failed to open directory %s: %s\n", menu->curpath, strerror(errno)); entries = malloc(sizeof(dir_entry)); entries->name = strdup(".."); entries->is_dir = 1; num_entries = 1; } #ifdef _WIN32 if (menu->curpath[1] == ':' && !menu->curpath[2]) { //Add fake .. entry to allow navigation to virtual "drives" directory dst = copy_dir_entry_to_guest(dst, m68k, "..", 1); } #endif for (size_t i = 0; dst && i < num_entries; i++) { dst = copy_dir_entry_to_guest(dst, m68k, entries[i].name, entries[i].is_dir); } //terminate list uint8_t *dest = get_native_pointer(dst, (void **)m68k->mem_pointers, &m68k->options->gen); if (dest) { *dest = dest[1] = 0; } free_dir_list(entries, num_entries); break; } case 1: { char buf[4096]; copy_string_from_guest(m68k, dst, buf, sizeof(buf)); if (!strcmp(buf, "..")) { #ifdef _WIN32 if (menu->curpath[1] == ':' && !menu->curpath[2]) { menu->curpath[0] = PATH_SEP[0]; menu->curpath[1] = 0; break; } #endif size_t len = strlen(menu->curpath); while (len > 0) { --len; if (is_path_sep(menu->curpath[len])) { if (!len) { //special handling for / menu->curpath[len+1] = 0; } else { menu->curpath[len] = 0; } break; } } } else { char *tmp = menu->curpath; #ifdef _WIN32 if (menu->curpath[0] == PATH_SEP[0] && !menu->curpath[1]) { menu->curpath = strdup(buf); } else #endif if (is_path_sep(menu->curpath[strlen(menu->curpath) - 1])) { menu->curpath = alloc_concat(menu->curpath, buf); } else { char const *pieces[] = {menu->curpath, PATH_SEP, buf}; menu->curpath = alloc_concat_m(3, pieces); } free(tmp); } break; } case 2: { char buf[4096]; copy_string_from_guest(m68k, dst, buf, sizeof(buf)); char const *pieces[] = {menu->curpath, PATH_SEP, buf}; gen->header.next_rom = alloc_concat_m(3, pieces); m68k->should_return = 1; break; } case 3: { switch (dst) { case 1: m68k->should_return = 1; gen->header.should_exit = 1; break; case 2: m68k->should_return = 1; break; } break; } case 4: { char *buffer = malloc(SAVE_INFO_BUFFER_SIZE); char *cur = buffer; if (gen->header.next_context && gen->header.next_context->save_dir) { char *end = buffer + SAVE_INFO_BUFFER_SIZE; char slotfile[] = "slot_0.gst"; char const * parts[3] = {gen->header.next_context->save_dir, PATH_SEP, slotfile}; struct tm ltime; char *fname; time_t modtime; for (int i = 0; i < 10 && cur < end; i++) { slotfile[5] = i + '0'; fname = alloc_concat_m(3, parts); modtime = get_modification_time(fname); free(fname); if (modtime) { cur += snprintf(cur, end-cur, "Slot %d - ", i); cur += strftime(cur, end-cur, "%c", localtime_r(&modtime, <ime)); } else { cur += snprintf(cur, end-cur, "Slot %d - EMPTY", i); } //advance past the null terminator for this entry cur++; } if (cur < end) { parts[2] = "quicksave.gst"; fname = alloc_concat_m(3, parts); modtime = get_modification_time(fname); free(fname); if (modtime) { cur += strftime(cur, end-cur, "Quick - %c", localtime_r(&modtime, <ime)); } else if ((end-cur) > strlen("Quick - EMPTY")){ cur += strlen(strcpy(cur, "Quick - EMPTY")); } //advance past the null terminator for this entry cur++; if (cur < end) { //terminate the list *(cur++) = 0; } } } else { *(cur++) = 0; *(cur++) = 0; } copy_to_guest(m68k, dst, buffer, cur-buffer); break; case 5: //save state if (gen->header.next_context) { gen->header.next_context->save_state = dst + 1; } m68k->should_return = 1; break; case 6: //load state if (gen->header.next_context && gen->header.next_context->save_dir) { char numslotname[] = "slot_0.gst"; char *slotname; if (dst == QUICK_SAVE_SLOT) { slotname = "quicksave.gst"; } else { numslotname[5] = '0' + dst; slotname = numslotname; } char const *parts[] = {gen->header.next_context->save_dir, PATH_SEP, slotname}; char *gstpath = alloc_concat_m(3, parts); genesis_context *next = (genesis_context *)gen->header.next_context; uint32_t pc = load_gst(next, gstpath); free(gstpath); if (!pc) { break; } next->m68k->resume_pc = get_native_address_trans(next->m68k, pc); } m68k->should_return = 1; break; } default: fprintf(stderr, "WARNING: write to undefined menu port %X\n", address); } menu->state = 0; } else { menu->latch = value; menu->state = 1; } if (m68k->should_return) { m68k->target_cycle = m68k->current_cycle; } return context; }