# this function extract parts subtrees from a tree.
# It is used in two
# places that have to do with pattern matching.
# One is for integrals, where an expression or its
# subparts are matched against cases in an
# integrals table.
# Another one is for applyging tranformation patterns
# defined via PATTERN, again patterns are applied to
# either the whole expression or any of its parts.



# unclear to me at the moment
# why this is exposed as something that can
# be evalled. Never called.

Eval_decomp = ->
	save()
	console.log "Eval_decomp is being called!!!!!!!!!!!!!!!!!!!!"
	h = tos
	push(symbol(NIL))
	push(cadr(p1))
	Eval()
	push(caddr(p1))
	Eval()
	p1 = pop()
	if (p1 == symbol(NIL))
		guess()
	else
		push(p1)
	decomp(false)
	list(tos - h)
	restore()


pushTryNotToDuplicate = (toBePushed) ->
	if tos > 0
		if DEBUG then console.log "comparing " + toBePushed + " to: " + stack[tos-1]
		if equal(toBePushed, stack[tos-1])
			if DEBUG then console.log "skipping " + toBePushed + " because it's already on stack "
			return
	push(toBePushed)


# returns constant expressions on the stack

decomp = (generalTransform) ->
	save()

	p2 = pop()
	p1 = pop()

	if DEBUG then console.log "DECOMPOSING " + p1

	# is the entire expression constant?

	if generalTransform
		if !iscons(p1)
			if DEBUG then console.log " ground thing: " + p1
			pushTryNotToDuplicate p1
			restore()
			return
	else
		if (Find(p1, p2) == 0)
			if DEBUG then console.log " entire expression is constant"
			pushTryNotToDuplicate(p1)
			#push(p1);	# may need later for pushing both +a, -a
			#negate()
			restore()
			return

	# sum?

	if (isadd(p1))
		decomp_sum(generalTransform)
		restore()
		return

	# product?

	if (ismultiply(p1))
		decomp_product(generalTransform)
		restore()
		return

	# naive decomp if not sum or product

	if DEBUG then console.log " naive decomp"
	p3 = cdr(p1)
	if DEBUG then console.log "startig p3: " + p3
	while (iscons(p3))

		# for a general transformations,
		# we want to match any part of the tree so
		# we need to push the subtree as well
		# as recurse to its parts
		if generalTransform
			push(car(p3))

		if DEBUG then console.log "recursive decomposition"
		push(car(p3))
		
		if DEBUG then console.log "car(p3): " + car(p3)
		push(p2)
		if DEBUG then console.log "p2: " + p2
		decomp(generalTransform)
		p3 = cdr(p3)

	restore()

decomp_sum = (generalTransform) ->
	if DEBUG then console.log " decomposing the sum "
	h = 0


	# decomp terms involving x

	p3 = cdr(p1)

	while (iscons(p3))
		if (Find(car(p3), p2) or generalTransform)
			push(car(p3))
			push(p2)
			decomp(generalTransform)
		p3 = cdr(p3)

	# add together all constant terms

	h = tos

	p3 = cdr(p1)

	while (iscons(p3))
		if (Find(car(p3), p2) == 0)
			pushTryNotToDuplicate(car(p3))
		p3 = cdr(p3)

	if (tos - h)
		add_all(tos - h)
		p3 = pop()
		pushTryNotToDuplicate(p3)
		push(p3)
		negate();	# need both +a, -a for some integrals

decomp_product = (generalTransform) ->
	if DEBUG then console.log " decomposing the product "
	h = 0

	# decomp factors involving x

	p3 = cdr(p1)

	while (iscons(p3))
		if (Find(car(p3), p2) or generalTransform)
			push(car(p3))
			push(p2)
			decomp(generalTransform)
		p3 = cdr(p3)

	# multiply together all constant factors

	h = tos

	p3 = cdr(p1)

	while (iscons(p3))
		if (Find(car(p3), p2) == 0)
			pushTryNotToDuplicate(car(p3))
		p3 = cdr(p3)

	if (tos - h)
		multiply_all(tos - h)
		#p3 = pop();	# may need later for pushing both +a, -a
		#push(p3)
		#push(p3)
		#negate()