parentheses

;modified POP to store value in R6.
;read comments
;

.ORIG x3000

SPACE		.FILL x0020
NEW_LINE	.FILL x000A
CHAR_RETURN	.FILL x000D
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;if ( push onto stack if ) pop from stack and check if popped value is (
;input - R0 holds the input
;output - R6 set to -1 if unbalanced. else not modified.

IS_BALANCED

TOP_OF_IN_LOOP
	IN

	AND R1, R1, #0		; Check if '('
	LD R1, NEG_OPEN
	ADD R1, R0, R1
	BRz PUSH_IT

	AND R1, R1, #0		; Check if ')'
	LD R1, NEG_CLOSE
	ADD R1, R0, R1
	BRz POP_IT

	AND R1, R1, #0		; Check if whitespace
	LD R1, NEG_SPACE
	ADD R1, R0, R1
	BRz FOUND_SPACE

	AND R1, R1, #0		; Check if return carriage
	LD R1, NEG_RETURN
	ADD R1, R0, R1
	BRz FOUND_RETURN

FOUND_RETURN
	JSR POP			; Check if there's anything left in stack
	AND R1, R1, #0		; if so, unbalanced and exit.
	ADD R1, R5, #-1
	BRn UNBALANCED

	;AND R0, R0, #0
	;LD R0, R
	;OUT
	;AND R0, R0, #0
	;LD R0, B
	;OUT

	AND R6, R6, #0		; else, balanced, set R6 to #1 and exit.
	ADD R6, R6, #1
	BRnzp DONE

FOUND_SPACE
	;AND R0, R0, #0		; Just ignore
	;LD R0, S
	;OUT
	BRnzp TOP_OF_IN_LOOP

PUSH_IT
	JSR PUSH		; if found '(', push it onto stack, and get another char.
	AND R1, R1, #0
	ADD R1, R5, #-1
	BRz ERROR
	BRnzp TOP_OF_IN_LOOP

POP_IT
	JSR POP			; if found ')' pop from stack, if there's nothing left,
	AND R2, R2, #0		; unbalanced and exit
	ADD R2, R5, #-1
	BRz UNBALANCED
	AND R1, R1, #0		; kind of unecessary, but check if popped char is actually '('
	LD R1, NEG_OPEN
	ADD R1, R6, R1
	BRz BALANCED
	BRnp UNBALANCED

UNBALANCED
	AND R6, R6, #0		; when unbalanced, set R6 to #-1
	ADD R6, R6, #-1
	;AND R0, R0, #0
	;LD R0, U
	;OUT
	BRnzp DONE

BALANCED
	;AND R0, R0, #0		; if still balanced, go back to getting chars
	;LD R0, B
	;OUT
	BRnzp TOP_OF_IN_LOOP

ERROR
	LEA R0, ERROR_MESSAGE
	PUTS
	BRnzp DONE

DONE
	HALT

B		.FILL x0042
U		.FILL x0055
S		.FILL x0053
R		.FILL x0052
NEG_OPEN	.FILL xFFD8
NEG_CLOSE	.FILL xFFD7
NEG_SPACE	.FILL xFFE0
NEG_RETURN	.FILL xFFF3
ERROR_MESSAGE	.STRINGZ "ERROR: Overflow, too many items in stack."


;IN:R0, OUT:R5 (0-success, 1-fail/overflow)
;R3: STACK_END R4: STACK_TOP
;
PUSH
	ST R3, PUSH_SaveR3	;save R3
	ST R4, PUSH_SaveR4	;save R4
	AND R5, R5, #0		;
	LD R3, STACK_END	;
	LD R4, STACK_TOP	;
	ADD R3, R3, #-1		;
	NOT R3, R3		;
	ADD R3, R3, #1		;
	ADD R3, R3, R4		;
	BRz OVERFLOW		;stack is full
	STR R0, R4, #0		;no overflow, store value in the stack
	ADD R4, R4, #-1		;move top of the stack
	ST R4, STACK_TOP	;store top of stack pointer
	BRnzp DONE_PUSH		;
OVERFLOW
	ADD R5, R5, #1		;
DONE_PUSH
	LD R3, PUSH_SaveR3	;
	LD R4, PUSH_SaveR4	;
	RET


PUSH_SaveR3	.BLKW #1	;
PUSH_SaveR4	.BLKW #1	;


;OUT: R6, OUT R5 (0-success, 1-fail/underflow)
;R3 STACK_START R4 STACK_TOP
;
POP
	ST R3, POP_SaveR3	;save R3
	ST R4, POP_SaveR4	;save R3
	AND R5, R5, #0		;clear R5
	LD R3, STACK_START	;
	LD R4, STACK_TOP	;
	NOT R3, R3		;
	ADD R3, R3, #1		;
	ADD R3, R3, R4		;
	BRz UNDERFLOW		;
	ADD R4, R4, #1		;
	LDR R6, R4, #0		;
	ST R4, STACK_TOP	;
	BRnzp DONE_POP		;
UNDERFLOW
	ADD R5, R5, #1		;
DONE_POP
	LD R3, POP_SaveR3	;
	LD R4, POP_SaveR4	;
	RET


POP_SaveR3	.BLKW #1	;
POP_SaveR4	.BLKW #1	;
STACK_END	.FILL x3FF0	;
STACK_START	.FILL x4000	;
STACK_TOP	.FILL x4000	;

.END