void memcard_eject(void)
{
mame_file *file;
char name[16];
/* if no card is preset, just ignore */
if (memcard_inserted == -1)
return;
/* create a name */
memcard_name(memcard_inserted, name);
/* open the file; if we can't, it's an error */
file = mame_fopen(Machine->gamedrv->name, name, FILETYPE_MEMCARD, TRUE);
if (file == NULL)
{
mame_fclose(file);
return;
}
/* initialize and then load the card */
if (Machine->drv->memcard_handler)
(*Machine->drv->memcard_handler)(file, MEMCARD_EJECT);
/* close the file */
mame_fclose(file);
memcard_inserted = -1;
}
int memcard_create(int index, int overwrite)
{
mame_file *file;
char name[16];
/* create a name */
memcard_name(index, name);
/* if we can't overwrite, fail if the file already exists */
if (!overwrite)
{
file = mame_fopen(Machine->gamedrv->name, name, FILETYPE_MEMCARD, FALSE);
if (file != NULL)
{
mame_fclose(file);
return 1;
}
}
/* create a new file */
file = mame_fopen(Machine->gamedrv->name, name, FILETYPE_MEMCARD, TRUE);
if (file == NULL)
return 1;
/* initialize and then save the card */
if (Machine->drv->memcard_handler)
(*Machine->drv->memcard_handler)(file, MEMCARD_CREATE);
/* close the file */
mame_fclose(file);
return 0;
}
void config_save_settings(void)
{
mame_file_error filerr;
config_type *type;
mame_file *file;
char *fname;
/* loop over all registrants and call their init function */
for (type = typelist; type; type = type->next)
(*type->save)(CONFIG_TYPE_INIT, NULL);
/* save the defaults file */
filerr = mame_fopen(SEARCHPATH_CONFIG, "default.cfg", OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file);
if (filerr == FILERR_NONE)
{
config_save_xml(file, CONFIG_TYPE_DEFAULT);
mame_fclose(file);
}
/* finally, save the game-specific file */
fname = assemble_2_strings(Machine->basename, ".cfg");
filerr = mame_fopen(SEARCHPATH_CONFIG, fname, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file);
free(fname);
if (filerr == FILERR_NONE)
{
config_save_xml(file, CONFIG_TYPE_GAME);
mame_fclose(file);
}
/* loop over all registrants and call their final function */
for (type = typelist; type; type = type->next)
(*type->save)(CONFIG_TYPE_FINAL, NULL);
}
void memcard_eject(running_machine *machine)
{
file_error filerr;
mame_file *file;
char name[16];
astring *fname;
/* if no card is preset, just ignore */
if (memcard_inserted == -1)
return;
/* create a name */
memcard_name(memcard_inserted, name);
fname = astring_assemble_3(astring_alloc(), Machine->basename, PATH_SEPARATOR, name);
/* open the file; if we can't, it's an error */
filerr = mame_fopen(SEARCHPATH_MEMCARD, astring_c(fname), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file);
astring_free(fname);
if (filerr != FILERR_NONE)
{
mame_fclose(file);
return;
}
/* initialize and then load the card */
if (machine->drv->memcard_handler)
(*machine->drv->memcard_handler)(machine, file, MEMCARD_EJECT);
/* close the file */
mame_fclose(file);
memcard_inserted = -1;
}
static void jchan_mcu_run(running_machine *machine)
{
UINT16 mcu_command = mcu_ram[0x0010/2]; /* command nb */
UINT16 mcu_offset = mcu_ram[0x0012/2] / 2; /* offset in shared RAM where MCU will write */
UINT16 mcu_subcmd = mcu_ram[0x0014/2]; /* sub-command parameter, happens only for command #4 */
logerror("%s : MCU executed command: %04X %04X %04X ",cpuexec_describe_context(machine),mcu_command,mcu_offset*2,mcu_subcmd);
/*
the only MCU commands found in program code are:
- 0x04: protection: provide data (see below) and code
- 0x03: read DSW
- 0x02: load game settings \ stored in ATMEL AT93C46 chip,
- 0x42: save game settings / 128 bytes serial EEPROM
*/
switch (mcu_command >> 8)
{
case 0x04: /* Protection: during self-test for mcu_subcmd = 0x3d, 0x3e, 0x3f */
{
toxboy_handle_04_subcommand(machine,mcu_subcmd,mcu_ram);
}
break;
case 0x03: // DSW
{
mcu_ram[mcu_offset] = input_port_read(machine, "DSW");
logerror("%s : MCU executed command: %04X %04X (read DSW)\n",cpuexec_describe_context(machine),mcu_command,mcu_offset*2);
}
break;
case 0x02: /* load game settings from 93C46 EEPROM ($1090-$10dc) */
{
mame_file *f;
if ((f = nvram_fopen(machine, OPEN_FLAG_READ)) != 0)
{
mame_fread(f,&mcu_ram[mcu_offset], 128);
mame_fclose(f);
}
logerror("(load NVRAM settings)\n");
}
break;
case 0x42: /* save game settings to 93C46 EEPROM ($50d4) */
{
mame_file *f;
if ((f = nvram_fopen(machine, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS)) != 0)
{
mame_fwrite(f,&mcu_ram[mcu_offset], 128);
mame_fclose(f);
}
logerror("(save NVRAM settings)\n");
}
break;
default:
logerror("- UNKNOWN COMMAND!!!\n");
}
}
void cli_frontend_exit(void)
{
/* close open files */
if (logfile) fclose(logfile);
if (options.playback) mame_fclose(options.playback);
if (options.record) mame_fclose(options.record);
if (options.language_file) mame_fclose(options.language_file);
}
int config_load_settings(running_machine *machine)
{
const char *controller = options_get_string(mame_options(), OPTION_CTRLR);
file_error filerr;
config_type *type;
mame_file *file;
int loaded = 0;
astring *fname;
/* loop over all registrants and call their init function */
for (type = typelist; type; type = type->next)
(*type->load)(CONFIG_TYPE_INIT, NULL);
/* now load the controller file */
if (controller[0] != 0)
{
/* open the config file */
fname = astring_assemble_2(astring_alloc(), controller, ".cfg");
filerr = mame_fopen(SEARCHPATH_CTRLR, astring_c(fname), OPEN_FLAG_READ, &file);
astring_free(fname);
if (filerr != FILERR_NONE)
fatalerror("Could not load controller file %s.cfg", controller);
/* load the XML */
if (!config_load_xml(machine, file, CONFIG_TYPE_CONTROLLER))
fatalerror("Could not load controller file %s.cfg", controller);
mame_fclose(file);
}
/* next load the defaults file */
filerr = mame_fopen(SEARCHPATH_CONFIG, "default.cfg", OPEN_FLAG_READ, &file);
if (filerr == FILERR_NONE)
{
config_load_xml(machine, file, CONFIG_TYPE_DEFAULT);
mame_fclose(file);
}
/* finally, load the game-specific file */
fname = astring_assemble_2(astring_alloc(), machine->basename, ".cfg");
filerr = mame_fopen(SEARCHPATH_CONFIG, astring_c(fname), OPEN_FLAG_READ, &file);
astring_free(fname);
if (filerr == FILERR_NONE)
{
loaded = config_load_xml(machine, file, CONFIG_TYPE_GAME);
mame_fclose(file);
}
/* loop over all registrants and call their final function */
for (type = typelist; type; type = type->next)
(*type->load)(CONFIG_TYPE_FINAL, NULL);
/* if we didn't find a saved config, return 0 so the main core knows that it */
/* is the first time the game is run and it should diplay the disclaimer. */
return loaded;
}
void cli_frontend_exit(void)
{
/* close open files */
if (logfile) fclose(logfile);
if (options.playback) mame_fclose(options.playback);
if (options.record) mame_fclose(options.record);
if (options.language_file) mame_fclose(options.language_file);
#ifdef MESS
if (win_write_config)
write_config(NULL, Machine->gamedrv);
#endif /* MESS */
}
int memcard_insert(int index)
{
file_error filerr;
mame_file *file;
char name[16];
astring *fname;
/* if a card is already inserted, eject it first */
if (memcard_inserted != -1)
memcard_eject(Machine);
assert(memcard_inserted == -1);
/* create a name */
memcard_name(index, name);
fname = astring_assemble_3(astring_alloc(), Machine->basename, PATH_SEPARATOR, name);
/* open the file; if we can't, it's an error */
filerr = mame_fopen(SEARCHPATH_MEMCARD, astring_c(fname), OPEN_FLAG_READ, &file);
astring_free(fname);
if (filerr != FILERR_NONE)
return 1;
/* initialize and then load the card */
if (Machine->drv->memcard_handler)
(*Machine->drv->memcard_handler)(Machine, file, MEMCARD_INSERT);
/* close the file */
mame_fclose(file);
memcard_inserted = index;
return 0;
}
int memcard_insert(int index)
{
mame_file *file;
char name[16];
/* if a card is already inserted, eject it first */
if (memcard_inserted != -1)
memcard_eject();
assert(memcard_inserted == -1);
/* create a name */
memcard_name(index, name);
/* open the file; if we can't, it's an error */
file = mame_fopen(Machine->gamedrv->name, name, FILETYPE_MEMCARD, FALSE);
if (file == NULL)
return 1;
/* initialize and then load the card */
if (Machine->drv->memcard_handler)
(*Machine->drv->memcard_handler)(file, MEMCARD_INSERT);
/* close the file */
mame_fclose(file);
memcard_inserted = index;
return 0;
}
static int write_config(const char *filename, const game_driver *gamedrv)
{
file_error filerr;
mame_file *f;
char buffer[128];
int retval = 1;
if (gamedrv != NULL)
{
sprintf(buffer, "%s.ini", gamedrv->name);
filename = buffer;
}
filerr = mame_fopen(SEARCHPATH_INI, buffer, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &f);
if (filerr != FILERR_NONE)
goto done;
options_output_ini_file(mame_options(), mame_core_file(f));
retval = 0;
done:
if (f != NULL)
mame_fclose(f);
return retval;
}
void mc10_init_machine(void)
{
mc10_keyboard_strobe = 0xff;
/* NPW: Taken from Juergen's MC-10 attempt that I just noticed... */
if( readinputport(7) & 0x80 )
{
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MRA8_RAM);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MWA8_RAM);
}
else
{
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MRA8_NOP);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0x5000, 0xbffe, 0, 0, MWA8_NOP);
}
/* Install DOS ROM ? */
if( readinputport(7) & 0x40 )
{
mame_file_error filerr;
mame_file *rom;
filerr = mame_fopen(SEARCHPATH_IMAGE, "mc10ext.rom", OPEN_FLAG_READ, &rom);
if( rom )
{
mame_fread(rom, memory_region(REGION_CPU1) + 0xc000, 0x2000);
mame_fclose(rom);
}
}
else
{
memory_install_read8_handler(0, ADDRESS_SPACE_PROGRAM, 0xc000, 0xdfff, 0, 0, MRA8_NOP);
memory_install_write8_handler(0, ADDRESS_SPACE_PROGRAM, 0xc000, 0xdfff, 0, 0, MWA8_NOP);
}
}
/* load battery backed nvram from a driver subdir. in the nvram dir. */
int image_battery_load(mess_image *img, void *buffer, int length)
{
mame_file *f;
int bytes_read = 0;
int result = FALSE;
char *nvram_filename;
/* some sanity checking */
if( buffer != NULL && length > 0 )
{
nvram_filename = battery_nvramfilename(img);
if (nvram_filename)
{
f = mame_fopen(Machine->gamedrv->name, nvram_filename, FILETYPE_NVRAM, 0);
if (f)
{
bytes_read = mame_fread(f, buffer, length);
mame_fclose(f);
result = TRUE;
}
free(nvram_filename);
}
/* fill remaining bytes (if necessary) */
memset(((char *) buffer) + bytes_read, '\0', length - bytes_read);
}
return result;
}
void legacy_image_device_base::clear()
{
if (m_mame_file)
{
mame_fclose(m_mame_file);
m_mame_file = NULL;
m_file = NULL;
} else {
if (m_file)
{
core_fclose(m_file);
m_file = NULL;
}
}
m_name.reset();
m_writeable = FALSE;
m_created = FALSE;
m_longname.reset();
m_manufacturer.reset();
m_year.reset();
m_playable.reset();
m_extrainfo.reset();
m_basename_noext.reset();
m_filetype.reset();
m_full_software_name = NULL;
m_software_info_ptr = NULL;
m_software_part_ptr = NULL;
}
static mame_file_error mame_fopen_next(const char *pathoption, const char *extension, mame_file **file)
{
mame_file_error filerr;
char *fname;
int seq;
/* allocate temp space for the name */
fname = malloc_or_die(strlen(Machine->basename) + 1 + 10 + strlen(extension) + 1);
/* try until we succeed */
for (seq = 0; ; seq++)
{
sprintf(fname, "%s" PATH_SEPARATOR "%04d.%s", Machine->basename, seq, extension);
filerr = mame_fopen(pathoption, fname, OPEN_FLAG_READ, file);
if (filerr != FILERR_NONE)
break;
mame_fclose(*file);
}
/* create the final file */
filerr = mame_fopen(pathoption, fname, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, file);
/* free the name and get out */
free(fname);
return filerr;
}
static void update_fps(mame_time emutime)
{
osd_ticks_t curr = osd_ticks();
// update stats for the FPS average calculation
if (fps_start_time == 0)
{
// start the timer going 1 second into the game
if (emutime.seconds > 1)
fps_start_time = osd_ticks();
}
else
{
fps_frames_displayed++;
if (fps_frames_displayed == video_config.framestorun)
{
mame_file_error filerr;
mame_file *fp;
char name[20];
// make a filename with an underscore prefix
sprintf(name, "_%.8s.png", Machine->gamedrv->name);
// write out the screenshot
filerr = mame_fopen(SEARCHPATH_SCREENSHOT, name, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &fp);
if (filerr == FILERR_NONE)
{
video_screen_save_snapshot(fp, 0);
mame_fclose(fp);
}
mame_schedule_exit(Machine);
}
fps_end_time = curr;
}
}
void vpm_game_exit(int game_index) {
/* close open files */
if (options.language_file) /* this seems to never be opened in Win32 version */
{ mame_fclose(options.language_file); options.language_file = NULL; }
if (logfile)
{ fclose(logfile); logfile = NULL; }
}
static void hs_save (void)
{
mame_file *f = mame_fopen (Machine->gamedrv->name, 0, FILETYPE_HIGHSCORE, 1);
LOG(("hs_save\n"));
if (f)
{
struct mem_range *mem_range = state.mem_range;
LOG(("saving...\n"));
while (mem_range)
{
UINT8 *data = osd_malloc (mem_range->num_bytes);
if (data)
{
/* this buffer will almost certainly be small
enough to be dynamically allocated, but let's
avoid memory trashing just in case
*/
copy_from_memory (mem_range->cpu, mem_range->addr, data, mem_range->num_bytes);
mame_fwrite(f, data, mem_range->num_bytes);
}
mem_range = mem_range->next;
}
mame_fclose(f);
}
}
static void hs_load (void)
{
mame_file *f = mame_fopen (Machine->gamedrv->name, 0, FILETYPE_HIGHSCORE, 0);
state.hiscores_have_been_loaded = 1;
LOG(("hs_load\n"));
if (f)
{
struct mem_range *mem_range = state.mem_range;
LOG(("loading...\n"));
while (mem_range)
{
UINT8 *data = osd_malloc (mem_range->num_bytes);
if (data)
{
/* this buffer will almost certainly be small
enough to be dynamically allocated, but let's
avoid memory trashing just in case
*/
mame_fread (f, data, mem_range->num_bytes);
copy_to_memory (mem_range->cpu, mem_range->addr, data, mem_range->num_bytes);
free (data);
}
mem_range = mem_range->next;
}
mame_fclose (f);
}
}
int ti99_hsgpl_load_memcard(void)
{
mame_file *file;
file = mame_fopen(Machine->gamedrv->name, "hsgpl", FILETYPE_MEMCARD, OSD_FOPEN_READ);
if (! file)
return /*1*/0;
if (ti99_hsgpl_file_load(file))
{
mame_fclose(file);
return 1;
}
mame_fclose(file);
return 0;
}
int ti99_ide_load_memcard(void)
{
mame_file_error filerr;
mame_file *file;
filerr = mame_fopen(SEARCHPATH_MEMCARD, "ide.nv", OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
return /*1*/0;
if (rtc65271_file_load(file))
{
mame_fclose(file);
return 1;
}
mame_fclose(file);
return 0;
}
BOOL LoadDIB(LPCTSTR filename, HGLOBAL *phDIB, HPALETTE *pPal, int pic_type)
{
mame_file *mfile;
BOOL success;
const char *zip_name = NULL;
switch (pic_type)
{
case TAB_SCREENSHOT :
set_pathlist(FILETYPE_ARTWORK,GetImgDir());
zip_name = "snap";
break;
case TAB_FLYER :
set_pathlist(FILETYPE_ARTWORK,GetFlyerDir());
zip_name = "flyers";
break;
case TAB_CABINET :
set_pathlist(FILETYPE_ARTWORK,GetCabinetDir());
zip_name = "cabinets";
break;
case TAB_MARQUEE :
set_pathlist(FILETYPE_ARTWORK,GetMarqueeDir());
zip_name = "marquees";
break;
case TAB_TITLE :
set_pathlist(FILETYPE_ARTWORK,GetTitlesDir());
zip_name = "titles";
break;
case TAB_CONTROL_PANEL :
set_pathlist(FILETYPE_ARTWORK,GetControlPanelDir());
zip_name = "cpanel";
break;
case BACKGROUND :
set_pathlist(FILETYPE_ARTWORK,GetBgDir());
zip_name = "bkground";
break;
default :
// in case a non-image tab gets here, which can happen
return FALSE;
}
// look for the raw file
mfile = mame_fopen(NULL,filename,FILETYPE_ARTWORK,0);
if (mfile == NULL)
{
// and look for the zip
mfile = mame_fopen(zip_name,filename,FILETYPE_ARTWORK,0);
}
if (mfile == NULL)
return FALSE;
success = png_read_bitmap(mfile, phDIB, pPal);
mame_fclose(mfile);
return success;
}
int debug_comment_load(void)
{
mame_file *fp = mame_fopen(Machine->gamedrv->name, 0, FILETYPE_COMMENT, 0);
if (!fp) return 0;
debug_comment_load_xml(fp);
mame_fclose(fp);
return 1;
}
static chd_file *get_disc(const device_config *device)
{
mame_file *image_file = NULL;
chd_file *image_chd = NULL;
mame_path *path;
/* open a path to the ROMs and find the first CHD file */
path = mame_openpath(mame_options(), OPTION_ROMPATH);
if (path != NULL)
{
const osd_directory_entry *dir;
/* iterate while we get new objects */
while ((dir = mame_readpath(path)) != NULL)
{
int length = strlen(dir->name);
/* look for files ending in .chd */
if (length > 4 &&
dir->name[length - 4] == '.' &&
tolower(dir->name[length - 3]) == 'c' &&
tolower(dir->name[length - 2]) == 'h' &&
tolower(dir->name[length - 1]) == 'd')
{
file_error filerr;
chd_error chderr;
/* open the file itself via our search path */
filerr = mame_fopen(SEARCHPATH_IMAGE, dir->name, OPEN_FLAG_READ, &image_file);
if (filerr == FILERR_NONE)
{
/* try to open the CHD */
chderr = chd_open_file(mame_core_file(image_file), CHD_OPEN_READ, NULL, &image_chd);
if (chderr == CHDERR_NONE)
{
set_disk_handle(device->machine, "laserdisc", image_file, image_chd);
filename = astring_dupc(dir->name);
add_exit_callback(device->machine, free_string);
break;
}
/* close the file on failure */
mame_fclose(image_file);
image_file = NULL;
}
}
}
mame_closepath(path);
}
/* if we failed, pop a message and exit */
if (image_file == NULL)
fatalerror("No valid image file found!\n");
return get_disk_handle(device->machine, "laserdisc");
}
void nvram_load(void)
{
if (Machine->drv->nvram_handler != NULL)
{
mame_file *nvram_file = mame_fopen(Machine->gamedrv->name, 0, FILETYPE_NVRAM, 0);
(*Machine->drv->nvram_handler)(nvram_file, 0);
if (nvram_file != NULL)
mame_fclose(nvram_file);
}
}
void nvram_load(void)
{
if (Machine->drv->nvram_handler != NULL)
{
mame_file *nvram_file = nvram_fopen(Machine, OPEN_FLAG_READ);
(*Machine->drv->nvram_handler)(Machine, nvram_file, 0);
if (nvram_file != NULL)
mame_fclose(nvram_file);
}
}
void mc146818_save(void)
{
mame_file *file;
file = mame_fopen(Machine->gamedrv->name, 0, FILETYPE_NVRAM, 1);
if (file)
{
mame_fwrite(file, mc146818->data, sizeof(mc146818->data));
mame_fclose(file);
}
}
void record_movie_stop(void)
{
#if 0 /* AdvanceMAME has its record code */
if (movie_file)
{
mng_capture_stop(movie_file);
mame_fclose(movie_file);
movie_file = NULL;
}
#endif
}
/****************************************************************************
* ParseClose - Closes the existing opened file (if any)
****************************************************************************/
static void ParseClose(void)
{
/* If the file is open, time for fclose. */
if (fp)
{
mame_fclose(fp);
}
fp = NULL;
}
void video_movie_end_recording(void)
{
/* close the file if it exists */
if (movie_file != NULL)
{
mng_capture_stop(movie_file);
mame_fclose(movie_file);
movie_file = NULL;
movie_frame = 0;
}
}
