home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Misc / OB3.2D2.DMS / in.adf / Module / UntracedLists.mod < prev    next >
Encoding:
Text File  |  1994-08-05  |  4.2 KB  |  218 lines
  1. (*-------------------------------------------------------------------------*)
  2. (*                                                                         *)
  3. (*  Amiga Oberon Library Module: UntracedLists        Date: 02-Nov-92      *)
  4. (*                                                                         *)
  5. (*   © 1992 by Fridtjof Siebert                                            *)
  6. (*                                                                         *)
  7. (*-------------------------------------------------------------------------*)
  8.  
  9. MODULE UntracedLists;
  10.  
  11. IMPORT BasicTypes;
  12.  
  13. TYPE
  14.   NodePtr* = UNTRACED POINTER TO Node;
  15.   Node* = RECORD (BasicTypes.ANYDesc)
  16.     next-: NodePtr;
  17.     prev-: NodePtr;
  18.   END;
  19.  
  20.   ListPtr * = UNTRACED POINTER TO List;
  21.   List* = RECORD (BasicTypes.ANYDesc)
  22.     head-: NodePtr;
  23.     tail-: NodePtr;
  24.     remallowed: INTEGER;
  25.     numElements: LONGINT;
  26.   END;
  27.  
  28.   UANY * = UNTRACED POINTER TO BasicTypes.ANYDesc;
  29.  
  30.   DoProc * = PROCEDURE(n: NodePtr);
  31.  
  32. (* Die DoProc darf Remove(), RemHead() und RemTail() nicht benutzen. *)
  33.  
  34.  
  35. PROCEDURE Init*(VAR list: List);
  36. BEGIN
  37.   list.head := NIL;
  38.   list.tail := NIL;
  39.   list.remallowed := 0;
  40.   list.numElements := 0;
  41. END Init;
  42.  
  43.  
  44. PROCEDURE AddHead*(VAR list: List; n: NodePtr);
  45. BEGIN
  46.   n.next := list.head;
  47.   n.prev := NIL;
  48.   IF n.next=NIL THEN list.tail   := n;
  49.                 ELSE n.next.prev := n END;
  50.   list.head := n;
  51.   INC(list.numElements);
  52. END AddHead;
  53.  
  54.  
  55. PROCEDURE AddTail*(VAR list: List; n: NodePtr);
  56. BEGIN
  57.   n.prev := list.tail;
  58.   n.next := NIL;
  59.   IF n.prev=NIL THEN list.head   := n;
  60.                 ELSE n.prev.next := n END;
  61.   list.tail := n;
  62.   INC(list.numElements);
  63. END AddTail;
  64.  
  65.  
  66. PROCEDURE Remove*(VAR list: List; n: NodePtr);
  67. BEGIN
  68.   IF n#NIL THEN
  69.     IF list.remallowed # 0 THEN HALT(20) END;
  70.     IF n.next#NIL THEN n.next.prev := n.prev ELSE list.tail := n.prev END;
  71.     IF n.prev#NIL THEN n.prev.next := n.next ELSE list.head := n.next END;
  72.     DEC(list.numElements);
  73.   END;
  74. END Remove;
  75.  
  76.  
  77. PROCEDURE RemHead*(VAR list: List): NodePtr;
  78. VAR n: NodePtr;
  79. BEGIN
  80.   n := list.head; Remove(list,n); RETURN n;
  81. END RemHead;
  82.  
  83.  
  84. PROCEDURE RemTail*(VAR list: List): NodePtr;
  85. VAR n: NodePtr;
  86. BEGIN
  87.   n := list.tail; Remove(list,n); RETURN n;
  88. END RemTail;
  89.  
  90.  
  91. PROCEDURE AddBefore*(VAR list: List;
  92.                          n,x: NodePtr);
  93. (* fügt n vor x in die Liste ein *)
  94.  
  95. BEGIN
  96.   n.prev := x.prev;
  97.   n.next := x;
  98.   x .prev := n;
  99.   IF n.prev=NIL THEN list.head   := n
  100.                 ELSE n.prev.next := n END;
  101.   INC(list.numElements);
  102. END AddBefore;
  103.  
  104.  
  105. PROCEDURE AddBehind*(VAR list: List;
  106.                          n,x: NodePtr);
  107. (* fügt n hinter x in die Liste ein *)
  108.  
  109. BEGIN
  110.   n.next := x.next;
  111.   n.prev := x;
  112.   x .next := n;
  113.   IF n.next=NIL THEN list.tail   := n
  114.                 ELSE n.next.prev := n END;
  115.   INC(list.numElements);
  116. END AddBehind;
  117.  
  118.  
  119. PROCEDURE Empty*(VAR list: List): BOOLEAN;
  120. BEGIN
  121.   RETURN list.numElements=0
  122. END Empty;
  123.  
  124.  
  125. PROCEDURE CountElements*(VAR list: List): LONGINT;
  126. BEGIN
  127.   RETURN list.numElements;
  128. END CountElements;
  129.  
  130.  
  131. PROCEDURE DoForward*(VAR list: List; proc: DoProc);
  132. VAR n: NodePtr;
  133. BEGIN
  134.   INC(list.remallowed);
  135.   n := list.head; WHILE n#NIL DO proc(n); n := n.next END;
  136.   DEC(list.remallowed);
  137. END DoForward;
  138.  
  139.  
  140. PROCEDURE DoBackward*(VAR list: List; proc: DoProc);
  141. VAR n: NodePtr;
  142. BEGIN
  143.   INC(list.remallowed);
  144.   n := list.tail; WHILE n#NIL DO proc(n); n := n.prev END;
  145.   DEC(list.remallowed);
  146. END DoBackward;
  147.  
  148.  
  149. PROCEDURE Next*(VAR n: NodePtr): BOOLEAN;
  150. BEGIN
  151.   n := n.next;
  152.   RETURN n#NIL;
  153. END Next;
  154.  
  155.  
  156. PROCEDURE Previous*(VAR n: NodePtr): BOOLEAN;
  157. BEGIN
  158.   n := n.prev;
  159.   RETURN n#NIL;
  160. END Previous;
  161.  
  162.  
  163. PROCEDURE Succ*(VAR n: NodePtr);
  164. BEGIN
  165.   n := n.next;
  166. END Succ;
  167.  
  168.  
  169. PROCEDURE Pred*(VAR n: NodePtr);
  170. BEGIN
  171.   n := n.prev;
  172. END Pred;
  173.  
  174.  
  175. PROCEDURE Head*(VAR list: List): NodePtr;
  176. BEGIN
  177.   RETURN list.head;
  178. END Head;
  179.  
  180.  
  181. PROCEDURE Tail*(VAR list: List): NodePtr;
  182. BEGIN
  183.   RETURN list.tail;
  184. END Tail;
  185.  
  186.  
  187. PROCEDURE (list: ListPtr) Add        * (x: UANY);  
  188. (*
  189.  * Adds x to the tail of list.
  190.  *)
  191. BEGIN
  192.   AddTail(list^,x(Node));
  193. END Add;
  194.  
  195.  
  196. PROCEDURE (list: ListPtr) Remove     * (x: UANY);
  197. (* removes x from list.
  198.  *)
  199. BEGIN
  200.   Remove(list^,x(Node));
  201. END Remove;
  202.  
  203.  
  204. PROCEDURE (list: ListPtr) nbElements * (): LONGINT;
  205. (* returns the number of elements within list.
  206.  *)
  207. BEGIN
  208.   RETURN list.numElements
  209. END nbElements;
  210.  
  211. END UntracedLists.
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.