<\/a> <\/h2>\nThese procedures are intended for access to the multiple interpreter facility from inside C programs. They enable managing multiple interpreters in a hierarchical relationship, and the management of aliases, commands that when invoked in one interpreter execute a command in another interpreter. The return value for those procedures that return an int<\/b> is either TCL_OK<\/b> or TCL_ERROR<\/b>. If TCL_ERROR<\/b> is returned then the result<\/b> field of the interpreter contains an error message.<\/p>\n
Tcl_CreateSlave<\/b> creates a new interpreter as a slave of interp<\/i>. It also creates a slave command named slaveName<\/i> in interp<\/i> which allows interp<\/i> to manipulate the new slave. If isSafe<\/i> is zero, the command creates a trusted slave in which Tcl code has access to all the Tcl commands. If it is 1<\/b>, the command creates a \u201csafe\u201d slave in which Tcl code has access only to set of Tcl commands defined as \u201cSafe Tcl\u201d; see the manual entry for the Tcl interp<\/b> command for details. If the creation of the new slave interpreter failed, NULL<\/b> is returned.<\/p>\n
Tcl_IsSafe<\/b> returns 1<\/b> if interp<\/i> is \u201csafe\u201d (was created with the TCL_SAFE_INTERPRETER<\/b> flag specified), 0<\/b> otherwise.<\/p>\n
Tcl_MakeSafe<\/b> marks interp<\/i> as \u201csafe\u201d, so that future calls to Tcl_IsSafe<\/b> will return 1. It also removes all known potentially-unsafe core functionality (both commands and variables) from interp<\/i>. However, it cannot know what parts of an extension or application are safe and does not make any attempt to remove those parts, so safety is not guaranteed after calling Tcl_MakeSafe<\/b>. Callers will want to take care with their use of Tcl_MakeSafe<\/b> to avoid false claims of safety. For many situations, Tcl_CreateSlave<\/b> may be a better choice, since it creates interpreters in a known-safe state.<\/p>\n
Tcl_GetSlave<\/b> returns a pointer to a slave interpreter of interp<\/i>. The slave interpreter is identified by slaveName<\/i>. If no such slave interpreter exists, NULL<\/b> is returned.<\/p>\n
Tcl_GetMaster<\/b> returns a pointer to the master interpreter of interp<\/i>. If interp<\/i> has no master (it is a top-level interpreter) then NULL<\/b> is returned.<\/p>\n
Tcl_GetInterpPath<\/b> sets the result<\/i> field in askingInterp<\/i> to the relative path between askingInterp<\/i> and slaveInterp<\/i>; slaveInterp<\/i> must be a slave of askingInterp<\/i>. If the computation of the relative path succeeds, TCL_OK<\/b> is returned, else TCL_ERROR<\/b> is returned and the result<\/i> field in askingInterp<\/i> contains the error message.<\/p>\n
Tcl_CreateAlias<\/b> creates a command named slaveCmd<\/i> in slaveInterp<\/i> that when invoked, will cause the command targetCmd<\/i> to be invoked in targetInterp<\/i>. The arguments specified by the strings contained in argv<\/i> are always prepended to any arguments supplied in the invocation of slaveCmd<\/i> and passed to targetCmd<\/i>. This operation returns TCL_OK<\/b> if it succeeds, or TCL_ERROR<\/b> if it fails; in that case, an error message is left in the value result of slaveInterp<\/i>. Note that there are no restrictions on the ancestry relationship (as created by Tcl_CreateSlave<\/b>) between slaveInterp<\/i> and targetInterp<\/i>. Any two interpreters can be used, without any restrictions on how they are related.<\/p>\n
Tcl_CreateAliasObj<\/b> is similar to Tcl_CreateAlias<\/b> except that it takes a vector of values to pass as additional arguments instead of a vector of strings.<\/p>\n
Tcl_GetAlias<\/b> returns information about an alias aliasName<\/i> in interp<\/i>. Any of the result fields can be NULL<\/b>, in which case the corresponding datum is not returned. If a result field is non\u2212NULL<\/b>, the address indicated is set to the corresponding datum. For example, if targetNamePtr<\/i> is non\u2212NULL<\/b> it is set to a pointer to the string containing the name of the target command.<\/p>\n
Tcl_GetAliasObj<\/b> is similar to Tcl_GetAlias<\/b> except that it returns a pointer to a vector of Tcl_Obj structures instead of a vector of strings.<\/p>\n
Tcl_ExposeCommand<\/b> moves the command named hiddenCmdName<\/i> from the set of hidden commands to the set of exposed commands, putting it under the name cmdName<\/i>. HiddenCmdName<\/i> must be the name of an existing hidden command, or the operation will return TCL_ERROR<\/b> and leave an error message in the result<\/i> field in interp<\/i>. If an exposed command named cmdName<\/i> already exists, the operation returns TCL_ERROR<\/b> and leaves an error message in the value result of interp<\/i>. If the operation succeeds, it returns TCL_OK<\/b>. After executing this command, attempts to use cmdName<\/i> in a call to Tcl_Eval<\/b> or with the Tcl eval<\/b> command will again succeed.<\/p>\n
Tcl_HideCommand<\/b> moves the command named cmdName<\/i> from the set of exposed commands to the set of hidden commands, under the name hiddenCmdName<\/i>. CmdName<\/i> must be the name of an existing exposed command, or the operation will return TCL_ERROR<\/b> and leave an error message in the value result of interp<\/i>. Currently both cmdName<\/i> and hiddenCmdName<\/i> must not contain namespace qualifiers, or the operation will return TCL_ERROR<\/b> and leave an error message in the value result of interp<\/i>. The CmdName<\/i> will be looked up in the global namespace, and not relative to the current namespace, even if the current namespace is not the global one. If a hidden command whose name is hiddenCmdName<\/i> already exists, the operation also returns TCL_ERROR<\/b> and the result<\/i> field in interp<\/i> contains an error message. If the operation succeeds, it returns TCL_OK<\/b>. After executing this command, attempts to use cmdName<\/i> in a call to Tcl_Eval<\/b> or with the Tcl eval<\/b> command will fail.<\/p>\n
For a description of the Tcl interface to multiple interpreters, see interp(n)<\/i>.<\/p>\n