np2/common/milstr.c - diff

Return to milstr.c CVS log

Up to [RetroPC.NET] / np2 / common

Diff for /np2/common/milstr.c between versions 1.4 and 1.13

version 1.4, 2003/11/21 06:51:10	version 1.13, 2005/02/07 14:46:08
Line 1	Line 1
#include "compiler.h"	#include "compiler.h"


	// ---- ANK / UCS2 / UCS4
// ---- ANK

#if defined(SUPPORT_ANK)	#if defined(SUPPORT_ANK)
int milank_cmp(const char str, const char cmp) {	int STRCALL milank_charsize(const OEMCHAR *str) {

	return((str[0] != '\0')?1:0);
	}

	int STRCALL milank_cmp(const OEMCHAR str, const OEMCHAR cmp) {

int s;	int s;
int c;	int c;

do {	do {
s = (BYTE)*str++;	s = *str++;
if (((s - 'a') & 0xff) < 26) {	if ((s >= 'a') && (s <= 'z')) {
s -= 0x20;	s -= 0x20;
}	}
c = (BYTE)*cmp++;	c = *cmp++;
if (((c - 'a') & 0xff) < 26) {	if ((c >= 'a') && (c <= 'z')) {
c -= 0x20;	c -= 0x20;
}	}
if (s != c) {	if (s != c) {
Line 26 int milank_cmp(const char *str, const ch	Line 30 int milank_cmp(const char *str, const ch
return(0);	return(0);
}	}

int milank_memcmp(const char str, const char cmp) {	int STRCALL milank_memcmp(const OEMCHAR str, const OEMCHAR cmp) {

int s;	int s;
int c;	int c;

do {	do {
c = (BYTE)*cmp++;	c = *cmp++;
if (c == 0) {	if (c == 0) {
return(0);	return(0);
}	}
if (((c - 'a') & 0xff) < 26) {	if ((c >= 'a') && (c <= 'z')) {
c -= 0x20;	c -= 0x20;
}	}
s = (BYTE)*str++;	s = *str++;
if (((s - 'a') & 0xff) < 26) {	if ((s >= 'a') && (s <= 'z')) {
s -= 0x20;	s -= 0x20;
}	}
} while(s == c);	} while(s == c);
return((s > c)?1:-1);	return((s > c)?1:-1);
}	}

void milank_ncpy(char dst, const char src, int maxlen) {	void STRCALL milank_ncpy(OEMCHAR dst, const OEMCHAR src, int maxlen) {

int i;	int i;

Line 60 void milank_ncpy(char dst, const char	Line 64 void milank_ncpy(char dst, const char
}	}
}	}

void milank_ncat(char dst, const char src, int maxlen) {	void STRCALL milank_ncat(OEMCHAR dst, const OEMCHAR src, int maxlen) {

int i;	int i;
int j;	int j;
Line 78 void milank_ncat(char dst, const char	Line 82 void milank_ncat(char dst, const char
dst[i] = '\0';	dst[i] = '\0';
}	}
}	}

	OEMCHAR * STRCALL milank_chr(const OEMCHAR *str, int c) {

	int s;

	if (str) {
	do {
	s = *str;
	if (s == c) {
	return((OEMCHAR *)str);
	}
	str++;
	} while(s);
	}
	return(NULL);
	}
#endif	#endif


// ---- Shift-JIS	// ---- Shift-JIS

#if defined(SUPPORT_SJIS)	#if defined(SUPPORT_SJIS)
int milsjis_cmp(const char str, const char cmp) {	int STRCALL milsjis_charsize(const char *str) {

	int pos;

	pos = ((((str[0] ^ 0x20) - 0xa1) & 0xff) < 0x3c)?1:0;
	return((str[pos] != '\0')?(pos+1):0);
	}

	int STRCALL milsjis_cmp(const char str, const char cmp) {

int s;	int s;
int c;	int c;

do {	do {
s = (BYTE)*str++;	s = (UINT8)*str++;
if ((((s ^ 0x20) - 0xa1) & 0xff) < 0x3c) {	if ((((s ^ 0x20) - 0xa1) & 0xff) < 0x3c) {
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if (s != c) {	if (s != c) {
goto mscp_err;	goto mscp_err;
}	}
s = (BYTE)*str++;	s = (UINT8)*str++;
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
}	}
else {	else {
if (((s - 'a') & 0xff) < 26) {	if (((s - 'a') & 0xff) < 26) {
s -= 0x20;	s -= 0x20;
}	}
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if (((c - 'a') & 0xff) < 26) {	if (((c - 'a') & 0xff) < 26) {
c -= 0x20;	c -= 0x20;
}	}
Line 118 mscp_err:	Line 146 mscp_err:
return((s > c)?1:-1);	return((s > c)?1:-1);
}	}

int milsjis_memcmp(const char str, const char cmp) {	int STRCALL milsjis_memcmp(const char str, const char cmp) {

int s;	int s;
int c;	int c;

do {	do {
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if ((((c ^ 0x20) - 0xa1) & 0xff) < 0x3c) {	if ((((c ^ 0x20) - 0xa1) & 0xff) < 0x3c) {
s = (BYTE)*str++;	s = (UINT8)*str++;
if (c != s) {	if (c != s) {
break;	break;
}	}
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
s = (BYTE)*str++;	s = (UINT8)*str++;
}	}
else if (c) {	else if (c) {
if (((c - 'a') & 0xff) < 26) {	if (((c - 'a') & 0xff) < 26) {
c &= ~0x20;	c &= ~0x20;
}	}
s = (BYTE)*str++;	s = (UINT8)*str++;
if (((s - 'a') & 0xff) < 26) {	if (((s - 'a') & 0xff) < 26) {
s &= ~0x20;	s &= ~0x20;
}	}
Line 149 int milsjis_memcmp(const char *str, cons	Line 177 int milsjis_memcmp(const char *str, cons
return((s > c)?1:-1);	return((s > c)?1:-1);
}	}

int milsjis_kanji1st(const char *str, int pos) {	int STRCALL milsjis_kanji1st(const char *str, int pos) {

int ret;	int ret;

Line 161 int milsjis_kanji1st(const char *str, in	Line 189 int milsjis_kanji1st(const char *str, in
return(ret);	return(ret);
}	}

int milsjis_kanji2nd(const char *str, int pos) {	int STRCALL milsjis_kanji2nd(const char *str, int pos) {

int ret = 0;	int ret;

	ret = 0;
while((pos > 0) && ((((str[--pos] ^ 0x20) - 0xa1) & 0xff) < 0x3c)) {	while((pos > 0) && ((((str[--pos] ^ 0x20) - 0xa1) & 0xff) < 0x3c)) {
ret ^= 1;	ret ^= 1;
}	}
return(ret);	return(ret);
}	}

void milsjis_ncpy(char dst, const char src, int maxlen) {	void STRCALL milsjis_ncpy(char dst, const char src, int maxlen) {

int i;	int i;

Line 189 void milsjis_ncpy(char *dst, const char	Line 218 void milsjis_ncpy(char *dst, const char
}	}
}	}

void milsjis_ncat(char dst, const char src, int maxlen) {	void STRCALL milsjis_ncat(char dst, const char src, int maxlen) {

int i;	int i;
int j;	int j;
Line 212 void milsjis_ncat(char *dst, const char	Line 241 void milsjis_ncat(char *dst, const char
dst[i] = '\0';	dst[i] = '\0';
}	}
}	}

	char * STRCALL milsjis_chr(const char *str, int c) {

	int s;

	if (str) {
	do {
	s = *str;
	if (s == c) {
	return((char *)str);
	}
	if ((((s ^ 0x20) - 0xa1) & 0xff) < 0x3c) {
	str++;
	s = *str;
	}
	str++;
	} while(s);
	}
	return(NULL);
	}
#endif	#endif


// ---- EUC	// ---- EUC

#if defined(SUPPORT_EUC)	#if defined(SUPPORT_EUC) // �� Ⱦ�ѥ��˺��Ƥ뤾��
int mileuc_cmp(const char str, const char cmp) {	int STRCALL mileuc_charsize(const char *str) {

	int pos;

	pos = (str[0] & 0x80)?1:0;
	return((str[pos] != '\0')?(pos+1):0);
	}

	int STRCALL mileuc_cmp(const char str, const char cmp) {

int s;	int s;
int c;	int c;

do {	do {
s = (BYTE)*str++;	s = (UINT8)*str++;
if (((s - 0xa1) & 0xff) < 0x5d) {	if (s & 0x80) {
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if (s != c) {	if (s != c) {
goto mscp_err;	goto mscp_err;
}	}
s = (BYTE)*str++;	s = (UINT8)*str++;
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
}	}
else {	else {
if (((s - 'a') & 0xff) < 26) {	if (((s - 'a') & 0xff) < 26) {
s -= 0x20;	s -= 0x20;
}	}
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if (((c - 'a') & 0xff) < 26) {	if (((c - 'a') & 0xff) < 26) {
c -= 0x20;	c -= 0x20;
}	}
Line 252 mscp_err:	Line 309 mscp_err:
return((s > c)?1:-1);	return((s > c)?1:-1);
}	}

int mileuc_memcmp(const char str, const char cmp) {	int STRCALL mileuc_memcmp(const char str, const char cmp) {

int s;	int s;
int c;	int c;

do {	do {
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if (((c - 0xa1) & 0xff) < 0x5d) {	if (c & 0x80) {
s = (BYTE)*str++;	s = (UINT8)*str++;
if (c != s) {	if (c != s) {
break;	break;
}	}
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
s = (BYTE)*str++;	s = (UINT8)*str++;
}	}
else if (c) {	else if (c) {
if (((c - 'a') & 0xff) < 26) {	if (((c - 'a') & 0xff) < 26) {
c -= 0x20;	c -= 0x20;
}	}
s = (BYTE)*str++;	s = (UINT8)*str++;
if (((s - 'a') & 0xff) < 26) {	if (((s - 'a') & 0xff) < 26) {
s -= 0x20;	s -= 0x20;
}	}
Line 283 int mileuc_memcmp(const char *str, const	Line 340 int mileuc_memcmp(const char *str, const
return((s > c)?1:-1);	return((s > c)?1:-1);
}	}

int mileuc_kanji1st(const char *str, int pos) {	int STRCALL mileuc_kanji1st(const char *str, int pos) {

int ret;	int ret;

ret = 0;	ret = 0;
while((pos >= 0) &&	while((pos >= 0) && (str[pos--] & 0x80)) {
(((str[pos--] - 0xa1) & 0xff) < 0x5d)) {
ret ^= 1;	ret ^= 1;
}	}
return(ret);	return(ret);
}	}

int mileuc_kanji2nd(const char *str, int pos) {	int STRCALL mileuc_kanji2nd(const char *str, int pos) {

int ret = 0;	int ret;

while((pos > 0) && (((str[--pos] - 0xa1) & 0xff) < 0x5d)) {	ret = 0;
	while((pos > 0) && (str[--pos] & 0x80)) {
ret ^= 1;	ret ^= 1;
}	}
return(ret);	return(ret);
}	}

void mileuc_ncpy(char dst, const char src, int maxlen) {	void STRCALL mileuc_ncpy(char dst, const char src, int maxlen) {

int i;	int i;

Line 323 void mileuc_ncpy(char dst, const char	Line 380 void mileuc_ncpy(char dst, const char
}	}
}	}

void mileuc_ncat(char dst, const char src, int maxlen) {	void STRCALL mileuc_ncat(char dst, const char src, int maxlen) {

int i;	int i;
int j;	int j;
Line 346 void mileuc_ncat(char dst, const char	Line 403 void mileuc_ncat(char dst, const char
dst[i] = '\0';	dst[i] = '\0';
}	}
}	}

	char * STRCALL mileuc_chr(const char *str, int c) {

	int s;

	if (str) {
	do {
	s = *str;
	if (s == c) {
	return((char *)str);
	}
	if (s & 0x80) {
	str++;
	s = *str;
	}
	str++;
	} while(s);
	}
	return(NULL);
	}
	#endif


	// ---- UTF8

	#if defined(SUPPORT_UTF8)
	int STRCALL milutf8_charsize(const char *str) {

	if (str[0] == '\0') {
	return(0);
	}
	else if (!(str[0] & 0x80)) {
	return(1);
	}
	else if ((str[0] & 0xe0) == 0xc0) {
	if ((str[1] & 0xc0) == 0x80) {
	return(2);
	}
	}
	else if ((str[0] & 0xf0) == 0xe0) {
	if (((str[1] & 0xc0) == 0x80) \|\|
	((str[2] & 0xc0) == 0x80)) {
	return(3);
	}
	}
	return(0);
	}

	int STRCALL milutf8_cmp(const char str, const char cmp) {

	int s;
	int c;

	do {
	s = (UINT8)*str++;
	if (((s - 'a') & 0xff) < 26) {
	s -= 0x20;
	}
	c = (UINT8)*cmp++;
	if (((c - 'a') & 0xff) < 26) {
	c -= 0x20;
	}
	if (s != c) {
	return((s > c)?1:-1);
	}
	} while(s);
	return(0);
	}

	int STRCALL milutf8_memcmp(const char str, const char cmp) {

	int s;
	int c;

	do {
	c = (UINT8)*cmp++;
	if (c == 0) {
	return(0);
	}
	if (((c - 'a') & 0xff) < 26) {
	c -= 0x20;
	}
	s = (UINT8)*str++;
	if (((s - 'a') & 0xff) < 26) {
	s -= 0x20;
	}
	} while(s == c);
	return((s > c)?1:-1);
	}

	int STRCALL milutf8_kanji1st(const char *str, int pos) {

	return(((str[pos] & 0xc0) >= 0xc0)?1:0);
	}

	int STRCALL milutf8_kanji2nd(const char *str, int pos) {

	return(((str[pos] & 0xc0) == 0x80)?1:0);
	}

	void STRCALL milutf8_ncpy(char dst, const char src, int maxlen) {

	int i;

	if (maxlen > 0) {
	maxlen--;
	for (i=0; i<maxlen && src[i]; i++) {
	dst[i] = src[i];
	}
	dst[i] = '\0';
	if (i) {
	do {
	i--;
	} while((i) && ((dst[i] & 0xc0) == 0x80));
	i += milutf8_charsize(dst + i);
	dst[i] = '\0';
	}
	}
	}

	void STRCALL milutf8_ncat(char dst, const char src, int maxlen) {

	int i;
	int j;

	if (maxlen > 0) {
	maxlen--;
	for (i=0; i<maxlen; i++) {
	if (!dst[i]) {
	break;
	}
	}
	for (j=0; i<maxlen && src[j]; i++, j++) {
	dst[i] = src[j];
	}
	dst[i] = '\0';
	if (i) {
	do {
	i--;
	} while((i) && ((dst[i] & 0xc0) == 0x80));
	i += milutf8_charsize(dst + i);
	dst[i] = '\0';
	}
	}
	}

	char * STRCALL milutf8_chr(const char *str, int c) {

	int s;

	if (str) {
	do {
	s = *str;
	if (s == c) {
	return((char *)str);
	}
	str++;
	} while(s);
	}
	return(NULL);
	}
#endif	#endif


// ---- other	// ---- other

int milstr_extendcmp(const char str, const char cmp) {	int STRCALL milstr_extendcmp(const OEMCHAR str, const OEMCHAR cmp) {

int c;	int c;
int s;	int s;

do {	do {
while(1) {	while(1) {
c = (BYTE)*cmp++;	c = (UINT8)*cmp++;
if (!c) {	if (!c) {
return(0);	return(0);
}	}
Line 387 int milstr_extendcmp(const char *str, co	Line 605 int milstr_extendcmp(const char *str, co
return((s > c)?1:-1);	return((s > c)?1:-1);
}	}

int milstr_getarg(char str, char arg[], int maxarg) {	OEMCHAR * STRCALL milstr_nextword(const OEMCHAR *str) {

	if (str) {
	while((str > '\0') && (str <= ' ')) {
	str++;
	}
	}
	return((OEMCHAR *)str);
	}

	int STRCALL milstr_getarg(OEMCHAR str, OEMCHAR arg[], int maxarg) {

int ret = 0;	int ret = 0;
char *p;	OEMCHAR *p;
BOOL quot;	BRESULT quot;

while(maxarg--) {	while(maxarg--) {
quot = FALSE;	quot = FALSE;
while((str) && (((BYTE)str) <= 0x20)) {	while((str > '\0') && (str <= ' ')) {
str++;	str++;
}	}
if (*str == '\0') {	if (*str == '\0') {
Line 404 int milstr_getarg(char str, char arg[]	Line 632 int milstr_getarg(char str, char arg[]
arg[ret++] = str;	arg[ret++] = str;
p = str;	p = str;
while(*str) {	while(*str) {
if (*str == 0x22) {	if (*str == '\"') {
quot = !quot;	quot = !quot;
}	}
else if ((((BYTE)*str) > 0x20) \|\| (quot)) {	else if ((quot) \|\| (str < '\0') \|\| (str > ' ')) {
p++ = str;	p++ = str;
}	}
else {	else {
Line 421 int milstr_getarg(char str, char arg[]	Line 649 int milstr_getarg(char str, char arg[]
return(ret);	return(ret);
}	}

long milstr_solveHEX(const char *str) {	long STRCALL milstr_solveHEX(const OEMCHAR *str) {

long ret;	long ret;
int i;	int i;
char c;	OEMCHAR c;

ret = 0;	ret = 0;
for (i=0; i<8; i++) {	for (i=0; i<8; i++) {
Line 448 long milstr_solveHEX(const char *str) {	Line 676 long milstr_solveHEX(const char *str) {
return(ret);	return(ret);
}	}

long milstr_solveINT(const char *str) {	long STRCALL milstr_solveINT(const OEMCHAR *str) {

long ret;	long ret;
int c;	int c;
Line 477 long milstr_solveINT(const char *str) {	Line 705 long milstr_solveINT(const char *str) {
return(ret * s);	return(ret * s);
}	}

	OEMCHAR * STRCALL milstr_list(const OEMCHAR *lststr, UINT pos) {

	if (lststr) {
	while(pos) {
	pos--;
	while(*lststr++ != '\0') {
	}
	}
	}
	return((OEMCHAR *)lststr);
	}

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

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