---
name: "CrtSlave"
section: "3"
platform: "macos"
package: "tcl"
version: "152"
release: "macOS 26.5"
platforms: ["macos"]
url: "https://new.carta.tech/CrtSlave"
---

# CrtSlave(3)

manage multiple Tcl interpreters, aliases and hidden commands

## NAME

Tcl\_IsSafe, Tcl\_MakeSafe, Tcl\_CreateSlave, Tcl\_GetSlave, Tcl\_GetMaster, Tcl\_GetInterpPath, Tcl\_CreateAlias, Tcl\_CreateAliasObj, Tcl\_GetAlias, Tcl\_GetAliasObj, Tcl\_ExposeCommand, Tcl\_HideCommand - manage multiple Tcl interpreters, aliases and hidden commands

## SYNOPSIS

```
#include <tcl.h>

int
Tcl_IsSafe(interp)

int
Tcl_MakeSafe(interp)

Tcl_Interp *
Tcl_CreateSlave(interp, slaveName, isSafe)

Tcl_Interp *
Tcl_GetSlave(interp, slaveName)

Tcl_Interp *
Tcl_GetMaster(interp)

int
Tcl_GetInterpPath(askingInterp, slaveInterp)

int
Tcl_CreateAlias(slaveInterp, slaveCmd, targetInterp, targetCmd,
                argc, argv)

int
Tcl_CreateAliasObj(slaveInterp, slaveCmd, targetInterp, targetCmd,
                   objc, objv)

int
Tcl_GetAlias(interp, slaveCmd, targetInterpPtr, targetCmdPtr,
             argcPtr, argvPtr)

int
Tcl_GetAliasObj(interp, slaveCmd, targetInterpPtr, targetCmdPtr,
                objcPtr, objvPtr)

int
Tcl_ExposeCommand(interp, hiddenCmdName, cmdName)

int
Tcl_HideCommand(interp, cmdName, hiddenCmdName)
```

## ARGUMENTS

Interpreter in which to execute the specified command. Name of slave interpreter to create or manipulate. If non-zero, a slave that is suitable for running untrusted code is created, otherwise a trusted slave is created. Interpreter to use for creating the source command for an alias (see below). Name of source command for alias. Interpreter that contains the target command for an alias. Name of target command for alias in *targetInterp*. Count of additional arguments to pass to the alias command. Vector of strings, the additional arguments to pass to the alias command. This storage is owned by the caller. Count of additional object arguments to pass to the alias object command. Vector of Tcl\_Obj structures, the additional object arguments to pass to the alias object command. This storage is owned by the caller. Pointer to location to store the address of the interpreter where a target command is defined for an alias. Pointer to location to store the address of the name of the target command for an alias. Pointer to location to store count of additional arguments to be passed to the alias. The location is in storage owned by the caller. Pointer to location to store a vector of strings, the additional arguments to pass to an alias. The location is in storage owned by the caller, the vector of strings is owned by the called function. Pointer to location to store count of additional object arguments to be passed to the alias. The location is in storage owned by the caller. Pointer to location to store a vector of Tcl\_Obj structures, the additional arguments to pass to an object alias command. The location is in storage owned by the caller, the vector of Tcl\_Obj structures is owned by the called function. Name of an exposed command to hide or create. Name under which a hidden command is stored and with which it can be exposed or invoked.

## DESCRIPTION

These 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** is either **TCL\_OK** or **TCL\_ERROR**. If **TCL\_ERROR** is returned then the **result** field of the interpreter contains an error message.

**Tcl\_CreateSlave** creates a new interpreter as a slave of *interp*. It also creates a slave command named *slaveName* in *interp* which  allows *interp* to manipulate the new slave.  If *isSafe* is zero, the command creates a trusted slave in which Tcl code has access to all the Tcl commands. If it is **1**, the command creates a slave in which Tcl code has access only to set of Tcl commands defined as see the manual entry for the Tcl **interp** command for details. If the creation of the new slave interpreter failed, **NULL** is returned.

**Tcl\_IsSafe** returns **1** if *interp* is (was created with the **TCL\_SAFE\_INTERPRETER** flag specified), **0** otherwise.

