Scroll to navigation

interp(3tcl) Tcl Built-In Commands interp(3tcl) 





NAME


interp - Create and manipulate Tcl interpreters






SYNOPSIS


interp subcommand ?arg arg ...?








DESCRIPTION


This command makes it possible to create one or more new Tcl
    interpreters that co-exist with the creating interpreter in the same
    application. The creating interpreter is called the parent and the
    new interpreter is called a child. A parent can create any number of
    children, and each child can itself create additional children for which it
    is parent, resulting in a hierarchy of interpreters.


Each interpreter is independent from the others: it has its own
    name space for commands, procedures, and global variables. A parent
    interpreter may create connections between its children and itself using a
    mechanism called an alias. An alias is a command in a child
    interpreter which, when invoked, causes a command to be invoked in its
    parent interpreter or in another child interpreter. The only other
    connections between interpreters are through environment variables (the
    env variable), which are normally shared among all interpreters in
    the application, and by resource limit exceeded callbacks. Note that the
    name space for files (such as the names returned by the open command)
    is no longer shared between interpreters. Explicit commands are provided to
    share files and to transfer references to open files from one interpreter to
    another.


The interp command also provides support for safe
    interpreters. A safe interpreter is a child whose functions have been
    greatly restricted, so that it is safe to execute untrusted scripts without
    fear of them damaging other interpreters or the application's environment.
    For example, all IO channel creation commands and subprocess creation
    commands are made inaccessible to safe interpreters. See SAFE
    INTERPRETERS below for more information on what features are present in
    a safe interpreter. The dangerous functionality is not removed from the safe
    interpreter; instead, it is hidden, so that only trusted interpreters
    can obtain access to it. For a detailed explanation of hidden commands, see
    HIDDEN COMMANDS, below. The alias mechanism can be used for protected
    communication (analogous to a kernel call) between a child interpreter and
    its parent. See ALIAS INVOCATION, below, for more details on how the
    alias mechanism works.


A qualified interpreter name is a proper Tcl list containing a
    subset of its ancestors in the interpreter hierarchy, terminated by the
    string naming the interpreter in its immediate parent. Interpreter names are
    relative to the interpreter in which they are used. For example, if
    “a” is a child of the current interpreter and it has a
    child “a1”, which in turn has a child
    “a11”, the qualified name of “a11”
    in “a” is the list “a1 a11”.


The interp command, described below, accepts qualified
    interpreter names as arguments; the interpreter in which the command is
    being evaluated can always be referred to as {} (the empty list or
    string). Note that it is impossible to refer to a parent (ancestor)
    interpreter by name in a child interpreter except through aliases. Also,
    there is no global name by which one can refer to the first interpreter
    created in an application. Both restrictions are motivated by safety
    concerns.






THE INTERP COMMAND


The interp command is used to create, delete, and
    manipulate child interpreters, and to share or transfer channels between
    interpreters. It can have any of several forms, depending on the
    subcommand argument:



  

  
Returns a Tcl list whose elements are the targetCmd and args
      associated with the alias represented by srcToken (this is the
      value returned when the alias was created; it is possible that the name of
      the source command in the child is different from srcToken).

  

  
Deletes the alias for srcToken in the child interpreter identified
      by srcPath. srcToken refers to the value returned when the
      alias was created; if the source command has been renamed, the renamed
      command will be deleted.

  

  
This command creates an alias between one child and another (see the
      alias child command below for creating aliases between a child and
      its parent). In this command, either of the child interpreters may be
      anywhere in the hierarchy of interpreters under the interpreter invoking
      the command. SrcPath and srcCmd identify the source of the
      alias. SrcPath is a Tcl list whose elements select a particular
      interpreter. For example, “a b” identifies an
      interpreter “b”, which is a child of interpreter
      “a”, which is a child of the invoking interpreter. An
      empty list specifies the interpreter invoking the command. srcCmd
      gives the name of a new command, which will be created in the source
      interpreter. TargetPath and targetCmd specify a target
      interpreter and command, and the arg arguments, if any, specify
      additional arguments to targetCmd which are prepended to any
      arguments specified in the invocation of srcCmd. TargetCmd
      may be undefined at the time of this call, or it may already exist; it is
      not created by this command. The alias arranges for the given target
      command to be invoked in the target interpreter whenever the given source
      command is invoked in the source interpreter. See ALIAS INVOCATION
      below for more details. The command returns a token that uniquely
      identifies the command created srcCmd, even if the command is
      renamed afterwards. The token may but does not have to be equal to
      srcCmd.

  

  
