algebrite/runtime/stack.coffee

Computer Algebra System in Coffeescript

#	 _______
#	|	| <- stack
#	|	|
#	|_______|
#	|	| <- stack + tos
#	|	|
#	|	|
#	|_______|
#	|	| <- frame
#	|_______|
#		  <- stack + TOS
#
#	The stack grows from low memory towards high memory. This is so that
#	multiple expressions can be pushed on the stack and then accessed as an
#	array.
#
#	The frame area holds local variables and grows from high memory towards
#	low memory. The frame area makes local variables visible to the garbage
#	collector.



tos = 0

# p is a U
nil_symbols = 0
push = (p) ->
	if !p?
		debugger
	if p.isZero?
		debugger

	#console.log "pushing "
	#console.log print_list(p)

	if p == symbol(NIL)
		nil_symbols++
		if DEBUG then console.log "pushing symbol(NIL) #" + nil_symbols
		#if nil_symbols == 111
		#	debugger
	if (tos >= frame)
		stop("stack overflow")
	stack[tos++] = p

# returns a U

moveTos = (stackPos) ->
	if tos <= stackPos
		# we are moving the stack pointer
		# "up" the stack (as if we were doing a push)
		tos = stackPos
		return
	# we are moving the stack pointer
	# "down" the stack i.e. as if we were
	# doing a pop, we can zero-
	# out all the elements that we pass
	# so we can reclaim the memory
	while tos > stackPos
		stack[tos] = null
		tos--
	return

top = ->
	stack[tos-1]

pop = ->
	#popsNum++
	#console.log "pop #" + popsNum
	if (tos == 0)
		debugger
		stop("stack underflow")
	if !stack[tos-1]?
		debugger
	elementToBeReturned = stack[--tos]
	
	# give a chance to the garbage
	# collection to reclaim space
	# This is JS-specific, it would
	# actually make the C garbage
	# collector useless.
	stack[tos] = null
	
	return elementToBeReturned

# n is an integer
push_frame = (n) ->
	i = 0
	frame -= n
	if (frame < tos)
		debugger
		stop("frame overflow, circular reference?")
	for i in [0...n]
		stack[frame + i] = symbol(NIL)

# n is an integer
pop_frame = (n) ->
	frame += n
	if (frame > TOS)
		stop("frame underflow")

save = ->
	frame -= 10
	if (frame < tos)
		debugger
		stop("frame overflow, circular reference?")
	stack[frame + 0] = p0
	stack[frame + 1] = p1
	stack[frame + 2] = p2
	stack[frame + 3] = p3
	stack[frame + 4] = p4
	stack[frame + 5] = p5
	stack[frame + 6] = p6
	stack[frame + 7] = p7
	stack[frame + 8] = p8
	stack[frame + 9] = p9

restore = ->
	if (frame > TOS - 10)
		stop("frame underflow")
	p0 = stack[frame + 0]
	p1 = stack[frame + 1]
	p2 = stack[frame + 2]
	p3 = stack[frame + 3]
	p4 = stack[frame + 4]
	p5 = stack[frame + 5]
	p6 = stack[frame + 6]
	p7 = stack[frame + 7]
	p8 = stack[frame + 8]
	p9 = stack[frame + 9]
	frame += 10

# Local U * is OK here because there is no functional path to the garbage collector.

swap = ->
	#U *p, *q
	# p and q are both Us
	p = pop()
	q = pop()
	push(p)
	push(q)

# Local U * is OK here because there is no functional path to the garbage collector.

dupl = ->
	#U *p
	p = pop()
	push(p)
	push(p)

$.dupl = dupl
$.swap = swap
$.restore = restore
$.save = save
$.push = push
$.pop = pop