Subversion Repositories Kolibri OS

Rev

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