wasCSharpSQLite – Rev 1
?pathlinks?
/*
* FormatCmd.java
*
* Copyright (c) 1997 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
*
* Included in SQLite3 port to C# for use in testharness only; 2008 Noah B Hart
*
* RCS @(#) $Id: FormatCmd.java,v 1.7 2003/02/01 00:56:29 mdejong Exp $
*
*/
using System;
using System.Text;
namespace tcl.lang
{
/// <summary> This class implements the built-in "format" command in Tcl.</summary>
class FormatCmd : Command
{
private const int LEFT_JUSTIFY = 1;
private const int SHOW_SIGN = 2;
private const int SPACE_OR_SIGN = 4;
private const int PAD_W_ZERO = 8;
private const int ALT_OUTPUT = 16;
private const int SIGNED_VALUE = 32;
private const int RADIX = 1; // Integer types. %d, %x, %o
private const int FLOAT = 2; // Floating point. %f
private const int EXP = 3; // Exponentional. %e and %E
private const int GENERIC = 4; // Floating or exponential,
// depending on exponent. %g
/// <summary> This procedure is invoked to process the "format" Tcl command.
/// See the user documentation for details on what it does.
///
/// The first argument to the cmdProc is the formatString. The cmdProc
/// simply copies all the chars into the sbuf until a '%' is found. At
/// this point the cmdProc parces the formatString and determines the
/// format parameters. The parcing of the formatString can be broken into
/// six possible phases:
///
/// Phase 0 - Simply Print: If the next char is %
/// Phase 1 - XPG3 Position Specifier: If the format [1-n]$ is used
/// Phase 2 - A Set of Flags: One or more of the following + -
/// [space] 0 #
/// Phase 3 - A Minimun Field Width Either [integer] or *
/// Phase 4 - A Precision If the format .[integer] or .*
/// Phase 5 - A Length Modifier If h is present
/// Phase 6 - A Conversion Character If one of the following is used
/// d u i o x X c s f E g G
///
/// Any phase can skip ahead one or more phases, but are not allowed
/// to move back to previous phases. Once the parameters are determined
/// the cmdProc calls one of three private methods that returns a fully
/// formatted string. This loop occurs for ever '%' in the formatString.
/// </summary>
public TCL.CompletionCode cmdProc( Interp interp, TclObject[] argv )
{
StringBuilder sbuf; // Stores the return value of the parsed
// format string
StrtoulResult stoul; // A return object to the strtoul call
char[] format; // The format argument is converted to a char
// array and manipulated as such
int phase; // Stores the current phase of the parsing
int width; // Minimum field width
int precision; // Field precision from field specifier
int fmtFlags; // Used to store the format flags ( #,+,etc)
int argIndex; // Index of argument to substitute next.
int fmtIndex; // Used to locate end of the format fields.
int endIndex; // Used to locate end of numerical fields.
int intValue; // Generic storage variable
long lngValue; // Store the TclInteger.get() result
double dblValue; // Store the TclDouble.get() result
bool noPercent; // Special case for speed: indicates there's
// no field specifier, just a string to copy.
bool xpgSet; // Indicates that xpg has been used for the
// particular format of the main while loop
bool gotXpg; // True means that an XPG3 %n$-style
// specifier has been seen.
bool gotSequential; // True means that a regular sequential
// (non-XPG3) conversion specifier has
// been seen.
bool useShort; // Value to be printed is short
// (half word).
bool precisionSet; // Used for f, e, and E conversions
bool cont; // Used for phase 3
if ( argv.Length < 2 )
{
throw new TclNumArgsException( interp, 1, argv, "formatString ?arg arg ...?" );
}
argIndex = 2;
fmtIndex = 0;
gotXpg = gotSequential = false;
format = argv[1].ToString().ToCharArray();
sbuf = new StringBuilder();
// So, what happens here is to scan the format string one % group
// at a time, making many individual appends to the StringBuffer.
while ( fmtIndex < format.Length )
{
fmtFlags = phase = width = 0;
noPercent = true;
xpgSet = precisionSet = useShort = false;
precision = -1;
// Append all characters to sbuf that are not used for the
// format specifier.
if ( format[fmtIndex] != '%' )
{
int i;
for ( i = fmtIndex; ( i < format.Length ); i++ )
{
if ( format[i] == '%' )
{
noPercent = false;
break;
}
}
sbuf.Append( new string( format, fmtIndex, i - fmtIndex ) );
fmtIndex = i;
if ( noPercent )
{
break;
}
}
// If true, then a % has been indicated but we are at the end
// of the format string. Call function to throw exception.
if ( fmtIndex + 1 >= format.Length )
{
errorEndMiddle( interp );
}
// Phase 0:
// Check for %%. If true then simply write a single '%'
// to the list.
checkOverFlow( interp, format, fmtIndex + 1 );
if ( format[fmtIndex + 1] == '%' )
{
sbuf.Append( "%" );
fmtIndex += 2;
// Re-enter the loop
continue;
}
fmtIndex++;
checkOverFlow( interp, format, fmtIndex );
if ( System.Char.IsDigit( format[fmtIndex] ) )
{
// Parce the format array looking for the end of
// the number.
stoul = strtoul( format, fmtIndex );
intValue = (int)stoul.value;
endIndex = stoul.index;
if ( format[endIndex] == '$' )
{
if ( intValue == 0 )
{
errorBadIndex( interp, true );
}
// Phase 1:
// Check for an XPG3-style %n$ specification.
// Note: there must not be a mixture of XPG3
// specs and non-XPG3 specs in the same format string.
if ( gotSequential )
{
errorMixedXPG( interp );
}
gotXpg = true;
xpgSet = true;
phase = 2;
fmtIndex = endIndex + 1;
argIndex = intValue + 1;
if ( ( argIndex < 2 ) || ( argIndex >= argv.Length ) )
{
errorBadIndex( interp, gotXpg );
}
}
else
{
// Phase 3:
// Format jumped straight to phase 3; Setting
// width field. Again, verify that all format
// specifiers are sequential.
if ( gotXpg )
{
errorMixedXPG( interp );
}
gotSequential = true;
if ( format[fmtIndex] != '0' )
{
fmtIndex = endIndex;
width = intValue;
phase = 4;
}
}
}
else
{
if ( gotXpg )
{
errorMixedXPG( interp );
}
gotSequential = true;
}
// Phase 2:
// Setting the Format Flags. At this point the phase value
// can be either zero or three. Anything greater is an
// incorrect format.
if ( phase < 3 )
{
checkOverFlow( interp, format, fmtIndex );
char ch = format[fmtIndex];
cont = true;
while ( cont )
{
switch ( ch )
{
case '-':
{
fmtFlags |= LEFT_JUSTIFY;
break;
}
case '#':
{
fmtFlags |= ALT_OUTPUT;
break;
}
case '0':
{
fmtFlags |= PAD_W_ZERO;
break;
}
case ' ':
{
fmtFlags |= SPACE_OR_SIGN;
break;
}
case '+':
{
fmtFlags |= SHOW_SIGN;
break;
}
default:
{
cont = false;
}
break;
}
if ( cont )
{
fmtIndex++;
checkOverFlow( interp, format, fmtIndex );
ch = format[fmtIndex];
}
}
phase = 3;
}
// Phase 3:
// Setting width field. Partially redundant code from the
// Phase 1 if/else statement, but this is made to run fast.
checkOverFlow( interp, format, fmtIndex );
if ( System.Char.IsDigit( format[fmtIndex] ) )
{
stoul = strtoul( format, fmtIndex );
width = (int)stoul.value;
fmtIndex = stoul.index;
}
else if ( format[fmtIndex] == '*' )
{
if ( argv.Length > argIndex )
{
width = TclInteger.get( interp, argv[argIndex] );
if ( width < 0 )
{
width = -width;
fmtFlags |= LEFT_JUSTIFY;
}
argIndex++;
fmtIndex++;
}
}
// Phase 4:
// Setting the precision field.
checkOverFlow( interp, format, fmtIndex );
if ( format[fmtIndex] == '.' )
{
fmtIndex++;
checkOverFlow( interp, format, fmtIndex );
if ( System.Char.IsDigit( format[fmtIndex] ) )
{
precisionSet = true;
stoul = strtoul( format, fmtIndex );
precision = (int)stoul.value;
fmtIndex = stoul.index;
}
else if ( format[fmtIndex] == '*' )
{
if ( argv.Length > argIndex )
{
precisionSet = true;
precision = TclInteger.get( interp, argv[argIndex] );
argIndex++;
fmtIndex++;
checkOverFlow( interp, format, fmtIndex );
}
}
else
{
// Format field had a '.' without an integer or '*'
// preceeding it (eg %2.d or %2.-5d)
errorBadField( interp, format[fmtIndex] );
}
}
// Phase 5:
// Setting the length modifier.
if ( format[fmtIndex] == 'h' )
{
fmtIndex++;
checkOverFlow( interp, format, fmtIndex );
useShort = true;
}
else if ( format[fmtIndex] == 'l' )
{
fmtIndex++;
checkOverFlow( interp, format, fmtIndex );
// 'l' is ignored, but should still be processed.
}
if ( ( argIndex < 2 ) || ( argIndex >= argv.Length ) )
{
errorBadIndex( interp, gotXpg );
}
// Phase 6:
// Setting conversion field.
// At this point, variables are initialized as follows:
//
// width The specified field width. This is always
// non-negative. Zero is the default.
// precision The specified precision. The default
// is -1.
// argIndex The argument index from the argv array
// for the appropriate arg.
// fmtFlags The format flags are set via bitwise
// operations. Below are the bits
// and their meanings.
// ALT_OUTPUT set if a '#' is present.
// SHOW_SIGN set if a '+' is present.
// SPACE_OR_SIGN set if a ' ' is present.
// LEFT_JUSTIFY set if a '-' is present or if the
// field width was negative.
// PAD_W_ZERO set if a '0' is present
string strValue = "";
char index = format[fmtIndex];
switch ( index )
{
case 'u':
case 'd':
case 'o':
case 'x':
case 'X':
case 'i':
{
if ( index == 'u' )
{
// Since Java does not provide unsigned ints we need to
// make our own. If the value is negative we need to
// clear out all of the leading bits from the 33rd bit
// and on. The result is a long value equal to that
// of an unsigned int.
lngValue = (long)TclInteger.get( interp, argv[argIndex] );
if ( lngValue < 0 )
{
lngValue = ( lngValue << 32 );
lngValue = ( SupportClass.URShift( lngValue, 32 ) );
}
}
else
{
fmtFlags |= SIGNED_VALUE;
lngValue = (long)TclInteger.get( interp, argv[argIndex] );
}
// If the useShort option has been selected, we need
// to clear all but the first 16 bits.
if ( useShort )
{
lngValue = ( lngValue << 48 );
lngValue = ( lngValue >> 48 );
}
if ( index == 'o' )
{
sbuf.Append( cvtLngToStr( lngValue, width, precision, fmtFlags, 8, "01234567".ToCharArray(), "0" ) );
}
else if ( index == 'x' )
{
sbuf.Append( cvtLngToStr( lngValue, width, precision, fmtFlags, 16, "0123456789abcdef".ToCharArray(), "0x" ) );
}
else if ( index == 'X' )
{
sbuf.Append( cvtLngToStr( lngValue, width, precision, fmtFlags, 16, "0123456789ABCDEF".ToCharArray(), "0X" ) );
}
else
{
sbuf.Append( cvtLngToStr( lngValue, width, precision, fmtFlags, 10, "0123456789".ToCharArray(), "" ) );
}
break;
}
case 'c':
{
intValue = 0;
char[] arr = new char[] { (char)TclInteger.get( interp, argv[argIndex] ) };
strValue = new string( arr );
sbuf.Append( cvtStrToStr( strValue, width, precision, fmtFlags ) );
break;
}
case 's':
{
strValue = argv[argIndex].ToString();
sbuf.Append( cvtStrToStr( strValue, width, precision, fmtFlags ) );
break;
}
case 'f':
{
dblValue = TclDouble.get( interp, argv[argIndex] );
sbuf.Append( cvtDblToStr( dblValue, width, precision, fmtFlags, 10, "0123456789".ToCharArray(), "", FLOAT ) );
break;
}
case 'e':
{
dblValue = TclDouble.get( interp, argv[argIndex] );
sbuf.Append( cvtDblToStr( dblValue, width, precision, fmtFlags, 10, "e".ToCharArray(), "", EXP ) );
break;
}
case 'E':
{
dblValue = TclDouble.get( interp, argv[argIndex] );
sbuf.Append( cvtDblToStr( dblValue, width, precision, fmtFlags, 10, "E".ToCharArray(), "", EXP ) );
break;
}
case 'g':
{
dblValue = TclDouble.get( interp, argv[argIndex] );
sbuf.Append( cvtDblToStr( dblValue, width, precision, fmtFlags, 10, "e".ToCharArray(), "", GENERIC ) );
break;
}
case 'G':
{
dblValue = TclDouble.get( interp, argv[argIndex] );
sbuf.Append( cvtDblToStr( dblValue, width, precision, fmtFlags, 10, "E".ToCharArray(), "", GENERIC ) );
break;
}
default:
{
errorBadField( interp, format[fmtIndex] );
}
break;
}
fmtIndex++;
argIndex++;
}
interp.setResult( sbuf.ToString() );
return TCL.CompletionCode.RETURN;
}
/// <summary> This procedure is invoked in "phase 6" od the Format cmdProc. It
/// converts the lngValue to a string with a specified format determined by
/// the other input variables.
/// </summary>
/// <param name="lngValue"> - Is the value of the argument input
/// </param>
/// <param name="width"> - The minimum width of the string.
/// </param>
/// <param name="precision">- The minimum width if the integer. If the string len
/// is less than precision, leading 0 are appended.
/// </param>
/// <param name="flags"> - Specifies various formatting to the string
/// representation (-, +, space, 0, #)
/// </param>
/// <param name="base"> - The base of the integer (8, 10, 16)
/// </param>
/// <param name="charSet"> - The char set to use for the conversion to ascii OR
/// The char used for sci notation.
/// </param>
/// <param name="altPrefix">- If not empty, str to append on the beginnig of the
/// resulting string (eg 0 or 0x or 0X ).
/// </param>
/// <returns> String representation of the long.
/// </returns>
private string cvtLngToStr( long lngValue, int width, int precision, int flags, int base_, char[] charSet, string altPrefix )
{
StringBuilder sbuf = new StringBuilder( 100 );
StringBuilder tmpBuf = new StringBuilder( 0 ).Append( "" );
int i;
int length;
int nspace;
int prefixSize = 0;
char prefix = (char)( 0 );
// For the format %#x, the value zero is printed "0" not "0x0".
// I think this is stupid.
if ( lngValue == 0 )
{
flags = ( flags | ALT_OUTPUT );
}
if ( ( flags & SIGNED_VALUE ) != 0 )
{
if ( lngValue < 0 )
{
if ( altPrefix.Length > 0 )
{
lngValue = ( lngValue << 32 );
lngValue = ( SupportClass.URShift( lngValue, 32 ) );
}
else
{
lngValue = -lngValue;
prefix = '-';
prefixSize = 1;
}
}
else if ( ( flags & SHOW_SIGN ) != 0 )
{
prefix = '+';
prefixSize = 1;
}
else if ( ( flags & SPACE_OR_SIGN ) != 0 )
{
prefix = ' ';
prefixSize = 1;
}
}
if ( ( ( PAD_W_ZERO & flags ) != 0 ) && ( precision < width - prefixSize ) )
{
precision = width - prefixSize;
}
// Convert to ascii
do
{
sbuf.Insert( 0, charSet[(int)( lngValue % base_ )] );
lngValue = lngValue / base_;
}
while ( lngValue > 0 );
length = sbuf.Length;
for ( i = ( precision - length ); i > 0; i-- )
{
sbuf.Insert( 0, '0' );
}
if ( prefix != 0 )
{
sbuf.Insert( 0, prefix );
}
if ( ( flags & ALT_OUTPUT ) != 0 )
{
if ( ( altPrefix.Length > 0 ) && ( sbuf[0] != altPrefix[0] ) )
{
sbuf.Insert( 0, altPrefix );
}
}
// The text of the conversion is pointed to by "bufpt" and is
// "length" characters long. The field width is "width". Do
// the output.
nspace = width - sbuf.Length;
if ( nspace > 0 )
{
tmpBuf = new StringBuilder( nspace );
for ( i = 0; i < nspace; i++ )
{
tmpBuf.Append( " " );
}
}
if ( ( LEFT_JUSTIFY & flags ) != 0 )
{
// left justified
return sbuf.ToString() + tmpBuf.ToString();
}
else
{
// right justified
return tmpBuf.ToString() + sbuf.ToString();
}
}
internal static string toString( double dblValue, int precision, int base_ )
{
return cvtDblToStr( dblValue, 0, precision, 0, base_, "e".ToCharArray(), null, GENERIC );
}
/// <summary> This procedure is invoked in "phase 6" od the Format cmdProc. It
/// converts the lngValue to a string with a specified format determined
/// by the other input variables.
/// </summary>
/// <param name="dblValue"> - Is the value of the argument input
/// </param>
/// <param name="width"> - The minimum width of the string.
/// </param>
/// <param name="precision">- The minimum width if the integer. If the string len
/// is less than precision, leading 0 are appended.
/// </param>
/// <param name="flags"> - Specifies various formatting to the string
/// representation (-, +, space, 0, #)
/// </param>
/// <param name="base"> - The base of the integer (8, 10, 16)
/// </param>
/// <param name="charSet"> - The char set to use for the conversion to ascii OR
/// The char used for sci notation.
/// </param>
/// <param name="altPrefix">- If not empty, str to append on the beginnig of the
/// resulting string (eg 0 or 0x or 0X ).
/// </param>
/// <param name="xtype"> - Either FLOAT, EXP, or GENERIC depending on the
/// format specifier.
/// </param>
/// <returns> String representation of the long.
/// </returns>
private static string cvtDblToStr( double dblValue, int width, int precision, int flags, int base_, char[] charSet, string altPrefix, int xtype )
{
if ( base_ == 10 )
return dblValue.ToString();
StringBuilder sbuf = new StringBuilder( 100 );
int i;
int exp;
int length;
int count;
int digit;
int prefixSize = 0;
char prefix = (char)( 0 );
double rounder;
bool flag_exp = false; // Flag for exponential representation
bool flag_rtz = true; // Flag for "remove trailing zeros"
bool flag_dp = true; // Flag for remove "decimal point"
if ( System.Double.IsNaN( dblValue ) )
{
return "NaN";
}
if ( dblValue == System.Double.NegativeInfinity )
{
return "-Inf";
}
if ( dblValue == System.Double.PositiveInfinity )
{
return "Inf";
}
// If precision < 0 (eg -1) then the precision defaults
if ( precision < 0 )
{
precision = 6;
}
if ( dblValue < 0.0 )
{
dblValue = -dblValue;
prefix = '-';
prefixSize = 1;
}
// ATK I do not know how C# can note negative 0
// else if (dblValue == 0.0 && (dblValue).Equals((- 0.0)))
// {
// // Handle -0.0
// //
// // 15.19.1 "Numerical Comparison Operators <, <=, >, and >= "
// // of the Java Language Spec says:
// // "Positive zero and negative zero are considered
// // equal. Therefore, -0.0<0.0 is false, for example, but
// // -0.0<=0.0 is true."
// //
// // The Double.equal man page says:
// // "If d1 represents +0.0 while d2 represents -0.0, or
// // vice versa, the equal test has the value false, even
// // though +0.0==-0.0 has the value true. This allows
// // hashtables to operate properly.
//
// dblValue = - dblValue;
// prefix = '-';
// prefixSize = 1;
// }
else if ( ( flags & SHOW_SIGN ) != 0 )
{
prefix = '+';
prefixSize = 1;
}
else if ( ( flags & SPACE_OR_SIGN ) != 0 )
{
prefix = ' ';
prefixSize = 1;
}
// For GENERIC xtypes the precision includes the ones digit
// so just decrement to get the correct precision.
if ( xtype == GENERIC && precision > 0 )
{
precision--;
}
// Rounding works like BSD when the constant 0.4999 is used. Wierd!
//for (i = precision, rounder = 0.4999; i > 0; i--, rounder *= 0.1)
//;
string ss = "0." + new String( '0', precision ) + "4999";
rounder = Convert.ToDouble( ss );
if ( xtype == FLOAT )
{
dblValue += rounder;
}
// Normalize dblValue to within 10.0 > dblValue >= 1.0
exp = 0;
if ( dblValue > 0.0 )
{
int k = 0;
while ( ( dblValue >= 1e8 ) && ( k++ < 100 ) )
{
dblValue *= 1e-8;
exp += 8;
}
while ( ( dblValue >= 10.0 ) && ( k++ < 100 ) )
{
dblValue *= 0.1;
exp++;
}
while ( ( dblValue < 1e-8 ) && ( k++ < 100 ) )
{
dblValue *= 1e8;
exp -= 8;
}
while ( ( dblValue < 1.0 ) && ( k++ < 100 ) )
{
dblValue *= 10.0;
exp--;
}
if ( k >= 100 )
{
return "NaN";
}
}
// If the field type is GENERIC, then convert to either EXP
// or FLOAT, as appropriate.
flag_exp = xtype == EXP;
if ( xtype != FLOAT )
{
//dblValue += rounder;
if ( dblValue >= 10.0 )
{
dblValue *= 0.1;
exp++;
}
}
if ( xtype == GENERIC )
{
flag_rtz = !( ( flags & ALT_OUTPUT ) != 0 );
if ( ( exp < -4 ) || ( exp > precision ) )
{
xtype = EXP;
}
else
{
precision = ( precision - exp );
xtype = FLOAT;
}
}
else
{
flag_rtz = false;
}
// The "exp+precision" test causes output to be of type EXP if
// the precision is too large to fit in buf[].
count = 0;
if ( xtype == FLOAT )
{
flag_dp = ( ( precision > 0 ) || ( ( flags & ALT_OUTPUT ) != 0 ) );
if ( prefixSize > 0 )
{
// Sign
sbuf.Append( prefix );
}
if ( exp < 0 )
{
// Digits before "."
sbuf.Append( '0' );
}
for ( ; exp >= 0; exp-- )
{
if ( count++ >= 16 )
{
sbuf.Append( '0' );
}
else
{
digit = (int)dblValue;
dblValue = ( dblValue - digit ) * 10.0;
sbuf.Append( digit );
}
}
if ( flag_dp )
{
sbuf.Append( '.' );
}
for ( exp++; ( exp < 0 ) && ( precision > 0 ); precision--, exp++ )
{
sbuf.Append( '0' );
}
while ( ( precision-- ) > 0 )
{
if ( count++ >= 16 )
{
sbuf.Append( '0' );
}
else
{
digit = (int)dblValue;
dblValue = ( dblValue - digit ) * 10.0;
sbuf.Append( digit );
}
}
if ( flag_rtz && flag_dp )
{
// Remove trailing zeros and "."
int len, index;
len = index = 0;
for ( len = ( sbuf.Length - 1 ), index = 0; ( len >= 0 ) && ( sbuf[len] == '0' ); len--, index++ )
;
if ( ( len >= 0 ) && ( sbuf[len] == '.' ) )
{
index++;
}
if ( index > 0 )
{
sbuf = new StringBuilder( sbuf.ToString().Substring( 0, ( sbuf.Length - index ) - ( 0 ) ) );
}
}
}
else
{
// EXP or GENERIC
flag_dp = ( ( precision > 0 ) || ( ( flags & ALT_OUTPUT ) != 0 ) );
if ( prefixSize > 0 )
{
sbuf.Append( prefix );
}
digit = (int)dblValue;
dblValue = ( dblValue - digit ) * 10.0;
sbuf.Append( digit );
if ( flag_dp )
{
sbuf.Append( '.' );
}
while ( precision-- > 0 )
{
if ( count++ >= 16 )
{
sbuf.Append( '0' );
}
else
{
digit = (int)dblValue;
dblValue = ( dblValue - digit ) * 10.0;
sbuf.Append( digit );
}
}
if ( flag_rtz && flag_dp )
{
// Remove trailing zeros and "."
for ( i = 0, length = ( sbuf.Length - 1 ); ( length >= 0 ) && ( sbuf[length] == '0' ); length--, i++ )
;
if ( ( length >= 0 ) && ( sbuf[length] == '.' ) )
{
i++;
}
if ( i > 0 )
{
sbuf = new StringBuilder( sbuf.ToString().Substring( 0, ( sbuf.Length - i ) - ( 0 ) ) );
}
}
if ( ( exp != 0 ) || flag_exp )
{
sbuf.Append( charSet[0] );
if ( exp < 0 )
{
sbuf.Append( '-' );
exp = -exp;
}
else
{
sbuf.Append( '+' );
}
if ( exp >= 100 )
{
sbuf.Append( ( exp / 100 ) );
exp %= 100;
}
sbuf.Append( exp / 10 );
sbuf.Append( exp % 10 );
}
}
// The converted number is in sbuf. Output it.
// Note that the number is in the usual order, not reversed as with
// integer conversions.
length = sbuf.Length;
// Special case: Add leading zeros if the PAD_W_ZERO flag is
// set and we are not left justified
if ( ( ( PAD_W_ZERO & flags ) != 0 ) && ( ( LEFT_JUSTIFY & flags ) == 0 ) )
{
int nPad = width - length;
i = prefixSize;
while ( ( nPad-- ) > 0 )
{
sbuf.Insert( prefixSize, '0' );
}
length = width;
}
// Count the number of spaces remaining and creat a StringBuffer
// (tmpBuf) with the correct number of spaces.
int nspace = width - length;
StringBuilder tmpBuf = new StringBuilder( 0 ).Append( "" );
if ( nspace > 0 )
{
tmpBuf = new StringBuilder( nspace );
for ( i = 0; i < nspace; i++ )
{
tmpBuf.Append( " " );
}
}
if ( ( LEFT_JUSTIFY & flags ) != 0 )
{
// left justified
return sbuf.ToString() + tmpBuf.ToString();
}
else
{
// right justified
return tmpBuf.ToString() + sbuf.ToString();
}
}
/// <summary> This procedure is invoked in "phase 6" od the Format cmdProc. It
/// converts the strValue to a string with a specified format determined
/// by the other input variables.
/// </summary>
/// <param name="strValue"> - Is the String w/o formatting.
/// </param>
/// <param name="width"> - The minimum width of the string.
/// </param>
/// <param name="precision">- The minimum width if the integer. If the string
/// len is less than precision, leading 0 are
/// appended.
/// </param>
/// <param name="flags"> - Specifies various formatting to the string
/// representation (-, +, space, 0, #)
/// </param>
/// <returns> String representation of the integer.
/// </returns>
private static string cvtStrToStr( string strValue, int width, int precision, int flags )
{
string left = "";
string right = "";
if ( precision < 0 )
{
precision = 0;
}
if ( ( precision != 0 ) && ( precision < strValue.Length ) )
{
strValue = strValue.Substring( 0, ( precision ) - ( 0 ) );
}
if ( width > strValue.Length )
{
StringBuilder sbuf = new StringBuilder();
int index = ( width - strValue.Length );
for ( int i = 0; i < index; i++ )
{
if ( ( flags & PAD_W_ZERO ) != 0 )
{
sbuf.Append( '0' );
}
else
{
sbuf.Append( ' ' );
}
}
if ( ( LEFT_JUSTIFY & flags ) != 0 )
{
right = sbuf.ToString();
}
else
{
left = sbuf.ToString();
}
}
return ( left + strValue + right );
}
/// <summary> Search through the array while the current char is a digit. When end
/// of array occurs or the char is not a digit, stop the loop, convert the
/// sub-array into a long. At this point return a StrtoulResult object
/// that contains the new long value and the current pointer to the array.
///
/// </summary>
/// <param name="arr">- the array that contains a string representation of an int.
/// </param>
/// <param name="endIndex">- the arr index where the numeric value begins.
/// </param>
/// <returns> StrtoResult containing the value and new index/
/// </returns>
private StrtoulResult strtoul( char[] arr, int endIndex )
{
int orgIndex;
orgIndex = endIndex;
for ( ; endIndex < arr.Length; endIndex++ )
{
if ( !System.Char.IsDigit( arr[endIndex] ) )
{
break;
}
}
return ( new StrtoulResult( System.Int64.Parse( new string( arr, orgIndex, endIndex - orgIndex ) ), endIndex, 0 ) );
}
/*
*
* Error routines:
*
*/
/// <summary> Called whenever the fmtIndex in the cmdProc is changed. It verifies
/// the the array index is still within the bounds of the array. If no
/// throw error.
/// </summary>
/// <param name="interp"> - The TclInterp which called the cmdProc method .
/// </param>
/// <param name="arr"> - The array to be checked.
/// </param>
/// <param name="index"> - The new value for the array index.
/// </param>
private static void checkOverFlow( Interp interp, char[] arr, int index )
{
if ( ( index >= arr.Length ) || ( index < 0 ) )
{
throw new TclException( interp, "\"%n$\" argument index out of range" );
}
}
/// <summary> Called whenever Sequential format specifiers are interlaced with
/// XPG format specifiers in one call to cmdProc.
///
/// </summary>
/// <param name="interp"> - The TclInterp which called the cmdProc method .
/// </param>
private static void errorMixedXPG( Interp interp )
{
throw new TclException( interp, "cannot mix \"%\" and \"%n$\" conversion specifiers" );
}
/// <summary> Called whenever the argIndex access outside the argv array. If the
/// type is an XPG then the error message is different.
///
/// </summary>
/// <param name="interp"> - The TclInterp which called the cmdProc method .
/// </param>
/// <param name="gotXpg"> - Boolean the determines if the current format is of a
/// XPG type or Sequential
/// </param>
private static void errorBadIndex( Interp interp, bool gotXpg )
{
if ( gotXpg )
{
throw new TclException( interp, "\"%n$\" argument index out of range" );
}
else
{
throw new TclException( interp, "not enough arguments for all format specifiers" );
}
}
/// <summary> Called whenever the current char in the format array is erroneous
///
/// </summary>
/// <param name="interp"> - The TclInterp which called the cmdProc method .
/// </param>
/// <param name="fieldSpecifier"> - The erroneous character
/// </param>
private static void errorBadField( Interp interp, char fieldSpecifier )
{
throw new TclException( interp, "bad field specifier \"" + fieldSpecifier + "\"" );
}
/// <summary> Called whenever the a '%' is found but then the format string ends.
///
/// </summary>
/// <param name="interp"> - The TclInterp which called the cmdProc method .
/// </param>
private static void errorEndMiddle( Interp interp )
{
throw new TclException( interp, "format string ended in middle of field specifier" );
}
}
}