Subversion Repositories Kolibri OS

Rev

Rev 3067 | Rev 3107 | 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)
  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) ----- тючьюцэю эх яюффхЁцштрхЄ ъшЁшыышЎє
  13. // strttl( EDX)
  14. // strtok( ESI)
  15. //------------------------------------------------------------------------------
  16.  
  17. inline fastcall signed int strcmp( ESI, EDI)
  18. {
  19.         loop()
  20.         {
  21.                 IF (DSBYTE[ESI]<DSBYTE[EDI]) RETURN -1;
  22.                 IF (DSBYTE[ESI]>DSBYTE[EDI]) RETURN 1;
  23.                 IF (DSBYTE[ESI]=='\0') RETURN 0;
  24.                 ESI++;
  25.                 EDI++;
  26.         }
  27. }
  28.  
  29.  
  30. inline fastcall signed int strncmp( ESI, EDI, ECX)
  31. {
  32.   asm {
  33.     MOV EBX, EDI
  34.     XOR EAX, EAX
  35.     MOV EDX, ECX
  36.     OR ECX, ECX
  37.     JE L1
  38.     REPNE SCASB
  39.     SUB EDX, ECX
  40.     MOV ECX, EDX
  41.     MOV EDI, EBX
  42.     XOR EBX, EBX
  43.     REPE CMPSB
  44.     MOV AL, DSBYTE[ ESI-1]
  45.     MOV BL, DSBYTE[ EDI-1]
  46.     SUB EAX, EBX
  47. L1:
  48.   }
  49. }
  50.  
  51.  
  52.  
  53. /*
  54.  
  55. inline fastcall signed int strcmpi( ESI,EDI)
  56. uses EBX
  57. {
  58.         do{
  59.                 $lodsb
  60.                 IF(AL>='a')&&(AL<='z')AL-=0x20;
  61.                 BL=DSBYTE[(E)DI];
  62.                 IF(BL>='a')&&(BL<='z')BL-=0x20;
  63.                 AL-=BL;
  64.                 IF(!ZEROFLAG)BREAK;
  65.                 (E)DI++;
  66.         }while(BL!=0);
  67. }
  68.  
  69. inline char STRNCMPI((E)SI,(E)DI,(E)CX)
  70. {
  71.         (E)AX=0;
  72.         LOOPNZ((E)CX){
  73.                 $lodsb
  74.                 IF(AL>='a')&&(AL<='z')AL-=0x20;
  75.                 AH=DSBYTE[EDI];
  76.                 IF(AH>='a')&&(AH<='z')AH-=0x20;
  77.                 EDI++;
  78.                 IF(AL==0)||(AH==0)||(AL!=AH)BREAK;
  79.         }
  80.         AL=AL-AH;
  81. }*/
  82.  
  83.  
  84.  
  85. inline fastcall unsigned int strlen( EDI)
  86. {
  87.         $xor eax, eax
  88.         $mov ecx, -1
  89.         $REPNE $SCASB
  90.         EAX-=2+ECX;
  91. }
  92.  
  93.  
  94. inline fastcall strcpy( EDI, ESI)
  95. {
  96.         $cld
  97. l2:
  98.         $lodsb
  99.         $stosb
  100.         $test al,al
  101.         $jnz l2
  102. }
  103.  
  104.  
  105. inline fastcall 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. /*void strcat(char *to, char *from) //Єюцх ЁрсюЄрхЄ
  134. {
  135.         while(*to) to++;
  136.         while(*from)
  137.         {
  138.                 *to = *from;
  139.                 to++;
  140.                 from++;
  141.         }
  142.         *to = '\0';
  143. }*/
  144.  
  145. dword itoa( ESI)
  146. {
  147.         unsigned char buffer[11];
  148.         EDI = #buffer;
  149.         ECX = 10;
  150.         if (ESI < 0)
  151.         {
  152.                  $mov     al, '-'
  153.                  $stosb
  154.                  $neg     esi
  155.         }
  156.  
  157.         $mov     eax, esi
  158.         $push    -'0'
  159. f2:
  160.         $xor     edx, edx
  161.         $div     ecx
  162.         $push    edx
  163.         $test    eax, eax
  164.         $jnz     f2
  165. f3:
  166.         $pop     eax
  167.         $add     al, '0'
  168.         $stosb
  169.         $jnz     f3
  170.        
  171.         $mov     al, '\0'
  172.         $stosb
  173.          
  174.      return #buffer;
  175. }
  176.  
  177.  
  178.  
  179. inline fastcall dword atoi( EDI)
  180. {
  181.         ESI=EDI;
  182.         IF(DSBYTE[ESI]=='-')ESI++;
  183.         EAX=0;
  184.         BH=AL;
  185.         do{
  186.                 BL=DSBYTE[ESI]-'0';
  187.                 EAX=EAX*10+EBX;
  188.                 ESI++;
  189.         }while(DSBYTE[ESI]>0);
  190.         IF(DSBYTE[EDI]=='-') -EAX;
  191. }
  192.  
  193.  
  194. inline fastcall signed int strchr( ESI,BL)
  195. {
  196.         int jj=0;
  197.         do{
  198.                 jj++;
  199.                 $lodsb
  200.                 IF(AL==BL) return jj;
  201.         } while(AL!=0);
  202.         return 0;
  203. }
  204.  
  205.  
  206. inline fastcall signed int strrchr( ESI,BL)
  207. {
  208.         int jj=0, last=0;
  209.         do{
  210.                 jj++;
  211.                 $lodsb
  212.                 IF(AL==BL) last=jj;
  213.         } while(AL!=0);
  214.         return last;
  215. }
  216.  
  217.  
  218. inline fastcall strupr( ESI)
  219. {
  220.         do{
  221.                 AL=DSBYTE[ESI];
  222.                 IF(AL>='a')IF(AL<='z')DSBYTE[ESI]=AL&0x5f;
  223.                 IF (AL>=160) && (AL<=175) DSBYTE[ESI] = AL - 32;        //р-я
  224.                 IF (AL>=224) && (AL<=239) DSBYTE[ESI] = AL - 80;        //р-я
  225.                 ESI++;
  226.         }while(AL!=0);
  227. }
  228.  
  229. inline fastcall strlwr( ESI)
  230. {
  231.         do{
  232.                 $LODSB
  233.                 IF(AL>='A')&&(AL<='Z'){
  234.                         AL+=0x20;
  235.                         DSBYTE[ESI-1]=AL;
  236.                         CONTINUE;
  237.                 }
  238.         }while(AL!=0);
  239. }
  240.  
  241. inline fastcall strttl( EDX)
  242. {
  243.         AL=DSBYTE[EDX];
  244.         IF(AL>='a')&&(AL<='z')DSBYTE[EDX]=AL&0x5f;
  245.         IF (AL>=160) && (AL<=175) DSBYTE[EDX] = AL - 32;        //р-я
  246.         IF (AL>=224) && (AL<=239) DSBYTE[EDX] = AL - 80;        //р-я
  247.         do{
  248.                 EDX++;
  249.                 AL=DSBYTE[EDX];
  250.                 IF(AL>='A')&&(AL<='Z'){DSBYTE[EDX]=AL|0x20; CONTINUE;}
  251.                 IF(AL>='А')&&(AL<='П')DSBYTE[EDX]=AL|0x20; //а-п
  252.                 IF (AL>=144) && (AL<=159) DSBYTE[EDX] = AL + 80;        //р-я
  253.         }while(AL!=0);
  254. }
  255.  
  256.  
  257.  
  258. inline fastcall dword strstr( EBX, EDX)
  259. {
  260.   asm {
  261.     MOV EDI, EDX
  262.     XOR ECX, ECX
  263.     XOR EAX, EAX
  264.     DEC ECX
  265.     REPNE SCASB
  266.     NOT ECX
  267.     DEC ECX
  268.     JE LS2
  269.     MOV ESI, ECX
  270.     XOR ECX, ECX
  271.     MOV EDI, EBX
  272.     DEC ECX
  273.     REPNE SCASB
  274.     NOT ECX
  275.     SUB ECX, ESI
  276.     JBE LS2
  277.     MOV EDI, EBX
  278.     LEA EBX, DSDWORD[ ESI-1]
  279. LS1: MOV ESI, EDX
  280.     LODSB
  281.     REPNE SCASB
  282.     JNE LS2
  283.     MOV EAX, ECX
  284.     PUSH EDI
  285.     MOV ECX, EBX
  286.     REPE CMPSB
  287.     POP EDI
  288.     MOV ECX, EAX
  289.     JNE LS1
  290.     LEA EAX, DSDWORD[ EDI-1]
  291.     JMP SHORT LS3
  292. LS2: XOR EAX, EAX
  293. LS3:
  294.   }
  295. }
  296.  
  297.  
  298.  
  299.  
  300. /* strtok( LPSTR dest, src, divs);
  301. src - єърчрЄхы№ эр шёїюфэє■ ёЄЁюъє шыш Ёхчєы№ЄрЄ яЁхф√фє∙хую т√чютр
  302. dest - єърчрЄхы№ эр сєЇхЁ, ъєфр сєфхЄ ёъюяшЁютрэю ёыютю
  303. divs - єърчрЄхы№ эр ёЄЁюъє, ёюфхЁцр∙є■ ёшьтюы√-ЁрчфхышЄхыш
  304. ┬ючтЁр∙рхЄ: 0, хёыш ёыют сюы№°х эхЄ
  305.          эх 0, хёыш ёыютю ёъюяшЁютрэю т dest (яхЁхфрщЄх ¤Єю чэрўхэшх
  306.                т ърўхёЄтх src фы  яюёыхфє■∙хую яюшёър) */
  307.  
  308. inline fastcall dword strtok( EDX, ESI, EBX)
  309. {
  310.   asm {
  311.     XOR ECX, ECX
  312.     MOV EDI, EBX
  313.     XOR EAX, EAX
  314.     DEC ECX
  315.     REPNE SCASB
  316.     XOR ECX, 0FFFFFFFFH
  317.     DEC ECX
  318.     PUSH ECX
  319. L1: LODSB
  320.     OR AL, AL
  321.     JZ L4
  322.     MOV EDI, EBX
  323.     MOV ECX, SSDWORD[ ESP]
  324.     REPNE SCASB
  325.     JZ L1
  326.     DEC ESI
  327. L2: LODSB
  328.     MOV EDI, EBX
  329.     MOV ECX, SSDWORD[ ESP]
  330.     REPNE SCASB
  331.     JZ L3
  332.     MOV DSBYTE[ EDX], AL
  333.     INC EDX
  334.     JMP SHORT L2
  335. L3: MOV EAX, ESI
  336. L4: POP ECX
  337.   } DSBYTE[ EDX] = 0;
  338. }
  339.  
  340. #define strncpy strcpyn
  341. #define strnmov strmovn
  342. #define stricmp strcmpi
  343. #define strcmpn strncmp
  344. #define strncmpi strcmpni
  345. #define stricmpn strcmpni
  346. #define strnicmp strcmpni
  347. #define strincmp strcmpni
  348. #define strcmpin strcmpni
  349.