Subversion Repositories Kolibri OS

Rev

Rev 2874 | Go to most recent revision | 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. // 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. char buffer[11];
  134. inline fastcall dword itoa( ESI)
  135. {
  136.      $mov     edi, #buffer
  137.      $mov     ecx, 10
  138.      $test     esi, esi
  139.      $jns     f1
  140.      $mov     al, '-'
  141.      $stosb
  142.      $neg     esi
  143. f1:
  144.      $mov     eax, esi
  145.      $push     -'0'
  146. f2:
  147.      $xor     edx, edx
  148.      $div     ecx
  149.      $push     edx
  150.      $test     eax, eax
  151.      $jnz     f2
  152. f3:
  153.      $pop     eax
  154.      $add     al, '0'
  155.      $stosb
  156.      $jnz     f3
  157.      $mov     eax, #buffer
  158.      $ret
  159. }
  160.  
  161.  
  162. inline fastcall dword atoi( EDI)
  163. {
  164.         //ESI=EDI=EAX;
  165.         ESI=EDI;
  166.         IF(DSBYTE[ESI]=='-')ESI++;
  167.         EAX=0;
  168.         BH=AL;
  169.         do{
  170.                 BL=DSBYTE[ESI]-'0';
  171.                 EAX=EAX*10+EBX;
  172.                 ESI++;
  173.         }while(DSBYTE[ESI]>0);
  174.         IF(DSBYTE[EDI]=='-') -EAX;
  175. }
  176.  
  177.  
  178. inline fastcall unsigned int strchr( ESI,BL)
  179. {
  180.         int jj=0;
  181.         do{
  182.                 jj++;
  183.                 $lodsb
  184.                 IF(AL==BL) return jj;
  185.         } while(AL!=0);
  186. }
  187.  
  188.  
  189. inline fastcall unsigned int strrchr( ESI,BL)
  190. {
  191.         int jj=0, last=-1;
  192.         do{
  193.                 jj++;
  194.                 $lodsb
  195.                 IF(AL==BL) last=jj;
  196.         } while(AL!=0);
  197.         return last;
  198. }
  199.  
  200.  
  201. inline fastcall strupr( ESI)
  202. {
  203.         do{
  204.                 AL=DSBYTE[ESI];
  205.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  206.                 ESI++;
  207.         }while(AL!=0);
  208. }
  209.  
  210. inline fastcall strlwr( ESI)
  211. {
  212.         do{
  213.                 $LODSB
  214.                 IF(AL>='A')&&(AL<='Z'){
  215.                         AL+=0x20;
  216.                         DSBYTE[ESI-1]=AL;
  217.                         CONTINUE;
  218.                 }
  219.         }while(AL!=0);
  220. }
  221.  
  222. inline fastcall strttl( EDX)
  223. {
  224.         AL=DSBYTE[EDX];
  225.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  226.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //à-ï
  227.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //à-ï
  228.         do{
  229.                 EDX++;
  230.                 AL=DSBYTE[EDX];
  231.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  232.                 IF(AL>='€')&&(AL<='')DSBYTE[EDX]=AL|0x20; // -¯
  233.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //à-ï
  234.         }while(AL!=0);
  235. }
  236.  
  237.  
  238.  
  239. inline fastcall unsigned int strstr( EBX, EDX)
  240. {
  241.   asm {
  242.     mov edi, edx
  243.     xor ecx, ecx
  244.     xor eax, eax
  245.     dec ecx
  246.     repne scasb
  247.     not ecx
  248.     dec ecx
  249.     je ls2
  250.     mov esi, ecx
  251.     xor ecx, ecx
  252.     mov edi, ebx
  253.     dec ecx
  254.     repne scasb
  255.     not ecx
  256.     sub ecx, esi
  257.     jbe ls2
  258.     mov edi, ebx
  259.     lea ebx, DSDWORD[ esi-1]
  260. ls1: mov esi, edx
  261.     lodsb
  262.     repne scasb
  263.     jne ls2
  264.     mov eax, ecx
  265.     push edi
  266.     mov ecx, ebx
  267.     repe cmpsb
  268.     pop edi
  269.     mov ecx, eax
  270.     jne ls1
  271.     lea eax, DSDWORD[ edi-1]
  272.     jmp short ls3
  273. ls2: xor eax, eax
  274. ls3:
  275.   }
  276. }
  277.  
  278.  
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288.  
  289.  
  290.  
  291.  
  292.  
  293. /* strtok( LPSTR dest, src, divs);
  294. src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
  295. dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
  296. divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
  297. Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
  298.          íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
  299.                â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
  300.  
  301. dword fastcall strtok( EDX, ESI, EBX)
  302. {
  303.   asm {
  304.     XOR ECX, ECX
  305.     MOV EDI, EBX
  306.     XOR EAX, EAX
  307.     DEC ECX
  308.     REPNE SCASB
  309.     XOR ECX, 0FFFFFFFFH
  310.     DEC ECX
  311.     PUSH ECX
  312. L1: LODSB
  313.     OR AL, AL
  314.     JZ L4
  315.     MOV EDI, EBX
  316.     MOV ECX, SSDWORD[ ESP]
  317.     REPNE SCASB
  318.     JZ L1
  319.     DEC ESI
  320. L2: LODSB
  321.     MOV EDI, EBX
  322.     MOV ECX, SSDWORD[ ESP]
  323.     REPNE SCASB
  324.     JZ L3
  325.     MOV DSBYTE[ EDX], AL
  326.     INC EDX
  327.     JMP SHORT L2
  328. L3: MOV EAX, ESI
  329. L4: POP ECX
  330.   } DSBYTE[ EDX] = 0;
  331. }
  332.  
  333. #define strncpy strcpyn
  334. #define strnmov strmovn
  335. #define stricmp strcmpi
  336. #define strcmpn strncmp
  337. #define strncmpi strcmpni
  338. #define stricmpn strcmpni
  339. #define strnicmp strcmpni
  340. #define strincmp strcmpni
  341. #define strcmpin strcmpni