Exemple #1
0
const char * Nes_State_::read_blocks( Nes_File_Reader& in )
{
    while ( true )
    {
        RETURN_ERR( in.next_block() );
        switch ( in.block_tag() )
        {
        case nes_state_t::tag:
            memset( &nes, 0, sizeof nes );
            RETURN_ERR( read_nes_state( in, &nes ) );
            set_nes_state( nes );
            break;

        case cpu_state_t::tag: {
            cpu_state_t s;
            memset( &s, 0, sizeof s );
            RETURN_ERR( read_nes_state( in, &s ) );
            cpu->pc = s.pc;
            cpu->sp = s.s;
            cpu->a = s.a;
            cpu->x = s.x;
            cpu->y = s.y;
            cpu->status = s.p;
            cpu_valid = true;
            break;
        }

        case ppu_state_t::tag:
            memset( ppu, 0, sizeof *ppu );
            RETURN_ERR( read_nes_state( in, ppu ) );
            ppu_valid = true;
            break;

        case apu_state_t::tag:
            memset( apu, 0, sizeof *apu );
            RETURN_ERR( read_nes_state( in, apu ) );
            apu_valid = true;
            break;

        case joypad_state_t::tag:
            memset( joypad, 0, sizeof *joypad );
            RETURN_ERR( read_nes_state( in, joypad ) );
            joypad_valid = true;
            break;

        case FOUR_CHAR('MAPR'):
            mapper->size = in.remain();
            RETURN_ERR( in.read_block_data( mapper->data, sizeof mapper->data ) );
            mapper_valid = true;
            break;

        case FOUR_CHAR('SPRT'):
            spr_ram_valid = true;
            RETURN_ERR( in.read_block_data( spr_ram, spr_ram_size ) );
            break;

        case FOUR_CHAR('NTAB'):
            nametable_size = in.remain();
            RETURN_ERR( in.read( nametable, 0x800 ) );
            if ( nametable_size > 0x800 )
                RETURN_ERR( in.read( chr, 0x800 ) );
            break;

        case FOUR_CHAR('LRAM'):
            ram_valid = true;
            RETURN_ERR( in.read_block_data( ram, ram_size ) );
            break;

        case FOUR_CHAR('CHRR'):
            chr_size = in.remain();
            RETURN_ERR( in.read_block_data( chr, chr_max ) );
            break;

        case FOUR_CHAR('SRAM'):
            sram_size = in.remain();
            RETURN_ERR( in.read_block_data( sram, sram_max ) );
            break;

        default:
            return 0;
        }
    }
}
blargg_err_t Nes_Snapshot::read_blocks( Nes_File_Reader& in )
{
	while ( true )
	{
		BLARGG_RETURN_ERR( in.next_block() );
		switch ( in.block_tag() )
		{
			case nes.tag:
				memset( &nes, 0, sizeof nes );
				BLARGG_RETURN_ERR( read_nes_state( in, &nes ) );
				set_nes_state( nes );
				break;
			
			case cpu_state_t::tag: {
				cpu_state_t s;
				memset( &s, 0, sizeof s );
				BLARGG_RETURN_ERR( read_nes_state( in, &s ) );
				cpu.pc = s.pc;
				cpu.sp = s.s;
				cpu.a = s.a;
				cpu.x = s.x;
				cpu.y = s.y;
				cpu.status = s.p;
				cpu_valid = true;
				break;
			}
			
			case ppu.tag:
				memset( &ppu, 0, sizeof ppu );
				BLARGG_RETURN_ERR( read_nes_state( in, &ppu ) );
				ppu_valid = true;
				break;
			
			case apu.tag:
				memset( &apu, 0, sizeof apu );
				BLARGG_RETURN_ERR( read_nes_state( in, &apu ) );
				apu_valid = true;
				break;
			
			case joypad.tag:
				memset( &joypad, 0, sizeof joypad );
				BLARGG_RETURN_ERR( read_nes_state( in, &joypad ) );
				joypad_valid = true;
				break;
			
			case 'MAPR':
				mapper.size = in.remain();
				BLARGG_RETURN_ERR( in.read_block_data( mapper.data, sizeof mapper.data ) );
				mapper_valid = true;
				break;
			
			case 'SPRT':
				spr_ram_valid = true;
				BLARGG_RETURN_ERR( in.read_block_data( spr_ram, sizeof spr_ram ) );
				break;
				
			case 'NTAB':
				nametable_size = in.remain();
				BLARGG_RETURN_ERR( in.read_block_data( nametable, sizeof nametable ) );
				break;
				
			case 'LRAM':
				ram_valid = true;
				BLARGG_RETURN_ERR( in.read_block_data( ram, sizeof ram ) );
				break;
				
			case 'CHRR':
				chr_size = in.remain();
				BLARGG_RETURN_ERR( in.read_block_data( chr, sizeof chr ) );
				break;
				
			case 'SRAM':
				sram_size = in.remain();
				BLARGG_RETURN_ERR( in.read_block_data( sram, sizeof sram ) );
				break; 
			
			default:
				return blargg_success;
		}
	}
}