开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
KString.h
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：30k
源码类别：

模拟服务器

开发平台：

C/C++

KString.h：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   KString.h
  4. //  Version     :   1.0
  5. //  Creater     :   Freeway Chen
  6. //  Date        :   1998-10-16
  7. //  Comment     :   String Rounte from Delphi 4.0
  8. //
  9. //////////////////////////////////////////////////////////////////////////////////////
  11. #ifndef _KSTRING_H_
  12. #define _KSTRING_H_     1
  14. #include "KSChar.h"
  16. #ifdef _XP_LINUX_
  18. #include <ctype.h>
  19. #include <string.h>
  22. inline int StrLen(const char *Str1)
  23. {
  24.     return strlen(Str1);
  25. }
  27. inline char * StrCpy(char *Dest, const char *Source)
  28. {
  29.     return strcpy(Dest, Source);
  30. }
  32. inline char * StrNCpy(char *Dest,const char *Source, int MaxLen)
  33. {
  34.     return strncpy(Dest, Source, MaxLen);
  35. }
  37. inline int StrCmp(const char *Str1, const char *Str2)
  38. {
  39.     return strcmp(Str1, Str2);
  40. }
  42. inline int StrNCmp(const char *Str1, const char *Str2, unsigned MaxLen)
  43. {
  44.     return strncmp(Str1, Str2, MaxLen);
  45. }
  47. inline int StrICmp(const char *Str1, const char *Str2)
  48. {
  49.     int f, l;
  51.     do {
  52.         f = tolower(*Str1);
  53.         Str1++;
  54.         l = tolower(*Str2);
  55.         Str2++;
  56.     } while ( f && (f == l) );
  58.     return (f - l);
  59. }
  61. inline int StrNICmp(const char *Str1, const char *Str2, unsigned Len)
  62. {
  63.     int f, l;
  65.     if (!Len)
  66.         return 0;
  68.     do {
  69.         f = tolower(*Str1);
  70.         Str1++;
  71.         l = tolower(*Str2);
  72.         Str2++;
  73.     } while (--Len && f && (f == l));
  75.     return (f - l);
  76. }
  79. inline char * StrChr(const char *Str1, const char Chr)
  80. {
  81.     return strchr(Str1, Chr);
  82. }
  84. inline char *StrStr(const char *Str1, const char *Str2)
  85. {
  86.     return strstr(Str1, Str2);
  87. }
  89. inline char * StrRChr(const char *Str1, const char Chr)
  90. {
  91.     return strrchr(Str1, Chr);
  92. }
  94. inline void MemCpy(void *Dst, const void *Src, unsigned int tSize)
  95. {
  96.     memcpy(Dst, Src, tSize);
  97. }
  99. inline void MemMove(void *Dst, const void *Src, unsigned int tSize)
  100. {
  101.     memmove(Dst, Src, tSize);
  102. }
  105. // return 0 equal
  106. // return 1 not equal
  107. inline int  FastMemCmp(const void *Dst, const void *Src, unsigned int tSize)
  108. {
  109.     int nRetCode = memcmp(Dst, Src, tSize);
  111.     return !(nRetCode == 0);
  112. }
  114. inline int MemCmp(const void *Dst, const void *Src, unsigned int tSize)
  115. {
  116.     return memcmp(Dst, Src, tSize);
  117. }
  119. inline void MemSet(void *Buffer, char ch1, size_t Count)
  120. { 
  121.     memset(Buffer, ch1, Count);
  122. }
  124. inline void MemZero(void *Buffer, size_t Count)
  125. { 
  126.     memset(Buffer, 0, Count);
  127. }
  130. inline void * MemChr(const void *Buffer, char Chr, size_t Count)
  131. {
  132.     return memchr(Buffer, Chr, Count);
  133. }
  135. // search a Integer
  136. inline void * MemInt(const void *Buffer, int nInt, size_t Count)
  137. {
  138.     int *pnBuffer = (int *)Buffer;
  140.     while (Count--)
  141.     {
  142.         if ((*pnBuffer) == nInt)
  143.             return (void *)pnBuffer;
  144.         
  145.         pnBuffer++;
  146.     }
  148.     return NULL;
  149. }
  152. inline char * StrCat(char *DestStr, const char *SrcStr)
  153. {
  154.     return strcat(DestStr, SrcStr);
  155. }
  157. inline char * StrUpper(char *SrcStr)
  158. {
  159.     char * cp;
  161.     for (cp = SrcStr; *cp; ++cp)
  162.     {
  163.         if (
  164.             ('a' <= *cp) && 
  165.             (*cp <= 'z')
  166.         )
  167.             *cp += 'A' - 'a';
  168.     }
  170.     return SrcStr;
  171. }
  173. inline char * StrSetEmpty(char *pszStr)
  174. {
  175.     *pszStr = '';
  176.     return pszStr;
  177. }
  179. inline int StrIsEmpty(const char *pszStr)
  180. {
  181.     return ('' == *pszStr);
  182. }
  184. inline char * StrSetEnd(char *pszStr)
  185. {
  186.     *pszStr = '';
  187.     return pszStr;
  188. }
  190. inline int StrIsEnd(const char *pszStr)
  191. {
  192.     return ('' == *pszStr);
  193. }
  195. #else   // not _XP_LINUX_                   
  197. // ------------------------------------------------------
  199. // VC Complier general :
  200. // push ebx esi edi
  201. // pop edi esi ebx
  202. // code when One Function
  204. // -------------------------------------------------------
  206. //#ifdef __BORLANDC__
  207. //#pragma inline
  208. //#define inline static
  209. //#define __asm _asm
  210. //#endif
  212. #include "KWString.h"
  214. inline int _fastcall StrLen(const char *Str1)
  215. {
  216.     int Len;
  218.     __asm cld
  219.     __asm MOV    edi, [Str1]
  220.     __asm MOV    ECX,0xFFFFFFFF
  221.     __asm XOR    AL,AL
  222.     __asm REPNE  SCASB
  223.     __asm MOV    EAX,0xFFFFFFFE
  224.     __asm SUB    EAX,ECX
  225.     __asm MOV    [Len], EAX
  227.     return Len;
  229. }
  231. inline char * _fastcall StrCpy(char *Dest, const char *Source)
  232. {
  233.     char *RetStr;
  235.     __asm cld
  236.     __asm MOV    ESI,[Source]
  237.     __asm MOV    EDX,[Dest]
  238.     __asm MOV    EDI,ESI
  239.     __asm MOV    ECX,0xFFFFFFFF
  240.     __asm XOR    AL,AL
  241.     __asm REPNE  SCASB
  242.     __asm NOT    ECX
  243.     __asm MOV    EDI,EDX
  244.     __asm MOV    EDX,ECX
  245.     __asm MOV    EAX,EDI
  246.     __asm SHR    ECX,2
  247.     __asm REP    MOVSD
  248.     __asm MOV    ECX,EDX
  249.     __asm AND    ECX,3
  250.     __asm REP    MOVSB
  251.     __asm MOV    [RetStr], EAX
  253.     return RetStr;
  254. }
  256. inline char * _fastcall StrNCpy(char *Dest,const char *Source, int MaxLen)
  257. {
  258.     char *RetStr;
  260.     __asm cld
  261.     __asm MOV    ESI,[Dest]
  262.     __asm MOV    EDX,[Source]
  263.     __asm MOV    EDI, EDX
  264.     __asm MOV    ECX,[MaxLen]
  265.     __asm MOV    EBX,ECX
  266.     __asm XOR    AL,AL
  267.     __asm TEST   ECX, ECX
  268.     __asm JZ     Label2
  269.     __asm REPNE  SCASB
  270.     __asm JNE    Label1
  271.     __asm INC    ECX
  272.     Label1:
  273.     __asm SUB    EBX,ECX
  274.     __asm MOV    EDI,ESI
  275.     __asm MOV    ESI,EDX
  276.     __asm MOV    EDX,EDI
  277.     __asm MOV    ECX,EBX
  278.     __asm SHR    ECX,2
  279.     __asm REP    MOVSD
  280.     __asm MOV    ECX,EBX
  281.     __asm AND    ECX,3
  282.     __asm REP    MOVSB
  283.     __asm STOSB
  284.     __asm MOV    ESI,EDX
  286.     Label2://Exit
  287.     __asm mov [RetStr], ESI
  289.     return RetStr;
  290. }
  292. inline int _fastcall StrCmp(const char *Str1, const char *Str2)
  293. {
  294.     int RetCode;
  296.     __asm cld
  297.     __asm MOV    EDI,[Str1]
  298.     __asm MOV    ESI,[Str2]
  299.     __asm mov    edx,edi
  300.     __asm MOV    ECX, -1
  301.     __asm XOR    EAX,EAX
  302.     __asm REPNE  SCASB
  303.     __asm NOT    ECX
  304.     __asm MOV    EDI,EDX
  305.     __asm XOR    EDX,EDX
  306.     __asm REPE   CMPSB
  307.     __asm MOV    AL,[EDI-1]
  308.     __asm MOV    DL,[ESI-1]
  309.     __asm SUB    EAX, EDX
  310.     __asm mov    [RetCode], eax
  312.     return RetCode;
  313. }
  315. inline int _fastcall StrNCmp(const char *Str1, const char *Str2, unsigned MaxLen)
  316. {
  317.     int RetCode;
  318.     
  319.     __asm MOV     EDI,[Str1]
  320.     __asm MOV     ESI,[Str2]
  321.     __asm mov     ECX,[MaxLen]
  322.     __asm mov     EDX,EDI
  324.     __asm MOV     EBX,ECX
  325.     __asm XOR     EAX,EAX
  326.     __asm OR      ECX,ECX
  327.     __asm JE      Label1
  328.     __asm REPNE   SCASB
  329.     __asm SUB     EBX,ECX
  330.     __asm MOV     ECX,EBX
  331.     __asm MOV     EDI,EDX
  332.     __asm XOR     EDX,EDX
  333.     __asm REPE    CMPSB
  334.     __asm MOV     AL, [EDI-1]
  335.     __asm MOV     DL, [ESI-1]
  336.     __asm SUB     EAX,EDX
  338. Label1:        
  339.     __asm mov [RetCode], eax
  341.     return RetCode;
  342. }
  344. inline int _fastcall StrICmp(const char *Str1, const char *Str2)
  345. {
  346.     int RetCode;
  348.     __asm cld
  349.     __asm MOV    EDI, [Str1]
  350.     __asm MOV    ESI, [Str2]
  351.     __asm mov    edx, edi
  352.     __asm mov    ebx, offset LowerToUpperTable
  353.     __asm MOV    ECX, -1
  354.     __asm XOR    EAX,EAX
  355.     __asm REPNE  SCASB
  356.     __asm NOT    ECX
  357.     __asm MOV    EDI,EDX
  358.     __asm XOR    EDX,EDX
  360.     Label1:
  361.     __asm REPE   CMPSB
  362.     __asm JE     Lable4 // exit
  365.     __asm MOVZX  EAX, byte ptr [EDI-1]
  366.     __asm MOVZX  EDX, byte ptr [ESI-1]
  367.     __asm MOVZX  EAX, byte ptr [EBX + EAX]
  368.     __asm MOVZX  EDX, byte ptr [EBX + EDX]
  369.     __asm SUB    EAX, EDX
  370.     __asm JE     Label1
  372.     Lable4:
  373.     __asm mov    [RetCode], eax
  375.     return RetCode;
  376. }
  378. inline int _fastcall StrNICmp(const char *Str1, const char *Str2, unsigned Len)
  379. {
  380.     int RetCode;
  382.     __asm cld
  383.     __asm MOV    EDI, [Str1]
  384.     __asm MOV    ESI, [Str2]
  385.     __asm MOV    ECX, [Len]
  386.     __asm mov    edx, edi
  387.     __asm mov    ebx, ecx
  388.     //__asm MOV    ECX, -1
  389.     __asm XOR    EAX,EAX
  390.     __asm REPNE  SCASB
  391.     __asm sub    ebx, ecx
  392.     __asm MOV    EDI,EDX
  393.     __asm mov    ecx, ebx
  394.     __asm XOR    EDX,EDX
  395.     __asm mov    ebx, offset LowerToUpperTable
  397.     Label1:
  398.     __asm REPE   CMPSB
  399.     __asm JE     Lable4 // exit EAX = 0
  402.     __asm MOVZX  EAX, byte ptr [EDI - 1]
  403.     __asm MOVZX  EDX, byte ptr [ESI - 1]
  404.     __asm MOVZX  EAX, byte ptr [EBX + EAX]
  405.     __asm MOVZX  EDX, byte ptr [EBX + EDX]
  406.     __asm SUB    EAX, EDX
  407.     __asm JE     Label1
  409.     Lable4:
  410.     __asm mov    [RetCode], eax
  412.     return RetCode;
  413. }
  416. inline char * _fastcall StrChr(const char *Str1, const char Chr)
  417. {
  418.     char *RetStr;
  420.     __asm cld
  421.     __asm MOV    EAX, [Str1]
  422.     __asm MOV    DL, [Chr]
  423.     __asm PUSH   EAX
  424.     __asm MOV    EDI, EAX
  425.     __asm MOV    ECX,0xFFFFFFFF
  426.     __asm XOR    AL,AL
  427.     __asm REPNE  SCASB
  428.     __asm NOT    ECX
  429.     __asm POP    EDI
  430.     __asm MOV    AL,DL
  431.     __asm REPNE  SCASB
  432.     __asm MOV    EAX,0
  433.     __asm JNE    Label1
  434.     __asm MOV    EAX,EDI
  435.     __asm DEC    EAX
  436.     Label1:
  437.     __asm MOV    [RetStr], EAX
  439.     return RetStr;
  440. }
  442. inline char * _fastcall StrStr(const char *Str1, const char *Str2)
  443. {
  444.     char *RetStr;
  446.     __asm CLD
  447.     __asm MOV     EDX,[Str2]
  448.     __asm MOV     EBX,[Str1]
  450.     __asm MOV     EDI,EDX
  451.     __asm XOR     AL,AL
  452.     __asm MOV     ECX,0FFFFFFFFH
  453.     __asm REPNE   SCASB
  454.     __asm NOT     ECX
  455.     __asm DEC     ECX
  456.     __asm JE      Lable2
  458.     __asm MOV     ESI,ECX
  459.     __asm MOV     EDI,EBX
  460.     __asm MOV     ECX,0FFFFFFFFH
  461.     __asm REPNE   SCASB
  462.     __asm NOT     ECX
  463.     __asm SUB     ECX,ESI
  464.     __asm JBE     Lable2
  466.     __asm MOV     EDI,EBX
  467.     __asm LEA     EBX,[ESI-1]
  468. Lable1:    
  469.     __asm MOV     ESI,EDX
  470.     __asm LODSB
  471.     __asm REPNE   SCASB
  472.     __asm JNE     Lable2
  474.     __asm MOV     EAX,ECX
  475.     __asm PUSH    EDI
  476.     __asm MOV     ECX,EBX
  477.     __asm REPE    CMPSB
  478.     __asm POP     EDI
  479.     __asm MOV     ECX,EAX
  480.     __asm JNE     Lable1
  482.     __asm LEA     EAX,[EDI-1]
  483.     __asm JMP     Lable3
  484. Lable2:    
  485.     __asm XOR     EAX,EAX
  486. Lable3:    
  487.     __asm MOV    [RetStr], EAX
  489.     return RetStr;
  490. }
  492. inline char * _fastcall StrRChr(const char *Str1, const char Chr)
  493. {
  494.     char *RetStr;
  496.     __asm MOV     EDI,[Str1]
  497.     __asm MOV     DL, [Chr]
  498.     __asm MOV     ECX,0xFFFFFFFF
  499.     __asm XOR     AL,AL
  500.     __asm REPNE   SCASB
  501.     __asm NOT     ECX
  502.     __asm STD
  503.     __asm DEC     EDI
  504.     __asm MOV     AL, DL
  505.     __asm REPNE   SCASB
  506.     __asm MOV     EAX,0
  507.     __asm JNE     Lable1
  508.     __asm MOV     EAX,EDI
  509.     __asm INC     EAX
  510.     Lable1:
  511.     __asm CLD
  513.     __asm mov   [RetStr], eax
  515.     return RetStr;
  516. }
  518. /*
  519. #ifdef _INTEL_P4
  521. inline void _fastcall MemCpy(void *Dst, const void *Src, unsigned int tSize)
  522. {
  523.     
  524.     __asm cld
  525.     __asm mov esi, [Src]
  526.     __asm mov edi, [Dst]
  527.     __asm prefetchnta [esi]
  528.     __asm prefetchnta [esi + 64]
  529.     __asm prefetchnta [esi + 128]
  530.     __asm prefetchnta [esi + 192]
  531.     __asm prefetchnta [esi + 256]
  532.     __asm mov ecx, [tSize]
  533.     __asm mov edx, ecx
  534.     __asm shr ecx, 7
  535.     __asm jz Label_Last
  537. Label_Loop:
  538.     __asm prefetchnta [esi + 320]
  540.     __asm movss xmm0, [esi]
  541.     __asm movss xmm1, [esi + 16]
  542.     __asm movss xmm2, [esi + 32]
  543.     __asm movss xmm3, [esi + 48]
  544.     __asm movss xmm4, [esi + 64]
  545.     __asm movss xmm5, [esi + 80]
  546.     __asm movss xmm6, [esi + 96]
  547.     __asm movss xmm7, [esi + 112]
  549.     __asm movss [edi], xmm0
  550.     __asm add esi, 128
  551.     __asm movss [edi + 16], xmm1
  552.     __asm movss [edi + 32], xmm2
  553.     __asm movss [edi + 48], xmm3
  554.     __asm movss [edi + 64], xmm4
  555.     __asm movss [edi + 80], xmm5
  556.     __asm movss [edi + 96], xmm6
  557.     __asm movss [edi + 112], xmm7
  558.     __asm add edi, 128
  560.     __asm dec ecx
  561.     __asm jnz Label_Loop
  563. Label_Last:
  564.     __asm and edx, 0x7f
  566.     __asm mov ecx, edx
  567.     __asm shr ecx, 2
  568.     __asm rep movsd
  570.     __asm mov ecx, edx
  571.     __asm and ecx, 0x3
  572.     __asm rep movsb          // mov BYTE
  573. }
  576. #else
  577. */
  578. inline void _fastcall MemCpy(void *Dst, const void *Src, unsigned int tSize)
  579. {
  580.     //Touch_Register(edx)
  581.     //Touch_Register(ecx)
  582.     //Touch_Register(esi)
  583.     //Touch_Register(edi)
  585.     __asm cld
  586.     __asm mov esi, [Src]
  587.     __asm mov edi, [Dst]
  588.     __asm mov ecx, [tSize]
  589.     __asm mov edx, ecx
  590.     __asm shr ecx, 2   
  591.     __asm rep movsd          // mov DWORD
  592.     __asm mov ecx, edx 
  593.     __asm and ecx, 0x03
  594.     __asm rep movsb          // mov BYTE
  595. }
  596. //#endif
  598. // Get Following Code From C++Builder 5.0
  599. inline void _fastcall MemMove(void *Dst, const void *Src, unsigned int tSize)
  600. {
  601.     __asm mov esi, [Src]
  602.     __asm mov edi, [Dst]
  603.     __asm mov ecx, [tSize]
  605.     __asm cmp edi, esi              // dest < source ?
  606.     __asm mov edx, ecx
  607.     __asm jb  MOV_UP                // yes, do a simple forward move
  608.     __asm je  MOV_END               // dest == source ? do nothing
  609.     
  610.     // MOV_DOWN
  611.     __asm STD                       // force esi and edi to decrement
  612.     __asm lea esi, [esi + ecx - 1]  // point to last byte of source buffer
  613.     __asm lea edi, [edi + ecx - 1]  // point to last byte of dest buffer
  614.     __asm and ecx, 3                // copy trailing bytes
  615.     __asm rep movsb
  616.     __asm mov ecx, edx              // get original count back
  617.     __asm shr ecx, 2                // calculate no. of longwords
  618.     __asm sub esi, 3                // point to previous longword in source
  619.     __asm sub edi, 3                // point to previous longword in dest
  620.     __asm rep movsd                 // copy longwords
  621.     __asm cld                       // clear direction flag
  622.     __asm jmp short MOV_END
  624.     MOV_UP:
  625.     __asm cld
  626.     __asm shr ecx, 2
  627.     __asm rep movsd                 // copy longwords
  628.     __asm mov ecx, edx              // get original count back
  629.     __asm and ecx, 3                // calculate remainder byte count (0-3)
  630.     __asm rep movsb                 // copy remaining bytes
  632.     MOV_END:
  633.     return;
  634. }
  637. // return 0 equal
  638. // return 1 not equal
  639. inline int _fastcall FastMemCmp(const void *Dst, const void *Src, unsigned int tSize)
  640. {
  641.     //Touch_Register(edx)
  642.     //Touch_Register(ecx)
  643.     //Touch_Register(esi)
  644.     //Touch_Register(edi)
  645.     int RetCode;
  647.     __asm cld
  648.     __asm mov esi, [Src]
  649.     __asm mov edi, [Dst]
  650.     __asm mov ecx, [tSize]
  652.     __asm mov eax, 1      // not equal
  654.     __asm mov edx, ecx
  655.     __asm shr ecx, 2
  656.     __asm and edx, 0x03
  657.     __asm rep cmpsd          // cmp DWORD
  658.     __asm jne Exit2
  659.     __asm mov ecx, edx 
  660.     __asm rep cmpsb          // cmp BYTE
  661.     __asm jne Exit2
  663.     __asm dec eax           // equal  0
  664.     Exit2:
  665.     __asm mov [RetCode], eax
  667.     return RetCode;
  668. }
  670. inline int _fastcall MemCmp(const void *Dst, const void *Src, unsigned int tSize){
  671.     //Touch_Register(edx)
  672.     //Touch_Register(ecx)
  673.     //Touch_Register(esi)
  674.     //Touch_Register(edi)
  675.     int RetCode;
  677.     __asm cld
  678.     __asm mov esi, [Src]
  679.     __asm mov edi, [Dst]
  680.     __asm mov ecx, [tSize]
  681.     __asm xor eax, eax
  682.     __asm xor edx, edx
  685.     __asm rep cmpsb          // mov DWORD
  686.     __asm jz Exit1
  687.     // not equal
  688.     __asm mov al, [edi-1]
  689.     __asm mov dl, [esi-1]
  690.     __asm sub eax, edx
  692.     Exit1:
  693.     __asm mov [RetCode], eax
  695.     return RetCode;
  696. }
  698. //#ifdef _INTEL_P4
  699. //
  700. //inline void _fastcall MemSet(void *Buffer, char ch1, size_t Count)
  701. //{
  702. //    __asm CLD
  703. //    __asm MOV     EDI, [Buffer] // Point EDI to destination
  704. //    __asm MOV     ECX, [Count]
  705. //    __asm MOV     DL, [ch1]
  706. //
  707. //    __asm mov     DH, DL
  708. //    __asm mov     eax, edx
  709. //    __asm shl     eax, 16
  710. //    __asm mov     ax, dx
  711. //    __asm movd    xmm0, eax
  712. //    __asm movd    xmm1, eax
  713. //    __asm pslldq  xmm0, 32
  714. //    __asm por     xmm0, xmm1
  715. //    __asm mov     xmm1, xmm0
  716. //    __asm pslldq  xmm0, 64
  717. //    __asm por     xmm0, xmm1
  718. //
  719. //
  720. //
  721. //
  722. //}
  723. //
  724. //#else
  726. inline void _fastcall MemSet(void *Buffer, char ch1, size_t Count)
  727. { 
  728.     __asm CLD
  729.     __asm MOV     EDI, [Buffer] // Point EDI to destination    
  730.     __asm MOV     ECX, [Count]
  731.     __asm MOV     DL, [ch1]
  732.     __asm MOV     DH,DL   // Fill EAX with value repeated 4 times
  733.     __asm MOV     EAX,EDX
  734.     __asm SHL     EAX,16
  735.     __asm MOV     AX,DX
  736.     __asm MOV     EDX, ECX
  737.     __asm SAR     ECX,2
  738.     __asm JS      Exit1
  739.     __asm REP     STOSD   // Fill count DIV 4 dwords
  740.     __asm MOV     ECX,EDX
  741.     __asm AND     ECX,3
  742.     __asm REP     STOSB   // Fill count MOD 4 bytes
  744.     Exit1:
  745.     return;
  746. }
  748. inline void _fastcall MemZero(void *Buffer, size_t Count)
  749. { 
  750.     __asm CLD
  751.     __asm MOV     EDI, [Buffer] // Point EDI to destination    
  752.     __asm MOV     ECX, [Count]
  753.     __asm xor     eax, eax
  754.     __asm MOV     EDX, ECX
  755.     __asm SAR     ECX,2
  756.     __asm JS      Exit1
  757.     __asm REP     STOSD   // Fill count DIV 4 dwords
  758.     __asm MOV     ECX,EDX
  759.     __asm AND     ECX,3
  760.     __asm REP     STOSB   // Fill count MOD 4 bytes
  762.     Exit1:
  763.     return;
  764. }
  766. //#endif
  768. inline void * _fastcall MemChr(const void *Buffer, char Chr, size_t Count)
  769. {
  770.     void *RetBuffer;
  772.     __asm cld
  773.     __asm MOV    EDI, [Buffer]
  774.     __asm MOV   ECX, [Count]
  775.     __asm MOV    AL, [Chr]
  776.     __asm REPNE  SCASB
  777.     __asm MOV    EAX, 0
  778.     __asm JNE    Label1
  779.     __asm MOV    EAX,EDI
  780.     __asm DEC    EAX
  782.     Label1:
  783.     __asm MOV    [RetBuffer], EAX
  785.     return RetBuffer;
  786. }
  788. // search a Integer
  789. inline void * _fastcall MemInt(const void *Buffer, int nInt, size_t Count)
  790. {
  791.     void *RetBuffer;
  793.     __asm MOV    [RetBuffer], 0
  794.     __asm CLD
  795.     __asm MOV    EDI, [Buffer]
  796.     __asm MOV    ECX, [Count]
  797.     __asm SUB    ECX, 4         //
  798.     __asm JB     Label0         // for protect bounds, follow 'cmp eax, [edi]'
  799.     __asm INC    ECX            //
  800.     __asm MOV    EAX, [nInt]
  801.     Loop0:
  802.     __asm REPNE  SCASB
  803.     __asm JNE    Label0
  805.     __asm CMP    EAX, [EDI - 1]
  806.     __asm JNE    Loop0
  808.     __asm LEA    EAX, [EDI - 1]
  810.     __asm MOV    [RetBuffer], EAX
  811.     Label0:
  812.     return RetBuffer;
  813. }
  815. inline char * _fastcall StrEnd(char *Str1)
  816. {
  817.     char *RetStr;
  819.     __asm MOV     ECX,0xFFFFFFFF
  820.     __asm XOR     AL,AL
  821.     __asm MOV     EDI,[Str1]
  822.     __asm REPNE   SCASB
  823.     __asm LEA     EAX,[EDI-1]
  824.     __asm MOV     [RetStr], EAX
  826.     return RetStr;
  827. }
  829. inline char * _fastcall StrCat(char *DestStr, const char *SrcStr)
  830. {
  831.     return StrCpy(StrEnd(DestStr), SrcStr);
  832. }
  834. inline char * _fastcall StrUpper(char *SrcStr)
  835. {
  836.     char *RetStr;
  838.     __asm push esi
  839.     __asm mov esi, [SrcStr]
  840.     __asm mov edx, [SrcStr]
  842.     Label1:
  843.     __asm movzx eax, byte ptr [esi]
  844.     __asm inc esi
  845.     __asm test eax, eax
  846.     __asm jz Label2
  847.     __asm mov al, LowerToUpperTable[eax]
  848.     __asm mov [esi - 1], al
  849.     __asm jmp short Label1
  851.     Label2:
  852.     __asm mov [RetStr], edx
  853.     __asm pop esi
  855.     return RetStr;
  856. }
  858. inline char * _fastcall StrSetEmpty(char *pszStr)
  859. {
  860.     *pszStr = '';
  861.     return pszStr;
  862. }
  864. inline int _fastcall StrIsEmpty(const char *pszStr)
  865. {
  866.     return ('' == *pszStr);
  867. }
  869. inline char * _fastcall StrSetEnd(char *pszStr)
  870. {
  871.     *pszStr = '';
  872.     return pszStr;
  873. }
  875. inline int _fastcall StrIsEnd(const char *pszStr)
  876. {
  877.     return ('' == *pszStr);
  878. }
  881. /*
  882. inline char *StrMove(char *Dest, char *Source,int Count)
  883. {
  884.     __asm{
  885.         MOV     ESI,[Source]
  886.         MOV     EDI,[Dest]
  887.         MOV     EDX,[Count]
  888.         CMP     EDI,ESI
  889.         JA      Label1
  890.         JE      Label2
  891.         SHR     ECX,2
  892.         REP     MOVSD
  893.         MOV     ECX,EDX
  894.         AND     ECX,3
  895.         REP     MOVSB
  896.         JMP     Label2
  897.     }
  898.     Label1:    
  899.     __asm{
  900.         LEA     ESI,[ESI+ECX-1]
  901.         LEA     EDI,[EDI+ECX-1]
  902.         AND     ECX,3
  903.         STD
  904.         REP     MOVSB
  905.         SUB     ESI,3
  906.         SUB     EDI,3
  907.         MOV     ECX,EDX
  908.         SHR     ECX,2
  909.         REP     MOVSD
  910.         CLD
  911.     }
  912.     Lable2:
  913. }
  915. function StrCopy(Dest, Source: PChar): PChar; assembler;
  916. asm
  917.         PUSH    EDI
  918.         PUSH    ESI
  919.         MOV     ESI,EAX
  920.         MOV     EDI,EDX
  921.         MOV     ECX,0FFFFFFFFH
  922.         XOR     AL,AL
  923.         REPNE   SCASB
  924.         NOT     ECX
  925.         MOV     EDI,ESI
  926.         MOV     ESI,EDX
  927.         MOV     EDX,ECX
  928.         MOV     EAX,EDI
  929.         SHR     ECX,2
  930.         REP     MOVSD
  931.         MOV     ECX,EDX
  932.         AND     ECX,3
  933.         REP     MOVSB
  934.         POP     ESI
  935.         POP     EDI
  936. end;
  938. function StrECopy(Dest, Source: PChar): PChar; assembler;
  939. asm
  940.         PUSH    EDI
  941.         PUSH    ESI
  942.         MOV     ESI,EAX
  943.         MOV     EDI,EDX
  944.         MOV     ECX,0FFFFFFFFH
  945.         XOR     AL,AL
  946.         REPNE   SCASB
  947.         NOT     ECX
  948.         MOV     EDI,ESI
  949.         MOV     ESI,EDX
  950.         MOV     EDX,ECX
  951.         SHR     ECX,2
  952.         REP     MOVSD
  953.         MOV     ECX,EDX
  954.         AND     ECX,3
  955.         REP     MOVSB
  956.         LEA     EAX,[EDI-1]
  957.         POP     ESI
  958.         POP     EDI
  959. end;
  961. function StrNCpy(Dest, Source: PChar; MaxLen: Cardinal): PChar; assembler;
  962. asm
  963.         PUSH    EDI
  964.         PUSH    ESI
  965.         PUSH    EBX
  966.         MOV     ESI,EAX
  967.         MOV     EDI,EDX
  968.         MOV     EBX,ECX
  969.         XOR     AL,AL
  970.         TEST    ECX,ECX
  971.         JZ      @@1
  972.         REPNE   SCASB
  973.         JNE     @@1
  974.         INC     ECX
  975. @@1:    SUB     EBX,ECX
  976.         MOV     EDI,ESI
  977.         MOV     ESI,EDX
  978.         MOV     EDX,EDI
  979.         MOV     ECX,EBX
  980.         SHR     ECX,2
  981.         REP     MOVSD
  982.         MOV     ECX,EBX
  983.         AND     ECX,3
  984.         REP     MOVSB
  985.         STOSB
  986.         MOV     EAX,EDX
  987.         POP     EBX
  988.         POP     ESI
  989.         POP     EDI
  990. end;
  992. function StrPCopy(Dest: PChar; const Source: string): PChar;
  993. begin
  994.   Result := StrNCpy(Dest, PChar(Source), Length(Source));
  995. end;
  997. function StrPLCopy(Dest: PChar; const Source: string;
  998.   MaxLen: Cardinal): PChar;
  999. begin
  1000.   Result := StrNCpy(Dest, PChar(Source), MaxLen);
  1001. end;
  1003. function StrCat(Dest, Source: PChar): PChar;
  1004. begin
  1005.   StrCopy(StrEnd(Dest), Source);
  1006.   Result := Dest;
  1007. end;
  1009. function StrLCat(Dest, Source: PChar; MaxLen: Cardinal): PChar; assembler;
  1010. asm
  1011.         PUSH    EDI
  1012.         PUSH    ESI
  1013.         PUSH    EBX
  1014.         MOV     EDI,Dest
  1015.         MOV     ESI,Source
  1016.         MOV     EBX,MaxLen
  1017.         CALL    StrEnd
  1018.         MOV     ECX,EDI
  1019.         ADD     ECX,EBX
  1020.         SUB     ECX,EAX
  1021.         JBE     @@1
  1022.         MOV     EDX,ESI
  1023.         CALL    StrNCpy
  1024. @@1:    MOV     EAX,EDI
  1025.         POP     EBX
  1026.         POP     ESI
  1027.         POP     EDI
  1028. end;
  1030. function StrComp(Str1, Str2: PChar): Integer; assembler;
  1031. asm
  1032.         PUSH    EDI
  1033.         PUSH    ESI
  1034.         MOV     EDI,EDX
  1035.         MOV     ESI,EAX
  1036.         MOV     ECX,0FFFFFFFFH
  1037.         XOR     EAX,EAX
  1038.         REPNE   SCASB
  1039.         NOT     ECX
  1040.         MOV     EDI,EDX
  1041.         XOR     EDX,EDX
  1042.         REPE    CMPSB
  1043.         MOV     AL,[ESI-1]
  1044.         MOV     DL,[EDI-1]
  1045.         SUB     EAX,EDX
  1046.         POP     ESI
  1047.         POP     EDI
  1048. end;
  1050. function StrIComp(Str1, Str2: PChar): Integer; assembler;
  1051. asm
  1052.         PUSH    EDI
  1053.         PUSH    ESI
  1054.         MOV     EDI,EDX
  1055.         MOV     ESI,EAX
  1056.         MOV     ECX,0FFFFFFFFH
  1057.         XOR     EAX,EAX
  1058.         REPNE   SCASB
  1059.         NOT     ECX
  1060.         MOV     EDI,EDX
  1061.         XOR     EDX,EDX
  1062. @@1:    REPE    CMPSB
  1063.         JE      @@4
  1064.         MOV     AL,[ESI-1]
  1065.         CMP     AL,'a'
  1066.         JB      @@2
  1067.         CMP     AL,'z'
  1068.         JA      @@2
  1069.         SUB     AL,20H
  1070. @@2:    MOV     DL,[EDI-1]
  1071.         CMP     DL,'a'
  1072.         JB      @@3
  1073.         CMP     DL,'z'
  1074.         JA      @@3
  1075.         SUB     DL,20H
  1076. @@3:    SUB     EAX,EDX
  1077.         JE      @@1
  1078. @@4:    POP     ESI
  1079.         POP     EDI
  1080. end;
  1082. function StrLComp(Str1, Str2: PChar; MaxLen: Cardinal): Integer; assembler;
  1083. asm
  1084.         PUSH    EDI
  1085.         PUSH    ESI
  1086.         PUSH    EBX
  1087.         MOV     EDI,EDX
  1088.         MOV     ESI,EAX
  1089.         MOV     EBX,ECX
  1090.         XOR     EAX,EAX
  1091.         OR      ECX,ECX
  1092.         JE      @@1
  1093.         REPNE   SCASB
  1094.         SUB     EBX,ECX
  1095.         MOV     ECX,EBX
  1096.         MOV     EDI,EDX
  1097.         XOR     EDX,EDX
  1098.         REPE    CMPSB
  1099.         MOV     AL,[ESI-1]
  1100.         MOV     DL,[EDI-1]
  1101.         SUB     EAX,EDX
  1102. @@1:    POP     EBX
  1103.         POP     ESI
  1104.         POP     EDI
  1105. end;
  1107. function StrLIComp(Str1, Str2: PChar; MaxLen: Cardinal): Integer; assembler;
  1108. asm
  1109.         PUSH    EDI
  1110.         PUSH    ESI
  1111.         PUSH    EBX
  1112.         MOV     EDI,EDX
  1113.         MOV     ESI,EAX
  1114.         MOV     EBX,ECX
  1115.         XOR     EAX,EAX
  1116.         OR      ECX,ECX
  1117.         JE      @@4
  1118.         REPNE   SCASB
  1119.         SUB     EBX,ECX
  1120.         MOV     ECX,EBX
  1121.         MOV     EDI,EDX
  1122.         XOR     EDX,EDX
  1123. @@1:    REPE    CMPSB
  1124.         JE      @@4
  1125.         MOV     AL,[ESI-1]
  1126.         CMP     AL,'a'
  1127.         JB      @@2
  1128.         CMP     AL,'z'
  1129.         JA      @@2
  1130.         SUB     AL,20H
  1131. @@2:    MOV     DL,[EDI-1]
  1132.         CMP     DL,'a'
  1133.         JB      @@3
  1134.         CMP     DL,'z'
  1135.         JA      @@3
  1136.         SUB     DL,20H
  1137. @@3:    SUB     EAX,EDX
  1138.         JE      @@1
  1139. @@4:    POP     EBX
  1140.         POP     ESI
  1141.         POP     EDI
  1142. end;
  1144. function StrScan(Str: PChar; Chr: Char): PChar; assembler;
  1145. asm
  1146.         PUSH    EDI
  1147.         PUSH    EAX
  1148.         MOV     EDI,Str
  1149.         MOV     ECX,0FFFFFFFFH
  1150.         XOR     AL,AL
  1151.         REPNE   SCASB
  1152.         NOT     ECX
  1153.         POP     EDI
  1154.         MOV     AL,Chr
  1155.         REPNE   SCASB
  1156.         MOV     EAX,0
  1157.         JNE     @@1
  1158.         MOV     EAX,EDI
  1159.         DEC     EAX
  1160. @@1:    POP     EDI
  1161. end;
  1163. function StrRScan(Str: PChar; Chr: Char): PChar; assembler;
  1164. asm
  1165.         PUSH    EDI
  1166.         MOV     EDI,Str
  1167.         MOV     ECX,0FFFFFFFFH
  1168.         XOR     AL,AL
  1169.         REPNE   SCASB
  1170.         NOT     ECX
  1171.         STD
  1172.         DEC     EDI
  1173.         MOV     AL,Chr
  1174.         REPNE   SCASB
  1175.         MOV     EAX,0
  1176.         JNE     @@1
  1177.         MOV     EAX,EDI
  1178.         INC     EAX
  1179. @@1:    CLD
  1180.         POP     EDI
  1181. end;
  1183. function StrPos(Str1, Str2: PChar): PChar; assembler;
  1184. asm
  1185.         PUSH    EDI
  1186.         PUSH    ESI
  1187.         PUSH    EBX
  1188.         OR      EAX,EAX
  1189.         JE      @@2
  1190.         OR      EDX,EDX
  1191.         JE      @@2
  1192.         MOV     EBX,EAX
  1193.         MOV     EDI,EDX
  1194.         XOR     AL,AL
  1195.         MOV     ECX,0FFFFFFFFH
  1196.         REPNE   SCASB
  1197.         NOT     ECX
  1198.         DEC     ECX
  1199.         JE      @@2
  1200.         MOV     ESI,ECX
  1201.         MOV     EDI,EBX
  1202.         MOV     ECX,0FFFFFFFFH
  1203.         REPNE   SCASB
  1204.         NOT     ECX
  1205.         SUB     ECX,ESI
  1206.         JBE     @@2
  1207.         MOV     EDI,EBX
  1208.         LEA     EBX,[ESI-1]
  1209. @@1:    MOV     ESI,EDX
  1210.         LODSB
  1211.         REPNE   SCASB
  1212.         JNE     @@2
  1213.         MOV     EAX,ECX
  1214.         PUSH    EDI
  1215.         MOV     ECX,EBX
  1216.         REPE    CMPSB
  1217.         POP     EDI
  1218.         MOV     ECX,EAX
  1219.         JNE     @@1
  1220.         LEA     EAX,[EDI-1]
  1221.         JMP     @@3
  1222. @@2:    XOR     EAX,EAX
  1223. @@3:    POP     EBX
  1224.         POP     ESI
  1225.         POP     EDI
  1226. end;
  1228. function StrUpper(Str: PChar): PChar; assembler;
  1229. asm
  1230.         PUSH    ESI
  1231.         MOV     ESI,Str
  1232.         MOV     EDX,Str
  1233. @@1:    LODSB
  1234.         OR      AL,AL
  1235.         JE      @@2
  1236.         CMP     AL,'a'
  1237.         JB      @@1
  1238.         CMP     AL,'z'
  1239.         JA      @@1
  1240.         SUB     AL,20H
  1241.         MOV     [ESI-1],AL
  1242.         JMP     @@1
  1243. @@2:    XCHG    EAX,EDX
  1244.         POP     ESI
  1245. end;
  1247. function StrLower(Str: PChar): PChar; assembler;
  1248. asm
  1249.         PUSH    ESI
  1250.         MOV     ESI,Str
  1251.         MOV     EDX,Str
  1252. @@1:    LODSB
  1253.         OR      AL,AL
  1254.         JE      @@2
  1255.         CMP     AL,'A'
  1256.         JB      @@1
  1257.         CMP     AL,'Z'
  1258.         JA      @@1
  1259.         ADD     AL,20H
  1260.         MOV     [ESI-1],AL
  1261.         JMP     @@1
  1262. @@2:    XCHG    EAX,EDX
  1263.         POP     ESI
  1264. end;
  1266. */
  1268. extern "C"{
  1269. void *  __cdecl memcpy(void *, const void *, size_t);
  1270. int     __cdecl memcmp(const void *, const void *, size_t);
  1271. void *  __cdecl memset(void *, int, size_t);
  1272. char *  __cdecl strcpy(char *, const char *);
  1273. char *  __cdecl strcat(char *, const char *);
  1274. int     __cdecl strcmp(const char *, const char *);
  1275. size_t  __cdecl strlen(const char *);
  1276. }
  1278. #pragma function(memcpy, memcmp, memset, strlen, strcpy, strcat, strcmp)
  1280. inline void *  __cdecl memcpy(void *pvDst, const void *pvSrc, size_t Count)
  1281. {
  1282.     MemCpy(pvDst, pvSrc, Count);
  1283.     return pvDst;
  1284. }
  1286. inline void *  __cdecl memmove(void *pvDst, const void *pvSrc, size_t Count)
  1287. {
  1288.     MemMove(pvDst, pvSrc, Count);
  1289.     return pvDst;
  1290. }
  1293. inline int     __cdecl memcmp(const void *pvDst, const void *pvSrc, size_t Count)
  1294. {
  1295.     return MemCmp(pvDst, pvSrc, Count);
  1296. }
  1298. inline void *  __cdecl memset(void *pvDst, int ch, size_t Count)
  1299. {
  1300.     
  1301.     MemSet(pvDst, (char)ch, Count);
  1302.     return pvDst;
  1303. }
  1305. inline void *  __cdecl memchr(const void *pvBuf, int ch, size_t Count)
  1306. {
  1307.     return MemChr(pvBuf, (char)ch, Count);
  1308. }
  1311. inline char *  __cdecl strcpy(char *pszDst, const char *pszSrc)
  1312. {
  1313.     return StrCpy(pszDst, pszSrc);
  1314. }
  1316. inline char *  __cdecl strcat(char *pszDst, const char *pszSrc)
  1317. {
  1318.     return StrCat(pszDst, pszSrc);
  1319. }
  1321. inline int     __cdecl strcmp(const char *pszStr1, const char *pszStr2)
  1322. {
  1323.     return StrCmp(pszStr1, pszStr2);
  1324. }
  1326. inline int __cdecl stricmp(const char *pszStr1, const char *pszStr2)
  1327. {
  1328.     return StrICmp(pszStr1, pszStr2);
  1329. }
  1332. inline size_t  __cdecl strlen(const char *pszStr)
  1333. {
  1334.     return StrLen(pszStr);
  1335. }
  1337. inline char *  __cdecl strncpy(char *pszDst, const char *pszSrc, size_t MaxLen)
  1338. {
  1339.     return StrNCpy(pszDst, pszSrc, MaxLen);
  1340. }
  1342. inline int     __cdecl strncmp(const char *pszStr1, const char *pszStr2, size_t MaxLen)
  1343. {
  1344.     return StrNCmp(pszStr1, pszStr2, MaxLen);
  1345. }
  1347. inline char *  __cdecl strchr(const char *pszStr, int ch)
  1348. {
  1349.     return StrChr(pszStr, (char)ch);
  1350. }
  1352. inline char *  __cdecl strrchr(const char *pszStr, int ch)
  1353. {
  1354.     return StrRChr(pszStr, (char)ch);
  1355. }
  1357. inline char * __cdecl strsetempty(char *pszStr)
  1358. {
  1359.     *pszStr = '';
  1360.     return pszStr;
  1361. }
  1363. inline int __cdecl strisempty(const char *pszStr)
  1364. {
  1365.     return ('' == *pszStr);
  1366. }
  1369. inline char * __cdecl strsetend(char *pszStr)
  1370. {
  1371.     *pszStr = '';
  1372.     return pszStr;
  1373. }
  1375. inline int __cdecl strisend(const char *pszStr)
  1376. {
  1377.     return ('' == *pszStr);
  1378. }
  1380. #endif  // _XP_LINUX_
  1383. #endif  // _KSTRING_H_