an exact version match or not.  If \fIexact\fR is 0, then the
extension is indicating that newer versions of Tcl are acceptable
as long as they have the same major version number as \fIversion\fR;
non-zero means that only the specified \fIversion\fR is acceptable.
\fBTcl_InitStubs\fR returns a string containing the actual version
of Tcl satisfying the request, or NULL if the Tcl version is not
acceptable, does not support stubs, or any other error condition occurred.
.PP
If \fBTcl_InitStubs\fR is called with as first argument the
pseudo interpreter returned by \fBTcl_InitSubsystems(0)\fR, then
the \fIversion\fR and \fIexact\fR parameters have no effect. 
.SH "SEE ALSO"
Tk_InitStubs
.SH KEYWORDS
stubs

'\"
'\" Copyright (c) 1995-1996 Sun Microsystems, Inc.
'\"
'\" See the file "license.terms" for information on usage and redistribution
'\" of this file, and for a DISCLAIMER OF ALL WARRANTIES.
'\" 
.so man.macros
.TH Tcl_InitSubsystems 3 8.6.1 Tcl "Tcl Library Procedures"
.BS
.SH NAME
Tcl_InitSubsystems \- initialize the Tcl library.
.SH SYNOPSIS
.nf
\fB#include <tcl.h>\fR
.sp
Tcl_Interp *
\fBTcl_InitSubsystems\fR(\fIflags\fR, \fI...\fR)
.SH ARGUMENTS
.AS int flags
.AP int flags in
Any combination of flags which might modify the initialization sequence.
At this moment, only 0, \fBTCL_INIT_PANIC\fR and \fBTCL_INIT_CUSTOM\fR
(or a combination) are supported.
The value 0 can be used if Tcl is used as utility library only.
.BE

.SH DESCRIPTION
.PP
The \fBTcl_InitSubsystems\fR procedure initializes the Tcl
library. This procedure is typically invoked as the very
first thing in the application's main program.
Its \fBflags\fR argument controls exactly what is initialized,
and what additional arguments are expected.
.PP
The call \fBTcl_InitSubsystems(0)\fR does the same as
\fBTcl_FindExecutable(NULL)\fR, except that a Tcl_Interp *
is returned which can be used only by \fBTcl_InitStubs\fR
to initialize the stub table. This opens up the Tcl Stub
technology for Tcl embedders, which now can dynamically
load the Tcl shared library and use functions in it
without ever creating an interpreter. E.g. the
following code can be compiled with -DUSE_TCL_STUBS:
.CS
Tcl_Interp *interp, *(*initSubSystems)(int, ...);
const char *version;
void *handle = dlopen("libtcl8.6.so", RTLD_NOW|RTLD_LOCAL);
initSubSystems = dlsym(handle, "Tcl_InitSubsystems");
version = Tcl_InitStubs(initSubSystems(0), NULL, 0);
/* At this point, Tcl C API calls without interp are ready for use */
interp = Tcl_CreateInterp(); /* Now we have a real interpreter */
Tcl_InitStubs(interp, version, 0); /* Initialize the stub table again */
.CE
This is equivalent to (without dynamical loading)
.CS
Tcl_Interp *interp;
const char *version;
version = Tcl_InitStubs(Tcl_InitSubSystems(0), NULL, 0);
/* At this point, Tcl C API calls without interp are ready for use */
interp = Tcl_CreateInterp(); /* Now we have a real interpreter */
Tcl_InitStubs(interp, version, 0); /* Initialize the stub table again */
.CE
The function \fBTcl_CreateInterp\fR, or any other Tcl function you
would like to call, no longer needs to be searched for in the
shared library. It can be called directly through the stub table.
Note that the stub table needs to be initialized twice, in order
to be sure that you can call all functions without limitations
after the real interpreter is created.
.PP

If you supply the flag \fBTCL_INIT_PANIC\fR to \fBTcl_InitSubsystems\fR,
the function expects an additional argument, a custom panicProc.
This is equivalent to calling \fBTcl_SetPanicProc\fR immediately



before \fBTcl_InitSubsystems\fR, except that you possibly cannot do
that yet if it requires an initialized stub table. Of course you
could call \fBTcl_SetPanicProc\fR immediately after \fBTcl_InitSubsystems\fR,
but then panics which could be produced by the initialization
itself still use the default panic procedure. 
.PP
If you supply the flag \fBTCL_INIT_CUSTOM\fR to \fBTcl_InitSubsystems\fR,
the function expects two additional arguments: ClientData and a
custom proc. The proc will be supplied two arguments, the (pseudo)

Tcl interpreter and ClientData. The given function will be executed
just before the encodings are initialized.





.PP

The interpreter returned by Tcl_InitSubsystems(0) or passed to the



TCL_INIT_CUSTOM function cannot be passed to any other function than
Tcl_InitStubs(). Tcl functions with an "interp" argument can only




be called if the function supports passing NULL.

.SH KEYWORDS
binary, executable file

/*
 * TODO - tommath stubs export goes here!
 */

/* Tcl_InitSubsystems, see TIP #414 */


