Subversion Repositories Kolibri OS

Rev

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