Next: Byte Data Output Functions, Up: The Output Library [Index]

void <prefix>_(...);

outputs its arguments, in the order in which they appear. Arguments of non intrinsic types other than the byte array type are ignored. Real arguments are output with as many digits as significant.

void <prefix>_bfxcardinal(integer b, integer d, integer x, cardinal z);

outputs the base *x*, *d* digits, *b* wide comma separated
blocks representation of *z* if *b* and *d* are not less than
zero and *x* is between 2 and 36 inclusive, does nothing otherwise

void <prefix>_bfxinteger(integer b, integer d, integer x, integer m);

outputs the base *x*, *d* digits, *b* wide comma separated
blocks representation of *m* if *b* and *d* are not less than
zero and *x* is between 2 and 36 inclusive, does nothing otherwise

void <prefix>_byte(integer c);

outputs the *c* character

void <prefix>_bytes(...);

outputs its arguments as bytes, numeric intrinsic types as one byte, byte sequences as are, in the order in which they appear. Arguments of non intrinsic types other than the byte array type are ignored.

void <prefix>_cardinal(cardinal z);

outputs the representation of *z*

void <prefix>_etext(text s);

outputs the *s* string escaped for shell use

void <prefix>_fcardinal(integer d, cardinal z);

outputs the *d* digits representation of *z* if *d* is not less
than zero, does nothing otherwise

void <prefix>_finteger(integer d, integer m);

outputs the *d* digits representation of *m* if *d* is not less
than zero, does nothing otherwise

void <prefix>_form(text s, ...);

See The _form Function.

outputs the filled out *s* form

void <prefix>_fxcardinal(integer d, integer x, cardinal z);

outputs the base *x*, *d* digits representation of *z* if
*d* is not less than zero and *x* is between 2 and 36 inclusive, does
nothing otherwise

void <prefix>_fxinteger(integer d, integer x, integer m);

outputs the base *x*, *d* digits representation of *m* if
*d* is not less than zero and *x* is between 2 and 36 inclusive, does
nothing otherwise

void <prefix>_gtext(text g, text s);

outputs the *s* string with the characters 0 through 31, ‘`"`’,
‘`\`’, 127 through 255 and the characters in *g* escaped

void <prefix>_integer(integer m);

outputs the representation of *m*

void <prefix>_msbfcardinal(integer d, cardinal z);

outputs the *d* bytes binary representation of *z*, most significant
byte first

void <prefix>_msbfvcardinal(cardinal z);

outputs the varint representation of *z*, most significant byte first (for
a variable number of bytes, with the first bit in each byte indicating whether
another follows and the remaining 7 carrying the encoded value)

void <prefix>_newline(void);

outputs a new line character (same as *<prefix>*‘`_byte`’(‘`'\n'`’))

void <prefix>_plan(...);

same as *<prefix>*‘`_`’

void <prefix>_real(integer d, real x);

outputs the representation of *x* with no more than *d* digits if
*d* is not less than 0, does nothing otherwise

void <prefix>_run(integer r, integer c);

outputs the *c* character *r* times

void <prefix>_space(integer m);

outputs *m* space characters

void <prefix>_text(text s);

outputs the *s* string

void <prefix>_wbfxcardinal (integer w, integer b, integer d, integer x, cardinal z);

outputs the base *x*, *d* digits, *b* wide comma separated
blocks representation of *z* if *b* and *d* are not less than
zero and *x* is between 2 and 36 inclusive. In any event,
at least *w* characters are written with the necessary white
space inserted to the left of *z* representation if *w* is not
negative and at least -*w* characters are written with the necessary white
space inserted to the right of *z* representation otherwise.

void <prefix>_wbfxinteger (integer w, integer b, integer d, integer x, integer m);

outputs the base *x*, *d* digits, *b* wide comma separated
blocks representation of *m* if *b* and *d* are not less than
zero and *x* is between 2 and 36 inclusive. In any event,
at least *w* characters are written with the necessary white
space inserted to the left of *m* representation if *w* is not
negative and at least -*w* characters are written with the necessary white
space inserted to the right of *m* representation otherwise.

void <prefix>_wcardinal(integer w, cardinal z);

outputs the representation of *z*. At least
*w* characters are written with the necessary white space inserted to the
left of *z* representation if *w* is not negative and at least
-*w* characters are written with the necessary white space inserted to the
right of *z* representation otherwise.

void <prefix>_winteger(integer w, integer m);

outputs the representation of *m*. At least
*w* characters are written with the necessary white space inserted to the
left of *m* representation if *w* is not negative and at least
-*w* characters are written with the necessary white space inserted to the
right of *m* representation otherwise.

void <prefix>_wpreal(integer w, integer a, integer d, real x);

outputs the representation of *x* with no more than *d* digits and at
least *a* + 1 characters after the integral part if *a* is not zero
(1 character for the period sign, *a* characters for the fractional part)
if *a* and *d* are not less than zero. In any
event, at least *w* characters are written with the necessary
white space inserted to the left of *x* representation if *w* is not
negative and at least -*w* characters are written with the necessary white
space inserted to the right of *x* representation otherwise.

void <prefix>_wxcardinal(integer w, integer x, cardinal z);

outputs the base *x* representation of *z* if *x* is between 2
and 36 inclusive. In any event, at least
*w* characters are written with the necessary white space inserted to the
left of *z* representation if *w* is not negative and at least
-*w* characters are written with the necessary white space inserted to the
right of *z* representation otherwise.

void <prefix>_wxinteger(integer w, integer x, integer m);

outputs the base *x* representation of *m* if *x* is between 2
and 36 inclusive. In any event, at least
*w* characters are written with the necessary white space inserted to the
left of *m* representation if *w* is not negative and at least
-*w* characters are written with the necessary white space inserted to the
right of *m* representation otherwise.

void <prefix>_xcardinal(integer x, cardinal z);

outputs the base *x* representation of *z* if *x* is between 2
and 36 inclusive, does nothing otherwise

void <prefix>_xinteger(integer x, integer m);

outputs the base *x* representation of *m* if *x* is between 2
and 36 inclusive, does nothing otherwise

Next: Byte Data Output Functions, Up: The Output Library [Index]