Subversion Repositories Kolibri OS

Rev

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

  1. (*
  2.     BSD 2-Clause License
  3.  
  4.     Copyright (c) 2018, 2019, Anton Krotov
  5.     All rights reserved.
  6. *)
  7.  
  8. MODULE KOSAPI;
  9.  
  10. IMPORT SYSTEM;
  11.  
  12.  
  13. TYPE
  14.  
  15.     STRING = ARRAY 1024 OF CHAR;
  16.  
  17.  
  18. VAR
  19.  
  20.     DLL_INIT: PROCEDURE [stdcall] (entry: INTEGER);
  21.  
  22.     imp_error*: RECORD
  23.  
  24.         proc*, lib*: STRING;
  25.         error*: INTEGER
  26.  
  27.     END;
  28.  
  29.  
  30. PROCEDURE [stdcall-] sysfunc1* (arg1: INTEGER): INTEGER;
  31. BEGIN
  32.     SYSTEM.CODE(
  33.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp + 8]   *)
  34.     0CDH, 040H,         (*  int     64                     *)
  35.     0C9H,               (*  leave                          *)
  36.     0C2H, 004H, 000H    (*  ret     4                      *)
  37.     )
  38.     RETURN 0
  39. END sysfunc1;
  40.  
  41.  
  42. PROCEDURE [stdcall-] sysfunc2* (arg1, arg2: INTEGER): INTEGER;
  43. BEGIN
  44.     SYSTEM.CODE(
  45.     053H,               (*  push    ebx                    *)
  46.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  47.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  48.     0CDH, 040H,         (*  int     64                     *)
  49.     05BH,               (*  pop     ebx                    *)
  50.     0C9H,               (*  leave                          *)
  51.     0C2H, 008H, 000H    (*  ret     8                      *)
  52.     )
  53.     RETURN 0
  54. END sysfunc2;
  55.  
  56.  
  57. PROCEDURE [stdcall-] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;
  58. BEGIN
  59.     SYSTEM.CODE(
  60.     053H,               (*  push    ebx                    *)
  61.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  62.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  63.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  64.     0CDH, 040H,         (*  int     64                     *)
  65.     05BH,               (*  pop     ebx                    *)
  66.     0C9H,               (*  leave                          *)
  67.     0C2H, 00CH, 000H    (*  ret     12                     *)
  68.     )
  69.     RETURN 0
  70. END sysfunc3;
  71.  
  72.  
  73. PROCEDURE [stdcall-] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER;
  74. BEGIN
  75.     SYSTEM.CODE(
  76.     053H,               (*  push    ebx                    *)
  77.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  78.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  79.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  80.     08BH, 055H, 014H,   (*  mov     edx, dword [ebp + 20]  *)
  81.     0CDH, 040H,         (*  int     64                     *)
  82.     05BH,               (*  pop     ebx                    *)
  83.     0C9H,               (*  leave                          *)
  84.     0C2H, 010H, 000H    (*  ret     16                     *)
  85.     )
  86.     RETURN 0
  87. END sysfunc4;
  88.  
  89.  
  90. PROCEDURE [stdcall-] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER;
  91. BEGIN
  92.     SYSTEM.CODE(
  93.     053H,               (*  push    ebx                    *)
  94.     056H,               (*  push    esi                    *)
  95.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  96.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  97.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  98.     08BH, 055H, 014H,   (*  mov     edx, dword [ebp + 20]  *)
  99.     08BH, 075H, 018H,   (*  mov     esi, dword [ebp + 24]  *)
  100.     0CDH, 040H,         (*  int     64                     *)
  101.     05EH,               (*  pop     esi                    *)
  102.     05BH,               (*  pop     ebx                    *)
  103.     0C9H,               (*  leave                          *)
  104.     0C2H, 014H, 000H    (*  ret     20                     *)
  105.     )
  106.     RETURN 0
  107. END sysfunc5;
  108.  
  109.  
  110. PROCEDURE [stdcall-] sysfunc6* (arg1, arg2, arg3, arg4, arg5, arg6: INTEGER): INTEGER;
  111. BEGIN
  112.     SYSTEM.CODE(
  113.     053H,               (*  push    ebx                    *)
  114.     056H,               (*  push    esi                    *)
  115.     057H,               (*  push    edi                    *)
  116.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  117.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  118.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  119.     08BH, 055H, 014H,   (*  mov     edx, dword [ebp + 20]  *)
  120.     08BH, 075H, 018H,   (*  mov     esi, dword [ebp + 24]  *)
  121.     08BH, 07DH, 01CH,   (*  mov     edi, dword [ebp + 28]  *)
  122.     0CDH, 040H,         (*  int     64                     *)
  123.     05FH,               (*  pop     edi                    *)
  124.     05EH,               (*  pop     esi                    *)
  125.     05BH,               (*  pop     ebx                    *)
  126.     0C9H,               (*  leave                          *)
  127.     0C2H, 018H, 000H    (*  ret     24                     *)
  128.     )
  129.     RETURN 0
  130. END sysfunc6;
  131.  
  132.  
  133. PROCEDURE [stdcall-] sysfunc7* (arg1, arg2, arg3, arg4, arg5, arg6, arg7: INTEGER): INTEGER;
  134. BEGIN
  135.     SYSTEM.CODE(
  136.     053H,               (*  push    ebx                    *)
  137.     056H,               (*  push    esi                    *)
  138.     057H,               (*  push    edi                    *)
  139.     055H,               (*  push    ebp                    *)
  140.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  141.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  142.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  143.     08BH, 055H, 014H,   (*  mov     edx, dword [ebp + 20]  *)
  144.     08BH, 075H, 018H,   (*  mov     esi, dword [ebp + 24]  *)
  145.     08BH, 07DH, 01CH,   (*  mov     edi, dword [ebp + 28]  *)
  146.     08BH, 06DH, 020H,   (*  mov     ebp, dword [ebp + 32]  *)
  147.     0CDH, 040H,         (*  int     64                     *)
  148.     05DH,               (*  pop     ebp                    *)
  149.     05FH,               (*  pop     edi                    *)
  150.     05EH,               (*  pop     esi                    *)
  151.     05BH,               (*  pop     ebx                    *)
  152.     0C9H,               (*  leave                          *)
  153.     0C2H, 01CH, 000H    (*  ret     28                     *)
  154.     )
  155.     RETURN 0
  156. END sysfunc7;
  157.  
  158.  
  159. PROCEDURE [stdcall-] sysfunc22* (arg1, arg2: INTEGER; VAR res2: INTEGER): INTEGER;
  160. BEGIN
  161.     SYSTEM.CODE(
  162.     053H,               (*  push    ebx                    *)
  163.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  164.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  165.     0CDH, 040H,         (*  int     64                     *)
  166.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  167.     089H, 019H,         (*  mov     dword [ecx], ebx       *)
  168.     05BH,               (*  pop     ebx                    *)
  169.     0C9H,               (*  leave                          *)
  170.     0C2H, 00CH, 000H    (*  ret     12                     *)
  171.     )
  172.     RETURN 0
  173. END sysfunc22;
  174.  
  175.  
  176. PROCEDURE mem_commit (adr, size: INTEGER);
  177. VAR
  178.     tmp: INTEGER;
  179.  
  180. BEGIN
  181.     FOR tmp := adr TO adr + size - 1 BY 4096 DO
  182.         SYSTEM.PUT(tmp, 0)
  183.     END
  184. END mem_commit;
  185.  
  186.  
  187. PROCEDURE [stdcall] malloc* (size: INTEGER): INTEGER;
  188. VAR
  189.     ptr: INTEGER;
  190.  
  191. BEGIN
  192.     SYSTEM.CODE(060H); (* pusha *)
  193.     IF sysfunc2(18, 16) > ASR(size, 10) THEN
  194.         ptr := sysfunc3(68, 12, size);
  195.         IF ptr # 0 THEN
  196.             mem_commit(ptr, size)
  197.         END
  198.     ELSE
  199.         ptr := 0
  200.     END;
  201.     SYSTEM.CODE(061H)  (* popa  *)
  202.     RETURN ptr
  203. END malloc;
  204.  
  205.  
  206. PROCEDURE [stdcall] free* (ptr: INTEGER): INTEGER;
  207. BEGIN
  208.     SYSTEM.CODE(060H); (* pusha *)
  209.     IF ptr # 0 THEN
  210.         ptr := sysfunc3(68, 13, ptr)
  211.     END;
  212.     SYSTEM.CODE(061H)  (* popa  *)
  213.     RETURN 0
  214. END free;
  215.  
  216.  
  217. PROCEDURE [stdcall] realloc* (ptr, size: INTEGER): INTEGER;
  218. BEGIN
  219.     SYSTEM.CODE(060H); (* pusha *)
  220.     ptr := sysfunc4(68, 20, size, ptr);
  221.     SYSTEM.CODE(061H)  (* popa  *)
  222.     RETURN ptr
  223. END realloc;
  224.  
  225.  
  226. PROCEDURE AppAdr (): INTEGER;
  227. VAR
  228.     buf: ARRAY 1024 OF CHAR;
  229.     a: INTEGER;
  230.  
  231. BEGIN
  232.     a := sysfunc3(9, SYSTEM.ADR(buf), -1);
  233.     SYSTEM.GET(SYSTEM.ADR(buf) + 22, a)
  234.     RETURN a
  235. END AppAdr;
  236.  
  237.  
  238. PROCEDURE GetCommandLine* (): INTEGER;
  239. VAR
  240.     param: INTEGER;
  241.  
  242. BEGIN
  243.     SYSTEM.GET(28 + AppAdr(), param)
  244.     RETURN param
  245. END GetCommandLine;
  246.  
  247.  
  248. PROCEDURE GetName* (): INTEGER;
  249. VAR
  250.     name: INTEGER;
  251.  
  252. BEGIN
  253.     SYSTEM.GET(32 + AppAdr(), name)
  254.     RETURN name
  255. END GetName;
  256.  
  257.  
  258. PROCEDURE [stdcall] dll_init2 (arg1, arg2, arg3, arg4, arg5: INTEGER);
  259. BEGIN
  260.     SYSTEM.CODE(
  261.     060H,               (*  pusha                          *)
  262.     08BH, 045H, 008H,   (*  mov     eax, dword [ebp +  8]  *)
  263.     08BH, 05DH, 00CH,   (*  mov     ebx, dword [ebp + 12]  *)
  264.     08BH, 04DH, 010H,   (*  mov     ecx, dword [ebp + 16]  *)
  265.     08BH, 055H, 014H,   (*  mov     edx, dword [ebp + 20]  *)
  266.     08BH, 075H, 018H,   (*  mov     esi, dword [ebp + 24]  *)
  267.     0FFH, 0D6H,         (*  call    esi                    *)
  268.     061H,               (*  popa                           *)
  269.     0C9H,               (*  leave                          *)
  270.     0C2H, 014H, 000H    (*  ret     20                     *)
  271.     )
  272. END dll_init2;
  273.  
  274.  
  275. PROCEDURE GetProcAdr* (name: ARRAY OF CHAR; lib: INTEGER): INTEGER;
  276. VAR
  277.     cur, procname, adr: INTEGER;
  278.  
  279.  
  280.     PROCEDURE streq (str1, str2: INTEGER): BOOLEAN;
  281.     VAR
  282.         c1, c2: CHAR;
  283.  
  284.     BEGIN
  285.         REPEAT
  286.             SYSTEM.GET(str1, c1);
  287.             SYSTEM.GET(str2, c2);
  288.             INC(str1);
  289.             INC(str2)
  290.         UNTIL (c1 # c2) OR (c1 = 0X)
  291.  
  292.         RETURN c1 = c2
  293.     END streq;
  294.  
  295.  
  296. BEGIN
  297.     adr := 0;
  298.     IF (lib # 0) & (name # "") THEN
  299.         cur := lib;
  300.         REPEAT
  301.             SYSTEM.GET(cur, procname);
  302.             INC(cur, 8)
  303.         UNTIL (procname = 0) OR streq(procname, SYSTEM.ADR(name[0]));
  304.         IF procname # 0 THEN
  305.             SYSTEM.GET(cur - 4, adr)
  306.         END
  307.     END
  308.  
  309.     RETURN adr
  310. END GetProcAdr;
  311.  
  312.  
  313. PROCEDURE init (dll: INTEGER);
  314. VAR
  315.     lib_init: INTEGER;
  316.  
  317. BEGIN
  318.     lib_init := GetProcAdr("lib_init", dll);
  319.     IF lib_init # 0 THEN
  320.         DLL_INIT(lib_init)
  321.     END;
  322.     lib_init := GetProcAdr("START", dll);
  323.     IF lib_init # 0 THEN
  324.         DLL_INIT(lib_init)
  325.     END
  326. END init;
  327.  
  328.  
  329. PROCEDURE GetStr (adr, i: INTEGER; VAR str: STRING);
  330. VAR
  331.     c: CHAR;
  332. BEGIN
  333.     REPEAT
  334.         SYSTEM.GET(adr, c); INC(adr);
  335.         str[i] := c; INC(i)
  336.     UNTIL c = 0X
  337. END GetStr;
  338.  
  339.  
  340. PROCEDURE [stdcall] dll_Load* (import_table: INTEGER): INTEGER;
  341. VAR
  342.     imp, lib, exp, proc, res: INTEGER;
  343.     fail, done: BOOLEAN;
  344.     procname, libname: STRING;
  345.  
  346. BEGIN
  347.     SYSTEM.CODE(060H); (* pusha *)
  348.     fail := FALSE;
  349.     done := FALSE;
  350.     res := 0;
  351.     libname := "/rd/1/lib/";
  352.     REPEAT
  353.         SYSTEM.GET(import_table, imp);
  354.         IF imp # 0 THEN
  355.             SYSTEM.GET(import_table + 4, lib);
  356.             GetStr(lib, 10, libname);
  357.             exp := sysfunc3(68, 19, SYSTEM.ADR(libname[0]));
  358.             fail := exp = 0;
  359.         ELSE
  360.             done := TRUE
  361.         END;
  362.         IF fail THEN
  363.             done := TRUE;
  364.             imp_error.proc := "";
  365.             imp_error.lib  := libname;
  366.             imp_error.error := 1
  367.         END;
  368.         IF (imp # 0) & ~fail THEN
  369.             REPEAT
  370.                 SYSTEM.GET(imp, proc);
  371.                 IF proc # 0 THEN
  372.                     GetStr(proc, 0, procname);
  373.                     proc := GetProcAdr(procname, exp);
  374.                     IF proc # 0 THEN
  375.                         SYSTEM.PUT(imp, proc);
  376.                         INC(imp, 4)
  377.                     ELSE
  378.                         imp_error.proc  := procname;
  379.                         imp_error.lib   := libname;
  380.                         imp_error.error := 2
  381.                     END
  382.                 END
  383.             UNTIL proc = 0;
  384.             init(exp);
  385.             INC(import_table, 8)
  386.         END
  387.     UNTIL done;
  388.     IF fail THEN
  389.         res := 1
  390.     END;
  391.     import_table := res;
  392.     SYSTEM.CODE(061H) (* popa *)
  393.     RETURN import_table
  394. END dll_Load;
  395.  
  396.  
  397. PROCEDURE [stdcall] dll_Init (entry: INTEGER);
  398. BEGIN
  399.     SYSTEM.CODE(060H); (* pusha *)
  400.     IF entry # 0 THEN
  401.         dll_init2(SYSTEM.ADR(malloc), SYSTEM.ADR(free), SYSTEM.ADR(realloc), SYSTEM.ADR(dll_Load), entry)
  402.     END;
  403.     SYSTEM.CODE(061H); (* popa  *)
  404. END dll_Init;
  405.  
  406.  
  407. PROCEDURE LoadLib* (name: ARRAY OF CHAR): INTEGER;
  408. VAR
  409.     Lib: INTEGER;
  410.  
  411. BEGIN
  412.     DLL_INIT := dll_Init;
  413.     Lib := sysfunc3(68, 19, SYSTEM.ADR(name[0]));
  414.     IF Lib # 0 THEN
  415.         init(Lib)
  416.     END
  417.     RETURN Lib
  418. END LoadLib;
  419.  
  420.  
  421. PROCEDURE _init*;
  422. BEGIN
  423.     DLL_INIT := dll_Init;
  424.     imp_error.lib   := "";
  425.     imp_error.proc  := "";
  426.     imp_error.error := 0
  427. END _init;
  428.  
  429.  
  430. END KOSAPI.