(* The following code implements stacks (of integers) using linked 
           lists. *)
        
        type
            nodeptr = ^node;
            node = record
                info: integer;
                link: nodeptr
            end;
        
            stack = nodeptr;
        
        procedure Create(var s: stack);
        (* Makes s an empty stack *)
        
            begin
                s := nil
            end;
        
        function Isempty(s: stack): boolean;
        (* Returns true if s is empty *)
        
            begin
                Isempty := s = nil
            end;
        
        procedure Push(i: integer; var s: stack);
        (* Pushes i onto stack s. *)
        
            var
                n: nodeptr;             (* Newly added node *)

            begin
        
                (* Get a node *)
        
                new(n);
        
                (* Load it up *)
        
                n^.info := i;
        
                (* Link it in *)
        
                n^.link := s;
                s := n
        
            end;
                                                               { Stacks p 2 }


        procedure Pop(var s: stack);
        (* Removes and discards top item from s *)
        
            var
                n: nodeptr;                     (* Node being discarded *)
        
            begin
                if s = nil then
                    (* Error *)
                else
                  begin
                    n := s;
                    s := s^.link;
                    dispose(n)
                  end
            end;
        
        function Top(s: stack): integer;
        (* Returns top item on stack s *)
        
            begin
                if s = nil then
                    (* Error *)
                else
                    Top := s^.info
            end;

Copyright ©1999 - Russell C. Bjork