static void save_sample_config ( const char *name )
{
#ifdef __EMSCRIPTEN__
DEBUGPRINT("CONFIG: no configuration is saved in case of emscripten." NL);
#else
char path[PATH_MAX + 1];
FILE *f = open_emu_file(name, "r", path);
if (f) {
fclose(f);
DEBUGPRINT("CONFIG: sample configuration %s (%s) already exists, skipping to create." NL, name, path);
return;
}
f = open_emu_file(name, "w", path);
if (f) {
dump_config(f);
fclose(f);
INFO_WINDOW("Note: created sample config file %s", path);
} else
INFO_WINDOW("Note: cannot create sample config file %s", path);
#endif
}
/* SDEXT emulation currently excepts the cartridge area (segments 4-7) to be filled
* with the FLASH ROM content. Even segment 7, which will be copied to the second 64K "hidden"
* and pagable flash area of the SD cartridge. Currently, there is no support for the full
* sized SDEXT flash image */
void sdext_init ( void )
{
/* try to detect SDEXT ROM extension and only turn on emulation if it exists */
if (sdext_detect_rom()) {
WARNING_WINDOW("No SD-card cartridge ROM code found in loaded ROM set. SD card hardware emulation has been disabled!");
*sdimg_path = 0;
sdf = NULL;
SD_DEBUG("SDEXT: init: REFUSE: no SD-card cartridge ROM code found in loaded ROM set." NL);
return;
}
SD_DEBUG("SDEXT: init: cool, SD-card cartridge ROM code seems to be found in loaded ROM set, enabling SD card hardware emulation ..." NL);
sdf = open_emu_file(config_getopt_str("sdimg"), "rb", sdimg_path); // open in read-only mode, to get the path
if (sdf) {
fclose(sdf);
sdf = fopen(sdimg_path, "r+b");
if (sdf) {
DEBUGPRINT("SDEXT: SD image file is re-open in read/write mode, good (fd=%d)." NL, fileno(sdf));
} else {
sdf = fopen(sdimg_path, "rb");
DEBUGPRINT("SDEXT: SD image cannot be re-open in read-write mode, using read-only access (fd=%d)." NL, fileno(sdf));
}
}
if (!sdf) {
WARNING_WINDOW("SD card image file \"%s\" cannot be open: %s. You can use Xep128 but SD card access won't work!", sdimg_path, ERRSTR());
*sdimg_path = 0;
} else {
sdfd = fileno(sdf);
sd_card_size = lseek(sdfd, 0, SEEK_END);
SD_DEBUG("SDEXT: SD card size is: %ld bytes" NL, sd_card_size);
if (sd_card_size > MAX_CARD_SIZE || sd_card_size < MIN_CARD_SIZE) {
fclose(sdf);
sdf = NULL;
ERROR_WINDOW("SD card image file \"%s\" is too small or large, valid range is %ld - %ld Mbytes, but this one is %ld bytes long (about %ld Mbytes). SD access has been disabled!",
sdimg_path, MIN_CARD_SIZE >> 20, MAX_CARD_SIZE >> 20,
sd_card_size, sd_card_size >> 20
);
*sdimg_path = 0;
}
}
int config_init ( int argc, char **argv )
{
const char *config_name = DEFAULT_CONFIG_FILE; // name of the used config file, can be overwritten via CLI
const struct configOption_st *opt;
const char *exe = argv[0];
int default_config = 1;
int testparsing = 0;
argc--; argv++;
#ifdef __EMSCRIPTEN__
exe = strdup("/files/emscripten-virtual-executable");
#endif
#ifdef _WIN32
console_open_window();
#endif
SDL_VERSION(&sdlver_compiled);
SDL_GetVersion(&sdlver_linked);
if (sdlver_linked.major < 2 || (sdlver_linked.minor == 0 && sdlver_linked.patch < 4)) {
ERROR_WINDOW("Too old SDL library linked, at least version 2.0.4 is required.");
return 1;
}
/* SDL info on paths */
if (get_path_info())
return 1;
/* ugly hack: pre-parse comand line to find debug statement (to be worse, it does not handle single argument options too well ... */
#ifdef DISABLE_DEBUG
printf("DEBUG: disabled at compilation time." NL);
#else
while (testparsing < argc) {
if (!strcmp(argv[testparsing], "-" DEBUGFILE_OPT) && testparsing != argc - 1 && strcmp(argv[testparsing + 1], "none")) {
debug_fp = fopen(argv[testparsing + 1], "w");
DEBUGPRINT("DEBUG: enable logging into file: %s" NL, argv[testparsing + 1]);
if (debug_fp == NULL)
fprintf(stderr, "Cannot open debug logging file: %s" NL, argv[testparsing + 1]);
break;
}
testparsing++;
}
testparsing = 0;
#endif
/* end of ugly hack */
/* let's continue with the info block ... */
DEBUGPRINT("%s %s v%s %s %s" NL
"GIT %s compiled by (%s) at (%s) with (%s)-(%s)" NL
"Platform: (%s) (%d-bit), video: (%s), audio: (%s), "
"SDL version compiled: (%d.%d.%d) and linked: (%d.%d.%d) rev (%s)" NL NL,
WINDOW_TITLE, DESCRIPTION, VERSION, COPYRIGHT, PROJECT_PAGE,
XEMU_BUILDINFO_GIT, XEMU_BUILDINFO_ON, XEMU_BUILDINFO_AT, CC_TYPE, XEMU_BUILDINFO_CC,
SDL_GetPlatform(), ARCH_BITS, SDL_GetCurrentVideoDriver(), SDL_GetCurrentAudioDriver(),
sdlver_compiled.major, sdlver_compiled.minor, sdlver_compiled.patch,
sdlver_linked.major, sdlver_linked.minor, sdlver_linked.patch, SDL_GetRevision()
);
DEBUGPRINT("PATH: executable: %s" NL, exe);
/* SDL path info block printout */
DEBUGPRINT("PATH: SDL base path: %s" NL, app_base_path);
DEBUGPRINT("PATH: SDL pref path: %s" NL, app_pref_path);
#ifndef _WIN32
DEBUGPRINT("PATH: data directory: %s/" NL, DATADIR);
#endif
DEBUGPRINT("PATH: Current directory: %s" NL NL, current_directory);
/* Look the very basic command line switches first */
if (argc && is_help_request_option(argv[0])) {
opt = configOptions;
printf("USAGE:" NL NL
"\t%s -optname optval -optname2 optval2 ..." NL NL "OPTIONS:" NL NL
"-config" NL "\tUse config file (or do not use the default one, if \"none\" is specified). This must be the first option if used! [default: @config]" NL,
exe
);
while (opt->name) {
printf("-%s" NL "\t%s [default: %s]" NL, opt->name, opt->help, opt->defval ? opt->defval : "-");
opt++;
}
printf(NL "%s" NL, disclaimer);
#ifdef _WIN32
if (!console_is_open)
ERROR_WINDOW("Could not dump help, since console couldn't be allocated.");
#endif
XEMUEXIT(0);
}
DEBUGPRINT("%s" NL NL, disclaimer);
if (argc && !strcasecmp(argv[0], "-testparsing")) {
testparsing = 1;
argc--; argv++;
}
if (argc & 1) {
fprintf(stderr, "FATAL: Bad command line: should be even number of parameters (two for an option as key and its value)" NL);
return 1;
}
if (argc > 1 && !strcmp(argv[0], "-config")) {
default_config = 0;
config_name = argv[1];
argc -= 2;
argv += 2;
}
/* Set default (built-in) values */
opt = configOptions;
while (opt->name) {
if (opt->defval)
config_set_internal(opt->name, -1, opt->defval);
opt++;
}
config_set_internal("rom", 0, COMBINED_ROM_FN); // set default "combined" ROM image set (from segment 0, starting with EXOS)
/* Default values for the keyboard follows ... */
keymap_preinit_config_internal();
/* check if we have written sample config file, if there is not, let's create one */
save_sample_config(DEFAULT_CONFIG_SAMPLE_FILE);
/* now parse config file (not the sample one!) if there is any */
if (strcasecmp(config_name, "none")) {
char path[PATH_MAX + 1];
FILE *f = open_emu_file(config_name, "r", path);
DEBUGPRINT("CONFIG: config file: %s (%s)" NL, config_name, f ? path : "*** CANNOT OPEN, NOT USING CONFIG FILE ***");
if (f) {
if (load_config_file_stream(f, path)) {
fclose(f);
return 1;
}
fclose(f);
} else if (!default_config) {
fprintf(stderr, "FATAL: Cannot open requested config file: %s" NL, config_name);
return 1;
} else
DEBUGPRINT("CONFIG: Skipping default config file (cannot open), using built-in defaults." NL);
} else
DEBUGPRINT("CONFIG: Using config file: DISABLED in command line" NL);
/* parse command line ... */
if (parse_command_line(argc, argv))
return -1;
/* open debug file, if it was not requested via command line at the beginning ... */
if (!debug_fp && strcmp(config_getopt_str(DEBUGFILE_OPT), "none")) {
debug_fp = fopen(config_getopt_str(DEBUGFILE_OPT), "w");
DEBUGPRINT("DEBUG: enable logging into file: %s" NL, config_getopt_str(DEBUGFILE_OPT));
if (!debug_fp)
ERROR_WINDOW("Cannot open debug messages log file requested: %s", config_getopt_str(DEBUGFILE_OPT));
}
if (debug_fp)
INFO_WINDOW("DEBUG: Debug messages logging is active");
else
printf("DEBUG: No debug messages logging is active." NL);
/* test parsing mode? */
if (testparsing) {
printf(NL "--- TEST DUMP OF *PARSED* CONFIGURATION (requested)" NL NL);
dump_config(stdout);
printf(NL "--- END OF TEST PARSING MODE (requested)" NL);
XEMUEXIT(0);
}
DEBUG("CONFIG: End of configuration step." NL NL);
/* Close console, unless user requested it with the -console option */
#ifdef _WIN32
if (!config_getopt_int("console"))
console_close_window();
#else
if (config_getopt_int("console"))
console_open_window(); // on non-windows, it only will mark console as open for monitor to be used ..
#endif
return 0;
}
/* This function also re-initializes the whole memory! Do not call it after you defined RAM for the system, but only before! */
int roms_load ( void )
{
int seg, last = 0;
char path[PATH_MAX + 1];
if (reloading) // in case of already defined (reloading) memory model, we want to back our SRAM segments up - if any at all ...
sram_save_all_segments();
for (seg = 0; seg < 0x100; seg++ ) {
memory_segment_map[seg] = (seg >= 0xFC ? VRAM_SEGMENT : UNUSED_SEGMENT); // 64K VRAM is default, you cannot override that!
if (reloading && rom_name_tab[seg])
free((void*)rom_name_tab[seg]); // already defined (reloading) situation, we want to free used memory as well
rom_name_tab[seg] = NULL;
}
reloading = 1; // set reloading flag, in next invocation of roms_load(), it will be done in config reload mode!
memset(memory, 0xFF, 0x400000);
xep_rom_seg = -1;
for (seg = 0; seg < 0x100; seg++ ) {
void *option = config_getopt("rom", seg, NULL);
if (option) {
const char *name;
int lseg = seg;
FILE *f;
config_getopt_pointed(option, &name);
if (!strcasecmp(name, "XEP") && seg) {
if (memory_segment_map[seg] == UNUSED_SEGMENT) {
DEBUG("CONFIG: ROM: segment %02Xh assigned to internal XEP ROM" NL, seg);
xep_rom_seg = seg;
memory_segment_map[seg] = XEPROM_SEGMENT;
} else
ERROR_WINDOW("XEP ROM forced segment assignment cannot be done since segment %02X is not unused", seg);
continue;
}
DEBUG("CONFIG: ROM: segment %02Xh file %s" NL, seg, name);
f = open_emu_file(name, "rb", path);
if (f == NULL) {
ERROR_WINDOW("Cannot open ROM image \"%s\" (to be used from segment %02Xh): %s", name, seg, ERRSTR());
if (!strcmp(name, COMBINED_ROM_FN)) { // this should be the auto-install functionality, with downloading stuff?
}
return -1;
}
DEBUG("CONFIG: ROM: ... file path is %s" NL, path);
rom_name_tab[seg] = SDL_strdup(path);
CHECK_MALLOC(rom_name_tab[seg]);
for (;;) {
int ret;
// Note: lseg overflow is not needed to be tested, as VRAM marks will stop reading of ROM image in the worst case ...
if (memory_segment_map[lseg] != UNUSED_SEGMENT) {
fclose(f);
forget_emu_file(path);
ERROR_WINDOW("While reading ROM image \"%s\" into segment %02Xh: already used segment (\"%s\")!", path, lseg, memory_segment_map[lseg]);
return -1;
}
ret = fread(memory + (lseg << 14), 1, 0x4000, f);
if (ret)
DEBUG("CONFIG: ROM: ... trying read 0x4000 bytes in segment %02Xh, result is %d" NL, lseg, ret);
if (ret < 0) {
ERROR_WINDOW("Cannot read ROM image \"%s\" (to be used in segment %02Xh): %s", path, lseg, ERRSTR());
fclose(f);
forget_emu_file(path);
return -1;
} else if (ret == 0) {
if (lseg == seg) {
fclose(f);
forget_emu_file(path);
ERROR_WINDOW("Null-sized ROM image \"%s\" (to be used in segment %02Xh).", path, lseg);
return -1;
}
break;
} else if (ret != 0x4000) {
fclose(f);
forget_emu_file(path);
ERROR_WINDOW("Bad ROM image \"%s\": not multiple of 16K bytes!", path);
return -1;
}
// check if ROM image contains XEP128_ROM segment signature, if so, try to use XEP ROM from here
if (!memcmp(memory + (lseg << 14), "XEP__ROM", 8) && xep_rom_seg == -1) {
xep_rom_seg = lseg;
memory_segment_map[lseg] = XEPROM_SEGMENT;
} else
memory_segment_map[lseg] = ROM_SEGMENT;
if (lseg > last)
last = lseg;
if (ret != 0x4000)
break;
lseg++;
}
fclose(f);
forget_emu_file(path);
} else if (!seg) {
ERROR_WINDOW("Fatal ROM image error: No ROM defined for segment 00h, no EXOS is requested!");
return -1;
}
}
/* XEP ROM: guess where to place it, or disable it ... */
if (config_getopt_int("xeprom")) {
// XEP ROM is enabled with 'xeprom' directive
if (xep_rom_seg == -1) { // not assigned manually, try to find a place for it ...
xep_rom_seg = last + 1; // ... with simply using the segment after the last used ROM segment
DEBUGPRINT("CONFIG: ROM: automatic XEP ROM image placer selected segment is %02Xh" NL, xep_rom_seg);
}
} else {
// XEP ROM is disabled (with 'xeprom' directive), _IF_ it was not assigned manually
if (xep_rom_seg == -1) {
DEBUGPRINT("CONFIG: ROM: XEP ROM is disabled by configuration!" NL);
INFO_WINDOW("XEP internal ROM image is disabled by configuration.\nXep128 will work, but no XEP feature will be available.");
}
}
/* XEP ROM: now install our internal ROM, if it's allowed/OK to do so */
if (xep_rom_seg > 0) {
if (memory_segment_map[xep_rom_seg] == UNUSED_SEGMENT || memory_segment_map[xep_rom_seg] == XEPROM_SEGMENT) {
xep_rom_addr = xep_rom_seg << 14;
memset(memory + xep_rom_addr, 0, 0x4000);
memcpy(memory + xep_rom_addr, xep_rom_image, sizeof xep_rom_image);
memory_segment_map[xep_rom_seg] = XEPROM_SEGMENT;
xep_set_default_device_name(NULL);
DEBUGPRINT("CONFIG: ROM: XEP internal ROM image has been installed in segment %02Xh" NL, xep_rom_seg);
} else {
DEBUGPRINT("CONFIG: ROM: XEP internal ROM image CANNOT be installed because segment %02Xh is used!!" NL, xep_rom_seg);
ERROR_WINDOW("XEP internal ROM image cannot be installed.\nXep128 will work, but no XEP feature will be available.");
xep_rom_seg = -1;
}
} else
xep_rom_seg = -1;
return 0;
}
static FILE *sram_open ( int seg, const char *mode, char *path )
{
char fn[64];
snprintf(fn, sizeof fn, "@sram-%02X.seg", seg);
return open_emu_file(fn, mode, path);
}
