>>77
As you can see, it doesn't take that many lines of code, and the effect of the code walker is localized. When I first learned CL I was a bit upset that they didn't tuck in continuations in the standard, given that it does practically support a very large variety of features(just think of CLOS, the type system, arrays, lambda lists, etc which are fairly complex), but now that I know CL decently, and understand its design goals, I can say safely that I'm actually glad they didn't include it. CL tries to include a lot of features, but they make great efforts to make sure you can implement these features in a performant and non-prohibitive way. Supporting continuations natively would have led to various problems:
The way continuations should behave in the presence of some special-operators which deal with the control-flow under exceptional conditions is very hard to define correctly, and you might as well have to make a choice between one of them when defining a language. The issues which can occur in the presence of
UNWIND-PROTECT have been discussed and studief in great detail by many Lisers. Dynamic bindings (if present) can cause trouble for a compiler wishing to do TCO in some cases, this could lead to some issues when implementing continuations again (and things like *which* bindings should be used, etc). Implementing continuations naively can be quite an overhead on performance (which goes against CL's goals of making it easy to write implementations which generate performant code), and writing high-performance compilers which implement continuations efficiently is possible, but tricky.
However, one simple way of implementing continuations is recompiling special forms/operators to use CPS and then defining call/cc in that terms is not that hard, and it can be done locally, without penalty to the entire implementation(just local penalty to the code defined in that manner). Besides, CL-CONT(and some other systems which implement continuations and call/cc), aren't that large and hard to implement. In "On Lisp", Graham even gives an implementation for a simple call/cc within a single page of code. His code is mostly fine, except for some slightly abuse of undefined behaviour(which could be easily translated into more proper code... I wonder why didn't he), but it's not an `industrial-strength' call/cc IMO. If you're going to use call/cc as part of some larger system(ex. web based continuations-based frameworks, which allow continuations to persist), you might want to opt for a more global and proper call/cc implementation. Those implementations will of course be larger as they are careful into taking into account the semantics of the entire language and allow your code to interoperate fairly cleanly(as long as you don't use a few conflicting special forms).
If you're curious about the details of some of the technical issues, this paper might be more interesting to you:
http://www.nhplace.com/kent/PFAQ/unwind-protect-vs-continuations-original.html