Subversion Repositories Kolibri OS

Rev

Rev 3363 | Rev 3448 | 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. // chrnum(dword searchin, char symbol)
  16. // strcpyb(dword searchin, copyin, startstr, endstr) --- copy string between strings
  17. // strnumb(dword searchin, startstr, endstr) --- get number between strings
  18. //------------------------------------------------------------------------------
  19.  
  20. inline fastcall signed int strcmp( ESI, EDI)
  21. {
  22.         loop()
  23.         {
  24.                 IF (DSBYTE[ESI]<DSBYTE[EDI]) RETURN -1;
  25.                 IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
  26.                 IF (DSBYTE[ESI]=='\0') RETURN 0;
  27.                 ESI++;
  28.                 EDI++;
  29.         }
  30. }
  31.  
  32.  
  33. inline fastcall signed int strncmp( ESI, EDI, ECX)
  34. {
  35.   asm {
  36.     MOV EBX, EDI
  37.     XOR EAX, EAX
  38.     MOV EDX, ECX
  39.     OR ECX, ECX
  40.     JE L1
  41.     REPNE SCASB
  42.     SUB EDX, ECX
  43.     MOV ECX, EDX
  44.     MOV EDI, EBX
  45.     XOR EBX, EBX
  46.     REPE CMPSB
  47.     MOV AL, DSBYTE[ ESI-1]
  48.     MOV BL, DSBYTE[ EDI-1]
  49.     SUB EAX, EBX
  50. L1:
  51.   }
  52. }
  53.  
  54.  
  55. inline fastcall unsigned int strlen( EDI)
  56. {
  57.         $xor eax, eax
  58.         $mov ecx, -1
  59.         $REPNE $SCASB
  60.         EAX-=2+ECX;
  61. }
  62.  
  63.  
  64. inline fastcall void strcpy( EDI, ESI)
  65. {
  66.         $cld
  67. L2:
  68.         $lodsb
  69.         $stosb
  70.         $test al,al
  71.         $jnz L2
  72. }
  73.  
  74.  
  75. inline fastcall int strlcpy(dword ESI, EDI, EBX)
  76. {
  77.         EDX=0;
  78.         do {
  79.                 DSBYTE[ESI]=DSBYTE[EDI];
  80.                 ESI++;
  81.                 EDI++;
  82.                 EDX++;
  83.                 if (EDX==EBX) { DSBYTE[ESI]='\0'; return -1;}
  84.         } while(DSBYTE[EDI-1]!='\0');
  85.         return 0;
  86. }
  87.  
  88.  
  89.  
  90. inline fastcall void strcat( EDI, ESI)
  91. {
  92.   asm {
  93.     mov ebx, edi
  94.     xor ecx, ecx
  95.     xor eax, eax
  96.     dec ecx
  97.     repne scasb
  98.     dec edi
  99.     mov edx, edi
  100.     mov edi, esi
  101.     xor ecx, ecx
  102.     xor eax, eax
  103.     dec ecx
  104.     repne scasb
  105.     xor ecx, 0ffffffffh
  106.     mov edi, edx
  107.     mov edx, ecx
  108.     mov eax, edi
  109.     shr ecx, 2
  110.     rep movsd
  111.     mov ecx, edx
  112.     and ecx, 3
  113.     rep movsb
  114.     mov eax, ebx
  115.         }
  116. }
  117.  
  118. inline fastcall void chrcat(ESI, BL)
  119. {
  120.         EDI = strlen(ESI);
  121.         ESBYTE[ESI+EDI] = BL;
  122.         ESBYTE[ESI+EDI+1] = 0;
  123. }
  124.  
  125.  
  126. inline fastcall signed int strchr( ESI,BL)
  127. {
  128.         int jj=0;
  129.         do{
  130.                 jj++;
  131.                 $lodsb
  132.                 IF(AL==BL) return jj;
  133.         } while(AL!=0);
  134.         return 0;
  135. }
  136.  
  137.  
  138. inline fastcall signed int strrchr( ESI,BL)
  139. {
  140.         int jj=0, last=0;
  141.         do{
  142.                 jj++;
  143.                 $lodsb
  144.                 IF(AL==BL) last=jj;
  145.         } while(AL!=0);
  146.         return last;
  147. }
  148.  
  149.  
  150. int chrnum(dword searchin, char symbol)
  151. {
  152.         int num = 0;
  153.         while(DSBYTE[searchin])
  154.         {
  155.                 if (DSBYTE[searchin] == symbol) num++;
  156.                 searchin++;
  157.         }
  158.         return num;
  159. }
  160.  
  161.  
  162. inline fastcall signed int strstr( EBX, EDX)
  163. {
  164.   asm {
  165.     MOV EDI, EDX
  166.     XOR ECX, ECX
  167.     XOR EAX, EAX
  168.     DEC ECX
  169.     REPNE SCASB
  170.     NOT ECX
  171.     DEC ECX
  172.     JE LS2
  173.     MOV ESI, ECX
  174.     XOR ECX, ECX
  175.     MOV EDI, EBX
  176.     DEC ECX
  177.     REPNE SCASB
  178.     NOT ECX
  179.     SUB ECX, ESI
  180.     JBE LS2
  181.     MOV EDI, EBX
  182.     LEA EBX, DSDWORD[ ESI-1]
  183. LS1: MOV ESI, EDX
  184.     LODSB
  185.     REPNE SCASB
  186.     JNE LS2
  187.     MOV EAX, ECX
  188.     PUSH EDI
  189.     MOV ECX, EBX
  190.     REPE CMPSB
  191.     POP EDI
  192.     MOV ECX, EAX
  193.     JNE LS1
  194.     LEA EAX, DSDWORD[ EDI-1]
  195.     JMP SHORT LS3
  196. LS2: XOR EAX, EAX
  197. LS3:
  198.   }
  199. }
  200.  
  201.  
  202. dword strstri(dword searchin, usestr_s)
  203. {
  204.         dword usestr_e = usestr_s;
  205.         char si, ue;
  206.  
  207.         while(DSBYTE[searchin])
  208.         {
  209.                 si = DSBYTE[searchin];
  210.                 ue = DSBYTE[usestr_e];
  211.                 if (si>='A') && (si<='Z') si +=32;
  212.                 if (ue>='A') && (ue<='Z') ue +=32;
  213.                 if (si == ue) usestr_e++; else usestr_e = usestr_s;
  214.                 searchin++;
  215.                 if (DSBYTE[usestr_e]=='\0') return searchin;
  216.         }
  217.         return 0;
  218. }
  219.  
  220.  
  221. void strcpyb(dword search_in, copyin, startstr, endstr)
  222. {
  223.         dword startp, endp;
  224.         startp = strstr(search_in, startstr) + strlen(startstr);
  225.         endp = strstri(startp, endstr);
  226.         if (startp==endp) return;
  227.         do
  228.         {
  229.                 DSBYTE[copyin] = DSBYTE[startp];
  230.                 copyin++;
  231.                 startp++;
  232.         }
  233.         while (startp<endp);
  234.         DSBYTE[copyin] = '\0';
  235. }
  236.  
  237.  
  238. /*void strcat(char *to, char *from) //òîæå ðàáîòàåò
  239. {
  240.         while(*to) to++;
  241.         while(*from)
  242.         {
  243.                 *to = *from;
  244.                 to++;
  245.                 from++;
  246.         }
  247.         *to = '\0';
  248. }*/
  249.  
  250. dword itoa( ESI)
  251. {
  252.         unsigned char buffer[11];
  253.         $pusha
  254.  
  255.         EDI = #buffer;
  256.         ECX = 10;
  257.         if (ESI < 0)
  258.         {
  259.                  $mov     al, '-'
  260.                  $stosb
  261.                  $neg     esi
  262.         }
  263.  
  264.         $mov     eax, esi
  265.         $push    -'0'
  266. F2:
  267.         $xor     edx, edx
  268.         $div     ecx
  269.         $push    edx
  270.         $test    eax, eax
  271.         $jnz     F2
  272. F3:
  273.         $pop     eax
  274.         $add     al, '0'
  275.         $stosb
  276.         $jnz     F3
  277.        
  278.         $mov     al, '\0'
  279.         $stosb
  280.  
  281.         $popa
  282.     return #buffer;
  283. }
  284.  
  285.  
  286. inline fastcall dword atoi( EDI)
  287. {
  288.         $push ebx
  289.         $push esi
  290.         ESI=EDI;
  291.         while (DSBYTE[ESI]==' ') ESI++;
  292.         if (DSBYTE[ESI]=='-') ESI++;
  293.         EAX=0;
  294.         while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
  295.         {
  296.                 $xor ebx, ebx
  297.                 EBX = DSBYTE[ESI]-'0';
  298.                 EAX *= 10;
  299.                 EAX += EBX;
  300.                 ESI++;
  301.         }
  302.         IF (DSBYTE[EDI]=='-') -EAX;
  303.         $pop esi
  304.         $pop ebx
  305. }
  306.  
  307.  
  308.  
  309. inline fastcall strupr( ESI)
  310. {
  311.         do{
  312.                 AL=DSBYTE[ESI];
  313.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  314.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //à-ï
  315.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //à-ï
  316.                 ESI++;
  317.         }while(AL!=0);
  318. }
  319.  
  320. inline fastcall strlwr( ESI)
  321. {
  322.         do{
  323.                 $LODSB
  324.                 IF(AL>='A')&&(AL<='Z'){
  325.                         AL+=0x20;
  326.                         DSBYTE[ESI-1]=AL;
  327.                         CONTINUE;
  328.                 }
  329.         }while(AL!=0);
  330. }
  331.  
  332. inline fastcall strttl( EDX)
  333. {
  334.         AL=DSBYTE[EDX];
  335.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  336.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //à-ï
  337.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //à-ï
  338.         do{
  339.                 EDX++;
  340.                 AL=DSBYTE[EDX];
  341.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  342.                 IF(AL>='€')&&(AL<='')DSBYTE[EDX]=AL|0x20; // -¯
  343.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //à-ï
  344.         }while(AL!=0);
  345. }
  346.  
  347. void debugi(dword d_int)
  348. {
  349.         char tmpch[11];
  350.         strcpy(#tmpch, itoa(d_int));
  351.         debug(#tmpch);
  352. }
  353.  
  354.  
  355. /* strtok( LPSTR dest, src, divs);
  356. src - óêàçàòåëü íà èñõîäíóþ ñòðîêó èëè ðåçóëüòàò ïðåäûäóùåãî âûçîâà
  357. dest - óêàçàòåëü íà áóôåð, êóäà áóäåò ñêîïèðîâàíî ñëîâî
  358. divs - óêàçàòåëü íà ñòðîêó, ñîäåðæàùóþ ñèìâîëû-ðàçäåëèòåëè
  359. Âîçâðàùàåò: 0, åñëè ñëîâ áîëüøå íåò
  360.          íå 0, åñëè ñëîâî ñêîïèðîâàíî â dest (ïåðåäàéòå ýòî çíà÷åíèå
  361.                â êà÷åñòâå src äëÿ ïîñëåäóþùåãî ïîèñêà) */
  362.  
  363. inline fastcall dword strtok( EDX, ESI, EBX)
  364. {
  365.   asm {
  366.     XOR ECX, ECX
  367.     MOV EDI, EBX
  368.     XOR EAX, EAX
  369.     DEC ECX
  370.     REPNE SCASB
  371.     XOR ECX, 0FFFFFFFFH
  372.     DEC ECX
  373.     PUSH ECX
  374. L1: LODSB
  375.     OR AL, AL
  376.     JZ L4
  377.     MOV EDI, EBX
  378.     MOV ECX, SSDWORD[ ESP]
  379.     REPNE SCASB
  380.     JZ L1
  381.     DEC ESI
  382. L2: LODSB
  383.     MOV EDI, EBX
  384.     MOV ECX, SSDWORD[ ESP]
  385.     REPNE SCASB
  386.     JZ L3
  387.     MOV DSBYTE[ EDX], AL
  388.     INC EDX
  389.     JMP SHORT L2
  390. L3: MOV EAX, ESI
  391. L4: POP ECX
  392.   } DSBYTE[ EDX] = 0;
  393. }
  394.  
  395. #define strncpy strcpyn
  396. #define strnmov strmovn
  397. #define stricmp strcmpi
  398. #define strcmpn strncmp
  399. #define strncmpi strcmpni
  400. #define stricmpn strcmpni
  401. #define strnicmp strcmpni
  402. #define strincmp strcmpni
  403. #define strcmpin strcmpni
  404.