Subversion Repositories Kolibri OS

Rev

Rev 3003 | 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.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //à-ï
  207.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //à-ï
  208.                 ESI++;
  209.         }while(AL!=0);
  210. }
  211.  
  212. inline fastcall strlwr( ESI)
  213. {
  214.         do{
  215.                 $LODSB
  216.                 IF(AL>='A')&&(AL<='Z'){
  217.                         AL+=0x20;
  218.                         DSBYTE[ESI-1]=AL;
  219.                         CONTINUE;
  220.                 }
  221.         }while(AL!=0);
  222. }
  223.  
  224. inline fastcall strttl( EDX)
  225. {
  226.         AL=DSBYTE[EDX];
  227.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  228.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //à-ï
  229.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //à-ï
  230.         do{
  231.                 EDX++;
  232.                 AL=DSBYTE[EDX];
  233.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  234.                 IF(AL>='€')&&(AL<='')DSBYTE[EDX]=AL|0x20; // -¯
  235.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //à-ï
  236.         }while(AL!=0);
  237. }
  238.  
  239.  
  240.  
  241. inline fastcall dword strstr( EBX, EDX)
  242. {
  243.   asm {
  244.     MOV EDI, EDX
  245.     XOR ECX, ECX
  246.     XOR EAX, EAX
  247.     DEC ECX
  248.     REPNE SCASB
  249.     NOT ECX
  250.     DEC ECX
  251.     JE LS2
  252.     MOV ESI, ECX
  253.     XOR ECX, ECX
  254.     MOV EDI, EBX
  255.     DEC ECX
  256.     REPNE SCASB
  257.     NOT ECX
  258.     SUB ECX, ESI
  259.     JBE LS2
  260.     MOV EDI, EBX
  261.     LEA EBX, DSDWORD[ ESI-1]
  262. LS1: MOV ESI, EDX
  263.     LODSB
  264.     REPNE SCASB
  265.     JNE LS2
  266.     MOV EAX, ECX
  267.     PUSH EDI
  268.     MOV ECX, EBX
  269.     REPE CMPSB
  270.     POP EDI
  271.     MOV ECX, EAX
  272.     JNE LS1
  273.     LEA EAX, DSDWORD[ EDI-1]
  274.     JMP SHORT LS3
  275. LS2: XOR EAX, EAX
  276. LS3:
  277.   }
  278. }
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288.  
  289.  
  290.  
  291.  
  292.  
  293.  
  294.  
  295. /* strtok( LPSTR dest, src, divs);
  296. src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
  297. dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
  298. divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
  299. Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
  300.          íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
  301.                â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
  302.  
  303. inline fastcall dword strtok( EDX, ESI, EBX)
  304. {
  305.   asm {
  306.     XOR ECX, ECX
  307.     MOV EDI, EBX
  308.     XOR EAX, EAX
  309.     DEC ECX
  310.     REPNE SCASB
  311.     XOR ECX, 0FFFFFFFFH
  312.     DEC ECX
  313.     PUSH ECX
  314. L1: LODSB
  315.     OR AL, AL
  316.     JZ L4
  317.     MOV EDI, EBX
  318.     MOV ECX, SSDWORD[ ESP]
  319.     REPNE SCASB
  320.     JZ L1
  321.     DEC ESI
  322. L2: LODSB
  323.     MOV EDI, EBX
  324.     MOV ECX, SSDWORD[ ESP]
  325.     REPNE SCASB
  326.     JZ L3
  327.     MOV DSBYTE[ EDX], AL
  328.     INC EDX
  329.     JMP SHORT L2
  330. L3: MOV EAX, ESI
  331. L4: POP ECX
  332.   } DSBYTE[ EDX] = 0;
  333. }
  334.  
  335. #define strncpy strcpyn
  336. #define strnmov strmovn
  337. #define stricmp strcmpi
  338. #define strcmpn strncmp
  339. #define strncmpi strcmpni
  340. #define stricmpn strcmpni
  341. #define strnicmp strcmpni
  342. #define strincmp strcmpni
  343. #define strcmpin strcmpni