Subversion Repositories Kolibri OS

Rev

Rev 3081 | Rev 3114 | 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.         EDI = #buffer;
  118.         ECX = 10;
  119.         if (ESI < 0)
  120.         {
  121.                  $mov     al, '-'
  122.                  $stosb
  123.                  $neg     esi
  124.         }
  125.  
  126.         $mov     eax, esi
  127.         $push    -'0'
  128. F2:
  129.         $xor     edx, edx
  130.         $div     ecx
  131.         $push    edx
  132.         $test    eax, eax
  133.         $jnz     F2
  134. F3:
  135.         $pop     eax
  136.         $add     al, '0'
  137.         $stosb
  138.         $jnz     F3
  139.        
  140.         $mov     al, '\0'
  141.         $stosb
  142.          
  143.      return #buffer;
  144. }
  145.  
  146.  
  147.  
  148. inline fastcall dword atoi( EDI)
  149. {
  150.         ESI=EDI;
  151.         IF(DSBYTE[ESI]=='-')ESI++;
  152.         EAX=0;
  153.         BH=AL;
  154.         do{
  155.                 BL=DSBYTE[ESI]-'0';
  156.                 EAX=EAX*10+EBX;
  157.                 ESI++;
  158.         }while(DSBYTE[ESI]>='0');
  159.         IF(DSBYTE[EDI]=='-') -EAX;
  160. }
  161.  
  162.  
  163. inline fastcall signed int strchr( ESI,BL)
  164. {
  165.         int jj=0;
  166.         do{
  167.                 jj++;
  168.                 $lodsb
  169.                 IF(AL==BL) return jj;
  170.         } while(AL!=0);
  171.         return 0;
  172. }
  173.  
  174.  
  175. inline fastcall signed int strrchr( ESI,BL)
  176. {
  177.         int jj=0, last=0;
  178.         do{
  179.                 jj++;
  180.                 $lodsb
  181.                 IF(AL==BL) last=jj;
  182.         } while(AL!=0);
  183.         return last;
  184. }
  185.  
  186.  
  187. inline fastcall strupr( ESI)
  188. {
  189.         do{
  190.                 AL=DSBYTE[ESI];
  191.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  192.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //р-я
  193.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //р-я
  194.                 ESI++;
  195.         }while(AL!=0);
  196. }
  197.  
  198. inline fastcall strlwr( ESI)
  199. {
  200.         do{
  201.                 $LODSB
  202.                 IF(AL>='A')&&(AL<='Z'){
  203.                         AL+=0x20;
  204.                         DSBYTE[ESI-1]=AL;
  205.                         CONTINUE;
  206.                 }
  207.         }while(AL!=0);
  208. }
  209.  
  210. inline fastcall strttl( EDX)
  211. {
  212.         AL=DSBYTE[EDX];
  213.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  214.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //р-я
  215.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //р-я
  216.         do{
  217.                 EDX++;
  218.                 AL=DSBYTE[EDX];
  219.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  220.                 IF(AL>='А')&&(AL<='П')DSBYTE[EDX]=AL|0x20; //а-п
  221.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //р-я
  222.         }while(AL!=0);
  223. }
  224.  
  225.  
  226.  
  227. inline fastcall dword strstr( EBX, EDX)
  228. {
  229.   asm {
  230.     MOV EDI, EDX
  231.     XOR ECX, ECX
  232.     XOR EAX, EAX
  233.     DEC ECX
  234.     REPNE SCASB
  235.     NOT ECX
  236.     DEC ECX
  237.     JE LS2
  238.     MOV ESI, ECX
  239.     XOR ECX, ECX
  240.     MOV EDI, EBX
  241.     DEC ECX
  242.     REPNE SCASB
  243.     NOT ECX
  244.     SUB ECX, ESI
  245.     JBE LS2
  246.     MOV EDI, EBX
  247.     LEA EBX, DSDWORD[ ESI-1]
  248. LS1: MOV ESI, EDX
  249.     LODSB
  250.     REPNE SCASB
  251.     JNE LS2
  252.     MOV EAX, ECX
  253.     PUSH EDI
  254.     MOV ECX, EBX
  255.     REPE CMPSB
  256.     POP EDI
  257.     MOV ECX, EAX
  258.     JNE LS1
  259.     LEA EAX, DSDWORD[ EDI-1]
  260.     JMP SHORT LS3
  261. LS2: XOR EAX, EAX
  262. LS3:
  263.   }
  264. }
  265.  
  266. //
  267. void strcpyb(dword searchin, copyin, startstr, endstr)
  268. {
  269.         dword startp, endp;
  270.         startp = strstr(searchin, startstr) + strlen(startstr);
  271.         endp = strstr(startp, endstr);
  272.         if (startp==endp) return;
  273.         do
  274.         {
  275.                 DSBYTE[copyin] = DSBYTE[startp];
  276.                 copyin++;
  277.                 startp++;
  278.         }
  279.         while (startp<endp);
  280.         DSBYTE[copyin] = '\0';
  281. }
  282.  
  283. int chrnum(dword searchin, char symbol)
  284. {
  285.         int num = 0;
  286.         while(DSBYTE[searchin])
  287.         {
  288.                 if (DSBYTE[searchin] == symbol) num++;
  289.                 searchin++;
  290.         }
  291.         return num;
  292. }
  293.  
  294.  
  295.  
  296.  
  297. /* strtok( LPSTR dest, src, divs);
  298. src - єърчрЄхы№ эр шёїюфэє■ ёЄЁюъє шыш Ёхчєы№ЄрЄ яЁхф√фє∙хую т√чютр
  299. dest - єърчрЄхы№ эр сєЇхЁ, ъєфр сєфхЄ ёъюяшЁютрэю ёыютю
  300. divs - єърчрЄхы№ эр ёЄЁюъє, ёюфхЁцр∙є■ ёшьтюы√-ЁрчфхышЄхыш
  301. ┬ючтЁр∙рхЄ: 0, хёыш ёыют сюы№°х эхЄ
  302.          эх 0, хёыш ёыютю ёъюяшЁютрэю т dest (яхЁхфрщЄх ¤Єю чэрўхэшх
  303.                т ърўхёЄтх src фы  яюёыхфє■∙хую яюшёър) */
  304.  
  305. inline fastcall dword strtok( EDX, ESI, EBX)
  306. {
  307.   asm {
  308.     XOR ECX, ECX
  309.     MOV EDI, EBX
  310.     XOR EAX, EAX
  311.     DEC ECX
  312.     REPNE SCASB
  313.     XOR ECX, 0FFFFFFFFH
  314.     DEC ECX
  315.     PUSH ECX
  316. L1: LODSB
  317.     OR AL, AL
  318.     JZ L4
  319.     MOV EDI, EBX
  320.     MOV ECX, SSDWORD[ ESP]
  321.     REPNE SCASB
  322.     JZ L1
  323.     DEC ESI
  324. L2: LODSB
  325.     MOV EDI, EBX
  326.     MOV ECX, SSDWORD[ ESP]
  327.     REPNE SCASB
  328.     JZ L3
  329.     MOV DSBYTE[ EDX], AL
  330.     INC EDX
  331.     JMP SHORT L2
  332. L3: MOV EAX, ESI
  333. L4: POP ECX
  334.   } DSBYTE[ EDX] = 0;
  335. }
  336.  
  337. #define strncpy strcpyn
  338. #define strnmov strmovn
  339. #define stricmp strcmpi
  340. #define strcmpn strncmp
  341. #define strncmpi strcmpni
  342. #define stricmpn strcmpni
  343. #define strnicmp strcmpni
  344. #define strincmp strcmpni
  345. #define strcmpin strcmpni
  346.