Пример #1
0
void debugger_flush_all_traces_on_abnormal_exit(void)
{
	/* clear out the machine list and flush traces on each one */
	while (machine_list != NULL)
	{
		machine_entry *deleteme = machine_list;
		debug_cpu_flush_traces(*deleteme->machine);
		machine_list = deleteme->next;
		global_free(deleteme);
	}
}
Пример #2
0
static void video_exit(running_machine &machine)
{
	// free all of our monitor information
	while (sdl_monitor_list != NULL)
	{
		sdl_monitor_info *temp = sdl_monitor_list;
		sdl_monitor_list = temp->next;
		global_free(temp);
	}

}
Пример #3
0
void debug_view_manager::free_view(debug_view &view)
{
	// free us but only if we're in the list
	for (debug_view **viewptr = &m_viewlist; *viewptr != nullptr; viewptr = &(*viewptr)->m_next)
		if (*viewptr == &view)
		{
			*viewptr = view.m_next;
			global_free(&view);
			break;
		}
}
Пример #4
0
static void create_bitmap(running_machine *machine, int player)
{
	int x, y;
	char filename[20];
	rgb_t color = crosshair_colors[player];

	/* if we have a bitmap and texture for this player, kill it */
	global_free(global.bitmap[player]);
	machine->render().texture_free(global.texture[player]);

	emu_file crossfile(machine->options(), OPTION_CROSSHAIRPATH, OPEN_FLAG_READ);
	if (global.name[player][0] != 0)
	{
		/* look for user specified file */
		sprintf(filename, "%s.png", global.name[player]);
		global.bitmap[player] = render_load_png(crossfile, NULL, filename, NULL, NULL);
	}
	else
	{
		/* look for default cross?.png in crsshair\game dir */
		sprintf(filename, "cross%d.png", player + 1);
		global.bitmap[player] = render_load_png(crossfile, machine->gamedrv->name, filename, NULL, NULL);

		/* look for default cross?.png in crsshair dir */
		if (global.bitmap[player] == NULL)
			global.bitmap[player] = render_load_png(crossfile, NULL, filename, NULL, NULL);
	}

	/* if that didn't work, use the built-in one */
	if (global.bitmap[player] == NULL)
	{
		/* allocate a blank bitmap to start with */
		global.bitmap[player] = global_alloc(bitmap_t(CROSSHAIR_RAW_SIZE, CROSSHAIR_RAW_SIZE, BITMAP_FORMAT_ARGB32));
		bitmap_fill(global.bitmap[player], NULL, MAKE_ARGB(0x00,0xff,0xff,0xff));

		/* extract the raw source data to it */
		for (y = 0; y < CROSSHAIR_RAW_SIZE / 2; y++)
		{
			/* assume it is mirrored vertically */
			UINT32 *dest0 = BITMAP_ADDR32(global.bitmap[player], y, 0);
			UINT32 *dest1 = BITMAP_ADDR32(global.bitmap[player], CROSSHAIR_RAW_SIZE - 1 - y, 0);

			/* extract to two rows simultaneously */
			for (x = 0; x < CROSSHAIR_RAW_SIZE; x++)
				if ((crosshair_raw_top[y * CROSSHAIR_RAW_ROWBYTES + x / 8] << (x % 8)) & 0x80)
					dest0[x] = dest1[x] = MAKE_ARGB(0xff,0x00,0x00,0x00) | color;
		}
	}

	/* create a texture to reference the bitmap */
	global.texture[player] = machine->render().texture_alloc(render_texture::hq_scale);
	global.texture[player]->set_bitmap(global.bitmap[player], NULL, TEXFORMAT_ARGB32);
}
Пример #5
0
device_image_interface::~device_image_interface()
{
   image_device_format **formatptr = &m_formatlist;

	/* free all entries */
	while (*formatptr != NULL)
	{
		image_device_format *entry = *formatptr;
		*formatptr = entry->m_next;
		global_free(entry);
	}
}
Пример #6
0
legacy_image_device_config_base::~legacy_image_device_config_base()
{
    image_device_format **formatptr = &m_formatlist;

	/* free all entries */
	while (*formatptr != NULL)
	{
		image_device_format *entry = *formatptr;
		*formatptr = entry->m_next;
		global_free(entry);
	}
}
Пример #7
0
void windows_osd_interface::video_exit()
{
	window_exit();

	// free all of our monitor information
	while (osd_monitor_info::list != NULL)
	{
		osd_monitor_info *temp = osd_monitor_info::list;
		osd_monitor_info::list = temp->m_next;
		global_free(temp);
	}
}
Пример #8
0
void
staleness_free_snapshot(stale_snap_allocs_t *snaps)
{
    if (snaps == NULL)
        return;
    if (snaps->num_entries > 0) {
        if (snaps->uses_large) {
            global_free(snaps->data.lg, snaps->num_entries*sizeof(*snaps->data.lg),
                        HEAPSTAT_STALENESS);
        } else {
            global_free(snaps->data.sm.main,
                        snaps->num_entries*sizeof(*snaps->data.sm.main),
                        HEAPSTAT_STALENESS);
            if (snaps->data.sm.ext != NULL) {
                global_free(snaps->data.sm.ext, snaps->data.sm.ext_capacity*
                            sizeof(*snaps->data.sm.ext), HEAPSTAT_STALENESS);
            }
        }
    }
    global_free(snaps, sizeof(*snaps), HEAPSTAT_STALENESS);
}
Пример #9
0
/* Free a boxed reference. Free the unboxed reference if necessary. */
void boxed_free(Boxed reference) {
  if (!reference)
    return;
  global_free();
  if (--reference->count > 0)
    return;
  assert(reference->count == 0);
  if (boxed_type(reference) == QUOTATION)
    quotation_clear(reference);
  unboxed_free(reference->value);
  free(reference);
}
Пример #10
0
static void crosshair_exit(running_machine &machine)
{
	/* free bitmaps and textures for each player */
	for (int player = 0; player < MAX_PLAYERS; player++)
	{
		machine.render().texture_free(global.texture[player]);
		global.texture[player] = NULL;

		global_free(global.bitmap[player]);
		global.bitmap[player] = NULL;
	}
}
Пример #11
0
void floppy_image_device::call_unload()
{
	dskchg = 0;

	if (image) {
		if(image_dirty)
			commit_image();
		global_free(image);
		image = 0;
	}
	if (!cur_unload_cb.isnull())
		cur_unload_cb(this);
}
Пример #12
0
static int nvram_system_save( running_machine &machine, const char *name, nvram_save_func _nvram_save)
{
	emu_file *file;
	file = nvram_system_fopen( machine, OPEN_FLAG_CREATE | OPEN_FLAG_WRITE | OPEN_FLAG_CREATE_PATHS, name);
	if (!file)
	{
		mame_printf_error( "nvram save failed (%s)\n", name);
		return FALSE;
	}
	(*_nvram_save)(machine, file);
	global_free(file);
	return TRUE;
}
Пример #13
0
static void winoutput_exit(running_machine &machine)
{
	// free all the clients
	while (clientlist != NULL)
	{
		registered_client *temp = clientlist;
		clientlist = temp->next;
		global_free(temp);
	}

	// broadcast a shutdown message
	PostMessage(HWND_BROADCAST, om_mame_stop, (WPARAM)output_hwnd, 0);
}
Пример #14
0
bool midiout_device::call_load(void)
{
	m_midi = machine().osd().create_midi_device();

	if (!m_midi->open_output(filename()))
	{
		global_free(m_midi);
		m_midi = NULL;
		return IMAGE_INIT_FAIL;
	}

	return IMAGE_INIT_PASS;
}
Пример #15
0
void windows_osd_interface::output_exit()
{
	// free all the clients
	while (clientlist != nullptr)
	{
		registered_client *temp = clientlist;
		clientlist = temp->next;
		global_free(temp);
	}

	// broadcast a shutdown message
	PostMessage(HWND_BROADCAST, om_mame_stop, (WPARAM)output_hwnd, 0);
}
Пример #16
0
static int nvram_system_load( running_machine &machine, const char *name, nvram_load_func _nvram_load, int required)
{
	emu_file *file;
	file = nvram_system_fopen( machine, OPEN_FLAG_READ, name);
	if (!file)
	{
		if (required) mame_printf_error( "nvram load failed (%s)\n", name);
		return FALSE;
	}
	(*_nvram_load)(machine, file);
	global_free(file);
	return TRUE;
}
Пример #17
0
void software_config_free(software_config *config)
{
	if (config->mconfig != NULL)
	{
		global_free(config->mconfig);
		config->mconfig = NULL;
	}
	/*if (config->hashfile != NULL)
	{
		hashfile_close(config->hashfile);
		config->hashfile = NULL;
	}*/
	free(config);
}
Пример #18
0
static void debugger_exit(running_machine *machine)
{
	machine_entry **entryptr;

	/* remove this machine from the list; it came down cleanly */
	for (entryptr = &machine_list; *entryptr != NULL; entryptr = &(*entryptr)->next)
		if ((*entryptr)->machine == machine)
		{
			machine_entry *deleteme = *entryptr;
			*entryptr = deleteme->next;
			global_free(deleteme);
			break;
		}
}
Пример #19
0
/*-------------------------------------------------
    softlist_match_roms - scan for a matching
    software ROM by hash
-------------------------------------------------*/
static void softlist_match_roms(core_options *options, const char *hash, int length, int *found)
{
	int drvindex;

	/* iterate over drivers */
	for (drvindex = 0; drivers[drvindex] != NULL; drvindex++)
	{
		machine_config *config = global_alloc(machine_config(drivers[drvindex]->machine_config));

		for (const device_config *dev = config->m_devicelist.first(SOFTWARE_LIST); dev != NULL; dev = dev->typenext())
		{
			software_list_config *swlist = (software_list_config *)downcast<const legacy_device_config_base *>(dev)->inline_config();

			for ( int i = 0; i < DEVINFO_STR_SWLIST_MAX - DEVINFO_STR_SWLIST_0; i++ )
			{
				if ( swlist->list_name[i] )
				{
					software_list *list = software_list_open( options, swlist->list_name[i], FALSE, NULL );

					for ( software_info *swinfo = software_list_find( list, "*", NULL ); swinfo != NULL; swinfo = software_list_find( list, "*", swinfo ) )
					{
						for ( software_part *part = software_find_part( swinfo, NULL, NULL ); part != NULL; part = software_part_next( part ) )
						{
							for ( const rom_entry *region = part->romdata; region != NULL; region = rom_next_region(region) )
							{
								for ( const rom_entry *rom = rom_first_file(region); rom != NULL; rom = rom_next_file(rom) )
								{
									if ( hash_data_is_equal(hash, ROM_GETHASHDATA(rom), 0) )
									{
										int baddump = hash_data_has_info(ROM_GETHASHDATA(rom), HASH_INFO_BAD_DUMP);

										/* output information about the match */
										if (*found != 0)
											mame_printf_info("                    ");
										mame_printf_info("= %s%-20s  %s:%s %s\n", baddump ? "(BAD) " : "", ROM_GETNAME(rom), swlist->list_name[i], swinfo->shortname, swinfo->longname);
										(*found)++;
									}
								}
							}
						}
					}

					software_list_close( list );
				}
			}
		}

		global_free(config);
	}
}
Пример #20
0
void
staleness_sweep(uint64 stamp)
{
    /* if we changed iter param to always be 64 bits we wouldn't need this */
    uint64 *iter_data = (uint64 *) global_alloc(sizeof(*iter_data), HEAPSTAT_STALENESS);
    /* note that depending on the time units in use, and the period between
     * snapshots, this sweep could use the same stamp as the last sweep:
     * that's fine, but should we up the sweep timer?
     */
    *iter_data = stamp;
    ASSERT(options.staleness, "should not get here");
    LOG(2, "\nSTALENESS SWEEP @%"INT64_FORMAT"u\n", stamp);
    malloc_iterate(alloc_itercb_sweep, (void *) iter_data);
    global_free(iter_data, sizeof(*iter_data), HEAPSTAT_STALENESS);
}
Пример #21
0
// Verifies the ROM set while calling SetRomAuditResults	
int MameUIVerifyRomSet(int game)
{
	audit_record *audit;
	int audit_records;
	int res;

	// perform the audit
	audit_records = audit_images(MameUIGlobal(), drivers[game], AUDIT_VALIDATE_FAST, &audit);
	res = ProcessAuditResults(game, audit, audit_records);
	if (audit_records > 0)
		global_free(audit);

	SetRomAuditResults(game, res);
	return res;
}
Пример #22
0
bool midiin_device::call_load(void)
{
	m_midi = machine().osd().create_midi_device();

	if (!m_midi->open_input(filename()))
	{
		global_free(m_midi);
		m_midi = NULL;
		return IMAGE_INIT_FAIL;
	}

	m_timer->adjust(attotime::from_hz(1500), 0, attotime::from_hz(1500));
	m_timer->enable(true);
	return IMAGE_INIT_PASS;
}
Пример #23
0
// Verifies the Sample set while calling SetSampleAuditResults	
int MameUIVerifySampleSet(int game)
{
	audit_record *audit;
	int audit_records;
	int res;

	// perform the audit
	audit_records = audit_samples(MameUIGlobal(), drivers[game], &audit);
	res = ProcessAuditResults(game, audit, audit_records);
	if (audit_records > 0)
		global_free(audit);

	SetSampleAuditResults(game, res);
	return res;
}
Пример #24
0
static void drawdd_window_destroy(win_window_info *window)
{
	dd_info *dd = (dd_info *)window->drawdata;

	// skip if nothing
	if (dd == NULL)
		return;

	// delete the ddraw object
	ddraw_delete(window);

	// free the memory in the window
	global_free(dd);
	window->drawdata = NULL;
}
Пример #25
0
netlist_base_t::~netlist_base_t()
{
	for (int i=0; i < m_nets.count(); i++)
	{
		if (!m_nets[i]->isRailNet())
		{
			global_free(m_nets[i]);
		}
	}

	m_nets.clear();

	m_devices.clear_and_free();

	pstring::resetmem();
}
Пример #26
0
void mini_osd_interface::osd_exit(running_machine &machine)
{	
	write_log("osd_exit called \n");

	global_free(Pad_device[0]);
	global_free(Pad_device[1]);
	global_free(joy_device[0]);
	global_free(joy_device[1]);
	global_free(retrokbd_device);
	global_free(mouse_device);
}
Пример #27
0
file_error common_process_file(emu_options &options, const char *location, bool has_crc, UINT32 crc, const rom_entry *romp, emu_file **image_file)
{
	*image_file = global_alloc(emu_file(options.media_path(), OPEN_FLAG_READ));
	file_error filerr;

	if (has_crc)
		filerr = (*image_file)->open(location, PATH_SEPARATOR, ROM_GETNAME(romp), crc);
	else
		filerr = (*image_file)->open(location, PATH_SEPARATOR, ROM_GETNAME(romp));

	if (filerr != FILERR_NONE)
	{
		global_free(*image_file);
		*image_file = NULL;
	}
	return filerr;
}
Пример #28
0
DR_EXPORT drmf_status_t
drfuzz_exit(void)
{
    int count = dr_atomic_add32_return_sum(&drfuzz_init_count, -1);
    if (count > 0)
        return DRMF_SUCCESS;
    if (count < 0)
        return DRMF_ERROR;

    global_free(callbacks, sizeof(drfuzz_callbacks_t), HEAPSTAT_MISC);

    drmgr_exit();
    drwrap_exit();

    hashtable_delete(&fuzz_target_htable);

    return DRMF_SUCCESS;
}
Пример #29
0
void info_xml_creator::output_devices()
{
	m_drivlist.reset();
	slot_map shortnames;

	while (m_drivlist.next())
	{
		// first, run through devices with roms which belongs to the default configuration
		device_iterator deviter(m_drivlist.config().root_device());
		for (device_t *device = deviter.first(); device != NULL; device = deviter.next())
		{
			if (device->owner() != NULL && device->rom_region() != NULL && device->shortname()!= NULL)
			{
				if (shortnames.add(device->shortname(), 0, FALSE) != TMERR_DUPLICATE)
					output_one_device(*device, device->tag());
			}
		}

		// then, run through slot devices
		slot_interface_iterator iter(m_drivlist.config().root_device());
		for (const device_slot_interface *slot = iter.first(); slot != NULL; slot = iter.next())
		{
			const slot_interface* intf = slot->get_slot_interfaces();
			for (int i = 0; intf && intf[i].name != NULL; i++)
			{
				astring temptag("_");
				temptag.cat(intf[i].name);
				device_t *dev = const_cast<machine_config &>(m_drivlist.config()).device_add(&m_drivlist.config().root_device(), temptag.cstr(), intf[i].devtype, 0);

				// notify this device and all its subdevices that they are now configured
				device_iterator subiter(*dev);
				for (device_t *device = subiter.first(); device != NULL; device = subiter.next())
					if (!device->configured())
						device->config_complete();

				if (shortnames.add(dev->shortname(), 0, FALSE) != TMERR_DUPLICATE)
					output_one_device(*dev, temptag.cstr());

				const_cast<machine_config &>(m_drivlist.config()).device_remove(&m_drivlist.config().root_device(), temptag.cstr());
				global_free(dev);
			}
		}
	}
}
Пример #30
0
static LRESULT unregister_client(HWND hwnd, LPARAM id)
{
	registered_client **client;
	int found = FALSE;

	// find any matching IDs in the list and remove them
	for (client = &clientlist; *client != NULL; client = &(*client)->next)
		if ((*client)->id == id)
		{
			registered_client *temp = *client;
			*client = (*client)->next;
			global_free(temp);
			found = TRUE;
			break;
		}

	// return an error if not found
	return found ? 0 : 1;
}