This command returns a Tcl list of the tokens of all the source commands
      for aliases defined in the interpreter identified by path. The
      tokens correspond to the values returned when the aliases were created
      (which may not be the same as the current names of the commands).

  

  
This command either gets or sets the current background exception handler
      for the interpreter identified by path. If cmdPrefix is
      absent, the current background exception handler is returned, and if it is
      present, it is a list of words (of minimum length one) that describes what
      to set the interpreter's background exception handler to. See the
      BACKGROUND EXCEPTION HANDLING section for more details.

  

  
Cancels the script being evaluated in the interpreter identified by
      path. Without the -unwind switch the evaluation stack for
      the interpreter is unwound until an enclosing catch command is found or
      there are no further invocations of the interpreter left on the call
      stack. With the -unwind switch the evaluation stack for the
      interpreter is unwound without regard to any intervening catch command
      until there are no further invocations of the interpreter left on the call
      stack. The -- switch can be used to mark the end of switches; it
      may be needed if path is an unusual value such as -safe. If
      result is present, it will be used as the error message string;
      otherwise, a default error message string will be used.

  

  
Creates a child interpreter identified by path and a new command,
      called a child command. The name of the child command is the last
      component of path. The new child interpreter and the child command
      are created in the interpreter identified by the path obtained by removing
      the last component from path. For example, if path is a
      b c then a new child interpreter and child command named
      c are created in the interpreter identified by the path a b.
      The child command may be used to manipulate the new interpreter as
      described below. If path is omitted, Tcl creates a unique name of
      the form interpx, where x is an integer, and uses it
      for the interpreter and the child command. If the -safe switch is
      specified (or if the parent interpreter is a safe interpreter), the new
      child interpreter will be created as a safe interpreter with limited
      functionality; otherwise the child will include the full set of Tcl
      built-in commands and variables. The -- switch can be used to mark
      the end of switches; it may be needed if path is an unusual value
      such as -safe. The result of the command is the name of the new
      interpreter. The name of a child interpreter must be unique among all the
      children for its parent; an error occurs if a child interpreter by the
      given name already exists in this parent. The initial recursion limit of
      the child interpreter is set to the current recursion limit of its parent
      interpreter.

  

  
Controls whether frame-level stack information is captured in the child
      interpreter identified by path. If no arguments are given, option
      and current setting are returned. If -frame is given, the debug
      setting is set to the given boolean if provided and the current setting is
      returned. This only affects the output of info frame, in that exact
      frame-level information for command invocation at the bytecode level is
      only captured with this setting on.






For example, with code like






proc mycontrol {... script} {


  ...


  uplevel 1 $script


  ...
}
proc dosomething {...} {


  ...


  mycontrol {


    somecode


  }
}




the standard setting will provide a relative line number for the
    command somecode and the relevant frame will be of type eval.
    With frame-debug active on the other hand the tracking extends so far that
    the system will be able to determine the file and absolute line number of
    this command, and return a frame of type source. This more exact
    information is paid for with slower execution of all commands.


Note that once it is on, this flag cannot be switched back off:
    such attempts are silently ignored. This is needed to maintain the
    consistency of the underlying interpreter's state.





  

  
Deletes zero or more interpreters given by the optional path
      arguments, and for each interpreter, it also deletes its children. The
      command also deletes the child command for each interpreter deleted. For
      each path argument, if no interpreter by that name exists, the
      command raises an error.

  

  
