自学教程：C++ software_entry函数代码示例

image_init_result channelf_cart_slot_device::call_load(){    if (m_cart)    {        uint32_t len = (software_entry() == nullptr) ? length() : get_software_region_length("rom");        m_cart->rom_alloc(len, tag());        if (software_entry() == nullptr)            fread(m_cart->get_rom_base(), len);        else            memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);        if (software_entry() == nullptr)        {            // we default to "chess" slot because some homebrew programs have been written to run            // on PCBs with RAM at $2000-$2800 as Saba Schach!            if (len == 0x40000)                m_type = CF_MULTI;  // TODO1: differentiate multicart final and earlier from fullpath            else                m_type = CF_CHESS;  // TODO2: is there any way to detect Maze and Hangman from fullpath?            m_cart->ram_alloc(0x800);        }        else        {            const char *pcb_name = get_feature("slot");            if (pcb_name)                m_type = chanf_get_pcb_id(pcb_name);            if (get_software_region("ram"))                m_cart->ram_alloc(get_software_region_length("ram"));        }        //printf("Type: %s/n", chanf_get_slot(m_type));        return image_init_result::PASS;    }    return image_init_result::PASS;}

int harddisk_image_device::internal_load_hd(){	astring tempstring;	chd_error err = CHDERR_NONE;	m_chd = NULL;	if (m_hard_disk_handle)		hard_disk_close(m_hard_disk_handle);	/* open the CHD file */	if (software_entry() != NULL)	{		m_chd  = get_disk_handle(device().machine(), device().subtag(tempstring,"harddriv"));	}	else	{		err = m_origchd.open(*image_core_file(), true);		if (err == CHDERR_NONE)		{			m_chd = &m_origchd;		}		else if (err == CHDERR_FILE_NOT_WRITEABLE)		{			err = m_origchd.open(*image_core_file(), false);			if (err == CHDERR_NONE)			{				err = open_disk_diff(device().machine().options(), basename_noext(), m_origchd, m_diffchd);				if (err == CHDERR_NONE)				{					m_chd = &m_diffchd;				}			}		}	}	if (m_chd != NULL)	{		/* open the hard disk file */		m_hard_disk_handle = hard_disk_open(m_chd);		if (m_hard_disk_handle != NULL)			return IMAGE_INIT_PASS;	}	/* if we had an error, close out the CHD */	m_origchd.close();	m_diffchd.close();	m_chd = NULL;	seterror(IMAGE_ERROR_UNSPECIFIED, chd_file::error_string(err));	return IMAGE_INIT_FAIL;}

bool device_image_interface::open_image_file(emu_options &options){	const char* path = options.value(instance_name());	if (strlen(path)>0)	{		set_init_phase();		if (load_internal(path, FALSE, 0, NULL, TRUE)==IMAGE_INIT_PASS)		{			if (software_entry()==NULL) return true;		}	}	return false;}

bool device_image_interface::open_image_file(emu_options &options){	const char* path = options.value(instance_name());	if (*path != 0)	{		set_init_phase();		if (load_internal(path, false, 0, nullptr, true) == image_init_result::PASS)		{			if (software_entry()==nullptr) return true;		}	}	return false;}

image_init_result harddisk_image_device::internal_load_hd(){	chd_error err = CHDERR_NONE;	m_chd = nullptr;	if (m_hard_disk_handle)		hard_disk_close(m_hard_disk_handle);	/* open the CHD file */	if (software_entry() != nullptr)	{		m_chd = machine().rom_load().get_disk_handle(device().subtag("harddriv").c_str());	}	else	{		err = m_origchd.open(image_core_file(), true);		if (err == CHDERR_NONE)		{			m_chd = &m_origchd;		}		else if (err == CHDERR_FILE_NOT_WRITEABLE)		{			err = m_origchd.open(image_core_file(), false);			if (err == CHDERR_NONE)			{				err = open_disk_diff(device().machine().options(), basename_noext(), m_origchd, m_diffchd);				if (err == CHDERR_NONE)				{					m_chd = &m_diffchd;				}			}		}	}	if (m_chd != nullptr)	{		/* open the hard disk file */		m_hard_disk_handle = hard_disk_open(m_chd);		if (m_hard_disk_handle != nullptr)			return image_init_result::PASS;	}	/* if we had an error, close out the CHD */	m_origchd.close();	m_diffchd.close();	m_chd = nullptr;	seterror(IMAGE_ERROR_UNSPECIFIED, chd_file::error_string(err));	return image_init_result::FAIL;}

bool cbm2_expansion_slot_device::call_load(){	size_t size = 0;	if (m_card)	{		if (software_entry() == NULL)		{			size = length();			if (!mame_stricmp(filetype(), "20"))			{				fread(m_card->cbm2_bank1_pointer(machine(), size), size);			}			else if (!mame_stricmp(filetype(), "40"))			{				fread(m_card->cbm2_bank2_pointer(machine(), size), size);			}			else if (!mame_stricmp(filetype(), "60"))			{				fread(m_card->cbm2_bank3_pointer(machine(), size), size);			}		}		else		{			size = get_software_region_length("bank1");			if (size) memcpy(m_card->cbm2_bank1_pointer(machine(), size), get_software_region("bank1"), size);			size = get_software_region_length("bank2");			if (size) memcpy(m_card->cbm2_bank2_pointer(machine(), size), get_software_region("bank2"), size);			size = get_software_region_length("bank3");			if (size) memcpy(m_card->cbm2_bank3_pointer(machine(), size), get_software_region("bank3"), size);			size = get_software_region_length("ram");			if (size) memset(m_card->cbm2_ram_pointer(machine(), size), 0, size);			size = get_software_region_length("nvram");			if (size) memset(m_card->cbm2_nvram_pointer(machine(), size), 0, size);		}	}	return IMAGE_INIT_PASS;}

bool plus4_expansion_slot_device::call_load(){	if (m_card)	{		if (software_entry() == NULL)		{			// TODO		}		else		{			load_software_region("c1l", m_card->m_c1l);			load_software_region("c1h", m_card->m_c1h);			load_software_region("c2l", m_card->m_c2l);			load_software_region("c2h", m_card->m_c2h);		}	}	return IMAGE_INIT_PASS;}

image_init_result vic20_expansion_slot_device::call_load(){	if (m_card)	{		if (software_entry() == nullptr)		{			if (is_filetype("20")) fread(m_card->m_blk1, 0x2000);			else if (is_filetype("40")) fread(m_card->m_blk2, 0x2000);			else if (is_filetype("60")) fread(m_card->m_blk3, 0x2000);			else if (is_filetype("70")) fread(m_card->m_blk3, 0x2000, 0x1000);			else if (is_filetype("a0")) fread(m_card->m_blk5, 0x2000);			else if (is_filetype("b0")) fread(m_card->m_blk5, 0x2000, 0x1000);			else if (is_filetype("crt"))			{				// read the header				uint8_t header[2];				fread(&header, 2);				uint16_t address = (header[1] << 8) | header[0];				switch (address)				{				case 0x2000: fread(m_card->m_blk1, 0x2000); break;				case 0x4000: fread(m_card->m_blk2, 0x2000); break;				case 0x6000: fread(m_card->m_blk3, 0x2000); break;				case 0x7000: fread(m_card->m_blk3, 0x2000, 0x1000); break;				case 0xa000: fread(m_card->m_blk5, 0x2000); break;				case 0xb000: fread(m_card->m_blk5, 0x2000, 0x1000); break;				default: return image_init_result::FAIL;				}			}		}		else		{			load_software_region("blk1", m_card->m_blk1);			load_software_region("blk2", m_card->m_blk2);			load_software_region("blk3", m_card->m_blk3);			load_software_region("blk5", m_card->m_blk5);		}	}	return image_init_result::PASS;}

bool vic20_expansion_slot_device::call_load(){	if (m_card)	{		if (software_entry() == NULL)		{			if (!core_stricmp(filetype(), "20")) fread(m_card->m_blk1, 0x2000);			else if (!core_stricmp(filetype(), "40")) fread(m_card->m_blk2, 0x2000);			else if (!core_stricmp(filetype(), "60")) fread(m_card->m_blk3, 0x2000);			else if (!core_stricmp(filetype(), "70")) fread(m_card->m_blk3, 0x2000, 0x1000);			else if (!core_stricmp(filetype(), "a0")) fread(m_card->m_blk5, 0x2000);			else if (!core_stricmp(filetype(), "b0")) fread(m_card->m_blk5, 0x2000, 0x1000);			else if (!core_stricmp(filetype(), "crt"))			{				// read the header				UINT8 header[2];				fread(&header, 2);				UINT16 address = (header[1] << 8) | header[0];				switch (address)				{				case 0x2000: fread(m_card->m_blk1, 0x2000); break;				case 0x4000: fread(m_card->m_blk2, 0x2000); break;				case 0x6000: fread(m_card->m_blk3, 0x2000); break;				case 0x7000: fread(m_card->m_blk3, 0x2000, 0x1000); break;				case 0xa000: fread(m_card->m_blk5, 0x2000); break;				case 0xb000: fread(m_card->m_blk5, 0x2000, 0x1000); break;				default: return IMAGE_INIT_FAIL;				}			}		}		else		{			load_software_region("blk1", m_card->m_blk1);			load_software_region("blk2", m_card->m_blk2);			load_software_region("blk3", m_card->m_blk3);			load_software_region("blk5", m_card->m_blk5);		}	}	return IMAGE_INIT_PASS;}

bool ql_rom_cartridge_slot_t::call_load(){    if (m_card)    {        size_t size = 0;        if (software_entry() == NULL)        {            size = length();            m_card->m_rom.allocate(size);            fread(m_card->m_rom, size);        }        else        {            load_software_region("rom", m_card->m_rom);        }    }    return IMAGE_INIT_PASS;}

bool cdrom_image_device::call_load(){	chd_error   err = (chd_error)0;	chd_file    *chd = NULL;	astring tempstring;	if (m_cdrom_handle)		cdrom_close(m_cdrom_handle);	if (software_entry() == NULL)	{		if (strstr(m_image_name,".chd") && is_loaded()) {			err = m_self_chd.open( *image_core_file() );    /* CDs are never writeable */			if ( err )				goto error;			chd = &m_self_chd;		}	} else {		chd  = get_disk_handle(device().machine(), device().subtag(tempstring,"cdrom"));	}	/* open the CHD file */	if (chd) {		m_cdrom_handle = cdrom_open( chd );	} else {		m_cdrom_handle = cdrom_open( m_image_name );	}	if ( ! m_cdrom_handle )		goto error;	return IMAGE_INIT_PASS;error:	if ( chd && chd == &m_self_chd )		m_self_chd.close( );	if ( err )		seterror( IMAGE_ERROR_UNSPECIFIED, chd_file::error_string( err ) );	return IMAGE_INIT_FAIL;}

// 128K for Dizzy The Adventurer, 256K for the othersbool nes_aladdin_slot_device::call_load(){	if (m_cart)	{		UINT8 *ROM = m_cart->get_cart_base();		UINT32 size = 0;		if (!ROM)			return IMAGE_INIT_FAIL;		if (software_entry() == NULL)		{			if (length() != 0x20010 && length() != 0x40010)				return IMAGE_INIT_FAIL;			UINT8 temp[0x40010];			size = length() - 0x10;			fread(&temp, length());			memcpy(ROM, temp + 0x10, size);			// double check that iNES files are really mapper 71 or 232			{				UINT8 mapper = (temp[6] & 0xf0) >> 4;				mapper |= temp[7] & 0xf0;				if (mapper != 71 && mapper != 232)					return IMAGE_INIT_FAIL;			}		}		else		{			if (get_software_region_length("rom") != 0x20000 && get_software_region_length("rom") != 0x40000)				return IMAGE_INIT_FAIL;			size = get_software_region_length("rom");			memcpy(ROM, get_software_region("rom"), size);		}		m_cart->set_cart_size(size);	}

image_init_result cdrom_image_device::call_load(){	chd_error   err = (chd_error)0;	chd_file    *chd = nullptr;	if (m_cdrom_handle)		cdrom_close(m_cdrom_handle);	if (software_entry() == nullptr)	{		if (is_filetype("chd") && is_loaded()) {			err = m_self_chd.open( image_core_file() );    /* CDs are never writeable */			if ( err )				goto error;			chd = &m_self_chd;		}	} else {		chd = device().machine().rom_load().get_disk_handle(device().subtag("cdrom").c_str());	}	/* open the CHD file */	if (chd) {		m_cdrom_handle = cdrom_open( chd );	} else {		m_cdrom_handle = cdrom_open(m_image_name.c_str());	}	if ( ! m_cdrom_handle )		goto error;	return image_init_result::PASS;error:	if ( chd && chd == &m_self_chd )		m_self_chd.close( );	if ( err )		seterror( IMAGE_ERROR_UNSPECIFIED, chd_file::error_string( err ) );	return image_init_result::FAIL;}

bool cococart_slot_device::call_load(){	if (m_cart)	{		offs_t read_length = 0;		if (software_entry() == NULL)		{			read_length = fread(m_cart->get_cart_base(), 0x8000);		}		else		{			read_length = get_software_region_length("rom");			memcpy(m_cart->get_cart_base(), get_software_region("rom"), read_length);		}		while(read_length < 0x8000)		{			offs_t len = MIN(read_length, 0x8000 - read_length);			memcpy(m_cart->get_cart_base() + read_length, m_cart->get_cart_base(), len);			read_length += len;		}	}	return IMAGE_INIT_PASS;}

bool adam_expansion_slot_device::call_load(){	if (m_cart)	{		size_t size = 0;		if (software_entry() == NULL)		{			size = length();			fread(m_cart->adam_rom_pointer(machine(), size), size);		}		else		{			size = get_software_region_length("rom");			if (size) memcpy(m_cart->adam_rom_pointer(machine(), size), get_software_region("rom"), size);			size = get_software_region_length("ram");			if (size) memcpy(m_cart->adam_ram_pointer(machine(), size), get_software_region("ram"), size);		}	}	return IMAGE_INIT_PASS;}

bool cbm2_expansion_slot_device::call_load(){	size_t size = 0;	if (m_card)	{		if (software_entry() == NULL)		{			size = length();			if (!core_stricmp(filetype(), "20"))			{				m_card->m_bank1.allocate(size);				fread(m_card->m_bank1, size);			}			else if (!core_stricmp(filetype(), "40"))			{				m_card->m_bank2.allocate(size);				fread(m_card->m_bank2, size);			}			else if (!core_stricmp(filetype(), "60"))			{				m_card->m_bank3.allocate(size);				fread(m_card->m_bank3, size);			}		}		else		{			load_software_region("bank1", m_card->m_bank1);			load_software_region("bank2", m_card->m_bank2);			load_software_region("bank3", m_card->m_bank3);		}	}	return IMAGE_INIT_PASS;}

image_init_result cbm2_expansion_slot_device::call_load(){	size_t size;	if (m_card)	{		if (software_entry() == nullptr)		{			size = length();			if (is_filetype("20"))			{				m_card->m_bank1.allocate(size);				fread(m_card->m_bank1, size);			}			else if (is_filetype("40"))			{				m_card->m_bank2.allocate(size);				fread(m_card->m_bank2, size);			}			else if (is_filetype("60"))			{				m_card->m_bank3.allocate(size);				fread(m_card->m_bank3, size);			}		}		else		{			load_software_region("bank1", m_card->m_bank1);			load_software_region("bank2", m_card->m_bank2);			load_software_region("bank3", m_card->m_bank3);		}	}	return image_init_result::PASS;}

image_init_result videobrain_expansion_slot_device::call_load(){	if (m_cart)	{		size_t size;		if (software_entry() == nullptr)		{			size = length();			fread(m_cart->videobrain_rom_pointer(machine(), size), size);		}		else		{			size = get_software_region_length("rom");			if (size) memcpy(m_cart->videobrain_rom_pointer(machine(), size), get_software_region("rom"), size);			size = get_software_region_length("ram");			if (size) memset(m_cart->videobrain_ram_pointer(machine(), size), 0, size);		}	}	return image_init_result::PASS;}

bool c64_expansion_slot_device::call_load(){	if (m_card)	{		size_t size = 0;		if (software_entry() == NULL)		{			size = length();			if (!mame_stricmp(filetype(), "80"))			{				fread(m_card->m_roml, size);				m_card->m_exrom = (0);				if (size == 0x4000)				{					m_card->m_game = 0;				}			}			else if (!mame_stricmp(filetype(), "a0"))			{				fread(m_card->m_romh, 0x2000);				m_card->m_exrom = 0;				m_card->m_game = 0;			}			else if (!mame_stricmp(filetype(), "e0"))			{				fread(m_card->m_romh, 0x2000);				m_card->m_game = 0;			}			else if (!mame_stricmp(filetype(), "crt"))			{				size_t roml_size = 0;				size_t romh_size = 0;				int exrom = 1;				int game = 1;				if (cbm_crt_read_header(m_file, &roml_size, &romh_size, &exrom, &game))				{					UINT8 *roml = NULL;					UINT8 *romh = NULL;					m_card->m_roml.allocate(roml_size);					m_card->m_romh.allocate(romh_size);					if (roml_size) roml = m_card->m_roml;					if (romh_size) romh = m_card->m_roml;					cbm_crt_read_data(m_file, roml, romh);				}				m_card->m_exrom = exrom;				m_card->m_game = game;			}		}		else		{			size = get_software_region_length("uprom");			if (size)			{				// Ultimax (VIC-10) cartridge				load_software_region("lorom", m_card->m_roml);				load_software_region("uprom", m_card->m_romh);				m_card->m_exrom = 1;				m_card->m_game = 0;			}			else			{				// Commodore 64/128 cartridge				load_software_region("roml", m_card->m_roml);				load_software_region("romh", m_card->m_romh);				load_software_region("nvram", m_card->m_nvram);				if (get_feature("exrom") != NULL) m_card->m_exrom = atol(get_feature("exrom"));				if (get_feature("game") != NULL) m_card->m_game = atol(get_feature("game"));			}		}	}	return IMAGE_INIT_PASS;}

bool vcs_cart_slot_device::call_load(){	UINT8 *ROM;	UINT32 len;	if (software_entry() != NULL)		len = get_software_region_length("rom");	else		len = length();	//printf("Size: 0x%X/n", len);	// check that filesize is among the supported ones	switch (len)	{	case 0x00800:	case 0x01000:	case 0x02000:	case 0x028ff:	case 0x02900:	case 0x03000:	case 0x04000:	case 0x08000:	case 0x10000:	case 0x80000:		break;	default:		seterror(IMAGE_ERROR_UNSUPPORTED, "Invalid rom file size" );		return IMAGE_INIT_FAIL;	}	m_cart->rom_alloc(len);	ROM = m_cart->get_rom_base();	if (software_entry() != NULL)	{		const char *pcb_name;		memcpy(ROM, get_software_region("rom"), len);		if ((pcb_name = get_feature("slot")) != NULL)			m_type = vcs_get_pcb_id(pcb_name);		else		{			// identify type based on size			switch (len)			{				case 0x800:					m_type = A26_2K;					break;				case 0x1000:					m_type = A26_4K;					break;				case 0x2000:					m_type = A26_F8;					break;				case 0x28ff:				case 0x2900:					m_type = A26_DPC;					break;				case 0x3000:					m_type = A26_FA;					break;				case 0x4000:					m_type = A26_F6;					break;				case 0x8000:					m_type = A26_F4;					break;				case 0x10000:					m_type = A26_32IN1;					break;				case 0x80000:					m_type = A26_3F;					break;				default:					m_type = A26_4K;					printf("Unrecognized cart type!/n");					break;			}					}	}	else	{		fread(ROM, len);		m_type = identify_cart_type(ROM, len);	}	//printf("Type: %s/n", vcs_get_slot(m_type));	// check for Special Chip (128bytes of RAM)	if (len == 0x2000 || len == 0x4000 || len == 0x8000)		if (detect_super_chip(ROM, len))		{			m_cart->ram_alloc(0x80);			//printf("Super Chip detected!/n");		}	// Super chip games:	// dig dig, crystal castles, millipede, stargate, defender ii, jr. Pac Man,//.........这里部分代码省略.........

void sega8_cart_slot_device::internal_header_logging(UINT8 *ROM, UINT32 len, UINT32 nvram_len){	static const char *const system_region[] =	{		"",		"",		"",		"Master System Japan",		"Master System Export",		"Game Gear Japan",		"Game Gear Export",		"Game Gear International",		"",		"",		"",		"",		"",		"",		"",		""	};	static int csum_length[] =	{		0x40000,		0x80000,		0x100000,		0,		0,		0,		0,		0,		0,		0,		0x1ff0,		0x3ff0,		0x7ff0,		0xcff0,		0x10000,		0x20000,	};	char reserved[10];	UINT8 version, csum_size, region, serial[3];	UINT16 checksum, csum = 0;	UINT32 csum_end;	// LOG FILE DETAILS	logerror("FILE DETAILS/n" );	logerror("============/n" );	logerror("Name: %s/n", basename());	logerror("File Size: 0x%08x/n", (software_entry() == nullptr) ? (int)length() : (int)get_software_region_length("rom"));	logerror("Detected type: %s/n", sega8_get_slot(m_type));	logerror("ROM (Allocated) Size: 0x%X/n", len);	logerror("RAM: %s/n", nvram_len ? "Yes" : "No");	if (nvram_len)		logerror("RAM (Allocated) Size: 0x%X - Battery: %s/n", nvram_len, m_cart->get_has_battery() ? "Yes" : "No");	logerror("/n" );	// LOG HEADER DETAILS	if (len < 0x8000)		return;	for (int i = 0; i < 10; i++)		reserved[i] = ROM[0x7ff0 + i];	checksum = ROM[0x7ffa] | (ROM[0x7ffb] << 8);	for (int i = 0; i < 3; i++)		serial[i] = ROM[0x7ffc + i];	serial[2] &= 0x0f;	version = (ROM[0x7ffe] & 0xf0) >> 4;	csum_size = ROM[0x7fff] & 0x0f;	csum_end = csum_length[csum_size];	if (!csum_end || csum_end > len)		csum_end = len;	region = (ROM[0x7fff] & 0xf0) >> 4;	// compute cart checksum to compare with expected one	for (int i = 0; i < csum_end; i++)	{		if (i < 0x7ff0 || i >= 0x8000)		{			csum += ROM[i];			csum &= 0xffff;		}	}	logerror("INTERNAL HEADER/n" );	logerror("===============/n" );	logerror("Reserved String: %.10s/n", reserved);	logerror("Region: %s/n", system_region[region]);	logerror("Checksum: (Expected) 0x%x - (Computed) 0x%x/n", checksum, csum);	logerror("   [checksum over 0x%X bytes]/n", csum_length[csum_size]);	logerror("Serial String: %X/n", serial[0] | (serial[1] << 8) | (serial[2] << 16));	logerror("Software Revision: %x/n", version);//.........这里部分代码省略.........

image_init_result sega8_cart_slot_device::call_load(){	if (m_cart)	{		UINT32 len = (software_entry() == nullptr) ? length() : get_software_region_length("rom");		UINT32 offset = 0;		UINT8 *ROM;		if (m_is_card && len > 0x8000)		{			seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a card larger than 32KB");			return image_init_result::FAIL;		}		// check for header		if ((len % 0x4000) == 512)		{			offset = 512;			len -= 512;		}		// make sure that we only get complete (0x4000) rom banks		if (len & 0x3fff)			len = ((len >> 14) + 1) << 14;		m_cart->rom_alloc(len, tag());		ROM = m_cart->get_rom_base();		if (software_entry() == nullptr)		{			fseek(offset, SEEK_SET);			fread(ROM, len);		}		else			memcpy(ROM, get_software_region("rom"), get_software_region_length("rom"));		/* check the image */		if (verify_cart(ROM, len) != image_verify_result::PASS)			logerror("Warning loading image: verify_cart failed/n");		if (software_entry() != nullptr)			m_type = sega8_get_pcb_id(get_feature("slot") ? get_feature("slot") : "rom");		else			m_type = get_cart_type(ROM, len);		set_lphaser_xoffset(ROM, len);		setup_ram();		// Check for gamegear cartridges with PIN 42 set to SMS mode		if (software_entry() != nullptr)		{			const char *pin_42 = get_feature("pin_42");			if (pin_42 && !strcmp(pin_42, "sms_mode"))				m_cart->set_sms_mode(1);		}		// when loading from fullpath m_late_battery_enable can be TRUE and in that case		// we attempt to load a battery because the game might have it!		if (m_cart->get_ram_size() && (m_cart->get_has_battery() || m_cart->get_late_battery()))			battery_load(m_cart->get_ram_base(), m_cart->get_ram_size(), 0x00);		//printf("Type: %s/n", sega8_get_slot(type));		internal_header_logging(ROM + offset, len, m_cart->get_ram_size());		return image_init_result::PASS;	}	return image_init_result::PASS;}

void sega8_cart_slot_device::setup_ram(){	if (software_entry() == nullptr)	{		if (m_type == SEGA8_CASTLE)		{			m_cart->ram_alloc(0x2000);			m_cart->set_has_battery(FALSE);		}		else if (m_type == SEGA8_OTHELLO)		{			m_cart->ram_alloc(0x800);			m_cart->set_has_battery(FALSE);		}		else if (m_type == SEGA8_BASIC_L3)		{			m_cart->ram_alloc(0x8000);			m_cart->set_has_battery(FALSE);		}		else if (m_type == SEGA8_MUSIC_EDITOR)		{			m_cart->ram_alloc(0x2800);			m_cart->set_has_battery(FALSE);		}		else if (m_type == SEGA8_DAHJEE_TYPEA)		{			m_cart->ram_alloc(0x2400);			m_cart->set_has_battery(FALSE);		}		else if (m_type == SEGA8_DAHJEE_TYPEB)		{			m_cart->ram_alloc(0x2000);			m_cart->set_has_battery(FALSE);		}		else if (m_type == SEGA8_CODEMASTERS)		{			// Codemasters cart can have 64KB of RAM (Ernie Els Golf? or 8KB?) and no battery			m_cart->ram_alloc(0x10000);			m_cart->set_has_battery(FALSE);		}		else		{			// for generic carts loaded from fullpath we have no way to know exactly if there was RAM,			// how much RAM was in the cart and if there was a battery so we always alloc 32KB and			// we save its content only if the game enable the RAM			m_cart->set_late_battery(TRUE);			m_cart->ram_alloc(0x08000);		}	}	else	{		// from softlist we rely on the xml to only allocate the correct amount of RAM and to save it only if a battery was present		const char *battery = get_feature("battery");		m_cart->set_late_battery(FALSE);		if (get_software_region_length("ram"))			m_cart->ram_alloc(get_software_region_length("ram"));		if (battery && !strcmp(battery, "yes"))			m_cart->set_has_battery(TRUE);	}}

bool cassette_image_device::call_load(){	casserr_t err;	int cassette_flags;	const char *extension;	int is_writable;	device_image_interface *image = nullptr;	interface(image);	if ((has_been_created()) || (length() == 0))	{		/* creating an image */		err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette);		if (err)			goto error;	}	else	{		/* opening an image */		do		{			is_writable = !is_readonly();			cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;			std::string fname;			if (software_entry()==nullptr) {				extension = filetype();			} else {				fname = m_mame_file->filename();				int loc = fname.find_last_of('.');				if (loc!=-1) {					extension = fname.substr(loc + 1,fname.length()-loc).c_str();				} else {					extension = "";				}			}			err = cassette_open_choices((void *)image, &image_ioprocs, extension, m_formats, cassette_flags, &m_cassette);			/* this is kind of a hack */			if (err && is_writable)				make_readonly();		}		while(err && is_writable);		if (err)			goto error;	}	/* set to default state, but only change the UI state */	change_state(m_default_state, CASSETTE_MASK_UISTATE);	/* reset the position */	m_position = 0.0;	m_position_time = device().machine().time().as_double();	/* default channel to 0, speed multiplier to 1 */	m_channel = 0;	m_speed = 1;	m_direction = 1;	return IMAGE_INIT_PASS;error:	image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;	switch(err)	{		case CASSETTE_ERROR_INTERNAL:			imgerr = IMAGE_ERROR_INTERNAL;			break;		case CASSETTE_ERROR_UNSUPPORTED:			imgerr = IMAGE_ERROR_UNSUPPORTED;			break;		case CASSETTE_ERROR_OUTOFMEMORY:			imgerr = IMAGE_ERROR_OUTOFMEMORY;			break;		case CASSETTE_ERROR_INVALIDIMAGE:			imgerr = IMAGE_ERROR_INVALIDIMAGE;			break;		default:			imgerr = IMAGE_ERROR_UNSPECIFIED;			break;	}	image->seterror(imgerr, "" );	return IMAGE_INIT_FAIL;}

bool crvision_cart_slot_device::call_load(){	if (m_cart)	{		UINT32 size = (software_entry() == nullptr) ? length() : get_software_region_length("rom");		if (size > 0x4800)		{			seterror(IMAGE_ERROR_UNSPECIFIED, "Image extends beyond the expected size for an APF cart");			return IMAGE_INIT_FAIL;		}		m_cart->rom_alloc(size, tag());		if (software_entry() == nullptr)			fread(m_cart->get_rom_base(), size);		else			memcpy(m_cart->get_rom_base(), get_software_region("rom"), size);		if (software_entry() == nullptr)		{			m_type = CRV_4K;			switch (size)			{				case 0x4800:					m_type = CRV_18K;					break;				case 0x4000:					m_type = CRV_16K;					break;				case 0x3000:					m_type = CRV_12K;					break;				case 0x2800:					m_type = CRV_10K;					break;				case 0x2000:					m_type = CRV_8K;					break;				case 0x1800:					m_type = CRV_6K;					break;				case 0x1000:				default:					break;			}		}		else		{			const char *pcb_name = get_feature("slot");			if (pcb_name)				m_type = crvision_get_pcb_id(pcb_name);		}		printf("Type: %s/n", crvision_get_slot(m_type));		return IMAGE_INIT_PASS;	}	return IMAGE_INIT_PASS;}

bool gba_cart_slot_device::call_load(){	if (m_cart)	{		UINT8 *ROM = (UINT8 *)m_cart->get_rom_base();		UINT32 cart_size;		if (software_entry() == NULL)		{			cart_size = length();			if (cart_size > 0x2000000)			{				seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");				return IMAGE_INIT_FAIL;			}			fread(ROM, cart_size);			m_cart->set_rom_size(cart_size);    // we store the actual game size...			m_type = get_cart_type(ROM, cart_size);		}		else		{			const char *pcb_name = get_feature("slot");			cart_size = get_software_region_length("rom");			if (cart_size > 0x2000000)			{				seterror(IMAGE_ERROR_UNSPECIFIED, "Attempted loading a cart larger than 32MB");				return IMAGE_INIT_FAIL;			}			memcpy(ROM, get_software_region("rom"), cart_size);			m_cart->set_rom_size(cart_size);    // we store the actual game size...			if (pcb_name)				m_type = gba_get_pcb_id(pcb_name);			//printf("Type: %s/n", gba_get_slot(m_type));			mame_printf_info("GBA: Detected (XML) %s/n", pcb_name ? pcb_name : "NONE");		}		if (m_type == GBA_SRAM)			m_cart->nvram_alloc(machine(), 0x10000);		// mirror the ROM		switch (cart_size)		{			case 2 * 1024 * 1024:				memcpy(ROM + 0x200000, ROM, 0x200000);				// intentional fall-through			case 4 * 1024 * 1024:				memcpy(ROM + 0x400000, ROM, 0x400000);				// intentional fall-through			case 8 * 1024 * 1024:				memcpy(ROM + 0x800000, ROM, 0x800000);				// intentional fall-through			case 16 * 1024 * 1024:				memcpy(ROM + 0x1000000, ROM, 0x1000000);				break;		}		if (m_cart->get_nvram_size())			battery_load(m_cart->get_nvram_base(), m_cart->get_nvram_size(), 0x00);		return IMAGE_INIT_PASS;	}	return IMAGE_INIT_PASS;}

bool a78_cart_slot_device::call_load(){	if (m_cart)	{		UINT32 len;		if (software_entry() != nullptr)		{			const char *pcb_name;			bool has_ram = get_software_region("ram") ? TRUE : FALSE;			bool has_nvram = get_software_region("nvram") ? TRUE : FALSE;			len = get_software_region_length("rom");			m_cart->rom_alloc(len, tag());			memcpy(m_cart->get_rom_base(), get_software_region("rom"), len);			if ((pcb_name = get_feature("slot")) != nullptr)				m_type = a78_get_pcb_id(pcb_name);			else				m_type = A78_TYPE0;			if (has_ram)				m_cart->ram_alloc(get_software_region_length("ram"));			if (has_nvram)			{				m_cart->nvram_alloc(get_software_region_length("nvram"));				battery_load(m_cart->get_nvram_base(), get_software_region_length("nvram"), 0xff);			}		}		else		{			// Load and check the header			int mapper;			char head[128];			fread(head, 128);			if (verify_header((char *)head) == IMAGE_VERIFY_FAIL)				return IMAGE_INIT_FAIL;			len = (head[49] << 24) | (head[50] << 16) | (head[51] << 8) | head[52];			if (len + 128 > length())			{				logerror("Invalid length in the header. The game might be corrupted./n");				len = length() - 128;			}			// let's try to auto-fix some common errors in the header			mapper = validate_header((head[53] << 8) | head[54], TRUE);			switch (mapper & 0x2e)			{				case 0x0000:					m_type = BIT(mapper, 0) ? A78_TYPE1 : A78_TYPE0;					break;				case 0x0002:					m_type = BIT(mapper, 0) ? A78_TYPE3 : A78_TYPE2;					break;				case 0x0006:					m_type = A78_TYPE6;					break;				case 0x000a:					m_type = A78_TYPEA;					break;				case 0x0022:				case 0x0026:					if (len > 0x40000)						m_type = A78_MEGACART;					else						m_type = A78_VERSABOARD;					break;			}			// check if cart has a POKEY at $0450 (typically a VersaBoard variant)			if (mapper & 0x40)			{				if (m_type != A78_TYPE2)				{					m_type &= ~0x02;					m_type += A78_POKEY0450;				}			}			// check special bits, which override the previous			if ((mapper & 0xff00) == 0x0100)				m_type = A78_ACTIVISION;			else if ((mapper & 0xff00) == 0x0200)				m_type = A78_ABSOLUTE;			logerror("Cart type: 0x%x/n", m_type);			if (head[58] == 1)			{				osd_printf_info("This cart supports external NVRAM using HSC./n");				osd_printf_info("Run it with the High Score Cart mounted to exploit this feature./n");			}			else if (head[58] == 2)			{				osd_printf_info("This cart supports external NVRAM using SaveKey./n");				osd_printf_info("This is not supported in MAME currently./n");			}//.........这里部分代码省略.........

int cartslot_image_device::load_cartridge(const rom_entry *romrgn, const rom_entry *roment, bool load){	const char *region;	const char *type;	UINT32 flags;	offs_t offset, size, read_length, pos = 0, len;	UINT8 *ptr;	UINT8 clear_val;	int datawidth, littleendian, i, j;	device_t *cpu;	astring regiontag;	device().siblingtag(regiontag, ROMREGION_GETTAG(romrgn));	region = regiontag.cstr();	offset = ROM_GETOFFSET(roment);	size = ROM_GETLENGTH(roment);	flags = ROM_GETFLAGS(roment);	ptr = ((UINT8 *) device().machine().root_device().memregion(region)->base()) + offset;	if (load)	{		if (software_entry() == NULL)		{			/* must this be full size */			if (flags & ROM_FULLSIZE)			{				if (length() != size)					return IMAGE_INIT_FAIL;			}			/* read the ROM */			pos = read_length = fread(ptr, size);			/* reset the ROM to the initial point. */			/* eventually, we could add a flag to allow the ROM to continue instead of restarting whenever a new cart region is present */			fseek(0, SEEK_SET);		}		else		{			/* must this be full size */			if (flags & ROM_FULLSIZE)			{				if (get_software_region_length("rom") != size)					return IMAGE_INIT_FAIL;			}			/* read the ROM */			pos = read_length = get_software_region_length("rom");			memcpy(ptr, get_software_region("rom"), read_length);		}		/* do we need to mirror the ROM? */		if (flags & ROM_MIRROR)		{			while(pos < size)			{				len = MIN(read_length, size - pos);				memcpy(ptr + pos, ptr, len);				pos += len;			}		}		/* postprocess this region */		type = regiontag.cstr();		littleendian = ROMREGION_ISLITTLEENDIAN(romrgn);		datawidth = ROMREGION_GETWIDTH(romrgn) / 8;		/* if the region is inverted, do that now */		device_memory_interface *memory;		cpu = device().machine().device(type);		if (cpu!=NULL && cpu->interface(memory))		{			datawidth = cpu->memory().space_config(AS_PROGRAM)->m_databus_width / 8;			littleendian = (cpu->memory().space_config()->m_endianness == ENDIANNESS_LITTLE);		}		/* swap the endianness if we need to */#ifdef LSB_FIRST		if (datawidth > 1 && !littleendian)#else		if (datawidth > 1 && littleendian)#endif		{			for (i = 0; i < size; i += datawidth)			{				UINT8 temp[8];				memcpy(temp, &ptr[i], datawidth);				for (j = datawidth - 1; j >= 0; j--)					ptr[i + j] = temp[datawidth - 1 - j];			}		}	}	/* clear out anything that remains */	if (!(flags & ROM_NOCLEAR))	{		clear_val = (flags & ROM_FILL_FF) ? 0xFF : 0x00;		memset(ptr + pos, clear_val, size - pos);	}	return IMAGE_INIT_PASS;//.........这里部分代码省略.........

bool msx_slot_cartridge_device::call_load(){	if ( m_cartridge )	{		if ( software_entry() )		{			UINT32 length;			// Allocate and copy rom contents			length = get_software_region_length("rom");			m_cartridge->rom_alloc( length );			if (length > 0)			{				UINT8 *rom_base = m_cartridge->get_rom_base();				memcpy(rom_base, get_software_region("rom"), length);			}			// Allocate and copy vlm5030 rom contents			length = get_software_region_length("vlm5030");			m_cartridge->rom_vlm5030_alloc(length);			if (length > 0)			{				UINT8 *rom_base = m_cartridge->get_rom_vlm5030_base();				memcpy(rom_base, get_software_region("vlm5030"), length);			}			// Allocate ram			length = get_software_region_length("ram");			m_cartridge->ram_alloc( length );			// Allocate sram			length = get_software_region_length("sram");			m_cartridge->sram_alloc( length );		}		else		{			UINT32 length = this->length();			// determine how much space to allocate			UINT32 length_aligned = 0x10000;			if (length <= 0x2000)				length_aligned = 0x2000;			else if (length <= 0x4000)				length_aligned = 0x4000;			else if (length <= 0x8000)				length_aligned = 0x8000;			else if (length <= 0xc000)				length_aligned = 0xc000;			else			{				while (length_aligned < length )					length_aligned *= 2;			}			m_cartridge->rom_alloc(length_aligned);			m_cartridge->ram_alloc(0);			m_cartridge->sram_alloc(0);			if (fread(m_cartridge->get_rom_base(), length) != length)			{				seterror(IMAGE_ERROR_UNSPECIFIED, "Unable to fully read file");				return IMAGE_INIT_FAIL;			}			// Check if there's some mapper related			std::string extrainfo;			if (hashfile_extrainfo(*this, extrainfo))			{			}		}		m_cartridge->set_out_irq_cb(DEVCB_WRITELINE(msx_slot_cartridge_device, irq_out));		m_cartridge->initialize_cartridge();		if (m_cartridge->get_sram_size() > 0)		{			battery_load(m_cartridge->get_sram_base(), m_cartridge->get_sram_size(), 0x00);		}	}	return IMAGE_INIT_PASS;}