**Tcl\_MakeSafe** marks *interp* as so that future calls to **Tcl\_IsSafe** will return 1.  It also removes all known potentially-unsafe core functionality (both commands and variables) from *interp*.  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**. Callers will want to take care with their use of **Tcl\_MakeSafe** to avoid false claims of safety.  For many situations, **Tcl\_CreateSlave** may be a better choice, since it creates interpreters in a known-safe state.

**Tcl\_GetSlave** returns a pointer to a slave interpreter of *interp*. The slave interpreter is identified by *slaveName*. If no such slave interpreter exists, **NULL** is returned.

**Tcl\_GetMaster** returns a pointer to the master interpreter of *interp*. If *interp* has no master (it is a top-level interpreter) then **NULL** is returned.

**Tcl\_GetInterpPath** sets the *result* field in *askingInterp* to the relative path between *askingInterp* and *slaveInterp*; *slaveInterp* must be a slave of *askingInterp*. If the computation of the relative path succeeds, **TCL\_OK** is returned, else **TCL\_ERROR** is returned and the *result* field in *askingInterp* contains the error message.

**Tcl\_CreateAlias** creates an object command named *slaveCmd* in *slaveInterp* that when invoked, will cause the command *targetCmd* to be invoked in *targetInterp*. The arguments specified by the strings contained in *argv* are always prepended to any arguments supplied in the invocation of *slaveCmd* and passed to *targetCmd*. This operation returns **TCL\_OK** if it succeeds, or **TCL\_ERROR** if it fails; in that case, an error message is left in the object result of *slaveInterp*. Note that there are no restrictions on the ancestry relationship (as created by **Tcl\_CreateSlave**) between *slaveInterp* and *targetInterp*. Any two interpreters can be used, without any restrictions on how they are related.

**Tcl\_CreateAliasObj** is similar to **Tcl\_CreateAlias** except  that it takes a vector of objects to pass as additional arguments instead of a vector of strings.

**Tcl\_GetAlias** returns information about an alias *aliasName* in *interp*. Any of the result fields can be **NULL**, in which case the corresponding datum is not returned. If a result field is non-**NULL**, the address indicated is set to the corresponding datum. For example, if *targetNamePtr* is non-**NULL** it is set to a pointer to the string containing the name of the target command.

**Tcl\_GetAliasObj** is similar to **Tcl\_GetAlias** except that it returns a pointer to a vector of Tcl\_Obj structures instead of a vector of strings.

**Tcl\_ExposeCommand** moves the command named *hiddenCmdName* from the set of hidden commands to the set of exposed commands, putting it under the name *cmdName*.  *HiddenCmdName* must be the name of an existing hidden command, or the operation will return **TCL\_ERROR** and leave an error message in the *result* field in *interp*. If an exposed command named *cmdName* already exists, the operation returns **TCL\_ERROR** and leaves an error message in the object result of *interp*. If the operation succeeds, it returns **TCL\_OK**. After executing this command, attempts to use *cmdName* in a call to **Tcl\_Eval** or with the Tcl **eval** command will again succeed.

**Tcl\_HideCommand** moves the command named *cmdName* from the set of exposed commands to the set of hidden commands, under the name *hiddenCmdName*. *CmdName* must be the name of an existing exposed command, or the operation will return **TCL\_ERROR** and leave an error message in the object result of *interp*. Currently both *cmdName* and *hiddenCmdName* must not contain namespace qualifiers, or the operation will return **TCL\_ERROR** and leave an error message in the object result of *interp*. The *CmdName* 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* already exists, the operation also returns **TCL\_ERROR** and the *result* field in *interp* contains an error message. If the operation succeeds, it returns **TCL\_OK**. After executing this command, attempts to use *cmdName* in a call to **Tcl\_Eval** or with the Tcl **eval** command will fail.

For a description of the Tcl interface to multiple interpreters, see *[interp(n)](/interp/n.md)*.

## SEE ALSO

interp

## KEYWORDS

alias, command, exposed commands, hidden commands, interpreter, invoke, master, slave