Subversion Repositories Kolibri OS

Rev

Rev 4180 | Rev 4550 | 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. dword strcmpi(dword cmp1, cmp2)
  218. {
  219.         char si, ue;
  220.  
  221.         loop()
  222.         {
  223.                 si = DSBYTE[cmp1];
  224.                 ue = DSBYTE[cmp2];
  225.                 if (si>='A') && (si<='Z') si +=32;
  226.                 if (ue>='A') && (ue<='Z') ue +=32;
  227.                 if (si != ue) return -1;
  228.                 cmp1++;
  229.                 cmp2++;
  230.                 if ((DSBYTE[cmp1]=='\0') && (DSBYTE[cmp2]=='\0')) return 0;
  231.                 if (DSBYTE[cmp1]=='\0') return -1;
  232.                 if (DSBYTE[cmp2]=='\0') return 1;
  233.         }
  234. }
  235.  
  236. dword strstri(dword searchin, usestr_s)
  237. {
  238.         dword usestr_e = usestr_s;
  239.         char si, ue;
  240.  
  241.         while(DSBYTE[searchin])
  242.         {
  243.                 si = DSBYTE[searchin];
  244.                 ue = DSBYTE[usestr_e];
  245.                 if (si>='A') && (si<='Z') si +=32;
  246.                 if (ue>='A') && (ue<='Z') ue +=32;
  247.                 if (si == ue) usestr_e++; else usestr_e = usestr_s;
  248.                 searchin++;
  249.                 if (DSBYTE[usestr_e]=='\0') return searchin;
  250.         }
  251.         return 0;
  252. }
  253.  
  254.  
  255. unsigned int strcpyb(dword search_in, copyin, startstr, endstr)
  256. {
  257.         dword startp, endp;
  258.         dword copyin_start_off = copyin;
  259.         if (startstr==0) startp = search_in; else startp = strstr(search_in, startstr) + strlen(startstr);
  260.         endp = strstri(startp, endstr);
  261.         if (endp==0) endp = startp+strlen(search_in);
  262.         //if (startp==endp) return 0;
  263.         do
  264.         {
  265.                 DSBYTE[copyin] = DSBYTE[startp];
  266.                 copyin++;
  267.                 startp++;
  268.         }
  269.         while (startp<endp);
  270.         DSBYTE[copyin] = '\0';
  271.         return copyin_start_off;
  272. }
  273.  
  274.  
  275. /*void strcat(char *to, char *from) //Єюцх ЁрсюЄрхЄ
  276. {
  277.         while(*to) to++;
  278.         while(*from)
  279.         {
  280.                 *to = *from;
  281.                 to++;
  282.                 from++;
  283.         }
  284.         *to = '\0';
  285. }*/
  286.  
  287.  
  288. inline fastcall dword atoi( EDI)
  289. {
  290.         $push ebx
  291.         $push esi
  292.         ESI=EDI;
  293.         while (DSBYTE[ESI]==' ') ESI++;
  294.         if (DSBYTE[ESI]=='-') ESI++;
  295.         EAX=0;
  296.         while (DSBYTE[ESI]>='0') && (DSBYTE[ESI]<='9')
  297.         {
  298.                 $xor ebx, ebx
  299.                 EBX = DSBYTE[ESI]-'0';
  300.                 EAX *= 10;
  301.                 EAX += EBX;
  302.                 ESI++;
  303.         }
  304.         IF (DSBYTE[EDI]=='-') -EAX;
  305.         $pop esi
  306.         $pop ebx
  307. }
  308.  
  309.  
  310.  
  311. inline fastcall strupr( ESI)
  312. {
  313.         do{
  314.                 AL=DSBYTE[ESI];
  315.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  316.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //р-я
  317.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //р-я
  318.                 ESI++;
  319.         }while(AL!=0);
  320. }
  321.  
  322. inline fastcall strlwr( ESI)
  323. {
  324.         do{
  325.                 $LODSB
  326.                 IF(AL>='A')&&(AL<='Z'){
  327.                         AL+=0x20;
  328.                         DSBYTE[ESI-1]=AL;
  329.                         CONTINUE;
  330.                 }
  331.         }while(AL!=0);
  332. }
  333.  
  334. inline fastcall strttl( EDX)
  335. {
  336.         AL=DSBYTE[EDX];
  337.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  338.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //р-я
  339.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //р-я
  340.         do{
  341.                 EDX++;
  342.                 AL=DSBYTE[EDX];
  343.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  344.                 IF(AL>='А')&&(AL<='П')DSBYTE[EDX]=AL|0x20; //а-п
  345.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //р-я
  346.         }while(AL!=0);
  347. }
  348.  
  349. unsigned char buffer[11];
  350. dword itoa( ESI)
  351. {
  352.         $pusha
  353.         EDI = #buffer;
  354.         ECX = 10;
  355.         if (ESI < 0)
  356.         {
  357.                  $mov     al, '-'
  358.                  $stosb
  359.                  $neg     esi
  360.         }
  361.  
  362.         $mov     eax, esi
  363.         $push    -'0'
  364. F2:
  365.         $xor     edx, edx
  366.         $div     ecx
  367.         $push    edx
  368.         $test    eax, eax
  369.         $jnz     F2
  370. F3:
  371.         $pop     eax
  372.         $add     al, '0'
  373.         $stosb
  374.         $jnz     F3
  375.        
  376.         $mov     al, '\0'
  377.         $stosb
  378.  
  379.         $popa
  380.     return #buffer;
  381. }
  382.  
  383. inline fastcall itoa_(signed int EDI, ESI)
  384. {
  385.         $pusha
  386.         EBX = EDI;
  387.         ECX = 10;
  388.         if (ESI > 90073741824)
  389.         {
  390.                  $mov     al, '-'
  391.                  $stosb
  392.                  $neg     esi
  393.         }
  394.  
  395.         $mov     eax, esi
  396.         $push    -'0'
  397. F2:
  398.         $xor     edx, edx
  399.         $div     ecx
  400.         $push    edx
  401.         $test    eax, eax
  402.         $jnz     F2
  403. F3:
  404.         $pop     eax
  405.         $add     al, '0'
  406.         $stosb
  407.         $jnz     F3
  408.        
  409.         $mov     al, '\0'
  410.         $stosb
  411.  
  412.         $popa
  413.     return EBX;
  414. }  
  415.  
  416. void debugi(dword d_int)
  417. {
  418.         char tmpch[12];
  419.         itoa_(#tmpch, d_int);
  420.         debug(#tmpch);
  421. }
  422.  
  423.  
  424.  
  425. #define strncpy strcpyn
  426. #define strnmov strmovn
  427. #define stricmp strcmpi
  428. #define strcmpn strncmp
  429.  
  430.