np2/statsave.c - diff

Return to statsave.c CVS log

Up to [RetroPC.NET] / np2

Diff for /np2/statsave.c between versions 1.17 and 1.20

version 1.17, 2003/11/15 07:10:02	version 1.20, 2003/12/12 01:04:39
Line 4	Line 4
#include "scrnmng.h"	#include "scrnmng.h"
#include "soundmng.h"	#include "soundmng.h"
#include "timemng.h"	#include "timemng.h"
#include "i286.h"	#include "cpucore.h"
#include "memory.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "cbuscore.h"	#include "cbuscore.h"
Line 57 enum {	Line 56 enum {
NP2FLAG_BIN = 0,	NP2FLAG_BIN = 0,
NP2FLAG_TERM,	NP2FLAG_TERM,
NP2FLAG_CLOCK,	NP2FLAG_CLOCK,
	NP2FLAG_COM,
	NP2FLAG_DISK,
NP2FLAG_DMA,	NP2FLAG_DMA,
NP2FLAG_EGC,	NP2FLAG_EGC,
NP2FLAG_EXT,
NP2FLAG_EVT,	NP2FLAG_EVT,
NP2FLAG_GIJ,	NP2FLAG_EXT,
NP2FLAG_FM,	NP2FLAG_FM,
NP2FLAG_COM,	NP2FLAG_GIJ,
NP2FLAG_DISK	NP2FLAG_MEM
};	};

