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


(*
    Copyright 2016, 2017, 2018 Anton Krotov
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with this program.  If not, see .
*)
 
MODULE API;
 
IMPORT sys := SYSTEM;
 
 
CONST
 
    MAX_SIZE  = 16 * 400H;
    HEAP_SIZE =  1 * 100000H;
 
    _new = 1;
    _dispose = 2;
 
 
TYPE
 
    CRITICAL_SECTION = ARRAY 2 OF INTEGER;
 
 
VAR
 
    heap, endheap: INTEGER;
    pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER;
 
    CriticalSection: CRITICAL_SECTION;
 
 
PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);
BEGIN
    sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")
END zeromem;
 
 
PROCEDURE mem_commit* (adr, size: INTEGER);
VAR
    tmp: INTEGER;
BEGIN
    FOR tmp := adr TO adr + size - 1 BY 4096 DO
        sys.PUT(tmp, 0)
    END
END mem_commit;
 
 
PROCEDURE strncmp* (a, b, n: INTEGER): INTEGER;
VAR
    A, B: CHAR;
    Res: INTEGER;
BEGIN
    Res := 0;
    WHILE n > 0 DO
        sys.GET(a, A); INC(a);
        sys.GET(b, B); INC(b);
        DEC(n);
        IF A # B THEN
            Res := ORD(A) - ORD(B);
            n := 0
        ELSIF A = 0X THEN
            n := 0
        END
    END
    RETURN Res
END strncmp;
 
 
PROCEDURE [stdcall] sysfunc1* (arg1: INTEGER): INTEGER;
BEGIN
    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
    sys.CODE("CD40");             (* int     40h              *)
    sys.CODE("C9");               (* leave                    *)
    sys.CODE("C20400");           (* ret     04h              *)
    RETURN 0
END sysfunc1;
 
 
PROCEDURE [stdcall] sysfunc2* (arg1, arg2: INTEGER): INTEGER;
BEGIN
    sys.CODE("53");               (* push    ebx              *)
    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
    sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
    sys.CODE("CD40");             (* int     40h              *)
    sys.CODE("5B");               (* pop     ebx              *)
    sys.CODE("C9");               (* leave                    *)
    sys.CODE("C20800");           (* ret     08h              *)
    RETURN 0
END sysfunc2;
 
 
PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;
BEGIN
    sys.CODE("53");               (* push    ebx              *)
    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
    sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
    sys.CODE("8B4D10");           (* mov     ecx, [ebp + 10h] *)
    sys.CODE("CD40");             (* int     40h              *)
    sys.CODE("5B");               (* pop     ebx              *)
    sys.CODE("C9");               (* leave                    *)
    sys.CODE("C20C00");           (* ret     0Ch              *)
    RETURN 0
END sysfunc3;
 
 
PROCEDURE [stdcall] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER;
BEGIN
    sys.CODE("53");               (* push    ebx              *)
    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
    sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
    sys.CODE("8B4D10");           (* mov     ecx, [ebp + 10h] *)
    sys.CODE("8B5514");           (* mov     edx, [ebp + 14h] *)
    sys.CODE("CD40");             (* int     40h              *)
    sys.CODE("5B");               (* pop     ebx              *)
    sys.CODE("C9");               (* leave                    *)
    sys.CODE("C21000");           (* ret     10h              *)
    RETURN 0
END sysfunc4;
 
 
PROCEDURE [stdcall] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER;
BEGIN
    sys.CODE("53");               (* push    ebx              *)
    sys.CODE("56");               (* push    esi              *)
    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
    sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
    sys.CODE("8B4D10");           (* mov     ecx, [ebp + 10h] *)
    sys.CODE("8B5514");           (* mov     edx, [ebp + 14h] *)
    sys.CODE("8B7518");           (* mov     esi, [ebp + 18h] *)
    sys.CODE("CD40");             (* int     40h              *)
    sys.CODE("5E");               (* pop     esi              *)
    sys.CODE("5B");               (* pop     ebx              *)
    sys.CODE("C9");               (* leave                    *)
    sys.CODE("C21400");           (* ret     14h              *)
    RETURN 0
END sysfunc5;
 
 
PROCEDURE switch_task;
VAR
    res: INTEGER;
BEGIN
    res := sysfunc2(68, 1)
END switch_task;
 
 
PROCEDURE futex_create (ptr: INTEGER): INTEGER;
    RETURN sysfunc3(77, 0, ptr)
