XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity
fb5bc1431f
kolibrios-fun/programs/develop/open watcom/trunk/clib/streamio/prtf.c

1101 lines
34 KiB
C
Raw Normal View History

update CLib git-svn-id: svn://kolibrios.org@614 a494cfbc-eb01-0410-851d-a64ba20cac60
2007-08-28 12:31:46 +02:00
/****************************************************************************
*
* Open Watcom Project
*
* Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
* ========================================================================
*
* This file contains Original Code and/or Modifications of Original
* Code as defined in and that are subject to the Sybase Open Watcom
* Public License version 1.0 (the 'License'). You may not use this file
* except in compliance with the License. BY USING THIS FILE YOU AGREE TO
* ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
* provided with the Original Code and Modifications, and is also
* available at www.sybase.com/developer/opensource.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
* ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
* NON-INFRINGEMENT. Please see the License for the specific language
* governing rights and limitations under the License.
*
* ========================================================================
*
* Description: __prtf() - low level string formatter.
*
****************************************************************************/
#define __LONG_LONG_SUPPORT__
#if !defined( __NETWARE__ ) && !defined( __UNIX__ )
#define USE_MBCS_TRANSLATION
#endif
#include "variety.h"
#ifdef SAFE_PRINTF
#include "saferlib.h"
#endif
#include "widechar.h"
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#if defined( __WIDECHAR__ ) || defined( USE_MBCS_TRANSLATION )
#include <mbstring.h>
#endif
#include "ftos.h"
#include "farsupp.h"
#include "printf.h"
#include "prtscncf.h"
#include "fixpoint.h"
#include "myvalist.h"
#define BUF_SIZE 72 /* 64-bit ints formatted as binary can get big */
#define TRUE 1
#define FALSE 0
#define PASCAL_STRING 'S' /* for Novell */
#define WIDE_CHAR_STRING 'S'
#if defined( __QNX_386__ )
/* for use in QNX 32-bit shared library */
#pragma aux __prtf "_sl_*" far;
#endif
#if defined( __QNX__ )
#define EFG_PRINTF __EFG_Format
#else
#define EFG_PRINTF (*__EFG_printf)
#endif
extern FAR_STRING EFG_PRINTF( char *buffer, my_va_list *args, _mbcs_SPECS __SLIB *specs );
#if defined( __WIDECHAR__ )
#define _FAR_OTHER_STRING FAR_ASCII_STRING
#else
#define _FAR_OTHER_STRING FAR_UNI_STRING
#endif
#if defined( __WINDOWS_386__ )
#ifdef __SW_3S
#pragma aux slib_callback_t modify [eax edx ecx fs gs];
#else
#pragma aux slib_callback_t modify [fs gs];
#endif
#endif
/* forward references */
static const CHAR_TYPE *evalflags( const CHAR_TYPE *, SPECS __SLIB * );
static FAR_STRING formstring( CHAR_TYPE *, my_va_list *, SPECS __SLIB *, CHAR_TYPE * );
static const CHAR_TYPE * getprintspecs( const CHAR_TYPE *, my_va_list *, SPECS __SLIB * );
#ifdef USE_MBCS_TRANSLATION
static void write_wide_string( FAR_UNI_STRING str, SPECS *specs,
slib_callback_t *out_putc );
static void write_skinny_string( FAR_ASCII_STRING str, SPECS *specs,
slib_callback_t *out_putc );
#endif
#ifdef SAFE_PRINTF
int __F_NAME(__prtf_s,__wprtf_s)
#else
int __F_NAME(__prtf,__wprtf)
#endif
( void __SLIB *dest, /* parm for use by out_putc */
const CHAR_TYPE *format, /* pointer to format string */
va_list args, /* pointer to pointer to args*/
#ifdef SAFE_PRINTF
const char **msg, /* rt-constraint message */
#endif
slib_callback_t *out_putc ) /* char output routine */
{
CHAR_TYPE buffer[ BUF_SIZE ];
CHAR_TYPE null_char = '\0';
CHAR_TYPE *a;
FAR_STRING arg;
const CHAR_TYPE *ctl;
SPECS specs;
specs._dest = dest;
specs._flags = 0;
specs._version = SPECS_VERSION;
specs._output_count = 0;
ctl = format;
while( *ctl != NULLCHAR ) {
if( *ctl != '%' ) {
(out_putc)( &specs, *ctl++ );
} else {
++ctl;
{
my_va_list pargs;
pargs = MY_VA_LIST( args );
ctl = getprintspecs( ctl, &pargs, &specs );
MY_VA_LIST( args ) = pargs;
}
specs._character = *ctl++;
if( specs._character == NULLCHAR )
break; /* 05-jan-89 */
if( specs._character == 'n' ) {
#ifdef SAFE_PRINTF
/* The %n specifier is not allowed - too dangerous. */
*msg = "%n";
break;
#else
FAR_INT iptr;
#if defined( __FAR_SUPPORT__ )
if( specs._flags & SPF_FAR ) {
iptr = va_arg( args, int _WCFAR * );
} else if( specs._flags & SPF_NEAR ) {
iptr = va_arg( args, int _WCNEAR * );
} else {
iptr = va_arg( args, int * );
}
#else
iptr = va_arg( args, int * );
#endif
if( specs._flags & SPF_CHAR ) {
*((FAR_CHAR)iptr) = specs._output_count;
} else if( specs._flags & SPF_SHORT ) {
*((FAR_SHORT)iptr) = specs._output_count;
} else if( specs._flags & SPF_LONG ) {
*((FAR_LONG)iptr) = specs._output_count;
#if defined( __LONG_LONG_SUPPORT__ )
} else if( specs._flags & SPF_LONG_LONG ) {
*((FAR_INT64)iptr) = specs._output_count;
#endif
} else {
*iptr = specs._output_count;
}
#endif /* SAFE_PRINTF */
} else {
#ifdef SAFE_PRINTF
if( specs._character == 's' || specs._character == 'S' ) {
FAR_STRING str;
va_list args_copy;
/* Make sure %s argument is not NULL. Note that near pointers
* in segmented models need special handling because only
* offset will be NULL, not segment.
*/
va_copy( args_copy, args );
#if defined( __FAR_SUPPORT__ )
if( specs._flags & SPF_FAR ) {
str = va_arg( args_copy, CHAR_TYPE _WCFAR * );
} else if( specs._flags & SPF_NEAR ) {
CHAR_TYPE _WCNEAR *ptr;
ptr = va_arg( args_copy, CHAR_TYPE _WCNEAR * );
if( ptr == NULL ) {
str = NULL;
} else {
str = ptr;
}
} else {
CHAR_TYPE *ptr;
ptr = va_arg( args_copy, CHAR_TYPE * );
if( ptr == NULL ) {
str = NULL;
} else {
str = ptr;
}
}
#else
str = va_arg( args_copy, CHAR_TYPE * );
#endif
va_end( args_copy );
if( str == NULL ) {
*msg = "%s -> NULL";
break; /* bail out */
}
}
#endif /* SAFE_PRINTF */
{
my_va_list pargs;
pargs = MY_VA_LIST( args );
arg = formstring( buffer, &pargs, &specs, &null_char );
MY_VA_LIST( args ) = pargs;
}
specs._fld_width -= specs._n0 +
specs._nz0 +
specs._n1 +
specs._nz1 +
specs._n2 +
specs._nz2;
if( !(specs._flags & SPF_LEFT_ADJUST) ) {
if( specs._pad_char == ' ' ) {
while( specs._fld_width > 0 ) {
(out_putc)( &specs, ' ' );
--specs._fld_width;
}
}
}
a = buffer;
while( specs._n0 > 0 ) {
(out_putc)( &specs, *a );
++a;
--specs._n0;
}
while( specs._nz0 > 0 ) {
(out_putc)( &specs, '0' );
--specs._nz0;
}
if( specs._character == 's' ) {
#if defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
if( specs._flags & SPF_SHORT ) {
write_skinny_string( (FAR_ASCII_STRING)arg, &specs, out_putc );
} else
#elif !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
if( specs._flags & SPF_LONG ) {
write_wide_string( (FAR_UNI_STRING)arg, &specs, out_putc );
} else
#endif
{
while( specs._n1 > 0 ) {
(out_putc)( &specs, *arg++ );
--specs._n1;
}
}
}
#if !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
else if( specs._character == WIDE_CHAR_STRING ) {
write_wide_string( (FAR_UNI_STRING)arg, &specs, out_putc );
} else
#elif !defined( __WIDECHAR__ ) && defined( __NETWARE__ )
else if( specs._character == WIDE_CHAR_STRING ) {
} else
#endif
{
while( specs._n1 > 0 ) {
(out_putc)( &specs, *arg++ );
--specs._n1;
}
}
while( specs._nz1 > 0 ) {
(out_putc)( &specs, '0' );
--specs._nz1;
}
while( specs._n2 > 0 ) {
(out_putc)( &specs, *arg );
++arg;
--specs._n2;
}
while( specs._nz2 > 0 ) {
(out_putc)( &specs, '0' );
--specs._nz2;
}
if( specs._flags & SPF_LEFT_ADJUST ) {
while( specs._fld_width > 0 ) {
(out_putc)( &specs, ' ' );
--specs._fld_width;
}
}
}
}
}
return( specs._output_count );
}
static const CHAR_TYPE * getprintspecs( const CHAR_TYPE *ctl,
my_va_list *pargs,
SPECS __SLIB *specs )
{
specs->_pad_char = ' ';
ctl = evalflags( ctl, specs );
specs->_fld_width = 0;
if( *ctl == '*' ) {
specs->_fld_width = va_arg( pargs->v, int );
if( specs->_fld_width < 0 ) {
specs->_fld_width = - specs->_fld_width;
specs->_flags |= SPF_LEFT_ADJUST;
}
ctl++;
} else {
while(( *ctl >= '0' ) && ( *ctl <= '9' )) {
specs->_fld_width = specs->_fld_width * 10 + ( *ctl++ - '0' );
}
}
specs->_prec = -1;
if( *ctl == '.' ) {
specs->_prec = 0;
ctl++;
if( *ctl == '*' ) {
specs->_prec = va_arg( pargs->v, int );
if( specs->_prec < 0 )
specs->_prec = -1; /* 19-jul-90 */
ctl++;
} else {
while(( *ctl >= '0' ) && ( *ctl <= '9' )) {
specs->_prec = specs->_prec * 10 + ( *ctl++ - '0' );
}
}
/*
"For b, 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 the field width; no space padding is performed. If the 0
or - flags both appear, the 0 flag is ignored. For b, d, i, o,
u, x or X conversions, if a precision is specified, the 0 flag
is ignored. For other conversions, the behaviour is undefined."
*/
// if( specs->_prec != -1 ) specs->_pad_char = ' '; /* 30-jul-95 *//*removed by JBS*/
}
switch( *ctl ) {
case 'l':
#if defined( __LONG_LONG_SUPPORT__ )
if( ctl[1] == 'l' ) {
specs->_flags |= SPF_LONG_LONG;
ctl += 2;
break;
}
#endif
/* fall through */
ZSPEC_CASE_LONG
TSPEC_CASE_LONG
case 'w':
specs->_flags |= SPF_LONG;
ctl++;
break;
case 'h':
if( ctl[1] == 'h' ) {
specs->_flags |= SPF_CHAR;
ctl += 2;
break;
}
specs->_flags |= SPF_SHORT;
ctl++;
break;
#if defined( __LONG_LONG_SUPPORT__ )
case 'I':
if(( ctl[1] == '6' ) && ( ctl[2] == '4' )) {
specs->_flags |= SPF_LONG_LONG;
ctl += 3;
}
break;
JSPEC_CASE_LLONG
/* fall through */
#endif
case 'L':
specs->_flags |= SPF_LONG_DOUBLE | SPF_LONG_LONG;
ctl++;
break;
#if defined( __FAR_SUPPORT__ )
case 'F': /* conflicts with ISO-defined 'F' conversion */
/* fall through */
#endif
case 'W': /* 8086 specific flag for FAR pointer */
specs->_flags |= SPF_FAR;
ctl++;
break;
case 'N': /* 8086 specific flag for NEAR pointer */
specs->_flags |= SPF_NEAR;
ctl++;
break;
#if defined( TSPEC_IS_INT ) || defined( ZSPEC_IS_INT )
TSPEC_CASE_INT /* If either 't' or 'z' spec corresponds to 'int', */
ZSPEC_CASE_INT /* we need to parse and ignore the spec. */
ctl++;
break;
#endif
}
return( ctl );
}
static const CHAR_TYPE *evalflags( const CHAR_TYPE *ctl, SPECS __SLIB *specs )
{
specs->_flags = 0;
for( ; ; ctl++ ) {
if( *ctl == '-' ) {
specs->_flags |= SPF_LEFT_ADJUST;
} else if( *ctl == '#' ) {
specs->_flags |= SPF_ALT;
} else if( *ctl == '+' ) {
specs->_flags |= SPF_FORCE_SIGN;
specs->_flags &= ~SPF_BLANK;
} else if( *ctl == ' ' ) {
if( ( specs->_flags & SPF_FORCE_SIGN ) == 0 ) {
specs->_flags |= SPF_BLANK;
}
} else if( *ctl == '0' ) {
specs->_pad_char = '0';
#ifdef __QNX__
specs->_flags |= SPF_ZERO_PAD;
#endif
} else {
break;
}
}
return( ctl );
}
static int far_strlen( FAR_STRING s, int precision )
{
int len;
len = 0;
while(( len != precision ) && ( *s++ != NULLCHAR ))
++len;
return( len );
}
/*
* far_other_strlen - calculates the length of an ascii string
* for the unicode version
* - calculates the length of a unicode string for
* the standard version
*/
static int far_other_strlen( FAR_STRING s, int precision )
{
int len = 0;
_FAR_OTHER_STRING ptr = (_FAR_OTHER_STRING)s;
#if !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
char mbBuf[MB_CUR_MAX];
int chBytes;
if( precision == -1 ) {
while( *ptr ) {
chBytes = wctomb( mbBuf, *ptr++ );
if( chBytes != -1 ) {
len += chBytes;
}
}
return( len );
}
while( *ptr && ( len <= precision )) {
chBytes = wctomb( mbBuf, *ptr++ );
if( chBytes != -1 ) {
len += chBytes;
}
}
return(( len <= precision ) ? len : precision );
#else
while( *ptr++ && ( len != precision ))
++len;
return( len );
#endif
}
static void fmt4hex( unsigned value, CHAR_TYPE *buf, int maxlen )
{
int i, len;
__F_NAME(itoa,_itow)( value, buf, 16 );
len = __F_NAME(strlen,wcslen)( buf );
for( i = maxlen - 1; len; --i ) {
--len;
buf[i] = buf[len];
}
while( i >= 0 ) {
buf[i] = '0';
--i;
}
buf[maxlen] = NULLCHAR;
}
static void FixedPoint_Format( CHAR_TYPE *buf, long value, SPECS __SLIB *specs )
{
T32 at;
int i;
CHAR_TYPE *bufp;
at.sWhole = value;
if( at.sWhole < 0 ) {
at.sWhole = - at.sWhole;
*buf++ = '-';
}
if( specs->_prec == -1 )
specs->_prec = 4;
__F_NAME(itoa,_itow)( at.wd.hi, buf, 10 );
bufp = buf; /* remember start address of buffer */
while( *buf )
++buf;
if( specs->_prec != 0 ) {
*buf++ = '.';
for( i = 0; i < specs->_prec; i++ ) {
at.wd.hi = 0;
at.uWhole *= 10;
*buf++ = at.bite.b3 + '0';
}
*buf = NULLCHAR;
}
if( at.wd.lo & 0x8000 ) { /* fraction >= .5, need to round */
for(;;) { /* 22-dec-91 */
if( buf == bufp ) {
*buf++ = '1';
while( *buf == '0' )
++buf;
if( *buf == '.' ) {
*buf++ = '0';
*buf++ = '.';
while( *buf == '0' ) {
++buf;
}
}
*buf++ = '0';
*buf = NULLCHAR;
break;
}
--buf;
if( *buf == '.' )
--buf;
if( *buf != '9' ) {
++ *buf;
break;
}
*buf = '0';
}
}
}
static void float_format( CHAR_TYPE *buffer, my_va_list *pargs, SPECS __SLIB *specs )
{
#ifdef __WIDECHAR__
char mbBuffer[BUF_SIZE*MB_CUR_MAX];
_mbcs_SPECS mbSpecs;
int count;
size_t rc;
char *p;
#endif // __WIDECHAR__
#ifdef __WIDECHAR__
/*
* EFG_PRINTF can only handle MBCS buffers and the MBCS version of the
* SPECS structure. So, make a _mbcs_SPECS structure equivalent to the
* _wide_SPECS one, and use that instead. Note that we can't use
* memcpy() because some field sizes are different.
*/
mbSpecs._dest = NULL; /* this field isn't actually used */
mbSpecs._flags = specs->_flags;
mbSpecs._version = specs->_version;
mbSpecs._fld_width = specs->_fld_width;
mbSpecs._prec = specs->_prec;
mbSpecs._output_count = specs->_output_count;
mbSpecs._n0 = specs->_n0;
mbSpecs._nz0 = specs->_nz0;
mbSpecs._n1 = specs->_n1;
mbSpecs._nz1 = specs->_nz1;
mbSpecs._n2 = specs->_n2;
mbSpecs._nz2 = specs->_nz2;
mbSpecs._character = (char)specs->_character;
mbSpecs._pad_char = (char)specs->_pad_char;
#endif
#ifdef __WIDECHAR__
EFG_PRINTF( mbBuffer, pargs, &mbSpecs );
#else
EFG_PRINTF( buffer, pargs, specs );
#endif
#ifdef __WIDECHAR__
/*
* Now convert the returned information back into our _wide_SPECS
* structure. We can't just use mbstowcs because it's an array of
* characters, not a string.
*/
p = mbBuffer;
for( count = 0; count < BUF_SIZE; count++ ) {
rc = mbtowc( &(buffer[count]), p, MB_CUR_MAX );
if( rc == -1 ) {
buffer[count] = L'?';
}
p = _mbsinc( p );
}
specs->_flags = mbSpecs._flags;
specs->_version = mbSpecs._version;
specs->_fld_width = mbSpecs._fld_width;
specs->_prec = mbSpecs._prec;
specs->_output_count = mbSpecs._output_count;
specs->_n0 = mbSpecs._n0;
specs->_nz0 = mbSpecs._nz0;
specs->_n1 = mbSpecs._n1;
specs->_nz1 = mbSpecs._nz1;
specs->_n2 = mbSpecs._n2;
specs->_nz2 = mbSpecs._nz2;
specs->_character = (wchar_t) mbSpecs._character;
specs->_pad_char = (wchar_t) mbSpecs._pad_char;
#endif
}
static void SetZeroPad( SPECS __SLIB *specs )
{
int n;
if( !(specs->_flags & SPF_LEFT_ADJUST) ) {
if( specs->_pad_char == '0' ) {
n = specs->_fld_width - specs->_n0 - specs->_nz0 -
specs->_n1 - specs->_nz1 - specs->_n2 - specs->_nz2;
if( n > 0 ) {
specs->_nz0 += n;
}
}
}
}
#if !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
static void write_wide_string( FAR_UNI_STRING str, SPECS *specs,
slib_callback_t *out_putc )
{
int bytes;
char mbBuf[MB_CUR_MAX];
char *mbBufPtr;
while( specs->_n1 > 0 ) {
bytes = wctomb( mbBuf, *str++ );
if( bytes != -1 ) {
if( bytes <= specs->_n1 ) {
mbBufPtr = mbBuf;
while( bytes-- ) {
(out_putc)( specs, *mbBufPtr++ );
--specs->_n1;
}
} else {
specs->_n1 = 0;
}
}
}
}
#endif
#if defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
static void write_skinny_string( FAR_ASCII_STRING str, SPECS *specs,
slib_callback_t *out_putc )
{
int bytes;
wchar_t wc;
FAR_ASCII_STRING mbPtr = str;
char mbBuf[MB_CUR_MAX];
while( specs->_n1 > 0 ) {
mbBuf[0] = *mbPtr++;
if( _ismbblead( mbBuf[0] ) )
mbBuf[1] = *mbPtr++;
bytes = mbtowc( &wc, mbBuf, MB_CUR_MAX );
if( bytes <= specs->_n1 ) {
if( bytes != -1 ) {
(out_putc)( specs, wc );
specs->_n1 -= bytes;
}
} else {
specs->_n1 = 0;
}
}
}
#endif
static FAR_STRING formstring( CHAR_TYPE *buffer, my_va_list *pargs,
SPECS __SLIB *specs, CHAR_TYPE *null_string )
{
FAR_STRING arg;
int length;
int radix;
#if defined( __LONG_LONG_SUPPORT__ )
unsigned long long long_long_value;
#endif
unsigned long long_value;
unsigned int int_value;
#if defined( __FAR_SUPPORT__ )
unsigned int seg_value;
#endif
#if !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
int bytes;
#endif
arg = buffer;
specs->_n0 = specs->_nz0 =
specs->_n1 = specs->_nz1 =
specs->_n2 = specs->_nz2 = 0;
if( ( specs->_character == 'b' ) ||
( specs->_character == 'o' ) ||
( specs->_character == 'u' ) ||
( specs->_character == 'x' ) ||
( specs->_character == 'X' ) ) {
#if defined( __LONG_LONG_SUPPORT__ )
if( specs->_flags & SPF_LONG_LONG ) {
long_long_value = va_arg( pargs->v, unsigned long long );
} else
#endif
if( specs->_flags & SPF_LONG ) {
long_value = va_arg( pargs->v, unsigned long );
} else {
long_value = va_arg( pargs->v, unsigned );
if( specs->_flags & SPF_SHORT ) { /* JBS 92/02/12 */
long_value = (unsigned short) long_value;
} else if( specs->_flags & SPF_CHAR ) {
long_value = (unsigned char)long_value;
}
}
} else
if( ( specs->_character == 'd' ) ||
( specs->_character == 'i' ) ) {
#if defined( __LONG_LONG_SUPPORT__ )
if( specs->_flags & SPF_LONG_LONG ) {
long_long_value = va_arg( pargs->v, long long );
} else
#endif
if( specs->_flags & SPF_LONG ) {
long_value = va_arg( pargs->v, long );
} else {
long_value = va_arg( pargs->v, int );
if( specs->_flags & SPF_SHORT ) { /* JBS 92/02/12 */
long_value = (short) long_value;
} else if( specs->_flags & SPF_CHAR ) {
long_value = (signed char)long_value;
}
}
{
int negative = FALSE;
#if defined( __LONG_LONG_SUPPORT__ )
if( specs->_flags & SPF_LONG_LONG ) {
if( (long long)long_long_value < 0 ) {
negative = TRUE;
}
} else
#endif
if( (long)long_value < 0 ) {
negative = TRUE;
}
if( negative ) {
buffer[specs->_n0++] = '-';
#if defined( __LONG_LONG_SUPPORT__ )
if( specs->_flags & SPF_LONG_LONG ) {
long_long_value = -long_long_value;
} else
#endif
long_value = - long_value;
} else if( specs->_flags & SPF_FORCE_SIGN ) {
buffer[specs->_n0++] = '+';
} else if( specs->_flags & SPF_BLANK ) {
buffer[specs->_n0++] = ' ';
}
}
}
radix = 10; /* base 10 for 'd', 'i' and 'u' */
switch( specs->_character ) {
case 'f':
case 'F':
if( specs->_flags & SPF_SHORT ) { /* "%hf" 13-jun-91 */
long_value = va_arg( pargs->v, long );
FixedPoint_Format( buffer, long_value, specs );
specs->_n1 = far_strlen( buffer, -1 );
break;
}
/* types f & F fall through */
case 'g':
case 'G':
case 'e':
case 'E':
float_format( buffer, pargs, specs );
SetZeroPad( specs );
arg++; // = &buffer[1];
break;
case 's':
#ifndef __NETWARE__
case WIDE_CHAR_STRING:
#else
case PASCAL_STRING:
#endif
// arg has been initialized to point to buffer
// set buffer[0] to a null character assuming pointer will be NULL
// If pointer is not null, then arg will be assigned the pointer
buffer[0] = '\0'; // assume null pointer
#if defined( __FAR_SUPPORT__ )
if( specs->_flags & SPF_FAR ) {
CHAR_TYPE _WCFAR *temp = va_arg( pargs->v, CHAR_TYPE _WCFAR * );
if( temp ) {
arg = temp;
}
} else if( specs->_flags & SPF_NEAR ) {
CHAR_TYPE _WCNEAR *temp = va_arg( pargs->v, CHAR_TYPE _WCNEAR * );
if( temp ) {
arg = (void *)temp;
}
} else {
CHAR_TYPE *temp = va_arg( pargs->v, CHAR_TYPE * );
if( temp ) {
arg = temp;
}
}
#else
{
CHAR_TYPE *temp = va_arg( pargs->v, CHAR_TYPE * );
if( temp ) {
arg = temp;
}
}
#endif
#ifdef __NETWARE__
if( specs->_character == PASCAL_STRING ) {
#ifdef __WIDECHAR__
if( specs->_flags & SPF_SHORT )
#else
if( specs->_flags & SPF_LONG )
#endif
{
length = *( (_FAR_OTHER_STRING)arg );
arg = (FAR_STRING)( (_FAR_OTHER_STRING)arg + 1 );
} else {
length = *arg++;
}
} else
#elif !defined( __NETWARE__ ) && !defined( __WIDECHAR__ )
if( specs->_character == WIDE_CHAR_STRING ) {
if( specs->_flags & SPF_SHORT ) {
length = far_strlen( arg, specs->_prec );
} else {
length = far_other_strlen( arg, specs->_prec );
}
} else
#endif
#ifdef __WIDECHAR__
if( specs->_flags & SPF_SHORT ) {
#else
if( specs->_flags & SPF_LONG ) {
#endif
length = far_other_strlen( arg, specs->_prec );
} else {
length = far_strlen( arg, specs->_prec );
}
specs->_n1 = length;
if(( specs->_prec >= 0 ) && ( specs->_prec < length )) {
specs->_n1 = specs->_prec;
}
break;
case 'x':
case 'X':
if( specs->_flags & SPF_ALT ) {
#if defined( __LONG_LONG_SUPPORT__ )
if( specs->_flags & SPF_LONG_LONG ) {
if( long_long_value != 0 ) {
buffer[specs->_n0++] = '0';
buffer[specs->_n0++] = specs->_character;
}
} else
#endif
if( long_value != 0 ) {
buffer[specs->_n0++] = '0';
buffer[specs->_n0++] = specs->_character;
}
}
radix = 16; /* base 16 */
goto processNumericTypes;
case 'b': /* CDH 2003 Apr 23 *//* Add binary mode */
radix = 2; /* base 2 */
goto processNumericTypes;
case 'o':
radix = 8; /* base 8 */
/* 'o' conversion falls through */
case 'd':
case 'i':
case 'u':
// 'x' and 'X' jumps here
processNumericTypes:
if( specs->_prec != -1 )
specs->_pad_char = ' '; /* 30-jul-95, 11-may-99 */
/* radix contains the base; 8 for 'o', 10 for 'd' and 'i' and 'u',
16 for 'x' and 'X', and 2 for 'b' */
arg = &buffer[ specs->_n0 ];
#if defined( __LONG_LONG_SUPPORT__ )
if( specs->_flags & SPF_LONG_LONG ) {
if(( specs->_prec == 0 ) && ( long_long_value == 0 )) {
*arg = '\0';
length = 0;
} else {
__F_NAME(ulltoa,_ulltow)( long_long_value, &buffer[specs->_n0], radix );
if( specs->_character == 'X' ) {
__F_NAME(strupr,_wcsupr)( buffer );
}
length = far_strlen( arg, -1 );
}
} else
#endif
if(( specs->_prec == 0 ) && ( long_value == 0 )) {
*arg = '\0';
length = 0;
} else {
__F_NAME(ultoa,_ultow)( long_value, &buffer[specs->_n0], radix );
if( specs->_character == 'X' ) {
__F_NAME(strupr,_wcsupr)( buffer );
}
length = far_strlen( arg, -1 );
}
specs->_n1 = length;
if( specs->_n1 < specs->_prec ) {
specs->_nz0 = specs->_prec - specs->_n1;
} else if( specs->_flags & SPF_ALT && radix < 10
&& (!length || (arg[0] != '0')) ) {
/* For 'b' and 'o' conversions, alternate format forces the number to
* start with a zero (effectively increases precision by one), but
* only if it doesn't start with a zero already.
*/
++specs->_nz0;
}
if( specs->_prec == -1 ) {
SetZeroPad( specs );
}
break;
case 'p':
case 'P':
#if defined( __FAR_SUPPORT__ )
#if defined( __BIG_DATA__ )
if( !( specs->_flags & (SPF_NEAR|SPF_FAR) ) ) {
specs->_flags |= SPF_FAR;
}
if( specs->_fld_width == 0 ) {
if( specs->_flags & SPF_NEAR ) {
specs->_fld_width = sizeof( unsigned ) * 2;
} else {
specs->_fld_width = sizeof( CHAR_TYPE _WCFAR * ) * 2 + 1;
}
}
#else
if( specs->_fld_width == 0 ) {
if( specs->_flags & SPF_FAR ) {
specs->_fld_width = sizeof( CHAR_TYPE _WCFAR * ) * 2 + 1;
} else {
specs->_fld_width = sizeof( unsigned ) * 2;
}
}
#endif
#else
if( specs->_fld_width == 0 ) {
specs->_fld_width = sizeof( unsigned ) * 2;
}
#endif
specs->_flags &= ~( SPF_BLANK | SPF_FORCE_SIGN );
int_value = va_arg( pargs->v, unsigned ); /* offset */
#if defined( __FAR_SUPPORT__ )
if( specs->_flags & SPF_FAR ) {
seg_value = va_arg( pargs->v, unsigned ) & 0xFFFF; /* segment */
/* use "unsigned short" for 386 instead of "unsigned" 21-jul-89 */
fmt4hex( seg_value, buffer, sizeof( unsigned short ) * 2 );
buffer[sizeof(unsigned short)*2] = ':';
fmt4hex( int_value, buffer + sizeof( unsigned short ) * 2 + 1,
sizeof( unsigned ) * 2 );
} else {
fmt4hex( int_value, buffer, sizeof( unsigned ) * 2 );
}
#else
fmt4hex( int_value, buffer, sizeof( unsigned ) * 2 );
#endif
if( specs->_character == 'P' ) {
__F_NAME(strupr,_wcsupr)( buffer );
}
specs->_n0 = far_strlen( arg, -1 );
break;
case 'c':
#if defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
if( specs->_flags & SPF_SHORT ) {
char * mbPtr;
char mbBuf[MB_CUR_MAX];
wchar_t wc;
mbPtr = va_arg( pargs->v, char* );
mbBuf[0] = mbPtr[0];
if( _ismbblead( mbBuf[0] ) )
mbBuf[1] = mbPtr[1];
if( mbtowc( &wc, mbBuf, MB_CUR_MAX ) != -1 ) {
buffer[0] = wc;
}
} else {
buffer[0] = va_arg( pargs->v, int );
}
specs->_n0 = 1;
#elif !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
specs->_n0 = 1;
if( specs->_flags & SPF_LONG ) {
char mbBuf[MB_CUR_MAX];
wchar_t wc;
wc = va_arg( pargs->v, int );
if( wctomb( mbBuf, wc ) != -1 ) {
buffer[0] = mbBuf[0];
if( _ismbblead( mbBuf[0] ) ) {
buffer[1] = mbBuf[1];
specs->_n0++;
}
}
} else {
buffer[0] = va_arg( pargs->v, int );
}
#else
specs->_n0 = 1;
buffer[0] = va_arg( pargs->v, int );
#endif
break;
#if !defined( __WIDECHAR__ ) && defined( USE_MBCS_TRANSLATION )
case 'C':
bytes = wctomb( buffer, va_arg( pargs->v, int ) );
// if( bytes != -1 && bytes <= specs->_prec ) {
if( bytes != -1 ) { /* Normative Addendum 4.5.3.3.1: no precision */
specs->_n0 = bytes;
} else {
specs->_n0 = 0;
}
break;
#endif
default:
specs->_fld_width = 0;
buffer[ 0 ] = specs->_character;
specs->_n0 = 1;
break;
}
return( arg );
}
Copy Permalink