static running_machine *create_machine(int game) { running_machine *machine; int scrnum; /* allocate memory for the machine */ machine = malloc(sizeof(*machine)); if (machine == NULL) goto error; memset(machine, 0, sizeof(*machine)); /* allocate memory for the internal mame_data */ machine->mame_data = malloc(sizeof(*machine->mame_data)); if (machine->mame_data == NULL) goto error; memset(machine->mame_data, 0, sizeof(*machine->mame_data)); /* initialize the driver-related variables in the machine */ machine->gamedrv = drivers[game]; machine->drv = malloc(sizeof(*machine->drv)); if (machine->drv == NULL) goto error; machine->basename = mame_strdup(machine->gamedrv->name); expand_machine_driver(machine->gamedrv->drv, (machine_config *)machine->drv); /* allocate the driver data */ if (machine->drv->driver_data_size != 0) { machine->driver_data = malloc(machine->drv->driver_data_size); if (machine->driver_data == NULL) goto error; memset(machine->driver_data, 0, machine->drv->driver_data_size); } /* configure all screens to be the default */ for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++) machine->screen[scrnum] = machine->drv->screen[scrnum].defstate; /* convert some options into live state */ machine->sample_rate = options.samplerate; machine->record_file = options.record; machine->playback_file = options.playback; machine->debug_mode = options.mame_debug; return machine; error: if (machine->driver_data != NULL) free(machine->driver_data); if (machine->drv != NULL) free((machine_config *)machine->drv); if (machine->mame_data != NULL) free(machine->mame_data); if (machine != NULL) free(machine); return NULL; }
static char *assemble_software_path(const game_driver *gamedrv, const char *filename) { char *result; if (osd_is_absolute_path(filename)) result = mame_strdup(filename); else result = assemble_5_strings("software", PATH_SEPARATOR, gamedrv->name, PATH_SEPARATOR, filename); return result; }
void mame_schedule_load(const char *filename) { /* free any existing request and allocate a copy of the requested name */ if (saveload_pending_file != NULL) free(saveload_pending_file); saveload_pending_file = mame_strdup(filename); /* note the start time and set a timer for the next timeslice to actually schedule it */ saveload_schedule_callback = handle_load; saveload_schedule_time = mame_timer_get_time(); /* we can't be paused since we need to clear out anonymous timers */ mame_pause(FALSE); }
void mame_schedule_save(running_machine *machine, const char *filename) { mame_private *mame = machine->mame_data; /* free any existing request and allocate a copy of the requested name */ if (mame->saveload_pending_file != NULL) free(mame->saveload_pending_file); mame->saveload_pending_file = mame_strdup(filename); /* note the start time and set a timer for the next timeslice to actually schedule it */ mame->saveload_schedule_callback = handle_save; mame->saveload_schedule_time = mame_timer_get_time(); /* we can't be paused since we need to clear out anonymous timers */ mame_pause(machine, FALSE); }
static void edit_add_hist(edit *e, const char *text) { if(e->ch) e->ch = 0; if(e->hold) { osd_free(e->hold); e->hold =0; } if(!e->h || (text[0] && strcmp(text, e->h->e))) { hentry *h = (hentry *) osd_malloc(sizeof(hentry)); h->h = e->h; h->e = mame_strdup(text); e->h = h; } }
static void edit_hist_back(edit *e) { const char *text = gtk_entry_get_text(e->edit_w); if(e->ch) { if(!e->ch->h) return; e->ch = e->ch->h; } else { if(!e->h) return; if(!strcmp(text, e->h->e)) { if(!e->h->h) return; e->ch = e->h->h; } else { if(text[0]) e->hold = mame_strdup(text); e->ch = e->h; } } gtk_entry_set_text(e->edit_w, e->ch->e); gtk_editable_select_region(GTK_EDITABLE(e->edit_w), 0, -1); }
BOOL LoadDIB(LPCTSTR filename, HGLOBAL *phDIB, HPALETTE *pPal, int pic_type) { mame_file_error filerr; mame_file *mfile = NULL; char *fname; BOOL success; const char *zip_name = NULL; char *pngfilename = NULL; char tmp[MAX_PATH]; strcpy(tmp, filename); strcat(tmp, ".png"); pngfilename = mame_strdup(tmp); switch (pic_type) { case TAB_SCREENSHOT : options_set_string(SEARCHPATH_ARTWORK,GetImgDir()); zip_name = "snap"; break; case TAB_FLYER : options_set_string(SEARCHPATH_ARTWORK,GetFlyerDir()); zip_name = "flyers"; break; case TAB_CABINET : options_set_string(SEARCHPATH_ARTWORK,GetCabinetDir()); zip_name = "cabinets"; break; case TAB_MARQUEE : options_set_string(SEARCHPATH_ARTWORK,GetMarqueeDir()); zip_name = "marquees"; break; case TAB_TITLE : options_set_string(SEARCHPATH_ARTWORK,GetTitlesDir()); zip_name = "titles"; break; case TAB_CONTROL_PANEL : options_set_string(SEARCHPATH_ARTWORK,GetControlPanelDir()); zip_name = "cpanel"; break; case BACKGROUND : options_set_string(SEARCHPATH_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 filerr = mame_fopen(SEARCHPATH_ARTWORK, pngfilename, OPEN_FLAG_READ, &mfile); if (filerr != FILERR_NONE) { // and look for the zip fname = assemble_3_strings(zip_name, PATH_SEPARATOR, pngfilename); filerr = mame_fopen(SEARCHPATH_ARTWORK, fname, OPEN_FLAG_READ, &mfile); free(fname); } if (filerr != FILERR_NONE) return FALSE; success = png_read_bitmap(mfile, phDIB, pPal); mame_fclose(mfile); return success; }
void ram_device::device_validity_check(validity_checker &valid) const { const char *ramsize_string = NULL; int is_valid = FALSE; UINT32 specified_ram = 0; const char *gamename_option = NULL; /* verify default ram value */ if (default_size() == 0) mame_printf_error("Invalid default RAM option: %s\n", m_default_size); /* command line options are only parsed for the device named RAM_TAG */ if (tag() != NULL && strcmp(tag(), ":" RAM_TAG) == 0) { /* verify command line ram option */ ramsize_string = mconfig().options().ram_size(); gamename_option = mconfig().options().system_name(); if ((ramsize_string != NULL) && (ramsize_string[0] != '\0')) { specified_ram = parse_string(ramsize_string); if (specified_ram == 0) mame_printf_error("Cannot recognize the RAM option %s\n", ramsize_string); if (gamename_option != NULL && *gamename_option != 0 && strcmp(gamename_option, mconfig().gamedrv().name) == 0) { /* compare command line option to default value */ if (default_size() == specified_ram) is_valid = TRUE; /* verify extra ram options */ if (m_extra_options != NULL) { int j; int size = strlen(m_extra_options); char * const s = mame_strdup(m_extra_options); char * const e = s + size; char *p = s; for (j=0;j<size;j++) { if (p[j]==',') p[j]=0; } /* try to parse each option */ while(p <= e) { UINT32 option_ram_size = parse_string(p); if (option_ram_size == 0) mame_printf_error("Invalid RAM option: %s\n", p); if (option_ram_size == specified_ram) is_valid = TRUE; p += strlen(p); if (p == e) break; p += 1; } osd_free(s); } } else { /* if not for this driver then return ok */ is_valid = TRUE; } } else { /* not specifying the ramsize on the command line is valid as well */ is_valid = TRUE; } } else is_valid = TRUE; if (!is_valid) { astring output; output.catprintf("Cannot recognize the RAM option %s", ramsize_string); output.catprintf(" (valid options are %s", m_default_size); if (m_extra_options != NULL) output.catprintf(",%s).\n", m_extra_options); else output.catprintf(").\n"); mame_printf_error("%s", output.cstr()); mame_printf_warning("Setting value to default %s\n",m_default_size); astring error; mconfig().options().set_value(OPTION_RAMSIZE, m_default_size, OPTION_PRIORITY_CMDLINE, error); assert(!error); } }
static BOOL RamPopulateControl(datamap *map, HWND dialog, HWND control, windows_options *opts, const char *option_name) { int i, current_index, driver_index; const game_driver *gamedrv; UINT32 ram, current_ram; const char *this_ram_string; TCHAR* t_ramstring; const device_t *device; // identify the driver driver_index = PropertiesCurrentGame(dialog); gamedrv = &driver_list::driver(driver_index); // clear out the combo box (void)ComboBox_ResetContent(control); // allocate the machine config machine_config cfg(*gamedrv,*opts); // identify how many options that we have device = cfg.devicelist().first(RAM); EnableWindow(control, (device != NULL)); i = 0; // we can only do something meaningful if there is more than one option if (device != NULL) { ram_config *config = (ram_config *)downcast<const legacy_device_base *>(device)->inline_config(); // identify the current amount of RAM this_ram_string = opts->value(OPTION_RAMSIZE); current_ram = (this_ram_string != NULL) ? ram_parse_string(this_ram_string) : 0; if (current_ram == 0) current_ram = ram_parse_string(config->default_size); // by default, assume index 0 current_index = 0; { ram = ram_parse_string(config->default_size); t_ramstring = tstring_from_utf8(config->default_size); if( !t_ramstring ) return FALSE; (void)ComboBox_InsertString(control, i, win_tstring_strdup(t_ramstring)); (void)ComboBox_SetItemData(control, i, ram); osd_free(t_ramstring); } if (config->extra_options != NULL) { int j; int size = strlen(config->extra_options); char * const s = mame_strdup(config->extra_options); char * const e = s + size; char *p = s; for (j=0;j<size;j++) { if (p[j]==',') p[j]=0; } /* try to parse each option */ while(p <= e) { i++; // identify this option ram = ram_parse_string(p); this_ram_string = p; t_ramstring = tstring_from_utf8(this_ram_string); if( !t_ramstring ) return FALSE; // add this option to the combo box (void)ComboBox_InsertString(control, i, win_tstring_strdup(t_ramstring)); (void)ComboBox_SetItemData(control, i, ram); osd_free(t_ramstring); // is this the current option? record the index if so if (ram == current_ram) current_index = i; p+= strlen(p); if (p == e) break; p += 1; } osd_free(s); } // set the combo box (void)ComboBox_SetCurSel(control, current_index); } return TRUE; }
void driver_switch::assign_drivers(emu_options &opts) { static const struct { const char *name; const game_driver * const *driver; } drivers_table[] = { #ifndef TINY_BUILD { "mame", mamedrivers }, { "plus", mameplusdrivers }, { "homebrew", mamehbdrivers }, { "decrypted", mamedecrypteddrivers }, #ifdef MAMEMESS { "console", messdrivers }, #endif /* MAMEMESS */ #else { "mame", tinydrivers }, #endif /* !TINY_BUILD */ { NULL } }; UINT32 enabled = 0; int i, n; bool mechanical = opts.bool_value(OPTION_DISABLE_MECHANICAL_DRIVER); #ifndef TINY_BUILD const char *drv_option = opts.value(OPTION_DRIVER_CONFIG); if (drv_option) { char *temp = mame_strdup(drv_option); if (temp) { char *p = strtok(temp, ","); while (p) { char *s = core_strtrim(p); //get individual driver name if (s[0]) { if (mame_stricmp(s, "all") == 0) { enabled = (UINT32)-1; break; } for (i = 0; drivers_table[i].name; i++) if (mame_stricmp(s, drivers_table[i].name) == 0) { enabled |= 1 << i; break; } if (!drivers_table[i].name) mame_printf_warning(_("Illegal value for %s = %s\n"), OPTION_DRIVER_CONFIG, s); } osd_free(s); p = strtok(NULL, ","); } osd_free(temp); } } #endif /* !TINY_BUILD */ if (enabled == 0) enabled = 1; // default to mamedrivers n = 0; for (i = 0; drivers_table[i].name; i++) if (enabled & (1 << i)) { for (int c = 0; drivers_table[i].driver[c]; c++) if (mame_stricmp(drivers_table[i].driver[c]->name, "___empty")) if (!mechanical || !(drivers_table[i].driver[c]->flags & GAME_MECHANICAL)) driver_list::s_drivers_sorted[n++] = drivers_table[i].driver[c]; } // ___empty driver add once driver_list::s_drivers_sorted[n++] = &GAME_NAME(___empty); driver_list::s_driver_count = n; qsort(driver_list::s_drivers_sorted, n, sizeof(*driver_list::s_drivers_sorted), driver_list::driver_sort_callback); }
static image_error_t load_zip_path(mess_image *image, const char *path) { image_error_t err = IMAGE_ERROR_FILENOTFOUND; zip_file *zip = NULL; zip_error ziperr; const zip_file_header *header; const char *zip_extension = ".zip"; char *path_copy; const char *zip_entry; void *ptr; int pos; /* create our own copy of the path */ path_copy = mame_strdup(path); if (!path_copy) { err = IMAGE_ERROR_OUTOFMEMORY; goto done; } /* loop through the path and try opening zip files */ ziperr = ZIPERR_FILE_ERROR; zip_entry = NULL; pos = strlen(path_copy); while(pos > strlen(zip_extension)) { /* is this a potential zip path? */ if ((path_copy[pos] == '\0') || !strncmp(&path_copy[pos], PATH_SEPARATOR, strlen(PATH_SEPARATOR))) { /* parse out the zip path */ if (path_copy[pos] == '\0') { /* no zip path */ zip_entry = NULL; } else { /* we are at a zip path */ path_copy[pos] = '\0'; zip_entry = &path_copy[pos + strlen(PATH_SEPARATOR)]; } /* try to open the zip file */ ziperr = zip_file_open(path_copy, &zip); if (ziperr != ZIPERR_FILE_ERROR) break; /* restore the path if we changed */ if (zip_entry) path_copy[pos] = PATH_SEPARATOR[0]; } pos--; } /* did we succeed in opening up a zip file? */ if (ziperr == ZIPERR_NONE) { /* iterate through the zip file */ header = zip_file_first_file(zip); /* if we specified a zip partial path, find it */ if (zip_entry) { while(header) { if (!mame_stricmp(header->filename, zip_entry)) break; header = zip_file_next_file(zip); } } /* were we successful? */ if (header) { /* if no zip path was specified, we have to change the name */ if (!zip_entry) { /* use the first entry; tough part is we have to change the name */ err = set_image_filename(image, image->name, header->filename); if (err) goto done; } /* allocate space for this zip file */ ptr = image_malloc(image, header->uncompressed_length); if (!ptr) { err = IMAGE_ERROR_OUTOFMEMORY; goto done; } ziperr = zip_file_decompress(zip, ptr, header->uncompressed_length); if (ziperr == ZIPERR_NONE) { /* success! */ err = IMAGE_ERROR_SUCCESS; image->ptr = ptr; image->length = header->uncompressed_length; } } } done: if (path_copy) free(path_copy); if (zip) zip_file_close(zip); return err; }
static LPWSTR GetPatchDescByLangcode(FILE *fp, int langcode) { LPWSTR result; char *desc = NULL; char langtag[8]; sprintf(langtag, "[%s]", ui_lang_info[langcode].name); fseek(fp, 0, SEEK_SET); while (!feof(fp)) { char s[4096]; if (fgets(s, ARRAY_LENGTH(s), fp) != NULL) { if (strncmp(langtag, s, strlen(langtag)) != 0) continue; while (fgets(s, ARRAY_LENGTH(s), fp) != NULL) { char *p; if (*s == '[') { if (desc) { result = _UTF8Unicode(desc); global_free(desc); return result; } else return NULL; } for (p = s; *p; p++) if (*p == '\r' || *p == '\n') { *p = '\0'; break; } // if (*s == '\0') // continue; if (desc) { char *p; int len = strlen(desc); len += strlen(s) + 2; p = (char *)malloc(len + 1); sprintf(p, "%s\r\n%s", desc, s); FreeIfAllocated(&desc); desc = p; } else { desc = mame_strdup(s); } } } } if (desc) { result = _UTF8Unicode(desc); global_free(desc); return result; } else return NULL; }