home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / dev / obero / oberon-a / source / amiga / execsupport.mod < prev    next >
Encoding:
Text File  |  1995-06-29  |  6.7 KB  |  267 lines
  1. (*************************************************************************
  2.  
  3.      $RCSfile: ExecSupport.mod $
  4.   Description: Support for clients of exec.library
  5.  
  6.    Created by: fjc (Frank Copeland)
  7.     $Revision: 3.5 $
  8.       $Author: fjc $
  9.         $Date: 1995/06/04 23:13:14 $
  10.  
  11.   Copyright © 1994-1995, Frank Copeland.
  12.   This file is part of the Oberon-A Library.
  13.   See Oberon-A.doc for conditions of use and distribution.
  14.  
  15. *************************************************************************)
  16.  
  17. <* STANDARD- *>
  18.  
  19. MODULE ExecSupport;
  20.  
  21. IMPORT SYS := SYSTEM, Kernel, e := Exec, s := Sets;
  22.  
  23. (*--------------------------------------------------------------------*)
  24. (*
  25.   Exec List handling procedures
  26. *)
  27.  
  28. (*------------------------------------*)
  29. PROCEDURE NewMinList*(VAR list: e.MinList);
  30. (*
  31.  * obsolete -- use NewList() instead!
  32.  *)
  33. BEGIN
  34.   list.head := SYS.ADR(list.tail);
  35.   list.tail := NIL;
  36.   list.tailPred := SYS.ADR(list.head);
  37. END NewMinList;
  38.  
  39.  
  40. (*------------------------------------*)
  41. PROCEDURE MinListEmpty*(VAR list : e.MinList): BOOLEAN;
  42. (*
  43.  * obsolete -- use ListEmpty() instead!
  44.  *)
  45. BEGIN
  46.   RETURN list.tailPred = SYS.ADR(list);
  47. END MinListEmpty;
  48.  
  49.  
  50. (*------------------------------------*)
  51. PROCEDURE NewList* (VAR list : e.CommonList);
  52. BEGIN (* NewList *)
  53.   NewMinList (SYS.VAL (e.MinList, list))
  54. END NewList;
  55.  
  56.  
  57. (*------------------------------------*)
  58. PROCEDURE ListEmpty*(VAR list : e.CommonList): BOOLEAN;
  59. BEGIN
  60.   RETURN MinListEmpty (SYS.VAL (e.MinList, list))
  61. END ListEmpty;
  62.  
  63.  
  64. (*--------------------------------------------------------------------*)
  65. (*
  66.   Exec MessagePort procedures.
  67. *)
  68.  
  69.  
  70. (*------------------------------------*)
  71. PROCEDURE IsMsgPortEmpty * (x : e.MsgPortBasePtr) : BOOLEAN;
  72.   VAR mp : e.MsgPortPtr;
  73. BEGIN
  74.   mp := SYS.VAL (e.MsgPortPtr, x);
  75.   RETURN mp.msgList.tailPred = SYS.VAL (e.NodePtr, mp);
  76. END IsMsgPortEmpty;
  77.  
  78.  
  79. (*------------------------------------*)
  80. <*$CopyArrays-*>
  81. PROCEDURE CreatePort * (portName : ARRAY OF CHAR; priority : SHORTINT)
  82.   : e.MsgPortPtr;
  83.  
  84.   VAR sigBit : SHORTINT; mp : e.MsgPortPtr; name : e.LSTRPTR;
  85.  
  86. BEGIN (* CreatePort *)
  87.   sigBit := e.AllocSignal (-1);
  88.   IF sigBit = -1 THEN RETURN NIL END;
  89.  
  90.   Kernel.Allocate (mp, SIZE (e.MsgPort), {e.public, e.memClear});
  91.   IF mp = NIL THEN e.FreeSignal (sigBit); RETURN NIL END;
  92.  
  93.   IF portName = "" THEN name := NIL ELSE name := SYS.ADR (portName) END;
  94.   mp.node.name := name;
  95.   mp.node.pri := priority;
  96.   mp.node.type := e.msgPort;
  97.   mp.flags := e.signal;
  98.   mp.sigBit := sigBit;
  99.   mp.sigTask := e.FindTask (e.NILSTR); (* Find THIS task. *)
  100.  
  101.   IF name # NIL THEN e.AddPort (mp)
  102.   ELSE NewList (mp.msgList)
  103.   END;
  104.  
  105.   RETURN mp
  106. END CreatePort;
  107.  
  108. (*------------------------------------*)
  109. PROCEDURE DeletePort * (mp : e.MsgPortPtr);
  110.  
  111. BEGIN (* DeletePort *)
  112.   IF mp = NIL THEN RETURN END;
  113.  
  114.   (* if it was public ... *)
  115.   IF mp.node.name # NIL THEN e.RemPort (mp) END;
  116.  
  117.   (* make it difficult to re-use the port *)
  118.   mp.sigTask := SYS.VAL (e.TaskPtr, -1);
  119.   mp.msgList.head := SYS.VAL (e.NodePtr, -1);
  120.  
  121.   e.FreeSignal (mp.sigBit);
  122.   SYS.DISPOSE (mp)
  123. END DeletePort;
  124.  
  125. (*--------------------------------------------------------------------*)
  126. (*
  127.   Exec IO procedures.
  128. *)
  129.  
  130.  
  131. (*------------------------------------*)
  132. PROCEDURE BeginIO * ( ioReq : e.IORequestBasePtr );
  133.  
  134. BEGIN (* BeginIO *)
  135.   SYS.PUTREG (9, ioReq); (* MOVE.L  ioReq(A5), A1 *)
  136.   SYS.INLINE (
  137.     2C69H, 20,           (* MOVE.L  20(A1), A6    *)
  138.     4EAEH, -001EH )      (* JSR     FFE2(A6)      *)
  139. END BeginIO;
  140.  
  141.  
  142. (*------------------------------------*)
  143. PROCEDURE AbortIO* ( ioReq : e.IORequestBasePtr );
  144. (*
  145.  * obsolete -- prefer to use Exec.AbortIO
  146.  *)
  147. BEGIN
  148.   SYS.PUTREG (9, ioReq); (* MOVE.L  ioReq(A5), A1 *)
  149.   SYS.INLINE (
  150.     2C69H, 20   ,        (* MOVE.L  20(A1), A6    *)
  151.     4EAEH, -36 )         (* JSR     -36(A6)       *)
  152. END AbortIO;
  153.  
  154.  
  155. (*------------------------------------*)
  156. PROCEDURE CreateExtIO *
  157.   ( port   : e.MsgPortPtr;
  158.     ioSize : INTEGER )
  159.   : e.APTR;
  160.  
  161.   VAR ioReq : e.IORequestPtr;
  162.  
  163. BEGIN (* CreateExtIO *)
  164.   IF port = NIL THEN RETURN NIL END;
  165.   Kernel.Allocate (ioReq, ioSize, {e.public, e.memClear});
  166.   IF ioReq # NIL THEN
  167.     ioReq.message.node.type := e.replyMsg;
  168.     ioReq.message.length := ioSize;
  169.     ioReq.message.replyPort := port
  170.   END;
  171.   RETURN ioReq
  172. END CreateExtIO;
  173.  
  174. (*------------------------------------*)
  175. PROCEDURE DeleteExtIO ( ioReq : e.APTR );
  176.  
  177.   VAR req : e.IORequestPtr;
  178.  
  179. BEGIN (* DeleteExtIO *)
  180.   IF ioReq # NIL THEN
  181.     req := ioReq;
  182.     req.message.node.succ := SYS.VAL (e.NodePtr, -1);
  183.     req.message.replyPort := SYS.VAL (e.MsgPortPtr, -1);
  184.     SYS.DISPOSE (req)
  185.   END
  186. END DeleteExtIO;
  187.  
  188. (*------------------------------------*)
  189. PROCEDURE CreateStdIO* ( port : e.MsgPortPtr ) : e.IOStdReqPtr;
  190.  
  191. BEGIN (* CreateStdIO *)
  192.   RETURN CreateExtIO (port, SIZE (e.IOStdReq))
  193. END CreateStdIO;
  194.  
  195. (*------------------------------------*)
  196. PROCEDURE DeleteStdIO* ( ioReq : e.IOStdReqPtr );
  197.  
  198. BEGIN (* DeleteStdIO *)
  199.   DeleteExtIO (ioReq)
  200. END DeleteStdIO;
  201.  
  202. (*------------------------------------*)
  203. PROCEDURE CreateTask *
  204.   ( name      : ARRAY OF CHAR;
  205.     pri       : SHORTINT;
  206.     initPC    : e.PROC;
  207.     stackSize : e.ULONG )
  208.   : e.TaskPtr;
  209.  
  210.   VAR
  211.     taskMemList : RECORD [2] (e.Node)
  212.       numEntries : INTEGER;
  213.       entries : ARRAY 3 OF RECORD [2]
  214.         reqs : s.SET32;
  215.         size : LONGINT;
  216.       END;
  217.     END;
  218.     memList : POINTER [2] TO RECORD [2] (e.MemList)
  219.       entries : ARRAY 3 OF e.MemEntry;
  220.     END;
  221.     newTask : e.TaskPtr;
  222.     userData : Kernel.UserDataPtr;
  223.  
  224. BEGIN (* CreateTask *)
  225.   stackSize := SYS.AND (stackSize + 3, 0FFFFFFFCH);
  226.   taskMemList.type := e.unknown;
  227.   taskMemList.pri := 0;
  228.   taskMemList.name := NIL;
  229.   taskMemList.numEntries := 2;
  230.   taskMemList.entries[0].reqs := {e.public, e.memClear};
  231.   taskMemList.entries[0].size := SIZE (e.Task);
  232.   taskMemList.entries[1].reqs := {e.memClear};
  233.   taskMemList.entries[1].size := stackSize;
  234.   taskMemList.entries[2].reqs := {e.memClear};
  235.   taskMemList.entries[2].size := SIZE (Kernel.UserData);
  236.   memList := e.AllocEntry (SYS.ADR (taskMemList));
  237.   IF 31 IN SYS.VAL (SET, memList) THEN RETURN NIL END;
  238.  
  239.   newTask := memList.entries[0].addr;
  240.   newTask.node.type := e.task;
  241.   newTask.node.pri := pri;
  242.   newTask.node.name := SYS.ADR (name);
  243.   newTask.spLower := memList.entries[1].addr;
  244.   newTask.spUpper :=
  245.     SYS.VAL (e.APTR, SYS.VAL (LONGINT, newTask.spLower) + stackSize);
  246.   newTask.spReg := newTask.spUpper;
  247.   userData := memList.entries[2].addr;
  248. <* IF SMALLDATA OR RESIDENT THEN *>
  249.   SYS.GETREG (12, userData.dataSegment);
  250. <* END *>
  251.   newTask.userData := userData;
  252.  
  253.   NewList (newTask.memEntry);
  254.   e.AddHead (newTask.memEntry, memList);
  255.   e.AddTask (newTask, initPC, NIL);
  256.   RETURN newTask
  257. END CreateTask;
  258.  
  259. (*------------------------------------*)
  260. PROCEDURE DeleteTask * ( task : e.TaskPtr );
  261.  
  262. BEGIN (* DeleteTask *)
  263.   e.RemTask (task)
  264. END DeleteTask;
  265.  
  266. END ExecSupport.
  267.