Subversion Repositories Kolibri OS

Rev

Rev 3081 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. //------------------------------------------------------------------------------
  2. // strcmp( ESI, EDI)
  3. // strlen( EDI)
  4. // strcpy( EDI, ESI)
  5. // strcat( EDI, ESI)
  6. // strchr( ESI,BL)
  7. // strrchr( ESI,BL)
  8. // strstr( EBX, EDX)
  9. // itoa( ESI)
  10. // atoi( EAX)
  11. // strupr( ESI)
  12. // strlwr( ESI) ----- тючьюцэю эх яюффхЁцштрхЄ ъшЁшыышЎє
  13. // strttl( EDX)
  14. // strtok( ESI)
  15. //------------------------------------------------------------------------------
  16.  
  17. inline fastcall signed int strcmp( ESI, EDI)
  18. {
  19.         loop()
  20.         {
  21.                 IF (DSBYTE[ESI]<DSBYTE[EDI]) RETURN -1;
  22.                 IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
  23.                 IF (DSBYTE[ESI]=='\0') RETURN 0;
  24.                 ESI++;
  25.                 EDI++;
  26.         }
  27. }
  28.  
  29.  
  30. inline fastcall signed int strncmp( ESI, EDI, ECX)
  31. {
  32.   asm {
  33.     MOV EBX, EDI
  34.     XOR EAX, EAX
  35.     MOV EDX, ECX
  36.     OR ECX, ECX
  37.     JE L1
  38.     REPNE SCASB
  39.     SUB EDX, ECX
  40.     MOV ECX, EDX
  41.     MOV EDI, EBX
  42.     XOR EBX, EBX
  43.     REPE CMPSB
  44.     MOV AL, DSBYTE[ ESI-1]
  45.     MOV BL, DSBYTE[ EDI-1]
  46.     SUB EAX, EBX
  47. L1:
  48.   }
  49. }
  50.  
  51.  
  52.  
  53. /*
  54.  
  55. inline fastcall signed int strcmpi( ESI,EDI)
  56. uses EBX
  57. {
  58.         do{
  59.                 $lodsb
  60.                 IF(AL>='a')&&(AL<='z')AL-=0x20;
  61.                 BL=DSBYTE[(E)DI];
  62.                 IF(BL>='a')&&(BL<='z')BL-=0x20;
  63.                 AL-=BL;
  64.                 IF(!ZEROFLAG)BREAK;
  65.                 (E)DI++;
  66.         }while(BL!=0);
  67. }
  68.  
  69. inline char STRNCMPI((E)SI,(E)DI,(E)CX)
  70. {
  71.         (E)AX=0;
  72.         LOOPNZ((E)CX){
  73.                 $lodsb
  74.                 IF(AL>='a')&&(AL<='z')AL-=0x20;
  75.                 AH=DSBYTE[EDI];
  76.                 IF(AH>='a')&&(AH<='z')AH-=0x20;
  77.                 EDI++;
  78.                 IF(AL==0)||(AH==0)||(AL!=AH)BREAK;
  79.         }
  80.         AL=AL-AH;
  81. }*/
  82.  
  83.  
  84.  
  85. inline fastcall unsigned int strlen( EDI)
  86. {
  87.         $xor eax, eax
  88.         $mov ecx, -1
  89.         $REPNE $SCASB
  90.         EAX-=2+ECX;
  91. }
  92.  
  93.  
  94. inline fastcall strcpy( EDI, ESI)
  95. {
  96.         $cld
  97. l2:
  98.         $lodsb
  99.         $stosb
  100.         $test al,al
  101.         $jnz l2
  102. }
  103.  
  104.  
  105. inline fastcall strcat( EDI, ESI)
  106. {
  107.   asm {
  108.     mov ebx, edi
  109.     xor ecx, ecx
  110.     xor eax, eax
  111.     dec ecx
  112.     repne scasb
  113.     dec edi
  114.     mov edx, edi
  115.     mov edi, esi
  116.     xor ecx, ecx
  117.     xor eax, eax
  118.     dec ecx
  119.     repne scasb
  120.     xor ecx, 0ffffffffh
  121.     mov edi, edx
  122.     mov edx, ecx
  123.     mov eax, edi
  124.     shr ecx, 2
  125.     rep movsd
  126.     mov ecx, edx
  127.     and ecx, 3
  128.     rep movsb
  129.     mov eax, ebx
  130.         }
  131. }
  132.  
  133. dword itoa( ESI)
  134. {
  135.         unsigned char buffer[11];
  136.         EDI = #buffer;
  137.         ECX = 10;
  138.         if (ESI < 0)
  139.         {
  140.                  $mov     al, '-'
  141.                  $stosb
  142.                  $neg     esi
  143.         }
  144.  
  145.         $mov     eax, esi
  146.         $push    -'0'
  147. f2:
  148.         $xor     edx, edx
  149.         $div     ecx
  150.         $push    edx
  151.         $test    eax, eax
  152.         $jnz     f2
  153. f3:
  154.         $pop     eax
  155.         $add     al, '0'
  156.         $stosb
  157.         $jnz     f3
  158.        
  159.         $mov     al, '\0'
  160.         $stosb
  161.          
  162.      return #buffer;
  163. }
  164.  
  165.  
  166.  
  167. inline fastcall dword atoi( EDI)
  168. {
  169.         ESI=EDI;
  170.         IF(DSBYTE[ESI]=='-')ESI++;
  171.         EAX=0;
  172.         BH=AL;
  173.         do{
  174.                 BL=DSBYTE[ESI]-'0';
  175.                 EAX=EAX*10+EBX;
  176.                 ESI++;
  177.         }while(DSBYTE[ESI]>0);
  178.         IF(DSBYTE[EDI]=='-') -EAX;
  179. }
  180.  
  181.  
  182. inline fastcall signed int strchr( ESI,BL)
  183. {
  184.         int jj=0;
  185.         do{
  186.                 jj++;
  187.                 $lodsb
  188.                 IF(AL==BL) return jj;
  189.         } while(AL!=0);
  190.         return 0;
  191. }
  192.  
  193.  
  194. inline fastcall signed int strrchr( ESI,BL)
  195. {
  196.         int jj=0, last=0;
  197.         do{
  198.                 jj++;
  199.                 $lodsb
  200.                 IF(AL==BL) last=jj;
  201.         } while(AL!=0);
  202.         return last;
  203. }
  204.  
  205.  
  206. inline fastcall strupr( ESI)
  207. {
  208.         do{
  209.                 AL=DSBYTE[ESI];
  210.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  211.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //р-я
  212.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //р-я
  213.                 ESI++;
  214.         }while(AL!=0);
  215. }
  216.  
  217. inline fastcall strlwr( ESI)
  218. {
  219.         do{
  220.                 $LODSB
  221.                 IF(AL>='A')&&(AL<='Z'){
  222.                         AL+=0x20;
  223.                         DSBYTE[ESI-1]=AL;
  224.                         CONTINUE;
  225.                 }
  226.         }while(AL!=0);
  227. }
  228.  
  229. inline fastcall strttl( EDX)
  230. {
  231.         AL=DSBYTE[EDX];
  232.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  233.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //р-я
  234.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //р-я
  235.         do{
  236.                 EDX++;
  237.                 AL=DSBYTE[EDX];
  238.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  239.                 IF(AL>='А')&&(AL<='П')DSBYTE[EDX]=AL|0x20; //а-п
  240.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //р-я
  241.         }while(AL!=0);
  242. }
  243.  
  244.  
  245.  
  246. inline fastcall dword strstr( EBX, EDX)
  247. {
  248.   asm {
  249.     MOV EDI, EDX
  250.     XOR ECX, ECX
  251.     XOR EAX, EAX
  252.     DEC ECX
  253.     REPNE SCASB
  254.     NOT ECX
  255.     DEC ECX
  256.     JE LS2
  257.     MOV ESI, ECX
  258.     XOR ECX, ECX
  259.     MOV EDI, EBX
  260.     DEC ECX
  261.     REPNE SCASB
  262.     NOT ECX
  263.     SUB ECX, ESI
  264.     JBE LS2
  265.     MOV EDI, EBX
  266.     LEA EBX, DSDWORD[ ESI-1]
  267. LS1: MOV ESI, EDX
  268.     LODSB
  269.     REPNE SCASB
  270.     JNE LS2
  271.     MOV EAX, ECX
  272.     PUSH EDI
  273.     MOV ECX, EBX
  274.     REPE CMPSB
  275.     POP EDI
  276.     MOV ECX, EAX
  277.     JNE LS1
  278.     LEA EAX, DSDWORD[ EDI-1]
  279.     JMP SHORT LS3
  280. LS2: XOR EAX, EAX
  281. LS3:
  282.   }
  283. }
  284.  
  285.  
  286.  
  287.  
  288. /* strtok( LPSTR dest, src, divs);
  289. src - єърчрЄхы№ эр шёїюфэє■ ёЄЁюъє шыш Ёхчєы№ЄрЄ яЁхф√фє∙хую т√чютр
  290. dest - єърчрЄхы№ эр сєЇхЁ, ъєфр сєфхЄ ёъюяшЁютрэю ёыютю
  291. divs - єърчрЄхы№ эр ёЄЁюъє, ёюфхЁцр∙є■ ёшьтюы√-ЁрчфхышЄхыш
  292. ┬ючтЁр∙рхЄ: 0, хёыш ёыют сюы№°х эхЄ
  293.          эх 0, хёыш ёыютю ёъюяшЁютрэю т dest (яхЁхфрщЄх ¤Єю чэрўхэшх
  294.                т ърўхёЄтх src фы  яюёыхфє■∙хую яюшёър) */
  295.  
  296. inline fastcall dword strtok( EDX, ESI, EBX)
  297. {
  298.   asm {
  299.     XOR ECX, ECX
  300.     MOV EDI, EBX
  301.     XOR EAX, EAX
  302.     DEC ECX
  303.     REPNE SCASB
  304.     XOR ECX, 0FFFFFFFFH
  305.     DEC ECX
  306.     PUSH ECX
  307. L1: LODSB
  308.     OR AL, AL
  309.     JZ L4
  310.     MOV EDI, EBX
  311.     MOV ECX, SSDWORD[ ESP]
  312.     REPNE SCASB
  313.     JZ L1
  314.     DEC ESI
  315. L2: LODSB
  316.     MOV EDI, EBX
  317.     MOV ECX, SSDWORD[ ESP]
  318.     REPNE SCASB
  319.     JZ L3
  320.     MOV DSBYTE[ EDX], AL
  321.     INC EDX
  322.     JMP SHORT L2
  323. L3: MOV EAX, ESI
  324. L4: POP ECX
  325.   } DSBYTE[ EDX] = 0;
  326. }
  327.  
  328. #define strncpy strcpyn
  329. #define strnmov strmovn
  330. #define stricmp strcmpi
  331. #define strcmpn strncmp
  332. #define strncmpi strcmpni
  333. #define stricmpn strcmpni
  334. #define strnicmp strcmpni
  335. #define strincmp strcmpni
  336. #define strcmpin strcmpni