typedef struct {	typedef struct {
Line 337 static int flagsave_term(NP2FFILE f, con	Line 337 static int flagsave_term(NP2FFILE f, con
}	}


// ----	// ---- common

static int flagsave_common(NP2FFILE f, const STENTRY *t) {	static int flagsave_common(NP2FFILE f, const STENTRY *t) {

Line 357 static int flagload_common(NP2FFILE f, c	Line 357 static int flagload_common(NP2FFILE f, c
}	}


// -----	// ----- clock

static int flagload_clock(NP2FFILE f, const STENTRY *t) {	static int flagload_clock(NP2FFILE f, const STENTRY *t) {

Line 370 static int flagload_clock(NP2FFILE f, co	Line 370 static int flagload_clock(NP2FFILE f, co
}	}


// -----	// ---- memory

	static int flagsave_mem(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagsave_create(f, t);
	if (ret != NP2FLAG_FAILURE) {
	ret \|= flagsave_save(f, mem, 0x110000);
	ret \|= flagsave_save(f, mem + VRAM1_B, 0x18000);
	ret \|= flagsave_save(f, mem + VRAM1_E, 0x8000);
	ret \|= flagsave_close(f);
	}
	return(ret);
	}

	static int flagload_mem(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagload_load(f, mem, 0x110000);
	ret \|= flagload_load(f, mem + VRAM1_B, 0x18000);
	ret \|= flagload_load(f, mem + VRAM1_E, 0x8000);
	(void)t;
	return(ret);
	}


	// ---- ext memory

	static int flagsave_ext(NP2FFILE f, const STENTRY *t) {

	int ret;

	ret = flagsave_create(f, t);
	if (ret != NP2FLAG_FAILURE) {
	ret \|= flagsave_save(f, &extmem, sizeof(extmem));
	if (CPU_EXTMEM) {
	ret \|= flagsave_save(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
	}
	ret \|= flagsave_close(f);
	}
	return(ret);
	}

	static int flagload_ext(NP2FFILE f, const STENTRY *t) {

	int ret;
	int i;
	UINT pagemax = 0;

	ret = flagload_load(f, &extmem, sizeof(extmem));
	if (extmem.maxmem) {
	if (extmem.maxmem > (13+1)) {
	extmem.maxmem = (13+1);
	}
	if (!extmemmng_realloc(extmem.maxmem - 1)) {
	pagemax = (extmem.maxmem - 1) << 8;
	if (CPU_EXTMEM) {
	ret \|= flagload_load(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
	}
	}
	else {
	extmem.maxmem = 0;
	}
	}
	for (i=0; i<4; i++) {
	if (extmem.page[i] < pagemax) {
	extmem.pageptr[i] = CPU_EXTMEM + (extmem.page[i] << 12);
	}
	else {
	extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
	}
	}
	(void)t;
	return(ret);
	}


	// ---- dma

static int flagsave_dma(NP2FFILE f, const STENTRY *t) {	static int flagsave_dma(NP2FFILE f, const STENTRY *t) {

Line 420 static int flagload_dma(NP2FFILE f, cons	Line 499 static int flagload_dma(NP2FFILE f, cons
}	}


// -----	// ---- egc

static int flagsave_egc(NP2FFILE f, const STENTRY *t) {	static int flagsave_egc(NP2FFILE f, const STENTRY *t) {

Line 451 static int flagload_egc(NP2FFILE f, cons	Line 530 static int flagload_egc(NP2FFILE f, cons
}	}


// -----	// ---- event

static int flagsave_ext(NP2FFILE f, const STENTRY *t) {

int ret;

ret = flagsave_create(f, t);
if (ret != NP2FLAG_FAILURE) {
ret \|= flagsave_save(f, &extmem, sizeof(extmem));
if (extmemmng_size) {
ret \|= flagsave_save(f, extmemmng_ptr, extmemmng_size);
}
ret \|= flagsave_close(f);
}
return(ret);
}

static int flagload_ext(NP2FFILE f, const STENTRY *t) {

int ret;
int i;
UINT pagemax = 0;

ret = flagload_load(f, &extmem, sizeof(extmem));
if (extmem.maxmem) {
if (extmem.maxmem > (13+1)) {
extmem.maxmem = (13+1);
}
if (!extmemmng_realloc(extmem.maxmem - 1)) {
pagemax = (extmem.maxmem - 1) << 8;
if (extmemmng_size) {
ret \|= flagload_load(f, extmemmng_ptr, extmemmng_size);
}
}
else {
extmem.maxmem = 0;
}
}
for (i=0; i<4; i++) {
if (extmem.page[i] < pagemax) {
extmem.pageptr[i] = extmemmng_ptr + (extmem.page[i] << 12);
}
else {
extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
}
}
(void)t;
return(ret);
}


// -----

typedef struct {	typedef struct {
UINT readyevents;	UINT readyevents;
Line 615 static int flagload_evt(NP2FFILE f, cons	Line 643 static int flagload_evt(NP2FFILE f, cons
}	}


// ----	// ---- gaiji

static int flagsave_gij(NP2FFILE f, const STENTRY *t) {	static int flagsave_gij(NP2FFILE f, const STENTRY *t) {

Line 658 static int flagload_gij(NP2FFILE f, cons	Line 686 static int flagload_gij(NP2FFILE f, cons
}	}


// -----	// ---- FM

enum {	enum {
FLAG_MG = 0x0001,	FLAG_MG = 0x0001,
Line 1092 static int flagload_disk(NP2FFILE f, con	Line 1120 static int flagload_disk(NP2FFILE f, con
}	}


// -----	// ---- com

static int flagsave_com(NP2FFILE f, const STENTRY *t) {	static int flagsave_com(NP2FFILE f, const STENTRY *t) {

Line 1218 int statsave_save(const char *filename)	Line 1246 int statsave_save(const char *filename)

_NP2FFILE f;	_NP2FFILE f;
int ret;	int ret;
UINT i;	const STENTRY *tbl;
	const STENTRY *tblterm;

ret = flagcreate(&f, filename);	ret = flagcreate(&f, filename);
if (ret == NP2FLAG_FAILURE) {	if (ret == NP2FLAG_FAILURE) {
return(ret);	return(ret);
}	}
for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {	tbl = np2tbl;
switch(np2tbl[i].type) {	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
	while(tbl < tblterm) {
	switch(tbl->type) {
case NP2FLAG_BIN:	case NP2FLAG_BIN:
case NP2FLAG_CLOCK:	case NP2FLAG_CLOCK:
ret \|= flagsave_common(&f, &np2tbl[i]);	ret \|= flagsave_common(&f, tbl);
break;	break;

case NP2FLAG_TERM:	case NP2FLAG_TERM:
ret \|= flagsave_term(&f, &np2tbl[i]);	ret \|= flagsave_term(&f, tbl);
break;	break;

case NP2FLAG_DMA:	case NP2FLAG_COM:
ret \|= flagsave_dma(&f, &np2tbl[i]);	ret \|= flagsave_com(&f, tbl);
break;	break;

case NP2FLAG_EGC:	case NP2FLAG_DISK:
ret \|= flagsave_egc(&f, &np2tbl[i]);	ret \|= flagsave_disk(&f, tbl);
break;	break;

case NP2FLAG_EXT:	case NP2FLAG_DMA:
ret \|= flagsave_ext(&f, &np2tbl[i]);	ret \|= flagsave_dma(&f, tbl);
	break;

	case NP2FLAG_EGC:
	ret \|= flagsave_egc(&f, tbl);
break;	break;

case NP2FLAG_EVT:	case NP2FLAG_EVT:
ret \|= flagsave_evt(&f, &np2tbl[i]);	ret \|= flagsave_evt(&f, tbl);
break;	break;

case NP2FLAG_GIJ:	case NP2FLAG_EXT:
ret \|= flagsave_gij(&f, &np2tbl[i]);	ret \|= flagsave_ext(&f, tbl);
break;	break;

case NP2FLAG_FM:	case NP2FLAG_FM:
ret \|= flagsave_fm(&f, &np2tbl[i]);	ret \|= flagsave_fm(&f, tbl);
break;	break;

case NP2FLAG_DISK:	case NP2FLAG_GIJ:
ret \|= flagsave_disk(&f, &np2tbl[i]);	ret \|= flagsave_gij(&f, tbl);
break;	break;

case NP2FLAG_COM:	case NP2FLAG_MEM:
ret \|= flagsave_com(&f, &np2tbl[i]);	ret \|= flagsave_mem(&f, tbl);
break;	break;
}	}
	tbl++;
}	}
flagclose(&f);	flagclose(&f);
return(ret);	return(ret);
Line 1274 int statsave_save(const char *filename)	Line 1310 int statsave_save(const char *filename)

int statsave_check(const char filename, char buf, int size) {	int statsave_check(const char filename, char buf, int size) {

	ERR_BUF e;
_NP2FFILE f;	_NP2FFILE f;
int ret;	int ret;
UINT i;
BOOL done;	BOOL done;
ERR_BUF e;	const STENTRY *tbl;
	const STENTRY *tblterm;

e.buf = buf;	e.buf = buf;
e.remain = size;	e.remain = size;
Line 1300 int statsave_check(const char *filename,	Line 1337 int statsave_check(const char *filename,
ret \|= flagload_create(&f);	ret \|= flagload_create(&f);
CopyMemory(index, f.p.index, sizeof(f.p.index));	CopyMemory(index, f.p.index, sizeof(f.p.index));
index[10] = 0;	index[10] = 0;
for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {	tbl = np2tbl;
if (!strcmp(index, np2tbl[i].index)) {	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
	while(tbl < tblterm) {
	if (!strcmp(index, tbl->index)) {
break;	break;
}	}
	tbl++;
}	}
if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {	if (tbl < tblterm) {
switch(np2tbl[i].type) {	switch(tbl->type) {
case NP2FLAG_BIN:	case NP2FLAG_BIN:
case NP2FLAG_CLOCK:	case NP2FLAG_CLOCK:
ret \|= flagcheck_versize(&f, &np2tbl[i], &e);	case NP2FLAG_MEM:
	ret \|= flagcheck_versize(&f, tbl, &e);
break;	break;

case NP2FLAG_TERM:	case NP2FLAG_TERM:
done = TRUE;	done = TRUE;
break;	break;

	case NP2FLAG_COM:
case NP2FLAG_DMA:	case NP2FLAG_DMA:
case NP2FLAG_EGC:	case NP2FLAG_EGC:
case NP2FLAG_EXT:
case NP2FLAG_EVT:	case NP2FLAG_EVT:
	case NP2FLAG_EXT:
case NP2FLAG_GIJ:	case NP2FLAG_GIJ:
case NP2FLAG_COM:	case NP2FLAG_FM:
ret \|= flagcheck_veronly(&f, &np2tbl[i], &e);	ret \|= flagcheck_veronly(&f, tbl, &e);
break;	break;

case NP2FLAG_DISK:	case NP2FLAG_DISK:
ret \|= flagcheck_disk(&f, &np2tbl[i], &e);	ret \|= flagcheck_disk(&f, tbl, &e);
break;

case NP2FLAG_FM: // ver0.31
break;	break;

default:	default:
Line 1354 int statsave_load(const char *filename)	Line 1393 int statsave_load(const char *filename)

_NP2FFILE f;	_NP2FFILE f;
int ret;	int ret;
UINT i;
BOOL done;	BOOL done;
	const STENTRY *tbl;
	const STENTRY *tblterm;

ret = flagopen(&f, filename, NULL);	ret = flagopen(&f, filename, NULL);
if (ret == NP2FLAG_FAILURE) {	if (ret == NP2FLAG_FAILURE) {
Line 1375 int statsave_load(const char *filename)	Line 1415 int statsave_load(const char *filename)
ret \|= flagload_create(&f);	ret \|= flagload_create(&f);
CopyMemory(index, f.p.index, sizeof(f.p.index));	CopyMemory(index, f.p.index, sizeof(f.p.index));
index[10] = 0;	index[10] = 0;
for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {	tbl = np2tbl;
if (!strcmp(index, np2tbl[i].index)) {	tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
	while(tbl < tblterm) {
	if (!strcmp(index, tbl->index)) {
break;	break;
}	}
	tbl++;
}	}
if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {	if (tbl < tblterm) {
switch(np2tbl[i].type) {	switch(tbl->type) {
case NP2FLAG_BIN:	case NP2FLAG_BIN:
ret \|= flagload_common(&f, &np2tbl[i]);	ret \|= flagload_common(&f, tbl);
break;	break;

case NP2FLAG_TERM:	case NP2FLAG_TERM:
Line 1391 int statsave_load(const char *filename)	Line 1434 int statsave_load(const char *filename)
break;	break;

case NP2FLAG_CLOCK:	case NP2FLAG_CLOCK:
ret \|= flagload_clock(&f, &np2tbl[i]);	ret \|= flagload_clock(&f, tbl);
break;	break;

case NP2FLAG_DMA:	case NP2FLAG_COM:
ret \|= flagload_dma(&f, &np2tbl[i]);	ret \|= flagload_com(&f, tbl);
break;	break;

case NP2FLAG_EGC:	case NP2FLAG_DISK:
ret \|= flagload_egc(&f, &np2tbl[i]);	ret \|= flagload_disk(&f, tbl);
break;	break;

case NP2FLAG_EXT:	case NP2FLAG_DMA:
ret \|= flagload_ext(&f, &np2tbl[i]);	ret \|= flagload_dma(&f, tbl);
	break;

	case NP2FLAG_EGC:
	ret \|= flagload_egc(&f, tbl);
break;	break;

case NP2FLAG_EVT:	case NP2FLAG_EVT:
ret \|= flagload_evt(&f, &np2tbl[i]);	ret \|= flagload_evt(&f, tbl);
break;	break;

case NP2FLAG_GIJ:	case NP2FLAG_EXT:
ret \|= flagload_gij(&f, &np2tbl[i]);	ret \|= flagload_ext(&f, tbl);
break;	break;

case NP2FLAG_FM:	case NP2FLAG_FM:
ret \|= flagload_fm(&f, &np2tbl[i]);	ret \|= flagload_fm(&f, tbl);
break;	break;

case NP2FLAG_DISK:	case NP2FLAG_GIJ:
ret \|= flagload_disk(&f, &np2tbl[i]);	ret \|= flagload_gij(&f, tbl);
break;	break;

case NP2FLAG_COM:	case NP2FLAG_MEM:
ret \|= flagload_com(&f, &np2tbl[i]);	ret \|= flagload_mem(&f, tbl);
break;	break;

default:	default:

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.17
changed lines
	Added in v.1.20