np2/common/profile.c - diff

Return to profile.c CVS log

Up to [RetroPC.NET] / np2 / common

Diff for /np2/common/profile.c between versions 1.10 and 1.13

version 1.10, 2004/06/12 15:32:52	version 1.13, 2005/03/20 06:09:16
Line 5	Line 5
#include "profile.h"	#include "profile.h"


static void strdelspace(char *buf, int size) {	static void strdelspace(OEMCHAR *buf, int size) {

char *p;	OEMCHAR *p;
int len;	int len;

p = *buf;	p = *buf;
Line 23 static void strdelspace(char **buf, int	Line 23 static void strdelspace(char **buf, int
*size = len;	*size = len;
}	}

static char profana(char buf, char **data) {	static OEMCHAR profana(OEMCHAR buf, OEMCHAR **data) {

int len;	int len;
char *buf2;	OEMCHAR *buf2;
int l;	int l;

len = strlen(buf);	len = OEMSTRLEN(buf);
strdelspace(&buf, &len);	strdelspace(&buf, &len);
if ((len >= 2) && (buf[0] == '[') && (buf[len - 1] == ']')) {	if ((len >= 2) && (buf[0] == '[') && (buf[len - 1] == ']')) {
buf++;	buf++;
Line 62 static char profana(char buf, char **d	Line 62 static char profana(char buf, char **d
return(NULL);	return(NULL);
}	}

BOOL profile_enum(const char filename, void arg,	BOOL profile_enum(const OEMCHAR filename, void arg,
BOOL (proc)(void arg, const char *para,	BOOL (proc)(void arg, const OEMCHAR *para,
const char key, const char data)) {	const OEMCHAR key, const OEMCHAR data)) {
TEXTFILEH fh;	TEXTFILEH fh;
BOOL r;	BOOL r;
char buf[0x200];	OEMCHAR buf[0x200];
char para[0x100];	OEMCHAR para[0x100];
char *key;	OEMCHAR *key;
char *data;	OEMCHAR *data;

r = FALSE;	r = FALSE;
if (proc == NULL) {	if (proc == NULL) {
Line 82 BOOL profile_enum(const char *filename,	Line 82 BOOL profile_enum(const char *filename,
}	}
para[0] = '\0';	para[0] = '\0';
while(1) {	while(1) {
if (textfile_read(fh, buf, sizeof(buf)) != SUCCESS) {	if (textfile_read(fh, buf, NELEMENTS(buf)) != SUCCESS) {
break;	break;
}	}
key = profana(buf, &data);	key = profana(buf, &data);
if (key) {	if (key) {
if (data == NULL) {	if (data == NULL) {
milstr_ncpy(para, key, sizeof(para));	milstr_ncpy(para, key, NELEMENTS(para));
}	}
else {	else {
r = proc(arg, para, key, data);	r = proc(arg, para, key, data);
Line 107 gden_err0:	Line 107 gden_err0:

// ----	// ----

const char profile_getarg(const char str, char *buf, UINT leng) {	const OEMCHAR profile_getarg(const OEMCHAR str, OEMCHAR *buf, UINT leng) {

UINT8 c;	UINT8 c;

Line 149 const char profile_getarg(const char s	Line 149 const char profile_getarg(const char s
// ---- �ޤ��ƥ��	// ---- �ޤ��ƥ��

typedef struct {	typedef struct {
UINT applen;	UINT applen;
UINT keylen;	UINT keylen;
UINT pos;	UINT pos;
UINT size;	UINT size;
UINT apphit;	UINT apphit;
const char *data;	const OEMCHAR *data;
UINT datasize;	UINT datasize;
} PFPOS;	} PFPOS;

static char delspace(const char buf, UINT *len) {	#define PFBUFSIZE (1 << 8)

	static OEMCHAR delspace(const OEMCHAR buf, UINT *len) {

UINT l;	UINT l;

Line 173 static char delspace(const char buf, U	Line 175 static char delspace(const char buf, U
}	}
*len = l;	*len = l;
}	}
return((char *)buf);	return((OEMCHAR *)buf);
}	}

static BOOL seakey(PFILEH hdl, PFPOS pfp, const char app, const char *key) {	static BRESULT seakey(PFILEH hdl, PFPOS pfp, const OEMCHAR app,
	const OEMCHAR *key) {

PFPOS ret;	PFPOS ret;
UINT pos;	UINT pos;
UINT size;	UINT size;
char *buf;	OEMCHAR *buf;
UINT len;	UINT len;
UINT cnt;	UINT cnt;

Line 189 static BOOL seakey(PFILEH hdl, PFPOS *pf	Line 192 static BOOL seakey(PFILEH hdl, PFPOS *pf
return(FAILURE);	return(FAILURE);
}	}
ZeroMemory(&ret, sizeof(ret));	ZeroMemory(&ret, sizeof(ret));
ret.applen = strlen(app);	ret.applen = OEMSTRLEN(app);
ret.keylen = strlen(key);	ret.keylen = OEMSTRLEN(key);
if ((ret.applen == 0) \|\| (ret.keylen == 0)) {	if ((ret.applen == 0) \|\| (ret.keylen == 0)) {
return(FAILURE);	return(FAILURE);
}	}
Line 259 static BOOL seakey(PFILEH hdl, PFPOS *pf	Line 262 static BOOL seakey(PFILEH hdl, PFPOS *pf
return(SUCCESS);	return(SUCCESS);
}	}

static BOOL replace(PFILEH hdl, UINT pos, UINT size1, UINT size2) {	static BRESULT replace(PFILEH hdl, UINT pos, UINT size1, UINT size2) {

UINT cnt;	UINT cnt;
UINT size;	UINT newsize;
char *p;	OEMCHAR *p;
char *q;	OEMCHAR *q;

size1 += pos;	size1 += pos;
size2 += pos;	size2 += pos;
Line 273 static BOOL replace(PFILEH hdl, UINT pos	Line 276 static BOOL replace(PFILEH hdl, UINT pos
}	}
cnt = hdl->size - size1;	cnt = hdl->size - size1;
if (size1 < size2) {	if (size1 < size2) {
size = size2 - size1;	newsize = hdl->size + size2 - size1;
if ((hdl->size + size) > hdl->buffers) {	if (newsize > hdl->buffers) {
return(FAILURE);	newsize = (newsize & (PFBUFSIZE - 1)) + PFBUFSIZE;
	p = (OEMCHAR )_MALLOC(newsize sizeof(OEMCHAR), "profile");
	if (p == NULL) {
	return(FAILURE);
	}
	CopyMemory(p, hdl->buffer, hdl->buffers * sizeof(OEMCHAR));
	if (hdl->buffer) {
	_MFREE(hdl->buffer);
	}
	hdl->buffer = p;
	hdl->buffers = newsize;
}	}
hdl->size += size;	hdl->size = newsize;
if (cnt) {	if (cnt) {
p = hdl->buffer + size1;	p = hdl->buffer + size1;
q = hdl->buffer + size2;	q = hdl->buffer + size2;
Line 301 static BOOL replace(PFILEH hdl, UINT pos	Line 314 static BOOL replace(PFILEH hdl, UINT pos
return(SUCCESS);	return(SUCCESS);
}	}

PFILEH profile_open(const char *filename, UINT flag) {	static PFILEH registfile(FILEH fh) {

FILEH fh;	UINT hdrsize;
UINT filesize;	UINT srcwidth;
	BOOL xendian;
	UINT rsize;
	UINT8 hdr[4];
UINT size;	UINT size;
	UINT newsize;
	OEMCHAR *buf;
PFILEH ret;	PFILEH ret;

if (filename == NULL) {	hdrsize = 0;
goto pfore_err1;	srcwidth = 1;
	xendian = FALSE;
	rsize = file_read(fh, hdr, sizeof(hdr));
	if ((rsize >= 3) &&
	(hdr[0] == 0xef) && (hdr[1] == 0xbb) && (hdr[2] == 0xbf)) {
	// UTF-8
	hdrsize = 3;
	}
	else if ((rsize >= 2) && (hdr[0] == 0xff) && (hdr[1] == 0xfe)) {
	// UCSLE
	hdrsize = 2;
	srcwidth = 2;
	#if defined(BYTESEX_BIG)
	xendian = TRUE;
	#endif
	}
	else if ((rsize >= 2) && (hdr[0] == 0xfe) && (hdr[1] == 0xff)) {
	// UCS2BE
	hdrsize = 2;
	srcwidth = 2;
	#if defined(BYTESEX_LITTLE)
	xendian = TRUE;
	#endif
	}

	if (srcwidth != sizeof(OEMCHAR)) {
	goto rf_err1;
}	}
fh = file_open(filename);	size = file_getsize(fh);
filesize = 0;	if (size < hdrsize) {
if (fh != FILEH_INVALID) {	goto rf_err1;
filesize = file_getsize(fh);
}	}
else if (flag & PFILEH_READONLY) {	if (file_seek(fh, (long)hdrsize, FSEEK_SET) != (long)hdrsize) {
goto pfore_err1;	goto rf_err1;
}	}
else {	size = (size - hdrsize) / srcwidth;
fh = file_create(filename);	newsize = (size & (PFBUFSIZE - 1)) + PFBUFSIZE;
if (fh == FILEH_INVALID) {	buf = (OEMCHAR )_MALLOC(newsize srcwidth, "profile");
goto pfore_err1;	if (buf == NULL) {
}	goto rf_err1;
}	}
size = filesize + 0x2000;	rsize = file_read(fh, buf, newsize * srcwidth) / srcwidth;
ret = (PFILEH)_MALLOC(sizeof(_PFILEH) + size, filename);
	ret = (PFILEH)_MALLOC(sizeof(_PFILEH), "profile");
if (ret == NULL) {	if (ret == NULL) {
goto pfore_err2;	goto rf_err2;
}	}
if (filesize) {	ZeroMemory(ret, sizeof(_PFILEH));
if (file_read(fh, ret + 1, filesize) != filesize) {	ret->buffer = buf;
goto pfore_err3;	ret->buffers = newsize;
}	ret->size = rsize;
	if (hdrsize) {
	CopyMemory(ret->hdr, hdr, hdrsize);
}	}
file_close(fh);	ret->hdrsize = hdrsize;
ret->buffer = (char *)(ret + 1);
ret->buffers = size;
ret->size = filesize;
ret->flag = flag;
file_cpyname(ret->path, filename, sizeof(ret->path));
return(ret);	return(ret);

pfore_err3:	rf_err2:
_MFREE(ret);	_MFREE(buf);

	rf_err1:
	return(NULL);
	}

	static PFILEH registnew(void) {

pfore_err2:	const UINT8 *hdr;
file_close(fh);	UINT hdrsize;
	PFILEH ret;

	#if defined(OSLANG_UTF8)
	hdr = str_utf8;
	hdrsize = sizeof(str_utf8);
	#elif defined(OSLANG_UCS2)
	hdr = (UINT8 *)str_ucs2;
	hdrsize = sizeof(str_ucs2);
	#else
	hdr = NULL;
	hdrsize = 0;
	#endif

pfore_err1:	ret = (PFILEH)_MALLOC(sizeof(_PFILEH), "profile");
	if (ret == NULL) {
	goto rn_err;
	}
	ZeroMemory(ret, sizeof(_PFILEH));
	// ret->buffer = NULL;
	// ret->buffers = 0;
	// ret->size = 0;
	if (hdrsize) {
	CopyMemory(ret->hdr, hdr, hdrsize);
	}
	ret->hdrsize = hdrsize;
	return(ret);

	rn_err:
return(NULL);	return(NULL);
}	}

	PFILEH profile_open(const OEMCHAR *filename, UINT flag) {

	PFILEH ret;
	FILEH fh;

	ret = NULL;
	if (filename != NULL) {
	fh = file_open_rb(filename);
	if (fh != FILEH_INVALID) {
	ret = registfile(fh);
	file_close(fh);
	}
	else if (flag & PFILEH_READONLY) {
	}
	else {
	ret = registnew();
	}
	}
	if (ret) {
	ret->flag = flag;
	file_cpyname(ret->path, filename, NELEMENTS(ret->path));
	}
	return(ret);
	}

void profile_close(PFILEH hdl) {	void profile_close(PFILEH hdl) {

FILEH fh;	FILEH fh;
Line 361 void profile_close(PFILEH hdl) {	Line 459 void profile_close(PFILEH hdl) {
if (hdl->flag & PFILEH_MODIFY) {	if (hdl->flag & PFILEH_MODIFY) {
fh = file_create(hdl->path);	fh = file_create(hdl->path);
if (fh != FILEH_INVALID) {	if (fh != FILEH_INVALID) {
file_write(fh, hdl->buffer, hdl->size);	file_write(fh, hdl->hdr, hdl->hdrsize);
	file_write(fh, hdl->buffer, hdl->size * sizeof(OEMCHAR));
file_close(fh);	file_close(fh);
}	}
}	}
Line 369 void profile_close(PFILEH hdl) {	Line 468 void profile_close(PFILEH hdl) {
}	}
}	}

BOOL profile_read(const char app, const char key, const char *def,	BRESULT profile_read(const OEMCHAR app, const OEMCHAR key,
char *ret, UINT size, PFILEH hdl) {	const OEMCHAR def, OEMCHAR ret, UINT size, PFILEH hdl) {

PFPOS pfp;	PFPOS pfp;

Line 388 BOOL profile_read(const char *app, const	Line 487 BOOL profile_read(const char *app, const
}	}
}	}

BOOL profile_write(const char app, const char key,	BRESULT profile_write(const OEMCHAR app, const OEMCHAR key,
const char *data, PFILEH hdl) {	const OEMCHAR *data, PFILEH hdl) {

PFPOS pfp;	PFPOS pfp;
UINT newsize;	UINT newsize;
UINT datalen;	UINT datalen;
char *buf;	OEMCHAR *buf;

if ((hdl == NULL) \|\| (hdl->flag & PFILEH_READONLY) \|\|	if ((hdl == NULL) \|\| (hdl->flag & PFILEH_READONLY) \|\|
(data == NULL) \|\| (seakey(hdl, &pfp, app, key) != SUCCESS)) {	(data == NULL) \|\| (seakey(hdl, &pfp, app, key) != SUCCESS)) {
Line 424 BOOL profile_write(const char *app, cons	Line 523 BOOL profile_write(const char *app, cons
#endif	#endif
pfp.pos += newsize;	pfp.pos += newsize;
}	}
datalen = strlen(data);	datalen = OEMSTRLEN(data);
newsize = pfp.keylen + 1 + datalen;	newsize = pfp.keylen + 1 + datalen;
#if defined(OSLINEBREAK_CR) \|\| defined(OSLINEBREAK_CRLF)	#if defined(OSLINEBREAK_CR) \|\| defined(OSLINEBREAK_CRLF)
newsize++;	newsize++;
Line 450 BOOL profile_write(const char *app, cons	Line 549 BOOL profile_write(const char *app, cons
return(SUCCESS);	return(SUCCESS);
}	}

static void bitmapset(BYTE *ptr, UINT pos, BOOL set) {
	// ----

	static void bitmapset(UINT8 *ptr, UINT pos, BOOL set) {

UINT8 bit;	UINT8 bit;

Line 464 static void bitmapset(BYTE *ptr, UINT po	Line 566 static void bitmapset(BYTE *ptr, UINT po
}	}
}	}

static BOOL bitmapget(const BYTE *ptr, UINT pos) {	static BOOL bitmapget(const UINT8 *ptr, UINT pos) {

return((ptr[pos >> 3] >> (pos & 7)) & 1);	return((ptr[pos >> 3] >> (pos & 7)) & 1);
}	}

static void binset(BYTE bin, UINT binlen, const char src) {	static void binset(UINT8 bin, UINT binlen, const OEMCHAR src) {

UINT i;	UINT i;
BYTE val;	UINT8 val;
BOOL set;	BOOL set;
char c;	OEMCHAR c;

for (i=0; i<binlen; i++) {	for (i=0; i<binlen; i++) {
val = 0;	val = 0;
Line 509 static void binset(BYTE *bin, UINT binle	Line 611 static void binset(BYTE *bin, UINT binle
}	}
}	}

static void binget(char work, int size, const BYTE bin, UINT binlen) {	static void binget(OEMCHAR work, int size, const UINT8 bin, UINT binlen) {

UINT i;	UINT i;
char tmp[8];	OEMCHAR tmp[8];

if (binlen) {	if (binlen) {
SPRINTF(tmp, "%.2x", bin[0]);	OEMSPRINTF(tmp, OEMTEXT("%.2x"), bin[0]);
milstr_ncpy(work, tmp, size);	milstr_ncpy(work, tmp, size);
}	}
for (i=1; i<binlen; i++) {	for (i=1; i<binlen; i++) {
SPRINTF(tmp, " %.2x", bin[i]);	OEMSPRINTF(tmp, OEMTEXT(" %.2x"), bin[i]);
milstr_ncat(work, tmp, size);	milstr_ncat(work, tmp, size);
}	}
}	}

void profile_iniread(const char path, const char app,	void profile_iniread(const OEMCHAR path, const OEMCHAR app,
const PFTBL *tbl, UINT count, PFREAD cb) {	const PFTBL *tbl, UINT count, PFREAD cb) {

PFILEH pfh;	PFILEH pfh;
const PFTBL *p;	const PFTBL *p;
const PFTBL *pterm;	const PFTBL *pterm;
char work[512];	OEMCHAR work[512];

pfh = profile_open(path, 0);	pfh = profile_open(path, 0);
if (pfh == NULL) {	if (pfh == NULL) {
Line 541 const PFTBL *pterm;	Line 643 const PFTBL *pterm;
while(p < pterm) {	while(p < pterm) {
if (profile_read(app, p->item, NULL, work, sizeof(work), pfh)	if (profile_read(app, p->item, NULL, work, sizeof(work), pfh)
== SUCCESS) {	== SUCCESS) {
switch(p->itemtype & PFITYPE_MASK) {	switch(p->itemtype & PFTYPE_MASK) {
case PFTYPE_STR:	case PFTYPE_STR:
milstr_ncpy(p->value, work, p->arg);	milstr_ncpy(p->value, work, p->arg);
break;	break;
Line 551 const PFTBL *pterm;	Line 653 const PFTBL *pterm;
break;	break;

case PFTYPE_BITMAP:	case PFTYPE_BITMAP:
bitmapset((BYTE *)p->value, p->arg,	bitmapset((UINT8 *)p->value, p->arg,
(!milstr_cmp(work, str_true))?TRUE:FALSE);	(!milstr_cmp(work, str_true))?TRUE:FALSE);
break;	break;

case PFTYPE_BIN:	case PFTYPE_BIN:
binset((BYTE *)p->value, p->arg, work);	binset((UINT8 *)p->value, p->arg, work);
break;	break;

case PFTYPE_SINT8:	case PFTYPE_SINT8:
Line 598 const PFTBL *pterm;	Line 700 const PFTBL *pterm;
profile_close(pfh);	profile_close(pfh);
}	}

void profile_iniwrite(const char path, const char app,	void profile_iniwrite(const OEMCHAR path, const OEMCHAR app,
const PFTBL *tbl, UINT count, PFWRITE cb) {	const PFTBL *tbl, UINT count, PFWRITE cb) {

PFILEH pfh;	PFILEH pfh;
const PFTBL *p;	const PFTBL *p;
const PFTBL *pterm;	const PFTBL *pterm;
const char *set;	const OEMCHAR *set;
char work[512];	OEMCHAR work[512];

pfh = profile_open(path, 0);	pfh = profile_open(path, 0);
if (pfh == NULL) {	if (pfh == NULL) {
Line 617 const char *set;	Line 719 const char *set;
if (!(p->itemtype & PFFLAG_RO)) {	if (!(p->itemtype & PFFLAG_RO)) {
work[0] = '\0';	work[0] = '\0';
set = work;	set = work;
switch(p->itemtype & PFITYPE_MASK) {	switch(p->itemtype & PFTYPE_MASK) {
case PFTYPE_STR:	case PFTYPE_STR:
set = (char *)p->value;	set = (OEMCHAR *)p->value;
break;	break;

case PFTYPE_BOOL:	case PFTYPE_BOOL:
Line 627 const char *set;	Line 729 const char *set;
break;	break;

case PFTYPE_BITMAP:	case PFTYPE_BITMAP:
set = (bitmapget((BYTE *)p->value, p->arg))?	set = (bitmapget((UINT8 *)p->value, p->arg))?
str_true:str_false;	str_true:str_false;
break;	break;

case PFTYPE_BIN:	case PFTYPE_BIN:
binget(work, sizeof(work), (BYTE *)p->value, p->arg);	binget(work, NELEMENTS(work), (UINT8 *)p->value, p->arg);
break;	break;

case PFTYPE_SINT8:	case PFTYPE_SINT8:
SPRINTF(work, str_d, ((SINT8 )p->value));	OEMSPRINTF(work, str_d, ((SINT8 )p->value));
break;	break;

case PFTYPE_SINT16:	case PFTYPE_SINT16:
SPRINTF(work, str_d, ((SINT16 )p->value));	OEMSPRINTF(work, str_d, ((SINT16 )p->value));
break;	break;

case PFTYPE_SINT32:	case PFTYPE_SINT32:
SPRINTF(work, str_d, ((SINT32 )p->value));	OEMSPRINTF(work, str_d, ((SINT32 )p->value));
break;	break;

case PFTYPE_UINT8:	case PFTYPE_UINT8:
SPRINTF(work, str_u, ((UINT8 )p->value));	OEMSPRINTF(work, str_u, ((UINT8 )p->value));
break;	break;

case PFTYPE_UINT16:	case PFTYPE_UINT16:
SPRINTF(work, str_u, ((UINT16 )p->value));	OEMSPRINTF(work, str_u, ((UINT16 )p->value));
break;	break;

case PFTYPE_UINT32:	case PFTYPE_UINT32:
SPRINTF(work, str_u, ((UINT32 )p->value));	OEMSPRINTF(work, str_u, ((UINT32 )p->value));
break;	break;

case PFTYPE_HEX8:	case PFTYPE_HEX8:
SPRINTF(work, str_x, ((UINT8 )p->value));	OEMSPRINTF(work, str_x, ((UINT8 )p->value));
break;	break;

case PFTYPE_HEX16:	case PFTYPE_HEX16:
SPRINTF(work, str_x, ((UINT16 )p->value));	OEMSPRINTF(work, str_x, ((UINT16 )p->value));
break;	break;

case PFTYPE_HEX32:	case PFTYPE_HEX32:
SPRINTF(work, str_x, ((UINT32 )p->value));	OEMSPRINTF(work, str_x, ((UINT32 )p->value));
break;	break;

default:	default:
if (cb != NULL) {	if (cb != NULL) {
set = (*cb)(p, work, sizeof(work));	set = (*cb)(p, work, NELEMENTS(work));
}	}
else {	else {
set = NULL;	set = NULL;

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

Removed from v.1.10
changed lines
	Added in v.1.13