/usr/lib/s9fes/help/format is in scheme9 2010.11.13-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 | S9 LIB (format #t string-f object ...) ==> #t
(format #f string-f object ...) ==> string
(format string string-f object ...) ==> string
(format output-port string-f object ...) ==> #t
Format prints according to the formatting instruction in STRING-F.
If the first argument is #T, the output is to the current output
port and #T is returned. If the argument is #F, a formatted string
is returned as the result of the call. If the first argument is is
a string, the output is appended to that string, returning a fresh
string. Otherwise the first argument must be an output port (to
which the output will be sent) and #T is returned.
Characters in the STRING-F argument are printed as if they were
output by the DISPLAY procedure with the exception of those prefixed
by a tilde (~). When a tilde is found in STRING-F, FORMAT fetches
the next argument from its argument list, formats it according to
the instructions encoded in the tilde command, and prints it.
In case of a formatting error FORMAT prints a message on the current
output port and aborts.
The tilde commands of the STRING-F argument have the following
general form:
directive := ~[<parameter>,...][:][@]<command-character>
parameter := [-|+]{0..9}... | '<character> | v | #
Parameters are positional. When specifying only the first parameters
of a command, the remaining parameters can be omitted, as in
~10D or ~10,'xD
But when, for example, the first and the third parameters is to
be specified, an empty parameter has to be included, as in
~10D,,'.D
Default values are assumed for parameters that are not specified.
The FORMAT procedure described here is a subset of the CommonLISP
format command. Its supports the commands described in the following.
PARAMETERS
Common parameters include the following:
mincol specifies the minimum size of an output field, e.g.:
(format #f "~5A" 'z) ==> "z "
colinc is a CL FORMAT parameter that is being ignored.
minpad is the minimum number of padding characters attached, e.g.:
(format #f "~,,3A" 'z) ==> "z "
padchar changes the padding character (which defaults to #\space):
(format #f "~,,3,'_A" 'z) ==> "z___"
comma-char change the numeric group separator (default: #\,):
(format #f "~,,'':D" 1234567) ==> "1'234'567"
comma-int change the numeric group interval (default: 3):
(format #f "~,,'',6:D" 1234567) ==> "1'234567"
When both mincol and minpad are specified, the length of the output
field will be limited to mincol unless the object to print alone is
longer than mincol:
(format #f "~5,,3'_A" 'zzz) ==> "zzz__"
When the object alone is longer than mincol, minpad padding characters
will be added:
(format #f "~5,,3,'_A" 'z12345) ==> "z12345___"
The special parameter V fetches its value from the following FORMAT
argument:
(format #f "~V,,,'_A" 5 'foo) ==> "foo__"
The special parameter # inserts the number of remaining arguments.
COMMANDS
~A mincol,colinc,minpad,padchar Aesthetic
Output is formatted in the same way as by DISPLAY.
~@A Insert padding characters on the left.
~:A Generate READ-proof output.
(format #f "~5,,,'_@A" #\X) ==> "____X"
~B mincol,padchar,comma-char,comma-int Binary
Print the binary representation of a number.
~@B Print the binary base prefix (#b).
~:B print separate groups of digits.
(format #f "~,,' 4:B" #b10101100) ==> "1010 1100"
~C char Character
Print next argument as a single characher.
When char is specified, print the character
with the goven ASCII code.
~@C Print that character in the same way as WRITE.
(format #f "~32@C") ==> "#\\space"
~D mincol,padchar,comma-char,comma-int Decimal
Print the decimal representation of a number.
~@D Print the decimal base prefix (#d).
~:D print separate groups of digits.
(format #f "~,,''3:D" 1234567) ==> "1'234'567"
~K (see ~?)
~O mincol,padchar,comma-char,comma-int Octal
Print the octal representation of a number.
~@O Print the octal base prefix (#o).
~:O print separate groups of digits.
(format #f "~@O" #o411) ==> "#o411"
~P (no parameters) Plural
When the current argument equals 1, print nothing,
when it is not 1, print "s".
~@P Print "y" instead of "" and "ies" instead of "s".
~:P Re-use the previous argument instead of fetching
a new one.
~:@P Combination of the above.
(format #f "~D thing~:@P" 2) ==> "2 thingies"
~R N,mincol,padchar,comma-char,comma-int Radix
Print the radix-N representation of a number.
Note: Only N in {2,8,10,16} is supported!
~@R Print radix prefix; BROKEN, do not use!
~:R print separate groups of digits.
(format #f "~16R" #x3039) ==> "3039"
~S ~mincol,colinc,minpad,padcharS Standard
Output is formatted in the same way as by WRITE.
~@S Insert padding characters on the left.
~:S Generate READ-proof output.
(format #f "~5,,,'_@S" #\X) ==> "__#\\X"
~T N Tabulator
Print N tabulation characters (default: one).
(format #f "~2T")
~X mincol,padchar,comma-char,comma-int Hexa-decimal
Print the hexa-decimal representation of a number.
~@X Print the hexa-decimal base prefix (#x).
~:X print separate groups of digits.
(format #f "~,,' ,4:X" #xdeadbeef) ==> "dead beef"
~#\newline Ignore Newline
Ignore a newline character in STRING-F.
The newline character and all subsequent #\space
characters will be replaced by a single #\space.
~@#\newline
The #\newline will be included, but subsequent
spaces will be discarded.
~:#\newline
The #\newline will be discarded, but subsequent
spaces will be included.
~% N Newline
Print N newline characters (default: one).
(format #f "~2%")
~& (see ~%)
~(~) (no parameters) Case Conversion
~(text~) converts "text" to lower case.
~:(text~) capitizes all words in "text".
~@(text~) capitizes the first word in "text".
~:@(text~) converts "text" to upper case.
(format #f "~(~A~)" "HELLO world") ==> "hello world"
(format #f "~:(~A~)" "HELLO world") ==> "Hello World"
(format #f "~@(~A~)" "HELLO world") ==> "Hello world"
(format #f "~:@(~A~)" "HELLO world") ==> "HELLO WORLD"
~* N Go To Argument
Jump N (default: 1) arguments forward.
~:* Jump N (default: 1) arguments backward.
~@* Jump to the Nth (default: 0) argument.
(format #f "~A~2@*~A" 'foo 'bar 'baz) ==> "foobaz"
~? (no parameters) Indirection
Fetch the format commands from the next argument
and the objects to be printed by the commands from
a list in the argument after the next one.
~@? Instead of fetching the objects from a list, keep
consuming FORMAT arguments.
(format #f "~?" "~A ~S" '(#\1 #\2)) ==> "1 #\\2"
(format #f "~@?" "~A ~S" #\1 #\2 ) ==> "1 #\\2"
~[text0~;...~;textN~:;text~] Conditional Expr
Fetch a numeric argument from the argument list
and output the Nth text between "~[" and "~]". The
individual texts are separated by "~;". When there
is no N'th text, output nothing. When there is no
Nth text, but a "~:;text" (default) clause exists,
output the text of that clause.
(format #f "~[foo~;bar~;baz~]" 1) ==> "bar"
~:[alternative~;consequent~] Conditional Expr
Print the consequent part if the current argument is
true (not #F) and otherwise print the alternative
part.
(format #f "~:[no~;yes~]" 1) ==> "yes"
~@[consequent~] Conditional Expr
The consequent is output only when the current
argument is true. When the argument is true, it
will not be consumed.
(format #f "~@[~A bar~]" #f) ==> ""
(format #f "~@[~Abar~]" 'foo) ==> "foobar"
~N[...~] (see ~[~]) Conditional Expr
Fetch the Nth text instead of taking the number
from an argument.
~^ Escape
Stop formatting when no more arguments are available.
When ~^ appears inside of an iteration command, only
the innermost iteration command will terminate.
(format #f "done~^, ~D matches") ==> "done"
(format #f "done~^, ~D matches" 17)
==> "done, 17 matches"
~N^ escapes if N=0.
~N,M^ escapes if N=M.
~N,M,K^ escapes if N<M<K.
Of course at least one of N,M,K should be a "v" (value
of next argument) or "#" (number of remaining arguments)
parameter, e.g.:
(format #f "~0,v,1^~D matches" 0) ==> ""
(format #f "~0,v,1^~D matches" 2 2) ==> "2 matches"
~_ N Blanks
Print N blank characters (default: one).
(format #f "~2_") ==> " "
~{text~} Iteration
Apply "text" to all members of the next argument,
which must be a list.
(format #f "members:~{ ~A~}" '(foo bar baz))
==> "members: foo bar baz"
~N{ Limit output to N members at most.
(format #f "members:~2{ ~A~}" '(foo bar baz))
==> "members: foo bar"
~:{ Iterate over a list of sublists. Individual arguments
are taken from the sublists:
(format #f "coordinates:~:{ ~S~S~}" '((a 1) (e 2) (b 7)))
==> "coordinates: a1 e2 b7"
~@{ Iterate over FORMATs arguments.
(format #f "members:~@{ ~A~}" 'foo 'bar 'baz)
==> "members: foo bar baz"
~:@{ Like ~:{, but fetch sublists from FORMATs arguments.
(format #f "coordinates:~:@{ ~S~S~}" '(a 1) '(e 2) '(b 7))
==> "coordinates: a1 e2 b7"
~| N Page Separator
Print N page separators (default: one).
(format #f "~2|")
~~ N Tilde
Print N tilde characters (default: one).
(format #f "~5~") ==> "~~~~~"
|