Subversion Repositories Kolibri OS

Rev

Rev 4692 | Rev 5574 | 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.  
  350. dword itoa( ESI)
  351. {
  352.     unsigned char buffer[11];
  353.         $pusha
  354.         EDI = #buffer;
  355.         ECX = 10;
  356.         if (ESI < 0)
  357.         {
  358.                  $mov     al, '-'
  359.                  $stosb
  360.                  $neg     esi
  361.         }
  362.  
  363.         $mov     eax, esi
  364.         $push    -'0'
  365. F2:
  366.         $xor     edx, edx
  367.         $div     ecx
  368.         $push    edx
  369.         $test    eax, eax
  370.         $jnz     F2
  371. F3:
  372.         $pop     eax
  373.         $add     al, '0'
  374.         $stosb
  375.         $jnz     F3
  376.        
  377.         $mov     al, '\0'
  378.         $stosb
  379.  
  380.         $popa
  381.     return #buffer;
  382. }
  383.  
  384. inline fastcall itoa_(signed int EDI, ESI)
  385. {
  386.         $pusha
  387.         EBX = EDI;
  388.         ECX = 10;
  389.         if (ESI > 90073741824)
  390.         {
  391.                  $mov     al, '-'
  392.                  $stosb
  393.                  $neg     esi
  394.         }
  395.  
  396.         $mov     eax, esi
  397.         $push    -'0'
  398. F2:
  399.         $xor     edx, edx
  400.         $div     ecx
  401.         $push    edx
  402.         $test    eax, eax
  403.         $jnz     F2
  404. F3:
  405.         $pop     eax
  406.         $add     al, '0'
  407.         $stosb
  408.         $jnz     F3
  409.        
  410.         $mov     al, '\0'
  411.         $stosb
  412.  
  413.         $popa
  414.     return EBX;
  415. }  
  416.  
  417. void debugi(dword d_int)
  418. {
  419.         char tmpch[12];
  420.         itoa_(#tmpch, d_int);
  421.         debugln(#tmpch);
  422. }
  423.  
  424.  
  425. #define strncpy strcpyn
  426. #define strnmov strmovn
  427. #define stricmp strcmpi
  428. #define strcmpn strncmp
  429.  
  430.