/* fprintf.c - print to a file. stdio.h *//* Copyright 1992-1995 Wind River Systems, Inc. *//*modification history--------------------01e,24jan95,rhp  doc: avoid 'L' in fprintf(), no long doubles                  in VxWorks (see SPR#3886)01d,19jul94,dvs  doc tweak (SPR #2512).01c,05mar93,jdi  documentation cleanup for 5.1.01b,20sep92,smb  documentation additions01a,29jul92,jcf  Added OBJ_VERIFY	    smb  taken from UCB stdio*//*DESCRIPTION * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * Chris Torek. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *	This product includes software developed by the University of *	California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors *    may be used to endorse or promote products derived from this software *    without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE.INCLUDE FILE: stdio.h, stdarg.hSEE ALSO: American National Standard X3.159-1989NOMANUAL*/#include "vxWorks.h"#include "stdarg.h"#include "fioLib.h"#include "objLib.h"#include "private/stdioP.h"/******************************************************************************** fprintf - write a formatted string to a stream (ANSI)** This routine writes output to a specified stream under control of the string* <fmt>. The string <fmt> contains ordinary characters, which are written* unchanged, plus conversion specifications, which cause the arguments that* follow <fmt> to be converted and printed as part of the formatted string.** The number of arguments for the format is arbitrary, but they must* correspond to the conversion specifications in <fmt>.  If there are* insufficient arguments, the behavior is undefined.  If the format is* exhausted while arguments remain, the excess arguments are evaluated but* otherwise ignored.  The routine returns when the end of the format string* is encountered.** The format is a multibyte character sequence, beginning and ending in its* initial shift state.  The format is composed of zero or more directives:* ordinary multibyte characters (not `%') that are copied unchanged to the* output stream; and conversion specification, each of which results in* fetching zero or more subsequent arguments.  Each conversion specification* is introduced by the `%' character.  After the `%', the following appear in* sequence:* .iP "" 4* Zero or more flags (in any order) that modify the meaning of the * conversion specification.* .iP* An optional minimum field width.  If the converted value has fewer* characters than the field width, it will be padded with spaces (by* default) on the left (or right, if the left adjustment flag, * described later, has been given) to the field width. The field* width takes the form of an asterisk (`*') (described later) or a decimal* integer.* .iP* An optional precision that gives the minimum number of digits to* appear for the `d', `i', `o', `u', `x', and `X' conversions, the number of * digits to appear after the decimal-point character for `e', `E', and `f'* conversions, the maximum number of significant digits for the `g' and* `G' conversions, or the maximum number of characters to be written * from a string in the `s' conversion.  The precision takes the form of a * period (`.') followed either by an asterisk (`*') (described later) or by* an optional decimal integer; if only the period is specified, the * precision is taken as zero.  If a precision appears with any other* conversion specifier, the behavior is undefined.* .iP* An optional `h' specifying that a following `d', `i', `o', `u', `x', and* `X' conversion specifier applies to a `short int' or `unsigned short int'* argument (the argument will have been promoted according to the integral* promotions, and its value converted to `short int' or* `unsigned short int' before printing); an optional `h' specifying that a* following `n' conversion specifier applies to a pointer to a `short int'* argument; an optional `l' (el) specifying that a following `d', `i', `o',* `u', `x', and `X' conversion specifier applies to a `long int' or* `unsigned long int' argument; or an optional `l' specifying that a following* `n' conversion specifier applies to a pointer to a `long int'* argument.  If an `h' or `l' appears with any other conversion* specifier, the behavior is undefined.** \&WARNING: ANSI C also specifies an optional `L' in some of the same* contexts as `l' above, corresponding to a `long double' argument.* However, the current release of the VxWorks libraries does not support * `long double' data; using the optional `L' gives unpredictable results.* .iP* A character that specifies the type of conversion to be applied.* .LP** As noted above, a field width, or precision, or both, can be indicated by* an asterisk (`*').  In this case, an `int' argument supplies the field width* or precision.  The arguments specifying field width, or precision, or both,* should appear (in that order) before the argument (if any) to be converted.* A negative field width argument is taken as a `-' flag followed by a positive* field width.  A negative precision argument is taken as if the precision* were omitted.** The flag characters and their meanings are:* .iP `-'* The result of the conversion will be left-justified within the field.* (it will be right-justified if this flag is not specified.)* .iP `+'* The result of a signed conversion will always begin with a plus or * minus sign.  (It will begin with a sign only when a negative value* is converted if this flag is not specified.)* .iP `space'* If the first character of a signed conversion is not a sign, or * if a signed conversion results in no characters, a space will be * prefixed to the result.  If the `space' and `+' flags both appear, the* `space' flag will be ignored.* .iP `#'* The result is to be converted to an "alternate form."  For `o' conversion* it increases the precision to force the first digit of the result to be a* zero.  For `x' (or `X') conversion, a non-zero result will have "0x" (or* "0X") prefixed to it.  For `e', `E', `f', `g', and `G' conversions, the* result will always contain a decimal-point character, even if no digits* follow it.  (Normally, a decimal-point character appears in the result of* these conversions only if no digit follows it).  For `g' and `G'* conversions, trailing zeros will not be removed from the result.  For* other conversions, the behavior is undefined.* .iP `0'* For `d', `i', `o', `u', `x', `X', `e', `E', `f', `g', and `G' conversions,* leading zeros (following any indication of sign or base) are used to pad* to the field width; no space padding is performed.  If the `0' and `-'* flags both appear, the `0' flag will be ignored.  For `d', `i', `o', `u',* `x', and `X' conversions, if a precision is specified, the `0' flag will* be ignored.  For other conversions, the behavior is undefined.* .LP** The conversion specifiers and their meanings are:* .iP "`d', `i'"* The `int' argument is converted to signed decimal in the style* `[-]dddd'.  The precision specifies the minimum number of digits * to appear; if the value being converted can be represented in* fewer digits, it will be expanded with leading zeros.  The* default precision is 1.  The result of converting a zero value* with a precision of zero is no characters.* .iP "`o', `u', `x', `X'"* The `unsigned int' argument is converted to unsigned octal (`o'),* unsigned decimal (`u'), or unsigned hexadecimal notation (`x' or `X')* in the style `dddd'; the letters abcdef are used for `x' conversion* and the letters ABCDEF for `X' conversion.  The precision specifies* the minimum number of digits to appear; if the value being * converted can be represented in fewer digits, it will be * expanded with leading zeros.  The default precision is 1.  The* result of converting a zero value with a precision of zero is * no characters.* .iP `f'* The `double' argument is converted to decimal notation in the * style `[-]ddd.ddd', where the number of digits after the decimal* point character is equal to the precision specification.  If the* precision is missing, it is taken as 6; if the precision is zero* and the `#' flag is not specified, no decimal-point character* appears.  If a decimal-point character appears, at least one * digit appears before it.  The value is rounded to the appropriate* number of digits.* .iP "`e', `E'"* The `double' argument is converted in the style `[-]d.ddde+/-dd',* where there is one digit before the decimal-point character * (which is non-zero if the argument is non-zero) and the number* of digits after it is equal to the precision; if the precision* is missing, it is taken as 6; if the precision is zero and the * `#' flag is not specified, no decimal-point character appears.  The* value is rounded to the appropriate number of digits.  The `E'* conversion specifier will produce a number with `E' instead of `e'* introducing the exponent.  The exponent always contains at least* two digits.  If the value is zero, the exponent is zero.* .iP "`g', `G'"* The `double' argument is converted in style `f' or `e' (or in style * `E' in the case of a `G' conversion specifier), with the precision* specifying the number of significant digits.  If the precision* is zero, it is taken as 1.  The style used depends on the * value converted; style `e' (or `E') will be used only if the * exponent resulting from such a conversion is less than -4 or * greater than or equal to the precision.  Trailing zeros are* removed from the fractional portion of the result; a decimal-point* character appears only if it is followed by a digit.* .iP `c'* The `int' argument is converted to an `unsigned char', and the * resulting character is written.* .iP `s'* The argument should be a pointer to an array of character type.* Characters from the array are written up to (but not including)* a terminating null character; if the precision is specified,* no more than that many characters are written.  If the precision* is not specified or is greater than the size of the array, the* array will contain a null character.* .iP `p'* The argument should be a pointer to `void'.  The value of the * pointer is converted to a sequence of printable characters,* in hexadecimal representation (prefixed with "0x").* .iP `n'* The argument should be a pointer to an integer into which* the number of characters written to the output stream* so far by this call to fprintf() is written.  No argument is converted.* .iP `%'* A `%' is written.  No argument is converted.  The complete* conversion specification is %%.* .LP** If a conversion specification is invalid, the behavior is undefined.** If any argument is, or points to, a union or an aggregate (except for an * array of character type using `s' conversion, or a pointer using `p' * conversion), the behavior is undefined.** In no case does a non-existent or small field width cause truncation of a* field if the result of a conversion is wider than the field width, the* field is expanded to contain the conversion result.** INCLUDE FILES: stdio.h ** RETURNS:* The number of characters written, or a negative value if an* output error occurs.** SEE ALSO: printf()*/int fprintf    (    FILE *	  fp,	/* stream to write to */    const char *  fmt,	/* format string */    ...			/* optional arguments to format string */    )    {    int		  ret;    va_list	  vaList;    if (OBJ_VERIFY (fp, fpClassId) != OK)	return (ERROR);    va_start (vaList, fmt);    ret = vfprintf (fp, fmt, vaList);    va_end (vaList);    return (ret);    }