print man page on Plan9

Man page or keyword search:  
man Server   549 pages
apropos Keyword Search (all sections)
Output format
Plan9 logo
[printable version]

PRINT(2)							      PRINT(2)

       print,  fprint,	sprint,	 snprint, seprint, smprint, runesprint, runes‐
       nprint, runeseprint, runesmprint,  vfprint,  vsnprint,  vseprint,  vsm‐
       print,  runevsnprint, runevseprint, runevsmprint - print formatted out‐

       #include <u.h>
       #include <libc.h>

       int   print(char *format, ...)

       int   fprint(int fd, char *format, ...)

       int   sprint(char *s, char *format, ...)

       int   snprint(char *s, int len, char *format, ...)

       char* seprint(char *s, char *e, char *format, ...)

       char* smprint(char *format, ...)

       int   runesprint(Rune *s, char *format, ...)

       int   runesnprint(Rune *s, int len, char *format, ...)

       Rune* runeseprint(Rune *s, Rune *e, char *format, ...)

       Rune* runesmprint(char *format, ...)

       int   vfprint(int fd, char *format, va_list v)

       int   vsnprint(char *s, int len, char *format, va_list v)

       char* vseprint(char *s, char *e, char *format, va_list v)

       char* vsmprint(char *format, va_list v)

       int   runevsnprint(Rune *s, int len, char *format, va_list v)

       Rune* runevseprint(Rune *s, Rune *e, char *format, va_list v)

       Rune* runevsmprint(Rune *format, va_list v)

       Print writes text to the standard output.  Fprint writes to  the	 named
       output file descriptor; a buffered form is described in bio(2).	Sprint
       places text followed by the NUL character  (\0)	in  consecutive	 bytes
       starting	 at  s;	 it is the user's responsibility to ensure that enough
       storage is available.  Each function returns the number of bytes trans‐
       mitted  (not  including	the  NUL in the case of sprint), or a negative
       value if an output error was encountered.

       Snprint is like sprint, but will not place more than len	 bytes	in  s.
       Its  result  is	always	NUL-terminated and holds the maximal number of
       complete UTF-8 characters that  can  fit.   Seprint  is	like  snprint,
       except that the end is indicated by a pointer e rather than a count and
       the return value points to the terminating NUL of the resulting string.
       Smprint is like sprint, except that it prints into and returns a string
       of the required length, which is allocated by malloc(2).

       The routines runesprint, runesnprint, runeseprint, and runesmprint  are
       the same as sprint, snprint, seprint and smprint except that their out‐
       put is rune strings instead of byte strings.

       Finally, the routines vfprint, vsnprint,	 vseprint,  vsmprint,  runevs‐
       nprint,	runevseprint, and runevsmprint are like their v-less relatives
       except they take as arguments a	va_list	 parameter,  so	 they  can  be
       called  within a variadic function.  The Example section shows a repre‐
       sentative usage.

       Each of these functions converts,  formats,  and	 prints	 its  trailing
       arguments  under	 control  of a format string.  The format contains two
       types of objects: plain characters, which are simply copied to the out‐
       put  stream,  and  conversion  specifications, each of which results in
       fetching of zero or more arguments.  The results are undefined if there
       are  arguments  of  the wrong type or too few arguments for the format.
       If the format is	 exhausted  while  arguments  remain,  the  excess  is

       Each conversion specification has the following format:

	      % [flags] verb

       The verb is a single character and each flag is a single character or a
       (decimal) numeric string.  Up to two numeric strings may be  used;  the
       first  is  called width, the second precision.  A period can be used to
       separate them, and if the period is present then	 width	and  precision
       are  taken to be zero if missing, otherwise they are `omitted'.	Either
       or both of the numbers may be replaced with the	character  *,  meaning
       that  the  actual  number will be obtained from the argument list as an
       integer.	 The flags and numbers are arguments  to  the  verb  described

       The  numeric verbs d, o, b, x, and X format their arguments in decimal,
       octal, binary, hexadecimal, and upper case  hexadecimal.	  Each	inter‐
       prets  the flags 0, h, hh, l, u, +, -, ,, and # to mean pad with zeros,
       short, byte, long, unsigned, always print a sign, left justified,  com‐
       mas  every three digits, and alternate format.  Also, a space character
       in the flag position is like +, but prints a space instead  of  a  plus
       sign  for non-negative values.  If neither short nor long is specified,
       then the argument is an int.  If unsigned is specified, then the	 argu‐
       ment is interpreted as a positive number and no sign is output.	If two
       l flags are given, then the argument is interpreted as a vlong (usually
       an  8-byte,  sometimes a 4-byte integer).  If precision is not omitted,
       the number is padded on the left with zeros until  at  least  precision
       digits  appear.	 Then, if alternate format is specified, for o conver‐
       sion, the number is preceded by a 0 if it doesn't  already  begin  with
       one;  for x conversion, the number is preceded by 0x; for X conversion,
       the number is preceded by 0X.  Finally, if width is  not	 omitted,  the
       number is padded on the left (or right, if left justification is speci‐
       fied) with enough blanks to make the field at  least  width  characters

       The  floating  point  verbs  f,	e, E, g, and G take a double argument.
       Each interprets the flags +, -, and # to mean always print a sign, left
       justified, and alternate format.	 Width is the minimum field width and,
       if the converted value takes up	less  than  width  characters,	it  is
       padded on the left (or right, if `left justified') with spaces.	Preci‐
       sion is the number of digits that are converted after the decimal place
       for  e,	E,  and	 f conversions, and precision is the maximum number of
       significant digits for g and G conversions.  The f verb produces output
       of  the	form  [-]digits[.digits].   E  conversion  appends an exponent
       E[-]digits, and e conversion appends an	exponent  e[-]digits.	The  g
       verb will output the argument in either e or f with the goal of produc‐
       ing the smallest output.	 Also, trailing zeros  are  omitted  from  the
       fraction	 part of the output, and a trailing decimal point appears only
       if it is followed by a digit.  The G verb is similar, but uses E format
       instead	of  e.	 When  alternate  format is specified, the result will
       always contain a decimal point, and for g and G	conversions,  trailing
       zeros are not removed.

       The s verb copies a nul-terminated string (pointer to char) to the out‐
       put.  The number of characters copied (n) is the minimum of the size of
       the  string  and	 precision.  These n characters are justified within a
       field of width characters as described above.  If a precision is given,
       it  is safe for the string not to be nul-terminated as long as it is at
       least precision characters (not bytes!) long.  The S verb  is  similar,
       but  it	interprets  its pointer as an array of runes (see utf(6)); the
       runes are converted to UTF before output.

       The c verb copies a single char (promoted to int)  justified  within  a
       field  of  width characters as described above.	The C verb is similar,
       but works on runes.

       The p verb formats a single pointer or pointer-sized integer  (uintptr,
       see intro(2)) in hexadecimal.

       The r verb takes no arguments; it copies the error string returned by a
       call to errstr(2).

       Custom verbs may be installed using fmtinstall(2).

       This function prints an error message with a variable number  of	 argu‐
       ments and then quits.

	      void fatal(char *msg, ...)
		    char buf[1024], *out;
		    va_list arg;

		    out = seprint(buf, buf+sizeof(buf), "Fatal error: ");
		    va_start(arg, msg);
		    out = vseprint(out, buf+sizeof(buf), msg, arg);
		    write(2, buf, out-buf);
		    exits("fatal error");


       fmtinstall(2), fprintf(2), utf(6), errstr(2)

       Routines that write to a file descriptor or call malloc set errstr.

       The formatting is close to that specified for ANSI fprintf(2); the main
       difference is that b is not in ANSI and u is a flag here instead	 of  a
       verb.   Also,  and distinctly not a bug, print and friends generate UTF
       rather than ASCII.

       There is no runeprint, runefprint, etc. because	runes  are  byte-order
       dependent  and  should  not  be written directly to a file; use the UTF
       output of print or fprint instead.   Also,  sprint  is  deprecated  for
       safety  reasons; use snprint, seprint, or smprint instead.  Safety also
       precludes the existence of runesprint.

                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Plan9

List of man pages available for Plan9

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net