~
^
This is an escape construct. If there are no more arguments remaining to
be processed, then the immediately
enclosing ~{ or ~< construct
is terminated. If there is no such enclosing construct, then the entire
formatting operation is terminated.
In the ~< case, the formatting
is performed, but no more segments are processed before doing the
justification.
~ may appear anywhere in a ^ ~{
construct.
(setq donestr "Done.~^ ~D warning~:P.~^ ~D error~:P.")
⇒ "Done.~^ ~D warning~:P.~^ ~D error~:P."
(format nil donestr) ⇒ "Done."
(format nil donestr 3) ⇒ "Done. 3 warnings."
(format nil donestr 1 5) ⇒ "Done. 1 warning. 5 errors."
If a prefix parameter is given, then termination occurs if the parameter
is zero. (Hence ~ is equivalent to
^~#.) If two
parameters are given, termination occurs if they are equal.
^
[Reviewer Note by Barmar: Which equality predicate?] If three
parameters are given, termination occurs if the first is less than or
equal to the second and the second is less than or equal to the third.
Of course, this is useless if all the prefix parameters are constants; at
least one of them should be a # or a V parameter.
If ~ is used within a ^~:{
construct, then it terminates
the current iteration step because in the standard case it tests for
remaining arguments of the current step only; the next iteration step
commences immediately. ~: is used to terminate
the iteration process.
^
~:
may be used only if the command it would terminate is
^~:{ or ~:@{ .
The entire iteration process is terminated if and only if the sublist that is
supplying the arguments for the current iteration step is the last sublist in
the case of ~:{ ,
or the last format
argument in the case of ~:@{ .
~: is not
equivalent to ^~#:;
the latter terminates the entire iteration if and only if no
arguments remain for the current iteration step.
For example:
^
(format nil "~:{ ~@?~:^ ...~} " '(("a") ("b"))) ⇒ "a...b"
If ~ appears within a control string being processed
under the control of a ^~? directive, but not within
any ~{ or ~< construct within that string,
then the string being
processed will be terminated, thereby ending processing
of the ~? directive. Processing then
continues within the string
containing the ~? directive at the point following that directive.
If ~
appears within a ^~[ or ~( construct,
then all the commands up to the ~ are properly selected
or case-converted,
the ^~[ or ~( processing is terminated,
and the outward search continues
for a ~{ or ~< construct
to be terminated. For example:
(setq tellstr "~@(~@[~R~]~^ ~A!~)")
⇒ "~@(~@[~R~]~^ ~A!~)"
(format nil tellstr 23) ⇒ "Twenty-three!"
(format nil tellstr nil "losers") ⇒ " Losers!"
(format nil tellstr 23 "losers") ⇒ "Twenty-three losers!"
Following are examples of the use of ~
within a ^~< construct.
(format nil "~15<~S~;~^~S~;~^~S~>" 'foo)
⇒ " FOO"
(format nil "~15<~S~;~^~S~;~^~S~>" 'foo 'bar)
⇒ "FOO BAR"
(format nil "~15<~S~;~^~S~;~^~S~>" 'foo 'bar 'baz)
⇒ "FOO BAR BAZ"