[BACK]Return to milstr.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / common

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

version 1.1, 2003/10/16 17:57:09 version 1.13, 2005/02/07 14:46:08
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   
   
 BOOL milstr_cmp(const char *str, const char *cmp) {  // ---- ANK / UCS2 / UCS4
   
   #if defined(SUPPORT_ANK)
   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;
   
         while(1) {          do {
                 s = (BYTE)*str++;                  s = *str++;
                   if ((s >= 'a') && (s <= 'z')) {
                           s -= 0x20;
                   }
                   c = *cmp++;
                   if ((c >= 'a') && (c <= 'z')) {
                           c -= 0x20;
                   }
                   if (s != c) {
                           return((s > c)?1:-1);
                   }
           } while(s);
           return(0);
   }
   
   int STRCALL milank_memcmp(const OEMCHAR *str, const OEMCHAR *cmp) {
   
           int             s;
           int             c;
   
           do {
                   c = *cmp++;
                   if (c == 0) {
                           return(0);
                   }
                   if ((c >= 'a') && (c <= 'z')) {
                           c -= 0x20;
                   }
                   s = *str++;
                   if ((s >= 'a') && (s <= 'z')) {
                           s -= 0x20;
                   }
           } while(s == c);
           return((s > c)?1:-1);
   }
   
   void STRCALL milank_ncpy(OEMCHAR *dst, const OEMCHAR *src, int maxlen) {
   
           int             i;
   
           if (maxlen > 0) {
                   maxlen--;
                   for (i=0; i<maxlen && src[i]; i++) {
                           dst[i] = src[i];
                   }
                   dst[i] = '\0';
           }
   }
   
   void STRCALL milank_ncat(OEMCHAR *dst, const OEMCHAR *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';
           }
   }
   
   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
   
   
   // ---- Shift-JIS
   
   #if defined(SUPPORT_SJIS)
   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             c;
   
           do {
                   s = (UINT8)*str++;
                 if ((((s ^ 0x20) - 0xa1) & 0xff) < 0x3c) {                  if ((((s ^ 0x20) - 0xa1) & 0xff) < 0x3c) {
                         if (s != (BYTE)*cmp++) {                          c = (UINT8)*cmp++;
                           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) < 0x1a) {                          if (((s - 'a') & 0xff) < 26) {
                                 s |= 0x20;                                  s -= 0x20;
                         }                          }
                         c = (BYTE)*cmp++;                          c = (UINT8)*cmp++;
                         if (((c - 'A') & 0xff) < 0x1a) {                          if (((c - 'a') & 0xff) < 26) {
                                 c |= 0x20;                                  c -= 0x20;
                         }                          }
                 }                  }
                 if (s != c) {                  if (s != c) {
                         goto mscp_err;                          goto mscp_err;
                 }                  }
                 if (!s) {          } while(s);
                         break;  
                 }  
         }  
         return(0);          return(0);
   
 mscp_err:  mscp_err:
         return(1);          return((s > c)?1:-1);
 }  }
   
 BOOL milstr_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) {
                         if (c != (BYTE)*str++) {                          s = (UINT8)*str++;
                           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;
                         }                          }
                 }                  }
                 else {                  else {
                         return(0);                          return(0);
                 }                  }
         } while(s == c);          } while(s == c);
         return(1);          return((s > c)?1:-1);
 }  }
   
 BOOL milstr_extendcmp(const char *str, const char *cmp) {  int STRCALL milsjis_kanji1st(const char *str, int pos) {
   
         char    c, s = '\0';          int             ret;
   
         while(*cmp) {          ret = 0;
                 while(*cmp) {          while((pos >= 0) &&
                         s = *cmp++;                  ((((str[pos--] ^ 0x20) - 0xa1) & 0xff) < 0x3c)) {
                         if (!s) {                  ret ^= 1;
                                 return(0);          }
           return(ret);
   }
   
   int STRCALL milsjis_kanji2nd(const char *str, int pos) {
   
           int             ret;
   
           ret = 0;
           while((pos > 0) && ((((str[--pos] ^ 0x20) - 0xa1) & 0xff) < 0x3c)) {
                   ret ^= 1;
           }
           return(ret);
   }
   
   void STRCALL milsjis_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];
                   }
                   if (i) {
                           if (milsjis_kanji1st(src, i-1)) {
                                   i--;
                         }                          }
                         if ((s >= '0') && (s <= '9')) {                  }
                   dst[i] = '\0';
           }
   }
   
   void STRCALL milsjis_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;                                  break;
                         }                          }
                         s &= 0xdf;                  }
                         if ((s >= 'A') && (s <= 'Z')) {                  for (j=0; i<maxlen && src[j]; i++, j++) {
                                 break;                          dst[i] = src[j];
                   }
                   if ((i > 0) && (j > 0)) {
                           if (milsjis_kanji1st(dst, i-1)) {
                                   i--;
                         }                          }
                 }                  }
                 while(1) {                  dst[i] = '\0';
                         c = *str++;          }
                         if (!c) {  }
                                 return(1);  
   char * STRCALL milsjis_chr(const char *str, int c) {
   
           int             s;
   
           if (str) {
                   do {
                           s = *str;
                           if (s == c) {
                                   return((char *)str);
                         }                          }
                         if ((c >= '0') && (c <= '9')) {                          if ((((s ^ 0x20) - 0xa1) & 0xff) < 0x3c) {
                                 break;                                  str++;
                                   s = *str;
                         }                          }
                         c &= 0xdf;                          str++;
                         if ((c >= 'A') && (c <= 'Z')) {                  } while(s);
                                 break;          }
           return(NULL);
   }
   #endif
   
   
   // ---- EUC
   
   #if defined(SUPPORT_EUC)                // あれ 半角カナ忘れてるぞ？
   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             c;
   
           do {
                   s = (UINT8)*str++;
                   if (s & 0x80) {
                           c = (UINT8)*cmp++;
                           if (s != c) {
                                   goto mscp_err;
                         }                          }
                           s = (UINT8)*str++;
                           c = (UINT8)*cmp++;
                 }                  }
                 if (c != s) {                  else {
                         return(1);                          if (((s - 'a') & 0xff) < 26) {
                                   s -= 0x20;
                           }
                           c = (UINT8)*cmp++;
                           if (((c - 'a') & 0xff) < 26) {
                                   c -= 0x20;
                           }
                 }                  }
         }                  if (s != c) {
                           goto mscp_err;
                   }
           } while(s);
         return(0);          return(0);
   
   mscp_err:
           return((s > c)?1:-1);
 }  }
   
 int milstr_kanji1st(const char *str, int pos) {  int STRCALL mileuc_memcmp(const char *str, const char *cmp) {
   
           int             s;
           int             c;
   
           do {
                   c = (UINT8)*cmp++;
                   if (c & 0x80) {
                           s = (UINT8)*str++;
                           if (c != s) {
                                   break;
                           }
                           c = (UINT8)*cmp++;
                           s = (UINT8)*str++;
                   }
                   else if (c) {
                           if (((c - 'a') & 0xff) < 26) {
                                   c -= 0x20;
                           }
                           s = (UINT8)*str++;
                           if (((s - 'a') & 0xff) < 26) {
                                   s -= 0x20;
                           }
                   }
                   else {
                           return(0);
                   }
           } while(s == c);
           return((s > c)?1:-1);
   }
   
   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--] ^ 0x20) - 0xa1) & 0xff) < 0x3c)) {  
                 ret ^= 1;                  ret ^= 1;
         }          }
         return(ret);          return(ret);
 }  }
   
 int milstr_kanji2nd(const char *str, int pos) {  int STRCALL mileuc_kanji2nd(const char *str, int pos) {
   
         int             ret = 0;          int             ret;
   
         while((pos) && ((((str[--pos] ^ 0x20) - 0xa1) & 0xff) < 0x3c)) {          ret = 0;
           while((pos > 0) && (str[--pos] & 0x80)) {
                 ret ^= 1;                  ret ^= 1;
         }          }
         return(ret);          return(ret);
 }  }
   
 void milstr_ncpy(char *dst, const char *src, int maxlen) {  void STRCALL mileuc_ncpy(char *dst, const char *src, int maxlen) {
   
         int             i;          int             i;
   
         if (maxlen--) {          if (maxlen > 0) {
                   maxlen--;
                 for (i=0; i<maxlen && src[i]; i++) {                  for (i=0; i<maxlen && src[i]; i++) {
                         dst[i] = src[i];                          dst[i] = src[i];
                 }                  }
                 if (i) {                  if (i) {
                         if (milstr_kanji1st(src, i-1)) {                          if (mileuc_kanji1st(src, i-1)) {
                                 i--;                                  i--;
                         }                          }
                 }                  }
Line 144  void milstr_ncpy(char *dst, const char * Line 380  void milstr_ncpy(char *dst, const char *
         }          }
 }  }
   
 void milstr_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;
   
         if (maxlen--) {          if (maxlen > 0) {
                   maxlen--;
                 for (i=0; i<maxlen; i++) {                  for (i=0; i<maxlen; i++) {
                         if (!dst[i]) break;                          if (!dst[i]) {
                                   break;
                           }
                 }                  }
                 for (j=0; i<maxlen && src[j]; i++, j++) {                  for (j=0; i<maxlen && src[j]; i++, j++) {
                         dst[i] = src[j];                          dst[i] = src[j];
                 }                  }
                 if ((i) && (j)) {                  if ((i > 0) && (j > 0)) {
                         if (milstr_kanji1st(dst, i-1)) {                          if (mileuc_kanji1st(dst, i-1)) {
                                 i--;                                  i--;
                         }                          }
                 }                  }
Line 165  void milstr_ncat(char *dst, const char * Line 404  void milstr_ncat(char *dst, const char *
         }          }
 }  }
   
 int milstr_getarg(char *str, char *arg[], int maxarg) {  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
   
   
   // ---- other
   
   int STRCALL milstr_extendcmp(const OEMCHAR *str, const OEMCHAR *cmp) {
   
           int             c;
           int             s;
   
           do {
                   while(1) {
                           c = (UINT8)*cmp++;
                           if (!c) {
                                   return(0);
                           }
                           if (((c - '0') & 0xff) < 10) {
                                   break;
                           }
                           c |= 0x20;
                           if (((c - 'a') & 0xff) < 26) {
                                   break;
                           }
                   }
                   while(1) {
                           s = *str++;
                           if (!s) {
                                   break;
                           }
                           if (((s - '0') & 0xff) < 10) {
                                   break;
                           }
                           s |= 0x20;
                           if (((s - 'a') & 0xff) < 26) {
                                   break;
                           }
                   }
           } while(s == c);
           return((s > c)?1:-1);
   }
   
   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 182  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 199  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 226  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 255  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);
   }
   
Removed from v.1.1  
changed lines
  Added in v.1.13

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