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

 

CONST
 
    MAX_SIZE  = 16 * 400H;
    HEAP_SIZE =  1 * 100000H;
 

    _new = 1;
    _dispose = 2;

 

 
 
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

        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;
 

    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;

    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;

            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 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

    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;

Rev 7110	Rev 7209
Line 1...	Line 1...
1	(*	1	(*
2	Copyright 2016, 2017 Anton Krotov	2	Copyright 2016, 2017, 2018 Anton Krotov
Line 3...	Line 3...
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
Line 22...	Line 22...
22		22
Line 23...	Line 23...
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
Line 28...	Line 28...
28	_new = 1;	28	_new = 1;
29	_dispose = 2;	29	_dispose = 2;
Line 30...	Line 30...
30		30
Line 43...	Line 43...
43		43
44		44
45	PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);	45	PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);
46	BEGIN	46	BEGIN
Line 47...	Line 47...
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
Line 55...	Line 55...
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
Line 74...	Line 74...
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;
Line 80...	Line 80...
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 *)
Line 88...	Line 88...
88	RETURN 0	88	RETURN 0
89	END sysfunc1;	89	END sysfunc1;
90		90
Line 97...	Line 97...
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;
Line 103...	Line 103...
103		103
104		104
105	PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;	105	PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;
Line 126...	Line 126...
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;
Line 132...	Line 132...
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;
Line 245...	Line 245...
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;
Line 272...	Line 272...
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;
Line 277...	Line 277...
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)
Line 282...	Line 282...
282	ELSIF func = _dispose THEN	282	ELSIF func = _dispose THEN
283	res := __DISPOSE(arg)	283	res := __DISPOSE(arg)
284	END;	284	END;
Line 285...	Line 285...
285		285
286	LeaveCriticalSection(CriticalSection)	286	LeaveCriticalSection(CriticalSection)
287	RETURN res	287	RETURN res
288	END NEW_DISPOSE;	288	END NEW_DISPOSE;
Line 289...	Line 289...
289		289
290		290
291	PROCEDURE _NEW* (size: INTEGER): INTEGER;	291	PROCEDURE _NEW* (size: INTEGER): INTEGER;
Line 292...	Line 292...
292	RETURN NEW_DISPOSE(_new, size)	292	RETURN NEW_DISPOSE(_new, size)
293	END _NEW;	293	END _NEW;
294		294
295		295
Line 296...	Line 296...
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
Line 300...	Line 300...
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
Line 306...	Line 306...
306		306
307	PROCEDURE ExitThread* (p1: INTEGER);	307	PROCEDURE ExitThread* (p1: INTEGER);
308	BEGIN	308	BEGIN
Line 345...	Line 345...
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;
Line 351...	Line 351...
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);
Line 356...	Line 356...
356	InitializeCriticalSection(CriticalSection)	356	InitializeCriticalSection(CriticalSection)
357	END init;	357	END init;

Subversion Repositories Kolibri OS

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