1 FUNCTION_BLOCK STACK_INT

     2   VAR_INPUT PUSH, POP: BOOL R_EDGE; (* Basic stack operations *)

     3             R1 : BOOL ;          (* Over-riding reset *)

     4             IN : INT ;           (* Input to be pushed *)

     5             N  : INT ;           (* Maximum depth after reset *)

     6   END_VAR

     7   VAR_OUTPUT EMPTY : BOOL := 1 ;     (* Stack empty *)

     8              OFLO  : BOOL := 0 ;     (* Stack overflow *)

     9              OUT   : INT  := 0 ;     (* Top of stack data *)

    10   END_VAR

    11   VAR STK : ARRAY[0..127] OF INT; (* Internal stack *)

    12       NI : INT :=128  ;           (* Storage for N upon reset *)

    13       PTR : INT := -1 ;           (* Stack pointer *)

    14   END_VAR

    15     (* Function Block body *)

    16 	LD	R1	(* Dispatch on operations *)

    17 	JMPC	RESET	

    18 	LD	POP	

    19 	ANDN	EMPTY	(* Don't pop empty stack *)

    20 	JMPC	POP_STK	

    21 	LD	PUSH	

    22 	ANDN	OFLO	(* Don't push overflowed stack *)

    23 	JMPC	PUSH_STK	

    24 	RET		(* Return if no operations active *)

    25 RESET:	LD	0	(* Stack reset operations *)

    26 	ST	OFLO	

    27 	LD	1	

    28 	ST   	EMPTY	

    29 	LD	-1	

    30 	ST 	PTR	

    31 	CAL	LIMIT(MN:=1,IN:=N,MX:=128)

    32 	ST	NI	

    33 	JMP	ZRO_OUT	

    34 POP_STK:	LD	0	

    35 	ST	OFLO	(* Popped stack is not overflowing *)

    36 	LD	PTR	

    37 	SUB	1	

    38 	ST	PTR	

    39 	LT	0	(* Empty when PTR < 0 *)

    40 	ST	EMPTY	

    41 	JMPC	ZRO_OUT	

    42 	LD	STK[PTR]	

    43 	JMP	SET_OUT	

    44 PUSH_STK:	LD	0	

    45 	ST	EMPTY	(* Pushed stack is not empty *)

    46 	LD	PTR	

    47 	ADD	1	

    48 	ST	PTR	

    49 	EQ	NI	(* Overflow when PTR = NI *)

    50 	ST	OFLO	

    51 	JMPC	ZRO_OUT	

    52 	LD	IN	

    53 	ST	STK[PTR]	(* Push IN onto STK *)

    54 	JMP	SET_OUT	

    55 ZRO_OUT:	LD	0	(* OUT=0 for EMPTY or OFLO *)

    56 SET_OUT:	ST 	OUT	

    57 

    58   END_FUNCTION_BLOCK