This command concatenates all of the arg arguments in the same
      fashion as the concat command, then evaluates the resulting string
      as a Tcl script in the child interpreter identified by path. The
      result of this evaluation (including all return options, such as
      -errorinfo and -errorcode information, if an error occurs)
      is returned to the invoking interpreter. Note that the script will be
      executed in the current context stack frame of the path
      interpreter; this is so that the implementations (in a parent interpreter)
      of aliases in a child interpreter can execute scripts in the child that
      find out information about the child's current state and stack frame.

  

  
Returns 1 if a child interpreter by the specified path
      exists in this parent, 0 otherwise. If path is omitted, the
      invoking interpreter is used.

  

  
Makes the hidden command hiddenName exposed, eventually bringing it
      back under a new exposedCmdName name (this name is currently
      accepted only if it is a valid global name space name without any ::), in
      the interpreter denoted by path. If an exposed command with the
      targeted name already exists, this command fails. Hidden commands are
      explained in more detail in HIDDEN COMMANDS, below.

  

  
Makes the exposed command exposedCmdName hidden, renaming it to the
      hidden command hiddenCmdName, or keeping the same name if
      hiddenCmdName is not given, in the interpreter denoted by
      path. If a hidden command with the targeted name already exists,
      this command fails. Currently both exposedCmdName and
      hiddenCmdName can not contain namespace qualifiers, or an error is
      raised. Commands to be hidden by interp hide are looked up in the
      global namespace even if the current namespace is not the global one. This
      prevents children from fooling a parent interpreter into hiding the wrong
      command, by making the current namespace be different from the global one.
      Hidden commands are explained in more detail in HIDDEN COMMANDS,
      below.

  

  
Returns a list of the names of all hidden commands in the interpreter
      identified by path.

  

  
Invokes the hidden command hiddenCmdName with the arguments
      supplied in the interpreter denoted by path. No substitutions or
      evaluation are applied to the arguments. Three -options are
      supported, all of which start with -: -namespace (which
      takes a single argument afterwards, nsName), -global, and
      --. If the -namespace flag is present, the hidden command is
      invoked in the namespace called nsName in the target interpreter.
      If the -global flag is present, the hidden command is invoked at
      the global level in the target interpreter; otherwise it is invoked at the
      current call frame and can access local variables in that and outer call
      frames. The -- flag allows the hiddenCmdName argument to
      start with a “-” character, and is otherwise unnecessary. If
      both the -namespace and -global flags are present, the
      -namespace flag is ignored. Note that the hidden command will be
      executed (by default) in the current context stack frame of the
      path interpreter. Hidden commands are explained in more detail in
      HIDDEN COMMANDS, below.

  

  
Returns 1 if the interpreter identified by the specified
      path is safe, 0 otherwise.

  

  
Sets up, manipulates and queries the configuration of the resource limit
      limitType for the interpreter denoted by path. If no
      -option is specified, return the current configuration of the
      limit. If -option is the sole argument, return the value of that
      option. Otherwise, a list of -option/value argument pairs
      must supplied. See RESOURCE LIMITS below for a more detailed
      explanation of what limits and options are supported.

  

  
Marks the interpreter identified by path as trusted. Does not
      expose the hidden commands. This command can only be invoked from a
      trusted interpreter. The command has no effect if the interpreter
      identified by path is already trusted.

  

  
Returns the maximum allowable nesting depth for the interpreter specified
      by path. If newlimit is specified, the interpreter recursion
      limit will be set so that nesting of more than newlimit calls to
      Tcl_Eval and related procedures in that interpreter will return an
      error. The newlimit value is also returned. The newlimit
      value must be a positive integer between 1 and the maximum value of a
      non-long integer on the platform.






The command sets the maximum size of the Tcl call stack only. It
    cannot by itself prevent stack overflows on the C stack being used by the
    application. If your machine has a limit on the size of the C stack, you may
    get stack overflows before reaching the limit set by the command. If this
    happens, see if there is a mechanism in your system for increasing the
    maximum size of the C stack.





  

  
