Index: generic/nx.decls =================================================================== diff -u --- generic/nx.decls (revision 0) +++ generic/nx.decls (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,178 @@ +# nx.decls -- +# +# This file contains the declarations for all supported public +# functions that are exported by the Next scripting library via the stubs table. +# This file is used to generate the nxDecls.h, nxPlatDecls.h, +# nxStub.c, and nxPlatStub.c files. +# +# +# Copyright (c) 1998-1999 by Scriptics Corporation. +# See the file "tcl-license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +library nx + +interface nx +hooks {nxInt} + +# Declare each of the functions in the public Tcl interface. Note that +# the an index should never be reused for a different function in order +# to preserve backwards compatibility. + +declare 0 generic { + int Nx_Init(Tcl_Interp *interp) +} +# 1 is reserved for safe init +#declare 1 generic { +# int Nx_SafeInit(Tcl_Interp *interp) +#} +declare 2 generic { + struct XOTcl_Class *XOTclIsClass(Tcl_Interp *interp, ClientData cd) +} +#declare 3 generic { +# +#} +declare 4 generic { + struct XOTcl_Object *XOTclGetObject(Tcl_Interp *interp, CONST char *name) +} +declare 5 generic { + struct XOTcl_Class *XOTclGetClass(Tcl_Interp *interp, CONST char *name) +} +declare 6 generic { + int XOTclCreateObject(Tcl_Interp *interp, Tcl_Obj *name, struct XOTcl_Class *cl) +} +#declare 7 generic { +# +#} +#declare 8 generic { +# int XOTclCreateClass(Tcl_Interp *interp, Tcl_Obj *name, struct XOTcl_Class *cl) +#} +declare 9 generic { + int XOTclDeleteObject(Tcl_Interp *interp, struct XOTcl_Object *obj) +} +#declare 10 generic { +# int XOTclDeleteClass(Tcl_Interp *interp, struct XOTcl_Class *cl) +#} +#declare 11 generic { +# int XOTclAddObjectMethod(Tcl_Interp *interp, struct XOTcl_Object *obj, +# CONST char* nm, Tcl_ObjCmdProc* proc, +# ClientData cd, Tcl_CmdDeleteProc *dp) +#} +#declare 12 generic { +# int XOTclAddClassMethod(Tcl_Interp *interp, struct XOTcl_Class *cl, +# CONST char* nm, Tcl_ObjCmdProc* proc, +# ClientData cd, Tcl_CmdDeleteProc *dp) +#} +declare 13 generic { + int XOTclRemoveObjectMethod(Tcl_Interp *interp,struct XOTcl_Object *obj, CONST char *nm) +} +declare 14 generic { + int XOTclRemoveClassMethod(Tcl_Interp *interp, struct XOTcl_Class *cl, CONST char *nm) +} +declare 15 generic { + Tcl_Obj *XOTclOSetInstVar(struct XOTcl_Object *obj, Tcl_Interp *interp, + Tcl_Obj *name, Tcl_Obj *value, int flgs) +} +declare 16 generic { + Tcl_Obj *XOTclOGetInstVar(struct XOTcl_Object *obj, Tcl_Interp *interp, + Tcl_Obj *name, int flgs) +} +#declare 17 generic { +# int XOTclInstVar(struct XOTcl_Object *obj, Tcl_Interp *interp, +# char *name, char *destName) +#} +#declare 18 generic { +# +#} +declare 19 generic { + Tcl_Obj *XOTcl_ObjSetVar2(struct XOTcl_Object *obj, + Tcl_Interp *interp,Tcl_Obj *name1,Tcl_Obj *name2, + Tcl_Obj *value,int flgs) +} +declare 20 generic { + Tcl_Obj *XOTcl_ObjGetVar2(struct XOTcl_Object *obj, + Tcl_Interp *interp,Tcl_Obj *name1,Tcl_Obj *name2, + int flgs) +} +declare 21 generic { + int XOTclUnsetInstVar2(struct XOTcl_Object *obj, Tcl_Interp *interp, + CONST char *name1, CONST char *name2, + int flgs) +} +#declare 22 generic { +# int XOTcl_TraceObjCmd(ClientData cd, Tcl_Interp *interp, +# int objc, Tcl_Obj *CONST objv[]) +#} +declare 23 generic { + int XOTclErrMsg(Tcl_Interp *interp, char *msg, Tcl_FreeProc *type) +} +declare 24 generic { + int XOTclVarErrMsg(Tcl_Interp *interp, ...) +} +declare 25 generic { + int XOTclErrInProc (Tcl_Interp *interp, Tcl_Obj *objName, + Tcl_Obj *clName, CONST char *procName) +} +#declare 26 generic { +# +#} +declare 27 generic { + int XOTclErrBadVal_(Tcl_Interp *interp, char *expected, char *value) +} +declare 28 generic { + int XOTclObjErrType(Tcl_Interp *interp, Tcl_Obj *nm, char *wt, char *parameterName) +} +declare 29 generic { + void XOTclStackDump (Tcl_Interp *interp) +} +#declare 30 generic { +# void XOTclCallStackDump (Tcl_Interp *interp) +#} +#declare 31 generic { +# void XOTclDeprecatedMsg(char *oldCmd, char *newCmd) +#} +declare 32 generic { + void XOTclSetObjClientData(XOTcl_Object *obj, ClientData data) +} +declare 33 generic { + ClientData XOTclGetObjClientData(XOTcl_Object *obj) +} +declare 34 generic { + void XOTclSetClassClientData(XOTcl_Class *cl, ClientData data) +} +declare 35 generic { + ClientData XOTclGetClassClientData(XOTcl_Class *cl) +} +declare 36 generic { + void XOTclRequireObjNamespace(Tcl_Interp *interp, XOTcl_Object *obj) +} +declare 37 generic { + int XOTclErrBadVal(Tcl_Interp *interp, char *context, char *expected, CONST char *value) +} +declare 38 generic { + int XOTclNextObjCmd(ClientData cd, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) +} +declare 39 generic { + int XOTclCallMethodWithArgs(ClientData cd, Tcl_Interp *interp, + Tcl_Obj *method, Tcl_Obj *arg, + int objc, Tcl_Obj *CONST objv[], int flags) +} +declare 40 generic { + int XOTclObjErrArgCnt(Tcl_Interp *interp, Tcl_Obj *cmdName, Tcl_Obj *methodName, + char *arglist) +} +declare 41 generic { + int XOTclAddObjectMethod(Tcl_Interp *interp, struct XOTcl_Object *obj, + CONST char *nm, Tcl_ObjCmdProc *proc, + ClientData cd, Tcl_CmdDeleteProc *dp, int flags) +} +declare 42 generic { + int XOTclAddClassMethod(Tcl_Interp *interp, struct XOTcl_Class *cl, + CONST char *nm, Tcl_ObjCmdProc *proc, + ClientData cd, Tcl_CmdDeleteProc *dp, int flags) +} +declare 43 generic { + int XOTclCreate(Tcl_Interp *in, XOTcl_Class *class, Tcl_Obj *name, ClientData data, + int objc, Tcl_Obj *CONST objv[]) +} Index: generic/nxDecls.h =================================================================== diff -u --- generic/nxDecls.h (revision 0) +++ generic/nxDecls.h (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,447 @@ +/* + * nxDecls.h -- + * + * Declarations of functions in the platform independent public XOTcl API. + * + * Copyright (C) 1999-2008 Gustaf Neumann, Uwe Zdun + * + * See the file "tcl-license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + */ + +#ifndef _XOTCLDECLS +#define _XOTCLDECLS + +/* + * WARNING: This file is automatically generated by the tools/genStubs.tcl + * script. Any modifications to the function declarations below should be made + * in the xotcl.decls script. + */ + +/* !BEGIN!: Do not edit below this line. */ + +/* + * Exported function declarations: + */ + +#ifndef Nx_Init_TCL_DECLARED +#define Nx_Init_TCL_DECLARED +/* 0 */ +EXTERN int Nx_Init (Tcl_Interp * interp); +#endif +/* Slot 1 is reserved */ +#ifndef XOTclIsClass_TCL_DECLARED +#define XOTclIsClass_TCL_DECLARED +/* 2 */ +EXTERN struct XOTcl_Class * XOTclIsClass (Tcl_Interp * interp, ClientData cd); +#endif +/* Slot 3 is reserved */ +#ifndef XOTclGetObject_TCL_DECLARED +#define XOTclGetObject_TCL_DECLARED +/* 4 */ +EXTERN struct XOTcl_Object * XOTclGetObject (Tcl_Interp * interp, + CONST char * name); +#endif +#ifndef XOTclGetClass_TCL_DECLARED +#define XOTclGetClass_TCL_DECLARED +/* 5 */ +EXTERN struct XOTcl_Class * XOTclGetClass (Tcl_Interp * interp, + CONST char * name); +#endif +#ifndef XOTclCreateObject_TCL_DECLARED +#define XOTclCreateObject_TCL_DECLARED +/* 6 */ +EXTERN int XOTclCreateObject (Tcl_Interp * interp, + Tcl_Obj * name, struct XOTcl_Class * cl); +#endif +/* Slot 7 is reserved */ +/* Slot 8 is reserved */ +#ifndef XOTclDeleteObject_TCL_DECLARED +#define XOTclDeleteObject_TCL_DECLARED +/* 9 */ +EXTERN int XOTclDeleteObject (Tcl_Interp * interp, + struct XOTcl_Object * obj); +#endif +/* Slot 10 is reserved */ +/* Slot 11 is reserved */ +/* Slot 12 is reserved */ +#ifndef XOTclRemoveObjectMethod_TCL_DECLARED +#define XOTclRemoveObjectMethod_TCL_DECLARED +/* 13 */ +EXTERN int XOTclRemoveObjectMethod (Tcl_Interp * interp, + struct XOTcl_Object * obj, CONST char * nm); +#endif +#ifndef XOTclRemoveClassMethod_TCL_DECLARED +#define XOTclRemoveClassMethod_TCL_DECLARED +/* 14 */ +EXTERN int XOTclRemoveClassMethod (Tcl_Interp * interp, + struct XOTcl_Class * cl, CONST char * nm); +#endif +#ifndef XOTclOSetInstVar_TCL_DECLARED +#define XOTclOSetInstVar_TCL_DECLARED +/* 15 */ +EXTERN Tcl_Obj * XOTclOSetInstVar (struct XOTcl_Object * obj, + Tcl_Interp * interp, Tcl_Obj * name, + Tcl_Obj * value, int flgs); +#endif +#ifndef XOTclOGetInstVar_TCL_DECLARED +#define XOTclOGetInstVar_TCL_DECLARED +/* 16 */ +EXTERN Tcl_Obj * XOTclOGetInstVar (struct XOTcl_Object * obj, + Tcl_Interp * interp, Tcl_Obj * name, + int flgs); +#endif +/* Slot 17 is reserved */ +/* Slot 18 is reserved */ +#ifndef XOTcl_ObjSetVar2_TCL_DECLARED +#define XOTcl_ObjSetVar2_TCL_DECLARED +/* 19 */ +EXTERN Tcl_Obj * XOTcl_ObjSetVar2 (struct XOTcl_Object * obj, + Tcl_Interp * interp, Tcl_Obj * name1, + Tcl_Obj * name2, Tcl_Obj * value, int flgs); +#endif +#ifndef XOTcl_ObjGetVar2_TCL_DECLARED +#define XOTcl_ObjGetVar2_TCL_DECLARED +/* 20 */ +EXTERN Tcl_Obj * XOTcl_ObjGetVar2 (struct XOTcl_Object * obj, + Tcl_Interp * interp, Tcl_Obj * name1, + Tcl_Obj * name2, int flgs); +#endif +#ifndef XOTclUnsetInstVar2_TCL_DECLARED +#define XOTclUnsetInstVar2_TCL_DECLARED +/* 21 */ +EXTERN int XOTclUnsetInstVar2 (struct XOTcl_Object * obj, + Tcl_Interp * interp, CONST char * name1, + CONST char * name2, int flgs); +#endif +/* Slot 22 is reserved */ +#ifndef XOTclErrMsg_TCL_DECLARED +#define XOTclErrMsg_TCL_DECLARED +/* 23 */ +EXTERN int XOTclErrMsg (Tcl_Interp * interp, char * msg, + Tcl_FreeProc * type); +#endif +#ifndef XOTclVarErrMsg_TCL_DECLARED +#define XOTclVarErrMsg_TCL_DECLARED +/* 24 */ +EXTERN int XOTclVarErrMsg (Tcl_Interp * interp, ...); +#endif +#ifndef XOTclErrInProc_TCL_DECLARED +#define XOTclErrInProc_TCL_DECLARED +/* 25 */ +EXTERN int XOTclErrInProc (Tcl_Interp * interp, + Tcl_Obj * objName, Tcl_Obj * clName, + CONST char * procName); +#endif +/* Slot 26 is reserved */ +#ifndef XOTclErrBadVal__TCL_DECLARED +#define XOTclErrBadVal__TCL_DECLARED +/* 27 */ +EXTERN int XOTclErrBadVal_ (Tcl_Interp * interp, + char * expected, char * value); +#endif +#ifndef XOTclObjErrType_TCL_DECLARED +#define XOTclObjErrType_TCL_DECLARED +/* 28 */ +EXTERN int XOTclObjErrType (Tcl_Interp * interp, Tcl_Obj * nm, + char * wt, char * parameterName); +#endif +#ifndef XOTclStackDump_TCL_DECLARED +#define XOTclStackDump_TCL_DECLARED +/* 29 */ +EXTERN void XOTclStackDump (Tcl_Interp * interp); +#endif +/* Slot 30 is reserved */ +/* Slot 31 is reserved */ +#ifndef XOTclSetObjClientData_TCL_DECLARED +#define XOTclSetObjClientData_TCL_DECLARED +/* 32 */ +EXTERN void XOTclSetObjClientData (XOTcl_Object * obj, + ClientData data); +#endif +#ifndef XOTclGetObjClientData_TCL_DECLARED +#define XOTclGetObjClientData_TCL_DECLARED +/* 33 */ +EXTERN ClientData XOTclGetObjClientData (XOTcl_Object * obj); +#endif +#ifndef XOTclSetClassClientData_TCL_DECLARED +#define XOTclSetClassClientData_TCL_DECLARED +/* 34 */ +EXTERN void XOTclSetClassClientData (XOTcl_Class * cl, + ClientData data); +#endif +#ifndef XOTclGetClassClientData_TCL_DECLARED +#define XOTclGetClassClientData_TCL_DECLARED +/* 35 */ +EXTERN ClientData XOTclGetClassClientData (XOTcl_Class * cl); +#endif +#ifndef XOTclRequireObjNamespace_TCL_DECLARED +#define XOTclRequireObjNamespace_TCL_DECLARED +/* 36 */ +EXTERN void XOTclRequireObjNamespace (Tcl_Interp * interp, + XOTcl_Object * obj); +#endif +#ifndef XOTclErrBadVal_TCL_DECLARED +#define XOTclErrBadVal_TCL_DECLARED +/* 37 */ +EXTERN int XOTclErrBadVal (Tcl_Interp * interp, char * context, + char * expected, CONST char * value); +#endif +#ifndef XOTclNextObjCmd_TCL_DECLARED +#define XOTclNextObjCmd_TCL_DECLARED +/* 38 */ +EXTERN int XOTclNextObjCmd (ClientData cd, Tcl_Interp * interp, + int objc, Tcl_Obj *CONST objv[]); +#endif +#ifndef XOTclCallMethodWithArgs_TCL_DECLARED +#define XOTclCallMethodWithArgs_TCL_DECLARED +/* 39 */ +EXTERN int XOTclCallMethodWithArgs (ClientData cd, + Tcl_Interp * interp, Tcl_Obj * method, + Tcl_Obj * arg, int objc, + Tcl_Obj *CONST objv[], int flags); +#endif +#ifndef XOTclObjErrArgCnt_TCL_DECLARED +#define XOTclObjErrArgCnt_TCL_DECLARED +/* 40 */ +EXTERN int XOTclObjErrArgCnt (Tcl_Interp * interp, + Tcl_Obj * cmdName, Tcl_Obj * methodName, + char * arglist); +#endif +#ifndef XOTclAddObjectMethod_TCL_DECLARED +#define XOTclAddObjectMethod_TCL_DECLARED +/* 41 */ +EXTERN int XOTclAddObjectMethod (Tcl_Interp * interp, + struct XOTcl_Object * obj, CONST char * nm, + Tcl_ObjCmdProc * proc, ClientData cd, + Tcl_CmdDeleteProc * dp, int flags); +#endif +#ifndef XOTclAddClassMethod_TCL_DECLARED +#define XOTclAddClassMethod_TCL_DECLARED +/* 42 */ +EXTERN int XOTclAddClassMethod (Tcl_Interp * interp, + struct XOTcl_Class * cl, CONST char * nm, + Tcl_ObjCmdProc * proc, ClientData cd, + Tcl_CmdDeleteProc * dp, int flags); +#endif +#ifndef XOTclCreate_TCL_DECLARED +#define XOTclCreate_TCL_DECLARED +/* 43 */ +EXTERN int XOTclCreate (Tcl_Interp * in, XOTcl_Class * class, + Tcl_Obj * name, ClientData data, int objc, + Tcl_Obj *CONST objv[]); +#endif + +typedef struct NxStubHooks { + struct NxIntStubs *nxIntStubs; +} NxStubHooks; + +typedef struct NxStubs { + int magic; + struct NxStubHooks *hooks; + + int (*nx_Init) (Tcl_Interp * interp); /* 0 */ + void *reserved1; + struct XOTcl_Class * (*xOTclIsClass) (Tcl_Interp * interp, ClientData cd); /* 2 */ + void *reserved3; + struct XOTcl_Object * (*xOTclGetObject) (Tcl_Interp * interp, CONST char * name); /* 4 */ + struct XOTcl_Class * (*xOTclGetClass) (Tcl_Interp * interp, CONST char * name); /* 5 */ + int (*xOTclCreateObject) (Tcl_Interp * interp, Tcl_Obj * name, struct XOTcl_Class * cl); /* 6 */ + void *reserved7; + void *reserved8; + int (*xOTclDeleteObject) (Tcl_Interp * interp, struct XOTcl_Object * obj); /* 9 */ + void *reserved10; + void *reserved11; + void *reserved12; + int (*xOTclRemoveObjectMethod) (Tcl_Interp * interp, struct XOTcl_Object * obj, CONST char * nm); /* 13 */ + int (*xOTclRemoveClassMethod) (Tcl_Interp * interp, struct XOTcl_Class * cl, CONST char * nm); /* 14 */ + Tcl_Obj * (*xOTclOSetInstVar) (struct XOTcl_Object * obj, Tcl_Interp * interp, Tcl_Obj * name, Tcl_Obj * value, int flgs); /* 15 */ + Tcl_Obj * (*xOTclOGetInstVar) (struct XOTcl_Object * obj, Tcl_Interp * interp, Tcl_Obj * name, int flgs); /* 16 */ + void *reserved17; + void *reserved18; + Tcl_Obj * (*xOTcl_ObjSetVar2) (struct XOTcl_Object * obj, Tcl_Interp * interp, Tcl_Obj * name1, Tcl_Obj * name2, Tcl_Obj * value, int flgs); /* 19 */ + Tcl_Obj * (*xOTcl_ObjGetVar2) (struct XOTcl_Object * obj, Tcl_Interp * interp, Tcl_Obj * name1, Tcl_Obj * name2, int flgs); /* 20 */ + int (*xOTclUnsetInstVar2) (struct XOTcl_Object * obj, Tcl_Interp * interp, CONST char * name1, CONST char * name2, int flgs); /* 21 */ + void *reserved22; + int (*xOTclErrMsg) (Tcl_Interp * interp, char * msg, Tcl_FreeProc * type); /* 23 */ + int (*xOTclVarErrMsg) (Tcl_Interp * interp, ...); /* 24 */ + int (*xOTclErrInProc) (Tcl_Interp * interp, Tcl_Obj * objName, Tcl_Obj * clName, CONST char * procName); /* 25 */ + void *reserved26; + int (*xOTclErrBadVal_) (Tcl_Interp * interp, char * expected, char * value); /* 27 */ + int (*xOTclObjErrType) (Tcl_Interp * interp, Tcl_Obj * nm, char * wt, char * parameterName); /* 28 */ + void (*xOTclStackDump) (Tcl_Interp * interp); /* 29 */ + void *reserved30; + void *reserved31; + void (*xOTclSetObjClientData) (XOTcl_Object * obj, ClientData data); /* 32 */ + ClientData (*xOTclGetObjClientData) (XOTcl_Object * obj); /* 33 */ + void (*xOTclSetClassClientData) (XOTcl_Class * cl, ClientData data); /* 34 */ + ClientData (*xOTclGetClassClientData) (XOTcl_Class * cl); /* 35 */ + void (*xOTclRequireObjNamespace) (Tcl_Interp * interp, XOTcl_Object * obj); /* 36 */ + int (*xOTclErrBadVal) (Tcl_Interp * interp, char * context, char * expected, CONST char * value); /* 37 */ + int (*xOTclNextObjCmd) (ClientData cd, Tcl_Interp * interp, int objc, Tcl_Obj *CONST objv[]); /* 38 */ + int (*xOTclCallMethodWithArgs) (ClientData cd, Tcl_Interp * interp, Tcl_Obj * method, Tcl_Obj * arg, int objc, Tcl_Obj *CONST objv[], int flags); /* 39 */ + int (*xOTclObjErrArgCnt) (Tcl_Interp * interp, Tcl_Obj * cmdName, Tcl_Obj * methodName, char * arglist); /* 40 */ + int (*xOTclAddObjectMethod) (Tcl_Interp * interp, struct XOTcl_Object * obj, CONST char * nm, Tcl_ObjCmdProc * proc, ClientData cd, Tcl_CmdDeleteProc * dp, int flags); /* 41 */ + int (*xOTclAddClassMethod) (Tcl_Interp * interp, struct XOTcl_Class * cl, CONST char * nm, Tcl_ObjCmdProc * proc, ClientData cd, Tcl_CmdDeleteProc * dp, int flags); /* 42 */ + int (*xOTclCreate) (Tcl_Interp * in, XOTcl_Class * class, Tcl_Obj * name, ClientData data, int objc, Tcl_Obj *CONST objv[]); /* 43 */ +} NxStubs; + +#ifdef __cplusplus +extern "C" { +#endif +extern NxStubs *nxStubsPtr; +#ifdef __cplusplus +} +#endif + +#if defined(USE_NX_STUBS) && !defined(USE_NX_STUB_PROCS) + +/* + * Inline function declarations: + */ + +#ifndef Nx_Init +#define Nx_Init \ + (nxStubsPtr->nx_Init) /* 0 */ +#endif +/* Slot 1 is reserved */ +#ifndef XOTclIsClass +#define XOTclIsClass \ + (nxStubsPtr->xOTclIsClass) /* 2 */ +#endif +/* Slot 3 is reserved */ +#ifndef XOTclGetObject +#define XOTclGetObject \ + (nxStubsPtr->xOTclGetObject) /* 4 */ +#endif +#ifndef XOTclGetClass +#define XOTclGetClass \ + (nxStubsPtr->xOTclGetClass) /* 5 */ +#endif +#ifndef XOTclCreateObject +#define XOTclCreateObject \ + (nxStubsPtr->xOTclCreateObject) /* 6 */ +#endif +/* Slot 7 is reserved */ +/* Slot 8 is reserved */ +#ifndef XOTclDeleteObject +#define XOTclDeleteObject \ + (nxStubsPtr->xOTclDeleteObject) /* 9 */ +#endif +/* Slot 10 is reserved */ +/* Slot 11 is reserved */ +/* Slot 12 is reserved */ +#ifndef XOTclRemoveObjectMethod +#define XOTclRemoveObjectMethod \ + (nxStubsPtr->xOTclRemoveObjectMethod) /* 13 */ +#endif +#ifndef XOTclRemoveClassMethod +#define XOTclRemoveClassMethod \ + (nxStubsPtr->xOTclRemoveClassMethod) /* 14 */ +#endif +#ifndef XOTclOSetInstVar +#define XOTclOSetInstVar \ + (nxStubsPtr->xOTclOSetInstVar) /* 15 */ +#endif +#ifndef XOTclOGetInstVar +#define XOTclOGetInstVar \ + (nxStubsPtr->xOTclOGetInstVar) /* 16 */ +#endif +/* Slot 17 is reserved */ +/* Slot 18 is reserved */ +#ifndef XOTcl_ObjSetVar2 +#define XOTcl_ObjSetVar2 \ + (nxStubsPtr->xOTcl_ObjSetVar2) /* 19 */ +#endif +#ifndef XOTcl_ObjGetVar2 +#define XOTcl_ObjGetVar2 \ + (nxStubsPtr->xOTcl_ObjGetVar2) /* 20 */ +#endif +#ifndef XOTclUnsetInstVar2 +#define XOTclUnsetInstVar2 \ + (nxStubsPtr->xOTclUnsetInstVar2) /* 21 */ +#endif +/* Slot 22 is reserved */ +#ifndef XOTclErrMsg +#define XOTclErrMsg \ + (nxStubsPtr->xOTclErrMsg) /* 23 */ +#endif +#ifndef XOTclVarErrMsg +#define XOTclVarErrMsg \ + (nxStubsPtr->xOTclVarErrMsg) /* 24 */ +#endif +#ifndef XOTclErrInProc +#define XOTclErrInProc \ + (nxStubsPtr->xOTclErrInProc) /* 25 */ +#endif +/* Slot 26 is reserved */ +#ifndef XOTclErrBadVal_ +#define XOTclErrBadVal_ \ + (nxStubsPtr->xOTclErrBadVal_) /* 27 */ +#endif +#ifndef XOTclObjErrType +#define XOTclObjErrType \ + (nxStubsPtr->xOTclObjErrType) /* 28 */ +#endif +#ifndef XOTclStackDump +#define XOTclStackDump \ + (nxStubsPtr->xOTclStackDump) /* 29 */ +#endif +/* Slot 30 is reserved */ +/* Slot 31 is reserved */ +#ifndef XOTclSetObjClientData +#define XOTclSetObjClientData \ + (nxStubsPtr->xOTclSetObjClientData) /* 32 */ +#endif +#ifndef XOTclGetObjClientData +#define XOTclGetObjClientData \ + (nxStubsPtr->xOTclGetObjClientData) /* 33 */ +#endif +#ifndef XOTclSetClassClientData +#define XOTclSetClassClientData \ + (nxStubsPtr->xOTclSetClassClientData) /* 34 */ +#endif +#ifndef XOTclGetClassClientData +#define XOTclGetClassClientData \ + (nxStubsPtr->xOTclGetClassClientData) /* 35 */ +#endif +#ifndef XOTclRequireObjNamespace +#define XOTclRequireObjNamespace \ + (nxStubsPtr->xOTclRequireObjNamespace) /* 36 */ +#endif +#ifndef XOTclErrBadVal +#define XOTclErrBadVal \ + (nxStubsPtr->xOTclErrBadVal) /* 37 */ +#endif +#ifndef XOTclNextObjCmd +#define XOTclNextObjCmd \ + (nxStubsPtr->xOTclNextObjCmd) /* 38 */ +#endif +#ifndef XOTclCallMethodWithArgs +#define XOTclCallMethodWithArgs \ + (nxStubsPtr->xOTclCallMethodWithArgs) /* 39 */ +#endif +#ifndef XOTclObjErrArgCnt +#define XOTclObjErrArgCnt \ + (nxStubsPtr->xOTclObjErrArgCnt) /* 40 */ +#endif +#ifndef XOTclAddObjectMethod +#define XOTclAddObjectMethod \ + (nxStubsPtr->xOTclAddObjectMethod) /* 41 */ +#endif +#ifndef XOTclAddClassMethod +#define XOTclAddClassMethod \ + (nxStubsPtr->xOTclAddClassMethod) /* 42 */ +#endif +#ifndef XOTclCreate +#define XOTclCreate \ + (nxStubsPtr->xOTclCreate) /* 43 */ +#endif + +#endif /* defined(USE_NX_STUBS) && !defined(USE_NX_STUB_PROCS) */ + +/* !END!: Do not edit above this line. */ + +#endif /* _XOTCLDECLS */ + Index: generic/nxInt.decls =================================================================== diff -u --- generic/nxInt.decls (revision 0) +++ generic/nxInt.decls (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,117 @@ +# nxInt.decls -- +# +# This file contains the declarations for all unsupported +# functions that are exported by the Tcl library. This file +# is used to generate the itclIntDecls.h and itclIntStub.c +# files +# +# Copyright (c) 1998-1999 by Scriptics Corporation. +# See the file "tcl-license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +library nx + +# Define the unsupported generic interfaces. + +interface nxInt + + +# +# Functions used within the package, but not considered "public" +# + +#declare 0 generic { + +#} +#declare 1 generic { + +#} +# declare 2 generic { +# int XOTclErrInProc (Tcl_Interp *in, Tcl_Obj* objName, +# Tcl_Obj* clName, char* procName) +# } +# declare 3 generic { +# int XOTclObjErrArgCnt(Tcl_Interp *in, Tcl_Obj *cmdname, char *arglist) +# } +# declare 4 generic { +# int XOTclErrBadVal(Tcl_Interp *in, char *expected, char *value) +# } +# declare 5 generic { +# int XOTclObjErrType(Tcl_Interp *in, Tcl_Obj *nm, char* wt) +# } +# declare 6 generic { +# void XOTclStackTrace (Tcl_Interp* in) +# } +# declare 7 generic { +# void XOTclCallStackTrace (Tcl_Interp* in) +# } +#declare 8 generic { +# void XOTclFilterTrace (Tcl_Interp* in) +#} +#declare 9 generic { +# int XOTclIsType(XOTclObject* obj, XOTclClass* type) +#} +#declare 10 generic { +# void XOTclRemoveClasses(XOTclClasses* sl) +#} +# declare 11 generic { +# XOTclClasses** XOTclAddClass(XOTclClasses** cList, XOTclClass* cl, ClientData cd) +# } +# declare 12 generic { + +# } +# declare 13 generic { +# XOTclClasses* XOTclComputeDependents(register XOTclClass* cl) +# } +# declare 14 generic { +# void XOTclDeprecatedMsg(char* oldCmd, char* newCmd) +# } +# declare 15 generic { +# void XOTclSetObjClientData(XOTclObject* obj, ClientData data) +# } +# declare 16 generic { +# ClientData XOTclGetObjClientData(XOTclObject* obj) +# } +# declare 17 generic { +# void XOTclSetClassClientData(XOTclClass* cl, ClientData data) +# } +# declare 18 generic { +# ClientData XOTclGetClassClientData(XOTclClass* cl) +# } +# declare 19 generic { +# void XOTclRequireObjectOpt(XOTclObject* obj) +# } +# declare 20 generic { +# void XOTclRequireClassOpt(XOTclClass* cl) +# } +# declare 21 generic { +# void XOTclRequireObjNamespace(Tcl_Interp* in, XOTclObject* obj) +# } +# declare 22 generic { + +# } +# declare 23 generic { + +# } +# declare 24 generic { + +# } +# declare 25 generic { + +# } +# declare 26 generic { + +# } +# declare 27 generic { + +# } +# declare 28 generic { + +# } +# declare 29 generic { + +# } +# declare 30 generic { + +# } Index: generic/nxIntDecls.h =================================================================== diff -u --- generic/nxIntDecls.h (revision 0) +++ generic/nxIntDecls.h (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,57 @@ +/* + * xotclIntDecls.h -- + * + * This file contains the declarations for all unsupported + * functions that are exported by the Tcl library. These + * interfaces are not guaranteed to remain the same between + * versions. Use at your own risk. + * + * Copyright (c) 1998-2008 Gustaf Neumann, Uwe Zdun + * + * See the file "tcl-license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + */ + +#ifndef _XOTCLINTDECLS +#define _XOTCLINTDECLS + +/* + * WARNING: This file is automatically generated by the tools/genStubs.tcl + * script. Any modifications to the function declarations below should be made + * in the xotclInt.decls script. + */ + +/* !BEGIN!: Do not edit below this line. */ + +/* + * Exported function declarations: + */ + + +typedef struct XotclIntStubs { + int magic; + struct XotclIntStubHooks *hooks; + +} XotclIntStubs; + +#ifdef __cplusplus +extern "C" { +#endif +extern XotclIntStubs *xotclIntStubsPtr; +#ifdef __cplusplus +} +#endif + +#if defined(USE_XOTCL_STUBS) && !defined(USE_XOTCL_STUB_PROCS) + +/* + * Inline function declarations: + */ + + +#endif /* defined(USE_XOTCL_STUBS) && !defined(USE_XOTCL_STUB_PROCS) */ + +/* !END!: Do not edit above this line. */ + +#endif /* _XOTCLINTDECLS */ Index: generic/nxStubInit.c =================================================================== diff -u --- generic/nxStubInit.c (revision 0) +++ generic/nxStubInit.c (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,88 @@ +/* + * nxStubInit.c -- + * + * This file contains the initializers for the XOTcl stub vectors. + * + * Copyright (c) 1998-1999 by XXX + * + * See the file "tcl-license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + */ + +#include "xotclInt.h" + +/* + * Remove macros that will interfere with the definitions below. + */ + +/* + * WARNING: The contents of this file is automatically generated by the + * tools/genStubs.tcl script. Any modifications to the function declarations + * below should be made in the generic/tcl.decls script. + */ + +/* !BEGIN!: Do not edit below this line. */ + +NxIntStubs nxIntStubs = { + TCL_STUB_MAGIC, + NULL, +}; + +static NxStubHooks nxStubHooks = { + &nxIntStubs +}; + +NxStubs nxStubs = { + TCL_STUB_MAGIC, + &nxStubHooks, + Nx_Init, /* 0 */ + NULL, /* 1 */ + XOTclIsClass, /* 2 */ + NULL, /* 3 */ + XOTclGetObject, /* 4 */ + XOTclGetClass, /* 5 */ + XOTclCreateObject, /* 6 */ + NULL, /* 7 */ + NULL, /* 8 */ + XOTclDeleteObject, /* 9 */ + NULL, /* 10 */ + NULL, /* 11 */ + NULL, /* 12 */ + XOTclRemoveObjectMethod, /* 13 */ + XOTclRemoveClassMethod, /* 14 */ + XOTclOSetInstVar, /* 15 */ + XOTclOGetInstVar, /* 16 */ + NULL, /* 17 */ + NULL, /* 18 */ + XOTcl_ObjSetVar2, /* 19 */ + XOTcl_ObjGetVar2, /* 20 */ + XOTclUnsetInstVar2, /* 21 */ + NULL, /* 22 */ + XOTclErrMsg, /* 23 */ + XOTclVarErrMsg, /* 24 */ + XOTclErrInProc, /* 25 */ + NULL, /* 26 */ + XOTclErrBadVal_, /* 27 */ + XOTclObjErrType, /* 28 */ + XOTclStackDump, /* 29 */ + NULL, /* 30 */ + NULL, /* 31 */ + XOTclSetObjClientData, /* 32 */ + XOTclGetObjClientData, /* 33 */ + XOTclSetClassClientData, /* 34 */ + XOTclGetClassClientData, /* 35 */ + XOTclRequireObjNamespace, /* 36 */ + XOTclErrBadVal, /* 37 */ + XOTclNextObjCmd, /* 38 */ + XOTclCallMethodWithArgs, /* 39 */ + XOTclObjErrArgCnt, /* 40 */ + XOTclAddObjectMethod, /* 41 */ + XOTclAddClassMethod, /* 42 */ + XOTclCreate, /* 43 */ +}; + +/* !END!: Do not edit above this line. */ + +MODULE_SCOPE const NxStubs * const nxConstStubPtr; +const NxStubs * const nxConstStubPtr = &nxStubs; Index: generic/nxStubLib.c =================================================================== diff -u --- generic/nxStubLib.c (revision 0) +++ generic/nxStubLib.c (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,102 @@ +/* + * nxStubLib.c -- + * + * Stub object that will be statically linked into extensions of XOTcl + * + * Copyright (c) 2001-2008 Gustaf Neumann, Uwe Zdun + * Copyright (c) 1998 Paul Duffin. + * + * See the file "tcl-license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + */ + +/* + * We need to ensure that we use the stub macros so that this file contains + * no references to any of the stub functions. This will make it possible + * to build an extension that references Tcl_InitStubs but doesn't end up + * including the rest of the stub functions. + */ + +#ifndef USE_TCL_STUBS +# define USE_TCL_STUBS +#endif +#undef USE_TCL_STUB_PROCS + +/* + * This ensures that the Xotcl_InitStubs has a prototype in + * xotcl.h and is not the macro that turns it into Tcl_PkgRequire + */ + +#ifndef USE_XOTCL_STUBS +# define USE_XOTCL_STUBS +#endif + +#include "xotclInt.h" + +#if defined(PRE86) +extern NxStubs *nxStubsPtr; +#else +MODULE_SCOPE const NxStubs *nxStubsPtr; +MODULE_SCOPE const NxIntStubs *nxIntStubsPtr; +#endif +CONST86 NxStubs *nxStubsPtr = NULL; +CONST86 NxIntStubs *nxIntStubsPtr = NULL; + + +/* + *---------------------------------------------------------------------- + * + * Xotcl_InitStubs -- + * + * Tries to initialise the stub table pointers and ensures that + * the correct version of XOTcl is loaded. + * + * Results: + * The actual version of XOTcl that satisfies the request, or + * NULL to indicate that an error occurred. + * + * Side effects: + * Sets the stub table pointers. + * + *---------------------------------------------------------------------- + */ + +CONST char * +Xotcl_InitStubs (Tcl_Interp *interp, CONST char *version, int exact) { + CONST char *actualVersion; + const char *packageName = "XOTcl"; + ClientData clientData = NULL; + + actualVersion = Tcl_PkgRequireEx(interp, "XOTcl", version, exact, + &clientData); + + if (clientData == NULL) { + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "Error loading ", packageName, " package; ", + "package not present or incomplete", NULL); + return NULL; + } else { + CONST86 NxStubs * const stubsPtr = clientData; + CONST86 NxIntStubs * const intStubsPtr = stubsPtr->hooks ? + stubsPtr->hooks->nxIntStubs : NULL; + + if (actualVersion == NULL) { + return NULL; + } + + if (!stubsPtr || !intStubsPtr) { + static char *errMsg = "missing stub table pointer"; + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "Error loading ", packageName, " package", + " (requested version '", version, "', loaded version '", + actualVersion, "'): ", errMsg, NULL); + return NULL; + } + + nxStubsPtr = stubsPtr; + nxIntStubsPtr = intStubsPtr; + + return actualVersion; + } +} Index: generic/xotcl.c =================================================================== diff -u -r35c67391973a07983d0b0dfe70706e6a69fbdbfc -raf4326a00a0f2d0b2f1e0369af71637f48c2d56a --- generic/xotcl.c (.../xotcl.c) (revision 35c67391973a07983d0b0dfe70706e6a69fbdbfc) +++ generic/xotcl.c (.../xotcl.c) (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -47,9 +47,9 @@ #ifdef COMPILE_XOTCL_STUBS # if defined(PRE86) -extern XotclStubs xotclStubs; +extern NxStubs nxStubs; # else -MODULE_SCOPE const XotclStubs * const xotclConstStubPtr; +MODULE_SCOPE const NxStubs * const nxConstStubPtr; # endif #endif @@ -11135,14 +11135,14 @@ if (isCreateString(name)) { /* - * The command was an interp create, so perform an Next_Init() on + * The command was an interp create, so perform an Nx_Init() on * the new interpreter */ slave = Tcl_GetSlave(interp, ObjStr(objv[2])); if (!slave) { return XOTclVarErrMsg(interp, "Creation of slave interpreter failed", (char *) NULL); } - if (Next_Init(slave) == TCL_ERROR) { + if (Nx_Init(slave) == TCL_ERROR) { return TCL_ERROR; } #ifdef XOTCL_MEM_COUNT @@ -14516,7 +14516,7 @@ */ extern int -Next_Init(Tcl_Interp *interp) { +Nx_Init(Tcl_Interp *interp) { ClientData runtimeState; int result, i; #ifdef XOTCL_BYTECODE @@ -14643,8 +14643,8 @@ XOTclBytecodeInit(); #endif - Tcl_SetVar(interp, "::nx::core::version", XOTCLVERSION, TCL_GLOBAL_ONLY); - Tcl_SetVar(interp, "::nx::core::patchlevel", XOTCLPATCHLEVEL, TCL_GLOBAL_ONLY); + Tcl_SetVar(interp, "::nx::core::version", NXVERSION, TCL_GLOBAL_ONLY); + Tcl_SetVar(interp, "::nx::core::patchlevel", NXPATCHLEVEL, TCL_GLOBAL_ONLY); Tcl_AddInterpResolvers(interp,"nxt", (Tcl_ResolveCmdProc*)InterpColonCmdResolver, @@ -14701,6 +14701,6 @@ extern int Next_SafeInit(Tcl_Interp *interp) { /*** dummy for now **/ - return Next_Init(interp); + return Nx_Init(interp); } Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `generic/xotcl.decls'. Fisheye: No comparison available. Pass `N' to diff? Index: generic/xotcl.h =================================================================== diff -u -r335be502582c8dbf25ed808978d56a8fde39c991 -raf4326a00a0f2d0b2f1e0369af71637f48c2d56a --- generic/xotcl.h (.../xotcl.h) (revision 335be502582c8dbf25ed808978d56a8fde39c991) +++ generic/xotcl.h (.../xotcl.h) (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -154,7 +154,7 @@ * Include the public function declarations that are accessible via * the stubs table. */ -#include "xotclDecls.h" +#include "nxDecls.h" /* * Xotcl_InitStubs is used by extensions that can be linked @@ -168,10 +168,10 @@ extern "C" # endif CONST char * -Xotcl_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, CONST char *version, int exact)); +Nx_InitStubs _ANSI_ARGS_((Tcl_Interp *interp, CONST char *version, int exact)); #else # define Xotcl_InitStubs(interp, version, exact) \ - Tcl_PkgRequire(interp, "XOTcl", version, exact) + Tcl_PkgRequire(interp, "nx", version, exact) #endif #endif /* RC_INVOKED */ Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `generic/xotclDecls.h'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `generic/xotclInt.decls'. Fisheye: No comparison available. Pass `N' to diff? Index: generic/xotclInt.h =================================================================== diff -u -rfb73930aa9ecf6ce966e512e6f899acb5784ea8c -raf4326a00a0f2d0b2f1e0369af71637f48c2d56a --- generic/xotclInt.h (.../xotclInt.h) (revision fb73930aa9ecf6ce966e512e6f899acb5784ea8c) +++ generic/xotclInt.h (.../xotclInt.h) (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -666,7 +666,7 @@ XOTclStringIncrStruct iss; Proc fakeProc; Tcl_Namespace *fakeNS; - XotclStubs *xotclStubs; + NxStubs *nxStubs; Tcl_CallFrame *varFramePtr; Tcl_Command cmdPtr; /* used for ACTIVE_MIXIN */ Tcl_Command colonCmd; @@ -701,7 +701,7 @@ * */ -#include "xotclIntDecls.h" +#include "nxIntDecls.h" /* * Profiling functions Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `generic/xotclIntDecls.h'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `generic/xotclStubInit.c'. Fisheye: No comparison available. Pass `N' to diff? Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `generic/xotclStubLib.c'. Fisheye: No comparison available. Pass `N' to diff? Index: library/lib/changeNextVersion =================================================================== diff -u --- library/lib/changeNextVersion (revision 0) +++ library/lib/changeNextVersion (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -0,0 +1,96 @@ +# -*- Tcl -*- +# +# this is a maintenance program for Next Scripting that allows us to change the +# version information across the whole distribution automatically. +# +# this program assumes that pwd is in nx-full-X.X* directory or subdir +# +set NX_MAJOR_VERSION 2 +set NX_MINOR_VERSION 0 +set NX_RELEASE_LEVEL .0 + +# example settings: +# 1.0 +#set NX_MAJOR_VERSION 1 +#set NX_MINOR_VERSION 0 +#set NX_RELEASE_LEVEL .3 +# +# 0.9.3 +#set NX_MAJOR_VERSION 0 +#set NX_MINOR_VERSION 9 +#set NX_RELEASE_LEVEL .3 + +#set NX_MAJOR_VERSION 0 +#set NX_MINOR_VERSION 9 +#set NX_RELEASE_LEVEL .3 +#set NX_RELEASE_LEVEL .4 +#set NX_RELEASE_LEVEL .5 + + +set NX_VERSION $NX_MAJOR_VERSION.$NX_MINOR_VERSION +set FULL_VERSION $NX_VERSION$NX_RELEASE_LEVEL + +if {![regexp {((^.*/nx-)([0-9.][0-9.a-z_-]*))/?} [pwd] _ topdirname topdirprefix oldversion]} { + error "this program assumes that pwd is in nx-X.X* directory" +} + +puts "Prior version is: $oldversion" +puts "New version is: $FULL_VERSION" +puts "Working in: $topdirname" + +cd $topdirname + +puts "... make clean first" +if {[file exists Makefile]} { + exec make clean +} + +foreach file [exec find . -name configure.in] { + puts "... updating $file" + set F [open $file]; set c [read $F]; close $F + set newFile "" + foreach line [split $c \n] { + set newLine $line + if {[regexp {^NX_MAJOR_VERSION=[0-9]} $line]} { + set line "NX_MAJOR_VERSION=$NX_MAJOR_VERSION" + } elseif {[regexp {^NX_MINOR_VERSION=[0-9]} $line]} { + set line "NX_MINOR_VERSION=$NX_MINOR_VERSION" + } elseif {[regexp {^NX_RELEASE_LEVEL=} $line]} { + set line "NX_RELEASE_LEVEL=$NX_RELEASE_LEVEL" + } elseif {[regexp {^define\(NxVersion, .*$} $line]} { + set line "define(NxVersion, $NX_MAJOR_VERSION.$NX_MINOR_VERSION$NX_RELEASE_LEVEL)" + } + append newFile $line\n + } + set F [open $file w]; puts $F $newFile; close $F +} + +set newtopdirname $topdirprefix$FULL_VERSION +if {$oldversion != $FULL_VERSION} { + puts "topdir: $topdirname->$newtopdirname" + file rename -force $topdirname $newtopdirname +} +cd $newtopdirname + +foreach file [exec find . -name configure.in] { + set dir [file dirname $file] + set oldpwd [pwd] + cd $dir + exec autoconf + cd $oldpwd +} + +# determine last configure command +cd $newtopdirname +if {[catch {set configurecmd [exec fgrep {$ ./configure} config.log]}]} { + set configurecmd "./configure" +} else { + regsub {^ +\$ } $configurecmd "" configurecmd +} +#puts $configurecmd + +cd $newtopdirname/ +puts "Configuring in [pwd]" +eval exec $configurecmd + +puts "ok ... version is now $FULL_VERSION" Fisheye: Tag af4326a00a0f2d0b2f1e0369af71637f48c2d56a refers to a dead (removed) revision in file `library/lib/changeXOTclVersion'. Fisheye: No comparison available. Pass `N' to diff? Index: unix/tclAppInit.c =================================================================== diff -u -r81c800c8b9cb42ef6743d9b80ac2be5ca211a69a -raf4326a00a0f2d0b2f1e0369af71637f48c2d56a --- unix/tclAppInit.c (.../tclAppInit.c) (revision 81c800c8b9cb42ef6743d9b80ac2be5ca211a69a) +++ unix/tclAppInit.c (.../tclAppInit.c) (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -154,9 +154,9 @@ return TCL_ERROR; } - Tcl_StaticPackage(interp, "next", Next_Init, 0); + Tcl_StaticPackage(interp, "nx", Next_Init, 0); #else - if (Tcl_PkgRequire(interp, "next", XOTCLVERSION, 1) == NULL) { + if (Tcl_PkgRequire(interp, "nx", NXVERSION, 1) == NULL) { return TCL_ERROR; } #endif Index: xotcl.m4 =================================================================== diff -u -r2111020b49da8ce57758e51accf0b6073037f0d2 -raf4326a00a0f2d0b2f1e0369af71637f48c2d56a --- xotcl.m4 (.../xotcl.m4) (revision 2111020b49da8ce57758e51accf0b6073037f0d2) +++ xotcl.m4 (.../xotcl.m4) (revision af4326a00a0f2d0b2f1e0369af71637f48c2d56a) @@ -24,7 +24,7 @@ # --with-xotcl=... # # Defines the following vars: -# XOTCL_BIN_DIR Full path to the directory containing +# NX_BIN_DIR Full path to the directory containing # the xotclConfig.sh file #------------------------------------------------------------------------ @@ -84,13 +84,13 @@ ]) if test x"${ac_cv_c_xotclconfig}" = x ; then - XOTCL_BIN_DIR="# no XOTcl configs found" + NX_BIN_DIR="# no XOTcl configs found" AC_MSG_WARN(Can't find XOTcl configuration definitions) exit 0 else no_xotcl= - XOTCL_BIN_DIR=${ac_cv_c_xotclconfig} - AC_MSG_RESULT(found $XOTCL_BIN_DIR/xotclConfig.sh) + NX_BIN_DIR=${ac_cv_c_xotclconfig} + AC_MSG_RESULT(found $NX_BIN_DIR/xotclConfig.sh) fi fi ]) @@ -103,7 +103,7 @@ # Arguments: # # Requires the following vars to be set: -# XOTCL_BIN_DIR +# NX_BIN_DIR # # Results: # @@ -112,11 +112,11 @@ #------------------------------------------------------------------------ AC_DEFUN(SC_LOAD_XOTCLCONFIG, [ - AC_MSG_CHECKING([for existence of $XOTCL_BIN_DIR/xotclConfig.sh]) + AC_MSG_CHECKING([for existence of $NX_BIN_DIR/xotclConfig.sh]) - if test -f "$XOTCL_BIN_DIR/xotclConfig.sh" ; then + if test -f "$NX_BIN_DIR/xotclConfig.sh" ; then AC_MSG_RESULT([loading]) - . $XOTCL_BIN_DIR/xotclConfig.sh + . $NX_BIN_DIR/xotclConfig.sh else AC_MSG_RESULT([file not found]) fi @@ -125,16 +125,16 @@ # The eval is required to do the TCL_DBGX substitution in the # TCL_LIB_FILE variable # - AC_SUBST(XOTCL_VERSION) - AC_SUBST(XOTCL_MAJOR_VERSION) - AC_SUBST(XOTCL_MINOR_VERSION) - AC_SUBST(XOTCL_RELEASE_LEVEL) - AC_SUBST(XOTCL_LIB_FILE) - AC_SUBST(XOTCL_BUILD_LIB_SPEC) - AC_SUBST(XOTCL_LIB_SPEC) - AC_SUBST(XOTCL_STUB_LIB_FILE) - AC_SUBST(XOTCL_BUILD_STUB_LIB_SPEC) - AC_SUBST(XOTCL_STUB_LIB_SPEC) - AC_SUBST(XOTCL_SRC_DIR) + AC_SUBST(NX_VERSION) + AC_SUBST(NX_MAJOR_VERSION) + AC_SUBST(NX_MINOR_VERSION) + AC_SUBST(NX_RELEASE_LEVEL) + AC_SUBST(NX_LIB_FILE) + AC_SUBST(NX_BUILD_LIB_SPEC) + AC_SUBST(NX_LIB_SPEC) + AC_SUBST(NX_STUB_LIB_FILE) + AC_SUBST(NX_BUILD_STUB_LIB_SPEC) + AC_SUBST(NX_STUB_LIB_SPEC) + AC_SUBST(NX_SRC_DIR) ])