Subversion Repositories Kolibri OS

Rev

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