view release on metacpan or  search on metacpan

tests/include/pdclib/include/stdio.h  view on Meta::CPAN

         '-' and '0' are given, '0' is ignored. If a precision is specified for
         any of the "diouxX" conversions, '0' is ignored. Behaviour is only
         defined for "diouxXaAeEfFgG".

   LENGTH MODIFIERS
   hh  For "diouxX" conversions, the argument from the argument stack is
       assumed to be of char width. (It will have been subject to integer
       promotion but will be converted back.) For 'n' conversions, the argument
       is assumed to be a pointer to signed char.
   h   For "diouxX" conversions, the argument from the argument stack is
       assumed to be of short int width. (It will have been subject to integer
       promotion but will be converted back.) For 'n' conversions, the argument
       is assumed to be a pointer to short int.
   l   For "diouxX" conversions, the argument from the argument stack is
       assumed to be of long int width. For 'n' conversions, the argument is
       assumed to be a pointer to short int. For 'c' conversions, the argument
       is assumed to be a wint_t. For 's' conversions, the argument is assumed
       to be a pointer to wchar_t. No effect on "aAeEfFgG" conversions.
   ll  For "diouxX" conversions, the argument from the argument stack is
       assumed to be of long long int width. For 'n' conversions, the argument
       is assumed to be a pointer to long long int.
   j   For "diouxX" conversions, the argument from the argument stack is
       assumed to be of intmax_t width. For 'n' conversions, the argument is
       assumed to be a pointer to intmax_t.
   z   For "diouxX" conversions, the argument from the argument stack is
       assumed to be of size_t width. For 'n' conversions, the argument is
       assumed to be a pointer to size_t.
   t   For "diouxX" conversions, the argument from the argument stack is
       assumed to be of ptrdiff_t width. For 'n' conversions, the argument is
       assumed to be a pointer to ptrdiff_t.
   L   For "aAeEfFgG" conversions, the argument from the argument stack is
       assumed to be a long double.
   Length modifiers appearing for any conversions not mentioned above will have
   undefined behaviour.
   If a length modifier appears with any conversion specifier other than as
   specified above, the behavior is undefined.

   CONVERSION SPECIFIERS
   d,i The argument from the argument stack is assumed to be of type int, and
       is converted to a signed decimal value with a minimum number of digits
       as specified by the precision (default 1), padded with leading zeroes.
       A zero value converted with precision zero yields no output.
   o   The argument from the argument stack is assumed to be of type unsigned
       int, and is converted to an unsigned octal value, other behaviour being
       as above.
   u   The argument from the argument stack is assumed to be of type unsigned
       int, and converted to an unsigned decimal value, other behaviour being
       as above.
   x,X The argument from the argument stack is assumed to be of type unsigned
       int, and converted to an unsigned hexadecimal value, using lowercase
       "abcdef" for 'x' and uppercase "ABCDEF" for 'X' conversion, other
       behaviour being as above.
   f,F The argument from the argument stack is assumed to be of type double,
       and converted to a decimal floating point in decimal-point notation,
       with the number of digits after the decimal point as specified by the
       precision (default 6) and the value being rounded appropriately. If
       precision is zero (and the '#' flag is not given), no decimal point is
       printed. At least one digit is always printed before the decimal point.
       For 'f' conversions, an infinity value is printed as either [-]inf or
       [-]infinity (, depending on the configuration of this implementation. A
       NaN value is printed as [-]nan. For 'F' conversions uppercase characters
       are used for these special values. The flags '-', '+' and ' ' apply as
       usual to these special values, '#' and '0' have no effect.
   e,E The argument from the argument stack is assumed to be of type double,
       and converted to a decimal floating point in normalized exponential
       notation ([?]d.ddd edd). "Normalized" means one nonzero digit before
       the decimal point, unless the value is zero. The number of digits after
       the decimal point is specified by the precision (default 6), the value
       being rounded appropriately. If precision is zero (and the '#' flag is
       not given), no decimal point is printed. The exponent has at least two
       digits, and not more than necessary to represent the exponent. If the
       value is zero, the exponent is zero. The 'e' written to indicate the
       exponend is uppercase for 'E' conversions.
       Infinity or NaN values are represented as for 'f' and 'F' conversions,
       respectively.
   g,G The argument from the argument stack is assumed to be of type double,
       and converted according to either 'f' or 'e' format for 'g' conversions,
       or 'F' or 'E' format for 'G' conversions, respectively, with the actual
       conversion chosen depending on the value. 'e' / 'E' conversion is chosen
       if the resulting exponent is < -4 or >= the precision (default 1).
       Trailing zeroes are removed (unless the '#' flag is given). A decimal
       point appears only if followed by a digit.
       Infinity or NaN values are represented as for 'f' and 'F' conversions,
       respectively.
   a,A The argument from the argument stack is assumed to be of type double,
       and converted to a floating point hexadecimal notation ([?]0xh.hhhh pd)
       with one hexadecimal digit (being nonzero if the value is normalized,
       and otherwise unspecified) before the decimal point, and the number of
       digits after the decimal point being specified by the precision. If no
       precision is given, the default is to print as many digits as nevessary
       to give an exact representation of the value (if FLT_RADIX is a power of
       2). If no precision is given and FLT_RADIX is not a power of 2, the
       default is to print as many digits to distinguish values of type double
       (possibly omitting trailing zeroes). (A precision p is sufficient to
       distinguish values of the source type if 16^p-1 > b^n where b is
       FLT_RADIX and n is the number of digits in the significand (to base b)
       of the source type. A smaller p might suffice depending on the
       implementation's scheme for determining the digit to the left of the
       decimal point.) The error has the correct sign for the current rounding
       direction.
       Unless the '#' flag is given, no decimal-point is given for zero
       precision.
       The 'a' conversion uses lowercase "abcdef", "0x" and 'p', the 'A'
       conversion uppercase "ABCDEF", "0X" and 'P'.
       The exponent always has at least one digit, and not more than necessary
       to represent the decimal exponent of 2. If the value is zero, the
       exponent is zero.
       Infinity or NaN values are represented as for 'f' and 'F' conversions,
       respectively.
       Binary implementations are at liberty to chose the hexadecimal digit to
       the left of the decimal point so that subsequent digits align to nibble
       boundaries.
   c   The argument from the argument stack is assumed to be of type int, and
       converted to a character after the value has been cast to unsigned char.
       If the 'l' length modifier is given, the argument is assumed to be of
       type wint_t, and converted as by a "%ls" conversion with no precision
       and a pointer to a two-element wchar_t array, with the first element
       being the wint_t argument and the second a '\0' wide character.
   s   The argument from the argument stack is assumed to be a char array (i.e.
       pointer to char). Characters from that array are printed until a zero
       byte is encountered or as many bytes as specified by a given precision
       have been written.
       If the l length modifier is given, the argument from the argument stack
       is assumed to be a wchar_t array (i.e. pointer to wchar_t). Wide
       characters from that array are converted to multibyte characters as by
       calls to wcrtomb() (using a mbstate_t object initialized to zero prior
       to the first conversion), up to and including the terminating null wide
       character. The resulting multibyte character sequence is then printed up
       to but not including the terminating null character. If a precision is
       given, it specifies the maximum number of bytes to be written (including
       shift sequences). If the given precision would require access to a wide
       character one past the end of the array, the array shall contain a '\0'
       wide character. In no case is a partial multibyte character written.
       Redundant shift sequences may result if the multibyte characters have a
       state-dependent encoding.
       TODO: Clarify these statements regarding %ls.
   p   The argument from the argument stack is assumed to be a void pointer,
       and converted to a sequence of printing characters in an implementation-
       defined manner.
       This implementation casts the pointer to type intptr_t, and prints the
       value as if a %#x conversion specifier was given.
   n   The argument from the argument stack is assumed to be a pointer to a
       signed integer, into which the number of characters written so far by
       this call to fprintf is stored. The behaviour, should any flags, field
       widths, or precisions be given is undefined.
   %   A verbatim '%' character is written. No argument is taken from the
       argument stack.

   Returns the number of characters written if successful, a negative value
   otherwise.
*/
_PDCLIB_PUBLIC int fprintf( FILE * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, ... );

/* TODO: fscanf() documentation */
/*
   Read input from a given stream, as defined by the given format string, and
   store converted input in the objects pointed to by 0..n subsequent arguments
   (the argument stack).

   The format string contains a sequence of directives that are expected to
   match the input. If such a directive fails to match, the function returns
   (matching error). It also returns if an input error occurs (input error).

   Directives can be:
   - one or more whitespaces, matching any number of whitespaces in the input;
   - printing characters, matching the input verbatim;
   - conversion specifications, which convert an input sequence into a value as
     defined by the individual specifier, and store that value in a memory