Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. :dword strcmp(dword str1,str2)
  2. {
  3.         LOOPCMP:
  4.         IF(DSBYTE[str1]!=DSBYTE[str2]) RETURN DSBYTE[str1]-DSBYTE[str2];
  5.         IF(!DSBYTE[str1]) RETURN DSBYTE[str1]-DSBYTE[str2];
  6.         IF(!DSBYTE[str2]) RETURN DSBYTE[str1]-DSBYTE[str2];
  7.         str1++;
  8.         str2++;
  9.         GOTO LOOPCMP;
  10. }
  11. /*
  12. void dll_Load() {
  13. asm {
  14.         push    ebp
  15.         mov     ebp, esp
  16.         mov     esi, SSDWORD[EBP+8]
  17.                 @next_lib:    
  18.         mov     edx, DSDWORD[ESI]
  19.         or      edx, edx
  20.         jz      exit
  21.         push    esi
  22.         mov     esi, DSDWORD[ESI+4]
  23.         mov     edi, #libPath
  24.                 add edi,9
  25.  
  26. @loc01:
  27.         lodsb
  28.         stosb
  29.         or      al, al
  30.         jnz     loc01
  31.  
  32.         mov     eax, 68
  33.         mov     ebx, 19
  34.         mov     ecx, #libPath
  35.         int     0x40
  36.         or      eax, eax
  37.         jz      fail
  38.  
  39.         push    edx
  40.         push    eax
  41.         call    dll_Link
  42.  
  43.         push    eax
  44.         mov     eax, DSDWORD[eax]
  45.         cmp     DSDWORD[EAX], '_bil'    // somehow this needs to be reversed..
  46.         pop     eax
  47.         jnz     loc02
  48.  
  49.         push    DSDWORD[EAX+4]
  50.         call    dll_Init
  51. @loc02:
  52.  
  53.         pop     esi
  54.         add     esi, 8
  55.         jmp     next_lib
  56. @exit:
  57.         xor     eax, eax
  58.         leave
  59.         ret     4
  60.        
  61. @fail:        
  62.         add     esp, 4
  63.         xor     eax, eax
  64.         inc     eax
  65.         leave
  66.         ret     4
  67.     }
  68. }
  69. void dll_GetProcAddress(){
  70. asm {
  71.         push    ebp
  72.         mov     ebp, esp
  73.         mov     edx, CSDWORD[EBP+8]
  74.         xor     eax, eax
  75.  
  76. @next:        
  77.         or      edx, edx
  78.         jz      end
  79.         cmp     CSDWORD[edx], 0
  80.         jz      end
  81.  
  82.         push    CSDWORD[EBP+12]
  83.         push    CSDWORD[EDX]
  84.         call    dll_StrCmp
  85.         test    eax, eax
  86.         jz      ok
  87.         add     edx, 8
  88.         jmp     next
  89. @ok:
  90.         mov     eax, DSDWORD[EDX+4]
  91. @end:
  92.         leave
  93.         ret     8
  94.     }
  95. }
  96. void dll_StrCmp() {
  97. asm {
  98.         push    ebp
  99.         mov     ebp, esp
  100.         push    esi
  101.         push    edi
  102.         mov     esi, CSDWORD[EBP+8]
  103.         mov     edi, CSDWORD[EBP+12]
  104.         xor     eax, eax
  105. @label1:
  106.         lodsb
  107.         scasb
  108.         jne     fail
  109.         or      al, al
  110.         jnz     label1
  111.         jmp     label_ok
  112. @fail:
  113.         or      eax, -1
  114. @label_ok:
  115.         pop     edi
  116.         pop     esi
  117.         leave
  118.         ret     8
  119.     }
  120. }
  121. void dll_Link() {
  122. asm {
  123.         push    ebp
  124.         mov     ebp, esp
  125.         push    eax
  126.         mov     esi, SSDWORD[EBP+12]
  127.         test    esi, esi
  128.         jz      done
  129. @next:        
  130.         lodsd
  131.         test    eax, eax
  132.         jz      done
  133.         push    eax
  134.         push    SSDWORD[EBP+8]
  135.         call    dll_GetProcAddress
  136.         or      eax, eax
  137.         jz      loc03
  138.         mov     DSDWORD[esi-4], eax
  139.         jmp     next
  140. @loc03:
  141.         mov     SSDWORD[esp], 0
  142. @done:
  143.         pop     eax
  144.         leave
  145.         ret     8
  146.     }
  147. }
  148. void dll_Init() {
  149. asm {
  150.         push    ebp
  151.         mov     ebp, esp
  152.         pushad
  153.         mov     eax, #malloc
  154.         mov     ebx, #free;
  155.         mov     ecx, #realloc;
  156.         mov     edx, #dll_Load;
  157.         call    SSDWORD[EBP+8]
  158.         popad
  159.         leave
  160.         ret     4
  161.     }
  162. }
  163. */
  164. :dword importLibrary(dword name)
  165. {
  166.         dword l = 0;
  167.         dword i = 0;
  168.         dword list = 0;
  169.         dword key = 0;
  170.         dword data = 0;
  171.        
  172.         dword ret = 0;
  173.        
  174.         i = malloc(1000);
  175.         l = strcpy(TEMP,#libPath);
  176.         l += strcpy(TEMP+l,name);
  177.         memcpy(TEMP+l,".obj",5);
  178.        
  179.         EAX = 68;
  180.         EBX = 19;
  181.         ECX = TEMP;
  182.         $int 0x40;
  183.        
  184.         list = EAX;
  185.        
  186.         while(DSDWORD[list])
  187.         {
  188.                 test2(DSDWORD[list],0);
  189.                 IF(!strcmp(DSDWORD[list],"con_init"))
  190.                 {
  191.                         //dll_Init(DSDWORD[list+4]);
  192.                 }
  193.                 ELSE dictSet(ret,DSDWORD[list],DSDWORD[list+4]);
  194.                 list+=8;
  195.         }
  196.         EAX = DSDWORD[i+92];
  197.         i = malloc(10);
  198.         strcpy(i,"test");
  199.         i = realloc(i,19);
  200.         test1(i,0);
  201. }