END futex_create;
 
 
PROCEDURE futex_wait (futex, value, timeout: INTEGER);
VAR
    res: INTEGER;
BEGIN
    res := sysfunc5(77, 2, futex, value, timeout)
END futex_wait;
 
 
PROCEDURE futex_wake (futex, number: INTEGER);
VAR
    res: INTEGER;
BEGIN
    res := sysfunc4(77, 3, futex, number)
END futex_wake;
 
 
PROCEDURE EnterCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);
BEGIN
    switch_task;
    futex_wait(CriticalSection[0], 1, 10000);
    CriticalSection[1] := 1
END EnterCriticalSection;
 
 
PROCEDURE LeaveCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);
BEGIN
    CriticalSection[1] := 0;
    futex_wake(CriticalSection[0], 1)
END LeaveCriticalSection;
 
 
PROCEDURE InitializeCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);
BEGIN
    CriticalSection[0] := futex_create(sys.ADR(CriticalSection[1]));
    CriticalSection[1] := 0
END InitializeCriticalSection;
 
 
PROCEDURE __NEW (size: INTEGER): INTEGER;
VAR
    res, idx, temp: INTEGER;
BEGIN
    IF size <= MAX_SIZE THEN
        idx := ASR(size, 5);
        res := pockets[idx];
        IF res # 0 THEN
            sys.GET(res, pockets[idx]);
            sys.PUT(res, size);
            INC(res, 4)
        ELSE
            temp := 0;
            IF heap + size >= endheap THEN
                IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN
                    temp := sysfunc3(68, 12, HEAP_SIZE)
                ELSE
                    temp := 0
                END;
                IF temp # 0 THEN
                    mem_commit(temp, HEAP_SIZE);
                    heap := temp;
                    endheap := heap + HEAP_SIZE
                ELSE
                    temp := -1
                END
            END;
            IF (heap # 0) & (temp # -1) THEN
                sys.PUT(heap, size);
                res := heap + 4;
                heap := heap + size
            ELSE
                res := 0
            END
        END
    ELSE
        IF sysfunc2(18, 16) > ASR(size, 10) THEN
            res := sysfunc3(68, 12, size);
            IF res # 0 THEN
                mem_commit(res, size);
                sys.PUT(res, size);
                INC(res, 4)
            END
        ELSE
            res := 0
        END
    END;
    IF (res # 0) & (size <= MAX_SIZE) THEN
        zeromem(ASR(size, 2) - 1, res)
    END
    RETURN res
END __NEW;
 
 
PROCEDURE __DISPOSE (ptr: INTEGER): INTEGER;
VAR
    size, idx: INTEGER;
BEGIN
    DEC(ptr, 4);
    sys.GET(ptr, size);
    IF size <= MAX_SIZE THEN
        idx := ASR(size, 5);
        sys.PUT(ptr, pockets[idx]);
        pockets[idx] := ptr
    ELSE
        size := sysfunc3(68, 13, ptr)
    END
    RETURN 0
END __DISPOSE;
 
 
PROCEDURE NEW_DISPOSE (func, arg: INTEGER): INTEGER;
VAR
    res: INTEGER;
BEGIN
    EnterCriticalSection(CriticalSection);
 
    IF func = _new THEN
        res := __NEW(arg)
    ELSIF func = _dispose THEN
        res := __DISPOSE(arg)
    END;
 
    LeaveCriticalSection(CriticalSection)
    RETURN res
END NEW_DISPOSE;
 
 
PROCEDURE _NEW* (size: INTEGER): INTEGER;
    RETURN NEW_DISPOSE(_new, size)
END _NEW;
 
 
PROCEDURE _DISPOSE* (ptr: INTEGER): INTEGER;
    RETURN NEW_DISPOSE(_dispose, ptr)
END _DISPOSE;
 
 
PROCEDURE ExitProcess* (p1: INTEGER);
BEGIN
    p1 := sysfunc1(-1)
END ExitProcess;
 
 
PROCEDURE ExitThread* (p1: INTEGER);
BEGIN
    p1 := sysfunc1(-1)
END ExitThread;
 
 
PROCEDURE OutChar (c: CHAR);
VAR
    res: INTEGER;
BEGIN
    res := sysfunc3(63, 1, ORD(c))
END OutChar;
 
 
PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
VAR
    c: CHAR;
BEGIN
    IF lpCaption # 0 THEN
        OutChar(0DX);
        OutChar(0AX);
        REPEAT
            sys.GET(lpCaption, c);
            IF c # 0X THEN
                OutChar(c)
            END;
            INC(lpCaption)
        UNTIL c = 0X;
        OutChar(":");
        OutChar(0DX);
        OutChar(0AX)
    END;
    REPEAT
        sys.GET(lpText, c);
        IF c # 0X THEN
            OutChar(c)
        END;
        INC(lpText)
    UNTIL c = 0X;
    IF lpCaption # 0 THEN
        OutChar(0DX);
        OutChar(0AX)
    END
END DebugMsg;
 
 
PROCEDURE init* (p1: INTEGER);
BEGIN
    p1 := sysfunc2(68, 11);
    InitializeCriticalSection(CriticalSection)
END init;
 
 
END API.

Rev 7110	Rev 7209
1	(*	1	(*
2	Copyright 2016, 2017 Anton Krotov	2	Copyright 2016, 2017, 2018 Anton Krotov
3		3
4	This program is free software: you can redistribute it and/or modify	4	This program is free software: you can redistribute it and/or modify
5	it under the terms of the GNU Lesser General Public License as published by	5	it under the terms of the GNU Lesser General Public License as published by
6	the Free Software Foundation, either version 3 of the License, or	6	the Free Software Foundation, either version 3 of the License, or
7	(at your option) any later version.	7	(at your option) any later version.
8		8
9	This program is distributed in the hope that it will be useful,	9	This program is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	GNU Lesser General Public License for more details.	12	GNU Lesser General Public License for more details.
13		13
14	You should have received a copy of the GNU Lesser General Public License	14	You should have received a copy of the GNU Lesser General Public License
15	along with this program. If not, see .	15	along with this program. If not, see .
16	*)	16	*)
17		17
18	MODULE API;	18	MODULE API;
19		19
20	IMPORT sys := SYSTEM;	20	IMPORT sys := SYSTEM;
21		21
22		22
23	CONST	23	CONST
24		24
25	MAX_SIZE = 16 * 400H;	25	MAX_SIZE = 16 * 400H;
26	HEAP_SIZE = 1 * 100000H;	26	HEAP_SIZE = 1 * 100000H;
27		27
28	_new = 1;	28	_new = 1;
29	_dispose = 2;	29	_dispose = 2;
30		30
31		31
32	TYPE	32	TYPE
33		33
34	CRITICAL_SECTION = ARRAY 2 OF INTEGER;	34	CRITICAL_SECTION = ARRAY 2 OF INTEGER;
35		35
36		36
37	VAR	37	VAR
38		38
39	heap, endheap: INTEGER;	39	heap, endheap: INTEGER;
40	pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER;	40	pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER;
41		41
42	CriticalSection: CRITICAL_SECTION;	42	CriticalSection: CRITICAL_SECTION;
43		43
44		44
45	PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);	45	PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);
46	BEGIN	46	BEGIN
47	sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")	47	sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")
48	END zeromem;	48	END zeromem;
49		49
50		50
51	PROCEDURE mem_commit* (adr, size: INTEGER);	51	PROCEDURE mem_commit* (adr, size: INTEGER);
52	VAR	52	VAR
53	tmp: INTEGER;	53	tmp: INTEGER;
54	BEGIN	54	BEGIN
55	FOR tmp := adr TO adr + size - 1 BY 4096 DO	55	FOR tmp := adr TO adr + size - 1 BY 4096 DO
56	sys.PUT(tmp, 0)	56	sys.PUT(tmp, 0)
57	END	57	END
58	END mem_commit;	58	END mem_commit;
59		59
60		60
61	PROCEDURE strncmp* (a, b, n: INTEGER): INTEGER;	61	PROCEDURE strncmp* (a, b, n: INTEGER): INTEGER;
62	VAR	62	VAR
63	A, B: CHAR;	63	A, B: CHAR;
64	Res: INTEGER;	64	Res: INTEGER;
65	BEGIN	65	BEGIN
66	Res := 0;	66	Res := 0;
67	WHILE n > 0 DO	67	WHILE n > 0 DO
68	sys.GET(a, A); INC(a);	68	sys.GET(a, A); INC(a);
69	sys.GET(b, B); INC(b);	69	sys.GET(b, B); INC(b);
70	DEC(n);	70	DEC(n);
71	IF A # B THEN	71	IF A # B THEN
72	Res := ORD(A) - ORD(B);	72	Res := ORD(A) - ORD(B);
73	n := 0	73	n := 0
74	ELSIF A = 0X THEN	74	ELSIF A = 0X THEN
75	n := 0	75	n := 0
76	END	76	END
77	END	77	END
78	RETURN Res	78	RETURN Res
79	END strncmp;	79	END strncmp;
80		80
81		81
82	PROCEDURE [stdcall] sysfunc1* (arg1: INTEGER): INTEGER;	82	PROCEDURE [stdcall] sysfunc1* (arg1: INTEGER): INTEGER;
83	BEGIN	83	BEGIN
84	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)	84	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)
85	sys.CODE("CD40"); (* int 40h *)	85	sys.CODE("CD40"); (* int 40h *)
86	sys.CODE("C9"); (* leave *)	86	sys.CODE("C9"); (* leave *)
87	sys.CODE("C20400"); (* ret 04h *)	87	sys.CODE("C20400"); (* ret 04h *)
88	RETURN 0	88	RETURN 0
89	END sysfunc1;	89	END sysfunc1;
90		90
91		91
92	PROCEDURE [stdcall] sysfunc2* (arg1, arg2: INTEGER): INTEGER;	92	PROCEDURE [stdcall] sysfunc2* (arg1, arg2: INTEGER): INTEGER;
93	BEGIN	93	BEGIN
94	sys.CODE("53"); (* push ebx *)	94	sys.CODE("53"); (* push ebx *)
95	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)	95	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)
96	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)	96	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)
97	sys.CODE("CD40"); (* int 40h *)	97	sys.CODE("CD40"); (* int 40h *)
98	sys.CODE("5B"); (* pop ebx *)	98	sys.CODE("5B"); (* pop ebx *)
99	sys.CODE("C9"); (* leave *)	99	sys.CODE("C9"); (* leave *)
100	sys.CODE("C20800"); (* ret 08h *)	100	sys.CODE("C20800"); (* ret 08h *)
101	RETURN 0	101	RETURN 0
102	END sysfunc2;	102	END sysfunc2;
103		103
104		104
105	PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;	105	PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;
106	BEGIN	106	BEGIN
107	sys.CODE("53"); (* push ebx *)	107	sys.CODE("53"); (* push ebx *)
108	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)	108	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)
109	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)	109	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)
110	sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *)	110	sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *)
111	sys.CODE("CD40"); (* int 40h *)	111	sys.CODE("CD40"); (* int 40h *)
112	sys.CODE("5B"); (* pop ebx *)	112	sys.CODE("5B"); (* pop ebx *)
113	sys.CODE("C9"); (* leave *)	113	sys.CODE("C9"); (* leave *)
114	sys.CODE("C20C00"); (* ret 0Ch *)	114	sys.CODE("C20C00"); (* ret 0Ch *)
115	RETURN 0	115	RETURN 0
116	END sysfunc3;	116	END sysfunc3;
117		117
118		118
119	PROCEDURE [stdcall] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER;	119	PROCEDURE [stdcall] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER;
120	BEGIN	120	BEGIN
121	sys.CODE("53"); (* push ebx *)	121	sys.CODE("53"); (* push ebx *)
122	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)	122	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)
123	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)	123	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)
124	sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *)	124	sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *)
125	sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *)	125	sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *)
126	sys.CODE("CD40"); (* int 40h *)	126	sys.CODE("CD40"); (* int 40h *)
127	sys.CODE("5B"); (* pop ebx *)	127	sys.CODE("5B"); (* pop ebx *)
128	sys.CODE("C9"); (* leave *)	128	sys.CODE("C9"); (* leave *)
129	sys.CODE("C21000"); (* ret 10h *)	129	sys.CODE("C21000"); (* ret 10h *)
130	RETURN 0	130	RETURN 0
131	END sysfunc4;	131	END sysfunc4;
132		132
133		133
134	PROCEDURE [stdcall] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER;	134	PROCEDURE [stdcall] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER;
135	BEGIN	135	BEGIN
136	sys.CODE("53"); (* push ebx *)	136	sys.CODE("53"); (* push ebx *)
137	sys.CODE("56"); (* push esi *)	137	sys.CODE("56"); (* push esi *)
138	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)	138	sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *)
139	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)	139	sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *)
140	sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *)	140	sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *)
141	sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *)	141	sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *)
142	sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *)	142	sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *)
143	sys.CODE("CD40"); (* int 40h *)	143	sys.CODE("CD40"); (* int 40h *)
144	sys.CODE("5E"); (* pop esi *)	144	sys.CODE("5E"); (* pop esi *)
145	sys.CODE("5B"); (* pop ebx *)	145	sys.CODE("5B"); (* pop ebx *)
146	sys.CODE("C9"); (* leave *)	146	sys.CODE("C9"); (* leave *)
147	sys.CODE("C21400"); (* ret 14h *)	147	sys.CODE("C21400"); (* ret 14h *)
148	RETURN 0	148	RETURN 0
149	END sysfunc5;	149	END sysfunc5;
150		150
151		151
152	PROCEDURE switch_task;	152	PROCEDURE switch_task;
153	VAR	153	VAR
154	res: INTEGER;	154	res: INTEGER;
155	BEGIN	155	BEGIN
156	res := sysfunc2(68, 1)	156	res := sysfunc2(68, 1)
157	END switch_task;	157	END switch_task;
158		158
159		159
160	PROCEDURE futex_create (ptr: INTEGER): INTEGER;	160	PROCEDURE futex_create (ptr: INTEGER): INTEGER;
161	RETURN sysfunc3(77, 0, ptr)	161	RETURN sysfunc3(77, 0, ptr)
162	END futex_create;	162	END futex_create;
163		163
164		164
165	PROCEDURE futex_wait (futex, value, timeout: INTEGER);	165	PROCEDURE futex_wait (futex, value, timeout: INTEGER);
166	VAR	166	VAR
167	res: INTEGER;	167	res: INTEGER;
168	BEGIN	168	BEGIN
169	res := sysfunc5(77, 2, futex, value, timeout)	169	res := sysfunc5(77, 2, futex, value, timeout)
170	END futex_wait;	170	END futex_wait;
171		171
172		172
173	PROCEDURE futex_wake (futex, number: INTEGER);	173	PROCEDURE futex_wake (futex, number: INTEGER);
174	VAR	174	VAR
175	res: INTEGER;	175	res: INTEGER;
176	BEGIN	176	BEGIN
177	res := sysfunc4(77, 3, futex, number)	177	res := sysfunc4(77, 3, futex, number)
178	END futex_wake;	178	END futex_wake;
179		179
180		180
181	PROCEDURE EnterCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);	181	PROCEDURE EnterCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);
182	BEGIN	182	BEGIN
183	switch_task;	183	switch_task;
184	futex_wait(CriticalSection[0], 1, 10000);	184	futex_wait(CriticalSection[0], 1, 10000);
185	CriticalSection[1] := 1	185	CriticalSection[1] := 1
186	END EnterCriticalSection;	186	END EnterCriticalSection;
187		187
188		188
189	PROCEDURE LeaveCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);	189	PROCEDURE LeaveCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);
190	BEGIN	190	BEGIN
191	CriticalSection[1] := 0;	191	CriticalSection[1] := 0;
192	futex_wake(CriticalSection[0], 1)	192	futex_wake(CriticalSection[0], 1)
193	END LeaveCriticalSection;	193	END LeaveCriticalSection;
194		194
195		195
196	PROCEDURE InitializeCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);	196	PROCEDURE InitializeCriticalSection* (VAR CriticalSection: CRITICAL_SECTION);
197	BEGIN	197	BEGIN
198	CriticalSection[0] := futex_create(sys.ADR(CriticalSection[1]));	198	CriticalSection[0] := futex_create(sys.ADR(CriticalSection[1]));
199	CriticalSection[1] := 0	199	CriticalSection[1] := 0
200	END InitializeCriticalSection;	200	END InitializeCriticalSection;
201		201
202		202
203	PROCEDURE __NEW (size: INTEGER): INTEGER;	203	PROCEDURE __NEW (size: INTEGER): INTEGER;
204	VAR	204	VAR
205	res, idx, temp: INTEGER;	205	res, idx, temp: INTEGER;
206	BEGIN	206	BEGIN
207	IF size <= MAX_SIZE THEN	207	IF size <= MAX_SIZE THEN
208	idx := ASR(size, 5);	208	idx := ASR(size, 5);
209	res := pockets[idx];	209	res := pockets[idx];
210	IF res # 0 THEN	210	IF res # 0 THEN
211	sys.GET(res, pockets[idx]);	211	sys.GET(res, pockets[idx]);
212	sys.PUT(res, size);	212	sys.PUT(res, size);
213	INC(res, 4)	213	INC(res, 4)
214	ELSE	214	ELSE
215	temp := 0;	215	temp := 0;
216	IF heap + size >= endheap THEN	216	IF heap + size >= endheap THEN
217	IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN	217	IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN
218	temp := sysfunc3(68, 12, HEAP_SIZE)	218	temp := sysfunc3(68, 12, HEAP_SIZE)
219	ELSE	219	ELSE
220	temp := 0	220	temp := 0
221	END;	221	END;
222	IF temp # 0 THEN	222	IF temp # 0 THEN
223	mem_commit(temp, HEAP_SIZE);	223	mem_commit(temp, HEAP_SIZE);
224	heap := temp;	224	heap := temp;
225	endheap := heap + HEAP_SIZE	225	endheap := heap + HEAP_SIZE
226	ELSE	226	ELSE
227	temp := -1	227	temp := -1
228	END	228	END
229	END;	229	END;
230	IF (heap # 0) & (temp # -1) THEN	230	IF (heap # 0) & (temp # -1) THEN
231	sys.PUT(heap, size);	231	sys.PUT(heap, size);
232	res := heap + 4;	232	res := heap + 4;
233	heap := heap + size	233	heap := heap + size
234	ELSE	234	ELSE
235	res := 0	235	res := 0
236	END	236	END
237	END	237	END
238	ELSE	238	ELSE
239	IF sysfunc2(18, 16) > ASR(size, 10) THEN	239	IF sysfunc2(18, 16) > ASR(size, 10) THEN
240	res := sysfunc3(68, 12, size);	240	res := sysfunc3(68, 12, size);
241	IF res # 0 THEN	241	IF res # 0 THEN
242	mem_commit(res, size);	242	mem_commit(res, size);
243	sys.PUT(res, size);	243	sys.PUT(res, size);
244	INC(res, 4)	244	INC(res, 4)
245	END	245	END
246	ELSE	246	ELSE
247	res := 0	247	res := 0
248	END	248	END
249	END;	249	END;
250	IF res # 0 THEN	250	IF (res # 0) & (size <= MAX_SIZE) THEN
251	zeromem(ASR(size, 2) - 1, res)	251	zeromem(ASR(size, 2) - 1, res)
252	END	252	END
253	RETURN res	253	RETURN res
254	END __NEW;	254	END __NEW;
255		255
256		256
257	PROCEDURE __DISPOSE (ptr: INTEGER): INTEGER;	257	PROCEDURE __DISPOSE (ptr: INTEGER): INTEGER;
258	VAR	258	VAR
259	size, idx: INTEGER;	259	size, idx: INTEGER;
260	BEGIN	260	BEGIN
261	DEC(ptr, 4);	261	DEC(ptr, 4);
262	sys.GET(ptr, size);	262	sys.GET(ptr, size);
263	IF size <= MAX_SIZE THEN	263	IF size <= MAX_SIZE THEN
264	idx := ASR(size, 5);	264	idx := ASR(size, 5);
265	sys.PUT(ptr, pockets[idx]);	265	sys.PUT(ptr, pockets[idx]);
266	pockets[idx] := ptr	266	pockets[idx] := ptr
267	ELSE	267	ELSE
268	size := sysfunc3(68, 13, ptr)	268	size := sysfunc3(68, 13, ptr)
269	END	269	END
270	RETURN 0	270	RETURN 0
271	END __DISPOSE;	271	END __DISPOSE;
272		272
273		273
274	PROCEDURE NEW_DISPOSE (func, arg: INTEGER): INTEGER;	274	PROCEDURE NEW_DISPOSE (func, arg: INTEGER): INTEGER;
275	VAR	275	VAR
276	res: INTEGER;	276	res: INTEGER;
277	BEGIN	277	BEGIN
278	EnterCriticalSection(CriticalSection);	278	EnterCriticalSection(CriticalSection);
279		279
280	IF func = _new THEN	280	IF func = _new THEN
281	res := __NEW(arg)	281	res := __NEW(arg)
282	ELSIF func = _dispose THEN	282	ELSIF func = _dispose THEN
283	res := __DISPOSE(arg)	283	res := __DISPOSE(arg)
284	END;	284	END;
285		285
286	LeaveCriticalSection(CriticalSection)	286	LeaveCriticalSection(CriticalSection)
287	RETURN res	287	RETURN res
288	END NEW_DISPOSE;	288	END NEW_DISPOSE;
289		289
290		290
291	PROCEDURE _NEW* (size: INTEGER): INTEGER;	291	PROCEDURE _NEW* (size: INTEGER): INTEGER;
292	RETURN NEW_DISPOSE(_new, size)	292	RETURN NEW_DISPOSE(_new, size)
293	END _NEW;	293	END _NEW;
294		294
295		295
296	PROCEDURE _DISPOSE* (ptr: INTEGER): INTEGER;	296	PROCEDURE _DISPOSE* (ptr: INTEGER): INTEGER;
297	RETURN NEW_DISPOSE(_dispose, ptr)	297	RETURN NEW_DISPOSE(_dispose, ptr)
298	END _DISPOSE;	298	END _DISPOSE;
299		299
300		300
301	PROCEDURE ExitProcess* (p1: INTEGER);	301	PROCEDURE ExitProcess* (p1: INTEGER);
302	BEGIN	302	BEGIN
303	p1 := sysfunc1(-1)	303	p1 := sysfunc1(-1)
304	END ExitProcess;	304	END ExitProcess;
305		305
306		306
307	PROCEDURE ExitThread* (p1: INTEGER);	307	PROCEDURE ExitThread* (p1: INTEGER);
308	BEGIN	308	BEGIN
309	p1 := sysfunc1(-1)	309	p1 := sysfunc1(-1)
310	END ExitThread;	310	END ExitThread;
311		311
312		312
313	PROCEDURE OutChar (c: CHAR);	313	PROCEDURE OutChar (c: CHAR);
314	VAR	314	VAR
315	res: INTEGER;	315	res: INTEGER;
316	BEGIN	316	BEGIN
317	res := sysfunc3(63, 1, ORD(c))	317	res := sysfunc3(63, 1, ORD(c))
318	END OutChar;	318	END OutChar;
319		319
320		320
321	PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);	321	PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER);
322	VAR	322	VAR
323	c: CHAR;	323	c: CHAR;
324	BEGIN	324	BEGIN
325	IF lpCaption # 0 THEN	325	IF lpCaption # 0 THEN
326	OutChar(0DX);	326	OutChar(0DX);
327	OutChar(0AX);	327	OutChar(0AX);
328	REPEAT	328	REPEAT
329	sys.GET(lpCaption, c);	329	sys.GET(lpCaption, c);
330	IF c # 0X THEN	330	IF c # 0X THEN
331	OutChar(c)	331	OutChar(c)
332	END;	332	END;
333	INC(lpCaption)	333	INC(lpCaption)
334	UNTIL c = 0X;	334	UNTIL c = 0X;
335	OutChar(":");	335	OutChar(":");
336	OutChar(0DX);	336	OutChar(0DX);
337	OutChar(0AX)	337	OutChar(0AX)
338	END;	338	END;
339	REPEAT	339	REPEAT
340	sys.GET(lpText, c);	340	sys.GET(lpText, c);
341	IF c # 0X THEN	341	IF c # 0X THEN
342	OutChar(c)	342	OutChar(c)
343	END;	343	END;
344	INC(lpText)	344	INC(lpText)
345	UNTIL c = 0X;	345	UNTIL c = 0X;
346	IF lpCaption # 0 THEN	346	IF lpCaption # 0 THEN
347	OutChar(0DX);	347	OutChar(0DX);
348	OutChar(0AX)	348	OutChar(0AX)
349	END	349	END
350	END DebugMsg;	350	END DebugMsg;
351		351
352		352
353	PROCEDURE init* (p1: INTEGER);	353	PROCEDURE init* (p1: INTEGER);
354	BEGIN	354	BEGIN
355	p1 := sysfunc2(68, 11);	355	p1 := sysfunc2(68, 11);
356	InitializeCriticalSection(CriticalSection)	356	InitializeCriticalSection(CriticalSection)
357	END init;	357	END init;
358		358
359		359
360	END API.	360	END API.

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/Lib/KolibriOS/API.ob07 – Rev 7110 → 7209