Idiom for tail recursion?

[jpwoodruff <jpwoodruff@gmail.com>]

To entertain myself, I'm making a program that implements the DEVS
specification for discrete event simulation.  The book I'm studying
describes a reference implementation in Scheme.

The program proceeds by passing a series of messages among objects
that are instances of only a couple class hierarchies.  The messages
cycle among the objects in (fairly convoluted) cycles of mutually
recursive dispatching calls.  Simulation time advances as the program
traverses the outermost cycles of activation.

In scheme, the functions are tail-recursive - the last call of each of
the respective mutually recursive procedures does the recurse.  This
paradigm is crystal clear in that language and the implementation
doesn't grow the stack.

But in Ada it appears that I'm going to have a stack of calls that
won't return.  I guess the program will quit running when I raise an
exception for that purpose.  Or maybe it won't halt, who knows :-}.

I most definitely do not see a transform to an iterative algorithm.

So the question: what idiom comes fairly close to the flavor of the
tail-recursion and won't blow stack?

John