Thanks very much for taking the time to comment in this thread.

I really thought there was a way for me to 'escape' from deeply nested
code within the body of my program, ending the execution of my program
mid-cycle, so to speak, winding up at toplevel with my program stopped
dead in its tracks. (as catch and throw can do) - all this by using
simple CL code like cond, cons, car, cdr, etc.

Your comments make it apparent that this can't be done in the
simplistic way that I want to do it, so I accept that.

I thought there was something obvious that I was overlooking.

I have nothing whatever against using CL's built-in constructs.

My aim was to eventually demonstrate that a lot of those constructs
could be duplicated in their actions by substituting continuations in
place of the legitimate constructs like catch, throw, and possibly even
unwind-protect.

Of course the continuations would run much slower than the built-in
stuff that CL already has.

My purpose was mainly self-education about "handling" CL continuations,
as implemented by Paul Graham's six macros in his old "On Lisp" book.

The suggestions that some have suggested I consider was to use the
built-in CL constructs "eval-when" and/or "define-symbol-macro" in
order to 'force' Paul Graham's old code to work in an ANSI environment.

I am against that approach on principle, because when I want my
toplevel non-special variable  %cont%  to have a value of 'foo  - -
then I want it to stay that way until I myself change it - - -
eval-when does not allow that to happen, my 'foo  value gets magically
messed with in behind-the-scenes manipulation by either eval-when or
define-symbol-macro, I don't know which one (or both) of those
constructs does the messing with the toplevel value of my variable, but
I don't like it.

Again, thanks for responding.   I consider it a real newbie privilege
to 'talk' to a real heavyweight in the computing arena.