Subversion Repositories Kolibri OS

Rev

Rev 2839 | Blame | 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. // strtok( ESI)
  14. //------------------------------------------------------------------------------
  15.  
  16.  
  17. inline fastcall unsigned int strlen( EDI)
  18. {
  19.         $xor eax, eax
  20.         $mov ecx, -1
  21.         $REPNE $SCASB
  22.         EAX-=2+ECX;
  23. }
  24.  
  25.  
  26. inline fastcall strcpy( EDI, ESI)
  27. {
  28.         $cld
  29. l2:
  30.         $lodsb
  31.         $stosb
  32.         $test al,al
  33.         $jnz l2
  34. }
  35.  
  36.  
  37. inline fastcall strcat( EDI, ESI)
  38. {
  39.   asm {
  40.     mov ebx, edi
  41.     xor ecx, ecx
  42.     xor eax, eax
  43.     dec ecx
  44.     repne scasb
  45.     dec edi
  46.     mov edx, edi
  47.     mov edi, esi
  48.     xor ecx, ecx
  49.     xor eax, eax
  50.     dec ecx
  51.     repne scasb
  52.     xor ecx, 0ffffffffh
  53.     mov edi, edx
  54.     mov edx, ecx
  55.     mov eax, edi
  56.     shr ecx, 2
  57.     rep movsd
  58.     mov ecx, edx
  59.     and ecx, 3
  60.     rep movsb
  61.     mov eax, ebx
  62.         }
  63. }
  64.  
  65. char buffer[11];
  66. inline fastcall dword itoa( ESI)
  67. {
  68.      $mov     edi, #buffer
  69.      $mov     ecx, 10
  70.      $test     esi, esi
  71.      $jns     f1
  72.      $mov     al, '-'
  73.      $stosb
  74.      $neg     esi
  75. f1:
  76.      $mov     eax, esi
  77.      $push     -'0'
  78. f2:
  79.      $xor     edx, edx
  80.      $div     ecx
  81.      $push     edx
  82.      $test     eax, eax
  83.      $jnz     f2
  84. f3:
  85.      $pop     eax
  86.      $add     al, '0'
  87.      $stosb
  88.      $jnz     f3
  89.      $mov     eax, #buffer
  90.      $ret
  91. }
  92.  
  93.  
  94. inline fastcall dword atoi( EDI)
  95. {
  96.         //ESI=EDI=EAX;
  97.         ESI=EDI;
  98.         IF(DSBYTE[ESI]=='-')ESI++;
  99.         EAX=0;
  100.         BH=AL;
  101.         do{
  102.                 BL=DSBYTE[ESI]-'0';
  103.                 EAX=EAX*10+EBX;
  104.                 ESI++;
  105.         }while(DSBYTE[ESI]>0);
  106.         IF(DSBYTE[EDI]=='-') -EAX;
  107. }
  108.  
  109.  
  110. inline fastcall signed int strcmp( ESI, EDI)
  111. {
  112.         loop()
  113.         {
  114.                 IF (DSBYTE[ESI]<DSBYTE[EDI]) RETURN -1;
  115.                 IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
  116.                 IF (DSBYTE[ESI]=='\0') RETURN 0;
  117.                 ESI++;
  118.                 EDI++;
  119.         }
  120. }
  121.  
  122. inline fastcall unsigned int strchr( ESI,BL)
  123. {
  124.         int jj=0;
  125.         do{
  126.                 jj++;
  127.                 $lodsb
  128.                 IF(AL==BL) return jj;
  129.         } while(AL!=0);
  130. }
  131.  
  132.  
  133. inline fastcall unsigned int strrchr( ESI,BL)
  134. {
  135.         int jj=0, last=-1;
  136.         do{
  137.                 jj++;
  138.                 $lodsb
  139.                 IF(AL==BL) last=jj;
  140.         } while(AL!=0);
  141.         return last;
  142. }
  143.  
  144.  
  145. inline fastcall strupr( ESI)
  146. {
  147.         do{
  148.                 AL=DSBYTE[ESI];
  149.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  150.                 ESI++;
  151.         }while(AL!=0);
  152. }
  153.  
  154. inline fastcall strlwr( ESI)
  155. {
  156.         do{
  157.                 $LODSB
  158.                 IF(AL>='A')&&(AL<='Z'){
  159.                         AL+=0x20;
  160.                         DSBYTE[ESI-1]=AL;
  161.                         CONTINUE;
  162.                 }
  163.         }while(AL!=0);
  164. }
  165.  
  166.  
  167. inline fastcall unsigned int strstr( EBX, EDX)
  168. {
  169.   asm {
  170.     mov edi, edx
  171.     xor ecx, ecx
  172.     xor eax, eax
  173.     dec ecx
  174.     repne scasb
  175.     not ecx
  176.     dec ecx
  177.     je ls2
  178.     mov esi, ecx
  179.     xor ecx, ecx
  180.     mov edi, ebx
  181.     dec ecx
  182.     repne scasb
  183.     not ecx
  184.     sub ecx, esi
  185.     jbe ls2
  186.     mov edi, ebx
  187.     lea ebx, DSDWORD[ esi-1]
  188. ls1: mov esi, edx
  189.     lodsb
  190.     repne scasb
  191.     jne ls2
  192.     mov eax, ecx
  193.     push edi
  194.     mov ecx, ebx
  195.     repe cmpsb
  196.     pop edi
  197.     mov ecx, eax
  198.     jne ls1
  199.     lea eax, DSDWORD[ edi-1]
  200.     jmp short ls3
  201. ls2: xor eax, eax
  202. ls3:
  203.   }
  204. }
  205.  
  206. /* strtok( LPSTR dest, src, divs);
  207. src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
  208. dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
  209. divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
  210. Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
  211.          íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
  212.                â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
  213.  
  214. dword fastcall strtok( EDX, ESI, EBX)
  215. {
  216.   asm {
  217.     XOR ECX, ECX
  218.     MOV EDI, EBX
  219.     XOR EAX, EAX
  220.     DEC ECX
  221.     REPNE SCASB
  222.     XOR ECX, 0FFFFFFFFH
  223.     DEC ECX
  224.     PUSH ECX
  225. L1: LODSB
  226.     OR AL, AL
  227.     JZ L4
  228.     MOV EDI, EBX
  229.     MOV ECX, SSDWORD[ ESP]
  230.     REPNE SCASB
  231.     JZ L1
  232.     DEC ESI
  233. L2: LODSB
  234.     MOV EDI, EBX
  235.     MOV ECX, SSDWORD[ ESP]
  236.     REPNE SCASB
  237.     JZ L3
  238.     MOV DSBYTE[ EDX], AL
  239.     INC EDX
  240.     JMP SHORT L2
  241. L3: MOV EAX, ESI
  242. L4: POP ECX
  243.   } DSBYTE[ EDX] = 0;
  244. }
  245.