void *memory = kernel_alloc(sizeof(some_object));

MODULE SimpleMemAllocator;

   TYPE
      Object* = POINTER TO RECORD
         data*: INTEGER; (* здесь должны быть реальные данные *)
      END;
   
      MemBlock* = POINTER TO RECORD
         count: INTEGER;
         stack: POINTER TO ARRAY OF Object;
      END;
      
   PROCEDURE (me: MemBlock) Alloc* (): Object, NEW;
      VAR p: Object;
   BEGIN
      IF me.count > 0 THEN
         DEC(me.count);
         p := me.stack[me.count];
      END;
      (* если p = NIL, то здесь можно увеличить размер me.stack *)
      RETURN p
   END Alloc;
   
   PROCEDURE (me: MemBlock) Free* (p: Object), NEW;
   BEGIN
      IF me.count < LEN(me.stack) THEN
         me.stack[me.count] := p;
         INC(me.count)
      END
   END Free;
   
   PROCEDURE NewMemBlock* (size: INTEGER): MemBlock;
      VAR mem: MemBlock; i: INTEGER;
   BEGIN
      ASSERT(size > 0);
      NEW(mem); NEW(mem.stack, size);
      mem.count := 0;
      FOR i := 0 TO size-1 DO NEW(mem.stack[i]) END;
      RETURN mem;
   END NewMemBlock;
      
END SimpleMemAllocator.

MODULE Heap;

   IMPORT S := SYSTEM, Log;
   
   CONST memsize = 1024;
   
   TYPE
      REC* = EXTENSIBLE RECORD [untagged] END;
      
   VAR mem: ARRAY 1024 OF BYTE;
      allocated: INTEGER;
   
   PROCEDURE Alloc* (size: INTEGER): S.PTR;
      VAR ptr: S.PTR;
   BEGIN
      IF allocated + size > memsize THEN RETURN NIL END;
      ptr := S.VAL(S.PTR, S.ADR(mem[allocated]));
      allocated := allocated + size;
      RETURN ptr
   END Alloc;
   
   PROCEDURE PrintPtr* (p: S.PTR);
   BEGIN
      Log.IntForm(S.VAL(INTEGER, p), 16, 8, '0', FALSE);
      Log.String(" from byte array ");
      Log.IntForm(S.ADR(mem[0]), 16, 8, '0', FALSE);
      Log.Ln
   END PrintPtr;

BEGIN
   allocated := 0;
END Heap.

MODULE HeapTest;

   IMPORT Heap;
   
   TYPE
      Point = RECORD (Heap.REC)
         x, y: REAL;
      END;
      
      PROCEDURE Do* ; (* (!) HeapTest.Do *)
         VAR p, q: POINTER TO Point;
      BEGIN
         p := Heap.Alloc(SIZE(Point));
         q := Heap.Alloc(SIZE(Point));
         Heap.PrintPtr(p);
         Heap.PrintPtr(q);
         p.x := 0; p.y := 0;
         q.x := 0; q.y := 0;
      END Do;

END HeapTest.