Causes the IO channel identified by channelId to become shared
      between the interpreter identified by srcPath and the interpreter
      identified by destPath. Both interpreters have the same permissions
      on the IO channel. Both interpreters must close it to close the underlying
      IO channel; IO channels accessible in an interpreter are automatically
      closed when an interpreter is destroyed.

  

  
Returns a Tcl list of the names of all the child interpreters associated
      with the interpreter identified by path. If path is omitted,
      the invoking interpreter is used.

  

  
Synonym for . interp children ?path?

  

  
Returns a Tcl list describing the target interpreter for an alias. The
      alias is specified with an interpreter path and source command name, just
      as in interp alias above. The name of the target interpreter is
      returned as an interpreter path, relative to the invoking interpreter. If
      the target interpreter for the alias is the invoking interpreter then an
      empty list is returned. If the target interpreter for the alias is not the
      invoking interpreter or one of its descendants then an error is generated.
      The target command does not have to be defined at the time of this
      invocation.

  

  
Causes the IO channel identified by channelId to become available
      in the interpreter identified by destPath and unavailable in the
      interpreter identified by srcPath.








CHILD COMMAND


For each child interpreter created with the interp command,
    a new Tcl command is created in the parent interpreter with the same name as
    the new interpreter. This command may be used to invoke various operations
    on the interpreter. It has the following general form:






child command ?arg arg ...?




Child is the name of the interpreter, and command
    and the args determine the exact behavior of the command. The valid
    forms of this command are:



  

  
Returns a Tcl list whose elements are the tokens of all the aliases in
      child. The tokens correspond to the values returned when the
      aliases were created (which may not be the same as the current names of
      the commands).

  

  
Returns a Tcl list whose elements are the targetCmd and args
      associated with the alias represented by srcToken (this is the
      value returned when the alias was created; it is possible that the actual
      source command in the child is different from srcToken).

  

  
Deletes the alias for srcToken in the child interpreter.
      srcToken refers to the value returned when the alias was created;
      if the source command has been renamed, the renamed command will be
      deleted.

  

  
Creates an alias such that whenever srcCmd is invoked in
      child, targetCmd is invoked in the parent. The arg
      arguments will be passed to targetCmd as additional arguments,
      prepended before any arguments passed in the invocation of srcCmd.
      See ALIAS INVOCATION below for details. The command returns a token
      that uniquely identifies the command created srcCmd, even if the
      command is renamed afterwards. The token may but does not have to be equal
      to srcCmd.

  

  
This command either gets or sets the current background exception handler
      for the child interpreter. If cmdPrefix is absent, the
      current background exception handler is returned, and if it is present, it
      is a list of words (of minimum length one) that describes what to set the
      interpreter's background exception handler to. See the BACKGROUND
      EXCEPTION HANDLING section for more details.

  

  
This command concatenates all of the arg arguments in the same
      fashion as the concat command, then evaluates the resulting string
      as a Tcl script in child. The result of this evaluation (including
      all return options, such as -errorinfo and -errorcode
      information, if an error occurs) is returned to the invoking interpreter.
      Note that the script will be executed in the current context stack frame
      of child; this is so that the implementations (in a parent
      interpreter) of aliases in a child interpreter can execute scripts in the
      child that find out information about the child's current state and stack
      frame.

  

  
This command exposes the hidden command hiddenName, eventually
      bringing it back under a new exposedCmdName name (this name is
      currently accepted only if it is a valid global name space name without
      any ::), in child. If an exposed command with the targeted name
      already exists, this command fails. For more details on hidden commands,
      see HIDDEN COMMANDS, below.

  

  
This command hides the exposed command exposedCmdName, renaming it
      to the hidden command hiddenCmdName, or keeping the same name if
      the argument is not given, in the child interpreter. If a hidden
      command with the targeted name already exists, this command fails.
      Currently both exposedCmdName and hiddenCmdName can not
      contain namespace qualifiers, or an error is raised. Commands to be hidden
      are looked up in the global namespace even if the current namespace is not
      the global one. This prevents children from fooling a parent interpreter
      into hiding the wrong command, by making the current namespace be
      different from the global one. For more details on hidden commands, see
      HIDDEN COMMANDS, below.

  

  
