WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/newlib/libc/stdio/sprintf.c


/*
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */
 
/*
FUNCTION
<>, <>, <>, <>, <>, <>---format output
 
INDEX
	fprintf
INDEX
	_fprintf_r
INDEX
	printf
INDEX
	_printf_r
INDEX
	asprintf
INDEX
	_asprintf_r
INDEX
	sprintf
INDEX
	_sprintf_r
INDEX
	snprintf
INDEX
	_snprintf_r
INDEX
	asnprintf
INDEX
	_asnprintf_r
 
ANSI_SYNOPSIS
        #include 
 
        int printf(const char *restrict <[format]>, ...);
        int fprintf(FILE *restrict <[fd]>, const char *restrict <[format]>, ...);
        int sprintf(char *restrict <[str]>, const char *restrict <[format]>, ...);
        int snprintf(char *restrict <[str]>, size_t <[size]>, const char *restrict <[format]>,
                     ...);
        int asprintf(char **restrict <[strp]>, const char *restrict <[format]>, ...);
        char *asnprintf(char *restrict <[str]>, size_t *restrict <[size]>, const char *restrict <[format]>,
                        ...);
 
        int _printf_r(struct _reent *<[ptr]>, const char *restrict <[format]>, ...);
        int _fprintf_r(struct _reent *<[ptr]>, FILE *restrict <[fd]>,
                       const char *restrict <[format]>, ...);
        int _sprintf_r(struct _reent *<[ptr]>, char *restrict <[str]>,
                       const char *restrict <[format]>, ...);
        int _snprintf_r(struct _reent *<[ptr]>, char *restrict <[str]>, size_t <[size]>,
                        const char *restrict <[format]>, ...);
        int _asprintf_r(struct _reent *<[ptr]>, char **restrict <[strp]>,
                        const char *restrict <[format]>, ...);
        char *_asnprintf_r(struct _reent *<[ptr]>, char *restrict <[str]>,
                           size_t *restrict <[size]>, const char *restrict <[format]>, ...);
 
DESCRIPTION
        <> accepts a series of arguments, applies to each a
        format specifier from <<*<[format]>>>, and writes the
        formatted data to <>, without a terminating NUL
        character.  The behavior of <> is undefined if there
        are not enough arguments for the format.  <> returns
        when it reaches the end of the format string.  If there are
        more arguments than the format requires, excess arguments are
        ignored.
 
        <> is like <>, except that output is directed
        to the stream <[fd]> rather than <>.
 
        <> is like <>, except that output is directed
        to the buffer <[str]>, and a terminating NUL is output.
        Behavior is undefined if more output is generated than the
        buffer can hold.
 
        <> is like <>, except that output is
        limited to at most <[size]> bytes, including the terminating
        <>.  As a special case, if <[size]> is 0, <[str]> can be
        NULL, and <> merely calculates how many bytes would
        be printed.
 
        <> is like <>, except that the output is
        stored in a dynamically allocated buffer, <[pstr]>, which
        should be freed later with <>.
 
        <> is like <>, except that the return type
        is either the original <[str]> if it was large enough, or a
        dynamically allocated string if the output exceeds *<[size]>;
        the length of the result is returned in *<[size]>.  When
        dynamic allocation occurs, the contents of the original
        <[str]> may have been modified.
 
        For <>, <>, and <>, the behavior
	is undefined if the output <<*<[str]>>> overlaps with one of
	the arguments.  Behavior is also undefined if the argument for
	<<%n>> within <<*<[format]>>> overlaps another argument.
 
        <[format]> is a pointer to a character string containing two
	types of objects: ordinary characters (other than <<%>>),
	which are copied unchanged to the output, and conversion
	specifications, each of which is introduced by <<%>>. (To
	include <<%>> in the output, use <<%%>> in the format string.)
	A conversion specification has the following form:
 
.       %[<[pos]>][<[flags]>][<[width]>][.<[prec]>][<[size]>]<[type]>
 
        The fields of the conversion specification have the following
        meanings:
 
        O+
	o <[pos]>
 
        Conversions normally consume arguments in the order that they
        are presented.  However, it is possible to consume arguments
        out of order, and reuse an argument for more than one
        conversion specification (although the behavior is undefined
        if the same argument is requested with different types), by
        specifying <[pos]>, which is a decimal integer followed by
        '$'.  The integer must be between 1 and  from
        limits.h, and if argument <<%n$>> is requested, all earlier
        arguments must be requested somewhere within <[format]>.  If
        positional parameters are used, then all conversion
        specifications except for <<%%>> must specify a position.
	This positional parameters method is a POSIX extension to the C
	standard definition for the functions.
 
	o <[flags]>
 
	<[flags]> is an optional sequence of characters which control
	output justification, numeric signs, decimal points, trailing
	zeros, and octal and hex prefixes.  The flag characters are
	minus (<<->>), plus (<<+>>), space ( ), zero (<<0>>), sharp
	(<<#>>), and quote (<<'>>).  They can appear in any
	combination, although not all flags can be used for all
	conversion specification types.
 
		o+
		o '
			A POSIX extension to the C standard.  However, this
			implementation presently treats it as a no-op, which
			is the default behavior for the C locale, anyway.  (If
			it did what it is supposed to, when <[type]> were <>,
			<>, <>, <>, <>, <>, or <>, the
			integer portion of the conversion would be formatted
			with thousands' grouping wide characters.)
 
		o -
			The result of the conversion is left
			justified, and the right is padded with
			blanks.  If you do not use this flag, the
			result is right justified, and padded on the
			left.
 
	        o +
			The result of a signed conversion (as
			determined by <[type]> of <>, <>, <>,
			<>, <>, <>, <>, <>, <>, or
			<>) will always begin with a plus or minus
			sign.  (If you do not use this flag, positive
			values do not begin with a plus sign.)
 
		o " " (space)
			If the first character of a signed conversion
		        specification is not a sign, or if a signed
		        conversion results in no characters, the
		        result will begin with a space.  If the space
		        ( ) flag and the plus (<<+>>) flag both
		        appear, the space flag is ignored.
 
	        o 0
			If the <[type]> character is <>, <>,
			<>, <>, <>, <>, <>, <>,
			<>, <>, <>, <>, <>, or <>:  leading
			zeros are used to pad the field width
			(following any indication of sign or base); no
			spaces are used for padding.  If the zero
			(<<0>>) and minus (<<->>) flags both appear,
			the zero (<<0>>) flag will be ignored.  For
			<>, <>, <>, <>, <>, and <>
			conversions, if a precision <[prec]> is
			specified, the zero (<<0>>) flag is ignored.
 
			Note that <<0>> is interpreted as a flag, not
		        as the beginning of a field width.
 
	        o #
			The result is to be converted to an
			alternative form, according to the <[type]>
			character:
 
			o+
			o o
				Increases precision to force the first
				digit of the result to be a zero.
 
			o x
				A non-zero result will have a <<0x>>
				prefix.
 
			o X
				A non-zero result will have a <<0X>>
				prefix.
 
			o a, A, e, E, f, or F
				The result will always contain a
			        decimal point even if no digits follow
			        the point.  (Normally, a decimal point
			        appears only if a digit follows it.)
			        Trailing zeros are removed.
 
			o g or G
				The result will always contain a
			        decimal point even if no digits follow
			        the point.  Trailing zeros are not
			        removed.
 
			o all others
				Undefined.
 
			o-
		o-
 
	o <[width]>
 
		<[width]> is an optional minimum field width.  You can
		either specify it directly as a decimal integer, or
		indirectly by using instead an asterisk (<<*>>), in
		which case an <> argument is used as the field
		width.  If positional arguments are used, then the
		width must also be specified positionally as <<*m$>>,
		with m as a decimal integer.  Negative field widths
		are treated as specifying the minus (<<->>) flag for
		left justfication, along with a positive field width.
		The resulting format may be wider than the specified
		width.
 
	o <[prec]>
 
		<[prec]> is an optional field; if present, it is
		introduced with `<<.>>' (a period). You can specify
		the precision either directly as a decimal integer or
		indirectly by using an asterisk (<<*>>), in which case
		an <> argument is used as the precision.  If
		positional arguments are used, then the precision must
		also be specified positionally as <<*m$>>, with m as a
		decimal integer.  Supplying a negative precision is
		equivalent to omitting the precision.  If only a
		period is specified the precision is zero. The effect
		depends on the conversion <[type]>.
 
		o+
		o d, i, o, u, x, or X
			Minimum number of digits to appear.  If no
			precision is given, defaults to 1.
 
		o a or A
			Number of digits to appear after the decimal
			point.  If no precision is given, the
			precision defaults to the minimum needed for
			an exact representation.
 
		o e, E, f or F
			Number of digits to appear after the decimal
			point.  If no precision is given, the
			precision defaults to 6.
 
		o g or G
			Maximum number of significant digits.  A
			precision of 0 is treated the same as a
			precision of 1.  If no precision is given, the
			precision defaults to 6.
 
		o s or S
			Maximum number of characters to print from the
			string.  If no precision is given, the entire
			string is printed.
 
		o all others
			undefined.
 
		o-
 
	o <[size]>
 
		<[size]> is an optional modifier that changes the data
		type that the corresponding argument has.  Behavior is
		unspecified if a size is given that does not match the
		<[type]>.
 
		o+
		o hh
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument should be
			converted to a <> or <
			char>> before printing.
 
			With <>, specifies that the argument is a
			pointer to a <>.
 
		o h
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument should be
			converted to a <> or <>
			before printing.
 
			With <>, specifies that the argument is a
			pointer to a <>.
 
		o l
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument is a
			<> or <>.
 
			With <>, specifies that the argument has
			type <>.
 
			With <>, specifies that the argument is a
			pointer to <>.
 
			With <>, specifies that the argument is a
			pointer to a <>.
 
			With <>, <>, <>, <>, <>, <>,
			<>, or <>, has no effect (because of
			vararg promotion rules, there is no need to
			distinguish between <> and <>).
 
		o ll
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument is a
			<> or <>.
 
			With <>, specifies that the argument is a
			pointer to a <>.
 
		o j
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument is an
			<> or <>.
 
			With <>, specifies that the argument is a
			pointer to an <>.
 
		o z
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument is a <>.
 
			With <>, specifies that the argument is a
			pointer to a <>.
 
		o t
			With <>, <>, <>, <>, <>, or
			<>, specifies that the argument is a
			<>.
 
			With <>, specifies that the argument is a
			pointer to a <>.
 
		o L
			With <>, <>, <>, <>, <>, <>,
			<>, or <>, specifies that the argument
			is a <>.
 
		o-
 
	o   <[type]>
 
		<[type]> specifies what kind of conversion <>
		performs.  Here is a table of these:
 
		o+
		o %
			Prints the percent character (<<%>>).
 
		o c
			Prints <[arg]> as single character.  If the
			<> size specifier is in effect, a multibyte
			character is printed.
 
		o C
			Short for <<%lc>>.  A POSIX extension to the C standard.
 
		o s
			Prints the elements of a pointer to <>
			until the precision or a null character is
			reached.  If the <> size specifier is in
			effect, the pointer is to an array of
			<>, and the string is converted to
			multibyte characters before printing.
 
		o S
			Short for <<%ls>>.  A POSIX extension to the C standard.
 
		o d or i
			Prints a signed decimal integer; takes an
			<>.  Leading zeros are inserted as
			necessary to reach the precision.  A value of 0 with
			a precision of 0 produces an empty string.
 
		o D
			Newlib extension, short for <<%ld>>.
 
		o o
			Prints an unsigned octal integer; takes an
			<>.  Leading zeros are inserted as
			necessary to reach the precision.  A value of 0 with
			a precision of 0 produces an empty string.
 
		o O
			Newlib extension, short for <<%lo>>.
 
		o u
			Prints an unsigned decimal integer; takes an
			<>.  Leading zeros are inserted as
			necessary to reach the precision.  A value of 0 with
			a precision of 0 produces an empty string.
 
		o U
			Newlib extension, short for <<%lu>>.
 
		o x
			Prints an unsigned hexadecimal integer (using
			<> as digits beyond <<9>>); takes an
			<>.  Leading zeros are inserted as
			necessary to reach the precision.  A value of 0 with
			a precision of 0 produces an empty string.
 
		o X
			Like <>, but uses <> as digits
			beyond <<9>>.
 
		o f
			Prints a signed value of the form
			<<[-]9999.9999>>, with the precision
			determining how many digits follow the decimal
			point; takes a <> (remember that
			<> promotes to <> as a vararg).
			The low order digit is rounded to even.  If
			the precision results in at most DECIMAL_DIG
			digits, the result is rounded correctly; if
			more than DECIMAL_DIG digits are printed, the
			result is only guaranteed to round back to the
			original value.
 
			If the value is infinite, the result is
			<>, and no zero padding is performed.  If
			the value is not a number, the result is
			<>, and no zero padding is performed.
 
		o F
			Like <>, but uses <> and <> for
			non-finite numbers.
 
		o e
			Prints a signed value of the form
			<<[-]9.9999e[+|-]999>>; takes a <>.
			The digit before the decimal point is non-zero
			if the value is non-zero.  The precision
			determines how many digits appear between
			<<.>> and <>, and the exponent always
			contains at least two digits.  The value zero
			has an exponent of zero.  If the value is not
			finite, it is printed like <>.
 
		o E
			Like <>, but using <> to introduce the
			exponent, and like <> for non-finite
			values.
 
		o g
			Prints a signed value in either <> or <>
			form, based on the given value and
			precision---an exponent less than -4 or
			greater than the precision selects the <>
			form.  Trailing zeros and the decimal point
			are printed only if necessary; takes a
			<>.
 
		o G
			Like <>, except use <> or <> form.
 
		o a
			Prints a signed value of the form
			<<[-]0x1.ffffp[+|-]9>>; takes a <>.
			The letters <> are used for digits
			beyond <<9>>.  The precision determines how
			many digits appear after the decimal point.
			The exponent contains at least one digit, and
			is a decimal value representing the power of
			2; a value of 0 has an exponent of 0.
			Non-finite values are printed like <>.
 
		o A
			Like <>, except uses <>, <>, and
			<> instead of lower case.
 
		o n
			Takes a pointer to <>, and stores a count
			of the number of bytes written so far.  No
			output is created.
 
		o p
			Takes a pointer to <>, and prints it in
			an implementation-defined format.  This
			implementation is similar to <<%#tx>>), except
			that <<0x>> appears even for the NULL pointer.
 
		o m
			Prints the output of <>; no
			argument is required.  A GNU extension.
 
		o-
	O-
 
        <<_printf_r>>, <<_fprintf_r>>, <<_asprintf_r>>,
        <<_sprintf_r>>, <<_snprintf_r>>, <<_asnprintf_r>> are simply
        reentrant versions of the functions above.
 
RETURNS
On success, <> and <> return the number of bytes in
the output string, except the concluding <> is not counted.
<> returns the number of bytes that would be in the output
string, except the concluding <> is not counted.  <> and
<> return the number of characters transmitted.
<> returns the original <[str]> if there was enough room,
otherwise it returns an allocated string.
 
If an error occurs, the result of <>, <>,
<>, and <> is a negative value, and the result of
<> is NULL.  No error returns occur for <>.  For
<> and <>, <> may be set according to
<>.  For <> and <>, <> may be set
to ENOMEM if allocation fails, and for <>, <> may be
set to EOVERFLOW if <[size]> or the output length exceeds INT_MAX.
 
BUGS
The ``''' (quote) flag does not work when locale's thousands_sep is not empty.
 
PORTABILITY
ANSI C requires <>, <>, <>, and
<>.  <> and <> are newlib extensions.
 
The ANSI C standard specifies that implementations must support at
least formatted output of up to 509 characters.  This implementation
has no inherent limit.
 
Depending on how newlib was configured, not all format specifiers are
supported.
 
Supporting OS subroutines required: <>, <>, <>,
<>, <>, <>, <>.
*/
 
