WebSVN – Kolibri OS – Diff – /programs/develop/oberon07/Lib/Linux32/API.ob07


(*
    BSD 2-Clause License
 
    Copyright (c) 2019, Anton Krotov
    All rights reserved.
*)
 
MODULE API;
 
IMPORT SYSTEM;
 
 
CONST
 
    RTLD_LAZY* = 1;
 
 
TYPE
 
    TP* = ARRAY 2 OF INTEGER;
 
 
VAR
 
    eol*: ARRAY 2 OF CHAR;
    MainParam*: INTEGER;
 
    libc*, librt*: INTEGER;
 
    dlopen*        : PROCEDURE [linux] (filename, flag: INTEGER): INTEGER;
    dlsym*         : PROCEDURE [linux] (handle, symbol: INTEGER): INTEGER;
 
    stdout*,
    stdin*,
    stderr*        : INTEGER;
 
    malloc*        : PROCEDURE [linux] (size: INTEGER): INTEGER;
    free*          : PROCEDURE [linux] (ptr: INTEGER);
    _exit*         : PROCEDURE [linux] (code: INTEGER);
    puts*          : PROCEDURE [linux] (pStr: INTEGER);
    fwrite*,
    fread*         : PROCEDURE [linux] (buffer, bytes, blocks, file: INTEGER): INTEGER;
    fopen*         : PROCEDURE [linux] (fname, fmode: INTEGER): INTEGER;
    fclose*        : PROCEDURE [linux] (file: INTEGER): INTEGER;
 
    clock_gettime* : PROCEDURE [linux] (clock_id: INTEGER; VAR tp: TP): INTEGER;
    time*          : PROCEDURE [linux] (ptr: INTEGER): INTEGER;
 
 
PROCEDURE putc* (c: CHAR);
VAR
    res: INTEGER;
 
BEGIN
    res := fwrite(SYSTEM.ADR(c), 1, 1, stdout)
END putc;
 
 
PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
BEGIN
    puts(lpCaption);
    puts(lpText)
END DebugMsg;
 
 
PROCEDURE _NEW* (size: INTEGER): INTEGER;
VAR
    res, ptr, words: INTEGER;
 
BEGIN
    res := malloc(size);
    IF res # 0 THEN
        ptr := res;
        words := size DIV SYSTEM.SIZE(INTEGER);
        WHILE words > 0 DO
            SYSTEM.PUT(ptr, 0);
            INC(ptr, SYSTEM.SIZE(INTEGER));
            DEC(words)
        END
    END
 
    RETURN res
END _NEW;
 
 
PROCEDURE _DISPOSE* (p: INTEGER): INTEGER;
BEGIN
    free(p)
    RETURN 0
END _DISPOSE;
 
 
PROCEDURE GetProcAdr (lib: INTEGER; name: ARRAY OF CHAR; VarAdr: INTEGER);
VAR
    sym: INTEGER;
 
BEGIN
    sym := dlsym(lib, SYSTEM.ADR(name[0]));
    ASSERT(sym # 0);
    SYSTEM.PUT(VarAdr, sym)
END GetProcAdr;
 
 
PROCEDURE init* (sp, code: INTEGER);
BEGIN
    SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER) * 2, dlopen);
    SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER),     dlsym);
    MainParam := sp;
 
    eol := 0AX;
 
    libc := dlopen(SYSTEM.SADR("libc.so.6"), RTLD_LAZY);
    GetProcAdr(libc, "malloc", SYSTEM.ADR(malloc));
    GetProcAdr(libc, "free", SYSTEM.ADR(free));
    GetProcAdr(libc, "exit", SYSTEM.ADR(_exit));
    GetProcAdr(libc, "stdout", SYSTEM.ADR(stdout));
    GetProcAdr(libc, "stdin", SYSTEM.ADR(stdin));
    GetProcAdr(libc, "stderr", SYSTEM.ADR(stderr));
    SYSTEM.GET(stdout - SYSTEM.SIZE(INTEGER), stdout);
    SYSTEM.GET(stdin  - SYSTEM.SIZE(INTEGER), stdin);
    SYSTEM.GET(stderr - SYSTEM.SIZE(INTEGER), stderr);
    GetProcAdr(libc, "puts", SYSTEM.ADR(puts));
    GetProcAdr(libc, "fwrite", SYSTEM.ADR(fwrite));
    GetProcAdr(libc, "fread", SYSTEM.ADR(fread));
    GetProcAdr(libc, "fopen", SYSTEM.ADR(fopen));
    GetProcAdr(libc, "fclose", SYSTEM.ADR(fclose));
    GetProcAdr(libc, "time", SYSTEM.ADR(time));
 
    librt := dlopen(SYSTEM.SADR("librt.so.1"), RTLD_LAZY);
    GetProcAdr(librt, "clock_gettime", SYSTEM.ADR(clock_gettime))
