From d94450a5cfe4e5e7117cdc87e20d906f843e9990 Mon Sep 17 00:00:00 2001 From: joye Date: Tue, 8 Jul 2014 19:55:45 +0000 Subject: *** empty log message *** --- src/bltGrText.C | 2 - src/bltNsUtil.C | 13 +- src/bltNsUtil.h | 31 +- src/bltOp.C | 4 +- src/bltOp.h | 23 +- src/bltParse.C | 12 +- src/bltParse.h | 25 +- src/bltSwitch.C | 6 +- src/bltSwitch.h | 150 ++++----- src/bltVecCmd.C | 902 ++++++++++++------------------------------------------- src/bltVecInt.h | 246 +++++++-------- src/bltVecMath.C | 71 ++--- src/bltVector.C | 224 +++++++------- src/bltVector.h | 37 ++- 14 files changed, 603 insertions(+), 1143 deletions(-) diff --git a/src/bltGrText.C b/src/bltGrText.C index 8e64606..62fd96a 100644 --- a/src/bltGrText.C +++ b/src/bltGrText.C @@ -29,11 +29,9 @@ #include -//extern "C" { #include #include #include -//}; #include "bltGrText.h" #include "bltGraph.h" diff --git a/src/bltNsUtil.C b/src/bltNsUtil.C index 97f132d..10918ac 100644 --- a/src/bltNsUtil.C +++ b/src/bltNsUtil.C @@ -29,15 +29,18 @@ #include #include + #include "bltNsUtil.h" -Tcl_Namespace* Blt_GetCommandNamespace(Tcl_Command cmdToken) +using namespace Blt; + +Tcl_Namespace* Blt::GetCommandNamespace(Tcl_Command cmdToken) { Command* cmdPtr = (Command*)cmdToken; return (Tcl_Namespace *)cmdPtr->nsPtr; } -int Blt_ParseObjectName(Tcl_Interp* interp, const char *path, +int Blt::ParseObjectName(Tcl_Interp* interp, const char *path, Blt_ObjectName *namePtr, unsigned int flags) { namePtr->nsPtr = NULL; @@ -78,7 +81,7 @@ int Blt_ParseObjectName(Tcl_Interp* interp, const char *path, return 1; } -char* Blt_MakeQualifiedName(Blt_ObjectName *namePtr, Tcl_DString *resultPtr) +char* Blt::MakeQualifiedName(Blt_ObjectName *namePtr, Tcl_DString *resultPtr) { Tcl_DStringInit(resultPtr); if ((namePtr->nsPtr->fullName[0] != ':') || @@ -103,10 +106,10 @@ static Tcl_Namespace* NamespaceOfVariable(Var *varPtr) return NULL; } -Tcl_Namespace* Blt_GetVariableNamespace(Tcl_Interp* interp, const char *path) +Tcl_Namespace* Blt::GetVariableNamespace(Tcl_Interp* interp, const char *path) { Blt_ObjectName objName; - if (!Blt_ParseObjectName(interp, path, &objName, BLT_NO_DEFAULT_NS)) + if (!ParseObjectName(interp, path, &objName, BLT_NO_DEFAULT_NS)) return NULL; if (objName.nsPtr == NULL) { diff --git a/src/bltNsUtil.h b/src/bltNsUtil.h index 5b9bb28..950a48a 100644 --- a/src/bltNsUtil.h +++ b/src/bltNsUtil.h @@ -38,26 +38,27 @@ #define NS_SEARCH_GLOBAL (1<<1) #define NS_SEARCH_BOTH (NS_SEARCH_GLOBAL | NS_SEARCH_CURRENT) -typedef struct { - const char *name; - Tcl_Namespace *nsPtr; -} Blt_ObjectName; - #define BLT_NO_DEFAULT_NS (1<<0) #define BLT_NO_ERROR_MSG (1<<1) -/* - * Auxillary procedures - */ -extern Tcl_Namespace *Blt_GetVariableNamespace(Tcl_Interp* interp, - const char *varName); +namespace Blt { + + typedef struct { + const char *name; + Tcl_Namespace *nsPtr; + } Blt_ObjectName; + + extern Tcl_Namespace* GetVariableNamespace(Tcl_Interp* interp, + const char *varName); -extern Tcl_Namespace *Blt_GetCommandNamespace(Tcl_Command cmdToken); + extern Tcl_Namespace* GetCommandNamespace(Tcl_Command cmdToken); -extern int Blt_ParseObjectName(Tcl_Interp* interp, const char *name, - Blt_ObjectName *objNamePtr, unsigned int flags); + extern int ParseObjectName(Tcl_Interp* interp, const char *name, + Blt_ObjectName *objNamePtr, + unsigned int flags); -extern char *Blt_MakeQualifiedName(Blt_ObjectName *objNamePtr, - Tcl_DString *resultPtr); + extern char* MakeQualifiedName(Blt_ObjectName *objNamePtr, + Tcl_DString *resultPtr); +}; #endif /* BLT_NS_UTIL_H */ diff --git a/src/bltOp.C b/src/bltOp.C index b4a9d7e..d52c133 100644 --- a/src/bltOp.C +++ b/src/bltOp.C @@ -31,6 +31,8 @@ #include "bltOp.h" +using namespace Blt; + static int BinaryOpSearch(Blt_OpSpec *specs, int nSpecs, const char *string, int length) { @@ -90,7 +92,7 @@ static int LinearOpSearch(Blt_OpSpec *specs, int nSpecs, const char *string, return last; /* Op found. */ } -void* Blt_GetOpFromObj(Tcl_Interp* interp, int nSpecs, Blt_OpSpec *specs, +void* Blt::GetOpFromObj(Tcl_Interp* interp, int nSpecs, Blt_OpSpec *specs, int operPos, int objc, Tcl_Obj* const objv[], int flags) { diff --git a/src/bltOp.h b/src/bltOp.h index 2311714..fc9ffb7 100644 --- a/src/bltOp.h +++ b/src/bltOp.h @@ -35,30 +35,33 @@ #include -typedef struct { +#define BLT_OP_BINARY_SEARCH 0 +#define BLT_OP_LINEAR_SEARCH 1 + +namespace Blt { + + typedef struct { const char *name; /* Name of operation */ int minChars; /* Minimum # characters to disambiguate */ void *proc; int minArgs; /* Minimum # args required */ int maxArgs; /* Maximum # args required */ const char *usage; /* Usage message */ -} Blt_OpSpec; + } Blt_OpSpec; -typedef enum { + typedef enum { BLT_OP_ARG0, /* Op is the first argument. */ BLT_OP_ARG1, /* Op is the second argument. */ BLT_OP_ARG2, /* Op is the third argument. */ BLT_OP_ARG3, /* Op is the fourth argument. */ BLT_OP_ARG4 /* Op is the fifth argument. */ -} Blt_OpIndex; - -#define BLT_OP_BINARY_SEARCH 0 -#define BLT_OP_LINEAR_SEARCH 1 + } Blt_OpIndex; -void *Blt_GetOpFromObj(Tcl_Interp* interp, int nSpecs, - Blt_OpSpec *specs, int operPos, int objc, - Tcl_Obj* const objv[], int flags); + void *GetOpFromObj(Tcl_Interp* interp, int nSpecs, + Blt_OpSpec *specs, int operPos, int objc, + Tcl_Obj* const objv[], int flags); +}; #endif diff --git a/src/bltParse.C b/src/bltParse.C index 14fb262..111a6bc 100644 --- a/src/bltParse.C +++ b/src/bltParse.C @@ -35,6 +35,8 @@ using namespace std; #include "bltParse.h" +using namespace Blt; + /* * A table used to classify input characters to assist in parsing * TCL commands. The table should be indexed with a signed character @@ -184,14 +186,14 @@ static unsigned char tclTypeTable[] = #define CHAR_TYPE(src,last) \ (((src)==(last))?TCL_COMMAND_END:(tclTypeTable+128)[(int)*(src)]) -int Blt_ParseNestedCmd(Tcl_Interp* interp, const char *string, +int Blt::ParseNestedCmd(Tcl_Interp* interp, const char *string, int flags, const char **termPtr, ParseValue *parsePtr) { return TCL_ERROR; } -int Blt_ParseBraces(Tcl_Interp* interp, const char *string, +int Blt::ParseBraces(Tcl_Interp* interp, const char *string, const char **termPtr, ParseValue *parsePtr) { int level; @@ -273,7 +275,7 @@ int Blt_ParseBraces(Tcl_Interp* interp, const char *string, return TCL_OK; } -void Blt_ExpandParseValue(ParseValue *parsePtr, int needed) +void Blt::ExpandParseValue(ParseValue *parsePtr, int needed) { /* @@ -303,7 +305,7 @@ void Blt_ExpandParseValue(ParseValue *parsePtr, int needed) parsePtr->clientData = (ClientData)1; } -int Blt_ParseQuotes(Tcl_Interp* interp, const char *string, int termChar, +int Blt::ParseQuotes(Tcl_Interp* interp, const char *string, int termChar, int flags, const char **termPtr, ParseValue *parsePtr) { const char *src; @@ -356,7 +358,7 @@ int Blt_ParseQuotes(Tcl_Interp* interp, const char *string, int termChar, int result; parsePtr->next = dest; - result = Blt_ParseNestedCmd(interp, src, flags, termPtr, parsePtr); + result = ParseNestedCmd(interp, src, flags, termPtr, parsePtr); if (result != TCL_OK) { return result; } diff --git a/src/bltParse.h b/src/bltParse.h index b9cb298..ee215a5 100644 --- a/src/bltParse.h +++ b/src/bltParse.h @@ -30,21 +30,26 @@ #ifndef _BLT_PARSE_H #define _BLT_PARSE_H -typedef struct _ParseValue ParseValue; -struct _ParseValue { +namespace Blt { + + typedef struct _ParseValue ParseValue; + struct _ParseValue { char *buffer; char *next; char *end; void (*expandProc)(ParseValue *pvPtr, int needed); ClientData clientData; -}; + }; -extern int Blt_ParseBraces(Tcl_Interp* interp, const char *string, - const char **termPtr, ParseValue *pvPtr); -extern int Blt_ParseNestedCmd(Tcl_Interp* interp, const char *string, - int flags, const char **termPtr, ParseValue *pvPtr); -extern int Blt_ParseQuotes(Tcl_Interp* interp, const char *string, - int termChar, int flags, const char **termPtr, ParseValue * pvPtr); -extern void Blt_ExpandParseValue(ParseValue *pvPtr, int needed); + extern int ParseBraces(Tcl_Interp* interp, const char *string, + const char **termPtr, ParseValue *pvPtr); + extern int ParseNestedCmd(Tcl_Interp* interp, const char *string, + int flags, const char **termPtr, + ParseValue *pvPtr); + extern int ParseQuotes(Tcl_Interp* interp, const char *string, + int termChar, int flags, const char **termPtr, + ParseValue * pvPtr); + extern void ExpandParseValue(ParseValue *pvPtr, int needed); +} #endif diff --git a/src/bltSwitch.C b/src/bltSwitch.C index bb4a62f..291d232 100644 --- a/src/bltSwitch.C +++ b/src/bltSwitch.C @@ -39,6 +39,8 @@ using namespace std; #include "bltSwitch.h" +using namespace Blt; + #define COUNT_NNEG 0 #define COUNT_POS 1 #define COUNT_ANY 2 @@ -295,7 +297,7 @@ static int DoSwitch(Tcl_Interp* interp, Blt_SwitchSpec *sp, return TCL_OK; } -int Blt_ParseSwitches(Tcl_Interp* interp, Blt_SwitchSpec *specs, +int Blt::ParseSwitches(Tcl_Interp* interp, Blt_SwitchSpec *specs, int objc, Tcl_Obj* const objv[], void *record, int flags) { @@ -372,7 +374,7 @@ int Blt_ParseSwitches(Tcl_Interp* interp, Blt_SwitchSpec *specs, return count; } -void Blt_FreeSwitches(Blt_SwitchSpec *specs, void *record, int needFlags) +void Blt::FreeSwitches(Blt_SwitchSpec *specs, void *record, int needFlags) { for (Blt_SwitchSpec *sp = specs; sp->type != BLT_SWITCH_END; sp++) { if ((sp->flags & needFlags) == needFlags) { diff --git a/src/bltSwitch.h b/src/bltSwitch.h index dab5e37..eed7b31 100644 --- a/src/bltSwitch.h +++ b/src/bltSwitch.h @@ -33,95 +33,97 @@ #ifndef BLT_SWITCH_H #define BLT_SWITCH_H -# include +#include -typedef int (Blt_SwitchParseProc)(ClientData clientData, Tcl_Interp* interp, - const char *switchName, Tcl_Obj *valueObjPtr, char *record, int offset, - int flags); -typedef void (Blt_SwitchFreeProc)(char *record, int offset, int flags); +#define BLT_SWITCH_DEFAULTS (0) +#define BLT_SWITCH_ARGV_PARTIAL (1<<1) +#define BLT_SWITCH_OBJV_PARTIAL (1<<1) -typedef struct { - Blt_SwitchParseProc *parseProc; /* Procedure to parse a switch - * value and store it in its * - * converted form in the data * - * record. */ + /* + * Possible flag values for Blt_SwitchSpec structures. Any bits at or + * above BLT_SWITCH_USER_BIT may be used by clients for selecting + * certain entries. + */ +#define BLT_SWITCH_NULL_OK (1<<0) +#define BLT_SWITCH_DONT_SET_DEFAULT (1<<3) +#define BLT_SWITCH_SPECIFIED (1<<4) +#define BLT_SWITCH_USER_BIT (1<<8) - Blt_SwitchFreeProc *freeProc; /* Procedure to free a switch. */ +namespace Blt { - ClientData clientData; /* Arbitrary one-word value used by - * switch parser, passed to - * parseProc. */ -} Blt_SwitchCustom; + typedef int (Blt_SwitchParseProc)(ClientData clientData, Tcl_Interp* interp, + const char *switchName, + Tcl_Obj *valueObjPtr, char *record, + int offset, int flags); + typedef void (Blt_SwitchFreeProc)(char *record, int offset, int flags); + typedef struct { + Blt_SwitchParseProc *parseProc; /* Procedure to parse a switch + * value and store it in its * + * converted form in the data * + * record. */ -/* - * Type values for Blt_SwitchSpec structures. See the user - * documentation for details. - */ -typedef enum { - BLT_SWITCH_BOOLEAN, - BLT_SWITCH_DOUBLE, - BLT_SWITCH_BITMASK, - BLT_SWITCH_BITMASK_INVERT, - BLT_SWITCH_FLOAT, - BLT_SWITCH_INT, - BLT_SWITCH_INT_NNEG, - BLT_SWITCH_INT_POS, - BLT_SWITCH_LIST, - BLT_SWITCH_LONG, - BLT_SWITCH_LONG_NNEG, - BLT_SWITCH_LONG_POS, - BLT_SWITCH_OBJ, - BLT_SWITCH_STRING, - BLT_SWITCH_VALUE, - BLT_SWITCH_CUSTOM, - BLT_SWITCH_END -} Blt_SwitchTypes; - - -typedef struct { - Blt_SwitchTypes type; /* Type of option, such as - * BLT_SWITCH_COLOR; see definitions - * below. Last option in table must - * have type BLT_SWITCH_END. */ - - const char *switchName; /* Switch used to specify option in + Blt_SwitchFreeProc *freeProc; /* Procedure to free a switch. */ + + ClientData clientData; /* Arbitrary one-word value used by + * switch parser, passed to + * parseProc. */ + } Blt_SwitchCustom; + + /* + * Type values for Blt_SwitchSpec structures. See the user + * documentation for details. + */ + typedef enum { + BLT_SWITCH_BOOLEAN, + BLT_SWITCH_DOUBLE, + BLT_SWITCH_BITMASK, + BLT_SWITCH_BITMASK_INVERT, + BLT_SWITCH_FLOAT, + BLT_SWITCH_INT, + BLT_SWITCH_INT_NNEG, + BLT_SWITCH_INT_POS, + BLT_SWITCH_LIST, + BLT_SWITCH_LONG, + BLT_SWITCH_LONG_NNEG, + BLT_SWITCH_LONG_POS, + BLT_SWITCH_OBJ, + BLT_SWITCH_STRING, + BLT_SWITCH_VALUE, + BLT_SWITCH_CUSTOM, + BLT_SWITCH_END + } Blt_SwitchTypes; + + typedef struct { + Blt_SwitchTypes type; /* Type of option, such as + * BLT_SWITCH_COLOR; see definitions + * below. Last option in table must + * have type BLT_SWITCH_END. */ + + const char *switchName; /* Switch used to specify option in * argv. NULL means this spec is part * of a group. */ - const char *help; /* Help string. */ - int offset; /* Where in widget record to store + const char *help; /* Help string. */ + int offset; /* Where in widget record to store * value; use Blt_Offset macro to * generate values for this. */ - int flags; /* Any combination of the values + int flags; /* Any combination of the values * defined below. */ - unsigned int mask; - - Blt_SwitchCustom *customPtr; /* If type is BLT_SWITCH_CUSTOM then - * this is a pointer to info about how - * to parse and print the option. - * Otherwise it is irrelevant. */ -} Blt_SwitchSpec; - -#define BLT_SWITCH_DEFAULTS (0) -#define BLT_SWITCH_ARGV_PARTIAL (1<<1) -#define BLT_SWITCH_OBJV_PARTIAL (1<<1) - -/* - * Possible flag values for Blt_SwitchSpec structures. Any bits at or - * above BLT_SWITCH_USER_BIT may be used by clients for selecting - * certain entries. - */ -#define BLT_SWITCH_NULL_OK (1<<0) -#define BLT_SWITCH_DONT_SET_DEFAULT (1<<3) -#define BLT_SWITCH_SPECIFIED (1<<4) -#define BLT_SWITCH_USER_BIT (1<<8) + unsigned int mask; -extern int Blt_ParseSwitches(Tcl_Interp* interp, Blt_SwitchSpec *specPtr, - int objc, Tcl_Obj *const *objv, void *rec, int flags); + Blt_SwitchCustom *customPtr; /* If type is BLT_SWITCH_CUSTOM then + * this is a pointer to info about how + * to parse and print the option. + * Otherwise it is irrelevant. */ + } Blt_SwitchSpec; -extern void Blt_FreeSwitches(Blt_SwitchSpec *specs, void *rec, int flags); + extern int ParseSwitches(Tcl_Interp* interp, Blt_SwitchSpec *specPtr, + int objc, Tcl_Obj *const *objv, void *rec, + int flags); + extern void FreeSwitches(Blt_SwitchSpec *specs, void *rec, int flags); +}; #endif /* BLT_SWITCH_H */ diff --git a/src/bltVecCmd.C b/src/bltVecCmd.C index dda383e..67562e5 100644 --- a/src/bltVecCmd.C +++ b/src/bltVecCmd.C @@ -57,6 +57,8 @@ #include "bltNsUtil.h" #include "bltSwitch.h" +using namespace Blt; + extern int Blt_SimplifyLine (Point2d *origPts, int low, int high, double tolerance, int *indices); @@ -162,28 +164,9 @@ static int Blt_ExprDoubleFromObj(Tcl_Interp* interp, Tcl_Obj *objPtr, double *va return TCL_ERROR; } -/* - *--------------------------------------------------------------------------- - * - * ObjToFFTVector -- - * - * Convert a string representing a vector into its vector structure. - * - * Results: - * The return value is a standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -ObjToFFTVector( - ClientData clientData, /* Not used. */ - Tcl_Interp* interp, /* Interpreter to send results back to */ - const char *switchName, /* Not used. */ - Tcl_Obj *objPtr, /* Name of vector. */ - char *record, /* Structure record */ - int offset, /* Offset to field in structure */ - int flags) /* Not used. */ +static int ObjToFFTVector(ClientData clientData, Tcl_Interp* interp, + const char *switchName, Tcl_Obj *objPtr, + char *record, int offset, int flags) { FFTData *dataPtr = (FFTData *)record; Vector *vPtr; @@ -192,7 +175,7 @@ ObjToFFTVector( char *string; string = Tcl_GetString(objPtr); - vPtr = Blt_Vec_Create(dataPtr->dataPtr, string, string, string, &isNew); + vPtr = Vec_Create(dataPtr->dataPtr, string, string, string, &isNew); if (vPtr == NULL) { return TCL_ERROR; } @@ -200,35 +183,15 @@ ObjToFFTVector( return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * ObjToIndex -- - * - * Convert a string representing a vector into its vector structure. - * - * Results: - * The return value is a standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -ObjToIndex( - ClientData clientData, /* Contains the vector in question to verify - * its length. */ - Tcl_Interp* interp, /* Interpreter to send results back to */ - const char *switchName, /* Not used. */ - Tcl_Obj *objPtr, /* Name of vector. */ - char *record, /* Structure record */ - int offset, /* Offset to field in structure */ - int flags) /* Not used. */ +static int ObjToIndex(ClientData clientData, Tcl_Interp* interp, + const char *switchName, Tcl_Obj *objPtr, char *record, + int offset, int flags) { Vector *vPtr = (Vector*)clientData; int *indexPtr = (int *)(record + offset); int index; - if (Blt_Vec_GetIndex(interp, vPtr, Tcl_GetString(objPtr), &index, + if (Vec_GetIndex(interp, vPtr, Tcl_GetString(objPtr), &index, INDEX_CHECK, (Blt_VectorIndexProc **)NULL) != TCL_OK) { return TCL_ERROR; } @@ -237,8 +200,7 @@ ObjToIndex( } -static Tcl_Obj * -GetValues(Vector *vPtr, int first, int last) +static Tcl_Obj* GetValues(Vector *vPtr, int first, int last) { Tcl_Obj *listObjPtr; double *vp, *vend; @@ -252,8 +214,7 @@ GetValues(Vector *vPtr, int first, int last) return listObjPtr; } -static void -ReplicateValue(Vector *vPtr, int first, int last, double value) +static void ReplicateValue(Vector *vPtr, int first, int last, double value) { double *vp, *vend; @@ -264,19 +225,19 @@ ReplicateValue(Vector *vPtr, int first, int last, double value) vPtr->notifyFlags |= UPDATE_RANGE; } -static int -CopyList(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int CopyList(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int i; - if (Blt_Vec_SetLength(interp, vPtr, objc) != TCL_OK) { + if (Vec_SetLength(interp, vPtr, objc) != TCL_OK) { return TCL_ERROR; } for (i = 0; i < objc; i++) { double value; if (Blt_ExprDoubleFromObj(interp, objv[i], &value) != TCL_OK) { - Blt_Vec_SetLength(interp, vPtr, i); + Vec_SetLength(interp, vPtr, i); return TCL_ERROR; } vPtr->valueArr[i] = value; @@ -284,15 +245,14 @@ CopyList(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -static int -AppendVector(Vector *destPtr, Vector *srcPtr) +static int AppendVector(Vector *destPtr, Vector *srcPtr) { size_t nBytes; size_t oldSize, newSize; oldSize = destPtr->length; newSize = oldSize + srcPtr->last - srcPtr->first + 1; - if (Blt_Vec_ChangeLength(destPtr->interp, destPtr, newSize) != TCL_OK) { + if (Vec_ChangeLength(destPtr->interp, destPtr, newSize) != TCL_OK) { return TCL_ERROR; } nBytes = (newSize - oldSize) * sizeof(double); @@ -302,8 +262,7 @@ AppendVector(Vector *destPtr, Vector *srcPtr) return TCL_OK; } -static int -AppendList(Vector *vPtr, int objc, Tcl_Obj* const objv[]) +static int AppendList(Vector *vPtr, int objc, Tcl_Obj* const objv[]) { Tcl_Interp* interp = vPtr->interp; int count; @@ -312,13 +271,13 @@ AppendList(Vector *vPtr, int objc, Tcl_Obj* const objv[]) int oldSize; oldSize = vPtr->length; - if (Blt_Vec_ChangeLength(interp, vPtr, vPtr->length + objc) != TCL_OK) { + if (Vec_ChangeLength(interp, vPtr, vPtr->length + objc) != TCL_OK) { return TCL_ERROR; } count = oldSize; for (i = 0; i < objc; i++) { if (Blt_ExprDoubleFromObj(interp, objv[i], &value) != TCL_OK) { - Blt_Vec_ChangeLength(interp, vPtr, count); + Vec_ChangeLength(interp, vPtr, count); return TCL_ERROR; } vPtr->valueArr[count++] = value; @@ -327,35 +286,17 @@ AppendList(Vector *vPtr, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* Vector instance option commands */ +// Vector instance option commands -/* - *--------------------------------------------------------------------------- - * - * AppendOp -- - * - * Appends one of more TCL lists of values, or vector objects onto the - * end of the current vector object. - * - * Results: - * A standard TCL result. If a current vector can't be created, - * resized, any of the named vectors can't be found, or one of lists of - * values is invalid, TCL_ERROR is returned. - * - * Side Effects: - * Clients of current vector will be notified of the change. - * - *--------------------------------------------------------------------------- - */ -static int -AppendOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int AppendOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int i; int result; Vector *v2Ptr; for (i = 2; i < objc; i++) { - v2Ptr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, + v2Ptr = Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, Tcl_GetString(objv[i]), (const char **)NULL, NS_SEARCH_BOTH); if (v2Ptr != NULL) { result = AppendVector(vPtr, v2Ptr); @@ -375,59 +316,22 @@ AppendOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) } if (objc > 2) { if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * ClearOp -- - * - * Deletes all the accumulated array indices for the TCL array associated - * will the vector. This routine can be used to free excess memory from - * a large vector. - * - * Results: - * Always returns TCL_OK. - * - * Side Effects: - * Memory used for the entries of the TCL array variable is freed. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -ClearOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int ClearOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * DeleteOp -- - * - * Deletes the given indices from the vector. If no indices are provided - * the entire vector is deleted. - * - * Results: - * A standard TCL result. If any of the given indices is invalid, - * interp->result will an error message and TCL_ERROR is returned. - * - * Side Effects: - * The clients of the vector will be notified of the vector - * deletions. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -DeleteOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int DeleteOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { unsigned char *unsetArr; int i, j; @@ -436,7 +340,7 @@ DeleteOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) /* FIXME: Don't delete vector with no indices. */ if (objc == 2) { - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); return TCL_OK; } @@ -449,7 +353,7 @@ DeleteOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) for (i = 2; i < objc; i++) { string = Tcl_GetString(objv[i]); - if (Blt_Vec_GetIndexRange(interp, vPtr, string, + if (Vec_GetIndexRange(interp, vPtr, string, (INDEX_COLON | INDEX_CHECK), (Blt_VectorIndexProc **) NULL) != TCL_OK) { free(unsetArr); @@ -472,31 +376,14 @@ DeleteOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) free(unsetArr); vPtr->length = count; if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * DupOp -- - * - * Creates one or more duplicates of the vector object. - * - * Results: - * A standard TCL result. If a new vector can't be created, - * or and existing vector resized, TCL_ERROR is returned. - * - * Side Effects: - * Clients of existing vectors will be notified of the change. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -DupOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int DupOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int i; @@ -506,33 +393,28 @@ DupOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) int isNew; name = Tcl_GetString(objv[i]); - v2Ptr = Blt_Vec_Create(vPtr->dataPtr, name, name, name, &isNew); + v2Ptr = Vec_Create(vPtr->dataPtr, name, name, name, &isNew); if (v2Ptr == NULL) { return TCL_ERROR; } if (v2Ptr == vPtr) { continue; } - if (Blt_Vec_Duplicate(v2Ptr, vPtr) != TCL_OK) { + if (Vec_Duplicate(v2Ptr, vPtr) != TCL_OK) { return TCL_ERROR; } if (!isNew) { if (v2Ptr->flush) { - Blt_Vec_FlushCache(v2Ptr); + Vec_FlushCache(v2Ptr); } - Blt_Vec_UpdateClients(v2Ptr); + Vec_UpdateClients(v2Ptr); } } return TCL_OK; } - -/* spinellia@acm.org START */ - -/* fft implementation */ -/*ARGSUSED*/ -static int -FFTOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int FFTOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { Vector *v2Ptr = NULL; int isNew; @@ -543,7 +425,7 @@ FFTOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) data.delta = 1.0; realVecName = Tcl_GetString(objv[2]); - v2Ptr = Blt_Vec_Create(vPtr->dataPtr, realVecName, realVecName, + v2Ptr = Vec_Create(vPtr->dataPtr, realVecName, realVecName, realVecName, &isNew); if (v2Ptr == NULL) { return TCL_ERROR; @@ -553,39 +435,38 @@ FFTOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) " can't be the same as the source", (char *)NULL); return TCL_ERROR; } - if (Blt_ParseSwitches(interp, fftSwitches, objc - 3, objv + 3, &data, + if (ParseSwitches(interp, fftSwitches, objc - 3, objv + 3, &data, BLT_SWITCH_DEFAULTS) < 0) { return TCL_ERROR; } - if (Blt_Vec_FFT(interp, v2Ptr, data.imagPtr, data.freqPtr, data.delta, + if (Vec_FFT(interp, v2Ptr, data.imagPtr, data.freqPtr, data.delta, data.mask, vPtr) != TCL_OK) { return TCL_ERROR; } /* Update bookkeeping. */ if (!isNew) { if (v2Ptr->flush) { - Blt_Vec_FlushCache(v2Ptr); + Vec_FlushCache(v2Ptr); } - Blt_Vec_UpdateClients(v2Ptr); + Vec_UpdateClients(v2Ptr); } if (data.imagPtr != NULL) { if (data.imagPtr->flush) { - Blt_Vec_FlushCache(data.imagPtr); + Vec_FlushCache(data.imagPtr); } - Blt_Vec_UpdateClients(data.imagPtr); + Vec_UpdateClients(data.imagPtr); } if (data.freqPtr != NULL) { if (data.freqPtr->flush) { - Blt_Vec_FlushCache(data.freqPtr); + Vec_FlushCache(data.freqPtr); } - Blt_Vec_UpdateClients(data.freqPtr); + Vec_UpdateClients(data.freqPtr); } return TCL_OK; } -/*ARGSUSED*/ -static int -InverseFFTOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int InverseFFTOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int isNew; char *name; @@ -594,54 +475,38 @@ InverseFFTOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) Vector *destImagPtr; name = Tcl_GetString(objv[2]); - if (Blt_Vec_LookupName(vPtr->dataPtr, name, &srcImagPtr) != TCL_OK ) { + if (Vec_LookupName(vPtr->dataPtr, name, &srcImagPtr) != TCL_OK ) { return TCL_ERROR; } name = Tcl_GetString(objv[3]); - destRealPtr = Blt_Vec_Create(vPtr->dataPtr, name, name, name, &isNew); + destRealPtr = Vec_Create(vPtr->dataPtr, name, name, name, &isNew); name = Tcl_GetString(objv[4]); - destImagPtr = Blt_Vec_Create(vPtr->dataPtr, name, name, name, &isNew); + destImagPtr = Vec_Create(vPtr->dataPtr, name, name, name, &isNew); - if (Blt_Vec_InverseFFT(interp, srcImagPtr, destRealPtr, destImagPtr, vPtr) + if (Vec_InverseFFT(interp, srcImagPtr, destRealPtr, destImagPtr, vPtr) != TCL_OK ){ return TCL_ERROR; } if (destRealPtr->flush) { - Blt_Vec_FlushCache(destRealPtr); + Vec_FlushCache(destRealPtr); } - Blt_Vec_UpdateClients(destRealPtr); + Vec_UpdateClients(destRealPtr); if (destImagPtr->flush) { - Blt_Vec_FlushCache(destImagPtr); + Vec_FlushCache(destImagPtr); } - Blt_Vec_UpdateClients(destImagPtr); + Vec_UpdateClients(destImagPtr); return TCL_OK; } - -/* - *--------------------------------------------------------------------------- - * - * IndexOp -- - * - * Sets or reads the value of the index. This simulates what the - * vector's variable does. - * - * Results: - * A standard TCL result. If the index is invalid, - * interp->result will an error message and TCL_ERROR is returned. - * Otherwise interp->result will contain the values. - * - *--------------------------------------------------------------------------- - */ -static int -IndexOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int IndexOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int first, last; char *string; string = Tcl_GetString(objv[2]); - if (Blt_Vec_GetIndexRange(interp, vPtr, string, INDEX_ALL_FLAGS, + if (Vec_GetIndexRange(interp, vPtr, string, INDEX_ALL_FLAGS, (Blt_VectorIndexProc **) NULL) != TCL_OK) { return TCL_ERROR; } @@ -669,7 +534,7 @@ IndexOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_ERROR; } if (first == vPtr->length) { - if (Blt_Vec_ChangeLength(interp, vPtr, vPtr->length + 1) + if (Vec_ChangeLength(interp, vPtr, vPtr->length + 1) != TCL_OK) { return TCL_ERROR; } @@ -677,30 +542,15 @@ IndexOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) ReplicateValue(vPtr, first, last, value); Tcl_SetObjResult(interp, objv[3]); if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * LengthOp -- - * - * Returns the length of the vector. If a new size is given, the - * vector is resized to the new vector. - * - * Results: - * A standard TCL result. If the new length is invalid, - * interp->result will an error message and TCL_ERROR is returned. - * Otherwise interp->result will contain the length of the vector. - * - *--------------------------------------------------------------------------- - */ -static int -LengthOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int LengthOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { if (objc == 3) { int nElem; @@ -713,40 +563,24 @@ LengthOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) Tcl_GetString(objv[2]), "\"", (char *)NULL); return TCL_ERROR; } - if ((Blt_Vec_SetSize(interp, vPtr, nElem) != TCL_OK) || - (Blt_Vec_SetLength(interp, vPtr, nElem) != TCL_OK)) { + if ((Vec_SetSize(interp, vPtr, nElem) != TCL_OK) || + (Vec_SetLength(interp, vPtr, nElem) != TCL_OK)) { return TCL_ERROR; } if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } Tcl_SetIntObj(Tcl_GetObjResult(interp), vPtr->length); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * MapOp -- - * - * Queries or sets the offset of the array index from the base - * address of the data array of values. - * - * Results: - * A standard TCL result. If the source vector doesn't exist - * or the source list is not a valid list of numbers, TCL_ERROR - * returned. Otherwise TCL_OK is returned. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -MapOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int MapOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { if (objc > 2) { - if (Blt_Vec_MapVariable(interp, vPtr, Tcl_GetString(objv[2])) + if (Vec_MapVariable(interp, vPtr, Tcl_GetString(objv[2])) != TCL_OK) { return TCL_ERROR; } @@ -757,43 +591,15 @@ MapOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * MaxOp -- - * - * Returns the maximum value of the vector. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -MaxOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int MaxOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { - Tcl_SetDoubleObj(Tcl_GetObjResult(interp), Blt_Vec_Max(vPtr)); + Tcl_SetDoubleObj(Tcl_GetObjResult(interp), Vec_Max(vPtr)); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * MergeOp -- - * - * Merges the values from the given vectors to the current vector. - * - * Results: - * A standard TCL result. If any of the given vectors differ in size, - * TCL_ERROR is returned. Otherwise TCL_OK is returned and the - * vector data will contain merged values of the given vectors. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -MergeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int MergeOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { Vector **vecArr; int refSize, nElem; @@ -812,7 +618,7 @@ MergeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) Vector *v2Ptr; int length; - if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), &v2Ptr) + if (Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), &v2Ptr) != TCL_OK) { free(vecArr); return TCL_ERROR; @@ -836,7 +642,7 @@ MergeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) valueArr = (double*)malloc(sizeof(double) * nElem); if (valueArr == NULL) { Tcl_AppendResult(vPtr->interp, "not enough memory to allocate ", - Blt_Itoa(nElem), " vector elements", (char *)NULL); + Itoa(nElem), " vector elements", (char *)NULL); return TCL_ERROR; } @@ -850,51 +656,24 @@ MergeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) } } free(vecArr); - Blt_Vec_Reset(vPtr, valueArr, nElem, nElem, TCL_DYNAMIC); + Vec_Reset(vPtr, valueArr, nElem, nElem, TCL_DYNAMIC); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * MinOp -- - * - * Returns the minimum value of the vector. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -MinOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int MinOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { - Tcl_SetDoubleObj(Tcl_GetObjResult(interp), Blt_Vec_Min(vPtr)); + Tcl_SetDoubleObj(Tcl_GetObjResult(interp), Vec_Min(vPtr)); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * NormalizeOp -- - * - * Normalizes the vector. - * - * Results: - * A standard TCL result. If the density is invalid, TCL_ERROR - * is returned. Otherwise TCL_OK is returned. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -NormalizeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int NormalizeOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int i; double range; - Blt_Vec_UpdateRange(vPtr); + Vec_UpdateRange(vPtr); range = vPtr->max - vPtr->min; if (objc > 2) { Vector *v2Ptr; @@ -902,22 +681,22 @@ NormalizeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) char *string; string = Tcl_GetString(objv[2]); - v2Ptr = Blt_Vec_Create(vPtr->dataPtr, string, string, string, &isNew); + v2Ptr = Vec_Create(vPtr->dataPtr, string, string, string, &isNew); if (v2Ptr == NULL) { return TCL_ERROR; } - if (Blt_Vec_SetLength(interp, v2Ptr, vPtr->length) != TCL_OK) { + if (Vec_SetLength(interp, v2Ptr, vPtr->length) != TCL_OK) { return TCL_ERROR; } for (i = 0; i < vPtr->length; i++) { v2Ptr->valueArr[i] = (vPtr->valueArr[i] - vPtr->min) / range; } - Blt_Vec_UpdateRange(v2Ptr); + Vec_UpdateRange(v2Ptr); if (!isNew) { if (v2Ptr->flush) { - Blt_Vec_FlushCache(v2Ptr); + Vec_FlushCache(v2Ptr); } - Blt_Vec_UpdateClients(v2Ptr); + Vec_UpdateClients(v2Ptr); } } else { Tcl_Obj *listObjPtr; @@ -935,29 +714,8 @@ NormalizeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * NotifyOp -- - * - * Notify clients of vector. - * - * Results: - * A standard TCL result. If any of the given vectors differ in size, - * TCL_ERROR is returned. Otherwise TCL_OK is returned and the - * vector data will contain merged values of the given vectors. - * - * x vector notify now - * x vector notify always - * x vector notify whenidle - * x vector notify update {} - * x vector notify delete {} - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -NotifyOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int NotifyOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int option; int boll; @@ -1004,22 +762,8 @@ NotifyOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * PopulateOp -- - * - * Creates or resizes a new vector based upon the density specified. - * - * Results: - * A standard TCL result. If the density is invalid, TCL_ERROR - * is returned. Otherwise TCL_OK is returned. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -PopulateOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int PopulateOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { Vector *v2Ptr; int size, density; @@ -1030,7 +774,7 @@ PopulateOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) char *string; string = Tcl_GetString(objv[2]); - v2Ptr = Blt_Vec_Create(vPtr->dataPtr, string, string, string, &isNew); + v2Ptr = Vec_Create(vPtr->dataPtr, string, string, string, &isNew); if (v2Ptr == NULL) { return TCL_ERROR; } @@ -1046,7 +790,7 @@ PopulateOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_ERROR; } size = (vPtr->length - 1) * (density + 1) + 1; - if (Blt_Vec_SetLength(interp, v2Ptr, size) != TCL_OK) { + if (Vec_SetLength(interp, v2Ptr, size) != TCL_OK) { return TCL_ERROR; } count = 0; @@ -1066,28 +810,14 @@ PopulateOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) *valuePtr = vPtr->valueArr[i]; if (!isNew) { if (v2Ptr->flush) { - Blt_Vec_FlushCache(v2Ptr); + Vec_FlushCache(v2Ptr); } - Blt_Vec_UpdateClients(v2Ptr); + Vec_UpdateClients(v2Ptr); } return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * ValuesOp -- - * - * Print the values vector. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -ValuesOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int ValuesOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) { PrintSwitches switches; @@ -1095,7 +825,7 @@ ValuesOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) switches.from = 0; switches.to = vPtr->length - 1; indexSwitch.clientData = vPtr; - if (Blt_ParseSwitches(interp, printSwitches, objc - 2, objv + 2, &switches, + if (ParseSwitches(interp, printSwitches, objc - 2, objv + 2, &switches, BLT_SWITCH_DEFAULTS) < 0) { return TCL_ERROR; } @@ -1134,23 +864,8 @@ ValuesOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * RangeOp -- - * - * Returns a TCL list of the range of vector values specified. - * - * Results: - * A standard TCL result. If the given range is invalid, TCL_ERROR - * is returned. Otherwise TCL_OK is returned and interp->result - * will contain the list of values. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -RangeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int RangeOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { Tcl_Obj *listObjPtr; int first, last; @@ -1160,9 +875,9 @@ RangeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) first = 0; last = vPtr->length - 1; } else if (objc == 4) { - if ((Blt_Vec_GetIndex(interp, vPtr, Tcl_GetString(objv[2]), &first, + if ((Vec_GetIndex(interp, vPtr, Tcl_GetString(objv[2]), &first, INDEX_CHECK, (Blt_VectorIndexProc **) NULL) != TCL_OK) || - (Blt_Vec_GetIndex(interp, vPtr, Tcl_GetString(objv[3]), &last, + (Vec_GetIndex(interp, vPtr, Tcl_GetString(objv[3]), &last, INDEX_CHECK, (Blt_VectorIndexProc **) NULL) != TCL_OK)) { return TCL_ERROR; } @@ -1188,28 +903,7 @@ RangeOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * InRange -- - * - * Determines if a value lies within a given range. - * - * The value is normalized and compared against the interval - * [0..1], where 0.0 is the minimum and 1.0 is the maximum. - * DBL_EPSILON is the smallest number that can be represented - * on the host machine, such that (1.0 + epsilon) != 1.0. - * - * Please note, min cannot be greater than max. - * - * Results: - * If the value is within of the interval [min..max], 1 is - * returned; 0 otherwise. - * - *--------------------------------------------------------------------------- - */ -INLINE static int -InRange(double value, double min, double max) +static int InRange(double value, double min, double max) { double range; @@ -1250,8 +944,8 @@ enum NativeFormats { * *--------------------------------------------------------------------------- */ -static enum NativeFormats -GetBinaryFormat(Tcl_Interp* interp, char *string, int *sizePtr) +static enum NativeFormats GetBinaryFormat(Tcl_Interp* interp, char *string, + int *sizePtr) { char c; @@ -1305,9 +999,8 @@ GetBinaryFormat(Tcl_Interp* interp, char *string, int *sizePtr) return FMT_UNKNOWN; } -static int -CopyValues(Vector *vPtr, char *byteArr, enum NativeFormats fmt, int size, - int length, int swap, int *indexPtr) +static int CopyValues(Vector *vPtr, char *byteArr, enum NativeFormats fmt, + int size, int length, int swap, int *indexPtr) { int i, n; int newSize; @@ -1329,7 +1022,7 @@ CopyValues(Vector *vPtr, char *byteArr, enum NativeFormats fmt, int size, } newSize = *indexPtr + length; if (newSize > vPtr->length) { - if (Blt_Vec_ChangeLength(vPtr->interp, vPtr, newSize) != TCL_OK) { + if (Vec_ChangeLength(vPtr->interp, vPtr, newSize) != TCL_OK) { return TCL_ERROR; } } @@ -1415,9 +1108,9 @@ CopyValues(Vector *vPtr, char *byteArr, enum NativeFormats fmt, int size, * *--------------------------------------------------------------------------- */ -/*ARGSUSED*/ -static int -BinreadOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) + +static int BinreadOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { Tcl_Channel channel; char *byteArr; @@ -1488,7 +1181,7 @@ BinreadOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_ERROR; } string = Tcl_GetString(objv[i]); - if (Blt_Vec_GetIndex(interp, vPtr, string, &first, 0, + if (Vec_GetIndex(interp, vPtr, string, &first, 0, (Blt_VectorIndexProc **)NULL) != TCL_OK) { return TCL_ERROR; } @@ -1539,33 +1232,17 @@ BinreadOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) free(byteArr); if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); /* Set the result as the number of values read. */ Tcl_SetIntObj(Tcl_GetObjResult(interp), total); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * SearchOp -- - * - * Searches for a value in the vector. Returns the indices of all vector - * elements matching a particular value. - * - * Results: - * Always returns TCL_OK. interp->result will contain a list of the - * indices of array elements matching value. If no elements match, - * interp->result will contain the empty string. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -SearchOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int SearchOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { double min, max; int i; @@ -1616,24 +1293,8 @@ SearchOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * OffsetOp -- - * - * Queries or sets the offset of the array index from the base address of - * the data array of values. - * - * Results: - * A standard TCL result. If the source vector doesn't exist or the - * source list is not a valid list of numbers, TCL_ERROR returned. - * Otherwise TCL_OK is returned. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -OffsetOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int OffsetOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { if (objc == 3) { int newOffset; @@ -1647,21 +1308,8 @@ OffsetOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * RandomOp -- - * - * Generates random values for the length of the vector. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -RandomOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int RandomOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int i; @@ -1669,27 +1317,14 @@ RandomOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) vPtr->valueArr[i] = drand48(); } if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * SeqOp -- - * - * Generates a sequence of values in the vector. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -SeqOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int SeqOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int n; double start, stop; @@ -1708,7 +1343,7 @@ SeqOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) int i; double step; - if (Blt_Vec_SetLength(interp, vPtr, n) != TCL_OK) { + if (Vec_SetLength(interp, vPtr, n) != TCL_OK) { return TCL_ERROR; } step = (stop - start) / (double)(n - 1); @@ -1716,34 +1351,15 @@ SeqOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) vPtr->valueArr[i] = start + (step * i); } if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * SetOp -- - * - * Sets the data of the vector object from a list of values. - * - * Results: - * A standard TCL result. If the source vector doesn't exist or the - * source list is not a valid list of numbers, TCL_ERROR returned. - * Otherwise TCL_OK is returned. - * - * Side Effects: - * The vector data is reset. Clients of the vector are notified. Any - * cached array indices are flushed. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -SetOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int SetOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int result; Vector *v2Ptr; @@ -1752,7 +1368,7 @@ SetOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) /* The source can be either a list of numbers or another vector. */ - v2Ptr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, + v2Ptr = Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, Tcl_GetString(objv[2]), NULL, NS_SEARCH_BOTH); if (v2Ptr != NULL) { if (vPtr == v2Ptr) { @@ -1761,14 +1377,14 @@ SetOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) * Source and destination vectors are the same. Copy the source * first into a temporary vector to avoid memory overlaps. */ - tmpPtr = Blt_Vec_New(vPtr->dataPtr); - result = Blt_Vec_Duplicate(tmpPtr, v2Ptr); + tmpPtr = Vec_New(vPtr->dataPtr); + result = Vec_Duplicate(tmpPtr, v2Ptr); if (result == TCL_OK) { - result = Blt_Vec_Duplicate(vPtr, tmpPtr); + result = Vec_Duplicate(vPtr, tmpPtr); } - Blt_Vec_Free(tmpPtr); + Vec_Free(tmpPtr); } else { - result = Blt_Vec_Duplicate(vPtr, v2Ptr); + result = Vec_Duplicate(vPtr, v2Ptr); } } else if (Tcl_ListObjGetElements(interp, objv[2], &nElem, &elemObjArr) == TCL_OK) { @@ -1784,34 +1400,15 @@ SetOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) * clients that it's been modified. */ if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } return result; } -/* - *--------------------------------------------------------------------------- - * - * SimplifyOp -- - * - * Sets the data of the vector object from a list of values. - * - * Results: - * A standard TCL result. If the source vector doesn't exist or the - * source list is not a valid list of numbers, TCL_ERROR returned. - * Otherwise TCL_OK is returned. - * - * Side Effects: - * The vector data is reset. Clients of the vector are notified. Any - * cached array indices are flushed. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -SimplifyOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int SimplifyOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { size_t i, n; int length, nPoints; @@ -1829,41 +1426,28 @@ SimplifyOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) reduced[i] = orig[simple[i]]; } free(simple); - Blt_Vec_Reset(vPtr, (double *)reduced, n * 2, vPtr->length, TCL_DYNAMIC); + Vec_Reset(vPtr, (double *)reduced, n * 2, vPtr->length, TCL_DYNAMIC); /* * The vector has changed; so flush the array indices (they're wrong * now), find the new range of the data, and notify the vector's * clients that it's been modified. */ if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * SplitOp -- - * - * Copies the values from the vector evenly into one of more vectors. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -SplitOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int SplitOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { int nVectors; nVectors = objc - 2; if ((vPtr->length % nVectors) != 0) { Tcl_AppendResult(interp, "can't split vector \"", vPtr->name, - "\" into ", Blt_Itoa(nVectors), " even parts.", (char *)NULL); + "\" into ", Itoa(nVectors), " even parts.", (char *)NULL); return TCL_ERROR; } if (nVectors > 0) { @@ -1875,19 +1459,19 @@ SplitOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) extra = vPtr->length / nVectors; for (i = 0; i < nVectors; i++) { string = Tcl_GetString(objv[i+2]); - v2Ptr = Blt_Vec_Create(vPtr->dataPtr, string, string, string, + v2Ptr = Vec_Create(vPtr->dataPtr, string, string, string, &isNew); oldSize = v2Ptr->length; newSize = oldSize + extra; - if (Blt_Vec_SetLength(interp, v2Ptr, newSize) != TCL_OK) { + if (Vec_SetLength(interp, v2Ptr, newSize) != TCL_OK) { return TCL_ERROR; } for (j = i, k = oldSize; j < vPtr->length; j += nVectors, k++) { v2Ptr->valueArr[k] = vPtr->valueArr[j]; } - Blt_Vec_UpdateClients(v2Ptr); + Vec_UpdateClients(v2Ptr); if (v2Ptr->flush) { - Blt_Vec_FlushCache(v2Ptr); + Vec_FlushCache(v2Ptr); } } } @@ -1902,8 +1486,7 @@ static int sortDecreasing; /* Indicates the ordering of the sort. If * non-zero, the vectors are sorted in * decreasing order */ -static int -CompareVectors(void *a, void *b) +static int CompareVectors(void *a, void *b) { double delta; int i; @@ -1923,27 +1506,7 @@ CompareVectors(void *a, void *b) return 0; } -/* - *--------------------------------------------------------------------------- - * - * Blt_Vec_SortMap -- - * - * Returns an array of indices that represents the sorted mapping of the - * original vector. - * - * Results: - * A standard TCL result. If any of the auxiliary vectors are a - * different size than the sorted vector object, TCL_ERROR is returned. - * Otherwise TCL_OK is returned. - * - * Side Effects: - * The vectors are sorted. - * - * vecName sort ?switches? vecName vecName... - *--------------------------------------------------------------------------- - */ -size_t * -Blt_Vec_SortMap(Vector **vectors, int nVectors) +size_t* Blt::Vec_SortMap(Vector **vectors, int nVectors) { size_t *map; int i; @@ -1963,8 +1526,8 @@ Blt_Vec_SortMap(Vector **vectors, int nVectors) return map; } -static size_t * -SortVectors(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static size_t* SortVectors(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { Vector **vectors, *v2Ptr; size_t *map; @@ -1974,7 +1537,7 @@ SortVectors(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) vectors[0] = vPtr; map = NULL; for (i = 0; i < objc; i++) { - if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), + if (Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), &v2Ptr) != TCL_OK) { goto error; } @@ -1986,34 +1549,13 @@ SortVectors(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) } vectors[i + 1] = v2Ptr; } - map = Blt_Vec_SortMap(vectors, objc + 1); + map = Vec_SortMap(vectors, objc + 1); error: free(vectors); return map; } - -/* - *--------------------------------------------------------------------------- - * - * SortOp -- - * - * Sorts the vector object and any other vectors according to sorting - * order of the vector object. - * - * Results: - * A standard TCL result. If any of the auxiliary vectors are a - * different size than the sorted vector object, TCL_ERROR is returned. - * Otherwise TCL_OK is returned. - * - * Side Effects: - * The vectors are sorted. - * - * vecName sort ?switches? vecName vecName... - *--------------------------------------------------------------------------- - */ -static int -SortOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int SortOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) { Vector *v2Ptr; double *copy; @@ -2026,7 +1568,7 @@ SortOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) sortDecreasing = 0; switches.flags = 0; - i = Blt_ParseSwitches(interp, sortSwitches, objc - 2, objv + 2, &switches, + i = ParseSwitches(interp, sortSwitches, objc - 2, objv + 2, &switches, BLT_SWITCH_OBJV_PARTIAL); if (i < 0) { return TCL_ERROR; @@ -2036,7 +1578,7 @@ SortOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) if (objc > 2) { map = SortVectors(vPtr, interp, objc - 2, objv + 2); } else { - map = Blt_Vec_SortMap(&vPtr, 1); + map = Vec_SortMap(&vPtr, 1); } if (map == NULL) { return TCL_ERROR; @@ -2067,34 +1609,34 @@ SortOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) nBytes = sortLength * sizeof(double); } if (sortLength != vPtr->length) { - Blt_Vec_SetLength(interp, vPtr, sortLength); + Vec_SetLength(interp, vPtr, sortLength); } for (n = 0; n < sortLength; n++) { vPtr->valueArr[n] = copy[map[n]]; } if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); /* Now sort any other vectors in the same fashion. The vectors must be * the same size as the map though. */ result = TCL_ERROR; for (i = 2; i < objc; i++) { - if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), + if (Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), &v2Ptr) != TCL_OK) { goto error; } if (sortLength != v2Ptr->length) { - Blt_Vec_SetLength(interp, v2Ptr, sortLength); + Vec_SetLength(interp, v2Ptr, sortLength); } memcpy((char *)copy, (char *)v2Ptr->valueArr, nBytes); for (n = 0; n < sortLength; n++) { v2Ptr->valueArr[n] = copy[map[n]]; } - Blt_Vec_UpdateClients(v2Ptr); + Vec_UpdateClients(v2Ptr); if (v2Ptr->flush) { - Blt_Vec_FlushCache(v2Ptr); + Vec_FlushCache(v2Ptr); } } result = TCL_OK; @@ -2104,54 +1646,23 @@ SortOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return result; } -/* - *--------------------------------------------------------------------------- - * - * InstExprOp -- - * - * Computes the result of the expression which may be either a scalar - * (single value) or vector (list of values). - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -InstExprOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int InstExprOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { - if (Blt_ExprVector(interp, Tcl_GetString(objv[2]), (Blt_Vector *)vPtr) + if (ExprVector(interp, Tcl_GetString(objv[2]), (Blt_Vector *)vPtr) != TCL_OK) { return TCL_ERROR; } if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * ArithOp -- - * - * Results: - * A standard TCL result. If the source vector doesn't exist or the - * source list is not a valid list of numbers, TCL_ERROR returned. - * Otherwise TCL_OK is returned. - * - * Side Effects: - * The vector data is reset. Clients of the vector are notified. - * Any cached array indices are flushed. - * - *--------------------------------------------------------------------------- - */ -/*ARGSUSED*/ -static int -ArithOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) +static int ArithOp(Vector *vPtr, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { double value; int i; @@ -2160,7 +1671,7 @@ ArithOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) Tcl_Obj *listObjPtr; char *string; - v2Ptr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, + v2Ptr = Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, Tcl_GetString(objv[2]), NULL, NS_SEARCH_BOTH); if (v2Ptr != NULL) { int j; @@ -2253,18 +1764,6 @@ ArithOp(Vector *vPtr, Tcl_Interp* interp, int objc, Tcl_Obj* const objv[]) return TCL_OK; } -/* - *--------------------------------------------------------------------------- - * - * VectorInstCmd -- - * - * Parses and invokes the appropriate vector instance command option. - * - * Results: - * A standard TCL result. - * - *--------------------------------------------------------------------------- - */ static Blt_OpSpec vectorInstOps[] = { {"*", 1, (void*)ArithOp, 3, 3, "item",}, /*Deprecated*/ @@ -2302,39 +1801,24 @@ static Blt_OpSpec vectorInstOps[] = static int nInstOps = sizeof(vectorInstOps) / sizeof(Blt_OpSpec); -int -Blt_Vec_InstCmd(ClientData clientData, Tcl_Interp* interp, int objc, - Tcl_Obj* const objv[]) +int Blt::Vec_InstCmd(ClientData clientData, Tcl_Interp* interp, + int objc, Tcl_Obj* const objv[]) { VectorCmdProc* proc; Vector* vPtr = (Vector*)clientData; vPtr->first = 0; vPtr->last = vPtr->length - 1; - proc = (VectorCmdProc*)Blt_GetOpFromObj(interp, nInstOps, vectorInstOps, BLT_OP_ARG1, objc, - objv, 0); + proc = (VectorCmdProc*)GetOpFromObj(interp, nInstOps, vectorInstOps, + BLT_OP_ARG1, objc, objv, 0); if (proc == NULL) { return TCL_ERROR; } return (*proc) (vPtr, interp, objc, objv); } - -/* - *--------------------------------------------------------------------------- - * - * Blt_Vec_VarTrace -- - * - * Results: - * Returns NULL on success. Only called from a variable trace. - * - * Side effects: - * - *--------------------------------------------------------------------------- - */ -char * -Blt_Vec_VarTrace(ClientData clientData, Tcl_Interp* interp, const char *part1, - const char *part2, int flags) +char* Blt::Vec_VarTrace(ClientData clientData, Tcl_Interp* interp, + const char *part1, const char *part2, int flags) { Blt_VectorIndexProc *indexProc; Vector* vPtr = (Vector*)clientData; @@ -2348,12 +1832,12 @@ Blt_Vec_VarTrace(ClientData clientData, Tcl_Interp* interp, const char *part1, free((void*)(vPtr->arrayName)); vPtr->arrayName = NULL; if (vPtr->freeOnUnset) { - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); } } return NULL; } - if (Blt_Vec_GetIndexRange(interp, vPtr, part2, INDEX_ALL_FLAGS, &indexProc) + if (Vec_GetIndexRange(interp, vPtr, part2, INDEX_ALL_FLAGS, &indexProc) != TCL_OK) { goto error; } @@ -2379,7 +1863,7 @@ Blt_Vec_VarTrace(ClientData clientData, Tcl_Interp* interp, const char *part1, goto error; } if (first == vPtr->length) { - if (Blt_Vec_ChangeLength((Tcl_Interp *)NULL, vPtr, vPtr->length + 1) + if (Vec_ChangeLength((Tcl_Interp *)NULL, vPtr, vPtr->length + 1) != TCL_OK) { return (char *)"error resizing vector"; } @@ -2434,13 +1918,13 @@ Blt_Vec_VarTrace(ClientData clientData, Tcl_Interp* interp, const char *part1, } vPtr->length -= ((last - first) + 1); if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } } else { return (char *)"unknown variable trace flag"; } if (flags & (TCL_TRACE_UNSETS | TCL_TRACE_WRITES)) { - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } Tcl_ResetResult(interp); return NULL; diff --git a/src/bltVecInt.h b/src/bltVecInt.h index da2e107..c09cf10 100644 --- a/src/bltVecInt.h +++ b/src/bltVecInt.h @@ -50,103 +50,6 @@ #define FFT_BARTLETT (1<<1) #define FFT_SPECTRUM (1<<2) -typedef struct { - double x; - double y; -} Point2d; - -typedef struct { - Tcl_HashTable vectorTable; /* Table of vectors */ - Tcl_HashTable mathProcTable; /* Table of vector math functions */ - Tcl_HashTable indexProcTable; - Tcl_Interp* interp; - unsigned int nextId; -} VectorInterpData; - -/* - * Vector -- - * - * A vector is an array of double precision values. It can be accessed - * through a TCL command, a TCL array variable, or C API. The storage for - * the array points initially to a statically allocated buffer, but to - * malloc-ed memory if more is necessary. - * - * Vectors can be shared by several clients (for example, two different - * graph widgets). The data is shared. When a client wants to use a - * vector, it allocates a vector identifier, which identifies the client. - * Clients use this ID to specify a callback routine to be invoked - * whenever the vector is modified or destroyed. Whenever the vector is - * updated or destroyed, each client is notified of the change by their - * callback routine. - */ - -typedef struct { - - /* - * If you change these fields, make sure you change the definition of - * Blt_Vector in blt.h too. - */ - - double *valueArr; /* Array of values (malloc-ed) */ - - int length; /* Current number of values in the array. */ - - int size; /* Maximum number of values that can be stored - * in the value array. */ - - double min, max; /* Minimum and maximum values in the vector */ - - int dirty; /* Indicates if the vector has been updated */ - - int reserved; - - /* The following fields are local to this module */ - - const char *name; /* The namespace-qualified name of the vector. - * It points to the hash key allocated for the - * entry in the vector hash table. */ - - VectorInterpData *dataPtr; - Tcl_Interp* interp; /* Interpreter associated with the - * vector */ - - Tcl_HashEntry *hashPtr; /* If non-NULL, pointer in a hash table to - * track the vectors in use. */ - - Tcl_FreeProc *freeProc; /* Address of procedure to call to release - * storage for the value array, Optionally can - * be one of the following: TCL_STATIC, - * TCL_DYNAMIC, or TCL_VOLATILE. */ - - const char *arrayName; /* The name of the TCL array variable mapped - * to the vector (malloc'ed). If NULL, - * indicates that the vector isn't mapped to - * any variable */ - - Tcl_Namespace *nsPtr; /* Namespace context of the vector itself. */ - - int offset; /* Offset from zero of the vector's starting - * index */ - - Tcl_Command cmdToken; /* Token for vector's TCL command. */ - - Blt_Chain chain; /* List of clients using this vector */ - - int notifyFlags; /* Notification flags. See definitions - * below */ - - int varFlags; /* Indicate if the variable is global, - * namespace, or local */ - - int freeOnUnset; /* For backward compatibility only: If - * non-zero, free the vector when its variable - * is unset. */ - int flush; - - int first, last; /* Selected region of vector. This is used - * mostly for the math routines */ -} Vector; - #define NOTIFY_UPDATED ((int)BLT_VECTOR_NOTIFY_UPDATE) #define NOTIFY_DESTROYED ((int)BLT_VECTOR_NOTIFY_DESTROY) @@ -184,76 +87,129 @@ typedef struct { } \ } - extern const char *Blt_Itoa(int value); - -extern void Blt_Vec_InstallSpecialIndices(Tcl_HashTable *tablePtr); - -extern void Blt_Vec_InstallMathFunctions(Tcl_HashTable *tablePtr); - -extern void Blt_Vec_UninstallMathFunctions(Tcl_HashTable *tablePtr); - -extern VectorInterpData *Blt_Vec_GetInterpData (Tcl_Interp* interp); +namespace Blt { -extern double Blt_Vec_Max(Vector *vecObjPtr); -extern double Blt_Vec_Min(Vector *vecObjPtr); + typedef struct { + double x; + double y; + } Point2d; -extern Vector *Blt_Vec_New(VectorInterpData *dataPtr); + typedef struct { + Tcl_HashTable vectorTable; /* Table of vectors */ + Tcl_HashTable mathProcTable; /* Table of vector math functions */ + Tcl_HashTable indexProcTable; + Tcl_Interp* interp; + unsigned int nextId; + } VectorInterpData; -extern int Blt_Vec_Duplicate(Vector *destPtr, Vector *srcPtr); + typedef struct { + // If you change these fields, make sure you change the definition of + // Blt_Vector in blt.h too. + double *valueArr; /* Array of values (malloc-ed) */ -extern int Blt_Vec_SetLength(Tcl_Interp* interp, Vector *vPtr, - int length); + int length; /* Current number of values in the array. */ -extern int Blt_Vec_SetSize(Tcl_Interp* interp, Vector *vPtr, - int size); + int size; /* Maximum number of values that can be stored + * in the value array. */ -extern int Blt_Vec_ChangeLength(Tcl_Interp* interp, Vector *vPtr, - int length); + double min, max; /* Minimum and maximum values in the vector */ -extern Vector *Blt_Vec_ParseElement(Tcl_Interp* interp, - VectorInterpData *dataPtr, const char *start, const char **endPtr, - int flags); + int dirty; /* Indicates if the vector has been updated */ -extern void Blt_Vec_Free(Vector *vPtr); + int reserved; -extern size_t *Blt_Vec_SortMap(Vector **vectors, int nVectors); + /* The following fields are local to this module */ -extern int Blt_Vec_LookupName(VectorInterpData *dataPtr, - const char *vecName, Vector **vPtrPtr); + const char *name; /* The namespace-qualified name of the vector. + * It points to the hash key allocated for the + * entry in the vector hash table. */ -extern Vector *Blt_Vec_Create(VectorInterpData *dataPtr, - const char *name, const char *cmdName, const char *varName, - int *newPtr); + VectorInterpData *dataPtr; + Tcl_Interp* interp; /* Interpreter associated with the + * vector */ -extern void Blt_Vec_UpdateRange(Vector *vPtr); + Tcl_HashEntry *hashPtr; /* If non-NULL, pointer in a hash table to + * track the vectors in use. */ -extern void Blt_Vec_UpdateClients(Vector *vPtr); + Tcl_FreeProc *freeProc; /* Address of procedure to call to release + * storage for the value array, Optionally can + * be one of the following: TCL_STATIC, + * TCL_DYNAMIC, or TCL_VOLATILE. */ -extern void Blt_Vec_FlushCache(Vector *vPtr); + const char *arrayName; /* The name of the TCL array variable mapped + * to the vector (malloc'ed). If NULL, + * indicates that the vector isn't mapped to + * any variable */ -extern int Blt_Vec_Reset(Vector *vPtr, double *dataArr, - int nValues, int arraySize, Tcl_FreeProc *freeProc); + Tcl_Namespace *nsPtr; /* Namespace context of the vector itself. */ -extern int Blt_Vec_GetIndex(Tcl_Interp* interp, Vector *vPtr, - const char *string, int *indexPtr, int flags, - Blt_VectorIndexProc **procPtrPtr); + int offset; /* Offset from zero of the vector's starting + * index */ -extern int Blt_Vec_GetIndexRange(Tcl_Interp* interp, Vector *vPtr, - const char *string, int flags, Blt_VectorIndexProc **procPtrPtr); + Tcl_Command cmdToken; /* Token for vector's TCL command. */ -extern int Blt_Vec_MapVariable(Tcl_Interp* interp, Vector *vPtr, - const char *name); + Blt_Chain chain; /* List of clients using this vector */ -extern int Blt_Vec_FFT(Tcl_Interp* interp, Vector *realPtr, - Vector *phasesPtr, Vector *freqPtr, double delta, - int flags, Vector *srcPtr); + int notifyFlags; /* Notification flags. See definitions + * below */ -extern int Blt_Vec_InverseFFT(Tcl_Interp* interp, Vector *iSrcPtr, - Vector *rDestPtr, Vector *iDestPtr, Vector *srcPtr); + int varFlags; /* Indicate if the variable is global, + * namespace, or local */ -extern Tcl_ObjCmdProc Blt_Vec_InstCmd; + int freeOnUnset; /* For backward compatibility only: If + * non-zero, free the vector when its variable + * is unset. */ + int flush; -extern Tcl_VarTraceProc Blt_Vec_VarTrace; + int first, last; /* Selected region of vector. This is used + * mostly for the math routines */ + } Vector; + + extern const char* Itoa(int value); + extern int Vec_GetIndex(Tcl_Interp* interp, Vector *vPtr, + const char *string, int *indexPtr, int flags, + Blt_VectorIndexProc **procPtrPtr); + extern int Vec_GetIndexRange(Tcl_Interp* interp, Vector *vPtr, + const char *string, int flags, + Blt_VectorIndexProc **procPtrPtr); + extern Vector* Vec_ParseElement(Tcl_Interp* interp, VectorInterpData *dataPtr, + const char *start, const char **endPtr, + int flags); + extern int Vec_SetLength(Tcl_Interp* interp, Vector *vPtr, int length); + extern int Vec_SetSize(Tcl_Interp* interp, Vector *vPtr, int size); + extern void Vec_FlushCache(Vector *vPtr); + extern void Vec_UpdateRange(Vector *vPtr); + extern void Vec_UpdateClients(Vector *vPtr); + extern void Vec_Free(Vector *vPtr); + extern Vector* Vec_New(VectorInterpData *dataPtr); + extern int Vec_MapVariable(Tcl_Interp* interp, Vector *vPtr, + const char *name); + extern int Vec_ChangeLength(Tcl_Interp* interp, Vector *vPtr, int length); + extern Vector* Vec_Create(VectorInterpData *dataPtr, const char *name, + const char *cmdName, const char *varName, + int *newPtr); + extern int Vec_LookupName(VectorInterpData *dataPtr, const char *vecName, + Vector **vPtrPtr); + extern VectorInterpData* Vec_GetInterpData (Tcl_Interp* interp); + extern int Vec_Reset(Vector *vPtr, double *dataArr, int nValues, + int arraySize, Tcl_FreeProc *freeProc); + extern int Vec_FFT(Tcl_Interp* interp, Vector *realPtr, + Vector *phasesPtr, Vector *freqPtr, double delta, + int flags, Vector *srcPtr); + extern int Vec_InverseFFT(Tcl_Interp* interp, Vector *iSrcPtr, + Vector *rDestPtr, Vector *iDestPtr, + Vector *srcPtr); + extern int Vec_Duplicate(Vector *destPtr, Vector *srcPtr); + extern size_t *Vec_SortMap(Vector **vectors, int nVectors); + extern double Vec_Max(Vector *vecObjPtr); + extern double Vec_Min(Vector *vecObjPtr); + + extern Tcl_ObjCmdProc Vec_InstCmd; + extern Tcl_VarTraceProc Vec_VarTrace; + extern void Vec_InstallMathFunctions(Tcl_HashTable *tablePtr); + extern void Vec_UninstallMathFunctions(Tcl_HashTable *tablePtr); + extern void Vec_InstallSpecialIndices(Tcl_HashTable *tablePtr); +}; extern Tcl_IdleProc Blt_Vec_NotifyClients; diff --git a/src/bltVecMath.C b/src/bltVecMath.C index 90b527e..d978a26 100644 --- a/src/bltVecMath.C +++ b/src/bltVecMath.C @@ -40,6 +40,8 @@ #include "bltNsUtil.h" #include "bltParse.h" +using namespace Blt; + /* * Three types of math functions: * @@ -169,7 +171,7 @@ static int Sort(Vector *vPtr) double *values; int i; - map = Blt_Vec_SortMap(&vPtr, 1); + map = Vec_SortMap(&vPtr, 1); values = (double*)malloc(sizeof(double) * vPtr->length); for(i = vPtr->first; i <= vPtr->last; i++) { values[i] = vPtr->valueArr[map[i]]; @@ -191,13 +193,13 @@ static double Length(Blt_Vector *vectorPtr) double Blt_VecMax(Blt_Vector *vectorPtr) { Vector *vPtr = (Vector *)vectorPtr; - return Blt_Vec_Max(vPtr); + return Vec_Max(vPtr); } double Blt_VecMin(Blt_Vector *vectorPtr) { Vector *vPtr = (Vector *)vectorPtr; - return Blt_Vec_Min(vPtr); + return Vec_Min(vPtr); } static double Product(Blt_Vector *vectorPtr) @@ -378,7 +380,7 @@ static double Median(Blt_Vector *vectorPtr) if (vPtr->length == 0) { return -DBL_MAX; } - map = Blt_Vec_SortMap(&vPtr, 1); + map = Vec_SortMap(&vPtr, 1); mid = (vPtr->length - 1) / 2; /* @@ -405,7 +407,7 @@ static double Q1(Blt_Vector *vectorPtr) if (vPtr->length == 0) { return -DBL_MAX; } - map = Blt_Vec_SortMap(&vPtr, 1); + map = Vec_SortMap(&vPtr, 1); if (vPtr->length < 4) { q1 = vPtr->valueArr[map[0]]; @@ -441,7 +443,7 @@ static double Q3(Blt_Vector *vectorPtr) return -DBL_MAX; } - map = Blt_Vec_SortMap(&vPtr, 1); + map = Vec_SortMap(&vPtr, 1); if (vPtr->length < 4) { q3 = vPtr->valueArr[map[vPtr->length - 1]]; @@ -473,8 +475,8 @@ static int Norm(Blt_Vector *vector) double norm, range, min, max; int i; - min = Blt_Vec_Min(vPtr); - max = Blt_Vec_Max(vPtr); + min = Vec_Min(vPtr); + max = Vec_Max(vPtr); range = max - min; for (i = 0; i < vPtr->length; i++) { norm = (vPtr->valueArr[i] - min) / range; @@ -562,7 +564,7 @@ static void MathError(Tcl_Interp* interp, double value) } else { Tcl_AppendResult(interp, "unknown floating-point error, ", - "errno = ", Blt_Itoa(errno), (char *)NULL); + "errno = ", Itoa(errno), (char *)NULL); Tcl_SetErrorCode(interp, "ARITH", "UNKNOWN", Tcl_GetStringResult(interp), (char *)NULL); } @@ -589,7 +591,7 @@ static int ParseString(Tcl_Interp* interp, const char *string, Value *valuePtr) return TCL_ERROR; } /* Numbers are stored as single element vectors. */ - if (Blt_Vec_ChangeLength(interp, valuePtr->vPtr, 1) != TCL_OK) { + if (Vec_ChangeLength(interp, valuePtr->vPtr, 1) != TCL_OK) { return TCL_ERROR; } valuePtr->vPtr->valueArr[0] = value; @@ -600,7 +602,7 @@ static int ParseString(Tcl_Interp* interp, const char *string, Value *valuePtr) while (isspace((unsigned char)(*string))) { string++; /* Skip spaces leading the vector name. */ } - vPtr = Blt_Vec_ParseElement(interp, valuePtr->vPtr->dataPtr, + vPtr = Vec_ParseElement(interp, valuePtr->vPtr->dataPtr, string, &endPtr, NS_SEARCH_BOTH); if (vPtr == NULL) { return TCL_ERROR; @@ -611,7 +613,7 @@ static int ParseString(Tcl_Interp* interp, const char *string, Value *valuePtr) return TCL_ERROR; } /* Copy the designated vector to our temporary. */ - Blt_Vec_Duplicate(valuePtr->vPtr, vPtr); + Vec_Duplicate(valuePtr->vPtr, vPtr); } return TCL_OK; } @@ -707,7 +709,7 @@ static int NextToken(Tcl_Interp* interp, ParseInfo *piPtr, Value *valuePtr) /* * Save the single floating-point value as an 1-component vector. */ - if (Blt_Vec_ChangeLength(interp, valuePtr->vPtr, 1) != TCL_OK) { + if (Vec_ChangeLength(interp, valuePtr->vPtr, 1) != TCL_OK) { return TCL_ERROR; } valuePtr->vPtr->valueArr[0] = value; @@ -729,7 +731,7 @@ static int NextToken(Tcl_Interp* interp, ParseInfo *piPtr, Value *valuePtr) case '[': piPtr->token = VALUE; - result = Blt_ParseNestedCmd(interp, p + 1, 0, &endPtr, &valuePtr->pv); + result = ParseNestedCmd(interp, p + 1, 0, &endPtr, &valuePtr->pv); if (result != TCL_OK) { return result; } @@ -740,7 +742,7 @@ static int NextToken(Tcl_Interp* interp, ParseInfo *piPtr, Value *valuePtr) case '"': piPtr->token = VALUE; - result = Blt_ParseQuotes(interp, p + 1, '"', 0, &endPtr, &valuePtr->pv); + result = ParseQuotes(interp, p + 1, '"', 0, &endPtr, &valuePtr->pv); if (result != TCL_OK) { return result; } @@ -751,7 +753,7 @@ static int NextToken(Tcl_Interp* interp, ParseInfo *piPtr, Value *valuePtr) case '{': piPtr->token = VALUE; - result = Blt_ParseBraces(interp, p + 1, &endPtr, &valuePtr->pv); + result = ParseBraces(interp, p + 1, &endPtr, &valuePtr->pv); if (result != TCL_OK) { return result; } @@ -875,12 +877,12 @@ static int NextToken(Tcl_Interp* interp, ParseInfo *piPtr, Value *valuePtr) while (isspace((unsigned char)(*p))) { p++; /* Skip spaces leading the vector name. */ } - vPtr = Blt_Vec_ParseElement(interp, valuePtr->vPtr->dataPtr, + vPtr = Vec_ParseElement(interp, valuePtr->vPtr->dataPtr, p, &endPtr, NS_SEARCH_BOTH); if (vPtr == NULL) { return TCL_ERROR; } - Blt_Vec_Duplicate(valuePtr->vPtr, vPtr); + Vec_Duplicate(valuePtr->vPtr, vPtr); piPtr->nextPtr = endPtr; } } @@ -905,12 +907,12 @@ static int NextValue(Tcl_Interp* interp, ParseInfo *piPtr, */ vPtr = valuePtr->vPtr; - v2Ptr = Blt_Vec_New(vPtr->dataPtr); + v2Ptr = Vec_New(vPtr->dataPtr); gotOp = 0; value2.vPtr = v2Ptr; value2.pv.buffer = value2.pv.next = value2.staticSpace; value2.pv.end = value2.pv.buffer + STATIC_STRING_SPACE - 1; - value2.pv.expandProc = Blt_ExpandParseValue; + value2.pv.expandProc = ExpandParseValue; value2.pv.clientData = NULL; result = NextToken(interp, piPtr, valuePtr); @@ -1169,7 +1171,7 @@ static int NextValue(Tcl_Interp* interp, ParseInfo *piPtr, * 1st operand is a scalar. */ scalar = vPtr->valueArr[0]; - Blt_Vec_Duplicate(vPtr, v2Ptr); + Vec_Duplicate(vPtr, v2Ptr); opnd = vPtr->valueArr; switch (oper) { case MULT: @@ -1391,14 +1393,14 @@ static int NextValue(Tcl_Interp* interp, ParseInfo *piPtr, if (value2.pv.buffer != value2.staticSpace) { free(value2.pv.buffer); } - Blt_Vec_Free(v2Ptr); + Vec_Free(v2Ptr); return result; error: if (value2.pv.buffer != value2.staticSpace) { free(value2.pv.buffer); } - Blt_Vec_Free(v2Ptr); + Vec_Free(v2Ptr); return TCL_ERROR; } @@ -1413,7 +1415,7 @@ static int EvaluateExpression(Tcl_Interp* interp, char *string, info.expr = info.nextPtr = string; valuePtr->pv.buffer = valuePtr->pv.next = valuePtr->staticSpace; valuePtr->pv.end = valuePtr->pv.buffer + STATIC_STRING_SPACE - 1; - valuePtr->pv.expandProc = Blt_ExpandParseValue; + valuePtr->pv.expandProc = ExpandParseValue; valuePtr->pv.clientData = NULL; result = NextValue(interp, &info, -1, valuePtr); @@ -1476,7 +1478,7 @@ static int ScalarFunc(ClientData clientData, Tcl_Interp* interp, Vector *vPtr) MathError(interp, value); return TCL_ERROR; } - if (Blt_Vec_ChangeLength(interp, vPtr, 1) != TCL_OK) { + if (Vec_ChangeLength(interp, vPtr, 1) != TCL_OK) { return TCL_ERROR; } vPtr->valueArr[0] = value; @@ -1531,7 +1533,7 @@ static MathFunction mathFunctions[] = {(char *)NULL,}, }; -void Blt_Vec_InstallMathFunctions(Tcl_HashTable *tablePtr) +void Blt::Vec_InstallMathFunctions(Tcl_HashTable *tablePtr) { MathFunction *mathPtr; @@ -1544,7 +1546,7 @@ void Blt_Vec_InstallMathFunctions(Tcl_HashTable *tablePtr) } } -void Blt_Vec_UninstallMathFunctions(Tcl_HashTable *tablePtr) +void Blt::Vec_UninstallMathFunctions(Tcl_HashTable *tablePtr) { Tcl_HashEntry *hPtr; Tcl_HashSearch cursor; @@ -1570,7 +1572,7 @@ static void InstallIndexProc(Tcl_HashTable *tablePtr, const char *string, Tcl_SetHashValue(hPtr, (ClientData)procPtr); } -void Blt_Vec_InstallSpecialIndices(Tcl_HashTable *tablePtr) +void Blt::Vec_InstallSpecialIndices(Tcl_HashTable *tablePtr) { InstallIndexProc(tablePtr, "min", Blt_VecMin); InstallIndexProc(tablePtr, "max", Blt_VecMax); @@ -1579,21 +1581,20 @@ void Blt_Vec_InstallSpecialIndices(Tcl_HashTable *tablePtr) InstallIndexProc(tablePtr, "prod", Product); } -int Blt_ExprVector(Tcl_Interp* interp, char *string, Blt_Vector *vector) +int Blt::ExprVector(Tcl_Interp* interp, char *string, Blt_Vector *vector) { VectorInterpData *dataPtr; /* Interpreter-specific data. */ Vector *vPtr = (Vector *)vector; Value value; - dataPtr = (vector != NULL) - ? vPtr->dataPtr : Blt_Vec_GetInterpData(interp); - value.vPtr = Blt_Vec_New(dataPtr); + dataPtr = (vector != NULL) ? vPtr->dataPtr : Vec_GetInterpData(interp); + value.vPtr = Vec_New(dataPtr); if (EvaluateExpression(interp, string, &value) != TCL_OK) { - Blt_Vec_Free(value.vPtr); + Vec_Free(value.vPtr); return TCL_ERROR; } if (vPtr != NULL) { - Blt_Vec_Duplicate(vPtr, value.vPtr); + Vec_Duplicate(vPtr, value.vPtr); } else { Tcl_Obj *listObjPtr; double *vp, *vend; @@ -1606,6 +1607,6 @@ int Blt_ExprVector(Tcl_Interp* interp, char *string, Blt_Vector *vector) } Tcl_SetObjResult(interp, listObjPtr); } - Blt_Vec_Free(value.vPtr); + Vec_Free(value.vPtr); return TCL_OK; } diff --git a/src/bltVector.C b/src/bltVector.C index 735f382..6420ea5 100644 --- a/src/bltVector.C +++ b/src/bltVector.C @@ -56,6 +56,8 @@ #include "bltSwitch.h" #include "bltOp.h" +using namespace Blt; + #define DEF_ARRAY_SIZE 64 #define TRACE_ALL (TCL_TRACE_WRITES | TCL_TRACE_READS | TCL_TRACE_UNSETS) @@ -116,7 +118,7 @@ typedef int (VectorCmdProc)(Vector* vecObjPtr, Tcl_Interp* interp, static char stringRep[200]; -const char *Blt_Itoa(int value) +const char *Blt::Itoa(int value) { snprintf(stringRep, 200, "%d", value); return stringRep; @@ -136,7 +138,7 @@ static Vector* FindVectorInNamespace(VectorInterpData *dataPtr, Blt_ObjectName *objNamePtr) { Tcl_DString dString; - const char* name = Blt_MakeQualifiedName(objNamePtr, &dString); + const char* name = MakeQualifiedName(objNamePtr, &dString); Tcl_HashEntry* hPtr = Tcl_FindHashEntry(&dataPtr->vectorTable, name); Tcl_DStringFree(&dString); if (hPtr != NULL) @@ -150,7 +152,7 @@ static Vector* GetVectorObject(VectorInterpData *dataPtr, const char *name, { Tcl_Interp* interp = dataPtr->interp; Blt_ObjectName objName; - if (!Blt_ParseObjectName(interp, name, &objName, BLT_NO_ERROR_MSG | BLT_NO_DEFAULT_NS)) + if (!ParseObjectName(interp, name, &objName, BLT_NO_ERROR_MSG | BLT_NO_DEFAULT_NS)) return NULL; Vector* vPtr = NULL; @@ -170,7 +172,7 @@ static Vector* GetVectorObject(VectorInterpData *dataPtr, const char *name, return vPtr; } -void Blt_Vec_UpdateRange(Vector* vPtr) +void Blt::Vec_UpdateRange(Vector* vPtr) { double* vp = vPtr->valueArr + vPtr->first; double* vend = vPtr->valueArr + vPtr->last; @@ -187,7 +189,7 @@ void Blt_Vec_UpdateRange(Vector* vPtr) vPtr->notifyFlags &= ~UPDATE_RANGE; } -int Blt_Vec_GetIndex(Tcl_Interp* interp, Vector* vPtr, const char *string, +int Blt::Vec_GetIndex(Tcl_Interp* interp, Vector* vPtr, const char *string, int *indexPtr, int flags, Blt_VectorIndexProc **procPtrPtr) { int value; @@ -253,8 +255,8 @@ int Blt_Vec_GetIndex(Tcl_Interp* interp, Vector* vPtr, const char *string, return TCL_OK; } -int Blt_Vec_GetIndexRange(Tcl_Interp* interp, Vector* vPtr, const char *string, - int flags, Blt_VectorIndexProc** procPtrPtr) +int Blt::Vec_GetIndexRange(Tcl_Interp* interp, Vector* vPtr, const char *string, + int flags, Blt_VectorIndexProc** procPtrPtr) { int ielem; char* colon = NULL; @@ -269,7 +271,7 @@ int Blt_Vec_GetIndexRange(Tcl_Interp* interp, Vector* vPtr, const char *string, int result; *colon = '\0'; - result = Blt_Vec_GetIndex(interp, vPtr, string, &ielem, flags, + result = Vec_GetIndex(interp, vPtr, string, &ielem, flags, (Blt_VectorIndexProc **) NULL); *colon = ':'; if (result != TCL_OK) { @@ -281,7 +283,7 @@ int Blt_Vec_GetIndexRange(Tcl_Interp* interp, Vector* vPtr, const char *string, /* Default to the last index */ vPtr->last = (vPtr->length > 0) ? vPtr->length - 1 : 0; } else { - if (Blt_Vec_GetIndex(interp, vPtr, colon + 1, &ielem, flags, + if (Vec_GetIndex(interp, vPtr, colon + 1, &ielem, flags, (Blt_VectorIndexProc **) NULL) != TCL_OK) { return TCL_ERROR; } @@ -295,7 +297,7 @@ int Blt_Vec_GetIndexRange(Tcl_Interp* interp, Vector* vPtr, const char *string, return TCL_ERROR; } } else { - if (Blt_Vec_GetIndex(interp, vPtr, string, &ielem, flags, + if (Vec_GetIndex(interp, vPtr, string, &ielem, flags, procPtrPtr) != TCL_OK) { return TCL_ERROR; } @@ -304,7 +306,7 @@ int Blt_Vec_GetIndexRange(Tcl_Interp* interp, Vector* vPtr, const char *string, return TCL_OK; } -Vector* Blt_Vec_ParseElement(Tcl_Interp* interp, VectorInterpData *dataPtr, +Vector* Blt::Vec_ParseElement(Tcl_Interp* interp, VectorInterpData *dataPtr, const char* start, const char** endPtr, int flags) { char* p = (char*)start; @@ -354,8 +356,7 @@ Vector* Blt_Vec_ParseElement(Tcl_Interp* interp, VectorInterpData *dataPtr, return NULL; } *p = '\0'; - result = Blt_Vec_GetIndexRange(interp, vPtr, start, - (INDEX_COLON | INDEX_CHECK), (Blt_VectorIndexProc **) NULL); + result = Vec_GetIndexRange(interp, vPtr, start, (INDEX_COLON | INDEX_CHECK), (Blt_VectorIndexProc **) NULL); *p = ')'; if (result != TCL_OK) { return NULL; @@ -397,7 +398,7 @@ void Blt_Vec_NotifyClients(ClientData clientData) } } -void Blt_Vec_UpdateClients(Vector* vPtr) +void Blt::Vec_UpdateClients(Vector* vPtr) { vPtr->dirty++; vPtr->max = vPtr->min = NAN; @@ -415,7 +416,7 @@ void Blt_Vec_UpdateClients(Vector* vPtr) } } -void Blt_Vec_FlushCache(Vector* vPtr) +void Blt::Vec_FlushCache(Vector* vPtr) { Tcl_Interp* interp = vPtr->interp; @@ -426,7 +427,7 @@ void Blt_Vec_FlushCache(Vector* vPtr) * elements in the array. */ Tcl_UntraceVar2(interp, vPtr->arrayName, (char *)NULL, - TRACE_ALL | vPtr->varFlags, Blt_Vec_VarTrace, vPtr); + TRACE_ALL | vPtr->varFlags, Vec_VarTrace, vPtr); /* Clear all the element entries from the entire array */ Tcl_UnsetVar2(interp, vPtr->arrayName, (char *)NULL, vPtr->varFlags); @@ -434,15 +435,15 @@ void Blt_Vec_FlushCache(Vector* vPtr) /* Restore the "end" index by default and the trace on the entire array */ Tcl_SetVar2(interp, vPtr->arrayName, "end", "", vPtr->varFlags); Tcl_TraceVar2(interp, vPtr->arrayName, (char *)NULL, - TRACE_ALL | vPtr->varFlags, Blt_Vec_VarTrace, vPtr); + TRACE_ALL | vPtr->varFlags, Vec_VarTrace, vPtr); } -int Blt_Vec_LookupName(VectorInterpData *dataPtr, const char *vecName, +int Blt::Vec_LookupName(VectorInterpData *dataPtr, const char *vecName, Vector** vPtrPtr) { const char *endPtr; - Vector* vPtr = Blt_Vec_ParseElement(dataPtr->interp, dataPtr, vecName, &endPtr, NS_SEARCH_BOTH); + Vector* vPtr = Vec_ParseElement(dataPtr->interp, dataPtr, vecName, &endPtr, NS_SEARCH_BOTH); if (vPtr == NULL) return TCL_ERROR; @@ -456,7 +457,7 @@ int Blt_Vec_LookupName(VectorInterpData *dataPtr, const char *vecName, return TCL_OK; } -double Blt_Vec_Min(Vector* vecObjPtr) +double Blt::Vec_Min(Vector* vecObjPtr) { double* vp = vecObjPtr->valueArr + vecObjPtr->first; double* vend = vecObjPtr->valueArr + vecObjPtr->last; @@ -469,7 +470,7 @@ double Blt_Vec_Min(Vector* vecObjPtr) return vecObjPtr->min; } -double Blt_Vec_Max(Vector* vecObjPtr) +double Blt::Vec_Max(Vector* vecObjPtr) { double max = NAN; double* vp = vecObjPtr->valueArr + vecObjPtr->first; @@ -493,8 +494,8 @@ static void DeleteCommand(Vector* vPtr) Tcl_DStringInit(&dString); objName.name = Tcl_GetCommandName(interp, vPtr->cmdToken); - objName.nsPtr = Blt_GetCommandNamespace(vPtr->cmdToken); - qualName = Blt_MakeQualifiedName(&objName, &dString); + objName.nsPtr = GetCommandNamespace(vPtr->cmdToken); + qualName = MakeQualifiedName(&objName, &dString); if (Tcl_GetCommandInfo(interp, qualName, &cmdInfo)) { // Disable the callback before deleting the TCL command cmdInfo.deleteProc = NULL; @@ -511,7 +512,7 @@ static void UnmapVariable(Vector* vPtr) // Unset the entire array Tcl_UntraceVar2(interp, vPtr->arrayName, (char *)NULL, - (TRACE_ALL | vPtr->varFlags), Blt_Vec_VarTrace, vPtr); + (TRACE_ALL | vPtr->varFlags), Vec_VarTrace, vPtr); Tcl_UnsetVar2(interp, vPtr->arrayName, (char *)NULL, vPtr->varFlags); if (vPtr->arrayName != NULL) { @@ -520,7 +521,7 @@ static void UnmapVariable(Vector* vPtr) } } -int Blt_Vec_MapVariable(Tcl_Interp* interp, Vector* vPtr, const char *path) +int Blt::Vec_MapVariable(Tcl_Interp* interp, Vector* vPtr, const char *path) { Blt_ObjectName objName; char *newPath; @@ -536,7 +537,7 @@ int Blt_Vec_MapVariable(Tcl_Interp* interp, Vector* vPtr, const char *path) * existing variable. */ } /* Get the variable name (without the namespace qualifier). */ - if (!Blt_ParseObjectName(interp, path, &objName, BLT_NO_DEFAULT_NS)) { + if (!ParseObjectName(interp, path, &objName, BLT_NO_DEFAULT_NS)) { return TCL_ERROR; } if (objName.nsPtr == NULL) { @@ -544,12 +545,12 @@ int Blt_Vec_MapVariable(Tcl_Interp* interp, Vector* vPtr, const char *path) * If there was no namespace qualifier, try harder to see if the * variable is non-local. */ - objName.nsPtr = Blt_GetVariableNamespace(interp, objName.name); + objName.nsPtr = GetVariableNamespace(interp, objName.name); } Tcl_DStringInit(&dString); vPtr->varFlags = 0; if (objName.nsPtr != NULL) { /* Global or namespace variable. */ - newPath = Blt_MakeQualifiedName(&objName, &dString); + newPath = MakeQualifiedName(&objName, &dString); vPtr->varFlags |= (TCL_GLOBAL_ONLY); } else { /* Local variable. */ newPath = (char *)objName.name; @@ -572,14 +573,14 @@ int Blt_Vec_MapVariable(Tcl_Interp* interp, Vector* vPtr, const char *path) return TCL_ERROR; } /* Create a full-array trace on reads, writes, and unsets. */ - Tcl_TraceVar2(interp, newPath, (char *)NULL, TRACE_ALL, Blt_Vec_VarTrace, + Tcl_TraceVar2(interp, newPath, (char *)NULL, TRACE_ALL, Vec_VarTrace, vPtr); vPtr->arrayName = Blt_Strdup(newPath); Tcl_DStringFree(&dString); return TCL_OK; } -int Blt_Vec_SetSize(Tcl_Interp* interp, Vector* vPtr, int newSize) +int Blt::Vec_SetSize(Tcl_Interp* interp, Vector* vPtr, int newSize) { if (newSize <= 0) { newSize = DEF_ARRAY_SIZE; @@ -594,7 +595,7 @@ int Blt_Vec_SetSize(Tcl_Interp* interp, Vector* vPtr, int newSize) if (newArr == NULL) { if (interp != NULL) { Tcl_AppendResult(interp, "can't reallocate ", - Blt_Itoa(newSize), " elements for vector \"", + Itoa(newSize), " elements for vector \"", vPtr->name, "\"", (char *)NULL); } return TCL_ERROR; @@ -612,7 +613,7 @@ int Blt_Vec_SetSize(Tcl_Interp* interp, Vector* vPtr, int newSize) if (newArr == NULL) { if (interp != NULL) { Tcl_AppendResult(interp, "can't allocate ", - Blt_Itoa(newSize), " elements for vector \"", + Itoa(newSize), " elements for vector \"", vPtr->name, "\"", (char *)NULL); } return TCL_ERROR; @@ -653,10 +654,10 @@ int Blt_Vec_SetSize(Tcl_Interp* interp, Vector* vPtr, int newSize) return TCL_OK; } -int Blt_Vec_SetLength(Tcl_Interp* interp, Vector* vPtr, int newLength) +int Blt::Vec_SetLength(Tcl_Interp* interp, Vector* vPtr, int newLength) { if (vPtr->size < newLength) { - if (Blt_Vec_SetSize(interp, vPtr, newLength) != TCL_OK) { + if (Vec_SetSize(interp, vPtr, newLength) != TCL_OK) { return TCL_ERROR; } } @@ -666,7 +667,7 @@ int Blt_Vec_SetLength(Tcl_Interp* interp, Vector* vPtr, int newLength) return TCL_OK; } -int Blt_Vec_ChangeLength(Tcl_Interp* interp, Vector* vPtr, int newLength) +int Blt::Vec_ChangeLength(Tcl_Interp* interp, Vector* vPtr, int newLength) { if (newLength < 0) { newLength = 0; @@ -681,7 +682,7 @@ int Blt_Vec_ChangeLength(Tcl_Interp* interp, Vector* vPtr, int newLength) newSize += newSize; } if (newSize != vPtr->size) { - if (Blt_Vec_SetSize(interp, vPtr, newSize) != TCL_OK) { + if (Vec_SetSize(interp, vPtr, newSize) != TCL_OK) { return TCL_ERROR; } } @@ -693,7 +694,7 @@ int Blt_Vec_ChangeLength(Tcl_Interp* interp, Vector* vPtr, int newLength) } -int Blt_Vec_Reset(Vector* vPtr, double *valueArr, int length, +int Blt::Vec_Reset(Vector* vPtr, double *valueArr, int length, int size, Tcl_FreeProc *freeProc) { if (vPtr->valueArr != valueArr) { /* New array of values resides @@ -705,7 +706,7 @@ int Blt_Vec_Reset(Vector* vPtr, double *valueArr, int length, size = DEF_ARRAY_SIZE; if (valueArr == NULL) { Tcl_AppendResult(vPtr->interp, "can't allocate ", - Blt_Itoa(size), " elements for vector \"", + Itoa(size), " elements for vector \"", vPtr->name, "\"", (char *)NULL); return TCL_ERROR; } @@ -717,7 +718,7 @@ int Blt_Vec_Reset(Vector* vPtr, double *valueArr, int length, double* newArr = (double*)malloc(size * sizeof(double)); if (newArr == NULL) { Tcl_AppendResult(vPtr->interp, "can't allocate ", - Blt_Itoa(size), " elements for vector \"", + Itoa(size), " elements for vector \"", vPtr->name, "\"", (char *)NULL); return TCL_ERROR; } @@ -743,13 +744,13 @@ int Blt_Vec_Reset(Vector* vPtr, double *valueArr, int length, vPtr->length = length; if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); return TCL_OK; } -Vector* Blt_Vec_New(VectorInterpData *dataPtr) +Vector* Blt::Vec_New(VectorInterpData *dataPtr) { Vector* vPtr = (Vector*)calloc(1, sizeof(Vector)); vPtr->valueArr = (double*)malloc(sizeof(double) * DEF_ARRAY_SIZE); @@ -770,7 +771,7 @@ Vector* Blt_Vec_New(VectorInterpData *dataPtr) return vPtr; } -void Blt_Vec_Free(Vector* vPtr) +void Blt::Vec_Free(Vector* vPtr) { Blt_ChainLink link; @@ -818,10 +819,10 @@ static void VectorInstDeleteProc(ClientData clientData) { Vector* vPtr = (Vector*)clientData; vPtr->cmdToken = 0; - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); } -Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, +Vector* Blt::Vec_Create(VectorInterpData *dataPtr, const char *vecName, const char *cmdName, const char *varName, int *isNewPtr) { Tcl_DString dString; @@ -833,7 +834,7 @@ Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, int isNew = 0; Vector* vPtr = NULL; - if (!Blt_ParseObjectName(interp, vecName, &objName, 0)) + if (!ParseObjectName(interp, vecName, &objName, 0)) return NULL; Tcl_DStringInit(&dString); @@ -844,7 +845,7 @@ Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, snprintf(string, 200, "vector%d", dataPtr->nextId++); objName.name = string; - qualName = Blt_MakeQualifiedName(&objName, &dString); + qualName = MakeQualifiedName(&objName, &dString); hPtr = Tcl_FindHashEntry(&dataPtr->vectorTable, qualName); } while (hPtr != NULL); } else { @@ -858,13 +859,13 @@ Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, goto error; } } - qualName = Blt_MakeQualifiedName(&objName, &dString); - vPtr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, dataPtr, qualName, + qualName = MakeQualifiedName(&objName, &dString); + vPtr = Vec_ParseElement((Tcl_Interp *)NULL, dataPtr, qualName, NULL, NS_SEARCH_CURRENT); } if (vPtr == NULL) { hPtr = Tcl_CreateHashEntry(&dataPtr->vectorTable, qualName, &isNew); - vPtr = Blt_Vec_New(dataPtr); + vPtr = Vec_New(dataPtr); vPtr->hashPtr = hPtr; vPtr->nsPtr = objName.nsPtr; @@ -900,13 +901,13 @@ Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, Tcl_DStringInit(&dString2); if (cmdName != qualName) { - if (!Blt_ParseObjectName(interp, cmdName, &objName, 0)) { + if (!ParseObjectName(interp, cmdName, &objName, 0)) { goto error; } - cmdName = Blt_MakeQualifiedName(&objName, &dString2); + cmdName = MakeQualifiedName(&objName, &dString2); } - vPtr->cmdToken = Tcl_CreateObjCommand(interp, (char *)cmdName, - Blt_Vec_InstCmd, vPtr, VectorInstDeleteProc); + vPtr->cmdToken = Tcl_CreateObjCommand(interp, (char *)cmdName, Vec_InstCmd, + vPtr, VectorInstDeleteProc); Tcl_DStringFree(&dString2); } checkVariable: @@ -914,7 +915,7 @@ Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, if ((varName[0] == '#') && (strcmp(varName, "#auto") == 0)) { varName = qualName; } - if (Blt_Vec_MapVariable(interp, vPtr, varName) != TCL_OK) { + if (Vec_MapVariable(interp, vPtr, varName) != TCL_OK) { goto error; } } @@ -926,12 +927,12 @@ Vector* Blt_Vec_Create(VectorInterpData *dataPtr, const char *vecName, error: Tcl_DStringFree(&dString); if (vPtr != NULL) { - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); } return NULL; } -int Blt_Vec_Duplicate(Vector* destPtr, Vector* srcPtr) +int Blt::Vec_Duplicate(Vector* destPtr, Vector* srcPtr) { size_t nBytes; size_t length; @@ -940,7 +941,7 @@ int Blt_Vec_Duplicate(Vector* destPtr, Vector* srcPtr) /* Copying the same vector. */ } length = srcPtr->last - srcPtr->first + 1; - if (Blt_Vec_ChangeLength(destPtr->interp, destPtr, length) != TCL_OK) { + if (Vec_ChangeLength(destPtr->interp, destPtr, length) != TCL_OK) { return TCL_ERROR; } nBytes = length * sizeof(double); @@ -1017,7 +1018,7 @@ static int VectorCreate2(ClientData clientData, Tcl_Interp* interp, return TCL_ERROR; } memset(&switches, 0, sizeof(switches)); - if (Blt_ParseSwitches(interp, createSwitches, objc - i, objv + i, + if (ParseSwitches(interp, createSwitches, objc - i, objv + i, &switches, BLT_SWITCH_DEFAULTS) < 0) { return TCL_ERROR; } @@ -1093,7 +1094,7 @@ static int VectorCreate2(ClientData clientData, Tcl_Interp* interp, /* * By default, we create a TCL command by the name of the vector. */ - vPtr = Blt_Vec_Create(dataPtr, string, + vPtr = Vec_Create(dataPtr, string, (switches.cmdName == NULL) ? string : switches.cmdName, (switches.varName == NULL) ? string : switches.varName, &isNew); if (leftParen != NULL) { @@ -1106,25 +1107,25 @@ static int VectorCreate2(ClientData clientData, Tcl_Interp* interp, vPtr->flush = switches.flush; vPtr->offset = first; if (size > 0) { - if (Blt_Vec_ChangeLength(interp, vPtr, size) != TCL_OK) { + if (Vec_ChangeLength(interp, vPtr, size) != TCL_OK) { goto error; } } if (!isNew) { if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); } } - Blt_FreeSwitches(createSwitches, (char *)&switches, 0); + FreeSwitches(createSwitches, (char *)&switches, 0); if (vPtr != NULL) { /* Return the name of the last vector created */ Tcl_SetStringObj(Tcl_GetObjResult(interp), vPtr->name, -1); } return TCL_OK; error: - Blt_FreeSwitches(createSwitches, (char *)&switches, 0); + FreeSwitches(createSwitches, (char *)&switches, 0); return TCL_ERROR; } @@ -1141,9 +1142,9 @@ static int VectorDestroyOp(ClientData clientData, Tcl_Interp* interp, for (int ii=2; iihashPtr = NULL; - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); } Tcl_DeleteHashTable(&dataPtr->vectorTable); /* If any user-defined math functions were installed, remove them. */ - Blt_Vec_UninstallMathFunctions(&dataPtr->mathProcTable); + Vec_UninstallMathFunctions(&dataPtr->mathProcTable); Tcl_DeleteHashTable(&dataPtr->mathProcTable); Tcl_DeleteHashTable(&dataPtr->indexProcTable); @@ -1222,7 +1223,7 @@ static void VectorInterpDeleteProc(ClientData clientData, Tcl_Interp* interp) free(dataPtr); } -VectorInterpData *Blt_Vec_GetInterpData(Tcl_Interp* interp) +VectorInterpData* Blt::Vec_GetInterpData(Tcl_Interp* interp) { VectorInterpData *dataPtr; Tcl_InterpDeleteProc *proc; @@ -1238,8 +1239,8 @@ VectorInterpData *Blt_Vec_GetInterpData(Tcl_Interp* interp) Tcl_InitHashTable(&dataPtr->vectorTable, TCL_STRING_KEYS); Tcl_InitHashTable(&dataPtr->mathProcTable, TCL_STRING_KEYS); Tcl_InitHashTable(&dataPtr->indexProcTable, TCL_STRING_KEYS); - Blt_Vec_InstallMathFunctions(&dataPtr->mathProcTable); - Blt_Vec_InstallSpecialIndices(&dataPtr->indexProcTable); + Vec_InstallMathFunctions(&dataPtr->mathProcTable); + Vec_InstallSpecialIndices(&dataPtr->indexProcTable); srand48(time((time_t *) NULL)); } return dataPtr; @@ -1259,7 +1260,7 @@ int Blt_VectorCmdInitProc(Tcl_Interp* interp) if (cmdToken) return TCL_OK; cmdToken = Tcl_CreateObjCommand(interp, cmdPath, VectorCmd, - Blt_Vec_GetInterpData(interp), NULL); + Vec_GetInterpData(interp), NULL); if (Tcl_Export(interp, nsPtr, "vector", 0) != TCL_OK) return TCL_ERROR; @@ -1278,21 +1279,21 @@ int Blt_CreateVector2(Tcl_Interp* interp, const char *vecName, char *nameCopy; if (initialSize < 0) { - Tcl_AppendResult(interp, "bad vector size \"", Blt_Itoa(initialSize), + Tcl_AppendResult(interp, "bad vector size \"", Itoa(initialSize), "\"", (char *)NULL); return TCL_ERROR; } - dataPtr = Blt_Vec_GetInterpData(interp); + dataPtr = Vec_GetInterpData(interp); nameCopy = Blt_Strdup(vecName); - vPtr = Blt_Vec_Create(dataPtr, nameCopy, cmdName, varName, &isNew); + vPtr = Vec_Create(dataPtr, nameCopy, cmdName, varName, &isNew); free(nameCopy); if (vPtr == NULL) { return TCL_ERROR; } if (initialSize > 0) { - if (Blt_Vec_ChangeLength(interp, vPtr, initialSize) != TCL_OK) { + if (Vec_ChangeLength(interp, vPtr, initialSize) != TCL_OK) { return TCL_ERROR; } } @@ -1312,25 +1313,25 @@ int Blt_DeleteVector(Blt_Vector* vecPtr) { Vector* vPtr = (Vector* )vecPtr; - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); return TCL_OK; } int Blt_DeleteVectorByName(Tcl_Interp* interp, const char *name) { // If the vector name was passed via a read-only string (e.g. "x"), the - // Blt_Vec_ParseElement routine will segfault when it tries to write into + // Vec_ParseElement routine will segfault when it tries to write into // the string. Therefore make a writable copy and free it when we're done. char* nameCopy = Blt_Strdup(name); - VectorInterpData *dataPtr = Blt_Vec_GetInterpData(interp); + VectorInterpData *dataPtr = Vec_GetInterpData(interp); Vector* vPtr; - int result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr); + int result = Vec_LookupName(dataPtr, nameCopy, &vPtr); free(nameCopy); if (result != TCL_OK) return TCL_ERROR; - Blt_Vec_Free(vPtr); + Vec_Free(vPtr); return TCL_OK; } @@ -1338,7 +1339,7 @@ int Blt_VectorExists2(Tcl_Interp* interp, const char *vecName) { VectorInterpData *dataPtr; - dataPtr = Blt_Vec_GetInterpData(interp); + dataPtr = Vec_GetInterpData(interp); if (GetVectorObject(dataPtr, vecName, NS_SEARCH_BOTH) != NULL) { return 1; } @@ -1369,7 +1370,7 @@ int Blt_GetVector(Tcl_Interp* interp, const char *name, Blt_Vector* *vecPtrPtr) char *nameCopy; int result; - dataPtr = Blt_Vec_GetInterpData(interp); + dataPtr = Vec_GetInterpData(interp); /* * If the vector name was passed via a read-only string (e.g. "x"), the * Blt_VectorParseName routine will segfault when it tries to write into @@ -1377,12 +1378,12 @@ int Blt_GetVector(Tcl_Interp* interp, const char *name, Blt_Vector* *vecPtrPtr) * done. */ nameCopy = Blt_Strdup(name); - result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr); + result = Vec_LookupName(dataPtr, nameCopy, &vPtr); free(nameCopy); if (result != TCL_OK) { return TCL_ERROR; } - Blt_Vec_UpdateRange(vPtr); + Vec_UpdateRange(vPtr); *vecPtrPtr = (Blt_Vector* ) vPtr; return TCL_OK; } @@ -1393,11 +1394,11 @@ int Blt_GetVectorFromObj(Tcl_Interp* interp, Tcl_Obj *objPtr, VectorInterpData *dataPtr; /* Interpreter-specific data. */ Vector* vPtr; - dataPtr = Blt_Vec_GetInterpData(interp); - if (Blt_Vec_LookupName(dataPtr, Tcl_GetString(objPtr), &vPtr) != TCL_OK) { + dataPtr = Vec_GetInterpData(interp); + if (Vec_LookupName(dataPtr, Tcl_GetString(objPtr), &vPtr) != TCL_OK) { return TCL_ERROR; } - Blt_Vec_UpdateRange(vPtr); + Vec_UpdateRange(vPtr); *vecPtrPtr = (Blt_Vector* ) vPtr; return TCL_OK; } @@ -1411,22 +1412,22 @@ int Blt_ResetVector(Blt_Vector* vecPtr, double *valueArr, int length, Tcl_AppendResult(vPtr->interp, "bad array size", (char *)NULL); return TCL_ERROR; } - return Blt_Vec_Reset(vPtr, valueArr, length, size, freeProc); + return Vec_Reset(vPtr, valueArr, length, size, freeProc); } int Blt_ResizeVector(Blt_Vector* vecPtr, int length) { Vector* vPtr = (Vector* )vecPtr; - if (Blt_Vec_ChangeLength((Tcl_Interp *)NULL, vPtr, length) != TCL_OK) { + if (Vec_ChangeLength((Tcl_Interp *)NULL, vPtr, length) != TCL_OK) { Tcl_AppendResult(vPtr->interp, "can't resize vector \"", vPtr->name, "\"", (char *)NULL); return TCL_ERROR; } if (vPtr->flush) { - Blt_Vec_FlushCache(vPtr); + Vec_FlushCache(vPtr); } - Blt_Vec_UpdateClients(vPtr); + Vec_UpdateClients(vPtr); return TCL_OK; } @@ -1439,7 +1440,7 @@ Blt_VectorId Blt_AllocVectorId(Tcl_Interp* interp, const char *name) int result; char *nameCopy; - dataPtr = Blt_Vec_GetInterpData(interp); + dataPtr = Vec_GetInterpData(interp); /* * If the vector name was passed via a read-only string (e.g. "x"), the * Blt_VectorParseName routine will segfault when it tries to write into @@ -1447,7 +1448,7 @@ Blt_VectorId Blt_AllocVectorId(Tcl_Interp* interp, const char *name) * done. */ nameCopy = Blt_Strdup(name); - result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr); + result = Vec_LookupName(dataPtr, nameCopy, &vPtr); free(nameCopy); if (result != TCL_OK) { @@ -1507,17 +1508,6 @@ const char* Blt_NameOfVector(Blt_Vector* vecPtr) /* Vector to query. */ return vPtr->name; } -int Blt_VectorNotifyPending(Blt_VectorId clientId) -{ - VectorClient *clientPtr = (VectorClient *)clientId; - - if ((clientPtr == NULL) || (clientPtr->magic != VECTOR_MAGIC) || - (clientPtr->serverPtr == NULL)) { - return 0; - } - return (clientPtr->serverPtr->notifyFlags & NOTIFY_PENDING); -} - int Blt_GetVectorById(Tcl_Interp* interp, Blt_VectorId clientId, Blt_Vector* *vecPtrPtr) { @@ -1531,7 +1521,7 @@ int Blt_GetVectorById(Tcl_Interp* interp, Blt_VectorId clientId, Tcl_AppendResult(interp, "vector no longer exists", (char *)NULL); return TCL_ERROR; } - Blt_Vec_UpdateRange(clientPtr->serverPtr); + Vec_UpdateRange(clientPtr->serverPtr); *vecPtrPtr = (Blt_Vector* ) clientPtr->serverPtr; return TCL_OK; } @@ -1543,7 +1533,7 @@ void Blt_InstallIndexProc(Tcl_Interp* interp, const char *string, Tcl_HashEntry *hPtr; int isNew; - dataPtr = Blt_Vec_GetInterpData(interp); + dataPtr = Vec_GetInterpData(interp); hPtr = Tcl_CreateHashEntry(&dataPtr->indexProcTable, string, &isNew); if (procPtr == NULL) { Tcl_DeleteHashEntry(hPtr); @@ -1618,7 +1608,7 @@ smallest_power_of_2_not_less_than(int x) return pow2; } -int Blt_Vec_FFT(Tcl_Interp* interp, Vector* realPtr, Vector* phasesPtr, +int Blt::Vec_FFT(Tcl_Interp* interp, Vector* realPtr, Vector* phasesPtr, Vector* freqPtr, double delta, int flags, Vector* srcPtr) { int length; @@ -1649,7 +1639,7 @@ int Blt_Vec_FFT(Tcl_Interp* interp, Vector* realPtr, Vector* phasesPtr, "\" can't be the same as the source", (char *)NULL); return TCL_ERROR; } - if (Blt_Vec_ChangeLength(interp, phasesPtr, + if (Vec_ChangeLength(interp, phasesPtr, pow2len/2-noconstant+middle) != TCL_OK) { return TCL_ERROR; } @@ -1660,7 +1650,7 @@ int Blt_Vec_FFT(Tcl_Interp* interp, Vector* realPtr, Vector* phasesPtr, "\" can't be the same as the source", (char *)NULL); return TCL_ERROR; } - if (Blt_Vec_ChangeLength(interp, freqPtr, + if (Vec_ChangeLength(interp, freqPtr, pow2len/2-noconstant+middle) != TCL_OK) { return TCL_ERROR; } @@ -1760,7 +1750,7 @@ int Blt_Vec_FFT(Tcl_Interp* interp, Vector* realPtr, Vector* phasesPtr, } -int Blt_Vec_InverseFFT(Tcl_Interp* interp, Vector* srcImagPtr, +int Blt::Vec_InverseFFT(Tcl_Interp* interp, Vector* srcImagPtr, Vector* destRealPtr, Vector* destImagPtr, Vector* srcPtr) { int length; @@ -1779,10 +1769,10 @@ int Blt_Vec_InverseFFT(Tcl_Interp* interp, Vector* srcImagPtr, pow2len = smallest_power_of_2_not_less_than( (length-1)*2 ); oneOverN = 1.0 / pow2len; - if (Blt_Vec_ChangeLength(interp, destRealPtr, pow2len) != TCL_OK) { + if (Vec_ChangeLength(interp, destRealPtr, pow2len) != TCL_OK) { return TCL_ERROR; } - if (Blt_Vec_ChangeLength(interp, destImagPtr, pow2len) != TCL_OK) { + if (Vec_ChangeLength(interp, destImagPtr, pow2len) != TCL_OK) { return TCL_ERROR; } diff --git a/src/bltVector.h b/src/bltVector.h index b0be76d..04d5b1d 100644 --- a/src/bltVector.h +++ b/src/bltVector.h @@ -87,29 +87,40 @@ typedef enum { #define Blt_VecSize(v) ((v)->arraySize) #define Blt_VecDirty(v) ((v)->dirty) +namespace Blt { + extern int ExprVector(Tcl_Interp* interp, char *expr, Blt_Vector *vecPtr); +}; + extern "C" { - int Blt_CreateVector(Tcl_Interp* interp, const char *vecName, int size, Blt_Vector ** vecPtrPtr); - int Blt_CreateVector2(Tcl_Interp* interp, const char *vecName, const char *cmdName, const char *varName, int initialSize, Blt_Vector **vecPtrPtr); + int Blt_CreateVector(Tcl_Interp* interp, const char *vecName, + int size, Blt_Vector** vecPtrPtr); + int Blt_CreateVector2(Tcl_Interp* interp, const char *vecName, + const char *cmdName, const char *varName, + int initialSize, Blt_Vector **vecPtrPtr); int Blt_DeleteVectorByName(Tcl_Interp* interp, const char *vecName); int Blt_DeleteVector(Blt_Vector *vecPtr); - int Blt_GetVector(Tcl_Interp* interp, const char *vecName, Blt_Vector **vecPtrPtr); - int Blt_GetVectorFromObj(Tcl_Interp* interp, Tcl_Obj *objPtr, Blt_Vector **vecPtrPtr); - int Blt_ResetVector(Blt_Vector *vecPtr, double *dataArr, int n, int arraySize, Tcl_FreeProc *freeProc); + int Blt_GetVector(Tcl_Interp* interp, const char *vecName, + Blt_Vector **vecPtrPtr); + int Blt_GetVectorFromObj(Tcl_Interp* interp, Tcl_Obj *objPtr, + Blt_Vector **vecPtrPtr); + int Blt_ResetVector(Blt_Vector *vecPtr, double *dataArr, int n, + int arraySize, Tcl_FreeProc *freeProc); int Blt_ResizeVector(Blt_Vector *vecPtr, int n); int Blt_VectorExists(Tcl_Interp* interp, const char *vecName); int Blt_VectorExists2(Tcl_Interp* interp, const char *vecName); Blt_VectorId Blt_AllocVectorId(Tcl_Interp* interp, const char *vecName); - int Blt_GetVectorById(Tcl_Interp* interp, Blt_VectorId clientId, Blt_Vector **vecPtrPtr); - void Blt_SetVectorChangedProc(Blt_VectorId clientId, Blt_VectorChangedProc *proc, ClientData clientData); + int Blt_GetVectorById(Tcl_Interp* interp, Blt_VectorId clientId, + Blt_Vector **vecPtrPtr); + void Blt_SetVectorChangedProc(Blt_VectorId clientId, + Blt_VectorChangedProc *proc, + ClientData clientData); void Blt_FreeVectorId(Blt_VectorId clientId); const char *Blt_NameOfVectorId(Blt_VectorId clientId); const char *Blt_NameOfVector(Blt_Vector *vecPtr); - void Blt_InstallIndexProc(Tcl_Interp* interp, const char *indexName, Blt_VectorIndexProc * procPtr); + void Blt_InstallIndexProc(Tcl_Interp* interp, const char *indexName, + Blt_VectorIndexProc * procPtr); + double Blt_VecMin(Blt_Vector *vPtr); + double Blt_VecMax(Blt_Vector *vPtr); } -extern double Blt_VecMin(Blt_Vector *vPtr); -extern double Blt_VecMax(Blt_Vector *vPtr); -extern int Blt_VectorNotifyPending(Blt_VectorId clientId); -extern int Blt_ExprVector(Tcl_Interp* interp, char *expr, Blt_Vector *vecPtr); - #endif /* _BLT_VECTOR_H */ -- cgit v0.12