Subversion Repositories Kolibri OS

Rev

Rev 4567 | Rev 5626 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. char a_libdir[43]  = "/sys/lib/\0";
  2.  
  3. :inline void error_init(dword text)
  4. {
  5.         dword l,ll;
  6.         dword TEXT_ERROR = malloc(1024);
  7.         #ifdef LANG_RUS
  8.                 strcpy(TEXT_ERROR,"'Žè¨¡ª  ¯à¨ § £à㧪¥ ¡¨¡«¨®â¥ª¨ `");
  9.         #elif LANG_EST
  10.                 strcpy(TEXT_ERROR,"'Viga teegi laadimisel `");
  11.         #else
  12.                 strcpy(TEXT_ERROR,"'Error while loading library `");
  13.         #endif
  14.         ll = strlen(TEXT_ERROR);
  15.         strcpy(TEXT_ERROR+ll,text);
  16.         l = strlen(text);
  17.         strncpy(TEXT_ERROR+ll+l,"`' -E",4);
  18.         notify(TEXT_ERROR);
  19.         free(TEXT_ERROR);
  20.         ExitProcess();
  21. }
  22.  
  23. // stdcall with 1 parameter
  24. void dll_Load() {
  25. asm {
  26.         push    ebp
  27.         mov     ebp, esp
  28.         mov     esi, SSDWORD[EBP+8]
  29.                 @next_lib:    
  30.         mov     edx, DSDWORD[ESI]
  31.         or      edx, edx
  32.         jz      exit
  33.         push    esi
  34.         mov     esi, DSDWORD[ESI+4]
  35.         mov     edi, #a_libdir+9
  36.  
  37. @loc01:
  38.         lodsb
  39.         stosb
  40.         or      al, al
  41.         jnz     loc01
  42.  
  43.         mov     eax, 68
  44.         mov     ebx, 19
  45.         mov     ecx, #a_libdir
  46.         int     0x40
  47.         or      eax, eax
  48.         jz      fail
  49.  
  50.         push    edx
  51.         push    eax
  52.         call    dll_Link
  53.  
  54.         push    eax
  55.         mov     eax, DSDWORD[eax]
  56.         cmp     DSDWORD[EAX], '_bil'    // somehow this needs to be reversed..
  57.         pop     eax
  58.         jnz     loc02
  59.  
  60.         push    DSDWORD[EAX+4]
  61.         call    dll_Init
  62. @loc02:
  63.  
  64.         pop     esi
  65.         add     esi, 8
  66.         jmp     next_lib
  67. @exit:
  68.         xor     eax, eax
  69.         leave
  70.         ret     4
  71.        
  72. @fail:        
  73.         add     esp, 4
  74.         xor     eax, eax
  75.         inc     eax
  76.         leave
  77.         ret     4
  78.     }
  79. }
  80.  
  81. //stdcall with 2 parameters
  82. void dll_Link() {
  83. asm {
  84.         push    ebp
  85.         mov     ebp, esp
  86.         push    eax
  87.         mov     esi, SSDWORD[EBP+12]
  88.         test    esi, esi
  89.         jz      done
  90. @next:        
  91.         lodsd
  92.         test    eax, eax
  93.         jz      done
  94.         push    eax
  95.         push    SSDWORD[EBP+8]
  96.         call    dll_GetProcAddress
  97.         or      eax, eax
  98.         jz      loc03
  99.         mov     DSDWORD[esi-4], eax
  100.         jmp     next
  101. @loc03:
  102.         mov     SSDWORD[esp], 0
  103. @done:
  104.         pop     eax
  105.         leave
  106.         ret     8
  107.     }
  108. }
  109.  
  110.  
  111. //stdcall with 1 parameter
  112. void dll_Init() {
  113. asm {
  114.         push    ebp
  115.         mov     ebp, esp
  116.         pushad
  117.         mov     eax, #mem_Alloc
  118.         mov     ebx, #mem_Free;
  119.         mov     ecx, #mem_ReAlloc;
  120.         mov     edx, #dll_Load;
  121.         call    SSDWORD[EBP+8]
  122.         popad
  123.         leave
  124.         ret     4
  125.     }
  126. }
  127.  
  128.  
  129. // stdcall with 2 parameters
  130. void dll_GetProcAddress(){
  131. asm {
  132.         push    ebp
  133.         mov     ebp, esp
  134.         mov     edx, CSDWORD[EBP+8]
  135.         xor     eax, eax
  136.  
  137. @next:        
  138.         or      edx, edx
  139.         jz      end
  140.         cmp     CSDWORD[edx], 0
  141.         jz      end
  142.  
  143.         push    CSDWORD[EBP+12]
  144.         push    CSDWORD[EDX]
  145.         call    dll_StrCmp
  146.         test    eax, eax
  147.         jz      ok
  148.         add     edx, 8
  149.         jmp     next
  150. @ok:
  151.         mov     eax, DSDWORD[EDX+4]
  152. @end:
  153.         leave
  154.         ret     8
  155.     }
  156. }
  157.  
  158.  
  159. // stdcall with 2 parameters
  160. void dll_StrCmp() {
  161. asm {
  162.         push    ebp
  163.         mov     ebp, esp
  164.         push    esi
  165.         push    edi
  166.         mov     esi, CSDWORD[EBP+8]
  167.         mov     edi, CSDWORD[EBP+12]
  168.         xor     eax, eax
  169. @label1:
  170.         lodsb
  171.         scasb
  172.         jne     fail
  173.         or      al, al
  174.         jnz     label1
  175.         jmp     label_ok
  176. @fail:
  177.         or      eax, -1
  178. @label_ok:
  179.         pop     edi
  180.         pop     esi
  181.         leave
  182.         ret     8
  183.     }
  184. }
  185.  
  186. int load_dll2(dword dllname, import_table, byte need_init)
  187. {
  188.    //dword dllentry=0;
  189. // load DLL
  190.         $mov     eax, 68
  191.         $mov     ebx, 19
  192.         ECX=dllname;
  193.         $int     0x40
  194.         $test    eax, eax
  195.         $jz      exit01
  196.  
  197. // initialize import
  198.         $mov     edx,eax
  199.         ESI=import_table;
  200.  
  201. @import_loop01:
  202.         $lodsd
  203.         $test    eax,eax
  204.         $jz      import_done01
  205.         $push    edx
  206. @import_find01:
  207.         $mov     ebx,DSDWORD[EDX]
  208.         $test    ebx, ebx
  209.         $jz      exit01
  210.         $push    eax
  211. @nex101:
  212.         $mov     cl,DSBYTE[EAX];
  213.         $cmp     cl,DSBYTE[EBX];
  214.         $jnz     import_find_next01
  215.         $test    cl,cl
  216.         $jz      import_found01
  217.         $inc     eax
  218.         $inc     ebx
  219.         $jmp     nex101
  220. @import_find_next01:
  221.         $pop     eax
  222.         $add     edx, 8
  223.         $jmp     import_find01
  224. @import_found01:
  225.         $pop     eax
  226.         $mov     eax,DSDWORD[edx+4]
  227.         $mov     DSDWORD[esi-4],eax
  228.         $pop     edx
  229.        
  230.         $jmp     import_loop01
  231. @import_done01:
  232.         IF (need_init) dll_Init (DSDWORD[EDX+4]);
  233.         return 0;
  234. @exit01:
  235.         return -1;
  236.                 //error_init(dllname);
  237. }