Eliminate (internal) TclOffset() usage, just use offsetof() in stead.

13 files changed, 23 insertions, 22 deletions

diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index d7eaf80..5d764e2 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -600,8 +600,8 @@ Tcl_CreateInterp(void)
 	/*NOTREACHED*/
 	Tcl_Panic("<time.h> is not compatible with MSVC");
     }
-    if ((TclOffset(Tcl_StatBuf,st_atime) != 32)
-	    || (TclOffset(Tcl_StatBuf,st_ctime) != 40)) {
+    if ((offsetof(Tcl_StatBuf,st_atime) != 32)
+	    || (offsetof(Tcl_StatBuf,st_ctime) != 40)) {
 	/*NOTREACHED*/
 	Tcl_Panic("<sys/stat.h> is not compatible with MSVC");
     }
diff --git a/generic/tclBinary.c b/generic/tclBinary.c
index 831a427..d8b9ae9 100644
--- a/generic/tclBinary.c
+++ b/generic/tclBinary.c
@@ -277,7 +277,7 @@ typedef struct ByteArray {
 } ByteArray;
 
 #define BYTEARRAY_SIZE(len) \
-		((unsigned) (TclOffset(ByteArray, bytes) + (len)))
+		(offsetof(ByteArray, bytes) + (len))
 #define GET_BYTEARRAY(irPtr) ((ByteArray *) (irPtr)->twoPtrValue.ptr1)
 #define SET_BYTEARRAY(irPtr, baPtr) \
 		(irPtr)->twoPtrValue.ptr1 = (void *) (baPtr)
diff --git a/generic/tclCkalloc.c b/generic/tclCkalloc.c
index 94327b5..d60633b 100644
--- a/generic/tclCkalloc.c
+++ b/generic/tclCkalloc.c
@@ -41,7 +41,7 @@ typedef struct MemTag {
 				 * last field in the structure. */
 } MemTag;
 
-#define TAG_SIZE(bytesInString) ((TclOffset(MemTag, string) + 1) + bytesInString)
+#define TAG_SIZE(bytesInString) ((offsetof(MemTag, string) + 1) + bytesInString)
 
 static MemTag *curTagPtr = NULL;/* Tag to use in all future mem_headers (set
 				 * by "memory tag" command). */
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index c53d3ad..0afa9cb 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -3030,7 +3030,7 @@ TclFindCompiledLocal(
 
     if (create || (name == NULL)) {
 	localVar = procPtr->numCompiledLocals;
-	localPtr = ckalloc(TclOffset(CompiledLocal, name) + nameBytes + 1);
+	localPtr = ckalloc(offsetof(CompiledLocal, name) + nameBytes + 1);
 	if (procPtr->firstLocalPtr == NULL) {
 	    procPtr->firstLocalPtr = procPtr->lastLocalPtr = localPtr;
 	} else {
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 6b69d97..8785d36 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -211,7 +211,7 @@ typedef struct TEBCdata {
  */
 
 #define VarHashGetValue(hPtr) \
-    ((Var *) ((char *)hPtr - TclOffset(VarInHash, entry)))
+    ((Var *) ((char *)hPtr - offsetof(VarInHash, entry)))
 
 static inline Var *
 VarHashCreateVar(
diff --git a/generic/tclHash.c b/generic/tclHash.c
index 6c21c59..9b462d9 100644
--- a/generic/tclHash.c
+++ b/generic/tclHash.c
@@ -809,7 +809,7 @@ AllocStringEntry(
     if (size < sizeof(hPtr->key)) {
 	allocsize = sizeof(hPtr->key);
     }
-    hPtr = ckalloc(TclOffset(Tcl_HashEntry, key) + allocsize);
+    hPtr = ckalloc(offsetof(Tcl_HashEntry, key) + allocsize);
     memcpy(hPtr->key.string, string, size);
     hPtr->clientData = 0;
     return hPtr;
diff --git a/generic/tclIO.h b/generic/tclIO.h
index 15f0f78..d10f268 100644
--- a/generic/tclIO.h
+++ b/generic/tclIO.h
@@ -50,7 +50,7 @@ typedef struct ChannelBuffer {
 				 * structure. */
 } ChannelBuffer;
 
-#define CHANNELBUFFER_HEADER_SIZE	TclOffset(ChannelBuffer, buf)
+#define CHANNELBUFFER_HEADER_SIZE	offsetof(ChannelBuffer, buf)
 
 /*
  * How much extra space to allocate in buffer to hold bytes from previous
diff --git a/generic/tclInt.h b/generic/tclInt.h
index e853f08..c844cc4 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4868,15 +4868,16 @@ MODULE_SCOPE Tcl_PackageInitProc Procbodytest_SafeInit;
 #endif
 
 /*
- * ----------------------------------------------------------------------
- * Macro to use to find the offset of a field in a structure. Computes number
- * of bytes from beginning of structure to a given field.
+ * Macro to use to find the offset of a field in astructure.
+ * Computes number of bytes from beginning of structure to a given field.
  */
 
-#ifdef offsetof
-#define TclOffset(type, field) ((int) offsetof(type, field))
-#else
-#define TclOffset(type, field) ((int) ((char *) &((type *) 0)->field))
+#ifndef TCL_NO_DEPRECATED
+#   define TclOffset(type, field) ((int) offsetof(type, field))
+#endif
+/* Workaround for platforms missing offsetof(), e.g. VC++ 6.0 */
+#ifndef offsetof
+#   define offsetof(type, field) ((size_t) ((char *) &((type *) 0)->field))
 #endif
 
 /*
diff --git a/generic/tclOOMethod.c b/generic/tclOOMethod.c
index db31795..32dd3c7 100644
--- a/generic/tclOOMethod.c
+++ b/generic/tclOOMethod.c
@@ -121,7 +121,7 @@ static const Tcl_MethodType fwdMethodType = {
 #define TclVarTable(contextNs) \
     ((Tcl_HashTable *) (&((Namespace *) (contextNs))->varTable))
 #define TclVarHashGetValue(hPtr) \
-    ((Tcl_Var) ((char *)hPtr - TclOffset(VarInHash, entry)))
+    ((Tcl_Var) ((char *)hPtr - offsetof(VarInHash, entry)))
 
 /*
  * ----------------------------------------------------------------------
diff --git a/generic/tclProc.c b/generic/tclProc.c
index f24dae8..afa00ee 100644
--- a/generic/tclProc.c
+++ b/generic/tclProc.c
@@ -634,7 +634,7 @@ TclCreateProc(
 	     * local variables for the argument.
 	     */
 
-	    localPtr = ckalloc(TclOffset(CompiledLocal, name) + fieldValues[0]->length +1);
+	    localPtr = ckalloc(offsetof(CompiledLocal, name) + fieldValues[0]->length +1);
 	    if (procPtr->firstLocalPtr == NULL) {
 		procPtr->firstLocalPtr = procPtr->lastLocalPtr = localPtr;
 	    } else {
diff --git a/generic/tclTest.c b/generic/tclTest.c
index 8474a91..4eb8519 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -7710,7 +7710,7 @@ MyCompiledVarFree(
 }
 
 #define TclVarHashGetValue(hPtr) \
-    ((Var *) ((char *)hPtr - TclOffset(VarInHash, entry)))
+    ((Var *) ((char *)hPtr - offsetof(VarInHash, entry)))
 
 static Tcl_Var
 MyCompiledVarFetch(
diff --git a/generic/tclTrace.c b/generic/tclTrace.c
index 20fa7e7..1a6d459 100644
--- a/generic/tclTrace.c
+++ b/generic/tclTrace.c
@@ -470,7 +470,7 @@ TraceExecutionObjCmd(
 	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
 	    TraceCommandInfo *tcmdPtr = ckalloc(
-		    TclOffset(TraceCommandInfo, command) + 1 + length);
+		    offsetof(TraceCommandInfo, command) + 1 + length);
 
 	    tcmdPtr->flags = flags;
 	    tcmdPtr->stepTrace = NULL;
@@ -707,7 +707,7 @@ TraceCommandObjCmd(
 	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
 	    TraceCommandInfo *tcmdPtr = ckalloc(
-		    TclOffset(TraceCommandInfo, command) + 1 + length);
+		    offsetof(TraceCommandInfo, command) + 1 + length);
 
 	    tcmdPtr->flags = flags;
 	    tcmdPtr->stepTrace = NULL;
@@ -910,7 +910,7 @@ TraceVariableObjCmd(
 	length = (size_t) commandLength;
 	if ((enum traceOptions) optionIndex == TRACE_ADD) {
 	    CombinedTraceVarInfo *ctvarPtr = ckalloc(
-		    TclOffset(CombinedTraceVarInfo, traceCmdInfo.command)
+		    offsetof(CombinedTraceVarInfo, traceCmdInfo.command)
 		    + 1 + length);
 
 	    ctvarPtr->traceCmdInfo.flags = flags;
diff --git a/generic/tclVar.c b/generic/tclVar.c
index e400369..e8ebd3c 100644
--- a/generic/tclVar.c
+++ b/generic/tclVar.c
@@ -45,7 +45,7 @@ static inline Var *	VarHashNextVar(Tcl_HashSearch *searchPtr);
 static inline void	CleanupVar(Var *varPtr, Var *arrayPtr);
 
 #define VarHashGetValue(hPtr) \
-    ((Var *) ((char *)hPtr - TclOffset(VarInHash, entry)))
+    ((Var *) ((char *)hPtr - offsetof(VarInHash, entry)))
 
 /*
  * NOTE: VarHashCreateVar increments the recount of its key argument.