Returns a list of the names of all hidden commands in child.

  

  
This command invokes the hidden command hiddenName with the
      supplied arguments, in child. No substitutions or evaluations are
      applied to the arguments. Three -options are supported, all of
      which start with -: -namespace (which takes a single
      argument afterwards, nsName), -global, and --. If the
      -namespace flag is given, the hidden command is invoked in the
      specified namespace in the child. If the -global flag is given, the
      command is invoked at the global level in the child; otherwise it is
      invoked at the current call frame and can access local variables in that
      or outer call frames. The -- flag allows the hiddenCmdName
      argument to start with a “-” character, and is otherwise
      unnecessary. If both the -namespace and -global flags are
      given, the -namespace flag is ignored. Note that the hidden command
      will be executed (by default) in the current context stack frame of
      child. For more details on hidden commands, see HIDDEN
      COMMANDS, below.

  

  
Returns 1 if the child interpreter is safe, 0
    otherwise.

  

  
Sets up, manipulates and queries the configuration of the resource limit
      limitType for the child interpreter. If no -option is
      specified, return the current configuration of the limit. If
      -option is the sole argument, return the value of that option.
      Otherwise, a list of -option/value argument pairs must
      supplied. See RESOURCE LIMITS below for a more detailed explanation
      of what limits and options are supported.

  

  
Marks the child interpreter as trusted. Can only be invoked by a trusted
      interpreter. This command does not expose any hidden commands in the child
      interpreter. The command has no effect if the child is already
    trusted.

  

  
Returns the maximum allowable nesting depth for the child
      interpreter. If newlimit is specified, the recursion limit in
      child will be set so that nesting of more than newlimit
      calls to Tcl_Eval() and related procedures in child will
      return an error. The newlimit value is also returned. The
      newlimit value must be a positive integer between 1 and the maximum
      value of a non-long integer on the platform.






The command sets the maximum size of the Tcl call stack only. It
    cannot by itself prevent stack overflows on the C stack being used by the
    application. If your machine has a limit on the size of the C stack, you may
    get stack overflows before reaching the limit set by the command. If this
    happens, see if there is a mechanism in your system for increasing the
    maximum size of the C stack.








SAFE INTERPRETERS


A safe interpreter is one with restricted functionality, so that
    is safe to execute an arbitrary script from your worst enemy without fear of
    that script damaging the enclosing application or the rest of your computing
    environment. In order to make an interpreter safe, certain commands and
    variables are removed from the interpreter. For example, commands to create
    files on disk are removed, and the exec command is removed, since it
    could be used to cause damage through subprocesses. Limited access to these
    facilities can be provided, by creating aliases to the parent interpreter
    which check their arguments carefully and provide restricted access to a
    safe subset of facilities. For example, file creation might be allowed in a
    particular subdirectory and subprocess invocation might be allowed for a
    carefully selected and fixed set of programs.


A safe interpreter is created by specifying the -safe
    switch to the interp create command. Furthermore, any child created
    by a safe interpreter will also be safe.


A safe interpreter is created with exactly the following set of
    built-in commands:




after	append	apply	array
binary	break	catch	chan
clock	close	concat	continue
dict	eof	error	eval
expr	fblocked	fcopy	fileevent
flush	for	foreach	format
gets	global	if	incr
info	interp	join	lappend
lassign	lindex	linsert	list
llength	lrange	lrepeat	lreplace
lsearch	lset	lsort	namespace
package	pid	proc	puts
read	regexp	regsub	rename
return	scan	seek	set
split	string	subst	switch
tell	time	trace	unset
update	uplevel	upvar	variable
vwait	while




The following commands are hidden by interp create when it
    creates a safe interpreter:




