home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / new / util / cdity / cx / txt / listsandnodes.mod < prev   
Text File  |  1994-09-09  |  3KB  |  149 lines
  1. IMPLEMENTATION MODULE ListsAndNodes;
  2.  
  3.    (* NodeSearch.mod - Einzeilige Funktionsbeschreibung
  4.     * Version     : $VER: NodeSearch.mod 0.0 (© 1994 Fin Schuppenhauer)
  5.     * Autor       : Fin Schuppenhauer
  6.     *               Braußpark 10
  7.     *               20537 Hamburg
  8.     *               (Germany)
  9.     * E-Mail      : 1schuppe@rzdspc2.informatik.uni-hamburg.de
  10.     * Erstellt am : 09 Sep 1994
  11.     * Letzte Änd. : 09 Sep 1994
  12.     *)
  13.  
  14. IMPORT
  15.    ed:ExecD,      el:ExecL,
  16.    str:String;
  17.  
  18. FROM SYSTEM IMPORT
  19.    CAST, ADDRESS, ADR;
  20.  
  21. CONST
  22.    EQUAL    = 0;
  23.    LESS     = 1;
  24.    GREATER  = -1;
  25.  
  26. PROCEDURE CompareNodeNames (node1, node2 : ed.NodePtr) : LONGINT;
  27. (** "Vergleicht die Namen zweier Exec-Nodes" *)
  28. BEGIN
  29.    IF node1^.name = NIL THEN
  30.       IF node2^.name = NIL THEN
  31.          RETURN EQUAL;
  32.       ELSE
  33.          RETURN LESS;
  34.       END;
  35.    ELSE
  36.       IF node2^.name = NIL THEN
  37.          RETURN GREATER;
  38.       ELSE
  39.          RETURN str.Compare(CAST(StrPtr, node1^.name)^,
  40.                             CAST(StrPtr, node2^.name)^);
  41.       END;
  42.    END;
  43. END CompareNodeNames;
  44. (* **)
  45.  
  46. PROCEDURE CountNodes (list : ed.ListPtr) : LONGCARD;
  47. (** "Zählt die Anzahl der Nodes einer Liste" *)
  48. VAR
  49.    count : LONGCARD;
  50.    node  : ed.NodePtr;
  51. BEGIN
  52.    count := 0;
  53.    node := list^.head;
  54.  
  55.    WHILE (node # NIL) & (node^.succ # NIL) DO
  56.       INC (count);
  57.       node := node^.succ;
  58.    END;
  59.  
  60.    RETURN count;
  61. END CountNodes;
  62. (* **)
  63.  
  64. PROCEDURE ChangeNodes (list : ed.ListPtr; node1, node2 : ed.NodePtr);
  65. (** "Vertauscht node1 mit node2" *)
  66. VAR
  67.    oldn1pred : ed.NodePtr;
  68.    oldn2pred : ed.NodePtr;
  69.  
  70. BEGIN
  71.    oldn1pred := node1^.pred;
  72.    IF node1^.succ = node2 THEN
  73.       (* Spezialfall !!! *)
  74.       node1^.pred^.succ := node2;
  75.       node2^.succ^.pred := node1;
  76.       node1^.succ := node2^.succ;
  77.       node1^.pred := node2;
  78.       node2^.succ := node1;
  79.       node2^.pred := oldn1pred;
  80.    ELSE
  81.       oldn2pred := node2^.pred;
  82.       el.Remove (node1);
  83.       el.Remove (node2);
  84.       el.Insert (list, node1, oldn2pred);
  85.       el.Insert (list, node2, oldn1pred);
  86.    END;
  87.  
  88. END ChangeNodes;
  89. (* **)
  90.  
  91. PROCEDURE SortExecList (list : ed.ListPtr; max : INTEGER);
  92. (** "Sortiert eine Exec-Liste alphabetisch anhand der node.name's" *)
  93. VAR
  94.    a,b   : INTEGER;
  95.    n     : ed.NodePtr;
  96. BEGIN
  97.    IF max = ALLNODES THEN
  98.       max := CountNodes(list);
  99.    END;
  100.  
  101.    FOR a := max-1 TO 1 BY -1 DO
  102.       n := list^.head;
  103.       FOR b := 1 TO a DO
  104.          IF CompareNodeNames (n, n^.succ) > 0 THEN
  105.             ChangeNodes (list, n, n^.succ);
  106.             n := n^.pred;
  107.          END;
  108.          n := n^.succ;
  109.       END;
  110.    END;
  111.  
  112. END SortExecList;
  113. (* **)
  114.  
  115. PROCEDURE Enumerate (list : ed.ListPtr; enumProc : EnumerateProcedure);
  116. (** "Prozedur enumProc auf jede Node anwenden" *)
  117. VAR
  118.    node  : ed.NodePtr;
  119. BEGIN
  120.    node := list^.head;
  121.  
  122.    WHILE (node # NIL) & (node^.succ # NIL) DO
  123.       enumProc (node);
  124.       node := node^.succ;
  125.    END;
  126. END Enumerate;
  127. (* **)
  128.  
  129. PROCEDURE FreeAllNodes (list : ed.ListPtr; nodesize : CARDINAL);
  130. (** "Belegten Speicher aller Nodes einer Liste freigeben" *)
  131. VAR
  132.    worknode, node : ed.NodePtr;
  133. BEGIN
  134.    node := list^.head;
  135.  
  136.    WHILE (node # NIL) & (node^.succ # NIL) DO
  137.       worknode := node;
  138.       node := node^.succ;
  139.       el.FreeMem (worknode, nodesize);
  140.    END;
  141.  
  142.    list^.head := NIL;
  143.    list^.tailPred := NIL;
  144. END FreeAllNodes;
  145. (* **)
  146.  
  147. BEGIN (* main *)
  148. END ListsAndNodes.
  149.