END init;
 
 
PROCEDURE exit* (code: INTEGER);
BEGIN
    _exit(code)
END exit;
 
 
PROCEDURE exit_thread* (code: INTEGER);
BEGIN
    _exit(code)
END exit_thread;
 
 
END API.

Rev 7597	Rev 7696
1	(*	1	(*
2	BSD 2-Clause License	2	BSD 2-Clause License
3		3
4	Copyright (c) 2019, Anton Krotov	4	Copyright (c) 2019, Anton Krotov
5	All rights reserved.	5	All rights reserved.
6	*)	6	*)
7		7
8	MODULE API;	8	MODULE API;
9		9
10	IMPORT SYSTEM;	10	IMPORT SYSTEM;
11		11
12		12
13	CONST	13	CONST
14		14
15	BASE_ADR = 08048000H;	15	RTLD_LAZY* = 1;
16		16
17		17
18	TYPE	18	TYPE
19		19
20	TP* = ARRAY 2 OF INTEGER;	20	TP* = ARRAY 2 OF INTEGER;
21		21
22		22
23	VAR	23	VAR
24		24
25	eol*: ARRAY 2 OF CHAR;	25	eol*: ARRAY 2 OF CHAR;
26	base, MainParam: INTEGER;	26	MainParam*: INTEGER;
27		27
28	libc, librt: INTEGER;	28	libc, librt: INTEGER;
29		29
30	dlopen* : PROCEDURE [linux] (filename, flag: INTEGER): INTEGER;	30	dlopen* : PROCEDURE [linux] (filename, flag: INTEGER): INTEGER;
31	dlsym* : PROCEDURE [linux] (handle, symbol: INTEGER): INTEGER;	31	dlsym* : PROCEDURE [linux] (handle, symbol: INTEGER): INTEGER;
32		32
33	stdout*,	33	stdout*,
34	stdin*,	34	stdin*,
35	stderr* : INTEGER;	35	stderr* : INTEGER;
36		36
37	malloc* : PROCEDURE [linux] (size: INTEGER): INTEGER;	37	malloc* : PROCEDURE [linux] (size: INTEGER): INTEGER;
38	free* : PROCEDURE [linux] (ptr: INTEGER);	38	free* : PROCEDURE [linux] (ptr: INTEGER);
39	_exit* : PROCEDURE [linux] (code: INTEGER);	39	_exit* : PROCEDURE [linux] (code: INTEGER);
40	puts* : PROCEDURE [linux] (pStr: INTEGER);	40	puts* : PROCEDURE [linux] (pStr: INTEGER);
41	fwrite*,	41	fwrite*,
42	fread* : PROCEDURE [linux] (buffer, bytes, blocks, file: INTEGER): INTEGER;	42	fread* : PROCEDURE [linux] (buffer, bytes, blocks, file: INTEGER): INTEGER;
43	fopen* : PROCEDURE [linux] (fname, fmode: INTEGER): INTEGER;	43	fopen* : PROCEDURE [linux] (fname, fmode: INTEGER): INTEGER;
44	fclose* : PROCEDURE [linux] (file: INTEGER): INTEGER;	44	fclose* : PROCEDURE [linux] (file: INTEGER): INTEGER;
45		45
46	clock_gettime* : PROCEDURE [linux] (clock_id: INTEGER; VAR tp: TP): INTEGER;	46	clock_gettime* : PROCEDURE [linux] (clock_id: INTEGER; VAR tp: TP): INTEGER;
47	time* : PROCEDURE [linux] (ptr: INTEGER): INTEGER;	47	time* : PROCEDURE [linux] (ptr: INTEGER): INTEGER;
48		48
49		49
50	PROCEDURE putc* (c: CHAR);	50	PROCEDURE putc* (c: CHAR);
51	VAR	51	VAR
52	res: INTEGER;	52	res: INTEGER;
53		53
54	BEGIN	54	BEGIN
55	res := fwrite(SYSTEM.ADR(c), 1, 1, stdout)	55	res := fwrite(SYSTEM.ADR(c), 1, 1, stdout)
56	END putc;	56	END putc;
57		57
58		58
59	PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);	59	PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
60	BEGIN	60	BEGIN
61	puts(lpCaption);	61	puts(lpCaption);
62	puts(lpText)	62	puts(lpText)
63	END DebugMsg;	63	END DebugMsg;
64		64
65		65
66	PROCEDURE _NEW* (size: INTEGER): INTEGER;	66	PROCEDURE _NEW* (size: INTEGER): INTEGER;
67	VAR	67	VAR
68	res, ptr, words: INTEGER;	68	res, ptr, words: INTEGER;
69		69
70	BEGIN	70	BEGIN
71	res := malloc(size);	71	res := malloc(size);
72	IF res # 0 THEN	72	IF res # 0 THEN
73	ptr := res;	73	ptr := res;
74	words := size DIV SYSTEM.SIZE(INTEGER);	74	words := size DIV SYSTEM.SIZE(INTEGER);
75	WHILE words > 0 DO	75	WHILE words > 0 DO
76	SYSTEM.PUT(ptr, 0);	76	SYSTEM.PUT(ptr, 0);
77	INC(ptr, SYSTEM.SIZE(INTEGER));	77	INC(ptr, SYSTEM.SIZE(INTEGER));
78	DEC(words)	78	DEC(words)
79	END	79	END
80	END	80	END
81		81
82	RETURN res	82	RETURN res
83	END _NEW;	83	END _NEW;
84		84
85		85
86	PROCEDURE _DISPOSE* (p: INTEGER): INTEGER;	86	PROCEDURE _DISPOSE* (p: INTEGER): INTEGER;
87	BEGIN	87	BEGIN
88	free(p)	88	free(p)
89	RETURN 0	89	RETURN 0
90	END _DISPOSE;	90	END _DISPOSE;
91		91
92		92
93	PROCEDURE GetProcAdr (lib: INTEGER; name: ARRAY OF CHAR; VarAdr: INTEGER);	93	PROCEDURE GetProcAdr (lib: INTEGER; name: ARRAY OF CHAR; VarAdr: INTEGER);
94	VAR	94	VAR
95	sym: INTEGER;	95	sym: INTEGER;
-		96
96	BEGIN	97	BEGIN
97	sym := dlsym(lib, SYSTEM.ADR(name[0]));	98	sym := dlsym(lib, SYSTEM.ADR(name[0]));
98	ASSERT(sym # 0);	99	ASSERT(sym # 0);
99	SYSTEM.PUT(VarAdr, sym)	100	SYSTEM.PUT(VarAdr, sym)
100	END GetProcAdr;	101	END GetProcAdr;
101		102
102		103
103	PROCEDURE init* (sp, code: INTEGER);	104	PROCEDURE init* (sp, code: INTEGER);
104	BEGIN	105	BEGIN
105	SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER) * 2, dlopen);	106	SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER) * 2, dlopen);
106	SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER), dlsym);	107	SYSTEM.GET(code - 1000H - SYSTEM.SIZE(INTEGER), dlsym);
107	MainParam := sp;	108	MainParam := sp;
108	base := BASE_ADR;	-
109	eol := 0AX;	109	eol := 0AX;
110		110
111	libc := dlopen(SYSTEM.SADR("libc.so.6"), 1);	111	libc := dlopen(SYSTEM.SADR("libc.so.6"), RTLD_LAZY);
112	GetProcAdr(libc, "malloc", SYSTEM.ADR(malloc));	112	GetProcAdr(libc, "malloc", SYSTEM.ADR(malloc));
113	GetProcAdr(libc, "free", SYSTEM.ADR(free));	113	GetProcAdr(libc, "free", SYSTEM.ADR(free));
114	GetProcAdr(libc, "exit", SYSTEM.ADR(_exit));	114	GetProcAdr(libc, "exit", SYSTEM.ADR(_exit));
115	GetProcAdr(libc, "stdout", SYSTEM.ADR(stdout));	115	GetProcAdr(libc, "stdout", SYSTEM.ADR(stdout));
116	GetProcAdr(libc, "stdin", SYSTEM.ADR(stdin));	116	GetProcAdr(libc, "stdin", SYSTEM.ADR(stdin));
117	GetProcAdr(libc, "stderr", SYSTEM.ADR(stderr));	117	GetProcAdr(libc, "stderr", SYSTEM.ADR(stderr));
118	SYSTEM.GET(stdout - SYSTEM.SIZE(INTEGER), stdout);	118	SYSTEM.GET(stdout - SYSTEM.SIZE(INTEGER), stdout);
119	SYSTEM.GET(stdin - SYSTEM.SIZE(INTEGER), stdin);	119	SYSTEM.GET(stdin - SYSTEM.SIZE(INTEGER), stdin);
120	SYSTEM.GET(stderr - SYSTEM.SIZE(INTEGER), stderr);	120	SYSTEM.GET(stderr - SYSTEM.SIZE(INTEGER), stderr);
121	GetProcAdr(libc, "puts", SYSTEM.ADR(puts));	121	GetProcAdr(libc, "puts", SYSTEM.ADR(puts));
122	GetProcAdr(libc, "fwrite", SYSTEM.ADR(fwrite));	122	GetProcAdr(libc, "fwrite", SYSTEM.ADR(fwrite));
123	GetProcAdr(libc, "fread", SYSTEM.ADR(fread));	123	GetProcAdr(libc, "fread", SYSTEM.ADR(fread));
124	GetProcAdr(libc, "fopen", SYSTEM.ADR(fopen));	124	GetProcAdr(libc, "fopen", SYSTEM.ADR(fopen));
125	GetProcAdr(libc, "fclose", SYSTEM.ADR(fclose));	125	GetProcAdr(libc, "fclose", SYSTEM.ADR(fclose));
126	GetProcAdr(libc, "time", SYSTEM.ADR(time));	126	GetProcAdr(libc, "time", SYSTEM.ADR(time));
127		127
128	librt := dlopen(SYSTEM.SADR("librt.so.1"), 1);	128	librt := dlopen(SYSTEM.SADR("librt.so.1"), RTLD_LAZY);
129	GetProcAdr(librt, "clock_gettime", SYSTEM.ADR(clock_gettime))	129	GetProcAdr(librt, "clock_gettime", SYSTEM.ADR(clock_gettime))
130	END init;	130	END init;
131		131
132		132
133	PROCEDURE exit* (code: INTEGER);	133	PROCEDURE exit* (code: INTEGER);
134	BEGIN	134	BEGIN
135	_exit(code)	135	_exit(code)
136	END exit;	136	END exit;
137		137
138		138
139	PROCEDURE exit_thread* (code: INTEGER);	139	PROCEDURE exit_thread* (code: INTEGER);
140	BEGIN	140	BEGIN
141	_exit(code)	141	_exit(code)
142	END exit_thread;	142	END exit_thread;
143		143
144		144
145	END API.	145	END API.

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Lib/Linux32/API.ob07 – Rev 7597 → 7696