cd	encoding	exec	exit
fconfigure	file	glob	load
open	pwd	socket	source
unload




These commands can be recreated later as Tcl procedures or
    aliases, or re-exposed by interp expose.


The following commands from Tcl's library of support procedures
    are not present in a safe interpreter:




auto_exec_ok	auto_import	auto_load
auto_load_index	auto_qualify	unknown




Note in particular that safe interpreters have no default
    unknown command, so Tcl's default autoloading facilities are not
    available. Autoload access to Tcl's commands that are normally
  autoloaded:




auto_mkindex	auto_mkindex_old
auto_reset	history
parray	pkg_mkIndex
::pkg::create	::safe::interpAddToAccessPath
::safe::interpCreate	::safe::interpConfigure
::safe::interpDelete	::safe::interpFindInAccessPath
::safe::interpInit	::safe::setLogCmd
tcl_endOfWord	tcl_findLibrary
tcl_startOfNextWord	tcl_startOfPreviousWord
tcl_wordBreakAfter	tcl_wordBreakBefore




can only be provided by explicit definition of an unknown
    command in the safe interpreter. This will involve exposing the
    source command. This is most easily accomplished by creating the safe
    interpreter with Tcl's Safe-Tcl mechanism. Safe-Tcl provides
    safe versions of source, load, and other Tcl commands needed
    to support autoloading of commands and the loading of packages.


In addition, the env variable is not present in a safe
    interpreter, so it cannot share environment variables with other
    interpreters. The env variable poses a security risk, because users
    can store sensitive information in an environment variable. For example, the
    PGP manual recommends storing the PGP private key protection password in the
    environment variable PGPPASS. Making this variable available to
    untrusted code executing in a safe interpreter would incur a security
  risk.


If extensions are loaded into a safe interpreter, they may also
    restrict their own functionality to eliminate unsafe commands. For a
    discussion of management of extensions for safety see the manual entries for
    Safe-Tcl and the load Tcl command.


A safe interpreter may not alter the recursion limit of any
    interpreter, including itself.






ALIAS INVOCATION


The alias mechanism has been carefully designed so that it can be
    used safely in an untrusted script which is being executed in a safe
    interpreter even if the target of the alias is not a safe interpreter. The
    most important thing in guaranteeing safety is to ensure that information
    passed from the child to the parent is never evaluated or substituted in the
    parent; if this were to occur, it would enable an evil script in the child
    to invoke arbitrary functions in the parent, which would compromise
    security.


When the source for an alias is invoked in the child interpreter,
    the usual Tcl substitutions are performed when parsing that command. These
    substitutions are carried out in the source interpreter just as they would
    be for any other command invoked in that interpreter. The command procedure
    for the source command takes its arguments and merges them with the
    targetCmd and args for the alias to create a new array of
    arguments. If the words of srcCmd were “srcCmd arg1 arg2
    ... argN”, the new set of words will be “targetCmd arg
    arg ... arg arg1 arg2 ... argN”, where targetCmd and
    args are the values supplied when the alias was created.
    TargetCmd is then used to locate a command procedure in the target
    interpreter, and that command procedure is invoked with the new set of
    arguments. An error occurs if there is no command named targetCmd in
    the target interpreter. No additional substitutions are performed on the
    words: the target command procedure is invoked directly, without going
    through the normal Tcl evaluation mechanism. Substitutions are thus
    performed on each word exactly once: targetCmd and args were
    substituted when parsing the command that created the alias, and arg1 -
    argN are substituted when the alias's source command is parsed in the
    source interpreter.


When writing the targetCmds for aliases in safe
    interpreters, it is very important that the arguments to that command never
    be evaluated or substituted, since this would provide an escape mechanism
    whereby the child interpreter could execute arbitrary code in the parent.
    This in turn would compromise the security of the system.






HIDDEN COMMANDS


