Some postscript commands useful in debugging:
(see p.108 of the red book for a list of these and other related commands,
and for pointers to other parts of the red book describing them.)

= and ==
Both = and == take the top element of the stack and send it to the standard
output.  The difference is that = prints out the value, and == prints out
the syntactic representation.  The following table should give you some
idea in how they differ:
You type:	and = says:	and == says:
=======================================
4		4		4
false		false		false
(afda)		afda		(afda)
[1 3 (a)]	--nostringval--	[1 3 (a)]
/tofu		tofu		/tofu
{dup mul}	--nostringval--	{dup mul}
Courier findfont --nostringval-- -dicttype-
[		--nostringval--	-marktype-
null		--nostringval--	-nulltype-
(for a description of these and other types, see p.26 of the red book)

Both destroy the element they print, so if you want to keep it, say "dup"
first.

stack and pstack
Both print out the stack.  They differ in the same ways = and == differ.
stack calls = to print out the stack, and pstack uses ==.  They do NOT
destroy the contents.  The top elements are printed first.

vmstatus
Sometimes the program runs out of memory.  There can be many reasons for
this.  More often than not, postscript's non-existent garbage collection
is at fault.  One way to check is to use vmstatus, which pushes onto the
stack (in this order):  level used maximum
where "level" is the level of saves done, "used" is the amount of VM
used, and "maximum" is the total amount of VM in the printer.
VM stands for "virtual memory", although it does not mean virtual
memory in the usual sense of indirect addressing to memory and disk.
It means space where strings, dictionaries, fonts, etc. can reside,
as opposed to space where the stack sits, or space to store the postscript
program.  Postscript does no garbage collection, and furthermore, offers
no way to do so.  So if you find vm size to be your problem, find ways
to reuse strings, arrays, etc. so that you don't have to keep creating new
ones.

Incidentally, another source of errors is the size of the operand stack.
There is a standard 500 level maximum on this stack.  For other limits,
see p.260 of the Red Book.