Subversion Repositories Kolibri OS

Rev

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