Subversion Repositories Kolibri OS

Rev

Rev 3225 | Rev 3444 | 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) --- find first BL
  7. // strrchr( ESI,BL) --- find last 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. // strnumb(dword searchin, startstr, endstr) --- get number between strings
  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 void 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 int strlcpy(dword ESI, EDI, EBX)
  75. {
  76.         EDX=0;
  77.         do {
  78.                 DSBYTE[ESI]=DSBYTE[EDI];
  79.                 ESI++;
  80.                 EDI++;
  81.                 EDX++;
  82.                 if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
  83.         } while(DSBYTE[EDI-1]!='\0');
  84.         return 0;
  85. }
  86.  
  87.  
  88.  
  89. inline fastcall void strcat( EDI, ESI)
  90. {
  91.   asm {
  92.     mov ebx, edi
  93.     xor ecx, ecx
  94.     xor eax, eax
  95.     dec ecx
  96.     repne scasb
  97.     dec edi
  98.     mov edx, edi
  99.     mov edi, esi
  100.     xor ecx, ecx
  101.     xor eax, eax
  102.     dec ecx
  103.     repne scasb
  104.     xor ecx, 0ffffffffh
  105.     mov edi, edx
  106.     mov edx, ecx
  107.     mov eax, edi
  108.     shr ecx, 2
  109.     rep movsd
  110.     mov ecx, edx
  111.     and ecx, 3
  112.     rep movsb
  113.     mov eax, ebx
  114.         }
  115. }
  116.  
  117. inline fastcall void chrcat(ESI, BL)
  118. {
  119.         EDI = strlen(ESI);
  120.         ESBYTE[ESI+EDI] = BL;
  121.         ESBYTE[ESI+EDI+1] = 0;
  122. }
  123.  
  124.  
  125. inline fastcall signed int strchr( ESI,BL)
  126. {
  127.         int jj=0;
  128.         do{
  129.                 jj++;
  130.                 $lodsb
  131.                 IF(AL==BL) return jj;
  132.         } while(AL!=0);
  133.         return 0;
  134. }
  135.  
  136.  
  137. inline fastcall signed int strrchr( ESI,BL)
  138. {
  139.         int jj=0, last=0;
  140.         do{
  141.                 jj++;
  142.                 $lodsb
  143.                 IF(AL==BL) last=jj;
  144.         } while(AL!=0);
  145.         return last;
  146. }
  147.  
  148.  
  149. int chrnum(dword searchin, char symbol)
  150. {
  151.         int num = 0;
  152.         while(DSBYTE[searchin])
  153.         {
  154.                 if (DSBYTE[searchin] == symbol) num++;
  155.                 searchin++;
  156.         }
  157.         return num;
  158. }
  159.  
  160.  
  161. inline fastcall signed int strstr( EBX, EDX)
  162. {
  163.   asm {
  164.     MOV EDI, EDX
  165.     XOR ECX, ECX
  166.     XOR EAX, EAX
  167.     DEC ECX
  168.     REPNE SCASB
  169.     NOT ECX
  170.     DEC ECX
  171.     JE LS2
  172.     MOV ESI, ECX
  173.     XOR ECX, ECX
  174.     MOV EDI, EBX
  175.     DEC ECX
  176.     REPNE SCASB
  177.     NOT ECX
  178.     SUB ECX, ESI
  179.     JBE LS2
  180.     MOV EDI, EBX
  181.     LEA EBX, DSDWORD[ ESI-1]
  182. LS1: MOV ESI, EDX
  183.     LODSB
  184.     REPNE SCASB
  185.     JNE LS2
  186.     MOV EAX, ECX
  187.     PUSH EDI
  188.     MOV ECX, EBX
  189.     REPE CMPSB
  190.     POP EDI
  191.     MOV ECX, EAX
  192.     JNE LS1
  193.     LEA EAX, DSDWORD[ EDI-1]
  194.     JMP SHORT LS3
  195. LS2: XOR EAX, EAX
  196. LS3:
  197.   }
  198. }
  199.  
  200.  
  201. dword strstri(dword searchin, usestr_s)
  202. {
  203.         dword usestr_e = usestr_s;
  204.         char si, ue;
  205.  
  206.         while(DSBYTE[searchin])
  207.         {
  208.                 si = DSBYTE[searchin];
  209.                 ue = DSBYTE[usestr_e];
  210.                 if (si>='A') && (si<='Z') si +=32;
  211.                 if (ue>='A') && (ue<='Z') ue +=32;
  212.                 if (si == ue) usestr_e++; else usestr_e = usestr_s;
  213.                 searchin++;
  214.                 if (DSBYTE[usestr_e]=='\0') return searchin;
  215.         }
  216.         return 0;
  217. }
  218.  
  219.  
  220. void strcpyb(dword search_in, copyin, startstr, endstr)
  221. {
  222.         dword startp, endp;
  223.         startp = strstr(search_in, startstr) + strlen(startstr);
  224.         endp = strstri(startp, endstr);
  225.         if (startp==endp) return;
  226.         do
  227.         {
  228.                 DSBYTE[copyin] = DSBYTE[startp];
  229.                 copyin++;
  230.                 startp++;
  231.         }
  232.         while (startp<endp);
  233.         DSBYTE[copyin] = '\0';
  234. }
  235.  
  236.  
  237. /*void strcat(char *to, char *from) //Єюцх ЁрсюЄрхЄ
  238. {
  239.         while(*to) to++;
  240.         while(*from)
  241.         {
  242.                 *to = *from;
  243.                 to++;
  244.                 from++;
  245.         }
  246.         *to = '\0';
  247. }*/
  248.  
  249. dword itoa( ESI)
  250. {
  251.         unsigned char buffer[11];
  252.         $pusha
  253.  
  254.         EDI = #buffer;
  255.         ECX = 10;
  256.         if (ESI < 0)
  257.         {
  258.                  $mov     al, '-'
  259.                  $stosb
  260.                  $neg     esi
  261.         }
  262.  
  263.         $mov     eax, esi
  264.         $push    -'0'
  265. F2:
  266.         $xor     edx, edx
  267.         $div     ecx
  268.         $push    edx
  269.         $test    eax, eax
  270.         $jnz     F2
  271. F3:
  272.         $pop     eax
  273.         $add     al, '0'
  274.         $stosb
  275.         $jnz     F3
  276.        
  277.         $mov     al, '\0'
  278.         $stosb
  279.  
  280.         $popa
  281.     return #buffer;
  282. }
  283.  
  284.  
  285. inline fastcall dword atoi( EDI)
  286. {
  287.         $push ebx
  288.         $push esi
  289.         ESI=EDI;
  290.         while (DSBYTE[ESI]==' ') ESI++;
  291.         if (DSBYTE[ESI]=='-') ESI++;
  292.         EAX=0;
  293.         while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
  294.         {
  295.                 $xor ebx, ebx
  296.                 EBX = DSBYTE[ESI]-'0';
  297.                 EAX *= 10;
  298.                 EAX += EBX;
  299.                 ESI++;
  300.         }
  301.         IF (DSBYTE[EDI]=='-') -EAX;
  302.         $pop esi
  303.         $pop ebx
  304. }
  305.  
  306.  
  307.  
  308. inline fastcall strupr( ESI)
  309. {
  310.         do{
  311.                 AL=DSBYTE[ESI];
  312.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  313.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //р-я
  314.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //р-я
  315.                 ESI++;
  316.         }while(AL!=0);
  317. }
  318.  
  319. inline fastcall strlwr( ESI)
  320. {
  321.         do{
  322.                 $LODSB
  323.                 IF(AL>='A')&&(AL<='Z'){
  324.                         AL+=0x20;
  325.                         DSBYTE[ESI-1]=AL;
  326.                         CONTINUE;
  327.                 }
  328.         }while(AL!=0);
  329. }
  330.  
  331. inline fastcall strttl( EDX)
  332. {
  333.         AL=DSBYTE[EDX];
  334.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  335.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //р-я
  336.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //р-я
  337.         do{
  338.                 EDX++;
  339.                 AL=DSBYTE[EDX];
  340.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  341.                 IF(AL>='А')&&(AL<='П')DSBYTE[EDX]=AL|0x20; //а-п
  342.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //р-я
  343.         }while(AL!=0);
  344. }
  345.  
  346. void debugi(dword d_int)
  347. {
  348.         char tmpch[11];
  349.         strcpy(#tmpch, itoa(d_int));
  350.         debug(#tmpch);
  351. }
  352.  
  353.  
  354. /* strtok( LPSTR dest, src, divs);
  355. src - єърчрЄхы№ эр шёїюфэє■ ёЄЁюъє шыш Ёхчєы№ЄрЄ яЁхф√фє∙хую т√чютр
  356. dest - єърчрЄхы№ эр сєЇхЁ, ъєфр сєфхЄ ёъюяшЁютрэю ёыютю
  357. divs - єърчрЄхы№ эр ёЄЁюъє, ёюфхЁцр∙є■ ёшьтюы√-ЁрчфхышЄхыш
  358. ┬ючтЁр∙рхЄ: 0, хёыш ёыют сюы№°х эхЄ
  359.          эх 0, хёыш ёыютю ёъюяшЁютрэю т dest (яхЁхфрщЄх ¤Єю чэрўхэшх
  360.                т ърўхёЄтх src фы  яюёыхфє■∙хую яюшёър) */
  361.  
  362. inline fastcall dword strtok( EDX, ESI, EBX)
  363. {
  364.   asm {
  365.     XOR ECX, ECX
  366.     MOV EDI, EBX
  367.     XOR EAX, EAX
  368.     DEC ECX
  369.     REPNE SCASB
  370.     XOR ECX, 0FFFFFFFFH
  371.     DEC ECX
  372.     PUSH ECX
  373. L1: LODSB
  374.     OR AL, AL
  375.     JZ L4
  376.     MOV EDI, EBX
  377.     MOV ECX, SSDWORD[ ESP]
  378.     REPNE SCASB
  379.     JZ L1
  380.     DEC ESI
  381. L2: LODSB
  382.     MOV EDI, EBX
  383.     MOV ECX, SSDWORD[ ESP]
  384.     REPNE SCASB
  385.     JZ L3
  386.     MOV DSBYTE[ EDX], AL
  387.     INC EDX
  388.     JMP SHORT L2
  389. L3: MOV EAX, ESI
  390. L4: POP ECX
  391.   } DSBYTE[ EDX] = 0;
  392. }
  393.  
  394. #define strncpy strcpyn
  395. #define strnmov strmovn
  396. #define stricmp strcmpi
  397. #define strcmpn strncmp
  398. #define strncmpi strcmpni
  399. #define stricmpn strcmpni
  400. #define strnicmp strcmpni
  401. #define strincmp strcmpni
  402. #define strcmpin strcmpni
  403.