Safe interpreters greatly restrict the functionality available to
    Tcl programs executing within them. Allowing the untrusted Tcl program to
    have direct access to this functionality is unsafe, because it can be used
    for a variety of attacks on the environment. However, there are times when
    there is a legitimate need to use the dangerous functionality in the context
    of the safe interpreter. For example, sometimes a program must be
    sourced into the interpreter. Another example is Tk, where windows
    are bound to the hierarchy of windows for a specific interpreter; some
    potentially dangerous functions, e.g. window management, must be performed
    on these windows within the interpreter context.


The interp command provides a solution to this problem in
    the form of hidden commands. Instead of removing the dangerous
    commands entirely from a safe interpreter, these commands are hidden so they
    become unavailable to Tcl scripts executing in the interpreter. However,
    such hidden commands can be invoked by any trusted ancestor of the safe
    interpreter, in the context of the safe interpreter, using interp
    invoke. Hidden commands and exposed commands reside in separate name
    spaces. It is possible to define a hidden command and an exposed command by
    the same name within one interpreter.


Hidden commands in a child interpreter can be invoked in the body
    of procedures called in the parent during alias invocation. For example, an
    alias for source could be created in a child interpreter. When it is
    invoked in the child interpreter, a procedure is called in the parent
    interpreter to check that the operation is allowable (e.g. it asks to source
    a file that the child interpreter is allowed to access). The procedure then
    it invokes the hidden source command in the child interpreter to
    actually source in the contents of the file. Note that two commands named
    source exist in the child interpreter: the alias, and the hidden
    command.


Because a parent interpreter may invoke a hidden command as part
    of handling an alias invocation, great care must be taken to avoid
    evaluating any arguments passed in through the alias invocation. Otherwise,
    malicious child interpreters could cause a trusted parent interpreter to
    execute dangerous commands on their behalf. See the section on ALIAS
    INVOCATION for a more complete discussion of this topic. To help avoid
    this problem, no substitutions or evaluations are applied to arguments of
    interp invokehidden.


Safe interpreters are not allowed to invoke hidden commands in
    themselves or in their descendants. This prevents them from gaining access
    to hidden functionality in themselves or their descendants.


The set of hidden commands in an interpreter can be manipulated by
    a trusted interpreter using interp expose and interp hide. The
    interp expose command moves a hidden command to the set of
    exposed commands in the interpreter identified by path, potentially
    renaming the command in the process. If an exposed command by the targeted
    name already exists, the operation fails. Similarly, interp hide
    moves an exposed command to the set of hidden commands in that interpreter.
    Safe interpreters are not allowed to move commands between the set of hidden
    and exposed commands, in either themselves or their descendants.


Currently, the names of hidden commands cannot contain namespace
    qualifiers, and you must first rename a command in a namespace to the global
    namespace before you can hide it. Commands to be hidden by interp
    hide are looked up in the global namespace even if the current namespace
    is not the global one. This prevents children from fooling a parent
    interpreter into hiding the wrong command, by making the current namespace
    be different from the global one.






RESOURCE LIMITS


Every interpreter has two kinds of resource limits that may be
    imposed by any parent interpreter upon its children. Command limits (of type
    command) restrict the total number of Tcl commands that may be
    executed by an interpreter (as can be inspected via the info cmdcount
    command), and time limits (of type time) place a limit by which
    execution within the interpreter must complete. Note that time limits are
    expressed as absolute times (as in clock seconds) and not
    relative times (as in after) because they may be modified after
    creation.


When a limit is exceeded for an interpreter, first any handler
    callbacks defined by parent interpreters are called. If those callbacks
    increase or remove the limit, execution within the (previously) limited
    interpreter continues. If the limit is still in force, an error is generated
    at that point and normal processing of errors within the interpreter (by the
    catch command) is disabled, so the error propagates outwards
    (building a stack-trace as it goes) to the point where the limited
    interpreter was invoked (e.g. by interp eval) where it becomes the
    responsibility of the calling code to catch and handle.




LIMIT OPTIONS


Every limit has a number of options associated with it, some of
    which are common across all kinds of limits, and others of which are
    particular to the kind of limit.



  

  