#define TCL_INIT_PANIC (1) /* Set Panic proc */

#define TCL_INIT_CUSTOM (2) /* Do any stuff before initializing the encoding */

EXTERN Tcl_Interp *Tcl_InitSubsystems(int flags, ...);

/*
 * Public functions that are not accessible via the stubs table.
 * Tcl_GetMemoryInfo is needed for AOLserver. [Bug 1868171]
 */

 * Side effects:
 *	The absolute pathname for the application is computed and stored to be
 *	returned later by [info nameofexecutable]. The system encoding is
 *	determined and stored to be returned later by [encoding system]
 *
 *---------------------------------------------------------------------------
 */
MODULE_SCOPE const TclStubs tclStubs;

/* Dummy const structure returned by Tcl_InitSubsystems,
 * which looks like an Tcl_Interp, but in reality is not.
 * It contains just enough for Tcl_InitStubs to be able
 * to initialize the stub table. */
static const struct {
    /* A real interpreter has interp->result/freeProc here: */
    const char version[sizeof(struct {char *r; void (*f)(void);})];
    int errorLine;
    const struct TclStubs *stubTable;
} dummyInterp = {
    TCL_PATCH_LEVEL, TCL_STUB_MAGIC, &tclStubs
};

#undef Tcl_FindExecutable
Tcl_Interp *
Tcl_InitSubsystems(int flags, ...)
{
    va_list argList;


    Tcl_Interp *interp = (Tcl_Interp *) &dummyInterp;


    va_start(argList, flags);
    if (flags & TCL_INIT_PANIC) {
	Tcl_SetPanicProc(va_arg(argList, Tcl_PanicProc *));


    }
    TclInitSubsystems();
    if (flags & TCL_INIT_CUSTOM) {
	ClientData clientData = va_arg(argList, ClientData);
	void (*fn)(Tcl_Interp *, ClientData) = va_arg(argList,
		void (*)(Tcl_Interp *, ClientData));
	fn(interp, clientData);
    }
    va_end(argList);

    TclpSetInitialEncodings();
    TclpFindExecutable(NULL);

























    return interp;
}

void
Tcl_FindExecutable(
    const char *argv0)		/* The value of the application's argv[0]
				 * (native). */

    if (!stubsPtr || (stubsPtr->magic != TCL_STUB_MAGIC)) {
	iPtr->result = "interpreter uses an incompatible stubs mechanism";
	iPtr->freeProc = TCL_STATIC;
	return NULL;
    }

    if(iPtr->errorLine == TCL_STUB_MAGIC) {
	actualVersion = (const char *)interp;
	tclStubsPtr = stubsPtr;
    } else {
	actualVersion = stubsPtr->tcl_PkgRequireEx(interp, "Tcl", version, 0, &pkgData);
	if (actualVersion == NULL) {
	    return NULL;
	}
	if (exact) {
	    const char *p = version;
	    int count = 0;

	    while (*p) {
		count += !isDigit(*p++);
	    }
	    if (count == 1) {
		const char *q = actualVersion;

		p = version;
		while (*p && (*p == *q)) {
		    p++; q++;
		}
		if (*p || isDigit(*q)) {
		    /* Construct error message */
		    stubsPtr->tcl_PkgRequireEx(interp, "Tcl", version, 1, NULL);
		    return NULL;
		}
	    } else {
		actualVersion = stubsPtr->tcl_PkgRequireEx(interp, "Tcl", version, 1, NULL);
		if (actualVersion == NULL) {
		    return NULL;
		}
	    }
	}
	tclStubsPtr = (const TclStubs *)pkgData;
    }

    if (tclStubsPtr->hooks) {
	tclPlatStubsPtr = tclStubsPtr->hooks->tclPlatStubs;
	tclIntStubsPtr = tclStubsPtr->hooks->tclIntStubs;
	tclIntPlatStubsPtr = tclStubsPtr->hooks->tclIntPlatStubs;
    } else {
	tclPlatStubsPtr = NULL;

    Tcl_Interp *interp,
    int mode,
    int format,
    int level,
    Tcl_Obj *dictObj,
    Tcl_ZlibStream *zshandle)
{

    Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
    Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);

    return TCL_ERROR;
}

int
Tcl_ZlibStreamClose(
    Tcl_ZlibStream zshandle)
{

Tcl_ZlibDeflate(
    Tcl_Interp *interp,
    int format,
    Tcl_Obj *data,
    int level,
    Tcl_Obj *gzipHeaderDictObj)
{

    Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
    Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);

    return TCL_ERROR;
}

int
Tcl_ZlibInflate(
    Tcl_Interp *interp,
    int format,
    Tcl_Obj *data,
    int bufferSize,
    Tcl_Obj *gzipHeaderDictObj)
{

    Tcl_SetObjResult(interp, Tcl_NewStringObj("unimplemented", -1));
    Tcl_SetErrorCode(interp, "TCL", "UNIMPLEMENTED", NULL);

    return TCL_ERROR;
}

unsigned int
Tcl_ZlibCRC32(
    unsigned int crc,
    const char *buf,