#include <_ansi.h>
#include 
#include 
#ifdef _HAVE_STDC
#include 
#else
#include 
#endif
#include 
#include "local.h"
 
int
#ifdef _HAVE_STDC
_DEFUN(_sprintf_r, (ptr, str, fmt),
       struct _reent *ptr _AND
       char *__restrict str          _AND
       _CONST char *__restrict fmt _DOTS)
#else
_sprintf_r(ptr, str, fmt, va_alist)
           struct _reent *ptr;
           char *__restrict str;
           _CONST char *__restrict fmt;
           va_dcl
#endif
{
  int ret;
  va_list ap;
  FILE f;
 
  f._flags = __SWR | __SSTR;
  f._bf._base = f._p = (unsigned char *) str;
  f._bf._size = f._w = INT_MAX;
  f._file = -1;  /* No file. */
#ifdef _HAVE_STDC
  va_start (ap, fmt);
#else
  va_start (ap);
#endif
  ret = _svfprintf_r (ptr, &f, fmt, ap);
  va_end (ap);
  *f._p = '\0';	/* terminate the string */
  return (ret);
}
 
#ifndef _REENT_ONLY
 
int
#ifdef _HAVE_STDC
_DEFUN(sprintf, (str, fmt),
       char *__restrict str _AND
       _CONST char *__restrict fmt _DOTS)
#else
sprintf(str, fmt, va_alist)
        char *str;
        _CONST char *fmt;
        va_dcl
#endif
{
  int ret;
  va_list ap;
  FILE f;
 
  f._flags = __SWR | __SSTR;
  f._bf._base = f._p = (unsigned char *) str;
  f._bf._size = f._w = INT_MAX;
  f._file = -1;  /* No file. */
#ifdef _HAVE_STDC
  va_start (ap, fmt);
#else
  va_start (ap);
#endif
  ret = _svfprintf_r (_REENT, &f, fmt, ap);
  va_end (ap);
  *f._p = '\0';	/* terminate the string */
  return (ret);
}
 
#endif
>
>
Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/newlib/libc/stdio/sprintf.c – Rev 4874 → 4921