This option (common for all limit types) specifies (if non-empty) a Tcl
      script to be executed in the global namespace of the interpreter reading
      and writing the option when the particular limit in the limited
      interpreter is exceeded. The callback may modify the limit on the
      interpreter if it wishes the limited interpreter to continue executing. If
      the callback generates an exception, it is reported through the background
      exception mechanism (see BACKGROUND EXCEPTION HANDLING). Note that
      the callbacks defined by one interpreter are completely isolated from the
      callbacks defined by another, and that the order in which those callbacks
      are called is undefined.

  

  
This option (common for all limit types) specifies how frequently (out of
      the points when the Tcl interpreter is in a consistent state where limit
      checking is possible) that the limit is actually checked. This allows the
      tuning of how frequently a limit is checked, and hence how often the
      limit-checking overhead (which may be substantial in the case of time
      limits) is incurred.

  

  
This option specifies the number of milliseconds after the moment defined
      in the -seconds option that the time limit will fire. It should
      only ever be specified in conjunction with the -seconds option
      (whether it was set previously or is being set this invocation.)

  

  
This option specifies the number of seconds after the epoch (see
      clock seconds) that the time limit for the interpreter will
      be triggered. The limit will be triggered at the start of the second
      unless specified at a sub-second level using the -milliseconds
      option. This option may be the empty string, which indicates that a time
      limit is not set for the interpreter.

  

  
This option specifies the number of commands that the interpreter may
      execute before triggering the command limit. This option may be the empty
      string, which indicates that a command limit is not set for the
      interpreter.




Where an interpreter with a resource limit set on it creates a
    child interpreter, that child interpreter will have resource limits imposed
    on it that are at least as restrictive as the limits on the creating parent
    interpreter. If the parent interpreter of the limited parent wishes to relax
    these conditions, it should hide the interp command in the child and
    then use aliases and the interp invokehidden subcommand to provide
    such access as it chooses to the interp command to the limited parent
    as necessary.








BACKGROUND EXCEPTION HANDLING


When an exception happens in a situation where it cannot be
    reported directly up the stack (e.g. when processing events in an
    update or vwait call) the exception is instead reported
    through the background exception handling mechanism. Every interpreter has a
    background exception handler registered; the default exception handler
    arranges for the bgerror command in the interpreter's global
    namespace to be called, but other exception handlers may be installed and
    process background exceptions in substantially different ways.


A background exception handler consists of a non-empty list of
    words to which will be appended two further words at invocation time. The
    first word will be the interpreter result at time of the exception,
    typically an error message, and the second will be the dictionary of return
    options at the time of the exception. These are the same values that
    catch can capture when it controls script evaluation in a
    non-background situation. The resulting list will then be executed in the
    interpreter's global namespace without further substitutions being
    performed.






CREDITS


The safe interpreter mechanism is based on the Safe-Tcl prototype
    implemented by Nathaniel Borenstein and Marshall Rose.






EXAMPLES


Creating and using an alias for a command in the current
    interpreter:






interp alias {} getIndex {} lsearch {alpha beta gamma delta}
set idx [getIndex delta]




Executing an arbitrary command in a safe interpreter where every
    invocation of lappend is logged:






set i [interp create -safe]
interp hide $i lappend
interp alias $i lappend {} loggedLappend $i
proc loggedLappend {i args} {


    puts "logged invocation of lappend $args"


    interp invokehidden $i lappend {*}$args
}
interp eval $i $someUntrustedScript




Setting a resource limit on an interpreter so that an infinite
    loop terminates.






set i [interp create]
interp limit $i command -value 1000
interp eval $i {


    set x 0


    while {1} {


        puts "Counting up... [incr x]"


    }
}








SEE ALSO


bgerror(3tcl), load(3tcl), safe(3tcl), Tcl_CreateChild(3tcl),
    Tcl_Eval(3tcl), Tcl_BackgroundException(3tcl)






KEYWORDS


alias, parent interpreter, safe interpreter, child interpreter







  

    8.6
    Tcl