diff options
Diffstat (limited to 'generic')
58 files changed, 4381 insertions, 1278 deletions
diff --git a/generic/tcl.decls b/generic/tcl.decls index 4ad45ab..82219aa 100644 --- a/generic/tcl.decls +++ b/generic/tcl.decls @@ -11,7 +11,7 @@ # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # -# RCS: @(#) $Id: tcl.decls,v 1.110 2005/05/03 18:07:44 dgp Exp $ +# RCS: @(#) $Id: tcl.decls,v 1.111 2005/05/10 18:34:04 kennykb Exp $ library tcl @@ -1989,6 +1989,21 @@ declare 554 generic { Tcl_DriverThreadActionProc *Tcl_ChannelThreadActionProc(Tcl_ChannelType *chanTypePtr) } +# TIP #237: + +declare 555 generic { + Tcl_Obj* Tcl_NewBignumObj( mp_int* value ) +} +declare 556 generic { + Tcl_Obj* Tcl_DbNewBignumObj( mp_int* value, CONST char* file, int line ) +} +declare 557 generic { + void Tcl_SetBignumObj( Tcl_Obj* obj, mp_int* value ) +} +declare 558 generic { + int Tcl_GetBignumFromObj( Tcl_Interp* interp, Tcl_Obj* obj, mp_int* value ) +} + ############################################################################## # Define the platform specific public Tcl interface. These functions are diff --git a/generic/tcl.h b/generic/tcl.h index 97e6d25..bdb8e10 100644 --- a/generic/tcl.h +++ b/generic/tcl.h @@ -13,7 +13,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tcl.h,v 1.197 2005/03/10 22:10:38 dgp Exp $ + * RCS: @(#) $Id: tcl.h,v 1.198 2005/05/10 18:34:05 kennykb Exp $ */ #ifndef _TCL @@ -768,6 +768,12 @@ typedef struct Tcl_Obj { VOID *ptr1; VOID *ptr2; } twoPtrValue; + struct { /* - internal rep as a wide int, + * tightly packed fields */ + VOID *digits; /* Pointer to digits */ + unsigned long misc; /* Alloc, used, and signum packed + * into a single word */ + } bignumValue; } internalRep; } Tcl_Obj; @@ -809,6 +815,8 @@ int Tcl_IsShared _ANSI_ARGS_((Tcl_Obj *objPtr)); */ #ifdef TCL_MEM_DEBUG +# define Tcl_NewBignumObj(val) \ + Tcl_DbNewBignumObj(val, __FILE__, __LINE__) # define Tcl_NewBooleanObj(val) \ Tcl_DbNewBooleanObj(val, __FILE__, __LINE__) # define Tcl_NewByteArrayObj(bytes, len) \ @@ -2292,6 +2300,15 @@ typedef void (Tcl_LimitHandlerProc) _ANSI_ARGS_((ClientData clientData, typedef void (Tcl_LimitHandlerDeleteProc) _ANSI_ARGS_((ClientData clientData)); +#ifndef MP_INT_DECLARED +typedef struct mp_int mp_int; +#define MP_INT_DECLARED +#endif +#ifndef MP_DIGIT_DECLARED +typedef unsigned long mp_digit; +#define MP_DIGIT_DECLARED +#endif + #ifndef TCL_NO_DEPRECATED /* diff --git a/generic/tclBasic.c b/generic/tclBasic.c index 9783367..2ec1776 100644 --- a/generic/tclBasic.c +++ b/generic/tclBasic.c @@ -13,11 +13,27 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclBasic.c,v 1.150 2005/05/05 18:37:55 dgp Exp $ + * RCS: @(#) $Id: tclBasic.c,v 1.151 2005/05/10 18:34:06 kennykb Exp $ */ #include "tclInt.h" #include "tclCompile.h" +#include <float.h> +#ifndef TCL_NO_MATH +#include <math.h> +#endif + +/* + * The following structure defines the client data for a math function + * registered with Tcl_CreateMathFunc + */ + +typedef struct OldMathFuncData { + Tcl_MathProc* proc; /* Handler procedure */ + int numArgs; /* Number of args expected */ + Tcl_ValueType* argTypes; /* Types of the args */ + ClientData clientData; /* Client data for the handler function */ +} OldMathFuncData; /* * Static procedures in this file: @@ -30,6 +46,106 @@ static void DeleteInterpProc _ANSI_ARGS_((Tcl_Interp *interp)); static void ProcessUnexpectedResult _ANSI_ARGS_(( Tcl_Interp *interp, int returnCode)); +static int OldMathFuncProc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp* interp, + int argc, + Tcl_Obj *CONST *objv )); + +static void OldMathFuncDeleteProc _ANSI_ARGS_((ClientData)); + +static int ExprAbsFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprBinaryFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprDoubleFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprIntFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprRandFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprRoundFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprSrandFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprUnaryFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int ExprWideFunc _ANSI_ARGS_((ClientData clientData, + Tcl_Interp *interp, + int argc, + Tcl_Obj *CONST *objv)); +static int VerifyExprObjType _ANSI_ARGS_((Tcl_Interp *interp, + Tcl_Obj *objPtr)); + +static void MathFuncWrongNumArgs + _ANSI_ARGS_((Tcl_Interp* interp, + int expected, + int actual, + Tcl_Obj *CONST *objv )); + +#ifndef TCL_WIDE_INT_IS_LONG +/* + * Extract a double value from a general numeric object. + */ +#define GET_DOUBLE_VALUE(doubleVar, objPtr, typePtr) \ + if ((typePtr) == &tclIntType) { \ + (doubleVar) = (double) (objPtr)->internalRep.longValue; \ + } else if ((typePtr) == &tclWideIntType) { \ + (doubleVar) = Tcl_WideAsDouble((objPtr)->internalRep.wideValue);\ + } else { \ + (doubleVar) = (objPtr)->internalRep.doubleValue; \ + } +#else /* TCL_WIDE_INT_IS_LONG */ +#define GET_DOUBLE_VALUE(doubleVar, objPtr, typePtr) \ + if (((typePtr) == &tclIntType) || ((typePtr) == &tclWideIntType)) { \ + (doubleVar) = (double) (objPtr)->internalRep.longValue; \ + } else { \ + (doubleVar) = (objPtr)->internalRep.doubleValue; \ + } +#endif /* TCL_WIDE_INT_IS_LONG */ +#define GET_WIDE_OR_INT(resultVar, objPtr, longVar, wideVar) \ + (resultVar) = Tcl_GetWideIntFromObj((Tcl_Interp *) NULL, (objPtr), \ + &(wideVar)); \ + if ((resultVar) == TCL_OK && (wideVar) >= Tcl_LongAsWide(LONG_MIN) \ + && (wideVar) <= Tcl_LongAsWide(LONG_MAX)) { \ + (objPtr)->typePtr = &tclIntType; \ + (objPtr)->internalRep.longValue = (longVar) \ + = Tcl_WideAsLong(wideVar); \ + } +#define IS_INTEGER_TYPE(typePtr) \ + ((typePtr) == &tclIntType || (typePtr) == &tclWideIntType) +#define IS_NUMERIC_TYPE(typePtr) \ + (IS_INTEGER_TYPE(typePtr) || (typePtr) == &tclDoubleType) + +/* + * Macros for testing floating-point values for certain special cases. Test + * for not-a-number by comparing a value against itself; test for infinity + * by comparing against the largest floating-point value. + */ + +#ifdef _MSC_VER +#define IS_NAN(f) (_isnan((f))) +#define IS_INF(f) ( ! (_finite((f)))) +#else +#define IS_NAN(f) ((f) != (f)) +#define IS_INF(f) ( (f) > DBL_MAX || (f) < -DBL_MAX ) +#endif + extern TclStubs tclStubs; /* @@ -144,6 +260,55 @@ static CmdInfo builtInCmds[] = { {NULL, (Tcl_ObjCmdProc *) NULL, (CompileProc *) NULL, 0} }; +/* + * Math functions + */ + +typedef struct { + CONST char* name; /* Name of the function */ + Tcl_ObjCmdProc* objCmdProc; /* Procedure that evaluates the function */ + ClientData clientData; /* Client data for the procedure */ +} BuiltinFuncDef; +BuiltinFuncDef BuiltinFuncTable[] = { + { "::tcl::mathfunc::abs", ExprAbsFunc, NULL }, +#ifndef TCL_NO_MATH + { "::tcl::mathfunc::acos", ExprUnaryFunc, (ClientData) acos }, + { "::tcl::mathfunc::asin", ExprUnaryFunc, (ClientData) asin }, + { "::tcl::mathfunc::atan", ExprUnaryFunc, (ClientData) atan }, + { "::tcl::mathfunc::atan2", ExprBinaryFunc, (ClientData) atan2 }, + { "::tcl::mathfunc::ceil", ExprUnaryFunc, (ClientData) ceil }, + { "::tcl::mathfunc::cos", ExprUnaryFunc, (ClientData) cos }, + { "::tcl::mathfunc::cosh", ExprUnaryFunc, (ClientData) cosh }, +#endif + { "::tcl::mathfunc::double",ExprDoubleFunc, NULL }, +#ifndef TCL_NO_MATH + { "::tcl::mathfunc::exp", ExprUnaryFunc, (ClientData) exp }, + { "::tcl::mathfunc::floor", ExprUnaryFunc, (ClientData) floor }, + { "::tcl::mathfunc::fmod", ExprBinaryFunc, (ClientData) fmod }, + { "::tcl::mathfunc::hypot", ExprBinaryFunc, (ClientData) hypot }, +#endif + { "::tcl::mathfunc::int", ExprIntFunc, NULL }, +#ifndef TCL_NO_MATH + { "::tcl::mathfunc::log", ExprUnaryFunc, (ClientData) log }, + { "::tcl::mathfunc::log10", ExprUnaryFunc, (ClientData) log10 }, + { "::tcl::mathfunc::pow", ExprBinaryFunc, (ClientData) pow }, +#endif + { "::tcl::mathfunc::rand", ExprRandFunc, NULL }, + { "::tcl::mathfunc::round", ExprRoundFunc, NULL }, +#ifndef TCL_NO_MATH + { "::tcl::mathfunc::sin", ExprUnaryFunc, (ClientData) sin }, + { "::tcl::mathfunc::sinh", ExprUnaryFunc, (ClientData) sinh }, + { "::tcl::mathfunc::sqrt", ExprUnaryFunc, (ClientData) sqrt }, +#endif + { "::tcl::mathfunc::srand", ExprSrandFunc, NULL }, +#ifndef TCL_NO_MATH + { "::tcl::mathfunc::tan", ExprUnaryFunc, (ClientData) tan }, + { "::tcl::mathfunc::tanh", ExprUnaryFunc, (ClientData) tanh }, +#endif + { "::tcl::mathfunc::wide", ExprWideFunc, NULL }, + { NULL, NULL, NULL } +}; + /* *---------------------------------------------------------------------- @@ -170,10 +335,9 @@ Tcl_CreateInterp() Interp *iPtr; Tcl_Interp *interp; Command *cmdPtr; - BuiltinFunc *builtinFuncPtr; - MathFunc *mathFuncPtr; - Tcl_HashEntry *hPtr; + BuiltinFuncDef *builtinFuncPtr; const CmdInfo *cmdInfoPtr; + Tcl_Namespace* mathfuncNSPtr; int i; union { char c[sizeof(short)]; @@ -213,7 +377,6 @@ Tcl_CreateInterp() iPtr->globalNsPtr = NULL; iPtr->hiddenCmdTablePtr = NULL; iPtr->interpInfo = NULL; - Tcl_InitHashTable(&iPtr->mathFuncTable, TCL_STRING_KEYS); iPtr->numLevels = 0; iPtr->maxNestingDepth = MAX_NESTING_DEPTH; @@ -223,10 +386,10 @@ Tcl_CreateInterp() iPtr->returnOpts = NULL; iPtr->errorInfo = NULL; - iPtr->eiVar = Tcl_NewStringObj("errorInfo", -1); + iPtr->eiVar = Tcl_NewStringObj( "errorInfo", -1 ); Tcl_IncrRefCount(iPtr->eiVar); iPtr->errorCode = NULL; - iPtr->ecVar = Tcl_NewStringObj("errorCode", -1); + iPtr->ecVar = Tcl_NewStringObj( "errorCode", -1 ); Tcl_IncrRefCount(iPtr->ecVar); iPtr->returnLevel = 0; iPtr->returnCode = TCL_OK; @@ -399,6 +562,11 @@ Tcl_CreateInterp() TclClockOldscanObjCmd, (ClientData) NULL, (Tcl_CmdDeleteProc*) NULL ); + /* + * Register the built-in functions + */ + + /* Register the default [interp bgerror] handler. */ Tcl_CreateObjCommand( interp, "::tcl::Bgerror", @@ -413,21 +581,25 @@ Tcl_CreateInterp() * Register the builtin math functions. */ + mathfuncNSPtr = Tcl_CreateNamespace( interp, "::tcl::mathfunc", + (ClientData) NULL, + (Tcl_NamespaceDeleteProc*) NULL ); + if ( mathfuncNSPtr == NULL ) { + Tcl_Panic( "Can't create math function namespace" ); + } i = 0; - for (builtinFuncPtr = tclBuiltinFuncTable; builtinFuncPtr->name != NULL; - builtinFuncPtr++) { - Tcl_CreateMathFunc((Tcl_Interp *) iPtr, builtinFuncPtr->name, - builtinFuncPtr->numArgs, builtinFuncPtr->argTypes, - (Tcl_MathProc *) NULL, (ClientData) 0); - hPtr = Tcl_FindHashEntry(&iPtr->mathFuncTable, - builtinFuncPtr->name); - if (hPtr == NULL) { - Tcl_Panic("Tcl_CreateInterp: Tcl_CreateMathFunc incorrectly registered '%s'", builtinFuncPtr->name); - return NULL; + for ( ; ; ) { + CONST char* tail; + builtinFuncPtr = &(BuiltinFuncTable[ i++ ]); + if ( builtinFuncPtr->name == NULL ) { + break; } - mathFuncPtr = (MathFunc *) Tcl_GetHashValue(hPtr); - mathFuncPtr->builtinFuncIndex = i; - i++; + Tcl_CreateObjCommand( interp, builtinFuncPtr->name, + builtinFuncPtr->objCmdProc, + builtinFuncPtr->clientData, + (Tcl_CmdDeleteProc*) NULL ); + tail = builtinFuncPtr->name + strlen( "::tcl::mathfunc::" ); + Tcl_Export( interp, mathfuncNSPtr, tail, 0 ); } /* @@ -936,16 +1108,6 @@ DeleteInterpProc(interp) Tcl_DeleteHashTable(hTablePtr); ckfree((char *) hTablePtr); } - /* - * Tear down the math function table. - */ - - for (hPtr = Tcl_FirstHashEntry(&iPtr->mathFuncTable, &search); - hPtr != NULL; - hPtr = Tcl_NextHashEntry(&search)) { - ckfree((char *) Tcl_GetHashValue(hPtr)); - } - Tcl_DeleteHashTable(&iPtr->mathFuncTable); /* * Invoke deletion callbacks; note that a callback can create new @@ -2675,52 +2837,176 @@ Tcl_CreateMathFunc(interp, name, numArgs, argTypes, proc, clientData) ClientData clientData; /* Additional value to pass to the * function. */ { - Interp *iPtr = (Interp *) interp; - Tcl_HashEntry *hPtr; - MathFunc *mathFuncPtr; - int new, i; - hPtr = Tcl_CreateHashEntry(&iPtr->mathFuncTable, name, &new); - if (new) { - Tcl_SetHashValue(hPtr, ckalloc(sizeof(MathFunc))); + Tcl_DString bigName; + + OldMathFuncData* data + = (OldMathFuncData*) Tcl_Alloc( sizeof ( OldMathFuncData ) ); + + if ( numArgs > MAX_MATH_ARGS ) { + Tcl_Panic( "attempt to create a math function with too many args" ); } - mathFuncPtr = (MathFunc *) Tcl_GetHashValue(hPtr); - if (!new) { - if (mathFuncPtr->builtinFuncIndex >= 0) { - /* - * We are redefining a builtin math function. Invalidate the - * interpreter's existing code by incrementing its - * compileEpoch member. This field is checked in Tcl_EvalObj - * and ObjInterpProc, and code whose compilation epoch doesn't - * match is recompiled. Newly compiled code will no longer - * treat the function as builtin. - */ + data->proc = proc; + data->numArgs = numArgs; + data->argTypes + = (Tcl_ValueType*) Tcl_Alloc( numArgs * sizeof( Tcl_ValueType ) ); + memcpy( data->argTypes, argTypes, numArgs * sizeof( Tcl_ValueType ) ); + data->clientData = clientData; - iPtr->compileEpoch++; - } else { - /* - * A non-builtin function is being redefined. We must invalidate - * existing code if the number of arguments has changed. This - * is because existing code was compiled assuming that number. - */ + Tcl_DStringInit( &bigName ); + Tcl_DStringAppend( &bigName, "::tcl::mathfunc::", -1 ); + Tcl_DStringAppend( &bigName, name, -1 ); - if (numArgs != mathFuncPtr->numArgs) { - iPtr->compileEpoch++; + Tcl_CreateObjCommand( interp, Tcl_DStringValue( &bigName ), + OldMathFuncProc, (ClientData) data, + OldMathFuncDeleteProc ); + Tcl_DStringFree( &bigName ); +} + +/* + *---------------------------------------------------------------------- + * + * OldMathFuncProc -- + * + * Dispatch to a math function created with Tcl_CreateMathFunc + * + * Results: + * Returns a standard Tcl result. + * + * Side effects: + * Whatever the math function does. + * + *---------------------------------------------------------------------- + */ + +static int +OldMathFuncProc( clientData, interp, objc, objv ) + ClientData clientData; /* Ponter to OldMathFuncData describing + * the function being called */ + Tcl_Interp* interp; /* Tcl interpreter */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Parameter vector */ +{ + Tcl_Obj* valuePtr; + OldMathFuncData* dataPtr = (OldMathFuncData*) clientData; + Tcl_Value args[MAX_MATH_ARGS]; + Tcl_Value funcResult; + int result; + int i, j, k; + double d; + + /* Check argument count */ + + if ( objc != dataPtr->numArgs + 1 ) { + MathFuncWrongNumArgs( interp, dataPtr->numArgs+1, objc, objv ); + return TCL_ERROR; + } + + /* Convert arguments from Tcl_Obj's to Tcl_Value's */ + + for ( j = 1, k = 0; j < objc; ++j, ++k ) { + valuePtr = objv[j]; + if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { + return TCL_ERROR; + } + + /* + * Copy the object's numeric value to the argument record, + * converting it if necessary. + */ + + if (valuePtr->typePtr == &tclIntType) { + i = valuePtr->internalRep.longValue; + if (dataPtr->argTypes[k] == TCL_DOUBLE) { + args[k].type = TCL_DOUBLE; + args[k].doubleValue = i; + } else if (dataPtr->argTypes[k] == TCL_WIDE_INT) { + args[k].type = TCL_WIDE_INT; + args[k].wideValue = Tcl_LongAsWide(i); + } else { + args[k].type = TCL_INT; + args[k].intValue = i; + } + } else if (valuePtr->typePtr == &tclWideIntType) { + Tcl_WideInt w; + TclGetWide(w,valuePtr); + if (dataPtr->argTypes[k] == TCL_DOUBLE) { + args[k].type = TCL_DOUBLE; + args[k].doubleValue = Tcl_WideAsDouble(w); + } else if (dataPtr->argTypes[k] == TCL_INT) { + args[k].type = TCL_INT; + args[k].intValue = Tcl_WideAsLong(w); + } else { + args[k].type = TCL_WIDE_INT; + args[k].wideValue = w; + } + } else { + d = valuePtr->internalRep.doubleValue; + if (dataPtr->argTypes[k] == TCL_INT) { + args[k].type = TCL_INT; + args[k].intValue = (long) d; + } else if (dataPtr->argTypes[k] == TCL_WIDE_INT) { + args[k].type = TCL_WIDE_INT; + args[k].wideValue = Tcl_DoubleAsWide(d); + } else { + args[k].type = TCL_DOUBLE; + args[k].doubleValue = d; } } } - - mathFuncPtr->builtinFuncIndex = -1; /* can't be a builtin function */ - if (numArgs > MAX_MATH_ARGS) { - numArgs = MAX_MATH_ARGS; + + /* Call the function */ + + result = (*dataPtr->proc)(dataPtr->clientData, interp, args, + &funcResult); + if (result != TCL_OK) { + return result; } - mathFuncPtr->numArgs = numArgs; - for (i = 0; i < numArgs; i++) { - mathFuncPtr->argTypes[i] = argTypes[i]; + + /* Return the result of the call */ + + if (funcResult.type == TCL_INT) { + TclNewLongObj(valuePtr, funcResult.intValue); + } else if (funcResult.type == TCL_WIDE_INT) { + TclNewWideIntObj(valuePtr, funcResult.wideValue); + } else { + d = funcResult.doubleValue; + if (IS_NAN(d) || IS_INF(d)) { + TclExprFloatError(interp, d); + return TCL_ERROR; + } + TclNewDoubleObj(valuePtr, d); } - mathFuncPtr->proc = proc; - mathFuncPtr->clientData = clientData; + Tcl_SetObjResult( interp, valuePtr ); + return TCL_OK; + +} + +/* + *---------------------------------------------------------------------- + * + * OldMathFuncDeleteProc -- + * + * Cleans up after deleting a math function registered with + * Tcl_CreateMathFunc + * + * Results: + * None. + * + * Side effects: + * Frees allocated memory. + * + *---------------------------------------------------------------------- + */ + +static void +OldMathFuncDeleteProc( clientData ) + ClientData clientData; +{ + OldMathFuncData* dataPtr = (OldMathFuncData*) clientData; + Tcl_Free( (VOID*) dataPtr->argTypes ); + Tcl_Free( (VOID*) dataPtr ); } /* @@ -2757,39 +3043,51 @@ Tcl_GetMathFuncInfo(interp, name, numArgsPtr, argTypesPtr, procPtr, Tcl_MathProc **procPtr; ClientData *clientDataPtr; { - Interp *iPtr = (Interp *) interp; - Tcl_HashEntry *hPtr; - MathFunc *mathFuncPtr; - Tcl_ValueType *argTypes; - int i,numArgs; - hPtr = Tcl_FindHashEntry(&iPtr->mathFuncTable, name); - if (hPtr == NULL) { - Tcl_AppendResult(interp, "math function \"", name, - "\" not known in this interpreter", (char *) NULL); - return TCL_ERROR; - } - mathFuncPtr = (MathFunc *) Tcl_GetHashValue(hPtr); + Tcl_Obj* cmdNameObj; + Command* cmdPtr; - *numArgsPtr = numArgs = mathFuncPtr->numArgs; - if (numArgs == 0) { - /* Avoid doing zero-sized allocs... */ - numArgs = 1; - } - *argTypesPtr = argTypes = - (Tcl_ValueType *)ckalloc(numArgs * sizeof(Tcl_ValueType)); - for (i = 0; i < mathFuncPtr->numArgs; i++) { - argTypes[i] = mathFuncPtr->argTypes[i]; + /* Get the command that implements the math function */ + + cmdNameObj = Tcl_NewStringObj( "tcl::mathfunc::", -1 ); + Tcl_AppendToObj( cmdNameObj, name, -1 ); + Tcl_IncrRefCount( cmdNameObj ); + cmdPtr = (Command*) Tcl_GetCommandFromObj( interp, cmdNameObj ); + Tcl_DecrRefCount( cmdNameObj ); + + /* Report unknown functions */ + + if ( cmdPtr == NULL ) { + Tcl_Obj* message; + message = Tcl_NewStringObj( "unknown math function \"", -1 ); + Tcl_AppendToObj( message, name, -1 ); + Tcl_AppendToObj( message, "\"", 1 ); + *numArgsPtr = -1; *argTypesPtr = NULL; + *procPtr = NULL; + *clientDataPtr = NULL; + return TCL_ERROR; } + + /* + * Retrieve function info for user defined functions; return + * dummy information for builtins. + */ - if (mathFuncPtr->builtinFuncIndex == -1) { - *procPtr = (Tcl_MathProc *) NULL; + if ( cmdPtr->objProc == &OldMathFuncProc ) { + OldMathFuncData* dataPtr = (OldMathFuncData*) cmdPtr->clientData; + *procPtr = dataPtr->proc; + *numArgsPtr = dataPtr->numArgs; + *argTypesPtr = dataPtr->argTypes; + *clientDataPtr = dataPtr->clientData; } else { - *procPtr = mathFuncPtr->proc; - *clientDataPtr = mathFuncPtr->clientData; + *procPtr = NULL; + *numArgsPtr = -1; + *argTypesPtr = NULL; + *procPtr = NULL; + *clientDataPtr = NULL; } - return TCL_OK; + } /* @@ -2816,33 +3114,42 @@ Tcl_ListMathFuncs(interp, pattern) Tcl_Interp *interp; CONST char *pattern; { - Interp *iPtr = (Interp *) interp; - Tcl_Obj *resultList = Tcl_NewObj(); - register Tcl_HashEntry *hPtr; - Tcl_HashSearch hSearch; - CONST char *name; - - if ((pattern != NULL) && TclMatchIsTrivial(pattern)) { - if ((Tcl_FindHashEntry(&iPtr->mathFuncTable, pattern) != NULL) - && (Tcl_ListObjAppendElement(interp, resultList, - Tcl_NewStringObj(pattern,-1)) != TCL_OK)) { - goto error; - } - return resultList; - } - for (hPtr = Tcl_FirstHashEntry(&iPtr->mathFuncTable, &hSearch); - hPtr != NULL; hPtr = Tcl_NextHashEntry(&hSearch)) { - name = Tcl_GetHashKey(&iPtr->mathFuncTable, hPtr); - if ((pattern == NULL || Tcl_StringMatch(name, pattern)) && - /* I don't expect this to fail, but... */ - Tcl_ListObjAppendElement(interp, resultList, - Tcl_NewStringObj(name,-1)) != TCL_OK) { -error: - Tcl_DecrRefCount(resultList); - return NULL; + Namespace* globalNsPtr = (Namespace*) Tcl_GetGlobalNamespace( interp ); + Namespace* nsPtr; + Namespace* dummy1NsPtr; + Namespace* dummy2NsPtr; + CONST char* dummyNamePtr; + Tcl_Obj* result = Tcl_NewObj(); + Tcl_HashEntry* cmdHashEntry; + Tcl_HashSearch cmdHashSearch; + CONST char* cmdNamePtr; + + TclGetNamespaceForQualName( interp, "::tcl::mathfunc", + globalNsPtr, + TCL_FIND_ONLY_NS | TCL_GLOBAL_ONLY, + &nsPtr, &dummy1NsPtr, &dummy2NsPtr, + &dummyNamePtr ); + + if ( nsPtr != NULL ) { + if ((pattern != NULL) && TclMatchIsTrivial(pattern)) { + if (Tcl_FindHashEntry(&nsPtr->cmdTable, pattern) != NULL) { + Tcl_ListObjAppendElement(NULL, result, + Tcl_NewStringObj(pattern,-1)); + } + } else { + for ( cmdHashEntry = + Tcl_FirstHashEntry( &nsPtr->cmdTable, &cmdHashSearch ); + cmdHashEntry != NULL; + cmdHashEntry = Tcl_NextHashEntry( &cmdHashSearch ) ) { + cmdNamePtr = Tcl_GetHashKey( &nsPtr->cmdTable, cmdHashEntry ); + if (pattern == NULL || Tcl_StringMatch(cmdNamePtr, pattern)) { + Tcl_ListObjAppendElement( NULL, result, + Tcl_NewStringObj( cmdNamePtr, -1 ) ); + } + } } } - return resultList; + return result; } /* @@ -3000,7 +3307,7 @@ TclEvalObjvInternal(interp, objc, objv, command, length, flags) for (i = objc-1; i >= 0; i--) { newObjv[i+1] = objv[i]; } - newObjv[0] = Tcl_NewStringObj("::unknown", -1); + newObjv[0] = Tcl_NewStringObj( "::unknown", -1); Tcl_IncrRefCount(newObjv[0]); cmdPtr = (Command *) Tcl_GetCommandFromObj(interp, newObjv[0]); if (cmdPtr == NULL) { @@ -3483,9 +3790,10 @@ Tcl_EvalEx(interp, script, numBytes, flags) objv[objectsUsed], &numElements); if (code == TCL_ERROR) { /* Attempt to expand a non-list */ - Tcl_Obj *msg = - Tcl_NewStringObj("\n (expanding word ", -1); - Tcl_Obj *wordNum = Tcl_NewIntObj(objectsUsed); + Tcl_Obj *msg; + Tcl_Obj *wordNum; + msg = Tcl_NewStringObj("\n (expanding word ", -1); + TclNewIntObj( wordNum, objectsUsed ); Tcl_IncrRefCount(wordNum); Tcl_IncrRefCount(msg); Tcl_AppendObjToObj(msg, wordNum); @@ -4299,8 +4607,9 @@ TclObjInvoke(interp, objc, objv, flags) && ((iPtr->flags & ERR_ALREADY_LOGGED) == 0)) { int length; Tcl_Obj *command = Tcl_NewListObj(objc, objv); - CONST char* cmdString = Tcl_GetStringFromObj(command, &length); - + CONST char* cmdString; + Tcl_IncrRefCount( command ); + cmdString = Tcl_GetStringFromObj(command, &length); Tcl_LogCommandInfo(interp, cmdString, cmdString, length); Tcl_DecrRefCount(command); iPtr->flags &= ~ERR_ALREADY_LOGGED; @@ -4701,4 +5010,642 @@ Tcl_GetVersion(majorV, minorV, patchLevelV, type) *type = TCL_RELEASE_LEVEL; } } - + +/* + *---------------------------------------------------------------------- + * + * Math Functions -- + * + * This page contains the procedures that implement all of the + * built-in math functions for expressions. + * + * Results: + * Each procedure returns TCL_OK if it succeeds and pushes an + * Tcl object holding the result. If it fails it returns TCL_ERROR + * and leaves an error message in the interpreter's result. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +ExprUnaryFunc(clientData, interp, objc, objv) + ClientData clientData; /* Contains the address of a procedure that + * takes one double argument and returns a + * double result. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Actual parameter list */ +{ + double d, dResult; + Tcl_Obj* oResult; + + double (*func) _ANSI_ARGS_((double)) = + (double (*)_ANSI_ARGS_((double))) clientData; + + /* + * Convert the function's argument to a double if necessary. + */ + + if ( objc != 2 ) { + MathFuncWrongNumArgs( interp, 2, objc, objv ); + } else if ( Tcl_GetDoubleFromObj( interp, objv[1], &d ) == TCL_OK ) { + + /* Evaluate the function */ + + dResult = (*func)(d); + if ((errno != 0 ) || IS_NAN(dResult)) { + if ( errno != ERANGE || ( dResult != 0.0 && !IS_INF(dResult) )) { + TclExprFloatError(interp, dResult); + return TCL_ERROR; + } + } + TclNewDoubleObj( oResult, dResult ); + Tcl_SetObjResult( interp, oResult ); + return TCL_OK; + } + + return TCL_ERROR; +} + +static int +ExprBinaryFunc( clientData, interp, objc, objv ) + ClientData clientData; /* Contains the address of a procedure that + * takes two double arguments and + * returns a double result. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Parameter vector */ +{ + double d1, d2, dResult; + Tcl_Obj* oResult; + + double (*func) _ANSI_ARGS_((double, double)) + = (double (*)_ANSI_ARGS_((double, double))) clientData; + + /* + * Convert the function's two arguments to doubles if necessary. + */ + + if ( objc != 3 ) { + MathFuncWrongNumArgs( interp, 3, objc, objv ); + } else if ( Tcl_GetDoubleFromObj( interp, objv[1], &d1 ) == TCL_OK + && Tcl_GetDoubleFromObj( interp, objv[2], &d2 ) == TCL_OK ) { + + /* Evaluate the function */ + + errno = 0; + dResult = (*func)(d1, d2); + if ((errno != 0) || IS_NAN(dResult)) { + if ( errno != ERANGE || ( dResult != 0.0 && !IS_INF( dResult ) ) ) { + TclExprFloatError(interp, dResult); + return TCL_ERROR; + } + } + TclNewDoubleObj( oResult, dResult ); + Tcl_SetObjResult( interp, oResult ); + return TCL_OK; + } + + return TCL_ERROR; + +} + +static int +ExprAbsFunc( clientData, interp, objc, objv ) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Parameter vector */ +{ + register Tcl_Obj *valuePtr; + long i, iResult; + double d, dResult; + Tcl_Obj* oResult; + + if ( objc != 2 ) { + MathFuncWrongNumArgs( interp, 2, objc, objv ); + return TCL_ERROR; + } + valuePtr = objv[1]; + + if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { + return TCL_ERROR; + } + + /* + * Derive the absolute value according to the arg type. + */ + if (valuePtr->typePtr == &tclIntType) { + i = valuePtr->internalRep.longValue; + if (i < 0) { + iResult = -i; + if (iResult < 0) { + /* FIXME: This should promote to wide! */ + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "integer value too large to represent", -1)); + Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", + "integer value too large to represent", (char *) NULL); + return TCL_ERROR; + } + } else { + iResult = i; + } + TclNewLongObj( oResult, iResult ); + Tcl_SetObjResult( interp, oResult ); + } else if (valuePtr->typePtr == &tclWideIntType) { + Tcl_WideInt wResult, w; + TclGetWide(w,valuePtr); + if (w < (Tcl_WideInt)0) { + wResult = -w; + if (wResult < 0) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "integer value too large to represent", -1)); + Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", + "integer value too large to represent", (char *) NULL); + return TCL_ERROR; + } + } else { + wResult = w; + } + TclNewWideIntObj( oResult, wResult ); + Tcl_SetObjResult( interp, oResult ); + } else { + d = valuePtr->internalRep.doubleValue; + if (d < 0.0) { + dResult = -d; + } else { + dResult = d; + } + if (IS_NAN(dResult)) { + TclExprFloatError(interp, dResult); + return TCL_ERROR; + } + TclNewDoubleObj( oResult, dResult ); + Tcl_SetObjResult( interp, oResult ); + } + + return TCL_OK; +} + +static int +ExprDoubleFunc(clientData, interp, objc, objv ) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Actual parameter vector */ +{ + Tcl_Obj* valuePtr; + double dResult; + Tcl_Obj* oResult; + + /* + * Check parameter type + */ + + if ( objc != 2 ) { + MathFuncWrongNumArgs( interp, 2, objc, objv ); + } else { + valuePtr = objv[1]; + if ( VerifyExprObjType( interp, valuePtr ) == TCL_OK ) { + GET_DOUBLE_VALUE( dResult, valuePtr, valuePtr->typePtr ); + TclNewDoubleObj( oResult, dResult ); + Tcl_SetObjResult( interp, oResult ); + return TCL_OK; + } + } + + return TCL_ERROR; +} + +static int +ExprIntFunc(clientData, interp, objc, objv) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Actual parameter vector */ +{ + + register Tcl_Obj *valuePtr; + long iResult; + double d; + Tcl_Obj* oResult; + + if ( objc != 2 ) { + MathFuncWrongNumArgs( interp, 2, objc, objv ); + } else { + valuePtr = objv[1]; + if (VerifyExprObjType(interp, valuePtr) == TCL_OK) { + if (valuePtr->typePtr == &tclIntType) { + iResult = valuePtr->internalRep.longValue; + } else if (valuePtr->typePtr == &tclWideIntType) { + TclGetLongFromWide(iResult,valuePtr); + } else { + d = valuePtr->internalRep.doubleValue; + if (d < 0.0) { + if (d < (double) (long) LONG_MIN) { + tooLarge: + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "integer value too large to represent", -1)); + Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", + "integer value too large to represent", + (char *) NULL); + return TCL_ERROR; + } + } else { + if (d > (double) LONG_MAX) { + goto tooLarge; + } + } + if (IS_NAN(d) || IS_INF(d)) { + TclExprFloatError(interp, d); + return TCL_ERROR; + } + iResult = (long) d; + } + TclNewIntObj( oResult, iResult ); + Tcl_SetObjResult( interp, oResult ); + return TCL_OK; + } + } + return TCL_ERROR; +} + +static int +ExprWideFunc(clientData, interp, objc, objv) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Actual parameter vector */ +{ + + register Tcl_Obj *valuePtr; + Tcl_WideInt wResult; + double d; + Tcl_Obj* oResult; + + if ( objc != 2 ) { + MathFuncWrongNumArgs( interp, 2, objc, objv ); + } else { + valuePtr = objv[1]; + if (VerifyExprObjType(interp, valuePtr) == TCL_OK) { + if (valuePtr->typePtr == &tclIntType) { + wResult = valuePtr->internalRep.longValue; + } else if (valuePtr->typePtr == &tclWideIntType) { + wResult = valuePtr->internalRep.wideValue; + } else { + d = valuePtr->internalRep.doubleValue; + if (d < 0.0) { + if (d < Tcl_WideAsDouble( LLONG_MIN ) ) { + tooLarge: + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "integer value too large to represent", -1)); + Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", + "integer value too large to represent", + (char *) NULL); + return TCL_ERROR; + } + } else { + if (d > Tcl_WideAsDouble( LLONG_MAX ) ) { + goto tooLarge; + } + } + if (IS_NAN(d) || IS_INF(d)) { + TclExprFloatError(interp, d); + return TCL_ERROR; + } + wResult = (Tcl_WideInt) d; + } + TclNewWideIntObj( oResult, wResult ); + Tcl_SetObjResult( interp, oResult ); + return TCL_OK; + } + } + return TCL_ERROR; +} + +static int +ExprRandFunc(clientData, interp, objc, objv) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Actual parameter vector */ +{ + Interp *iPtr = (Interp *) interp; + double dResult; + long tmp; /* Algorithm assumes at least 32 bits. + * Only long guarantees that. See below. */ + Tcl_Obj* oResult; + + if ( objc != 1 ) { + MathFuncWrongNumArgs( interp, 1, objc, objv ); + return TCL_ERROR; + } + + if (!(iPtr->flags & RAND_SEED_INITIALIZED)) { + iPtr->flags |= RAND_SEED_INITIALIZED; + + /* + * Take into consideration the thread this interp is running in order + * to insure different seeds in different threads (bug #416643) + */ + + iPtr->randSeed = TclpGetClicks() + ((long)Tcl_GetCurrentThread()<<12); + + /* + * Make sure 1 <= randSeed <= (2^31) - 2. See below. + */ + + iPtr->randSeed &= (unsigned long) 0x7fffffff; + if ((iPtr->randSeed == 0) || (iPtr->randSeed == 0x7fffffff)) { + iPtr->randSeed ^= 123459876; + } + } + + /* + * Generate the random number using the linear congruential + * generator defined by the following recurrence: + * seed = ( IA * seed ) mod IM + * where IA is 16807 and IM is (2^31) - 1. The recurrence maps + * a seed in the range [1, IM - 1] to a new seed in that same range. + * The recurrence maps IM to 0, and maps 0 back to 0, so those two + * values must not be allowed as initial values of seed. + * + * In order to avoid potential problems with integer overflow, the + * recurrence is implemented in terms of additional constants + * IQ and IR such that + * IM = IA*IQ + IR + * None of the operations in the implementation overflows a 32-bit + * signed integer, and the C type long is guaranteed to be at least + * 32 bits wide. + * + * For more details on how this algorithm works, refer to the following + * papers: + * + * S.K. Park & K.W. Miller, "Random number generators: good ones + * are hard to find," Comm ACM 31(10):1192-1201, Oct 1988 + * + * W.H. Press & S.A. Teukolsky, "Portable random number + * generators," Computers in Physics 6(5):522-524, Sep/Oct 1992. + */ + +#define RAND_IA 16807 +#define RAND_IM 2147483647 +#define RAND_IQ 127773 +#define RAND_IR 2836 +#define RAND_MASK 123459876 + + tmp = iPtr->randSeed/RAND_IQ; + iPtr->randSeed = RAND_IA*(iPtr->randSeed - tmp*RAND_IQ) - RAND_IR*tmp; + if (iPtr->randSeed < 0) { + iPtr->randSeed += RAND_IM; + } + + /* + * Since the recurrence keeps seed values in the range [1, RAND_IM - 1], + * dividing by RAND_IM yields a double in the range (0, 1). + */ + + dResult = iPtr->randSeed * (1.0/RAND_IM); + + /* + * Push a Tcl object with the result. + */ + + TclNewDoubleObj( oResult, dResult ); + Tcl_SetObjResult( interp, oResult ); + return TCL_OK; +} + +static int +ExprRoundFunc(clientData, interp, objc, objv) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Parameter vector */ +{ + Tcl_Obj *valuePtr, *resPtr; + double d, a, f; + + /* Check the argument count. */ + + if ( objc != 2 ) { + MathFuncWrongNumArgs( interp, 1, objc, objv ); + return TCL_ERROR; + } + valuePtr = objv[1]; + + /* Coerce the argument to a number. Integers are already rounded. */ + + if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { + return TCL_ERROR; + } + if ((valuePtr->typePtr == &tclIntType) || + (valuePtr->typePtr == &tclWideIntType)) { + return TCL_OK; + } + GET_DOUBLE_VALUE( d, valuePtr, valuePtr->typePtr ); + + /* + * Round the number to the nearest integer. I'd like to use rint() + * or nearbyint(), but they are far from universal. + */ + + a = fabs( d ); + if ( a < Tcl_WideAsDouble( LLONG_MAX ) + 0.5 ) { + d = valuePtr->internalRep.doubleValue; + f = floor( d ); + d -= f; + if ( d > 0.5 || ( d == 0.5 && fmod( f, 2.0 ) != 0.0 ) ) { + f = f + 1.0; + } + if ( f >= (double) LONG_MIN && f <= (double) LONG_MAX ) { + TclNewLongObj( resPtr, (long) f ); + } else { + TclNewWideIntObj( resPtr, Tcl_DoubleAsWide( f ) ); + } + Tcl_SetObjResult( interp, resPtr ); + return TCL_OK; + } + + /* + * Error return: result cannot be represented as an integer. + */ + + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "integer value too large to represent", -1)); + Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", + "integer value too large to represent", + (char *) NULL); + + return TCL_ERROR; + +} + +static int +ExprSrandFunc(clientData, interp, objc, objv) + ClientData clientData; /* Ignored. */ + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + int objc; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Parameter vector */ +{ + Interp *iPtr = (Interp *) interp; + Tcl_Obj *valuePtr; + long i = 0; /* Initialized to avoid compiler warning. */ + + /* + * Convert argument and use it to reset the seed. + */ + + if (objc != 2 ) { + MathFuncWrongNumArgs( interp, 2, objc, objv ); + return TCL_ERROR; + } + valuePtr = objv[1]; + + if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { + return TCL_ERROR; + } + + if ( Tcl_GetLongFromObj( NULL, valuePtr, &i ) != TCL_OK ) { + /* + * At this point, the only other possible type is double + */ + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "can't use floating-point value as argument to srand", -1)); + return TCL_ERROR; + } + + /* + * Reset the seed. Make sure 1 <= randSeed <= 2^31 - 2. + * See comments in ExprRandFunc() for more details. + */ + + iPtr->flags |= RAND_SEED_INITIALIZED; + iPtr->randSeed = i; + iPtr->randSeed &= (unsigned long) 0x7fffffff; + if ((iPtr->randSeed == 0) || (iPtr->randSeed == 0x7fffffff)) { + iPtr->randSeed ^= 123459876; + } + + /* + * To avoid duplicating the random number generation code we simply + * clean up our state and call the real random number function. That + * function will always succeed. + */ + + return ExprRandFunc(clientData, interp, 1, objv); + +} + +/* + *---------------------------------------------------------------------- + * + * VerifyExprObjType -- + * + * This procedure is called by the math functions to verify that + * the object is either an int or double, coercing it if necessary. + * If an error occurs during conversion, an error message is left + * in the interpreter's result unless "interp" is NULL. + * + * Results: + * TCL_OK if it was int or double, TCL_ERROR otherwise + * + * Side effects: + * objPtr is ensured to be of tclIntType, tclWideIntType or + * tclDoubleType. + * + *---------------------------------------------------------------------- + */ + +static int +VerifyExprObjType(interp, objPtr) + Tcl_Interp *interp; /* The interpreter in which to execute the + * function. */ + Tcl_Obj *objPtr; /* Points to the object to type check. */ +{ + if (IS_NUMERIC_TYPE(objPtr->typePtr)) { + return TCL_OK; + } else { + int length, result = TCL_OK; + char *s = Tcl_GetStringFromObj(objPtr, &length); + + if (TclLooksLikeInt(s, length)) { + long i; /* Set but never used, needed in GET_WIDE_OR_INT */ + Tcl_WideInt w; + GET_WIDE_OR_INT(result, objPtr, i, w); + } else { + double d; + result = Tcl_GetDoubleFromObj((Tcl_Interp *) NULL, objPtr, &d); + } + if ((result != TCL_OK) && (interp != NULL)) { + if (TclCheckBadOctal((Tcl_Interp *) NULL, s)) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "argument to math function was an invalid octal number", + -1)); + } else { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "argument to math function didn't have numeric value", + -1)); + } + } + return result; + } +} + +/* + *---------------------------------------------------------------------- + * + * MathFuncWrongNumArgs -- + * + * Generate an error message when a math function presents the + * wrong number of arguments + * + * Results: + * None. + * + * Side effects: + * An error message is stored in the interpreter result + * + *---------------------------------------------------------------------- + */ + +static void +MathFuncWrongNumArgs( interp, expected, found, objv ) + Tcl_Interp* interp; /* Tcl interpreter */ + int expected; /* Formal parameter count */ + int found; /* Actual parameter count */ + Tcl_Obj *CONST *objv; /* Actual parameter vector */ +{ + Tcl_Obj* errorMessage; + CONST char* name = Tcl_GetString( objv[0] ); + CONST char* tail = name + strlen( name ); + while ( tail > name+1 ) { + --tail; + if ( *tail == ':' && tail[-1] == ':' ) { + name = tail+1; + break; + } + } + errorMessage = Tcl_NewStringObj( "too ", -1 ); + if ( found < expected ) { + Tcl_AppendToObj( errorMessage, "few", -1 ); + } else { + Tcl_AppendToObj( errorMessage, "many", -1 ); + } + Tcl_AppendToObj( errorMessage, " arguments for math function \"", -1 ); + Tcl_AppendToObj( errorMessage, name, -1 ); + Tcl_AppendToObj( errorMessage, "\"", -1 ); + Tcl_SetObjResult( interp, errorMessage ); +} diff --git a/generic/tclBinary.c b/generic/tclBinary.c index 1b613d8..706d1f0 100644 --- a/generic/tclBinary.c +++ b/generic/tclBinary.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclBinary.c,v 1.21 2004/10/06 05:52:21 dgp Exp $ + * RCS: @(#) $Id: tclBinary.c,v 1.22 2005/05/10 18:34:07 kennykb Exp $ */ #include "tclInt.h" @@ -1605,10 +1605,15 @@ FormatNumber(interp, type, src, cursorPtr) case 'Q': /* * Double-precision floating point values. + * Tcl_GetDoubleFromObj returns TCL_ERROR for NaN, but + * we can check by comparing the object's type pointer. */ if (Tcl_GetDoubleFromObj(interp, src, &dvalue) != TCL_OK) { - return TCL_ERROR; + if ( src->typePtr != &tclDoubleType ) { + return TCL_ERROR; + } + dvalue = src->internalRep.doubleValue; } CopyNumber(&dvalue, *cursorPtr, sizeof(double), type); *cursorPtr += sizeof(double); @@ -1619,10 +1624,14 @@ FormatNumber(interp, type, src, cursorPtr) case 'R': /* * Single-precision floating point values. + * Tcl_GetDoubleFromObj returns TCL_ERROR for NaN, but + * we can check by comparing the object's type pointer. */ if (Tcl_GetDoubleFromObj(interp, src, &dvalue) != TCL_OK) { - return TCL_ERROR; + if ( src->typePtr != &tclDoubleType ) { + return TCL_ERROR; + } } /* diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c index eb57690..c3037bc 100644 --- a/generic/tclCmdAH.c +++ b/generic/tclCmdAH.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCmdAH.c,v 1.60 2005/04/19 16:32:55 dgp Exp $ + * RCS: @(#) $Id: tclCmdAH.c,v 1.61 2005/05/10 18:34:08 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclCmdIL.c b/generic/tclCmdIL.c index 3b61959..7f67180 100644 --- a/generic/tclCmdIL.c +++ b/generic/tclCmdIL.c @@ -15,7 +15,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCmdIL.c,v 1.73 2005/05/05 18:37:56 dgp Exp $ + * RCS: @(#) $Id: tclCmdIL.c,v 1.74 2005/05/10 18:34:08 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclCmdMZ.c b/generic/tclCmdMZ.c index 18da3f4..aee76d3 100644 --- a/generic/tclCmdMZ.c +++ b/generic/tclCmdMZ.c @@ -15,7 +15,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCmdMZ.c,v 1.117 2005/04/29 20:49:43 dgp Exp $ + * RCS: @(#) $Id: tclCmdMZ.c,v 1.118 2005/05/10 18:34:08 kennykb Exp $ */ #include "tclInt.h" @@ -1536,17 +1536,8 @@ Tcl_StringObjCmd(dummy, interp, objc, objv) } } errno = 0; - strtod(string1, &stop); /* INTL: Tcl source. */ - if (errno == ERANGE) { - /* - * if (errno == ERANGE), then it was an over/underflow - * problem, but in this method, we only want to know - * yes or no, so bad flow returns 0 (false) and sets - * the failVarObj to the string length. - */ - result = 0; - failat = -1; - } else if (stop == string1) { + TclStrToD(string1, (CONST char **) &stop); /* INTL: Tcl source. */ + if (stop == string1) { /* * In this case, nothing like a number was found */ diff --git a/generic/tclCompCmds.c b/generic/tclCompCmds.c index bd0c4b7..da77439 100644 --- a/generic/tclCompCmds.c +++ b/generic/tclCompCmds.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCompCmds.c,v 1.67 2005/05/05 18:37:57 dgp Exp $ + * RCS: @(#) $Id: tclCompCmds.c,v 1.68 2005/05/10 18:34:09 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclCompExpr.c b/generic/tclCompExpr.c index e25160d..e378ef6 100644 --- a/generic/tclCompExpr.c +++ b/generic/tclCompExpr.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCompExpr.c,v 1.25 2004/10/08 15:39:52 dkf Exp $ + * RCS: @(#) $Id: tclCompExpr.c,v 1.26 2005/05/10 18:34:11 kennykb Exp $ */ #include "tclInt.h" @@ -828,95 +828,54 @@ CompileMathFuncCall(exprTokenPtr, funcName, infoPtr, envPtr, endPtrPtr) * just after the last token in the * subexpression is stored here. */ { - Tcl_Interp *interp = infoPtr->interp; - Interp *iPtr = (Interp *) interp; - MathFunc *mathFuncPtr; - Tcl_HashEntry *hPtr; + Tcl_DString cmdName; + int objIndex; Tcl_Token *tokenPtr, *afterSubexprPtr; - int code, i; - - /* - * Look up the MathFunc record for the function. - */ - - code = TCL_OK; - hPtr = Tcl_FindHashEntry(&iPtr->mathFuncTable, funcName); - if (hPtr == NULL) { - Tcl_AppendResult(interp, "unknown math function \"", funcName, - "\"", (char *) NULL); - code = TCL_ERROR; - goto done; - } - mathFuncPtr = (MathFunc *) Tcl_GetHashValue(hPtr); - + int argCount; + int code = TCL_OK; + /* - * If not a builtin function, push an object with the function's name. + * Prepend "tcl::mathfunc::" to the function name, to produce the + * name of a command that evaluates the function. Push that + * command name on the stack, in a literal registered to the + * namespace so that resolution can be cached. */ - if (mathFuncPtr->builtinFuncIndex < 0) { - TclEmitPush(TclRegisterNewLiteral(envPtr, funcName, -1), envPtr); - } + Tcl_DStringInit( &cmdName ); + Tcl_DStringAppend( &cmdName, "tcl::mathfunc::", -1 ); + Tcl_DStringAppend( &cmdName, funcName, -1 ); + objIndex = TclRegisterNewNSLiteral( envPtr, + Tcl_DStringValue( &cmdName ), + Tcl_DStringLength( &cmdName ) ); + TclEmitPush( objIndex, envPtr ); + Tcl_DStringFree( &cmdName ); /* * Compile any arguments for the function. */ + argCount = 1; tokenPtr = exprTokenPtr+2; afterSubexprPtr = exprTokenPtr + (exprTokenPtr->numComponents + 1); - if (mathFuncPtr->numArgs > 0) { - for (i = 0; i < mathFuncPtr->numArgs; i++) { - if (tokenPtr == afterSubexprPtr) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "too few arguments for math function", -1)); - code = TCL_ERROR; - goto done; - } - code = CompileSubExpr(tokenPtr, infoPtr, envPtr); - if (code != TCL_OK) { - goto done; - } - tokenPtr += (tokenPtr->numComponents + 1); + while (tokenPtr != afterSubexprPtr) { + ++argCount; + code = CompileSubExpr(tokenPtr, infoPtr, envPtr); + if (code != TCL_OK) { + return code; } - if (tokenPtr != afterSubexprPtr) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "too many arguments for math function", -1)); - code = TCL_ERROR; - goto done; - } - } else if (tokenPtr != afterSubexprPtr) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "too many arguments for math function", -1)); - code = TCL_ERROR; - goto done; + tokenPtr += (tokenPtr->numComponents + 1); } - /* - * Compile the call on the math function. Note that the "objc" argument - * count for non-builtin functions is incremented by 1 to include the - * function name itself. - */ + /* Invoke the function */ - if (mathFuncPtr->builtinFuncIndex >= 0) { /* a builtin function */ - /* - * Adjust the current stack depth by the number of arguments - * of the builtin function. This cannot be handled by the - * TclEmitInstInt1 macro as the number of arguments is not - * passed as an operand. - */ - - if (envPtr->maxStackDepth < envPtr->currStackDepth) { - envPtr->maxStackDepth = envPtr->currStackDepth; - } - TclEmitInstInt1(INST_CALL_BUILTIN_FUNC1, - mathFuncPtr->builtinFuncIndex, envPtr); - envPtr->currStackDepth -= mathFuncPtr->numArgs; + if ( argCount < 255 ) { + TclEmitInstInt1( INST_INVOKE_STK1, argCount, envPtr ); } else { - TclEmitInstInt1(INST_CALL_FUNC1, (mathFuncPtr->numArgs+1), envPtr); + TclEmitInstInt4( INST_INVOKE_STK4, argCount, envPtr ); } - *endPtrPtr = afterSubexprPtr; - done: - return code; + *endPtrPtr = afterSubexprPtr; + return TCL_OK; } /* diff --git a/generic/tclCompile.c b/generic/tclCompile.c index 47b6831..f67fea6 100644 --- a/generic/tclCompile.c +++ b/generic/tclCompile.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCompile.c,v 1.84 2005/05/05 15:32:20 dgp Exp $ + * RCS: @(#) $Id: tclCompile.c,v 1.85 2005/05/10 18:34:11 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclCompile.h b/generic/tclCompile.h index 896b385..ab34f81 100644 --- a/generic/tclCompile.h +++ b/generic/tclCompile.h @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclCompile.h,v 1.54 2005/03/25 00:35:03 dgp Exp $ + * RCS: @(#) $Id: tclCompile.h,v 1.55 2005/05/10 18:34:27 kennykb Exp $ */ #ifndef _TCLCOMPILATION @@ -591,64 +591,6 @@ typedef struct InstructionDesc { MODULE_SCOPE InstructionDesc tclInstructionTable[]; /* - * Definitions of the values of the INST_CALL_BUILTIN_FUNC instruction's - * operand byte. Each value denotes a builtin Tcl math function. These - * values must correspond to the entries in the tclBuiltinFuncTable array - * below and to the values stored in the tclInt.h MathFunc structure's - * builtinFuncIndex field. - */ - -#define BUILTIN_FUNC_ACOS 0 -#define BUILTIN_FUNC_ASIN 1 -#define BUILTIN_FUNC_ATAN 2 -#define BUILTIN_FUNC_ATAN2 3 -#define BUILTIN_FUNC_CEIL 4 -#define BUILTIN_FUNC_COS 5 -#define BUILTIN_FUNC_COSH 6 -#define BUILTIN_FUNC_EXP 7 -#define BUILTIN_FUNC_FLOOR 8 -#define BUILTIN_FUNC_FMOD 9 -#define BUILTIN_FUNC_HYPOT 10 -#define BUILTIN_FUNC_LOG 11 -#define BUILTIN_FUNC_LOG10 12 -#define BUILTIN_FUNC_POW 13 -#define BUILTIN_FUNC_SIN 14 -#define BUILTIN_FUNC_SINH 15 -#define BUILTIN_FUNC_SQRT 16 -#define BUILTIN_FUNC_TAN 17 -#define BUILTIN_FUNC_TANH 18 -#define BUILTIN_FUNC_ABS 19 -#define BUILTIN_FUNC_DOUBLE 20 -#define BUILTIN_FUNC_INT 21 -#define BUILTIN_FUNC_RAND 22 -#define BUILTIN_FUNC_ROUND 23 -#define BUILTIN_FUNC_SRAND 24 -#define BUILTIN_FUNC_WIDE 25 - -#define LAST_BUILTIN_FUNC 25 - -/* - * Table describing the built-in math functions. Entries in this table are - * indexed by the values of the INST_CALL_BUILTIN_FUNC instruction's - * operand byte. - */ - -typedef int (CallBuiltinFuncProc) _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); - -typedef struct { - char *name; /* Name of function. */ - int numArgs; /* Number of arguments for function. */ - Tcl_ValueType argTypes[MAX_MATH_ARGS]; - /* Acceptable types for each argument. */ - CallBuiltinFuncProc *proc; /* Procedure implementing this function. */ - ClientData clientData; /* Additional argument to pass to the - * function when invoking it. */ -} BuiltinFunc; - -MODULE_SCOPE BuiltinFunc tclBuiltinFuncTable[]; - -/* * Compilation of some Tcl constructs such as if commands and the logical or * (||) and logical and (&&) operators in expressions requires the * generation of forward jumps. Since the PC target of these jumps isn't diff --git a/generic/tclConfig.c b/generic/tclConfig.c index 4172fdb..f9c6dda 100644 --- a/generic/tclConfig.c +++ b/generic/tclConfig.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclConfig.c,v 1.7 2005/04/02 02:08:32 msofer Exp $ + * RCS: @(#) $Id: tclConfig.c,v 1.8 2005/05/10 18:34:28 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclDecls.h b/generic/tclDecls.h index 0ec588f..7ab10d3 100644 --- a/generic/tclDecls.h +++ b/generic/tclDecls.h @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclDecls.h,v 1.112 2005/05/03 18:07:47 dgp Exp $ + * RCS: @(#) $Id: tclDecls.h,v 1.113 2005/05/10 18:34:28 kennykb Exp $ */ #ifndef _TCLDECLS @@ -3461,6 +3461,29 @@ EXTERN void Tcl_QueryTimeProc _ANSI_ARGS_(( EXTERN Tcl_DriverThreadActionProc * Tcl_ChannelThreadActionProc _ANSI_ARGS_(( Tcl_ChannelType * chanTypePtr)); #endif +#ifndef Tcl_NewBignumObj_TCL_DECLARED +#define Tcl_NewBignumObj_TCL_DECLARED +/* 555 */ +EXTERN Tcl_Obj* Tcl_NewBignumObj _ANSI_ARGS_((mp_int* value)); +#endif +#ifndef Tcl_DbNewBignumObj_TCL_DECLARED +#define Tcl_DbNewBignumObj_TCL_DECLARED +/* 556 */ +EXTERN Tcl_Obj* Tcl_DbNewBignumObj _ANSI_ARGS_((mp_int* value, + CONST char* file, int line)); +#endif +#ifndef Tcl_SetBignumObj_TCL_DECLARED +#define Tcl_SetBignumObj_TCL_DECLARED +/* 557 */ +EXTERN void Tcl_SetBignumObj _ANSI_ARGS_((Tcl_Obj* obj, + mp_int* value)); +#endif +#ifndef Tcl_GetBignumFromObj_TCL_DECLARED +#define Tcl_GetBignumFromObj_TCL_DECLARED +/* 558 */ +EXTERN int Tcl_GetBignumFromObj _ANSI_ARGS_((Tcl_Interp* interp, + Tcl_Obj* obj, mp_int* value)); +#endif typedef struct TclStubHooks { struct TclPlatStubs *tclPlatStubs; @@ -4057,6 +4080,10 @@ typedef struct TclStubs { void (*tcl_SetTimeProc) _ANSI_ARGS_((Tcl_GetTimeProc* getProc, Tcl_ScaleTimeProc* scaleProc, ClientData clientData)); /* 552 */ void (*tcl_QueryTimeProc) _ANSI_ARGS_((Tcl_GetTimeProc** getProc, Tcl_ScaleTimeProc** scaleProc, ClientData* clientData)); /* 553 */ Tcl_DriverThreadActionProc * (*tcl_ChannelThreadActionProc) _ANSI_ARGS_((Tcl_ChannelType * chanTypePtr)); /* 554 */ + Tcl_Obj* (*tcl_NewBignumObj) _ANSI_ARGS_((mp_int* value)); /* 555 */ + Tcl_Obj* (*tcl_DbNewBignumObj) _ANSI_ARGS_((mp_int* value, CONST char* file, int line)); /* 556 */ + void (*tcl_SetBignumObj) _ANSI_ARGS_((Tcl_Obj* obj, mp_int* value)); /* 557 */ + int (*tcl_GetBignumFromObj) _ANSI_ARGS_((Tcl_Interp* interp, Tcl_Obj* obj, mp_int* value)); /* 558 */ } TclStubs; #ifdef __cplusplus @@ -6317,6 +6344,22 @@ extern TclStubs *tclStubsPtr; #define Tcl_ChannelThreadActionProc \ (tclStubsPtr->tcl_ChannelThreadActionProc) /* 554 */ #endif +#ifndef Tcl_NewBignumObj +#define Tcl_NewBignumObj \ + (tclStubsPtr->tcl_NewBignumObj) /* 555 */ +#endif +#ifndef Tcl_DbNewBignumObj +#define Tcl_DbNewBignumObj \ + (tclStubsPtr->tcl_DbNewBignumObj) /* 556 */ +#endif +#ifndef Tcl_SetBignumObj +#define Tcl_SetBignumObj \ + (tclStubsPtr->tcl_SetBignumObj) /* 557 */ +#endif +#ifndef Tcl_GetBignumFromObj +#define Tcl_GetBignumFromObj \ + (tclStubsPtr->tcl_GetBignumFromObj) /* 558 */ +#endif #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */ diff --git a/generic/tclDictObj.c b/generic/tclDictObj.c index 1dc87d4..5c40825 100644 --- a/generic/tclDictObj.c +++ b/generic/tclDictObj.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclDictObj.c,v 1.30 2005/05/05 18:37:58 dgp Exp $ + * RCS: @(#) $Id: tclDictObj.c,v 1.31 2005/05/10 18:34:34 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c index 13c517b..646713d 100644 --- a/generic/tclEncoding.c +++ b/generic/tclEncoding.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclEncoding.c,v 1.34 2005/04/12 20:28:46 dgp Exp $ + * RCS: @(#) $Id: tclEncoding.c,v 1.35 2005/05/10 18:34:34 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclEnv.c b/generic/tclEnv.c index e4d7b23..4ceb4fb 100644 --- a/generic/tclEnv.c +++ b/generic/tclEnv.c @@ -12,7 +12,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclEnv.c,v 1.23 2005/05/03 18:08:17 dgp Exp $ + * RCS: @(#) $Id: tclEnv.c,v 1.24 2005/05/10 18:34:34 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclEvent.c b/generic/tclEvent.c index 8d4533ec..6e2a4df 100644 --- a/generic/tclEvent.c +++ b/generic/tclEvent.c @@ -12,7 +12,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclEvent.c,v 1.56 2004/12/16 19:36:17 dkf Exp $ + * RCS: @(#) $Id: tclEvent.c,v 1.57 2005/05/10 18:34:35 kennykb Exp $ */ #include "tclInt.h" @@ -798,6 +798,8 @@ TclInitSubsystems() #endif TclpInitPlatform(); /* creates signal handler(s) */ + TclInitDoubleConversion(); /* initializes constants for + * converting to/from double */ TclInitObjSubsystem(); /* register obj types, create mutexes */ TclInitIOSubsystem(); /* inits a tsd key (noop) */ TclInitEncodingSubsystem(); /* process wide encoding init */ @@ -938,6 +940,10 @@ Tcl_Finalize() TclFinalizeLoad(); TclResetFilesystem(); + + /* Now we can free constants for conversions to/from double */ + + TclFinalizeDoubleConversion(); /* * There shouldn't be any malloc'ed memory after this. diff --git a/generic/tclExecute.c b/generic/tclExecute.c index ad91579..3333c79 100644 --- a/generic/tclExecute.c +++ b/generic/tclExecute.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclExecute.c,v 1.187 2005/05/10 10:02:16 msofer Exp $ + * RCS: @(#) $Id: tclExecute.c,v 1.188 2005/05/10 18:34:35 kennykb Exp $ */ #include "tclInt.h" @@ -20,6 +20,18 @@ #ifndef TCL_NO_MATH # include <math.h> #endif +#include <float.h> + +/* + * Hack to determine whether we may expect IEEE floating point. + * The hack is formally incorrect in that non-IEEE platforms might + * have the same precision and range, but VAX, IBM, and Cray do not; + * are there any other floating point units that we might care about? + */ + +#if ( FLT_RADIX == 2 ) && ( DBL_MANT_DIG == 53 ) && ( DBL_MAX_EXP == 1024 ) +#define IEEE_FLOATING_POINT +#endif /* * The stuff below is a bit of a hack so that this file can be used @@ -136,8 +148,13 @@ long tclObjsShared[TCL_MAX_SHARED_OBJ_STATS] = { 0, 0, 0, 0, 0 }; * by comparing against the largest floating-point value. */ -#define IS_NAN(v) ((v) != (v)) -#define IS_INF(v) (((v) > DBL_MAX) || ((v) < -DBL_MAX)) +#ifdef _MSC_VER +#define IS_NAN(f) (_isnan((f))) +#define IS_INF(f) ( ! (_finite((f)))) +#else +#define IS_NAN(f) ((f) != (f)) +#define IS_INF(f) ( (f) > DBL_MAX || (f) < -DBL_MAX ) +#endif /* * The new macro for ending an instruction; note that a @@ -345,26 +362,6 @@ long tclObjsShared[TCL_MAX_SHARED_OBJ_STATS] = { 0, 0, 0, 0, 0 }; static int TclExecuteByteCode _ANSI_ARGS_((Tcl_Interp *interp, ByteCode *codePtr)); -static int ExprAbsFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprBinaryFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprCallMathFunc _ANSI_ARGS_((Tcl_Interp *interp, - int objc, Tcl_Obj **objv)); -static int ExprDoubleFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprIntFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprRandFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprRoundFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprSrandFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprUnaryFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); -static int ExprWideFunc _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj **tosPtr, ClientData clientData)); #ifdef TCL_COMPILE_STATS static int EvalStatsCmd _ANSI_ARGS_((ClientData clientData, Tcl_Interp *interp, int objc, @@ -391,50 +388,11 @@ static void ValidatePcAndStackTop _ANSI_ARGS_(( int stackTop, int stackLowerBound, int checkStack)); #endif /* TCL_COMPILE_DEBUG */ -static int VerifyExprObjType _ANSI_ARGS_((Tcl_Interp *interp, - Tcl_Obj *objPtr)); static Tcl_WideInt ExponWide _ANSI_ARGS_((Tcl_WideInt w, Tcl_WideInt w2, int *errExpon)); static long ExponLong _ANSI_ARGS_((long i, long i2, int *errExpon)); -/* - * Table describing the built-in math functions. Entries in this table are - * indexed by the values of the INST_CALL_BUILTIN_FUNC instruction's - * operand byte. - */ - -BuiltinFunc tclBuiltinFuncTable[] = { -#ifndef TCL_NO_MATH - {"acos", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) acos}, - {"asin", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) asin}, - {"atan", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) atan}, - {"atan2", 2, {TCL_DOUBLE, TCL_DOUBLE}, ExprBinaryFunc, (ClientData) atan2}, - {"ceil", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) ceil}, - {"cos", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) cos}, - {"cosh", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) cosh}, - {"exp", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) exp}, - {"floor", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) floor}, - {"fmod", 2, {TCL_DOUBLE, TCL_DOUBLE}, ExprBinaryFunc, (ClientData) fmod}, - {"hypot", 2, {TCL_DOUBLE, TCL_DOUBLE}, ExprBinaryFunc, (ClientData) hypot}, - {"log", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) log}, - {"log10", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) log10}, - {"pow", 2, {TCL_DOUBLE, TCL_DOUBLE}, ExprBinaryFunc, (ClientData) pow}, - {"sin", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) sin}, - {"sinh", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) sinh}, - {"sqrt", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) sqrt}, - {"tan", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) tan}, - {"tanh", 1, {TCL_DOUBLE}, ExprUnaryFunc, (ClientData) tanh}, -#endif - {"abs", 1, {TCL_EITHER}, ExprAbsFunc, 0}, - {"double", 1, {TCL_EITHER}, ExprDoubleFunc, 0}, - {"int", 1, {TCL_EITHER}, ExprIntFunc, 0}, - {"rand", 0, {TCL_EITHER}, ExprRandFunc, 0}, /* NOTE: rand takes no args. */ - {"round", 1, {TCL_EITHER}, ExprRoundFunc, 0}, - {"srand", 1, {TCL_INT}, ExprSrandFunc, 0}, - {"wide", 1, {TCL_EITHER}, ExprWideFunc, 0}, - {0}, -}; /* *---------------------------------------------------------------------- @@ -4023,10 +3981,18 @@ TclExecuteByteCode(interp, codePtr) dResult = d1 * d2; break; case INST_DIV: +#ifndef IEEE_FLOATING_POINT if (d2 == 0.0) { TRACE(("%.6g %.6g => DIVIDE BY ZERO\n", d1, d2)); goto divideByZero; } +#endif + /* + * We presume that we are running with zero-divide + * unmasked if we're on an IEEE box. Otherwise, + * this statement might cause demons to fly out + * our noses. + */ dResult = d1 / d2; break; case INST_EXPON: @@ -4042,7 +4008,7 @@ TclExecuteByteCode(interp, codePtr) * Check now for IEEE floating-point error. */ - if (IS_NAN(dResult) || IS_INF(dResult)) { + if (IS_NAN(dResult)) { TRACE(("%.20s %.20s => IEEE FLOATING PT ERROR\n", O2S(valuePtr), O2S(value2Ptr))); TclExprFloatError(interp, dResult); @@ -4430,53 +4396,13 @@ TclExecuteByteCode(interp, codePtr) case INST_CALL_BUILTIN_FUNC1: { - int opnd; - BuiltinFunc *mathFuncPtr; - - /* - * Call one of the built-in Tcl math functions. - */ - - opnd = TclGetUInt1AtPtr(pc+1); - if ((opnd < 0) || (opnd > LAST_BUILTIN_FUNC)) { - TRACE(("UNRECOGNIZED BUILTIN FUNC CODE %d\n", opnd)); - Tcl_Panic("TclExecuteByteCode: unrecognized builtin function code %d", opnd); - } - mathFuncPtr = &(tclBuiltinFuncTable[opnd]); - result = (*mathFuncPtr->proc)(interp, tosPtr, - mathFuncPtr->clientData); - if (result != TCL_OK) { - goto checkForCatch; - } - tosPtr -= (mathFuncPtr->numArgs - 1); - TRACE_WITH_OBJ(("%d => ", opnd), *tosPtr); + Tcl_Panic("TclExecuteByteCode: obsolete INST_CALL_BUILTIN_FUNC1 found"); } - NEXT_INST_F(2, 0, 0); case INST_CALL_FUNC1: { - /* - * Call a non-builtin Tcl math function previously - * registered by a call to Tcl_CreateMathFunc. - */ - - int objc; /* Number of arguments. The function name - * is the 0-th argument. */ - Tcl_Obj **objv; /* The array of arguments. The function - * name is objv[0]. */ - - objc = TclGetUInt1AtPtr(pc+1); - objv = (tosPtr - (objc-1)); /* "objv[0]" */ - DECACHE_STACK_INFO(); - result = ExprCallMathFunc(interp, objc, objv); - CACHE_STACK_INFO(); - if (result != TCL_OK) { - goto checkForCatch; - } - tosPtr = objv; - TRACE_WITH_OBJ(("%d => ", objc), *tosPtr); + Tcl_Panic("TclExecuteByteCode: obsolete INST_CALL_FUNC1 found"); } - NEXT_INST_F(2, 0, 0); case INST_TRY_CVT_TO_NUMERIC: { @@ -4569,7 +4495,7 @@ TclExecuteByteCode(interp, codePtr) if (tPtr == &tclDoubleType) { d = objResultPtr->internalRep.doubleValue; - if (IS_NAN(d) || IS_INF(d)) { + if (IS_NAN(d)) { TRACE(("\"%.20s\" => IEEE FLOATING PT ERROR\n", O2S(objResultPtr))); TclExprFloatError(interp, d); @@ -5594,765 +5520,6 @@ GetOpcodeName(pc) /* *---------------------------------------------------------------------- * - * VerifyExprObjType -- - * - * This procedure is called by the math functions to verify that - * the object is either an int or double, coercing it if necessary. - * If an error occurs during conversion, an error message is left - * in the interpreter's result unless "interp" is NULL. - * - * Results: - * TCL_OK if it was int or double, TCL_ERROR otherwise - * - * Side effects: - * objPtr is ensured to be of tclIntType, tclWideIntType or - * tclDoubleType. - * - *---------------------------------------------------------------------- - */ - -static int -VerifyExprObjType(interp, objPtr) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj *objPtr; /* Points to the object to type check. */ -{ - if (IS_NUMERIC_TYPE(objPtr->typePtr)) { - return TCL_OK; - } else { - int length, result = TCL_OK; - char *s = Tcl_GetStringFromObj(objPtr, &length); - - if (TclLooksLikeInt(s, length)) { - long i; /* Set but never used, needed in GET_WIDE_OR_INT */ - Tcl_WideInt w; - GET_WIDE_OR_INT(result, objPtr, i, w); - } else { - double d; - result = Tcl_GetDoubleFromObj((Tcl_Interp *) NULL, objPtr, &d); - } - if ((result != TCL_OK) && (interp != NULL)) { - if (TclCheckBadOctal((Tcl_Interp *) NULL, s)) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "argument to math function was an invalid octal number", - -1)); - } else { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "argument to math function didn't have numeric value", - -1)); - } - } - return result; - } -} - -/* - *---------------------------------------------------------------------- - * - * Math Functions -- - * - * This page contains the procedures that implement all of the - * built-in math functions for expressions. - * - * Results: - * Each procedure returns TCL_OK if it succeeds and pushes an - * Tcl object holding the result. If it fails it returns TCL_ERROR - * and leaves an error message in the interpreter's result. - * - * Side effects: - * None. - * - *---------------------------------------------------------------------- - */ - -static int -ExprUnaryFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Contains the address of a procedure that - * takes one double argument and returns a - * double result. */ -{ - register Tcl_Obj *valuePtr, *resPtr; - double d, dResult; - - double (*func) _ANSI_ARGS_((double)) = - (double (*)_ANSI_ARGS_((double))) clientData; - - /* - * Pop the function's argument from the evaluation stack. Convert it - * to a double if necessary. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - GET_DOUBLE_VALUE(d, valuePtr, valuePtr->typePtr); - - errno = 0; - dResult = (*func)(d); - if ((errno != 0) || IS_NAN(dResult) || IS_INF(dResult)) { - TclExprFloatError(interp, dResult); - return TCL_ERROR; - } - - /* - * Push a Tcl object holding the result. - */ - - TclNewDoubleObj(resPtr, dResult); - PUSH_OBJECT(resPtr); - TclDecrRefCount(valuePtr); - return TCL_OK; -} - -static int -ExprBinaryFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Contains the address of a procedure that - * takes two double arguments and - * returns a double result. */ -{ - register Tcl_Obj *valuePtr, *value2Ptr, *resPtr; - double d1, d2, dResult; - - double (*func) _ANSI_ARGS_((double, double)) - = (double (*)_ANSI_ARGS_((double, double))) clientData; - - /* - * Pop the function's two arguments from the evaluation stack. Convert - * them to doubles if necessary. - */ - - value2Ptr = POP_OBJECT(); - valuePtr = POP_OBJECT(); - - if ((VerifyExprObjType(interp, valuePtr) != TCL_OK) || - (VerifyExprObjType(interp, value2Ptr) != TCL_OK)) { - return TCL_ERROR; - } - - GET_DOUBLE_VALUE(d1, valuePtr, valuePtr->typePtr); - GET_DOUBLE_VALUE(d2, value2Ptr, value2Ptr->typePtr); - - errno = 0; - dResult = (*func)(d1, d2); - if ((errno != 0) || IS_NAN(dResult) || IS_INF(dResult)) { - TclExprFloatError(interp, dResult); - return TCL_ERROR; - } - - /* - * Push a Tcl object holding the result. - */ - - TclNewDoubleObj(resPtr, dResult); - PUSH_OBJECT(resPtr); - TclDecrRefCount(valuePtr); - TclDecrRefCount(value2Ptr); - return TCL_OK; -} - -static int -ExprAbsFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - register Tcl_Obj *valuePtr, *resPtr; - long i, iResult; - double d, dResult; - - /* - * Pop the argument from the evaluation stack. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - /* - * Push a Tcl object with the result. - */ - if (valuePtr->typePtr == &tclIntType) { - i = valuePtr->internalRep.longValue; - if (i < 0) { - iResult = -i; - if (iResult < 0) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "integer value too large to represent", -1)); - Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", - "integer value too large to represent", (char *) NULL); - return TCL_ERROR; - } - } else { - iResult = i; - } - TclNewLongObj(resPtr, iResult); - PUSH_OBJECT(resPtr); - } else if (valuePtr->typePtr == &tclWideIntType) { - Tcl_WideInt wResult, w; - TclGetWide(w,valuePtr); - if (w < W0) { - wResult = -w; - if (wResult < 0) { - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "integer value too large to represent", -1)); - Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", - "integer value too large to represent", (char *) NULL); - return TCL_ERROR; - } - } else { - wResult = w; - } - TclNewWideIntObj(resPtr, wResult); - PUSH_OBJECT(resPtr); - } else { - d = valuePtr->internalRep.doubleValue; - if (d < 0.0) { - dResult = -d; - } else { - dResult = d; - } - if (IS_NAN(dResult) || IS_INF(dResult)) { - TclExprFloatError(interp, dResult); - return TCL_ERROR; - } - TclNewDoubleObj(resPtr, dResult); - PUSH_OBJECT(resPtr); - } - - TclDecrRefCount(valuePtr); - return TCL_OK; -} - -static int -ExprDoubleFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - register Tcl_Obj *valuePtr, *resPtr; - double dResult; - - /* - * Pop the argument from the evaluation stack. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - GET_DOUBLE_VALUE(dResult, valuePtr, valuePtr->typePtr); - - /* - * Push a Tcl object with the result. - */ - - TclNewDoubleObj(resPtr, dResult); - PUSH_OBJECT(resPtr); - - TclDecrRefCount(valuePtr); - return TCL_OK; -} - -static int -ExprIntFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - register Tcl_Obj *valuePtr, *resPtr; - long iResult; - double d; - - /* - * Pop the argument from the evaluation stack. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - if (valuePtr->typePtr == &tclIntType) { - iResult = valuePtr->internalRep.longValue; - } else if (valuePtr->typePtr == &tclWideIntType) { - TclGetLongFromWide(iResult,valuePtr); - } else { - d = valuePtr->internalRep.doubleValue; - if (d < 0.0) { - if (d < (double) (long) LONG_MIN) { - tooLarge: - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "integer value too large to represent", -1)); - Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", - "integer value too large to represent", (char *) NULL); - return TCL_ERROR; - } - } else { - if (d > (double) LONG_MAX) { - goto tooLarge; - } - } - if (IS_NAN(d) || IS_INF(d)) { - TclExprFloatError(interp, d); - return TCL_ERROR; - } - iResult = (long) d; - } - - /* - * Push a Tcl object with the result. - */ - - TclNewLongObj(resPtr, iResult); - PUSH_OBJECT(resPtr); - TclDecrRefCount(valuePtr); - return TCL_OK; -} - -static int -ExprWideFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - register Tcl_Obj *valuePtr, *resPtr; - Tcl_WideInt wResult; - double d; - - /* - * Pop the argument from the evaluation stack. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - if (valuePtr->typePtr == &tclWideIntType) { - TclGetWide(wResult,valuePtr); - } else if (valuePtr->typePtr == &tclIntType) { - wResult = Tcl_LongAsWide(valuePtr->internalRep.longValue); - } else { - d = valuePtr->internalRep.doubleValue; - if (d < 0.0) { - if (d < Tcl_WideAsDouble(LLONG_MIN)) { - tooLarge: - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "integer value too large to represent", -1)); - Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", - "integer value too large to represent", (char *) NULL); - return TCL_ERROR; - } - } else { - if (d > Tcl_WideAsDouble(LLONG_MAX)) { - goto tooLarge; - } - } - if (IS_NAN(d) || IS_INF(d)) { - TclExprFloatError(interp, d); - return TCL_ERROR; - } - wResult = Tcl_DoubleAsWide(d); - } - - /* - * Push a Tcl object with the result. - */ - - TclNewWideIntObj(resPtr, wResult); - PUSH_OBJECT(resPtr); - TclDecrRefCount(valuePtr); - return TCL_OK; -} - -static int -ExprRandFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - Interp *iPtr = (Interp *) interp; - double dResult; - long tmp; /* Algorithm assumes at least 32 bits. - * Only long guarantees that. See below. */ - Tcl_Obj *resPtr; - - if (!(iPtr->flags & RAND_SEED_INITIALIZED)) { - iPtr->flags |= RAND_SEED_INITIALIZED; - - /* - * Take into consideration the thread this interp is running in order - * to insure different seeds in different threads (bug #416643) - */ - - iPtr->randSeed = TclpGetClicks() + ((long)Tcl_GetCurrentThread()<<12); - - /* - * Make sure 1 <= randSeed <= (2^31) - 2. See below. - */ - - iPtr->randSeed &= (unsigned long) 0x7fffffff; - if ((iPtr->randSeed == 0) || (iPtr->randSeed == 0x7fffffff)) { - iPtr->randSeed ^= 123459876; - } - } - - /* - * Generate the random number using the linear congruential - * generator defined by the following recurrence: - * seed = ( IA * seed ) mod IM - * where IA is 16807 and IM is (2^31) - 1. The recurrence maps - * a seed in the range [1, IM - 1] to a new seed in that same range. - * The recurrence maps IM to 0, and maps 0 back to 0, so those two - * values must not be allowed as initial values of seed. - * - * In order to avoid potential problems with integer overflow, the - * recurrence is implemented in terms of additional constants - * IQ and IR such that - * IM = IA*IQ + IR - * None of the operations in the implementation overflows a 32-bit - * signed integer, and the C type long is guaranteed to be at least - * 32 bits wide. - * - * For more details on how this algorithm works, refer to the following - * papers: - * - * S.K. Park & K.W. Miller, "Random number generators: good ones - * are hard to find," Comm ACM 31(10):1192-1201, Oct 1988 - * - * W.H. Press & S.A. Teukolsky, "Portable random number - * generators," Computers in Physics 6(5):522-524, Sep/Oct 1992. - */ - -#define RAND_IA 16807 -#define RAND_IM 2147483647 -#define RAND_IQ 127773 -#define RAND_IR 2836 -#define RAND_MASK 123459876 - - tmp = iPtr->randSeed/RAND_IQ; - iPtr->randSeed = RAND_IA*(iPtr->randSeed - tmp*RAND_IQ) - RAND_IR*tmp; - if (iPtr->randSeed < 0) { - iPtr->randSeed += RAND_IM; - } - - /* - * Since the recurrence keeps seed values in the range [1, RAND_IM - 1], - * dividing by RAND_IM yields a double in the range (0, 1). - */ - - dResult = iPtr->randSeed * (1.0/RAND_IM); - - /* - * Push a Tcl object with the result. - */ - - TclNewDoubleObj(resPtr, dResult); - PUSH_OBJECT(resPtr); - return TCL_OK; -} - -static int -ExprRoundFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - Tcl_Obj *valuePtr, *resPtr; - double d; - - /* - * Pop the argument from the evaluation stack. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - if ((valuePtr->typePtr == &tclIntType) || - (valuePtr->typePtr == &tclWideIntType)) { - return TCL_OK; - } - - d = valuePtr->internalRep.doubleValue; - if (d < 0.0) { - if (d <= Tcl_WideAsDouble(LLONG_MIN)-0.5) { - goto tooLarge; - } else if (d <= (((double) (long) LONG_MIN) - 0.5)) { - TclNewWideIntObj(resPtr, Tcl_DoubleAsWide(d - 0.5)); - } else { - TclNewLongObj(resPtr, (long) (d - 0.5)); - } - } else { - if (d >= Tcl_WideAsDouble(LLONG_MAX)+0.5) { - goto tooLarge; - } else if (d >= (((double) LONG_MAX + 0.5))) { - TclNewWideIntObj(resPtr, Tcl_DoubleAsWide(d + 0.5)); - } else { - TclNewLongObj(resPtr, (long) (d + 0.5)); - } - } - - /* - * Free the argument Tcl_Obj and push the result object. - */ - - TclDecrRefCount(valuePtr); - PUSH_OBJECT(resPtr); - return TCL_OK; - - /* - * Error return: result cannot be represented as an integer. - */ - - tooLarge: - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "integer value too large to represent", -1)); - Tcl_SetErrorCode(interp, "ARITH", "IOVERFLOW", - "integer value too large to represent", - (char *) NULL); - return TCL_ERROR; -} - -static int -ExprSrandFunc(interp, tosPtr, clientData) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - Tcl_Obj **tosPtr; /* Points to top of evaluation stack. */ - ClientData clientData; /* Ignored. */ -{ - Interp *iPtr = (Interp *) interp; - Tcl_Obj *valuePtr; - long i = 0; /* Initialized to avoid compiler warning. */ - - /* - * Pop the argument from the evaluation stack. Use the value - * to reset the random number seed. - */ - - valuePtr = POP_OBJECT(); - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - if (Tcl_GetLongFromObj(NULL, valuePtr, &i) != TCL_OK) { - /* - * At this point, the only other possible type is double - */ - Tcl_SetObjResult(interp, Tcl_NewStringObj( - "can't use floating-point value as argument to srand", -1)); - return TCL_ERROR; - } - - /* - * Reset the seed. Make sure 1 <= randSeed <= 2^31 - 2. - * See comments in ExprRandFunc() for more details. - */ - - iPtr->flags |= RAND_SEED_INITIALIZED; - iPtr->randSeed = i; - iPtr->randSeed &= (unsigned long) 0x7fffffff; - if ((iPtr->randSeed == 0) || (iPtr->randSeed == 0x7fffffff)) { - iPtr->randSeed ^= 123459876; - } - - /* - * To avoid duplicating the random number generation code we simply - * clean up our state and call the real random number function. That - * function will always succeed. - */ - - TclDecrRefCount(valuePtr); - ExprRandFunc(interp, tosPtr, clientData); - return TCL_OK; -} - -/* - *---------------------------------------------------------------------- - * - * ExprCallMathFunc -- - * - * This procedure is invoked to call a non-builtin math function - * during the execution of an expression. - * - * Results: - * TCL_OK is returned if all went well and the function's value - * was computed successfully. If an error occurred, TCL_ERROR - * is returned and an error message is left in the interpreter's - * result. After a successful return this procedure pops its - * objc arguments and pushes a Tcl object holding the result. - * - * Side effects: - * None, unless the called math function has side effects. - * - *---------------------------------------------------------------------- - */ - -static int -ExprCallMathFunc(interp, objc, objv) - Tcl_Interp *interp; /* The interpreter in which to execute the - * function. */ - int objc; /* Number of arguments. The function name is - * the 0-th argument. */ - Tcl_Obj **objv; /* The array of arguments. The function name - * is objv[0]. */ -{ - Interp *iPtr = (Interp *) interp; - char *funcName; - Tcl_HashEntry *hPtr; - MathFunc *mathFuncPtr; /* Information about math function. */ - Tcl_Value args[MAX_MATH_ARGS]; /* Arguments for function call. */ - Tcl_Value funcResult; /* Result of function call as Tcl_Value. */ - register Tcl_Obj *valuePtr; - long i; - double d; - int j, k, result; - - Tcl_ResetResult(interp); - - /* - * Look up the MathFunc record for the function. - */ - - funcName = TclGetString(objv[0]); - hPtr = Tcl_FindHashEntry(&iPtr->mathFuncTable, funcName); - if (hPtr == NULL) { - Tcl_AppendResult(interp, "unknown math function \"", funcName, - "\"", (char *) NULL); - return TCL_ERROR; - } - mathFuncPtr = (MathFunc *) Tcl_GetHashValue(hPtr); - if (mathFuncPtr->numArgs != (objc-1)) { - Tcl_Panic("ExprCallMathFunc: expected number of args %d != actual number %d", - mathFuncPtr->numArgs, objc); - return TCL_ERROR; - } - - /* - * Collect the arguments for the function, if there are any, into the - * array "args". Note that args[0] will have the Tcl_Value that - * corresponds to objv[1]. - */ - - for (j = 1, k = 0; j < objc; j++, k++) { - valuePtr = objv[j]; - - if (VerifyExprObjType(interp, valuePtr) != TCL_OK) { - return TCL_ERROR; - } - - /* - * Copy the object's numeric value to the argument record, - * converting it if necessary. - */ - - if (valuePtr->typePtr == &tclIntType) { - i = valuePtr->internalRep.longValue; - if (mathFuncPtr->argTypes[k] == TCL_DOUBLE) { - args[k].type = TCL_DOUBLE; - args[k].doubleValue = i; - } else if (mathFuncPtr->argTypes[k] == TCL_WIDE_INT) { - args[k].type = TCL_WIDE_INT; - args[k].wideValue = Tcl_LongAsWide(i); - } else { - args[k].type = TCL_INT; - args[k].intValue = i; - } - } else if (valuePtr->typePtr == &tclWideIntType) { - Tcl_WideInt w; - TclGetWide(w,valuePtr); - if (mathFuncPtr->argTypes[k] == TCL_DOUBLE) { - args[k].type = TCL_DOUBLE; - args[k].doubleValue = Tcl_WideAsDouble(w); - } else if (mathFuncPtr->argTypes[k] == TCL_INT) { - args[k].type = TCL_INT; - args[k].intValue = Tcl_WideAsLong(w); - } else { - args[k].type = TCL_WIDE_INT; - args[k].wideValue = w; - } - } else { - d = valuePtr->internalRep.doubleValue; - if (mathFuncPtr->argTypes[k] == TCL_INT) { - args[k].type = TCL_INT; - args[k].intValue = (long) d; - } else if (mathFuncPtr->argTypes[k] == TCL_WIDE_INT) { - args[k].type = TCL_WIDE_INT; - args[k].wideValue = Tcl_DoubleAsWide(d); - } else { - args[k].type = TCL_DOUBLE; - args[k].doubleValue = d; - } - } - } - - /* - * Invoke the function and copy its result back into valuePtr. - */ - - result = (*mathFuncPtr->proc)(mathFuncPtr->clientData, interp, args, - &funcResult); - if (result != TCL_OK) { - return result; - } - - /* - * Pop the objc top stack elements and decrement their ref counts. - */ - - for (k = 0; k < objc; k++) { - valuePtr = objv[k]; - TclDecrRefCount(valuePtr); - } - - /* - * Push the call's object result. - */ - - if (funcResult.type == TCL_INT) { - TclNewLongObj(objv[0], funcResult.intValue); - } else if (funcResult.type == TCL_WIDE_INT) { - TclNewWideIntObj(objv[0], funcResult.wideValue); - } else { - d = funcResult.doubleValue; - if (IS_NAN(d) || IS_INF(d)) { - TclExprFloatError(interp, d); - return TCL_ERROR; - } - TclNewDoubleObj(objv[0], d); - } - Tcl_IncrRefCount(objv[0]); - - return result; -} - -/* - *---------------------------------------------------------------------- - * * TclExprFloatError -- * * This procedure is called when an error occurs during a diff --git a/generic/tclFCmd.c b/generic/tclFCmd.c index 024526e..f8606e5 100644 --- a/generic/tclFCmd.c +++ b/generic/tclFCmd.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclFCmd.c,v 1.31 2005/01/14 18:56:32 vincentdarley Exp $ + * RCS: @(#) $Id: tclFCmd.c,v 1.32 2005/05/10 18:34:37 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclFileName.c b/generic/tclFileName.c index bde0071..5bfad99 100644 --- a/generic/tclFileName.c +++ b/generic/tclFileName.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclFileName.c,v 1.68 2005/04/20 15:13:39 kennykb Exp $ + * RCS: @(#) $Id: tclFileName.c,v 1.69 2005/05/10 18:34:38 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclGet.c b/generic/tclGet.c index 1804088..be3d942 100644 --- a/generic/tclGet.c +++ b/generic/tclGet.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclGet.c,v 1.14 2005/05/03 18:08:18 dgp Exp $ + * RCS: @(#) $Id: tclGet.c,v 1.15 2005/05/10 18:34:38 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclGetDate.y b/generic/tclGetDate.y index 0be34be..800c04b 100644 --- a/generic/tclGetDate.y +++ b/generic/tclGetDate.y @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclGetDate.y,v 1.26 2004/12/29 20:57:27 kennykb Exp $ + * RCS: @(#) $Id: tclGetDate.y,v 1.27 2005/05/10 18:34:38 kennykb Exp $ */ %{ diff --git a/generic/tclIO.c b/generic/tclIO.c index e94264a..ee37035 100644 --- a/generic/tclIO.c +++ b/generic/tclIO.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclIO.c,v 1.85 2005/05/05 18:37:58 dgp Exp $ + * RCS: @(#) $Id: tclIO.c,v 1.86 2005/05/10 18:34:38 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclIOCmd.c b/generic/tclIOCmd.c index fc14619..abd789c 100644 --- a/generic/tclIOCmd.c +++ b/generic/tclIOCmd.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclIOCmd.c,v 1.23 2005/04/27 18:48:25 dgp Exp $ + * RCS: @(#) $Id: tclIOCmd.c,v 1.24 2005/05/10 18:34:40 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclIOUtil.c b/generic/tclIOUtil.c index 17d6efa..f94a3c8 100644 --- a/generic/tclIOUtil.c +++ b/generic/tclIOUtil.c @@ -17,7 +17,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclIOUtil.c,v 1.117 2005/04/27 18:48:25 dgp Exp $ + * RCS: @(#) $Id: tclIOUtil.c,v 1.118 2005/05/10 18:34:40 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclInt.decls b/generic/tclInt.decls index a997c25..c457741 100644 --- a/generic/tclInt.decls +++ b/generic/tclInt.decls @@ -12,7 +12,7 @@ # See the file "license.terms" for information on usage and redistribution # of this file, and for a DISCLAIMER OF ALL WARRANTIES. # -# RCS: @(#) $Id: tclInt.decls,v 1.87 2005/05/05 18:38:00 dgp Exp $ +# RCS: @(#) $Id: tclInt.decls,v 1.88 2005/05/10 18:34:41 kennykb Exp $ library tcl @@ -874,6 +874,23 @@ declare 218 generic { void TclPopStackFrame(Tcl_Interp *interp) } +# Entries in tommath needed only by tcltest + +declare 219 generic { + int TclBN_mp_div_d(mp_int *a, mp_digit b, mp_int *c, mp_digit *d) +} +declare 220 generic { + int TclBN_mp_mul_d(mp_int *a, mp_digit b, mp_int *c) +} +declare 221 generic { + void TclBN_mp_clear(mp_int *a) +} +declare 222 generic { + int TclBN_mp_init(mp_int *a) +} +declare 223 generic { + int TclBN_mp_read_radix(mp_int *a, const char *str, int radix) +} ############################################################################## diff --git a/generic/tclInt.h b/generic/tclInt.h index 6af07ff..0a05edb 100644 --- a/generic/tclInt.h +++ b/generic/tclInt.h @@ -12,7 +12,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclInt.h,v 1.228 2005/05/05 18:38:01 dgp Exp $ + * RCS: @(#) $Id: tclInt.h,v 1.229 2005/05/10 18:34:42 kennykb Exp $ */ #ifndef _TCLINT @@ -1852,10 +1852,14 @@ MODULE_SCOPE void TclAppendObjToErrorInfo _ANSI_ARGS_(( Tcl_Interp *interp, Tcl_Obj *objPtr)); MODULE_SCOPE int TclArraySet _ANSI_ARGS_((Tcl_Interp *interp, Tcl_Obj *arrayNameObj, Tcl_Obj *arrayElemObj)); +MODULE_SCOPE double TclBignumToDouble _ANSI_ARGS_((mp_int* bignum)); MODULE_SCOPE int TclCheckBadOctal _ANSI_ARGS_((Tcl_Interp *interp, CONST char *value)); MODULE_SCOPE void TclCleanupLiteralTable _ANSI_ARGS_(( Tcl_Interp* interp, LiteralTable* tablePtr)); +MODULE_SCOPE int TclDoubleDigits _ANSI_ARGS_((char* buf, + double value, + int* signum)); MODULE_SCOPE void TclExpandTokenArray _ANSI_ARGS_(( Tcl_Parse *parsePtr)); MODULE_SCOPE int TclFileAttrsCmd _ANSI_ARGS_((Tcl_Interp *interp, @@ -1871,6 +1875,7 @@ MODULE_SCOPE int TclFileRenameCmd _ANSI_ARGS_((Tcl_Interp *interp, MODULE_SCOPE void TclFinalizeAllocSubsystem _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeCompExecEnv _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeCompilation _ANSI_ARGS_((void)); +MODULE_SCOPE void TclFinalizeDoubleConversion _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeEncodingSubsystem _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeEnvironment _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeExecution _ANSI_ARGS_((void)); @@ -1884,6 +1889,7 @@ MODULE_SCOPE void TclFinalizeAsync _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeSynchronization _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeLock _ANSI_ARGS_((void)); MODULE_SCOPE void TclFinalizeThreadData _ANSI_ARGS_((void)); +MODULE_SCOPE void TclFormatNaN _ANSI_ARGS_((double value, char* buffer)); MODULE_SCOPE int TclFSFileAttrIndex _ANSI_ARGS_((Tcl_Obj *pathPtr, CONST char *attributeName, int *indexPtr)); MODULE_SCOPE Tcl_Obj * TclGetBgErrorHandler _ANSI_ARGS_((Tcl_Interp *interp)); @@ -1902,6 +1908,7 @@ MODULE_SCOPE int TclGlob _ANSI_ARGS_((Tcl_Interp *interp, int globFlags, Tcl_GlobTypeData* types)); MODULE_SCOPE void TclInitAlloc _ANSI_ARGS_((void)); MODULE_SCOPE void TclInitDbCkalloc _ANSI_ARGS_((void)); +MODULE_SCOPE void TclInitDoubleConversion _ANSI_ARGS_((void)); MODULE_SCOPE void TclInitEmbeddedConfigurationInformation _ANSI_ARGS_((Tcl_Interp *interp)); MODULE_SCOPE void TclInitEncodingSubsystem _ANSI_ARGS_((void)); @@ -2048,6 +2055,8 @@ MODULE_SCOPE void TclSetProcessGlobalValue _ANSI_ARGS_ (( Tcl_Encoding encoding)); MODULE_SCOPE VOID TclSignalExitThread _ANSI_ARGS_((Tcl_ThreadId id, int result)); +MODULE_SCOPE double TclStrToD _ANSI_ARGS_((CONST char* string, + CONST char** endPtr)); MODULE_SCOPE int TclSubstTokens _ANSI_ARGS_((Tcl_Interp *interp, Tcl_Token *tokenPtr, int count, int *tokensLeftPtr)); @@ -2717,6 +2726,20 @@ MODULE_SCOPE void TclDbInitNewObj _ANSI_ARGS_((Tcl_Obj *objPtr)); } /* + *---------------------------------------------------------------------- + * + * Core procedures added to libtommath for bignum manipulation. + * + *---------------------------------------------------------------------- + */ + +MODULE_SCOPE void* TclBNAlloc( size_t nBytes ); +MODULE_SCOPE void* TclBNRealloc( void* oldBlock, size_t newNBytes ); +MODULE_SCOPE void TclBNFree( void* block ); +MODULE_SCOPE void TclBNInitBignumFromLong( mp_int* bignum, long initVal ); + + +/* *---------------------------------------------------------------- * Macro used by the Tcl core to check whether a pattern has * any characters special to [string match]. diff --git a/generic/tclIntDecls.h b/generic/tclIntDecls.h index 6972a28..7364d0f 100644 --- a/generic/tclIntDecls.h +++ b/generic/tclIntDecls.h @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclIntDecls.h,v 1.78 2005/05/05 18:38:02 dgp Exp $ + * RCS: @(#) $Id: tclIntDecls.h,v 1.79 2005/05/10 18:34:42 kennykb Exp $ */ #ifndef _TCLINTDECLS @@ -1128,6 +1128,34 @@ EXTERN int TclPushStackFrame _ANSI_ARGS_((Tcl_Interp * interp, /* 218 */ EXTERN void TclPopStackFrame _ANSI_ARGS_((Tcl_Interp * interp)); #endif +#ifndef TclBN_mp_div_d_TCL_DECLARED +#define TclBN_mp_div_d_TCL_DECLARED +/* 219 */ +EXTERN int TclBN_mp_div_d _ANSI_ARGS_((mp_int * a, mp_digit b, + mp_int * c, mp_digit * d)); +#endif +#ifndef TclBN_mp_mul_d_TCL_DECLARED +#define TclBN_mp_mul_d_TCL_DECLARED +/* 220 */ +EXTERN int TclBN_mp_mul_d _ANSI_ARGS_((mp_int * a, mp_digit b, + mp_int * c)); +#endif +#ifndef TclBN_mp_clear_TCL_DECLARED +#define TclBN_mp_clear_TCL_DECLARED +/* 221 */ +EXTERN void TclBN_mp_clear _ANSI_ARGS_((mp_int * a)); +#endif +#ifndef TclBN_mp_init_TCL_DECLARED +#define TclBN_mp_init_TCL_DECLARED +/* 222 */ +EXTERN int TclBN_mp_init _ANSI_ARGS_((mp_int * a)); +#endif +#ifndef TclBN_mp_read_radix_TCL_DECLARED +#define TclBN_mp_read_radix_TCL_DECLARED +/* 223 */ +EXTERN int TclBN_mp_read_radix _ANSI_ARGS_((mp_int * a, + const char * str, int radix)); +#endif typedef struct TclIntStubs { int magic; @@ -1367,6 +1395,11 @@ typedef struct TclIntStubs { void (*tclStackFree) _ANSI_ARGS_((Tcl_Interp * interp)); /* 216 */ int (*tclPushStackFrame) _ANSI_ARGS_((Tcl_Interp * interp, Tcl_CallFrame ** framePtrPtr, Tcl_Namespace * namespacePtr, int isProcCallFrame)); /* 217 */ void (*tclPopStackFrame) _ANSI_ARGS_((Tcl_Interp * interp)); /* 218 */ + int (*tclBN_mp_div_d) _ANSI_ARGS_((mp_int * a, mp_digit b, mp_int * c, mp_digit * d)); /* 219 */ + int (*tclBN_mp_mul_d) _ANSI_ARGS_((mp_int * a, mp_digit b, mp_int * c)); /* 220 */ + void (*tclBN_mp_clear) _ANSI_ARGS_((mp_int * a)); /* 221 */ + int (*tclBN_mp_init) _ANSI_ARGS_((mp_int * a)); /* 222 */ + int (*tclBN_mp_read_radix) _ANSI_ARGS_((mp_int * a, const char * str, int radix)); /* 223 */ } TclIntStubs; #ifdef __cplusplus @@ -2121,6 +2154,26 @@ extern TclIntStubs *tclIntStubsPtr; #define TclPopStackFrame \ (tclIntStubsPtr->tclPopStackFrame) /* 218 */ #endif +#ifndef TclBN_mp_div_d +#define TclBN_mp_div_d \ + (tclIntStubsPtr->tclBN_mp_div_d) /* 219 */ +#endif +#ifndef TclBN_mp_mul_d +#define TclBN_mp_mul_d \ + (tclIntStubsPtr->tclBN_mp_mul_d) /* 220 */ +#endif +#ifndef TclBN_mp_clear +#define TclBN_mp_clear \ + (tclIntStubsPtr->tclBN_mp_clear) /* 221 */ +#endif +#ifndef TclBN_mp_init +#define TclBN_mp_init \ + (tclIntStubsPtr->tclBN_mp_init) /* 222 */ +#endif +#ifndef TclBN_mp_read_radix +#define TclBN_mp_read_radix \ + (tclIntStubsPtr->tclBN_mp_read_radix) /* 223 */ +#endif #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */ diff --git a/generic/tclInterp.c b/generic/tclInterp.c index 74d4006..f6cc8dc 100644 --- a/generic/tclInterp.c +++ b/generic/tclInterp.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclInterp.c,v 1.58 2005/04/19 16:32:56 dgp Exp $ + * RCS: @(#) $Id: tclInterp.c,v 1.59 2005/05/10 18:34:44 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclListObj.c b/generic/tclListObj.c index 47bcccf..aa793f4 100644 --- a/generic/tclListObj.c +++ b/generic/tclListObj.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclListObj.c,v 1.22 2005/04/09 11:09:58 das Exp $ + * RCS: @(#) $Id: tclListObj.c,v 1.23 2005/05/10 18:34:44 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclLiteral.c b/generic/tclLiteral.c index e55814e..962856e 100644 --- a/generic/tclLiteral.c +++ b/generic/tclLiteral.c @@ -13,7 +13,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclLiteral.c,v 1.23 2005/04/25 02:08:33 dgp Exp $ + * RCS: @(#) $Id: tclLiteral.c,v 1.24 2005/05/10 18:34:44 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclNamesp.c b/generic/tclNamesp.c index 5cd013e..27f5603 100644 --- a/generic/tclNamesp.c +++ b/generic/tclNamesp.c @@ -21,7 +21,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclNamesp.c,v 1.73 2005/05/05 18:38:04 dgp Exp $ + * RCS: @(#) $Id: tclNamesp.c,v 1.74 2005/05/10 18:34:45 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclNotify.c b/generic/tclNotify.c index 4a343aa..d025c2c 100644 --- a/generic/tclNotify.c +++ b/generic/tclNotify.c @@ -14,7 +14,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclNotify.c,v 1.17 2005/04/26 00:45:01 das Exp $ + * RCS: @(#) $Id: tclNotify.c,v 1.18 2005/05/10 18:34:46 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclObj.c b/generic/tclObj.c index 1b25e16..5f5cfb2 100644 --- a/generic/tclObj.c +++ b/generic/tclObj.c @@ -7,15 +7,28 @@ * Copyright (c) 1995-1997 Sun Microsystems, Inc. * Copyright (c) 1999 by Scriptics Corporation. * Copyright (c) 2001 by ActiveState Corporation. + * Copyright (c) 2005 by Kevin B. Kenny. All rights reserved. * * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclObj.c,v 1.82 2005/04/25 02:08:34 dgp Exp $ + * RCS: @(#) $Id: tclObj.c,v 1.83 2005/05/10 18:34:46 kennykb Exp $ */ #include "tclInt.h" +#include "tommath.h" #include "tclCompile.h" +#include <float.h> + +/* + * Define test for NaN + */ + +#ifdef _MSC_VER +#define IS_NAN(f) _isnan((f)) +#else +#define IS_NAN(f) ((f) != (f)) +#endif /* * Table of all object types. @@ -136,6 +149,28 @@ Tcl_ThreadDataKey pendingObjDataKey; /* + * Macros to pack/unpack a bignum's fields in a Tcl_Obj internal rep + */ + +#define PACK_BIGNUM( bignum, objPtr ) \ + do { \ + (objPtr)->internalRep.bignumValue.digits = (void*) (bignum).dp; \ + (objPtr)->internalRep.bignumValue.misc = ( \ + ( (bignum).sign << 30 ) \ + | ( (bignum).alloc << 15 ) \ + | ( (bignum).used ) ); \ + } while ( 0 ) + +#define UNPACK_BIGNUM( objPtr, bignum ) \ + do { \ + (bignum).dp = (mp_digit*) (objPtr)->internalRep.bignumValue.digits; \ + (bignum).sign = (objPtr)->internalRep.bignumValue.misc >> 30; \ + (bignum).alloc = ( (objPtr)->internalRep.bignumValue.misc >> 15 ) \ + & 0x7fff; \ + (bignum).used = (objPtr)->internalRep.bignumValue.misc & 0x7fff; \ + } while ( 0 ) + +/* * Prototypes for procedures defined later in this file: */ @@ -157,6 +192,13 @@ static int SetWideIntFromAny _ANSI_ARGS_((Tcl_Interp *interp, static void UpdateStringOfWideInt _ANSI_ARGS_((Tcl_Obj *objPtr)); #endif +static void FreeBignum _ANSI_ARGS_(( Tcl_Obj *objPtr )); +static void DupBignum _ANSI_ARGS_(( Tcl_Obj *objPtr, + Tcl_Obj *copyPtr )); +static void UpdateStringOfBignum _ANSI_ARGS_(( Tcl_Obj *objPtr )); +static int SetBignumFromAny _ANSI_ARGS_(( Tcl_Interp* interp, + Tcl_Obj* objPtr )); + /* * Prototypes for the array hash key methods. */ @@ -226,6 +268,14 @@ Tcl_ObjType tclWideIntType = { SetWideIntFromAny /* setFromAnyProc */ }; +Tcl_ObjType tclBignumType = { + "bignum", /* name */ + FreeBignum, /* freeIntRepProc */ + DupBignum, /* dupIntRepProc */ + UpdateStringOfBignum, /* updateStringProc */ + SetBignumFromAny /* setFromAnyProc */ +}; + /* * The structure below defines the Tcl obj hash key type. */ @@ -331,6 +381,7 @@ TclInitObjSubsystem() Tcl_RegisterObjType(&tclEndOffsetType); Tcl_RegisterObjType(&tclIntType); Tcl_RegisterObjType(&tclWideIntType); + Tcl_RegisterObjType( &tclBignumType ); Tcl_RegisterObjType(&tclStringType); Tcl_RegisterObjType(&tclListType); Tcl_RegisterObjType(&tclDictType); @@ -1670,22 +1721,29 @@ Tcl_GetDoubleFromObj(interp, objPtr, dblPtr) { register int result; - if (objPtr->typePtr == &tclDoubleType) { - *dblPtr = objPtr->internalRep.doubleValue; - return TCL_OK; - } else if (objPtr->typePtr == &tclIntType) { + if (objPtr->typePtr == &tclIntType) { *dblPtr = objPtr->internalRep.longValue; return TCL_OK; } else if (objPtr->typePtr == &tclWideIntType) { *dblPtr = (double) objPtr->internalRep.wideValue; return TCL_OK; + } else if (objPtr->typePtr != &tclDoubleType) { + result = SetDoubleFromAny(interp, objPtr); + if ( result != TCL_OK ) { + return TCL_ERROR; + } } - - result = SetDoubleFromAny(interp, objPtr); - if (result == TCL_OK) { - *dblPtr = objPtr->internalRep.doubleValue; + if ( IS_NAN( objPtr->internalRep.doubleValue ) ) { + if ( interp != NULL ) { + Tcl_SetObjResult + ( interp, + Tcl_NewStringObj( "floating point value is Not a Number", + -1 ) ); + } + return TCL_ERROR; } - return result; + *dblPtr = objPtr->internalRep.doubleValue; + return TCL_OK; } /* @@ -1713,7 +1771,7 @@ SetDoubleFromAny(interp, objPtr) Tcl_Interp *interp; /* Used for error reporting if not NULL. */ register Tcl_Obj *objPtr; /* The object to convert. */ { - char *string, *end; + CONST char *string, *end; double newDouble; int length; @@ -1730,7 +1788,7 @@ SetDoubleFromAny(interp, objPtr) */ errno = 0; - newDouble = strtod(string, &end); + newDouble = TclStrToD(string, &end); if (end == string) { badDouble: if (interp != NULL) { @@ -1755,7 +1813,7 @@ SetDoubleFromAny(interp, objPtr) goto badDouble; } - if (errno != 0) { + if (errno != 0 && errno != ERANGE) { if (interp != NULL) { TclExprFloatError(interp, newDouble); } @@ -2715,6 +2773,390 @@ Tcl_GetWideIntFromObj(interp, objPtr, wideIntPtr) /* *---------------------------------------------------------------------- * + * FreeBignum -- + * + * This procedure frees the internal rep of a bignum. + * + * Results: + * None. + * + *---------------------------------------------------------------------- + */ + +static void +FreeBignum( Tcl_Obj* objPtr ) +{ + mp_int toFree; /* Bignum to free */ + UNPACK_BIGNUM( objPtr, toFree ); + mp_clear( &toFree ); +} + +/* + *---------------------------------------------------------------------- + * + * DupBignum -- + * + * This procedure duplicates the internal rep of a bignum. + * + * Results: + * None. + * + * Side effects: + * The destination object receies a copy of the source object + * + *---------------------------------------------------------------------- + */ + +static void +DupBignum( srcPtr, copyPtr ) + Tcl_Obj* srcPtr; + Tcl_Obj* copyPtr; +{ + mp_int bignumVal; + mp_int bignumCopy; + copyPtr->typePtr = &tclBignumType; + UNPACK_BIGNUM( srcPtr, bignumVal ); + if ( mp_init_copy( &bignumCopy, &bignumVal ) != MP_OKAY ) { + Tcl_Panic( "initialization failure in DupBignum" ); + } + PACK_BIGNUM( bignumVal, copyPtr ); +} + +/* + *---------------------------------------------------------------------- + * + * SetBignumFromAny -- + * + * This procedure interprets a Tcl_Obj as a bignum and sets + * the internal representation accordingly. + * + * Results: + * Returns a standard Tcl status. If conversion fails, an + * error message is left in the interpreter result. + * + * Side effects: + * The bignum internal representation is packed into the object. + * + *---------------------------------------------------------------------- + */ + +static int +SetBignumFromAny( interp, objPtr ) + Tcl_Interp* interp; + Tcl_Obj* objPtr; +{ + CONST char* stringVal; + CONST char* p; + int length; + int signum = MP_ZPOS; + int radix = 10; + int status; + mp_int bignumVal; + + if ( objPtr->typePtr == &tclIntType ) { + + /* + * If the number already contains an integer, simply widen it to + * a bignum. + */ + + TclBNInitBignumFromLong( &bignumVal, objPtr->internalRep.longValue ); + } else { + + /* + * The number doesn't contain an integer. Convert its string rep + * to a bignum, handling 0XXX and 0xXXX notation + */ + + stringVal = Tcl_GetStringFromObj( objPtr, &length ); + p = stringVal; + + /* + * Pull off the signum + */ + + if ( *p == '+' ) { + ++p; + } else if ( *p == '-' ) { + ++p; + signum = MP_NEG; + } + + /* + * Handle octal and hexadecimal + */ + + if ( *p == '0' ) { + ++p; + if ( *p == 'x' || *p == 'X' ) { + ++p; + radix = 16; + } else { + --p; + radix = 8; + } + } + + /* Convert the value */ + + if ( mp_init( &bignumVal ) != MP_OKAY ) { + Tcl_Panic( "initialization failure in SetBignumFromAny" ); + } + status = mp_read_radix( &bignumVal, p, radix ); + switch ( status ) { + case MP_MEM: + Tcl_Panic( "out of memory in SetBignumFromAny" ); + case MP_OKAY: + break; + default: + { + if ( interp != NULL ) { + Tcl_Obj* msg + = Tcl_NewStringObj( "expected integer but got \"", + -1 ); + TclAppendLimitedToObj( msg, stringVal, length, 50, "" ); + Tcl_AppendToObj( msg, "\"", -1 ); + Tcl_SetObjResult( interp, msg ); + TclCheckBadOctal( interp, stringVal ); + } + mp_clear( &bignumVal ); + return TCL_ERROR; + } + } + + /* Conversion to bignum succeeded. Make sure that everything fits. */ + + if ( bignumVal.alloc > 0x7fff ) { + Tcl_Obj* msg + = Tcl_NewStringObj( "integer value too large to represent", -1 ); + Tcl_SetObjResult( interp, msg ); + mp_clear( &bignumVal ); + return TCL_ERROR; + } + } + + /* + * Conversion succeeded. Clean up the old internal rep and + * store the new one. + */ + + TclFreeIntRep( objPtr ); + bignumVal.sign = signum; + PACK_BIGNUM( bignumVal, objPtr ); + objPtr->typePtr = &tclBignumType; + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * UpdateStringOfBignum -- + * + * This procedure updates the string representation of a bignum + * object. + * + * Results: + * None. + * + * Side effects: + * The object's string is set to whatever results from the bignum- + * to-string conversion. + * + * The object's existing string representation is NOT freed; memory + * will leak if the string rep is still valid at the time this procedure + * is called. + */ + +void +UpdateStringOfBignum( Tcl_Obj* objPtr ) +{ + mp_int bignumVal; + int size; + int status; + char* stringVal; + UNPACK_BIGNUM( objPtr, bignumVal ); + status = mp_radix_size( &bignumVal, 10, &size ); + if ( status != MP_OKAY ) { + Tcl_Panic( "radix size failure in UpdateStringOfBignum" ); + } + stringVal = Tcl_Alloc( (size_t) size ); + status = mp_toradix_n( &bignumVal, stringVal, 10, size ); + if ( status != MP_OKAY ) { + Tcl_Panic( "conversion failure in UpdateStringOfBignum" ); + } + objPtr->bytes = stringVal; + objPtr->length = size - 1; /* size includes a trailing null byte */ +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_NewBignumObj -- + * + * Creates an initializes a bignum object. + * + * Results: + * Returns the newly created object. + * + * Side effects: + * The bignum value is cleared, since ownership has transferred + * to Tcl. + * + *---------------------------------------------------------------------- + */ + +#ifdef TCL_MEM_DEBUG +#undef Tcl_NewBignumObj +Tcl_Obj* +Tcl_NewBignumObj( mp_int* bignumValue ) +{ + return Tcl_DbNewBignumObj( bignumValue, "unknown", 0 ); +} +#else +Tcl_Obj * +Tcl_NewBignumObj( mp_int* bignumValue ) +{ + Tcl_Obj* objPtr; + TclNewObj( objPtr ); + PACK_BIGNUM( *bignumValue, objPtr ); + objPtr->typePtr=&tclBignumType; + objPtr->bytes = NULL; + + /* Clear with mp_init; mp_clear would overwrite the digit array. */ + + mp_init( bignumValue ); + + return objPtr; +} +#endif + +/* + *---------------------------------------------------------------------- + * + * Tcl_DbNewBignumObj -- + * + * This procedure is normally called when debugging: that is, when + * TCL_MEM_DEBUG is defined. It constructs a bignum object, recording + * the creation point so that [memory active] can report it. + * + * Results: + * Returns the newly created object. + * + * Side effects: + * The bignum value is cleared, since ownership has transferred + * to Tcl. + * + *---------------------------------------------------------------------- + */ + +#ifdef TCL_MEM_DEBUG +Tcl_Obj* +Tcl_DbNewBignumObj( mp_int* bignumValue, CONST char* file, int line ) +{ + Tcl_Obj* objPtr; + TclDbNewObj( objPtr, file, line ); + objPtr->bytes = NULL; + PACK_BIGNUM( *bignumValue, objPtr ); + objPtr->typePtr=&tclBignumType; + objPtr->bytes = NULL; + + /* Clear with mp_init; mp_clear would overwrite the digit array. */ + + mp_init( bignumValue ); + + return objPtr; +} +#else +Tcl_Obj* +Tcl_DbNewBignumObj( mp_int* bignumValue, CONST char* file, int line ) +{ + return Tcl_NewBignumObj( bignumValue ); +} +#endif + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetBignumFromObj -- + * + * This procedure retrieves a 'bignum' value from a Tcl object, + * converting the object if necessary. + * + * Results: + * Returns TCL_OK if the conversion is successful, TCL_ERROR otherwise. + * + * Side effects: + * A copy of bignum is stored in *bignumValue, which is expected + * to be uninitialized or cleared. If conversion fails, an + * the 'interp' argument is not NULL, an error message is stored + * in the interpreter result. + * + * It is expected that the caller will NOT have invoked mp_init on the + * bignum value before passing it in. The raw value of the object is + * returned, and Tcl owns that memory, so the caller should NOT invoke + * mp_clear afterwards. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetBignumFromObj( Tcl_Interp* interp, + /* Tcl interpreter for error reporting */ + Tcl_Obj* objPtr, + /* Object to read */ + mp_int* bignumValue ) + /* Returned bignum value. */ +{ + mp_int temp; + if ( objPtr -> typePtr != &tclBignumType ) { + if ( SetBignumFromAny( interp, objPtr ) != TCL_OK ) { + return TCL_ERROR; + } + } + UNPACK_BIGNUM( objPtr, temp ); + mp_init_copy( bignumValue, &temp ); + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_SetBignumObj -- + * + * This procedure sets the value of a Tcl_Obj to a large integer. + * + * Results: + * None. + * + * Side effects: + * Object value is stored. The bignum value is cleared, since + * ownership has transferred to Tcl. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_SetBignumObj( Tcl_Obj* objPtr, + /* Object to set */ + mp_int* bignumValue ) + /* Value to store */ +{ + if ( Tcl_IsShared( objPtr ) ) { + Tcl_Panic( "Tcl_SetBignumObj called with shared object" ); + } + TclFreeIntRep( objPtr ); + objPtr->typePtr = &tclBignumType; + PACK_BIGNUM( *bignumValue, objPtr ); + Tcl_InvalidateStringRep( objPtr ); + + /* Clear the value with mp_init; mp_clear overwrites the digit array. */ + + mp_init( bignumValue ); +} + +/* + *---------------------------------------------------------------------- + * * Tcl_DbIncrRefCount -- * * This procedure is normally called when debugging: i.e., when diff --git a/generic/tclParse.c b/generic/tclParse.c index 9700f93..fbf1d65 100644 --- a/generic/tclParse.c +++ b/generic/tclParse.c @@ -13,7 +13,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclParse.c,v 1.41 2005/05/03 18:08:18 dgp Exp $ + * RCS: @(#) $Id: tclParse.c,v 1.42 2005/05/10 18:34:46 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclParseExpr.c b/generic/tclParseExpr.c index 61860f6..c6a478e 100644 --- a/generic/tclParseExpr.c +++ b/generic/tclParseExpr.c @@ -13,7 +13,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclParseExpr.c,v 1.24 2005/05/03 18:08:19 dgp Exp $ + * RCS: @(#) $Id: tclParseExpr.c,v 1.25 2005/05/10 18:34:47 kennykb Exp $ */ #include "tclInt.h" @@ -1451,43 +1451,32 @@ ParsePrimaryExpr(infoPtr) return code; } if (infoPtr->lexeme != OPEN_PAREN) { - /* - * Guess what kind of error we have by trying to tell - * whether we have a function or variable name here. - * Alas, this makes the parser more tightly bound with the - * rest of the interpreter, but that is the only way to - * give a sensible message here. Still, it is not too - * serious as this is only done when generating an error. - */ - Interp *iPtr = (Interp *) infoPtr->parsePtr->interp; - Tcl_DString functionName; - Tcl_HashEntry *hPtr; /* - * Look up the name as a function name. We need a writable - * copy (DString) so we can terminate it with a NULL for - * the benefit of Tcl_FindHashEntry which operates on - * NULL-terminated string keys. + * Either there's a math function without a (, or a + * variable name without a '$'. */ - Tcl_DStringInit(&functionName); - hPtr = Tcl_FindHashEntry(&iPtr->mathFuncTable, - Tcl_DStringAppend(&functionName, tokenPtr->start, - tokenPtr->size)); - Tcl_DStringFree(&functionName); - /* - * Assume that we have an attempted variable reference - * unless we've got a function name, as the set of - * potential function names is typically much smaller. - */ - if (hPtr != NULL) { - LogSyntaxError(infoPtr, - "expected parenthesis enclosing function arguments"); - } else { - LogSyntaxError(infoPtr, - "variable references require preceding $"); - } + Tcl_Obj* errMsg + = Tcl_NewStringObj( "syntax error in expression \"", -1 ); + TclAppendLimitedToObj( errMsg, + infoPtr->originalExpr, + (int) (infoPtr->lastChar + - infoPtr->originalExpr ), + 63, + NULL ); + Tcl_AppendToObj( errMsg, "\": the word \"", -1 ); + Tcl_AppendToObj( errMsg, tokenPtr->start, tokenPtr->size ); + Tcl_AppendToObj( errMsg, + "\" requires a preceding $ if it's a variable ", + -1 ); + Tcl_AppendToObj( errMsg, + "or function arguments if it's a function", -1 ); + Tcl_SetObjResult( infoPtr->parsePtr->interp, errMsg ); + infoPtr->parsePtr->errorType = TCL_PARSE_SYNTAX; + infoPtr->parsePtr->term = infoPtr->start; return TCL_ERROR; + } code = GetLexeme(infoPtr); /* skip over '(' */ if (code != TCL_OK) { @@ -1666,23 +1655,17 @@ GetLexeme(infoPtr) * so we can set an terminating NULL to keep strtod from * scanning too far. */ - char *startPtr, *termPtr; + char *startPtr; + CONST char *termPtr; double doubleValue; Tcl_DString toParse; errno = 0; Tcl_DStringInit(&toParse); startPtr = Tcl_DStringAppend(&toParse, src, length); - doubleValue = strtod(startPtr, &termPtr); + doubleValue = TclStrToD(startPtr, &termPtr); Tcl_DStringFree(&toParse); if (termPtr != startPtr) { - if (errno != 0) { - if (interp != NULL) { - TclExprFloatError(interp, doubleValue); - } - parsePtr->errorType = TCL_PARSE_BAD_NUMBER; - return TCL_ERROR; - } /* * startPtr was the start of a valid double, copied @@ -2077,7 +2060,7 @@ ParseMaxDoubleLength(string, end) case 'C': case 'D': case 'E': case 'F': case 'I': case 'N': case 'P': case 'X': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'i': case 'n': case 'p': case 'x': - case '.': case '+': case '-': + case '.': case '+': case '-': case '(': case ' ': case ')': p++; break; default: diff --git a/generic/tclPathObj.c b/generic/tclPathObj.c index 5a57477..08491cc 100644 --- a/generic/tclPathObj.c +++ b/generic/tclPathObj.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclPathObj.c,v 1.40 2005/02/05 09:15:42 davidw Exp $ + * RCS: @(#) $Id: tclPathObj.c,v 1.41 2005/05/10 18:34:47 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclPort.h b/generic/tclPort.h index 730ab76..ad98823 100644 --- a/generic/tclPort.h +++ b/generic/tclPort.h @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclPort.h,v 1.14 2005/01/05 10:31:02 dkf Exp $ + * RCS: @(#) $Id: tclPort.h,v 1.15 2005/05/10 18:34:47 kennykb Exp $ */ #ifndef _TCLPORT diff --git a/generic/tclProc.c b/generic/tclProc.c index 4d9e7e0..a87caa7 100644 --- a/generic/tclProc.c +++ b/generic/tclProc.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclProc.c,v 1.73 2005/02/02 23:09:06 mdejong Exp $ + * RCS: @(#) $Id: tclProc.c,v 1.74 2005/05/10 18:34:47 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclRegexp.c b/generic/tclRegexp.c index 25c30dc..dfc7236 100644 --- a/generic/tclRegexp.c +++ b/generic/tclRegexp.c @@ -10,7 +10,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclRegexp.c,v 1.18 2005/05/03 18:08:19 dgp Exp $ + * RCS: @(#) $Id: tclRegexp.c,v 1.19 2005/05/10 18:34:48 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclResult.c b/generic/tclResult.c index bf00083..770d7cb 100644 --- a/generic/tclResult.c +++ b/generic/tclResult.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclResult.c,v 1.24 2005/05/03 18:08:20 dgp Exp $ + * RCS: @(#) $Id: tclResult.c,v 1.25 2005/05/10 18:34:48 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclScan.c b/generic/tclScan.c index 624910c..2e4bf18 100644 --- a/generic/tclScan.c +++ b/generic/tclScan.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclScan.c,v 1.16 2004/10/06 15:59:25 dgp Exp $ + * RCS: @(#) $Id: tclScan.c,v 1.17 2005/05/10 18:34:49 kennykb Exp $ */ #include "tclInt.h" @@ -1144,7 +1144,7 @@ Tcl_ScanObjCmd(dummy, interp, objc, objv) if (!(flags & SCAN_SUPPRESS)) { double dvalue; *end = '\0'; - dvalue = strtod(buf, NULL); + dvalue = TclStrToD(buf, NULL); objPtr = Tcl_NewDoubleObj(dvalue); Tcl_IncrRefCount(objPtr); objs[objIndex++] = objPtr; diff --git a/generic/tclStrToD.c b/generic/tclStrToD.c new file mode 100755 index 0000000..2d622a7 --- /dev/null +++ b/generic/tclStrToD.c @@ -0,0 +1,1361 @@ +/* + *---------------------------------------------------------------------- + * + * tclStrToD.c -- + * + * This file contains a TclStrToD procedure that handles conversion + * of string to double, with correct rounding even where extended + * precision is needed to achieve that. It also contains a + * TclDoubleDigits procedure that handles conversion of double + * to string (at least the significand), and several utility functions + * for interconverting 'double' and the integer types. + * + * Copyright (c) 2005 by Kevin B. Kenny. All rights reserved. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * RCS: @(#) $Id: tclStrToD.c,v 1.2 2005/05/10 18:34:49 kennykb Exp $ + * + *---------------------------------------------------------------------- + */ + +#include <tclInt.h> +#include <stdio.h> +#include <stdlib.h> +#include <float.h> +#include <limits.h> +#include <math.h> +#include <ctype.h> +#include <tommath.h> + +/* + * The stuff below is a bit of a hack so that this file can be used in + * environments that include no UNIX, i.e. no errno: just arrange to use + * the errno from tclExecute.c here. + */ + +#ifdef TCL_GENERIC_ONLY +#define NO_ERRNO_H +#endif + +#ifdef NO_ERRNO_H +extern int errno; /* Use errno from tclExecute.c. */ +#define ERANGE 34 +#endif + +#if ( FLT_RADIX == 2 ) && ( DBL_MANT_DIG == 53 ) && ( DBL_MAX_EXP == 1024 ) +#define IEEE_FLOATING_POINT +#endif + +/* + * gcc on x86 needs access to rounding controls. It is tempting to + * include fpu_control.h, but that file exists only on Linux; it is + * missing on Cygwin and MinGW. + */ + +#if defined(__GNUC__) && defined(__i386) +typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__))); +#define _FPU_GETCW(cw) __asm__ ("fnstcw %0" : "=m" (*&cw)) +#define _FPU_SETCW(cw) __asm__ ("fldcw %0" : : "m" (*&cw)) +#endif + +/* The powers of ten that can be represented exactly as IEEE754 doubles. */ + +#define MAXPOW 22 +static double pow10 [MAXPOW+1]; + +static int mmaxpow; /* Largest power of ten that can be + * represented exactly in a 'double'. */ + +/* Inexact higher powers of ten */ + +static CONST double pow_10_2_n [] = { + 1.0, + 100.0, + 10000.0, + 1.0e+8, + 1.0e+16, + 1.0e+32, + 1.0e+64, + 1.0e+128, + 1.0e+256 +}; + +/* Logarithm of the floating point radix. */ + +static int log2FLT_RADIX; + +/* Number of bits in a double's significand */ + +static int mantBits; + +/* Table of powers of 5**(2**n), up to 5**256 */ + +static mp_int pow5[9]; + +/* The smallest representable double */ + +static double tiny; + +/* The maximum number of digits to the left of the decimal point of a + * double. */ + +static int maxDigits; + +/* The maximum number of digits to the right of the decimal point in a + * double. */ + +static int minDigits; + +/* Number of mp_digit's needed to hold the significand of a double */ + +static int mantDIGIT; + +/* Static functions defined in this file */ + +static double RefineResult _ANSI_ARGS_((double approx, CONST char* start, + int nDigits, long exponent)); +static double ParseNaN _ANSI_ARGS_(( int signum, CONST char** end )); +static double SafeLdExp _ANSI_ARGS_(( double fraction, int exponent )); + +/* + *---------------------------------------------------------------------- + * + * TclStrToD -- + * + * Scans a double from a string. + * + * Results: + * Returns the scanned number. In the case of underflow, returns + * an appropriately signed zero; in the case of overflow, returns + * an appropriately signed HUGE_VAL. + * + * Side effects: + * Stores a pointer to the end of the scanned number in '*endPtr', + * if endPtr is not NULL. If '*endPtr' is equal to 's' on return from + * this function, it indicates that the input string could not be + * recognized as a number. + * In the case of underflow or overflow, 'errno' is set to ERANGE. + * + *------------------------------------------------------------------------ + */ + +double +TclStrToD( CONST char* s, + /* String to scan */ + CONST char ** endPtr ) + /* Pointer to the end of the scanned number */ +{ + + CONST char* p = s; + CONST char* startOfSignificand = NULL; + /* Start of the significand in the + * string */ + int signum = 0; /* Sign of the significand */ + double exactSignificand = 0.0; + /* Significand, represented exactly + * as a floating-point number */ + int seenDigit = 0; /* Flag == 1 if a digit has been seen */ + int nSigDigs = 0; /* Number of significant digits presented */ + int nDigitsAfterDp = 0; /* Number of digits after the decimal point */ + int nTrailZero = 0; /* Number of trailing zeros in the + * significand */ + long exponent = 0; /* Exponent */ + int seenDp = 0; /* Flag == 1 if decimal point has been seen */ + + char c; /* One character extracted from the input */ + + /* + * v must be 'volatile double' on gc-ix86 to force correct rounding + * to IEEE double and not Intel double-extended. + */ + + volatile double v; /* Scanned value */ + int machexp; /* Exponent of the machine rep of the + * scanned value */ + int expt2; /* Exponent for computing first + * approximation to the true value */ + int i, j; + + /* + * With gcc on x86, the floating point rounding mode is double-extended. + * This causes the result of double-precision calculations to be rounded + * twice: once to the precision of double-extended and then again to the + * precision of double. Double-rounding introduces gratuitous errors of + * 1 ulp, so we need to change rounding mode to 53-bits. + */ + +#if defined(__GNUC__) && defined(__i386) + fpu_control_t roundTo53Bits = 0x027f; + fpu_control_t oldRoundingMode; + _FPU_GETCW( oldRoundingMode ); + _FPU_SETCW( roundTo53Bits ); +#endif + + /* Discard leading whitespace */ + + while ( isspace( *p ) ) { + ++p; + } + + /* Determine the sign of the significand */ + + switch( *p ) { + case '-': + signum = 1; + /* FALLTHROUGH */ + case '+': + ++p; + } + + /* Discard leading zeroes */ + + while ( *p == '0' ) { + seenDigit = 1; + ++p; + } + + /* + * Scan digits from the significand. Simultaneously, keep track + * of the number of digits after the decimal point. Maintain + * a pointer to the start of the significand. Keep "exactSignificand" + * equal to the conversion of the DBL_DIG most significant digits. + */ + + for ( ; ; ) { + c = *p; + if ( c == '.' && !seenDp ) { + seenDp = 1; + ++p; + } else if ( isdigit(c) ) { + if ( c == '0' ) { + if ( startOfSignificand != NULL ) { + ++nTrailZero; + } + } else { + if ( startOfSignificand == NULL ) { + startOfSignificand = p; + } else if ( nTrailZero ) { + if ( nTrailZero + nSigDigs < DBL_DIG ) { + exactSignificand *= pow10[ nTrailZero ]; + } else if ( nSigDigs < DBL_DIG ) { + exactSignificand *= pow10[ DBL_DIG - nSigDigs ]; + } + nSigDigs += nTrailZero; + } + if ( nSigDigs < DBL_DIG ) { + exactSignificand = 10. * exactSignificand + (c - '0'); + } + ++nSigDigs; + nTrailZero = 0; + } + if ( seenDp ) { + ++nDigitsAfterDp; + } + seenDigit = 1; + ++p; + } else { + break; + } + } + + /* + * At this point, we've scanned the significand, and p points + * to the character beyond it. "startOfSignificand" is the first + * non-zero character in the significand. "nSigDigs" is the number + * of significant digits of the significand, not including any + * trailing zeroes. "exactSignificand" is a floating point number + * that represents, without loss of precision, the first + * min(DBL_DIG,n) digits of the significand. "nDigitsAfterDp" + * is the number of digits after the decimal point, again excluding + * trailing zeroes. + * + * Now scan 'E' format + */ + + exponent = 0; + if ( seenDigit && ( *p == 'e' || *p == 'E' ) ) { + CONST char* stringSave = p; + ++p; + c = *p; + if ( isdigit( c ) || c == '+' || c == '-' ) { + errno = 0; + exponent = strtol( p, (char**)&p, 10 ); + if ( errno == ERANGE ) { + if ( exponent > 0 ) { + v = HUGE_VAL; + } else { + v = 0.0; + } + *endPtr = p; + goto returnValue; + } + } + if ( p == stringSave + 1 ) { + p = stringSave; + exponent = 0; + } + } + exponent = exponent + nTrailZero - nDigitsAfterDp; + + /* + * If we come here with no significant digits, we might still be + * looking at Inf or NaN. Go parse them. + */ + + if ( !seenDigit ) { + + /* Test for Inf */ + + if ( c == 'I' || c == 'i' ) { + + if ( ( p[1] == 'N' || p[1] == 'n' ) + && ( p[2] == 'F' || p[2] == 'f' ) ) { + p += 3; + if ( ( p[0] == 'I' || p[0] == 'i' ) + && ( p[1] == 'N' || p[1] == 'n' ) + && ( p[2] == 'I' || p[2] == 'i' ) + && ( p[3] == 'T' || p[3] == 't' ) + && ( p[4] == 'Y' || p[1] == 'y' ) ) { + p += 5; + } + errno = ERANGE; + v = HUGE_VAL; + if ( endPtr != NULL ) { + *endPtr = p; + } + goto returnValue; + } + + +#ifdef IEEE_FLOATING_POINT + + /* IEEE floating point supports NaN */ + + } else if ( (c == 'N' || c == 'n' ) + && ( sizeof(Tcl_WideUInt) == sizeof( double ) ) ) { + + if ( ( p[1] == 'A' || p[1] == 'a' ) + && ( p[2] == 'N' || p[2] == 'n' ) ) { + p += 3; + + if ( endPtr != NULL ) { + *endPtr = p; + } + + /* Restore FPU mode word */ + +#if defined(__GNUC__) && defined(__i386) + _FPU_SETCW( oldRoundingMode ); +#endif + return ParseNaN( signum, endPtr ); + + } +#endif + + } + + goto error; + } + + /* + * We've successfully scanned; update the end-of-element pointer. + */ + + if ( endPtr != NULL ) { + *endPtr = p; + } + + /* Test for zero. */ + + if ( nSigDigs == 0 ) { + v = 0.0; + goto returnValue; + } + + /* + * The easy cases are where we have an exact significand and + * the exponent is small enough that we can compute the value + * with only one roundoff. In addition to the cases where we + * can multiply or divide an exact-integer significand by an + * exact-integer power of 10, there is also David Gay's case + * where we can scale the significand by a power of 10 (still + * keeping it exact) and then multiply by an exact power of 10. + * The last case enables combinations like 83e25 that would + * otherwise require high precision arithmetic. + */ + + if ( nSigDigs <= DBL_DIG ) { + if ( exponent >= 0 ) { + if ( exponent <= mmaxpow ) { + v = exactSignificand * pow10[ exponent ]; + goto returnValue; + } else { + int diff = DBL_DIG - nSigDigs; + if ( exponent - diff <= mmaxpow ) { + volatile double factor = exactSignificand * pow10[ diff ]; + v = factor * pow10[ exponent - diff ]; + goto returnValue; + } + } + } else { + if ( exponent >= -mmaxpow ) { + v = exactSignificand / pow10[ -exponent ]; + goto returnValue; + } + } + } + + /* + * We don't have one of the easy cases, so we can't compute the + * scanned number exactly, and have to do it in multiple precision. + * Begin by testing for obvious overflows and underflows. + */ + + if ( nSigDigs + exponent - 1 > maxDigits ) { + v = HUGE_VAL; + errno = ERANGE; + goto returnValue; + } + if ( nSigDigs + exponent - 1 < minDigits ) { + errno = ERANGE; + v = 0.; + goto returnValue; + } + + /* + * Nothing exceeds the boundaries of the tables, at least. + * Compute an approximate value for the number, with + * no possibility of overflow because we manage the exponent + * separately. + */ + + if ( nSigDigs > DBL_DIG ) { + expt2 = exponent + nSigDigs - DBL_DIG; + } else { + expt2 = exponent; + } + v = frexp( exactSignificand, &machexp ); + if ( expt2 > 0 ) { + v = frexp( v * pow10[ expt2 & 0xf ], &j ); + machexp += j; + for ( i = 4; i < 9; ++i ) { + if ( expt2 & ( 1 << i ) ) { + v = frexp( v * pow_10_2_n[ i ], &j ); + machexp += j; + } + } + } else { + v = frexp( v / pow10[ (-expt2) & 0xf ], &j ); + machexp += j; + for ( i = 4; i < 9; ++i ) { + if ( (-expt2) & ( 1 << i ) ) { + v = frexp( v / pow_10_2_n[ i ], &j ); + machexp += j; + } + } + } + + /* + * A first approximation is that the result will be v * 2 ** machexp. + * v is greater than or equal to 0.5 and less than 1. + * If machexp > DBL_MAX_EXP * log2(FLT_RADIX), there is an overflow. + * Constrain the result to the smallest representible number to avoid + * premature underflow. + */ + + if ( machexp > DBL_MAX_EXP * log2FLT_RADIX ) { + v = HUGE_VAL; + errno = ERANGE; + goto returnValue; + } + + v = SafeLdExp( v, machexp ); + if ( v < tiny ) { + v = tiny; + } + + /* We have a first approximation in v. Now we need to refine it. */ + + v = RefineResult( v, startOfSignificand, nSigDigs, exponent ); + + /* In a very few cases, a second iteration is needed. e.g., 457e-102 */ + + v = RefineResult( v, startOfSignificand, nSigDigs, exponent ); + + /* Handle underflow */ + + returnValue: + if ( nSigDigs != 0 && v == 0.0 ) { + errno = ERANGE; + } + + /* Return a number with correct sign */ + + if ( signum ) { + v = -v; + } + + /* Restore FPU mode word */ + +#if defined(__GNUC__) && defined(__i386) + _FPU_SETCW( oldRoundingMode ); +#endif + + return v; + + /* Come here on an invalid input */ + + error: + if ( endPtr != NULL ) { + *endPtr = s; + } + + /* Restore FPU mode word */ + +#if defined(__GNUC__) && defined(__i386) + _FPU_SETCW( oldRoundingMode ); +#endif + return 0.0; + +} + +/* + *---------------------------------------------------------------------- + * + * RefineResult -- + * + * Given a poor approximation to a floating point number, returns + * a better one (The better approximation is correct to within + * 1 ulp, and is entirely correct if the poor approximation is + * correct to 1 ulp.) + * + * Results: + * Returns the improved result. + * + *---------------------------------------------------------------------- + */ + +static double +RefineResult( double approxResult, + /* Approximate result of conversion */ + CONST char* sigStart, + /* Pointer to start of significand in + * input string. */ + int nSigDigs, /* Number of significant digits */ + long exponent ) /* Power of ten to multiply by significand */ +{ + + int M2, M5; /* Powers of 2 and of 5 needed to put + * the decimal and binary numbers over + * a common denominator. */ + double significand; /* Sigificand of the binary number */ + int binExponent; /* Exponent of the binary number */ + + int msb; /* Most significant bit position of an + * intermediate result */ + int nDigits; /* Number of mp_digit's in an intermediate + * result */ + mp_int twoMv; /* Approx binary value expressed as an + * exact integer scaled by the multiplier 2M */ + mp_int twoMd; /* Exact decimal value expressed as an + * exact integer scaled by the multiplier 2M */ + int scale; /* Scale factor for M */ + int multiplier; /* Power of two to scale M */ + double num, den; /* Numerator and denominator of the + * correction term */ + double quot; /* Correction term */ + double minincr; /* Lower bound on the absolute value + * of the correction term. */ + int i; + CONST char* p; + + /* + * The first approximation is always low. If we find that + * it's HUGE_VAL, we're done. + */ + + if ( approxResult == HUGE_VAL ) { + return approxResult; + } + + /* + * Find a common denominator for the decimal and binary fractions. + * The common denominator will be 2**M2 + 5**M5. + */ + + significand = frexp( approxResult, &binExponent ); + i = mantBits - binExponent; + if ( i < 0 ) { + M2 = 0; + } else { + M2 = i; + } + if ( exponent > 0 ) { + M5 = 0; + } else { + M5 = -exponent; + if ( (M5-1) > M2 ) { + M2 = M5-1; + } + } + + /* + * The floating point number is significand*2**binExponent. + * The 2**-1 bit of the significand (the most significant) + * corresponds to the 2**(binExponent+M2 + 1) bit of 2*M2*v. + * Allocate enough digits to hold that quantity, then + * convert the significand to a large integer, scaled + * appropriately. Then multiply by the appropriate power of 5. + */ + + msb = binExponent + M2; /* 1008 */ + nDigits = msb / DIGIT_BIT + 1; + mp_init_size( &twoMv, nDigits ); + i = ( msb % DIGIT_BIT + 1 ); + twoMv.used = nDigits; + significand *= SafeLdExp( 1.0, i ); + while ( -- nDigits >= 0 ) { + twoMv.dp[nDigits] = (mp_digit) significand; + significand -= (mp_digit) significand; + significand = SafeLdExp( significand, DIGIT_BIT ); + } + for ( i = 0; i <= 8; ++i ) { + if ( M5 & ( 1 << i ) ) { + mp_mul( &twoMv, pow5+i, &twoMv ); + } + } + + /* + * Collect the decimal significand as a high precision integer. + * The least significant bit corresponds to bit M2+exponent+1 + * so it will need to be shifted left by that many bits after + * being multiplied by 5**(M5+exponent). + */ + + mp_init( &twoMd ); mp_zero( &twoMd ); + i = nSigDigs; + for ( p = sigStart ; ; ++p ) { + char c = *p; + if ( isdigit( c ) ) { + mp_mul_d( &twoMd, (unsigned) 10, &twoMd ); + mp_add_d( &twoMd, (unsigned) (c - '0'), &twoMd ); + --i; + if ( i == 0 ) break; + } + } + for ( i = 0; i <= 8; ++i ) { + if ( (M5+exponent) & ( 1 << i ) ) { + mp_mul( &twoMd, pow5+i, &twoMd ); + } + } + mp_mul_2d( &twoMd, M2+exponent+1, &twoMd ); + mp_sub( &twoMd, &twoMv, &twoMd ); + + /* + * The result, 2Mv-2Md, needs to be divided by 2M to yield a correction + * term. Because 2M may well overflow a double, we need to scale the + * denominator by a factor of 2**binExponent-mantBits + */ + + scale = binExponent - mantBits - 1; + + mp_set( &twoMv, 1 ); + for ( i = 0; i <= 8; ++i ) { + if ( M5 & ( 1 << i ) ) { + mp_mul( &twoMv, pow5+i, &twoMv ); + } + } + multiplier = M2 + scale + 1; + if ( multiplier > 0 ) { + mp_mul_2d( &twoMv, multiplier, &twoMv ); + } else if ( multiplier < 0 ) { + mp_div_2d( &twoMv, -multiplier, &twoMv, NULL ); + } + + /* + * If the result is less than unity, the error is less than 1/2 unit + * in the last place, so there's no correction to make. + */ + + if ( mp_cmp_mag( &twoMd, &twoMv ) == MP_LT ) { + return approxResult; + } + + /* + * Convert the numerator and denominator of the corrector term + * accurately to floating point numbers. + */ + + num = TclBignumToDouble( &twoMd ); + den = TclBignumToDouble( &twoMv ); + + quot = SafeLdExp( num/den, scale ); + minincr = SafeLdExp( 1.0, binExponent - mantBits ); + + if ( quot < 0. && quot > -minincr ) { + quot = -minincr; + } else if ( quot > 0. && quot < minincr ) { + quot = minincr; + } + + mp_clear( &twoMd ); + mp_clear( &twoMv ); + + + return approxResult + quot; +} + +/* + *---------------------------------------------------------------------- + * + * ParseNaN -- + * + * Parses a "not a number" from an input string, and returns the + * double precision NaN corresponding to it. + * + * Side effects: + * Advances endPtr to follow any (hex) in the input string. + * + * If the NaN is followed by a left paren, a string of spaes + * and hexadecimal digits, and a right paren, endPtr is advanced + * to follow it. + * + * The string of hexadecimal digits is OR'ed into the resulting + * NaN, and the signum is set as well. Note that a signalling NaN + * is never returned. + * + *---------------------------------------------------------------------- + */ + +double +ParseNaN( int signum, /* Flag == 1 if minus sign has been + * seen in front of NaN */ + CONST char** endPtr ) + /* Pointer-to-pointer to char following "NaN" + * in the input string */ +{ + CONST char* p = *endPtr; + char c; + union { + Tcl_WideUInt iv; + double dv; + } theNaN; + + /* Scan off a hex number in parentheses. Embedded blanks are ok. */ + + theNaN.iv = 0; + if ( *p == '(' ) { + ++p; + for ( ; ; ) { + c = *p++; + if ( isspace(c) ) { + continue; + } else if ( c == ')' ) { + *endPtr = p; + break; + } else if ( isdigit(c) ) { + c -= '0'; + } else if ( c >= 'A' && c <= 'F' ) { + c = c - 'A' + 10; + } else if ( c >= 'a' && c <= 'f' ) { + c = c - 'a' + 10; + } else { + theNaN.iv = ( ((Tcl_WideUInt) 0x7ff8) << 48 ) + | ( ((Tcl_WideUInt) signum) << 63 ); + return theNaN.dv; + } + theNaN.iv = (theNaN.iv << 4) | c; + } + } + + /* + * Mask the hex number down to the least significant 51 bits. + */ + + theNaN.iv &= ( ((Tcl_WideUInt) 1) << 51 ) - 1; + if ( signum ) { + theNaN.iv |= ((Tcl_WideUInt) 0xfff8) << 48; + } else { + theNaN.iv |= ((Tcl_WideUInt) 0x7ff8) << 48; + } + + *endPtr = p; + return theNaN.dv; +} + +/* + *---------------------------------------------------------------------- + * + * TclDoubleDigits -- + * + * Converts a double to a string of digits. + * + * Results: + * Returns the position of the character in the string + * after which the decimal point should appear. Since + * the string contains only significant digits, the + * position may be less than zero or greater than the + * length of the string. + * + * Side effects: + * Stores the digits in the given buffer and sets 'signum' + * according to the sign of the number. + * + *---------------------------------------------------------------------- + */ + +int +TclDoubleDigits( char * strPtr, /* Buffer in which to store the result, + * must have at least 18 chars */ + double v, /* Number to convert. Must be + * finite, and not NaN */ + int *signum ) /* Output: 1 if the number is negative. + * Should handle -0 correctly on the + * IEEE architecture. */ +{ + + double f; /* Significand of v */ + + int e; /* Power of FLT_RADIX that satisfies + * v = f * FLT_RADIX**e */ + + + int low_ok; + int high_ok; + + mp_int r; /* Scaled significand */ + mp_int s; /* Divisor such that v = r / s */ + mp_int mplus; /* Scaled epsilon: (r + 2* mplus) == + * v(+) where v(+) is the floating point + * successor of v. */ + mp_int mminus; /* Scaled epsilon: (r - 2*mminus ) == + * v(-) where v(-) is the floating point + * predecessor of v. */ + mp_int temp; + + int rfac2 = 0; /* Powers of 2 and 5 by which large */ + int rfac5 = 0; /* integers should be scaled */ + int sfac2 = 0; + int sfac5 = 0; + int mplusfac2 = 0; + int mminusfac2 = 0; + + double a; + char c; + int i, k, n; + + /* + * Take the absolute value of the number, and report the number's + * sign. Take special steps to preserve signed zeroes in IEEE floating + * point. (We can't use fpclassify, because that's a C9x feature and + * we still have to build on C89 compilers.) + */ + +#ifndef IEEE_FLOATING_POINT + if ( v >= 0.0 ) { + *signum = 0; + } else { + *signum = 1; + v = -v; + } +#else + union { + Tcl_WideUInt iv; + double dv; + } bitwhack; + bitwhack.dv = v; + if ( bitwhack.iv & ( (Tcl_WideUInt) 1 << 63 ) ) { + *signum = 1; + bitwhack.iv &= ~( (Tcl_WideUInt) 1 << 63 ); + v = bitwhack.dv; + } else { + *signum = 0; + } +#endif + + /* Handle zero specially */ + + if ( v == 0.0 ) { + *strPtr++ = '0'; + *strPtr++ = '\0'; + return 1; + } + + /* + * Develop f and e such that v = f * FLT_RADIX**e, with + * 1.0/FLT_RADIX <= f < 1. + */ + + f = frexp( v, &e ); + n = e % log2FLT_RADIX; + if ( n > 0 ) { + n -= log2FLT_RADIX; + e += 1; + } + f *= ldexp( 1.0, n ); + e = ( e - n ) / log2FLT_RADIX; + if ( f == 1.0 ) { + f = 1.0 / FLT_RADIX; + e += 1; + } + + /* + * If the original number was denormalized, adjust e and f to be + * denormal as well. + */ + + if ( e < DBL_MIN_EXP ) { + n = mantBits + ( e - DBL_MIN_EXP ) * log2FLT_RADIX; + f = ldexp( f, ( e - DBL_MIN_EXP ) * log2FLT_RADIX ); + e = DBL_MIN_EXP; + n = ( n + DIGIT_BIT - 1 ) / DIGIT_BIT; + } else { + n = mantDIGIT; + } + + /* + * Now extract the base-2**DIGIT_BIT digits of f into a multi-precision + * integer r. Preserve the invariant v = r * 2**rfac2 * FLT_RADIX**e + * by adjusting e. + */ + + a = f; + n = mantDIGIT; + mp_init_size( &r, n ); + r.used = n; + r.sign = MP_ZPOS; + i = ( mantBits % DIGIT_BIT ); + if ( i == 0 ) { + i = DIGIT_BIT; + } + while ( n > 0 ) { + a *= ldexp( 1.0, i ); + i = DIGIT_BIT; + r.dp[--n] = (mp_digit) a; + a -= (mp_digit) a; + } + e -= DBL_MANT_DIG; + + low_ok = high_ok = ( mp_iseven( &r ) ); + + /* + * We are going to want to develop integers r, s, mplus, and mminus + * such that v = r / s, v(+)-v / 2 = mplus / s; v-v(-) / 2 = mminus / s + * and then scale either s or r, mplus, mminus by an appropriate + * power of ten. + * + * We actually do this by keeping track of the powers of 2 and 5 + * by which f is multiplied to yield v and by which 1 is multiplied + * to yield s, mplus, and mminus. + */ + + if ( e >= 0 ) { + + int bits = e * log2FLT_RADIX; + + if ( f != 1.0 / FLT_RADIX ) { + + /* Normal case, m+ and m- are both FLT_RADIX**e */ + + rfac2 += bits + 1; + sfac2 = 1; + mplusfac2 = bits; + mminusfac2 = bits; + + } else { + + /* + * If f is equal to the smallest significand, then we need another + * factor of FLT_RADIX in s to cope with stepping to + * the next smaller exponent when going to e's predecessor. + */ + + rfac2 += bits + log2FLT_RADIX - 1; + sfac2 = 1 + log2FLT_RADIX; + mplusfac2 = bits + log2FLT_RADIX; + mminusfac2 = bits; + + } + + } else { + + /* v has digits after the binary point */ + + if ( e <= DBL_MIN_EXP - DBL_MANT_DIG + || f != 1.0 / FLT_RADIX ) { + + /* + * Either f isn't the smallest significand or e is + * the smallest exponent. mplus and mminus will both be 1. + */ + + rfac2 += 1; + sfac2 = 1 - e * log2FLT_RADIX; + mplusfac2 = 0; + mminusfac2 = 0; + + } else { + + /* + * f is the smallest significand, but e is not the smallest + * exponent. We need to scale by FLT_RADIX again to cope + * with the fact that v's predecessor has a smaller exponent. + */ + + rfac2 += 1 + log2FLT_RADIX; + sfac2 = 1 + log2FLT_RADIX * ( 1 - e ); + mplusfac2 = FLT_RADIX; + mminusfac2 = 0; + + } + } + + /* + * Estimate the highest power of ten that will be + * needed to hold the result. + */ + + k = (int) ceil( log( v ) / log( 10. ) ); + if ( k >= 0 ) { + sfac2 += k; + sfac5 = k; + } else { + rfac2 -= k; + mplusfac2 -= k; + mminusfac2 -= k; + rfac5 = -k; + } + + /* + * Scale r, s, mplus, mminus by the appropriate powers of 2 and 5. + */ + + mp_init_set( &mplus, 1 ); + for ( i = 0; i <= 8; ++i ) { + if ( rfac5 & ( 1 << i ) ) { + mp_mul( &mplus, pow5+i, &mplus ); + } + } + mp_mul( &r, &mplus, &r ); + mp_mul_2d( &r, rfac2, &r ); + mp_init_copy( &mminus, &mplus ); + mp_mul_2d( &mplus, mplusfac2, &mplus ); + mp_mul_2d( &mminus, mminusfac2, &mminus ); + mp_init_set( &s, 1 ); + for ( i = 0; i <= 8; ++i ) { + if ( sfac5 & ( 1 << i ) ) { + mp_mul( &s, pow5+i, &s ); + } + } + mp_mul_2d( &s, sfac2, &s ); + + /* + * It is possible for k to be off by one because we used an + * inexact logarithm. + */ + + mp_init( &temp ); + mp_add( &r, &mplus, &temp ); + i = mp_cmp_mag( &temp, &s ); + if ( i > 0 || ( high_ok && i == 0 ) ) { + mp_mul_d( &s, 10, &s ); + ++k; + } else { + mp_mul_d( &temp, 10, &temp ); + i = mp_cmp_mag( &temp, &s ); + if ( i < 0 || ( high_ok && i == 0 ) ) { + mp_mul_d( &r, 10, &r ); + mp_mul_d( &mplus, 10, &mplus ); + mp_mul_d( &mminus, 10, &mminus ); + --k; + } + } + + /* + * At this point, k contains the power of ten by which we're + * scaling the result. r/s is at least 1/10 and strictly less + * than ten, and v = r/s * 10**k. mplus and mminus give the + * rounding limits. + */ + + for ( ; ; ) { + int tc1, tc2; + mp_mul_d( &r, 10, &r ); + mp_div( &r, &s, &temp, &r ); /* temp = 10r / s; r = 10r mod s */ + i = temp.dp[0]; + mp_mul_d( &mplus, 10, &mplus ); + mp_mul_d( &mminus, 10, &mminus ); + tc1 = mp_cmp_mag( &r, &mminus ); + if ( low_ok ) { + tc1 = ( tc1 <= 0 ); + } else { + tc1 = ( tc1 < 0 ); + } + mp_add( &r, &mplus, &temp ); + tc2 = mp_cmp_mag( &temp, &s ); + if ( high_ok ) { + tc2 = ( tc2 >= 0 ); + } else { + tc2= ( tc2 > 0 ); + } + if ( ! tc1 ) { + if ( !tc2 ) { + *strPtr++ = '0' + i; + } else { + c = (char) (i + '1'); + break; + } + } else { + if ( !tc2 ) { + c = (char) (i + '0'); + } else { + mp_mul_2d( &r, 1, &r ); + n = mp_cmp_mag( &r, &s ); + if ( n < 0 ) { + c = (char) (i + '0'); + } else { + c = (char) (i + '1'); + } + } + break; + } + }; + *strPtr++ = c; + *strPtr++ = '\0'; + + /* Free memory */ + + mp_clear_multi( &r, &s, &mplus, &mminus, &temp, NULL ); + return k; + +} + +/* + *---------------------------------------------------------------------- + * + * TclInitDoubleConversion -- + * + * Initializes constants that are needed for conversions to and + * from 'double' + * + * Results: + * None. + * + * Side effects: + * The log base 2 of the floating point radix, the number of + * bits in a double mantissa, and a table of the powers of five + * and ten are computed and stored. + * + *---------------------------------------------------------------------- + */ + +void +TclInitDoubleConversion( void ) +{ + int i; + int x; + double d; + if ( frexp( (double) FLT_RADIX, &log2FLT_RADIX ) != 0.5 ) { + Tcl_Panic( "This code doesn't work on a decimal machine!" ); + } + --log2FLT_RADIX; + mantBits = DBL_MANT_DIG * log2FLT_RADIX; + d = 1.0; + x = (int) (DBL_MANT_DIG * log((double) FLT_RADIX) / log( 5.0 )); + if ( x < MAXPOW ) { + mmaxpow = x; + } else { + mmaxpow = MAXPOW; + } + for ( i = 0; i <= mmaxpow; ++i ) { + pow10[i] = d; + d *= 10.0; + } + for ( i = 0; i < 9; ++i ) { + mp_init( pow5 + i ); + } + mp_set( pow5, 5 ); + for ( i = 0; i < 8; ++i ) { + mp_sqr( pow5+i, pow5+i+1 ); + } + tiny = SafeLdExp( 1.0, DBL_MIN_EXP * log2FLT_RADIX - mantBits ); + maxDigits = (int) ((DBL_MAX_EXP * log((double) FLT_RADIX) + + 0.5 * log(10.)) + / log( 10. )); + minDigits = (int) floor ( ( DBL_MIN_EXP - DBL_MANT_DIG ) + * log( (double) FLT_RADIX ) / log( 10. ) ); + mantDIGIT = ( mantBits + DIGIT_BIT - 1 ) / DIGIT_BIT; +} + +/* + *---------------------------------------------------------------------- + * + * TclFinalizeDoubleConversion -- + * + * Cleans up this file on exit. + * + * Results: + * None + * + * Side effects: + * Memory allocated by TclInitDoubleConversion is freed. + * + *---------------------------------------------------------------------- + */ + +void +TclFinalizeDoubleConversion() +{ + int i; + for ( i = 0; i < 9; ++i ) { + mp_clear( pow5 + i ); + } +} + +/* + *---------------------------------------------------------------------- + * + * TclBignumToDouble -- + * + * Convert an arbitrary-precision integer to a native floating + * point number. + * + * Results: + * Returns the converted number. Sets errno to ERANGE if the + * number is too large to convert. + * + *---------------------------------------------------------------------- + */ + +double +TclBignumToDouble( mp_int* a ) + /* Integer to convert */ +{ + mp_int b; + int bits; + int shift; + int i; + double r; + + /* Determine how many bits we need, and extract that many from + * the input. Round to nearest unit in the last place. */ + + bits = mp_count_bits( a ); + if ( bits > DBL_MAX_EXP * log2FLT_RADIX ) { + errno = ERANGE; + return HUGE_VAL; + } + shift = mantBits + 1 - bits; + mp_init( &b ); + if ( shift > 0 ) { + mp_mul_2d( a, shift, &b ); + } else if ( shift < 0 ) { + mp_div_2d( a, -shift, &b, NULL ); + } else { + mp_copy( a, &b ); + } + mp_add_d( &b, 1, &b ); + mp_div_2d( &b, 1, &b, NULL ); + + /* Accumulate the result, one mp_digit at a time */ + + r = 0.0; + for ( i = b.used-1; i >= 0; --i ) { + r = ldexp( r, DIGIT_BIT ) + b.dp[i]; + } + mp_clear( &b ); + + /* Scale the result to the correct number of bits. */ + + r = ldexp( r, bits - mantBits ); + + /* Return the result with the appropriate sign. */ + + if ( a->sign == MP_ZPOS ) { + return r; + } else { + return -r; + } +} + +/* + *---------------------------------------------------------------------- + * + * SafeLdExp -- + * + * Do an 'ldexp' operation, but handle denormals gracefully. + * + * Results: + * Returns the appropriately scaled value. + * + * On some platforms, 'ldexp' fails when presented with a number + * too small to represent as a normalized double. This routine + * does 'ldexp' in two steps for those numbers, to return correctly + * denormalized values. + * + *---------------------------------------------------------------------- + */ + +static double +SafeLdExp( double fract, int expt ) +{ + int minexpt = DBL_MIN_EXP * log2FLT_RADIX; + volatile double a, b, retval; + if ( expt < minexpt ) { + a = ldexp( fract, expt - mantBits - minexpt ); + b = ldexp( 1.0, mantBits + minexpt ); + retval = a * b; + } else { + retval = ldexp( fract, expt ); + } + return retval; +} + +/* + *---------------------------------------------------------------------- + * + * TclFormatNaN -- + * + * Makes the string representation of a "Not a Number" + * + * Results: + * None. + * + * Side effects: + * Stores the string representation in the supplied buffer, + * which must be at least TCL_DOUBLE_SPACE characters. + * + *---------------------------------------------------------------------- + */ + +void +TclFormatNaN( double value, /* The Not-a-Number to format */ + char* buffer ) /* String representation */ +{ +#ifndef IEEE_FLOATING_POINT + strcpy( buffer, "NaN" ); + return; +#else + + union { + double dv; + Tcl_WideUInt iv; + } bitwhack; + + bitwhack.dv = value; + if ( bitwhack.iv & ((Tcl_WideUInt) 1 << 63 ) ) { + bitwhack.iv &= ~ ((Tcl_WideUInt) 1 << 63 ); + *buffer++ = '-'; + } + *buffer++ = 'N'; *buffer++ = 'a'; *buffer++ = 'N'; + bitwhack.iv &= (((Tcl_WideUInt) 1) << 51) - 1; + if ( bitwhack.iv != 0 ) { + sprintf( buffer, "(%" TCL_LL_MODIFIER "x)", bitwhack.iv ); + } else { + *buffer = '\0'; + } + +#endif +} diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c index 9d01456..0e8c1f1 100644 --- a/generic/tclStringObj.c +++ b/generic/tclStringObj.c @@ -33,7 +33,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclStringObj.c,v 1.36 2005/04/01 15:17:26 msofer Exp $ */ + * RCS: @(#) $Id: tclStringObj.c,v 1.37 2005/05/10 18:34:49 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclStubInit.c b/generic/tclStubInit.c index 020f1ab..8240c9c 100644 --- a/generic/tclStubInit.c +++ b/generic/tclStubInit.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclStubInit.c,v 1.115 2005/05/05 18:38:04 dgp Exp $ + * RCS: @(#) $Id: tclStubInit.c,v 1.116 2005/05/10 18:34:49 kennykb Exp $ */ #include "tclInt.h" @@ -303,6 +303,11 @@ TclIntStubs tclIntStubs = { TclStackFree, /* 216 */ TclPushStackFrame, /* 217 */ TclPopStackFrame, /* 218 */ + TclBN_mp_div_d, /* 219 */ + TclBN_mp_mul_d, /* 220 */ + TclBN_mp_clear, /* 221 */ + TclBN_mp_init, /* 222 */ + TclBN_mp_read_radix, /* 223 */ }; TclIntPlatStubs tclIntPlatStubs = { @@ -971,6 +976,10 @@ TclStubs tclStubs = { Tcl_SetTimeProc, /* 552 */ Tcl_QueryTimeProc, /* 553 */ Tcl_ChannelThreadActionProc, /* 554 */ + Tcl_NewBignumObj, /* 555 */ + Tcl_DbNewBignumObj, /* 556 */ + Tcl_SetBignumObj, /* 557 */ + Tcl_GetBignumFromObj, /* 558 */ }; /* !END!: Do not edit above this line. */ diff --git a/generic/tclTest.c b/generic/tclTest.c index cb3a314..68b8963 100644 --- a/generic/tclTest.c +++ b/generic/tclTest.c @@ -14,7 +14,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclTest.c,v 1.88 2005/01/28 13:38:57 dkf Exp $ + * RCS: @(#) $Id: tclTest.c,v 1.89 2005/05/10 18:34:50 kennykb Exp $ */ #define TCL_TEST diff --git a/generic/tclTestObj.c b/generic/tclTestObj.c index 5c45d70..9e29ed1 100644 --- a/generic/tclTestObj.c +++ b/generic/tclTestObj.c @@ -8,14 +8,16 @@ * * Copyright (c) 1995-1998 Sun Microsystems, Inc. * Copyright (c) 1999 by Scriptics Corporation. + * Copyright (c) 2005 by Kevin B. Kenny. All rights reserved. * * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclTestObj.c,v 1.12 2002/12/04 13:09:24 vincentdarley Exp $ + * RCS: @(#) $Id: tclTestObj.c,v 1.13 2005/05/10 18:34:50 kennykb Exp $ */ #include "tclInt.h" +#include "tommath.h" /* * An array of Tcl_Obj pointers used in the commands that operate on or get @@ -37,6 +39,9 @@ static int GetVariableIndex _ANSI_ARGS_((Tcl_Interp *interp, static void SetVarToObj _ANSI_ARGS_((int varIndex, Tcl_Obj *objPtr)); int TclObjTest_Init _ANSI_ARGS_((Tcl_Interp *interp)); +static int TestbignumobjCmd _ANSI_ARGS_((ClientData dummy, + Tcl_Interp *interp, int objc, + Tcl_Obj *CONST objv[])); static int TestbooleanobjCmd _ANSI_ARGS_((ClientData dummy, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[])); @@ -95,6 +100,8 @@ TclObjTest_Init(interp) varPtr[i] = NULL; } + Tcl_CreateObjCommand( interp, "testbignumobj", TestbignumobjCmd, + (ClientData) 0, (Tcl_CmdDeleteProc*) NULL ); Tcl_CreateObjCommand(interp, "testbooleanobj", TestbooleanobjCmd, (ClientData) 0, (Tcl_CmdDeleteProc *) NULL); Tcl_CreateObjCommand(interp, "testconvertobj", TestconvertobjCmd, @@ -115,6 +122,169 @@ TclObjTest_Init(interp) /* *---------------------------------------------------------------------- * + * TestbignumobjCmd -- + * + * This procedure implmenets the "testbignumobj" command. It is used + * to exercise the bignum Tcl object type implementation. + * + * Results: + * Returns a standard Tcl object result. + * + * Side effects: + * Creates and frees bignum objects; converts objects to have bignum + * type. + * + *---------------------------------------------------------------------- + */ + +static int +TestbignumobjCmd( clientData, interp, objc, objv ) + ClientData clientData; /* unused */ + Tcl_Interp* interp; /* Tcl interpreter */ + int objc; /* Argument count */ + Tcl_Obj* CONST objv[]; /* Argument vector */ +{ + + const char * subcmds[] = { + "set", "get", "mult10", "div10", + NULL + }; + enum options { + BIGNUM_SET, BIGNUM_GET, BIGNUM_MULT10, BIGNUM_DIV10 + }; + + int index; + int varIndex; + char* string; + mp_int bignumValue, newValue; + + if ( objc < 3 ) { + Tcl_WrongNumArgs( interp, 1, objv, "option ?arg?..." ); + return TCL_ERROR; + } + if ( Tcl_GetIndexFromObj( interp, objv[1], subcmds, "option", 0, &index ) + != TCL_OK ) { + return TCL_ERROR; + } + string = Tcl_GetString( objv[ 2 ] ); + if ( GetVariableIndex( interp, string, &varIndex ) != TCL_OK ) { + return TCL_ERROR; + } + + switch ( index ) + { + case BIGNUM_SET: + if ( objc != 4 ) { + Tcl_WrongNumArgs( interp, 2, objv, "var value" ); + } + string = Tcl_GetString( objv[3] ); + if ( mp_init( &bignumValue ) != MP_OKAY ) { + Tcl_SetObjResult( interp, + Tcl_NewStringObj( "error in mp_init", -1 ) ); + return TCL_ERROR; + } + if ( mp_read_radix( &bignumValue, string, 10 ) + != MP_OKAY ) { + mp_clear( &bignumValue ); + Tcl_SetObjResult( interp, + Tcl_NewStringObj( "error in mp_read_radix", + -1 ) ); + return TCL_ERROR; + } + + /* + * If the object currently bound to the variable with index + * varIndex has ref count 1 (i.e. the object is unshared) we can + * modify that object directly. Otherwise, if RC>1 (i.e. the + * object is shared), we must create a new object to modify/set and + * decrement the old formerly-shared object's ref count. This is + * "copy on write". + */ + + if ((varPtr[varIndex] != NULL) + && !Tcl_IsShared(varPtr[varIndex])) { + Tcl_SetBignumObj(varPtr[varIndex], &bignumValue ); + } else { + SetVarToObj(varIndex, Tcl_NewBignumObj(&bignumValue)); + } + break; + + case BIGNUM_GET: + if ( objc != 3 ) { + Tcl_WrongNumArgs( interp, 2, objv, "varIndex" ); + return TCL_ERROR; + } + if ( CheckIfVarUnset( interp, varIndex ) ) { + return TCL_ERROR; + } + break; + + case BIGNUM_MULT10: + if ( objc != 3 ) { + Tcl_WrongNumArgs( interp, 2, objv, "varIndex" ); + return TCL_ERROR; + } + if ( CheckIfVarUnset( interp, varIndex ) ) { + return TCL_ERROR; + } + if ( Tcl_GetBignumFromObj( interp, varPtr[varIndex], + &bignumValue ) != TCL_OK ) { + return TCL_ERROR; + } + if ( mp_init( &newValue ) != MP_OKAY + || ( mp_mul_d( &bignumValue, 10, &newValue ) != MP_OKAY ) ) { + mp_clear( &bignumValue ); + mp_clear( &newValue ); + Tcl_SetObjResult( interp, + Tcl_NewStringObj( "error in mp_mul_d", + -1 ) ); + return TCL_ERROR; + } + mp_clear( &bignumValue ); + if ( !Tcl_IsShared( varPtr[varIndex] ) ) { + Tcl_SetBignumObj( varPtr[varIndex], &newValue ); + } else { + SetVarToObj( varIndex, Tcl_NewBignumObj( &newValue ) ); + } + break; + + case BIGNUM_DIV10: + if ( objc != 3 ) { + Tcl_WrongNumArgs( interp, 2, objv, "varIndex" ); + return TCL_ERROR; + } + if ( CheckIfVarUnset( interp, varIndex ) ) { + return TCL_ERROR; + } + if ( Tcl_GetBignumFromObj( interp, varPtr[varIndex], + &bignumValue ) != TCL_OK ) { + return TCL_ERROR; + } + if ( mp_init( &newValue ) != MP_OKAY + || ( mp_div_d( &bignumValue, 10, &newValue, NULL ) + != MP_OKAY ) ) { + mp_clear( &bignumValue ); + mp_clear( &newValue ); + Tcl_SetObjResult( interp, + Tcl_NewStringObj( "error in mp_div_d", + -1 ) ); + return TCL_ERROR; + } + mp_clear( &bignumValue ); + if ( !Tcl_IsShared( varPtr[varIndex] ) ) { + Tcl_SetBignumObj( varPtr[varIndex], &newValue ); + } else { + SetVarToObj( varIndex, Tcl_NewBignumObj( &newValue ) ); + } + } + + Tcl_SetObjResult( interp, varPtr[varIndex] ); + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * * TestbooleanobjCmd -- * * This procedure implements the "testbooleanobj" command. It is used diff --git a/generic/tclThread.c b/generic/tclThread.c index 6fc558c..2afc284 100644 --- a/generic/tclThread.c +++ b/generic/tclThread.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclThread.c,v 1.10 2005/02/03 13:31:10 dkf Exp $ + * RCS: @(#) $Id: tclThread.c,v 1.11 2005/05/10 18:34:50 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclThreadAlloc.c b/generic/tclThreadAlloc.c index 0e8c087..c03cc9e 100755 --- a/generic/tclThreadAlloc.c +++ b/generic/tclThreadAlloc.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclThreadAlloc.c,v 1.15 2005/04/16 08:00:17 vasiljevic Exp $ + * RCS: @(#) $Id: tclThreadAlloc.c,v 1.16 2005/05/10 18:34:50 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclThreadTest.c b/generic/tclThreadTest.c index 7b2ac56..299a5aa 100644 --- a/generic/tclThreadTest.c +++ b/generic/tclThreadTest.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclThreadTest.c,v 1.18 2005/03/25 00:35:03 dgp Exp $ + * RCS: @(#) $Id: tclThreadTest.c,v 1.19 2005/05/10 18:34:50 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclTimer.c b/generic/tclTimer.c index 14cdd27..a8728f4 100644 --- a/generic/tclTimer.c +++ b/generic/tclTimer.c @@ -9,7 +9,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclTimer.c,v 1.14 2005/03/23 22:09:28 dgp Exp $ + * RCS: @(#) $Id: tclTimer.c,v 1.15 2005/05/10 18:34:51 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclTomMath.h b/generic/tclTomMath.h new file mode 100644 index 0000000..4ffbea2 --- /dev/null +++ b/generic/tclTomMath.h @@ -0,0 +1,109 @@ +/* + * tclTomMath.h -- + * + * Interface information that comes in at the head of + * <tommath.h> to adapt the API to Tcl's linkage conventions. + * + * Copyright (c) 2005 by Kevin B. Kenny. All rights reserved. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * RCS: @(#) $Id: tclTomMath.h,v 1.2 2005/05/10 18:34:51 kennykb Exp $ + */ + +#ifndef TCLTOMMATH_H +#define TCLTOMMATH_H 1 + +#include <tcl.h> +#include <stdlib.h> + + +/* Define TOMMATH_DLLIMPORT and TOMMATH_DLLEXPORT to suit the compiler */ + +#ifdef STATIC_BUILD +# define TOMMATH_DLLIMPORT +# define TOMMATH_DLLEXPORT +#else +# if (defined(__WIN32__) && (defined(_MSC_VER) || (__BORLANDC__ >= 0x0550) || defined(__LCC__) || defined(__WATCOMC__) || (defined(__GNUC__) && defined(__declspec)))) +# define TOMMATH_DLLIMPORT __declspec(dllimport) +# define TOMMATH_DLLEXPORT __declspec(dllexport) +# else +# define TOMMATH_DLLIMPORT +# define TOMMATH_DLLEXPORT +# endif +#endif + +/* Define TOMMATH_STORAGE_CLASS according to the build options. */ + +#undef TOMMATH_STORAGE_CLASS +#ifdef BUILD_tcl +# define TOMMATH_STORAGE_CLASS TOMMATH_DLLEXPORT +#else +# ifdef USE_TCL_STUBS +# define TOMMATH_STORAGE_CLASS +# else +# define TOMMATH_STORAGE_CLASS TOMMATH_DLLIMPORT +# endif +#endif + +/* Define custom memory allocation for libtommath */ + +#define XMALLOC(x) TclBNAlloc(x) +#define XFREE(x) TclBNFree(x) +#define XREALLOC(x,n) TclBNRealloc(x,n) +#define XCALLOC(n,x) TclBNCalloc(n,x) +void* TclBNAlloc( size_t ); +void* TclBNRealloc( void*, size_t ); +void TclBNFree( void* ); +void* TclBNCalloc( size_t, size_t ); + +/* Rename all global symboles in libtommath to avoid linkage conflicts */ + +#define KARATSUBA_MUL_CUTOFF TclBNKaratsubaMulCutoff +#define KARATSUBA_SQR_CUTOFF TclBNKaratsubaSqrCutoff +#define TOOM_MUL_CUTOFF TclBNToomMulCutoff +#define TOOM_SQR_CUTOFF TclBNToomSqrCutoff + +#define mp_s_rmap TclBNMpSRmap + +#define bn_reverse TclBN_reverse +#define fast_s_mp_mul_digs TclBN_fast_s_mp_mul_digs +#define mp_add TclBN_mp_add +#define mp_clamp TclBN_mp_clamp +#define mp_clear TclBN_mp_clear +#define mp_clear_multi TclBN_mp_clear_multi +#define mp_cmp TclBN_mp_cmp +#define mp_cmp_mag TclBN_mp_cmp_mag +#define mp_copy TclBN_mp_copy +#define mp_count_bits TclBN_mp_count_bits +#define mp_div TclBN_mp_div +#define mp_div_d TclBN_mp_div_d +#define mp_div_2 TclBN_mp_div_2 +#define mp_div_2d TclBN_mp_div_2d +#define mp_div_3 TclBN_mp_div_3 +#define mp_exch TclBN_mp_exch +#define mp_grow TclBN_mp_grow +#define mp_init TclBN_mp_init +#define mp_init_copy TclBN_mp_init_copy +#define mp_init_multi TclBN_mp_init_multi +#define mp_init_size TclBN_mp_init_size +#define mp_karatsuba_mul TclBN_mp_karatsuba_mul +#define mp_lshd TclBN_mp_lshd +#define mp_mod_2d TclBN_mp_mod_2d +#define mp_mul TclBN_mp_mul +#define mp_mul_2 TclBN_mp_mul_2 +#define mp_mul_2d TclBN_mp_mul_2d +#define mp_mul_d TclBN_mp_mul_d +#define mp_radix_size TclBN_mp_radix_size +#define mp_read_radix TclBN_mp_read_radix +#define mp_rshd TclBN_mp_rshd +#define mp_sub TclBN_mp_sub +#define mp_toom_mul TclBN_mp_toom_mul +#define mp_toradix_n TclBN_mp_toradix_n +#define mp_zero TclBN_mp_zero +#define s_mp_add TclBN_s_mp_add +#define s_mp_mul_digs TclBN_s_mp_mul_digs +#define s_mp_sub TclBN_s_mp_sub + +#endif diff --git a/generic/tclTomMathInterface.c b/generic/tclTomMathInterface.c new file mode 100644 index 0000000..89537b9 --- /dev/null +++ b/generic/tclTomMathInterface.c @@ -0,0 +1,143 @@ +/* + *---------------------------------------------------------------------- + * + * tclTomMathInterface.c -- + * + * This file contains procedures that are used as a 'glue' + * layer between Tcl and libtommath. + * + * Copyright (c) 2005 by Kevin B. Kenny. All rights reserved. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * RCS: @(#) $Id: tclTomMathInterface.c,v 1.2 2005/05/10 18:34:51 kennykb Exp $ + */ + +#include "tclInt.h" +#include "tommath.h" +#include <limits.h> + +/* + *---------------------------------------------------------------------- + * + * TclBNAlloc -- + * + * Allocate memory for libtommath. + * + * Results: + * Returns a pointer to the allocated block. + * + * This procedure is a wrapper around Tcl_Alloc, needed because of + * a mismatched type signature between Tcl_Alloc and malloc. + * + *---------------------------------------------------------------------- + */ + +extern void * +TclBNAlloc( size_t x ) +{ + return (void*) Tcl_Alloc( (unsigned int) x ); +} + +/* + *---------------------------------------------------------------------- + * + * TclBNAlloc -- + * + * Change the size of an allocated block of memory in libtommath + * + * Results: + * Returns a pointer to the allocated block. + * + * This procedure is a wrapper around Tcl_Realloc, needed because of + * a mismatched type signature between Tcl_Realloc and realloc. + * + *---------------------------------------------------------------------- + */ + +extern void * +TclBNRealloc( void* p, size_t s ) +{ + return (void*) Tcl_Realloc( (char*) p, (unsigned int) s ); +} + +/* + *---------------------------------------------------------------------- + * + * TclBNFree -- + * + * Free allocated memory in libtommath. + * + * Results: + * None. + * + * Side effects: + * Memory is freed. + * + * This function is simply a wrapper around Tcl_Free, needed in + * libtommath because of a type mismatch between free and Tcl_Free. + * + *---------------------------------------------------------------------- + */ + +extern void +TclBNFree( void* p ) +{ + Tcl_Free( (char*) p); +} + +/* + *---------------------------------------------------------------------- + * + * TclBNInitBignumFromLong -- + * + * Allocate and initialize a 'bignum' from a native 'long'. + * + * Results: + * None. + * + * Side effects: + * The 'bignum' is constructed. + * + *---------------------------------------------------------------------- + */ + +extern void +TclBNInitBignumFromLong( mp_int* a, long initVal ) +{ + + int status; + unsigned long v; + mp_digit* p; + + /* + * Allocate enough memory to hold the largest possible long + */ + + status = mp_init_size( a, ( ( CHAR_BIT * sizeof( long ) + DIGIT_BIT - 1 ) + / DIGIT_BIT ) ); + if ( status != MP_OKAY ) { + Tcl_Panic( "initialization failure in TclBNInitBignumFromLong" ); + } + + /* Convert arg to sign and magnitude */ + + if ( initVal < 0 ) { + a->sign = MP_NEG; + v = -initVal; + } else { + a->sign = MP_ZPOS; + v = initVal; + } + + /* Store the magnitude in the bignum. */ + + p = a->dp; + while ( v ) { + *p++ = (mp_digit) ( v & MP_MASK ); + v >>= MP_DIGIT_BIT; + } + a->used = p - a->dp; + +} diff --git a/generic/tclTrace.c b/generic/tclTrace.c index f717c8d..3a15ac8 100644 --- a/generic/tclTrace.c +++ b/generic/tclTrace.c @@ -11,7 +11,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclTrace.c,v 1.22 2005/03/10 22:10:38 dgp Exp $ + * RCS: @(#) $Id: tclTrace.c,v 1.23 2005/05/10 18:34:51 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclUtf.c b/generic/tclUtf.c index d3ac7e1..7a5494a 100644 --- a/generic/tclUtf.c +++ b/generic/tclUtf.c @@ -8,7 +8,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclUtf.c,v 1.33 2005/05/03 18:08:20 dgp Exp $ + * RCS: @(#) $Id: tclUtf.c,v 1.34 2005/05/10 18:34:51 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tclUtil.c b/generic/tclUtil.c index 869169a..278380d 100644 --- a/generic/tclUtil.c +++ b/generic/tclUtil.c @@ -11,10 +11,32 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclUtil.c,v 1.58 2005/05/05 18:38:06 dgp Exp $ + * RCS: @(#) $Id: tclUtil.c,v 1.59 2005/05/10 18:34:52 kennykb Exp $ */ #include "tclInt.h" +#include <float.h> +#include <math.h> + +/* + * Define test for NaN + */ + +#ifdef _MSC_VER +#define IS_NAN(f) (_isnan((f))) +#else +#define IS_NAN(f) ((f) != (f)) +#endif + +/* + * Define test for Inf + */ + +#ifdef _MSC_VER +#define IS_INF(f) ( ! (_finite((f)))) +#else +#define IS_INF(f) ( (f) > DBL_MAX || (f) < -DBL_MAX ) +#endif /* * The absolute pathname of the executable in which this Tcl library @@ -56,12 +78,9 @@ static ProcessGlobalValue executableName = {0, 0, NULL, NULL, NULL, NULL, NULL}; * TclPrecTraceProc. */ -static char precisionString[10] = "12"; - /* The string value of all the tcl_precision - * variables. */ -static char precisionFormat[10] = "%.12g"; - /* The format string actually used in calls - * to sprintf. */ +static int precision = 0; /* Precision of floating point conversions, + * in the range 0-17 inclusive. */ + TCL_DECLARE_MUTEX(precisionMutex) /* @@ -1879,33 +1898,125 @@ Tcl_PrintDouble(interp, value, dst) * characters. */ { char *p, c; + int prec; + int exp; + int signum; + char buffer[TCL_DOUBLE_SPACE]; Tcl_UniChar ch; Tcl_MutexLock(&precisionMutex); - sprintf(dst, precisionFormat, value); + prec = precision; Tcl_MutexUnlock(&precisionMutex); /* - * If the ASCII result looks like an integer, add ".0" so that it - * doesn't look like an integer anymore. This prevents floating-point - * values from being converted to integers unintentionally. - * Check for ASCII specifically to speed up the function. + * If prec == 0, then use TclDoubleDigits to develop a decimal + * significand and exponent, then format it in E or F format as + * appropriate. If prec != 0, use the native sprintf and then + * add a trailing ".0" if there is no decimal point in the rep. */ - for (p = dst; *p != 0; ) { - if (UCHAR(*p) < 0x80) { - c = *p++; - } else { - p += Tcl_UtfToUniChar(p, &ch); - c = UCHAR(ch); + if ( prec == 0 ) { + + /* Handle NaN */ + + if ( IS_NAN( value ) ) { + TclFormatNaN( value, dst ); + return; } - if ((c == '.') || isalpha(UCHAR(c))) { /* INTL: ISO only. */ + + /* Handle infinities */ + + if ( IS_INF( value ) ) { + if ( value < 0 ) { + strcpy( dst, "-Inf" ); + } else { + strcpy( dst, "Inf" ); + } return; } + + /* Ordinary (normal and denormal) values */ + + exp = TclDoubleDigits( buffer, value, &signum ); + if ( signum ) { + *dst++ = '-'; + } + prec = strlen( buffer ); + p = buffer; + if ( exp < -3 || exp > 17 ) { + + /* E format for numbers < 1e-3 or >= 1e17 */ + + *dst++ = *p++; + c = *p; + if ( c != '\0' ) { + *dst++ = '.'; + while ( c != '\0' ) { + *dst++ = c; + c = *++p; + } + } + sprintf( dst, "e%+d", exp-1 ); + } else { + + /* F format for others */ + + if ( exp <= 0 ) { + *dst++ = '0'; + } + c = *p; + while ( exp-- > 0 ) { + if ( c != '\0' ) { + *dst++ = c; + c = *++p; + } else { + *dst++ = '0'; + } + } + *dst++ = '.'; + if ( c == '\0' ) { + *dst++ = '0'; + } else { + while ( ++exp < 0 ) { + *dst++ = '0'; + } + while ( c != '\0' ) { + *dst++ = c; + c = *++p; + } + } + *dst++ = '\0'; + } + + } else { + + /* tcl_precision is supplied, pass it to the native sprintf */ + + sprintf( dst, "%.*g", prec, value ); + + /* + * If the ASCII result looks like an integer, add ".0" so that it + * doesn't look like an integer anymore. This prevents floating-point + * values from being converted to integers unintentionally. + * Check for ASCII specifically to speed up the function. + */ + + for (p = dst; *p != 0; ) { + if (UCHAR(*p) < 0x80) { + c = *p++; + } else { + p += Tcl_UtfToUniChar(p, &ch); + c = UCHAR(ch); + } + if ((c == '.') || isalpha(UCHAR(c))) { /* INTL: ISO only. */ + return; + } + } + p[0] = '.'; + p[1] = '0'; + p[2] = 0; + } - p[0] = '.'; - p[1] = '0'; - p[2] = 0; } /* @@ -1937,8 +2048,7 @@ TclPrecTraceProc(clientData, interp, name1, name2, flags) CONST char *name2; /* Second part of variable name. */ int flags; /* Information about what happened. */ { - CONST char *value; - char *end; + Tcl_Obj* value; int prec; /* @@ -1961,11 +2071,11 @@ TclPrecTraceProc(clientData, interp, name1, name2, flags) * out of date. */ - Tcl_MutexLock(&precisionMutex); if (flags & TCL_TRACE_READS) { - Tcl_SetVar2(interp, name1, name2, precisionString, - flags & TCL_GLOBAL_ONLY); + Tcl_MutexLock(&precisionMutex); + Tcl_SetVar2Ex( interp, name1, name2, Tcl_NewIntObj( precision ), + flags & TCL_GLOBAL_ONLY ); Tcl_MutexUnlock(&precisionMutex); return (char *) NULL; } @@ -1978,25 +2088,21 @@ TclPrecTraceProc(clientData, interp, name1, name2, flags) */ if (Tcl_IsSafe(interp)) { - Tcl_SetVar2(interp, name1, name2, precisionString, - flags & TCL_GLOBAL_ONLY); + Tcl_MutexLock(&precisionMutex); + Tcl_SetVar2Ex( interp, name1, name2, Tcl_NewIntObj( precision ), + flags & TCL_GLOBAL_ONLY ); Tcl_MutexUnlock(&precisionMutex); return "can't modify precision from a safe interpreter"; } - value = Tcl_GetVar2(interp, name1, name2, flags & TCL_GLOBAL_ONLY); - if (value == NULL) { - value = ""; - } - prec = strtoul(value, &end, 10); - if ((prec <= 0) || (prec > TCL_MAX_PREC) || (prec > 100) || - (end == value) || (*end != 0)) { - Tcl_SetVar2(interp, name1, name2, precisionString, - flags & TCL_GLOBAL_ONLY); - Tcl_MutexUnlock(&precisionMutex); + value = Tcl_GetVar2Ex(interp, name1, name2, flags & TCL_GLOBAL_ONLY); + if ( value == NULL + || Tcl_GetIntFromObj( (Tcl_Interp*) NULL, value, &prec ) != TCL_OK + || prec < 0 + || prec > TCL_MAX_PREC ) { return "improper value for precision"; } - TclFormatInt(precisionString, prec); - sprintf(precisionFormat, "%%.%dg", prec); + Tcl_MutexLock( &precisionMutex ); + precision = prec; Tcl_MutexUnlock(&precisionMutex); return (char *) NULL; } diff --git a/generic/tclVar.c b/generic/tclVar.c index 314f958..6cdedc9 100644 --- a/generic/tclVar.c +++ b/generic/tclVar.c @@ -15,7 +15,7 @@ * See the file "license.terms" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * - * RCS: @(#) $Id: tclVar.c,v 1.105 2005/05/05 18:38:06 dgp Exp $ + * RCS: @(#) $Id: tclVar.c,v 1.106 2005/05/10 18:34:52 kennykb Exp $ */ #include "tclInt.h" diff --git a/generic/tommath.h b/generic/tommath.h new file mode 100644 index 0000000..a9983a4 --- /dev/null +++ b/generic/tommath.h @@ -0,0 +1,591 @@ +/* LibTomMath, multiple-precision integer library -- Tom St Denis + * + * LibTomMath is a library that provides multiple-precision + * integer arithmetic as well as number theoretic functionality. + * + * The library was designed directly after the MPI library by + * Michael Fromberger but has been written from scratch with + * additional optimizations in place. + * + * The library is free for all purposes without any express + * guarantee it works. + * + * Tom St Denis, tomstdenis@iahu.ca, http://math.libtomcrypt.org + */ +#ifndef BN_H_ +#define BN_H_ + +#ifdef TCL_TOMMATH +#include <tclTomMath.h> +#endif +#ifndef TOMMATH_STORAGE_CLASS +#define TOMMATH_STORAGE_CLASS extern +#endif + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <ctype.h> +#include <limits.h> + +#include <tommath_class.h> + +#undef MIN +#define MIN(x,y) ((x)<(y)?(x):(y)) +#undef MAX +#define MAX(x,y) ((x)>(y)?(x):(y)) + +#ifdef __cplusplus +extern "C" { + +/* C++ compilers don't like assigning void * to mp_digit * */ +#define OPT_CAST(x) (x *) + +#else + +/* C on the other hand doesn't care */ +#define OPT_CAST(x) + +#endif + + +/* detect 64-bit mode if possible */ +#if defined(__x86_64__) + #if !(defined(MP_64BIT) && defined(MP_16BIT) && defined(MP_8BIT)) + #define MP_64BIT + #endif +#endif + +/* some default configurations. + * + * A "mp_digit" must be able to hold DIGIT_BIT + 1 bits + * A "mp_word" must be able to hold 2*DIGIT_BIT + 1 bits + * + * At the very least a mp_digit must be able to hold 7 bits + * [any size beyond that is ok provided it doesn't overflow the data type] + */ +#ifdef MP_8BIT +#ifndef MP_DIGIT_DECLARED + typedef unsigned char mp_digit; +#define MP_DIGIT_DECLARED +#endif + typedef unsigned short mp_word; +#elif defined(MP_16BIT) +#ifndef MP_DIGIT_DECLARED + typedef unsigned short mp_digit; +#define MP_DIGIT_DECLARED +#endif + typedef unsigned long mp_word; +#elif defined(MP_64BIT) + /* for GCC only on supported platforms */ +#ifndef CRYPT + typedef unsigned long long ulong64; + typedef signed long long long64; +#endif + +#ifndef MP_DIGIT_DECLARED + typedef unsigned long mp_digit; +#define MP_DIGIT_DECLARED +#endif + typedef unsigned long mp_word __attribute__ ((mode(TI))); + + #define DIGIT_BIT 60 +#else + /* this is the default case, 28-bit digits */ + + /* this is to make porting into LibTomCrypt easier :-) */ +#ifndef CRYPT + #if defined(_MSC_VER) || defined(__BORLANDC__) + typedef unsigned __int64 ulong64; + typedef signed __int64 long64; + #else + typedef unsigned long long ulong64; + typedef signed long long long64; + #endif +#endif + +#ifndef MP_DIGIT_DECLARED + typedef unsigned long mp_digit; +#define MP_DIGIT_DECLARED +#endif + typedef ulong64 mp_word; + +#ifdef MP_31BIT + /* this is an extension that uses 31-bit digits */ + #define DIGIT_BIT 31 +#else + /* default case is 28-bit digits, defines MP_28BIT as a handy macro to test */ + #define DIGIT_BIT 28 + #define MP_28BIT +#endif +#endif + +/* define heap macros */ +#ifndef CRYPT + /* default to libc stuff */ + #ifndef XMALLOC + #define XMALLOC malloc + #define XFREE free + #define XREALLOC realloc + #define XCALLOC calloc + #else + /* prototypes for our heap functions */ + extern void *XMALLOC(size_t n); + extern void *REALLOC(void *p, size_t n); + extern void *XCALLOC(size_t n, size_t s); + extern void XFREE(void *p); + #endif +#endif + + +/* otherwise the bits per digit is calculated automatically from the size of a mp_digit */ +#ifndef DIGIT_BIT + #define DIGIT_BIT ((int)((CHAR_BIT * sizeof(mp_digit) - 1))) /* bits per digit */ +#endif + +#define MP_DIGIT_BIT DIGIT_BIT +#define MP_MASK ((((mp_digit)1)<<((mp_digit)DIGIT_BIT))-((mp_digit)1)) +#define MP_DIGIT_MAX MP_MASK + +/* equalities */ +#define MP_LT -1 /* less than */ +#define MP_EQ 0 /* equal to */ +#define MP_GT 1 /* greater than */ + +#define MP_ZPOS 0 /* positive integer */ +#define MP_NEG 1 /* negative */ + +#define MP_OKAY 0 /* ok result */ +#define MP_MEM -2 /* out of mem */ +#define MP_VAL -3 /* invalid input */ +#define MP_RANGE MP_VAL + +#define MP_YES 1 /* yes response */ +#define MP_NO 0 /* no response */ + +/* Primality generation flags */ +#define LTM_PRIME_BBS 0x0001 /* BBS style prime */ +#define LTM_PRIME_SAFE 0x0002 /* Safe prime (p-1)/2 == prime */ +#define LTM_PRIME_2MSB_OFF 0x0004 /* force 2nd MSB to 0 */ +#define LTM_PRIME_2MSB_ON 0x0008 /* force 2nd MSB to 1 */ + +typedef int mp_err; + +/* you'll have to tune these... */ +extern int KARATSUBA_MUL_CUTOFF, + KARATSUBA_SQR_CUTOFF, + TOOM_MUL_CUTOFF, + TOOM_SQR_CUTOFF; + +/* define this to use lower memory usage routines (exptmods mostly) */ +/* #define MP_LOW_MEM */ + +/* default precision */ +#ifndef MP_PREC + #ifndef MP_LOW_MEM + #define MP_PREC 64 /* default digits of precision */ + #else + #define MP_PREC 8 /* default digits of precision */ + #endif +#endif + +/* size of comba arrays, should be at least 2 * 2**(BITS_PER_WORD - BITS_PER_DIGIT*2) */ +#define MP_WARRAY (1 << (sizeof(mp_word) * CHAR_BIT - 2 * DIGIT_BIT + 1)) + +/* the infamous mp_int structure */ +#ifndef MP_INT_DECLARED +#define MP_INT_DECLARED +typedef struct mp_int mp_int; +#endif +struct mp_int { + int used, alloc, sign; + mp_digit *dp; +}; + +/* callback for mp_prime_random, should fill dst with random bytes and return how many read [upto len] */ +typedef int ltm_prime_callback(unsigned char *dst, int len, void *dat); + + +#define USED(m) ((m)->used) +#define DIGIT(m,k) ((m)->dp[(k)]) +#define SIGN(m) ((m)->sign) + +/* error code to char* string */ +TOMMATH_STORAGE_CLASS char *mp_error_to_string(int code); + +/* ---> init and deinit bignum functions <--- */ +/* init a bignum */ +TOMMATH_STORAGE_CLASS int mp_init(mp_int *a); + +/* free a bignum */ +TOMMATH_STORAGE_CLASS void mp_clear(mp_int *a); + +/* init a null terminated series of arguments */ +TOMMATH_STORAGE_CLASS int mp_init_multi(mp_int *mp, ...); + +/* clear a null terminated series of arguments */ +TOMMATH_STORAGE_CLASS void mp_clear_multi(mp_int *mp, ...); + +/* exchange two ints */ +TOMMATH_STORAGE_CLASS void mp_exch(mp_int *a, mp_int *b); + +/* shrink ram required for a bignum */ +TOMMATH_STORAGE_CLASS int mp_shrink(mp_int *a); + +/* grow an int to a given size */ +TOMMATH_STORAGE_CLASS int mp_grow(mp_int *a, int size); + +/* init to a given number of digits */ +TOMMATH_STORAGE_CLASS int mp_init_size(mp_int *a, int size); + +/* ---> Basic Manipulations <--- */ +#define mp_iszero(a) (((a)->used == 0) ? MP_YES : MP_NO) +#define mp_iseven(a) (((a)->used == 0 || (((a)->dp[0] & 1) == 0)) ? MP_YES : MP_NO) +#define mp_isodd(a) (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? MP_YES : MP_NO) + +/* set to zero */ +TOMMATH_STORAGE_CLASS void mp_zero(mp_int *a); + +/* set to a digit */ +TOMMATH_STORAGE_CLASS void mp_set(mp_int *a, mp_digit b); + +/* set a 32-bit const */ +TOMMATH_STORAGE_CLASS int mp_set_int(mp_int *a, unsigned long b); + +/* get a 32-bit value */ +unsigned long mp_get_int(mp_int * a); + +/* initialize and set a digit */ +TOMMATH_STORAGE_CLASS int mp_init_set (mp_int * a, mp_digit b); + +/* initialize and set 32-bit value */ +TOMMATH_STORAGE_CLASS int mp_init_set_int (mp_int * a, unsigned long b); + +/* copy, b = a */ +TOMMATH_STORAGE_CLASS int mp_copy(mp_int *a, mp_int *b); + +/* inits and copies, a = b */ +TOMMATH_STORAGE_CLASS int mp_init_copy(mp_int *a, mp_int *b); + +/* trim unused digits */ +TOMMATH_STORAGE_CLASS void mp_clamp(mp_int *a); + +/* ---> digit manipulation <--- */ + +/* right shift by "b" digits */ +TOMMATH_STORAGE_CLASS void mp_rshd(mp_int *a, int b); + +/* left shift by "b" digits */ +TOMMATH_STORAGE_CLASS int mp_lshd(mp_int *a, int b); + +/* c = a / 2**b */ +TOMMATH_STORAGE_CLASS int mp_div_2d(mp_int *a, int b, mp_int *c, mp_int *d); + +/* b = a/2 */ +TOMMATH_STORAGE_CLASS int mp_div_2(mp_int *a, mp_int *b); + +/* c = a * 2**b */ +TOMMATH_STORAGE_CLASS int mp_mul_2d(mp_int *a, int b, mp_int *c); + +/* b = a*2 */ +TOMMATH_STORAGE_CLASS int mp_mul_2(mp_int *a, mp_int *b); + +/* c = a mod 2**d */ +TOMMATH_STORAGE_CLASS int mp_mod_2d(mp_int *a, int b, mp_int *c); + +/* computes a = 2**b */ +TOMMATH_STORAGE_CLASS int mp_2expt(mp_int *a, int b); + +/* Counts the number of lsbs which are zero before the first zero bit */ +TOMMATH_STORAGE_CLASS int mp_cnt_lsb(mp_int *a); + +/* I Love Earth! */ + +/* makes a pseudo-random int of a given size */ +TOMMATH_STORAGE_CLASS int mp_rand(mp_int *a, int digits); + +/* ---> binary operations <--- */ +/* c = a XOR b */ +TOMMATH_STORAGE_CLASS int mp_xor(mp_int *a, mp_int *b, mp_int *c); + +/* c = a OR b */ +TOMMATH_STORAGE_CLASS int mp_or(mp_int *a, mp_int *b, mp_int *c); + +/* c = a AND b */ +TOMMATH_STORAGE_CLASS int mp_and(mp_int *a, mp_int *b, mp_int *c); + +/* ---> Basic arithmetic <--- */ + +/* b = -a */ +TOMMATH_STORAGE_CLASS int mp_neg(mp_int *a, mp_int *b); + +/* b = |a| */ +TOMMATH_STORAGE_CLASS int mp_abs(mp_int *a, mp_int *b); + +/* compare a to b */ +TOMMATH_STORAGE_CLASS int mp_cmp(mp_int *a, mp_int *b); + +/* compare |a| to |b| */ +TOMMATH_STORAGE_CLASS int mp_cmp_mag(mp_int *a, mp_int *b); + +/* c = a + b */ +TOMMATH_STORAGE_CLASS int mp_add(mp_int *a, mp_int *b, mp_int *c); + +/* c = a - b */ +TOMMATH_STORAGE_CLASS int mp_sub(mp_int *a, mp_int *b, mp_int *c); + +/* c = a * b */ +TOMMATH_STORAGE_CLASS int mp_mul(mp_int *a, mp_int *b, mp_int *c); + +/* b = a*a */ +TOMMATH_STORAGE_CLASS int mp_sqr(mp_int *a, mp_int *b); + +/* a/b => cb + d == a */ +TOMMATH_STORAGE_CLASS int mp_div(mp_int *a, mp_int *b, mp_int *c, mp_int *d); + +/* c = a mod b, 0 <= c < b */ +TOMMATH_STORAGE_CLASS int mp_mod(mp_int *a, mp_int *b, mp_int *c); + +/* ---> single digit functions <--- */ + +/* compare against a single digit */ +TOMMATH_STORAGE_CLASS int mp_cmp_d(mp_int *a, mp_digit b); + +/* c = a + b */ +TOMMATH_STORAGE_CLASS int mp_add_d(mp_int *a, mp_digit b, mp_int *c); + +/* c = a - b */ +TOMMATH_STORAGE_CLASS int mp_sub_d(mp_int *a, mp_digit b, mp_int *c); + +/* c = a * b */ +TOMMATH_STORAGE_CLASS int mp_mul_d(mp_int *a, mp_digit b, mp_int *c); + +/* a/b => cb + d == a */ +TOMMATH_STORAGE_CLASS int mp_div_d(mp_int *a, mp_digit b, mp_int *c, mp_digit *d); + +/* a/3 => 3c + d == a */ +TOMMATH_STORAGE_CLASS int mp_div_3(mp_int *a, mp_int *c, mp_digit *d); + +/* c = a**b */ +TOMMATH_STORAGE_CLASS int mp_expt_d(mp_int *a, mp_digit b, mp_int *c); + +/* c = a mod b, 0 <= c < b */ +TOMMATH_STORAGE_CLASS int mp_mod_d(mp_int *a, mp_digit b, mp_digit *c); + +/* ---> number theory <--- */ + +/* d = a + b (mod c) */ +TOMMATH_STORAGE_CLASS int mp_addmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d); + +/* d = a - b (mod c) */ +TOMMATH_STORAGE_CLASS int mp_submod(mp_int *a, mp_int *b, mp_int *c, mp_int *d); + +/* d = a * b (mod c) */ +TOMMATH_STORAGE_CLASS int mp_mulmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d); + +/* c = a * a (mod b) */ +TOMMATH_STORAGE_CLASS int mp_sqrmod(mp_int *a, mp_int *b, mp_int *c); + +/* c = 1/a (mod b) */ +TOMMATH_STORAGE_CLASS int mp_invmod(mp_int *a, mp_int *b, mp_int *c); + +/* c = (a, b) */ +TOMMATH_STORAGE_CLASS int mp_gcd(mp_int *a, mp_int *b, mp_int *c); + +/* produces value such that U1*a + U2*b = U3 */ +TOMMATH_STORAGE_CLASS int mp_exteuclid(mp_int *a, mp_int *b, mp_int *U1, mp_int *U2, mp_int *U3); + +/* c = [a, b] or (a*b)/(a, b) */ +TOMMATH_STORAGE_CLASS int mp_lcm(mp_int *a, mp_int *b, mp_int *c); + +/* finds one of the b'th root of a, such that |c|**b <= |a| + * + * returns error if a < 0 and b is even + */ +TOMMATH_STORAGE_CLASS int mp_n_root(mp_int *a, mp_digit b, mp_int *c); + +/* special sqrt algo */ +TOMMATH_STORAGE_CLASS int mp_sqrt(mp_int *arg, mp_int *ret); + +/* is number a square? */ +TOMMATH_STORAGE_CLASS int mp_is_square(mp_int *arg, int *ret); + +/* computes the jacobi c = (a | n) (or Legendre if b is prime) */ +TOMMATH_STORAGE_CLASS int mp_jacobi(mp_int *a, mp_int *n, int *c); + +/* used to setup the Barrett reduction for a given modulus b */ +TOMMATH_STORAGE_CLASS int mp_reduce_setup(mp_int *a, mp_int *b); + +/* Barrett Reduction, computes a (mod b) with a precomputed value c + * + * Assumes that 0 < a <= b*b, note if 0 > a > -(b*b) then you can merely + * compute the reduction as -1 * mp_reduce(mp_abs(a)) [pseudo code]. + */ +TOMMATH_STORAGE_CLASS int mp_reduce(mp_int *a, mp_int *b, mp_int *c); + +/* setups the montgomery reduction */ +TOMMATH_STORAGE_CLASS int mp_montgomery_setup(mp_int *a, mp_digit *mp); + +/* computes a = B**n mod b without division or multiplication useful for + * normalizing numbers in a Montgomery system. + */ +TOMMATH_STORAGE_CLASS int mp_montgomery_calc_normalization(mp_int *a, mp_int *b); + +/* computes x/R == x (mod N) via Montgomery Reduction */ +TOMMATH_STORAGE_CLASS int mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp); + +/* returns 1 if a is a valid DR modulus */ +TOMMATH_STORAGE_CLASS int mp_dr_is_modulus(mp_int *a); + +/* sets the value of "d" required for mp_dr_reduce */ +TOMMATH_STORAGE_CLASS void mp_dr_setup(mp_int *a, mp_digit *d); + +/* reduces a modulo b using the Diminished Radix method */ +TOMMATH_STORAGE_CLASS int mp_dr_reduce(mp_int *a, mp_int *b, mp_digit mp); + +/* returns true if a can be reduced with mp_reduce_2k */ +TOMMATH_STORAGE_CLASS int mp_reduce_is_2k(mp_int *a); + +/* determines k value for 2k reduction */ +TOMMATH_STORAGE_CLASS int mp_reduce_2k_setup(mp_int *a, mp_digit *d); + +/* reduces a modulo b where b is of the form 2**p - k [0 <= a] */ +TOMMATH_STORAGE_CLASS int mp_reduce_2k(mp_int *a, mp_int *n, mp_digit d); + +/* d = a**b (mod c) */ +TOMMATH_STORAGE_CLASS int mp_exptmod(mp_int *a, mp_int *b, mp_int *c, mp_int *d); + +/* ---> Primes <--- */ + +/* number of primes */ +#ifdef MP_8BIT + #define PRIME_SIZE 31 +#else + #define PRIME_SIZE 256 +#endif + +/* table of first PRIME_SIZE primes */ +extern const mp_digit ltm_prime_tab[]; + +/* result=1 if a is divisible by one of the first PRIME_SIZE primes */ +TOMMATH_STORAGE_CLASS int mp_prime_is_divisible(mp_int *a, int *result); + +/* performs one Fermat test of "a" using base "b". + * Sets result to 0 if composite or 1 if probable prime + */ +TOMMATH_STORAGE_CLASS int mp_prime_fermat(mp_int *a, mp_int *b, int *result); + +/* performs one Miller-Rabin test of "a" using base "b". + * Sets result to 0 if composite or 1 if probable prime + */ +TOMMATH_STORAGE_CLASS int mp_prime_miller_rabin(mp_int *a, mp_int *b, int *result); + +/* This gives [for a given bit size] the number of trials required + * such that Miller-Rabin gives a prob of failure lower than 2^-96 + */ +TOMMATH_STORAGE_CLASS int mp_prime_rabin_miller_trials(int size); + +/* performs t rounds of Miller-Rabin on "a" using the first + * t prime bases. Also performs an initial sieve of trial + * division. Determines if "a" is prime with probability + * of error no more than (1/4)**t. + * + * Sets result to 1 if probably prime, 0 otherwise + */ +TOMMATH_STORAGE_CLASS int mp_prime_is_prime(mp_int *a, int t, int *result); + +/* finds the next prime after the number "a" using "t" trials + * of Miller-Rabin. + * + * bbs_style = 1 means the prime must be congruent to 3 mod 4 + */ +TOMMATH_STORAGE_CLASS int mp_prime_next_prime(mp_int *a, int t, int bbs_style); + +/* makes a truly random prime of a given size (bytes), + * call with bbs = 1 if you want it to be congruent to 3 mod 4 + * + * You have to supply a callback which fills in a buffer with random bytes. "dat" is a parameter you can + * have passed to the callback (e.g. a state or something). This function doesn't use "dat" itself + * so it can be NULL + * + * The prime generated will be larger than 2^(8*size). + */ +#define mp_prime_random(a, t, size, bbs, cb, dat) mp_prime_random_ex(a, t, ((size) * 8) + 1, (bbs==1)?LTM_PRIME_BBS:0, cb, dat) + +/* makes a truly random prime of a given size (bits), + * + * Flags are as follows: + * + * LTM_PRIME_BBS - make prime congruent to 3 mod 4 + * LTM_PRIME_SAFE - make sure (p-1)/2 is prime as well (implies LTM_PRIME_BBS) + * LTM_PRIME_2MSB_OFF - make the 2nd highest bit zero + * LTM_PRIME_2MSB_ON - make the 2nd highest bit one + * + * You have to supply a callback which fills in a buffer with random bytes. "dat" is a parameter you can + * have passed to the callback (e.g. a state or something). This function doesn't use "dat" itself + * so it can be NULL + * + */ +TOMMATH_STORAGE_CLASS int mp_prime_random_ex(mp_int *a, int t, int size, int flags, ltm_prime_callback cb, void *dat); + +/* ---> radix conversion <--- */ +TOMMATH_STORAGE_CLASS int mp_count_bits(mp_int *a); + +TOMMATH_STORAGE_CLASS int mp_unsigned_bin_size(mp_int *a); +TOMMATH_STORAGE_CLASS int mp_read_unsigned_bin(mp_int *a, unsigned char *b, int c); +TOMMATH_STORAGE_CLASS int mp_to_unsigned_bin(mp_int *a, unsigned char *b); + +TOMMATH_STORAGE_CLASS int mp_signed_bin_size(mp_int *a); +TOMMATH_STORAGE_CLASS int mp_read_signed_bin(mp_int *a, unsigned char *b, int c); +TOMMATH_STORAGE_CLASS int mp_to_signed_bin(mp_int *a, unsigned char *b); + +TOMMATH_STORAGE_CLASS int mp_read_radix(mp_int *a, const char *str, int radix); +TOMMATH_STORAGE_CLASS int mp_toradix(mp_int *a, char *str, int radix); +TOMMATH_STORAGE_CLASS int mp_toradix_n(mp_int * a, char *str, int radix, int maxlen); +TOMMATH_STORAGE_CLASS int mp_radix_size(mp_int *a, int radix, int *size); + +TOMMATH_STORAGE_CLASS int mp_fread(mp_int *a, int radix, FILE *stream); +TOMMATH_STORAGE_CLASS int mp_fwrite(mp_int *a, int radix, FILE *stream); + +#define mp_read_raw(mp, str, len) mp_read_signed_bin((mp), (str), (len)) +#define mp_raw_size(mp) mp_signed_bin_size(mp) +#define mp_toraw(mp, str) mp_to_signed_bin((mp), (str)) +#define mp_read_mag(mp, str, len) mp_read_unsigned_bin((mp), (str), (len)) +#define mp_mag_size(mp) mp_unsigned_bin_size(mp) +#define mp_tomag(mp, str) mp_to_unsigned_bin((mp), (str)) + +#define mp_tobinary(M, S) mp_toradix((M), (S), 2) +#define mp_tooctal(M, S) mp_toradix((M), (S), 8) +#define mp_todecimal(M, S) mp_toradix((M), (S), 10) +#define mp_tohex(M, S) mp_toradix((M), (S), 16) + +/* lowlevel functions, do not call! */ +TOMMATH_STORAGE_CLASS int s_mp_add(mp_int *a, mp_int *b, mp_int *c); +TOMMATH_STORAGE_CLASS int s_mp_sub(mp_int *a, mp_int *b, mp_int *c); +#define s_mp_mul(a, b, c) s_mp_mul_digs(a, b, c, (a)->used + (b)->used + 1) +TOMMATH_STORAGE_CLASS int fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs); +TOMMATH_STORAGE_CLASS int s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs); +TOMMATH_STORAGE_CLASS int fast_s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs); +TOMMATH_STORAGE_CLASS int s_mp_mul_high_digs(mp_int *a, mp_int *b, mp_int *c, int digs); +TOMMATH_STORAGE_CLASS int fast_s_mp_sqr(mp_int *a, mp_int *b); +TOMMATH_STORAGE_CLASS int s_mp_sqr(mp_int *a, mp_int *b); +TOMMATH_STORAGE_CLASS int mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c); +TOMMATH_STORAGE_CLASS int mp_toom_mul(mp_int *a, mp_int *b, mp_int *c); +TOMMATH_STORAGE_CLASS int mp_karatsuba_sqr(mp_int *a, mp_int *b); +TOMMATH_STORAGE_CLASS int mp_toom_sqr(mp_int *a, mp_int *b); +TOMMATH_STORAGE_CLASS int fast_mp_invmod(mp_int *a, mp_int *b, mp_int *c); +TOMMATH_STORAGE_CLASS int mp_invmod_slow (mp_int * a, mp_int * b, mp_int * c); +TOMMATH_STORAGE_CLASS int fast_mp_montgomery_reduce(mp_int *a, mp_int *m, mp_digit mp); +TOMMATH_STORAGE_CLASS int mp_exptmod_fast(mp_int *G, mp_int *X, mp_int *P, mp_int *Y, int mode); +TOMMATH_STORAGE_CLASS int s_mp_exptmod (mp_int * G, mp_int * X, mp_int * P, mp_int * Y); +TOMMATH_STORAGE_CLASS void bn_reverse(unsigned char *s, int len); + +extern const char *mp_s_rmap; + +#ifdef __cplusplus + } +#endif + +#endif + + |