C++ device_image_interface::is_readonly方法代码示例

static void atari_load_proc(device_image_interface &image)
{
	atari_fdc_t *fdc = get_safe_token(image.device().owner());
	int id = floppy_get_drive(image);
	int size, i;
	const char *ext;

	fdc->drv[id].image = auto_alloc_array(image.device().machine(),UINT8,MAXSIZE);
	if (!fdc->drv[id].image)
		return;

	/* tell whether the image is writable */
	fdc->drv[id].mode = !image.is_readonly();
	/* set up image if it has been created */
	if (image.has_been_created())
	{
		int sector;
		char buff[256];
		memset(buff, 0, sizeof(buff));
		/* default to 720 sectors */
		for( sector = 0; sector < 720; sector++ )
			image.fwrite(buff, 256);
		image.fseek(0, SEEK_SET);
	}

	size = image.fread(fdc->drv[id].image, MAXSIZE);

	if( size <= 0 )
	{
		fdc->drv[id].image = NULL;
		return;
	}


	/* re allocate the buffer; we don't want to be too lazy ;) */
	//fdc->drv[id].image = (UINT8*)image.image_realloc(fdc->drv[id].image, size);

	ext = image.filetype();

	// hack alert, this means we can only load ATR via the softlist at the moment, image.filetype reutrns NULL :/
	if (image.software_entry() != NULL) ext="ATR";

	/* no extension: assume XFD format (no header) */
	if (!ext)
	{
		fdc->drv[id].type = FORMAT_XFD;
		fdc->drv[id].header_skip = 0;
	}
	else
	/* XFD extension */
	if( toupper(ext[0])=='X' && toupper(ext[1])=='F' && toupper(ext[2])=='D' )
	{
		fdc->drv[id].type = FORMAT_XFD;
		fdc->drv[id].header_skip = 0;
	}
	else
	/* ATR extension */
	if( toupper(ext[0])=='A' && toupper(ext[1])=='T' && toupper(ext[2])=='R' )
	{
		fdc->drv[id].type = FORMAT_ATR;
		fdc->drv[id].header_skip = 16;
	}
	else
	/* DSK extension */
	if( toupper(ext[0])=='D' && toupper(ext[1])=='S' && toupper(ext[2])=='K' )
	{
		fdc->drv[id].type = FORMAT_DSK;
		fdc->drv[id].header_skip = sizeof(dsk_format);
	}
	else
	{
		fdc->drv[id].type = FORMAT_XFD;
		fdc->drv[id].header_skip = 0;
	}

	if( fdc->drv[id].type == FORMAT_ATR &&
		(fdc->drv[id].image[0] != 0x96 || fdc->drv[id].image[1] != 0x02) )
	{
		fdc->drv[id].type = FORMAT_XFD;
		fdc->drv[id].header_skip = 0;
	}


	switch (fdc->drv[id].type)
	{
	/* XFD or unknown format: find a matching size from the table */
	case FORMAT_XFD:
		for( i = 0; xfd_formats[i].size; i++ )
		{
			if( size == xfd_formats[i].size )
			{
				fdc->drv[id].density = xfd_formats[i].dsk.density;
				fdc->drv[id].tracks = xfd_formats[i].dsk.tracks;
				fdc->drv[id].spt = xfd_formats[i].dsk.spt;
				fdc->drv[id].heads = (xfd_formats[i].dsk.doublesided) ? 2 : 1;
				fdc->drv[id].bseclen = 128;
				fdc->drv[id].seclen = 256 * xfd_formats[i].dsk.seclen_hi + xfd_formats[i].dsk.seclen_lo;
				fdc->drv[id].sectors = fdc->drv[id].tracks * fdc->drv[id].heads * fdc->drv[id].spt;
				break;
			}
//.........这里部分代码省略.........

void atari_fdc_device::atari_load_proc(device_image_interface &image, bool is_created)
{
    int id = floppy_get_drive(image);
    int size, i;

    m_drv[id].image = std::make_unique<uint8_t[]>(MAXSIZE);
    if (!m_drv[id].image)
        return;

    /* tell whether the image is writable */
    m_drv[id].mode = !image.is_readonly();
    /* set up image if it has been created */
    if (is_created)
    {
        int sector;
        char buff[256];
        memset(buff, 0, sizeof(buff));
        /* default to 720 sectors */
        for( sector = 0; sector < 720; sector++ )
            image.fwrite(buff, 256);
        image.fseek(0, SEEK_SET);
    }

    size = image.fread(m_drv[id].image.get(), MAXSIZE);

    if( size <= 0 )
    {
        m_drv[id].image = nullptr;
        return;
    }


    /* re allocate the buffer; we don't want to be too lazy ;) */
    //m_drv[id].image = (uint8_t*)image.image_realloc(m_drv[id].image, size);

    // hack alert, this means we can only load ATR via the softlist at the moment, image.filetype returns "" :/
    bool is_softlist_entry = image.software_entry() != nullptr;

    /* no extension: assume XFD format (no header) */
    if (image.is_filetype("") && !is_softlist_entry)
    {
        m_drv[id].type = FORMAT_XFD;
        m_drv[id].header_skip = 0;
    }
    else
        /* XFD extension */
        if( image.is_filetype("xfd") )
        {
            m_drv[id].type = FORMAT_XFD;
            m_drv[id].header_skip = 0;
        }
        else
            /* ATR extension */
            if( image.is_filetype("atr") || is_softlist_entry)
            {
                m_drv[id].type = FORMAT_ATR;
                m_drv[id].header_skip = 16;
            }
            else
                /* DSK extension */
                if( image.is_filetype("dsk") )
                {
                    m_drv[id].type = FORMAT_DSK;
                    m_drv[id].header_skip = sizeof(atari_dsk_format);
                }
                else
                {
                    m_drv[id].type = FORMAT_XFD;
                    m_drv[id].header_skip = 0;
                }

    if( m_drv[id].type == FORMAT_ATR &&
            (m_drv[id].image[0] != 0x96 || m_drv[id].image[1] != 0x02) )
    {
        m_drv[id].type = FORMAT_XFD;
        m_drv[id].header_skip = 0;
    }


    switch (m_drv[id].type)
    {
    /* XFD or unknown format: find a matching size from the table */
    case FORMAT_XFD:
        for( i = 0; xfd_formats[i].size; i++ )
        {
            if( size == xfd_formats[i].size )
            {
                m_drv[id].density = xfd_formats[i].dsk.density;
                m_drv[id].tracks = xfd_formats[i].dsk.tracks;
                m_drv[id].spt = xfd_formats[i].dsk.spt;
                m_drv[id].heads = (xfd_formats[i].dsk.doublesided) ? 2 : 1;
                m_drv[id].bseclen = 128;
                m_drv[id].seclen = 256 * xfd_formats[i].dsk.seclen_hi + xfd_formats[i].dsk.seclen_lo;
                m_drv[id].sectors = m_drv[id].tracks * m_drv[id].heads * m_drv[id].spt;
                break;
            }
        }
        break;
    /* ATR format: find a size including the 16 bytes header */
    case FORMAT_ATR:
//.........这里部分代码省略.........