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

 (*
     Copyright 2016, 2017 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
-  MAX_SIZE  = 16 * 400H;
+    CRITICAL_SECTION = ARRAY 2 OF INTEGER;
   HEAP_SIZE =  1 * 100000H;
 VAR
-  heap, endheap: INTEGER;
+    heap, endheap: INTEGER;
+    pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER;
+    CriticalSection: CRITICAL_SECTION;
-  pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER;
-PROCEDURE [stdcall] zeromem*(size, adr: INTEGER);
+PROCEDURE [stdcall] zeromem* (size, adr: INTEGER);
 BEGIN
+    sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")
-  sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F")
+END zeromem;
-END zeromem;
 PROCEDURE mem_commit* (adr, size: INTEGER);
-PROCEDURE mem_commit*(adr, size: INTEGER);
+VAR
-VAR tmp: INTEGER;
+    tmp: INTEGER;
 BEGIN
-  FOR tmp := adr TO adr + size - 1 BY 4096 DO
+    FOR tmp := adr TO adr + size - 1 BY 4096 DO
+        sys.PUT(tmp, 0)
-    sys.PUT(tmp, 0)
+    END
+END mem_commit;
-  END
-END mem_commit;
+PROCEDURE strncmp* (a, b, n: INTEGER): INTEGER;
+VAR
-PROCEDURE strncmp*(a, b, n: INTEGER): INTEGER;
+    A, B: CHAR;
-VAR A, B: CHAR; Res: INTEGER;
+    Res: INTEGER;
 BEGIN
-  Res := 0;
+    Res := 0;
-  WHILE n > 0 DO
+    WHILE n > 0 DO
-    sys.GET(a, A); INC(a);
+        sys.GET(a, A); INC(a);
-    sys.GET(b, B); INC(b);
+        sys.GET(b, B); INC(b);
-    DEC(n);
+        DEC(n);
-    IF A # B THEN
+        IF A # B THEN
+            Res := ORD(A) - ORD(B);
-      Res := ORD(A) - ORD(B);
+            n := 0
-      n := 0
-    ELSIF A = 0X THEN
+        ELSIF A = 0X THEN
-      n := 0
+            n := 0
+        END
     END
-  END
+    RETURN Res
-  RETURN Res
+END strncmp;
-END strncmp;
-PROCEDURE [stdcall] sysfunc1*(arg1: INTEGER): INTEGER;
+PROCEDURE [stdcall] sysfunc1* (arg1: INTEGER): INTEGER;
 BEGIN
-  sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
+    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
-  sys.CODE("CD40");             (* int     40h              *)
+    sys.CODE("CD40");             (* int     40h              *)
+    sys.CODE("C9");               (* leave                    *)
-  sys.CODE("C9");               (* leave                    *)
+    sys.CODE("C20400");           (* ret     04h              *)
-  sys.CODE("C20400");           (* ret     04h              *)
+    RETURN 0
-  RETURN 0
+END sysfunc1;
-END sysfunc1;
-PROCEDURE [stdcall] sysfunc2*(arg1, arg2: INTEGER): INTEGER;
+PROCEDURE [stdcall] sysfunc2* (arg1, arg2: INTEGER): INTEGER;
 BEGIN
-  sys.CODE("53");               (* push    ebx              *)
+    sys.CODE("53");               (* push    ebx              *)
-  sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
+    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
-  sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
+    sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
-  sys.CODE("CD40");             (* int     40h              *)
+    sys.CODE("CD40");             (* int     40h              *)
-  sys.CODE("5B");               (* pop     ebx              *)
+    sys.CODE("5B");               (* pop     ebx              *)
+    sys.CODE("C9");               (* leave                    *)
-  sys.CODE("C9");               (* leave                    *)
+    sys.CODE("C20800");           (* ret     08h              *)
-  sys.CODE("C20800");           (* ret     08h              *)
+    RETURN 0
-  RETURN 0
+END sysfunc2;
-END sysfunc2;
-PROCEDURE [stdcall] sysfunc3*(arg1, arg2, arg3: INTEGER): INTEGER;
+PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER;
 BEGIN
-  sys.CODE("53");               (* push    ebx              *)
+    sys.CODE("53");               (* push    ebx              *)
-  sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
+    sys.CODE("8B4508");           (* mov     eax, [ebp + 08h] *)
-  sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
+    sys.CODE("8B5D0C");           (* mov     ebx, [ebp + 0Ch] *)
-  sys.CODE("8B4D10");           (* mov     ecx, [ebp + 10h] *)
+    sys.CODE("8B4D10");           (* mov     ecx, [ebp + 10h] *)
-  sys.CODE("CD40");             (* int     40h              *)
+    sys.CODE("CD40");             (* int     40h              *)
-  sys.CODE("5B");               (* pop     ebx              *)
+    sys.CODE("5B");               (* pop     ebx              *)
+    sys.CODE("C9");               (* leave                    *)
-  sys.CODE("C9");               (* leave                    *)
+    sys.CODE("C20C00");           (* ret     0Ch              *)
-  sys.CODE("C20C00");           (* ret     0Ch              *)
-  RETURN 0
+    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 sysfunc3;
+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)
-PROCEDURE _NEW*(size: INTEGER): INTEGER;
+END futex_create;
+PROCEDURE futex_wait (futex, value, timeout: INTEGER);
+VAR
+    res: INTEGER;
+BEGIN
+    res := sysfunc5(77, 2, futex, value, timeout)
-VAR res, idx, temp: INTEGER;
+END futex_wait;
-BEGIN
-  IF size <= MAX_SIZE THEN
+PROCEDURE futex_wake (futex, number: INTEGER);
+VAR
+    res: INTEGER;
+BEGIN
+    res := sysfunc4(77, 3, futex, number)
-    idx := ASR(size, 5);
+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;
-    res := pockets[idx];
+    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
-    IF res # 0 THEN
+END InitializeCriticalSection;
-      sys.GET(res, pockets[idx]);
+PROCEDURE __NEW (size: INTEGER): INTEGER;
+VAR
-      sys.PUT(res, size);
+    res, idx, temp: INTEGER;
-      INC(res, 4)
+BEGIN
+    IF size <= MAX_SIZE THEN
+        idx := ASR(size, 5);
-    ELSE
+        res := pockets[idx];
-      temp := 0;
+        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 heap + size >= endheap THEN
-        IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN
+                IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN
-          temp := sysfunc3(68, 12, HEAP_SIZE)
+                    temp := sysfunc3(68, 12, HEAP_SIZE)
-        ELSE
+                ELSE
-          temp := 0
+                    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);
-        END;
+            IF res # 0 THEN
-        IF temp # 0 THEN
+                mem_commit(res, size);
-          mem_commit(temp, HEAP_SIZE);
+                sys.PUT(res, size);
-          heap := temp;
+                INC(res, 4)
-          endheap := heap + HEAP_SIZE
-        ELSE
-          temp := -1
+            END
-        END
+        ELSE
-      END;
-      IF (heap # 0) & (temp # -1) THEN
-        sys.PUT(heap, size);
-        res := heap + 4;
+            res := 0
+        END
-        heap := heap + size
+    END;
+    IF res # 0 THEN
+        zeromem(ASR(size, 2) - 1, res)
-      ELSE
+    END
+    RETURN res
+END __NEW;
-        res := 0
+PROCEDURE __DISPOSE (ptr: INTEGER): INTEGER;
-      END
+VAR
-    END
+    size, idx: INTEGER;
-  ELSE
+BEGIN
-    IF sysfunc2(18, 16) > ASR(size, 10) THEN
+    DEC(ptr, 4);
-      res := sysfunc3(68, 12, size);
-      IF res # 0 THEN
+    sys.GET(ptr, size);
-        mem_commit(res, size);
+    IF size <= MAX_SIZE THEN
-        sys.PUT(res, size);
+        idx := ASR(size, 5);
+        sys.PUT(ptr, pockets[idx]);
+        pockets[idx] := ptr
+    ELSE
+        size := sysfunc3(68, 13, ptr)
+    END
+    RETURN 0
+END __DISPOSE;
-        INC(res, 4)
+PROCEDURE NEW_DISPOSE (func, arg: INTEGER): INTEGER;
-      END
+VAR
-    ELSE
+    res: INTEGER;
+BEGIN
+    EnterCriticalSection(CriticalSection);
-      res := 0
+    IF func = _new THEN
+        res := __NEW(arg)
-    END
+    ELSIF func = _dispose THEN
+        res := __DISPOSE(arg)
+    END;
+    LeaveCriticalSection(CriticalSection)
+    RETURN res
-  END;
+END NEW_DISPOSE;
-  IF res # 0 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);
+PROCEDURE _NEW* (size: INTEGER): INTEGER;
-  IF size <= MAX_SIZE THEN
-    idx := ASR(size, 5);
-    sys.PUT(ptr, pockets[idx]);
+    RETURN NEW_DISPOSE(_new, size)
+END _NEW;
-    pockets[idx] := ptr
   ELSE
-    size := sysfunc3(68, 13, ptr)
+PROCEDURE _DISPOSE* (ptr: INTEGER): INTEGER;
-  END
+    RETURN NEW_DISPOSE(_dispose, ptr)
+END _DISPOSE;
-  RETURN 0
 END _DISPOSE;
+PROCEDURE ExitProcess* (p1: INTEGER);
-PROCEDURE ExitProcess*(p1: INTEGER);
+BEGIN
+  p1 := sysfunc1(-1)
-BEGIN
+END ExitProcess;
-  p1 := sysfunc1(-1)
-END ExitProcess;
+PROCEDURE ExitThread* (p1: INTEGER);
+BEGIN
-PROCEDURE ExitThread*(p1: INTEGER);
+    p1 := sysfunc1(-1)
+END ExitThread;
-BEGIN
-  p1 := sysfunc1(-1)
+PROCEDURE OutChar (c: CHAR);
-END ExitThread;
+VAR
+    res: INTEGER;
-PROCEDURE OutChar(c: CHAR);
+BEGIN
-VAR res: INTEGER;
+    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
-BEGIN
+            sys.GET(lpCaption, c);
-  res := sysfunc3(63, 1, ORD(c))
+            IF c # 0X THEN
-END OutChar;
+                OutChar(c)
+            END;
-PROCEDURE DebugMsg*(lpText, lpCaption: INTEGER);
+            INC(lpCaption)
-VAR c: CHAR;
+        UNTIL c = 0X;
-BEGIN
+        OutChar(":");
-  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(0DX);
-    OutChar(0AX)
+        OutChar(0AX)
-  END;
+    END;
-  REPEAT
+    REPEAT
-    sys.GET(lpText, c);
+        sys.GET(lpText, c);
+        IF c # 0X THEN
-    IF c # 0X THEN
+            OutChar(c)
-      OutChar(c)
+        END;
-    END;
+        INC(lpText)
-    INC(lpText)
+    UNTIL c = 0X;
-  UNTIL c = 0X;
+    IF lpCaption # 0 THEN
-  IF lpCaption # 0 THEN
+        OutChar(0DX);
-    OutChar(0DX);
+        OutChar(0AX)
-    OutChar(0AX)
+    END
-  END
+END DebugMsg;
 END DebugMsg;
 PROCEDURE init* (p1: INTEGER);
 BEGIN
-  p1 := sysfunc2(68, 11)
+    p1 := sysfunc2(68, 11);
+    InitializeCriticalSection(CriticalSection)
 END init;
 END API.

Subversion Repositories Kolibri OS

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