home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / 001-010 / amok07 / stack / stack.mod < prev    next >
Encoding:
Modula Implementation  |  1993-11-04  |  2.3 KB  |  78 lines
  1. (*********************************************************************
  2.  *                                                                   *
  3.  *  :Program.    Stack.mod                                           *
  4.  *  :Author.     Michael Frieß                                       *
  5.  *  :Address.    Kernerstr. 22a                                      *
  6.  *  :shortcut.   [MiF]                                               *
  7.  *  :Version.    1.0                                                 *
  8.  *  :Date.       15.09.88                                            *
  9.  *  :Copyright.  PD                                                  *
  10.  *  :Language.   Modula-II                                           *
  11.  *  :Translator. M2Amiga                                             *
  12.  *  :Imports.    MemSystem (at least V1.0 --> Amok#5)                *
  13.  *  :Contents.   Generic data type: Stack                            *
  14.  *                                                                   *
  15.  *********************************************************************)
  16.  
  17. IMPLEMENTATION MODULE Stack;
  18. (* MODULE Stack: (C) Copyright 1988 by Michael Frieß *)
  19.  
  20. FROM SYSTEM    IMPORT BYTE, ADR, ADDRESS;
  21. FROM MemSystem IMPORT Allocate, Deallocate;
  22. FROM Exec      IMPORT CopyMem;
  23.  
  24. CONST copyright = "MODULE Stack: (C) Copyright 1988 by Michael Frieß";
  25.  
  26. TYPE stack      = POINTER TO element;
  27.      element    = RECORD
  28.                    Data : ADDRESS;
  29.                    Next : stack;
  30.                   END;
  31.  
  32. PROCEDURE Init (VAR s:stack);
  33.  BEGIN
  34.   s := NIL;
  35.  END Init;
  36.  
  37. PROCEDURE Write  (VAR s:stack; Data : ARRAY OF BYTE);
  38.  VAR p : stack;
  39.  BEGIN
  40.   p := s;
  41.   Allocate (s, SIZE(element));
  42.   IF s = NIL THEN HALT END;
  43.   s^.Next := p;
  44.   Allocate (s^.Data, HIGH(Data)+1);
  45.   IF s^.Data = NIL THEN HALT END;
  46.   CopyMem (ADR(Data), s^.Data, HIGH(Data)+1);
  47.  END Write;
  48.  
  49. PROCEDURE Read (VAR s:stack; VAR Data : ARRAY OF BYTE);
  50.  VAR p : stack;
  51.  BEGIN
  52.   IF s # NIL THEN
  53.    CopyMem (s^.Data, ADR(Data), HIGH(Data)+1);
  54.    p := s^.Next;
  55.    Deallocate (s^.Data);
  56.    Deallocate (s);
  57.    s := p
  58.   END
  59.  END Read;
  60.  
  61. PROCEDURE Empty (s:stack) : BOOLEAN;
  62.  BEGIN
  63.   RETURN (s = NIL)
  64.  END Empty;
  65.  
  66. PROCEDURE Discard (VAR s:stack);
  67.  VAR p : stack;
  68.  BEGIN
  69.   WHILE s # NIL DO
  70.    p := s^.Next;
  71.    Deallocate (s^.Data);
  72.    Deallocate (s);
  73.    s := p
  74.   END;
  75.  END Discard;
  76.  
  77. END Stack.
  78.