Subversion Repositories Kolibri OS

Rev

Rev 7597 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
7696 akron1 1
(*
7597 akron1 2
    BSD 2-Clause License
6613 leency 3
 
7696 akron1 4
    Copyright (c) 2018-2019, Anton Krotov
7597 akron1 5
    All rights reserved.
6613 leency 6
*)
7
 
8
MODULE KOSAPI;
9
 
7597 akron1 10
IMPORT SYSTEM;
6613 leency 11
 
12
 
7597 akron1 13
TYPE
6613 leency 14
 
7597 akron1 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;
6613 leency 31
BEGIN
7597 akron1 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
6613 leency 39
END sysfunc1;
40
 
7597 akron1 41
 
42
PROCEDURE [stdcall-] sysfunc2* (arg1, arg2: INTEGER): INTEGER;
6613 leency 43
BEGIN
7597 akron1 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
6613 leency 54
END sysfunc2;
55
 
7597 akron1 56
 
57
PROCEDURE [stdcall-] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;
6613 leency 58
BEGIN
7597 akron1 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
6613 leency 70
END sysfunc3;
71
 
7597 akron1 72
 
73
PROCEDURE [stdcall-] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER;
6613 leency 74
BEGIN
7597 akron1 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
6613 leency 87
END sysfunc4;
88
 
7597 akron1 89
 
90
PROCEDURE [stdcall-] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER;
6613 leency 91
BEGIN
7597 akron1 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
6613 leency 107
END sysfunc5;
108
 
7597 akron1 109
 
110
PROCEDURE [stdcall-] sysfunc6* (arg1, arg2, arg3, arg4, arg5, arg6: INTEGER): INTEGER;
6613 leency 111
BEGIN
7597 akron1 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
6613 leency 130
END sysfunc6;
131
 
7597 akron1 132
 
133
PROCEDURE [stdcall-] sysfunc7* (arg1, arg2, arg3, arg4, arg5, arg6, arg7: INTEGER): INTEGER;
6613 leency 134
BEGIN
7597 akron1 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
6613 leency 156
END sysfunc7;
157
 
7597 akron1 158
 
159
PROCEDURE [stdcall-] sysfunc22* (arg1, arg2: INTEGER; VAR res2: INTEGER): INTEGER;
6613 leency 160
BEGIN
7597 akron1 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
6613 leency 173
END sysfunc22;
174
 
7597 akron1 175
 
176
PROCEDURE mem_commit (adr, size: INTEGER);
177
VAR
178
    tmp: INTEGER;
179
 
6647 akron1 180
BEGIN
7597 akron1 181
    FOR tmp := adr TO adr + size - 1 BY 4096 DO
182
        SYSTEM.PUT(tmp, 0)
183
    END
6647 akron1 184
END mem_commit;
185
 
7597 akron1 186
 
187
PROCEDURE [stdcall] malloc* (size: INTEGER): INTEGER;
188
VAR
189
    ptr: INTEGER;
190
 
6613 leency 191
BEGIN
7597 akron1 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
6613 leency 203
END malloc;
204
 
7597 akron1 205
 
206
PROCEDURE [stdcall] free* (ptr: INTEGER): INTEGER;
6613 leency 207
BEGIN
7597 akron1 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
6613 leency 214
END free;
215
 
7597 akron1 216
 
217
PROCEDURE [stdcall] realloc* (ptr, size: INTEGER): INTEGER;
6613 leency 218
BEGIN
7597 akron1 219
    SYSTEM.CODE(060H); (* pusha *)
220
    ptr := sysfunc4(68, 20, size, ptr);
221
    SYSTEM.CODE(061H)  (* popa  *)
222
    RETURN ptr
6613 leency 223
END realloc;
224
 
7597 akron1 225
 
226
PROCEDURE AppAdr (): INTEGER;
7209 akron1 227
VAR
228
    buf: ARRAY 1024 OF CHAR;
229
    a: INTEGER;
7597 akron1 230
 
7209 akron1 231
BEGIN
7597 akron1 232
    a := sysfunc3(9, SYSTEM.ADR(buf), -1);
233
    SYSTEM.GET(SYSTEM.ADR(buf) + 22, a)
7209 akron1 234
    RETURN a
235
END AppAdr;
236
 
7597 akron1 237
 
238
PROCEDURE GetCommandLine* (): INTEGER;
239
VAR
240
    param: INTEGER;
241
 
6613 leency 242
BEGIN
7597 akron1 243
    SYSTEM.GET(28 + AppAdr(), param)
244
    RETURN param
6613 leency 245
END GetCommandLine;
246
 
7597 akron1 247
 
248
PROCEDURE GetName* (): INTEGER;
249
VAR
250
    name: INTEGER;
251
 
6613 leency 252
BEGIN
7597 akron1 253
    SYSTEM.GET(32 + AppAdr(), name)
254
    RETURN name
6613 leency 255
END GetName;
256
 
7597 akron1 257
 
258
PROCEDURE [stdcall] dll_init2 (arg1, arg2, arg3, arg4, arg5: INTEGER);
6613 leency 259
BEGIN
7597 akron1 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
    )
6613 leency 272
END dll_init2;
273
 
274
 
7597 akron1 275
PROCEDURE GetProcAdr* (name: ARRAY OF CHAR; lib: INTEGER): INTEGER;
276
VAR
277
    cur, procname, adr: INTEGER;
6613 leency 278
 
7597 akron1 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
 
6613 leency 296
BEGIN
7597 akron1 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
6613 leency 307
    END
7597 akron1 308
 
309
    RETURN adr
6613 leency 310
END GetProcAdr;
311
 
7597 akron1 312
 
313
PROCEDURE init (dll: INTEGER);
314
VAR
315
    lib_init: INTEGER;
316
 
6613 leency 317
BEGIN
7597 akron1 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
6613 leency 326
END init;
327
 
328
 
7597 akron1 329
PROCEDURE GetStr (adr, i: INTEGER; VAR str: STRING);
330
VAR
331
    c: CHAR;
332
BEGIN
6613 leency 333
    REPEAT
7597 akron1 334
        SYSTEM.GET(adr, c); INC(adr);
335
        str[i] := c; INC(i)
6613 leency 336
    UNTIL c = 0X
7597 akron1 337
END GetStr;
6613 leency 338
 
7597 akron1 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
 
6613 leency 346
BEGIN
7597 akron1 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;
6613 leency 388
    IF fail THEN
7597 akron1 389
        res := 1
6613 leency 390
    END;
7597 akron1 391
    import_table := res;
392
    SYSTEM.CODE(061H) (* popa *)
393
    RETURN import_table
6613 leency 394
END dll_Load;
395
 
7597 akron1 396
 
397
PROCEDURE [stdcall] dll_Init (entry: INTEGER);
6613 leency 398
BEGIN
7597 akron1 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  *)
6613 leency 404
END dll_Init;
405
 
7597 akron1 406
 
407
PROCEDURE LoadLib* (name: ARRAY OF CHAR): INTEGER;
408
VAR
409
    Lib: INTEGER;
410
 
6613 leency 411
BEGIN
7597 akron1 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
6613 leency 418
END LoadLib;
419
 
7597 akron1 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
 
7696 akron1 430
END KOSAPI.