MODULE KnyshStack;
 
IMPORT StdLog;
 
CONST
	sizeStack* = 100;
	numberOfLetter* = 256;
TYPE
	myKey*= ARRAY numberOfLetter OF CHAR;
	pListItem* = POINTER TO RECORD
		key: myKey;
		next: pListItem;
	END;	
 
VAR
	myListItem, firstItem: pListItem;
	numberItemsOfStack-: INTEGER;
 
PROCEDURE (self: pListItem) AddTheItem* (add: ARRAY OF CHAR): BOOLEAN, NEW;(*добавить элемент*)
BEGIN
	IF LEN(add) > numberOfLetter THEN
		StdLog.String ("Количество букв в слове не должно превышать");
		StdLog.Int (numberOfLetter);
		RETURN FALSE
	ELSIF add$ = "" THEN
		StdLog.String ("Слово не должно быть пустым.");
		RETURN FALSE
	ELSE
		IF numberItemsOfStack = sizeStack THEN
			StdLog.String ("Достигнуто максимальное количество элементов в стеке.");
			RETURN FALSE
		ELSE
			INC(numberItemsOfStack);
			IF firstItem = NIL THEN
				NEW (myListItem);
				myListItem.key := add$;
				firstItem := myListItem
			ELSE
				NEW (myListItem.next);
				myListItem.next.key := add$;
				myListItem.next.next := firstItem;
				firstItem := myListItem.next;
				myListItem.next := NIL;
			END;
			RETURN TRUE;
		END;
		RETURN TRUE
	END
END AddTheItem;
 
PROCEDURE (self: pListItem) ExtractTheItem* (OUT str:myKey), NEW;(*извлечь элемент*)
BEGIN
	IF firstItem # NIL THEN
		DEC(numberItemsOfStack);
		str := firstItem.key;
		firstItem:= firstItem.next
	ELSE
		StdLog.String ("Стек пуст - извлекать нечего.");
	END
END ExtractTheItem;
 
PROCEDURE (self: pListItem) ClearList*, NEW;(*очистить стек*)
BEGIN
	myListItem := NIL;
	firstItem := NIL;
	numberItemsOfStack := 0
END ClearList;
 
BEGIN
	numberItemsOfStack := 0;
END KnyshStack.

MODULE KnyshExamplesStack;
 
IMPORT KnyshStack, StdLog;
 
PROCEDURE a*;(**)
VAR 
	obj1, obj2: KnyshStack.pListItem;
	f: BOOLEAN;
	letter: KnyshStack.myKey;
BEGIN
	NEW(obj1);
	NEW(obj2);
	f := obj1.AddTheItem ("Вася");
	f := obj1.AddTheItem ("Катя");
	f := obj1.AddTheItem ("Юля");
	f := obj1.AddTheItem ("Саша");
	f := obj2.AddTheItem ("Лена");
 
	obj1.ExtractTheItem(letter);
	StdLog.String (letter)
END a;
 
END KnyshExamplesStack.

MODULE MyStacks;
 
  TYPE
     String* = ARRAY 256 OF CHAR;
 
     Item = POINTER TO RECORD
       val: String;
       next: Item;
     END;
 
     Stack* = POINTER TO RECORD
        item: Item;
        count: INTEGER
     END;
 
  PROCEDURE (s: Stack) Push* (IN str: String), NEW;
    VAR i: Item;
  BEGIN
    NEW(i); i.val := str$; i.next := s.item; s.item := i;
    INC(s.count)
  END Push;
 
  PROCEDURE (s: Stack) Pop* (OUT str: String), NEW;
  BEGIN
    ASSERT(s.item # NIL, 60); (* Стек пуст *)
    str := s.item.val$;
    s.item := s.item.next;
    DEC(s.count)
  END Pop;
 
  PROCEDURE (s: Stack) Count* (): INTEGER, NEW;
  BEGIN
    RETURN s.count
  END Count;
 
  PROCEDURE (s: Stack) Clear*, NEW;
  BEGIN
    s.item := NIL; s.count := 0
  END Clear;
 
END MyStacks.

MODULE MyTest;
 
  IMPORT MyStacks, Log;
 
  PROCEDURE Do*;
    VAR s1, s2: MyStacks.Stack; str: MyStacks.String;
  BEGIN
    NEW(s1); NEW(s2);
    s1.Push("Вася");
    s1.Push("Катя");
    s1.Push("Юля");
    s1.Push("Саша");
    s2.Push("Лена");
 
    s1.Pop(str);
    ASSERT(str = "Саша", 100); (* Если не трапает, значит всё работает как задумано *)
    Log.String(str); Log.Ln;
  END Do;
 
END MyTest.

IF firstItem = NIL THEN
	NEW (myListItem);
	myListItem.key := add$;
	firstItem := myListItem
ELSE
	NEW (myListItem.next);
	myListItem.next.key := add$;
	myListItem.next.next := firstItem;
	firstItem := myListItem.next;
	myListItem.next := NIL;
END;

  NEW(i); i.val := str$; i.next := s.item; s.item := i