namespace - create and manipulate contexts for commands and variables
namespace ?
subcommand? ?
arg ...?
The
namespace command lets you create, access, and destroy separate
contexts for commands and variables. See the section
WHAT IS A
NAMESPACE? below for a brief overview of namespaces. The legal values of
subcommand are listed below. Note that you can abbreviate the
subcommands.
- namespace children ?namespace? ?pattern?
- Returns a list of all child namespaces that belong to the namespace
namespace. If namespace is not specified, then the children
are returned for the current namespace. This command returns
fully-qualified names, which start with a double colon ( ::). If
the optional pattern is given, then this command returns only the
names that match the glob-style pattern. The actual pattern used is
determined as follows: a pattern that starts with double colon (
::) is used directly, otherwise the namespace namespace (or
the fully-qualified name of the current namespace) is prepended onto the
pattern.
- namespace code script
- Captures the current namespace context for later execution of the script
script. It returns a new script in which script has been
wrapped in a namespace inscope command. The new script has two
important properties. First, it can be evaluated in any namespace and will
cause script to be evaluated in the current namespace (the one
where the namespace code command was invoked). Second, additional
arguments can be appended to the resulting script and they will be passed
to script as additional arguments. For example, suppose the command
set script [namespace code {foo bar}] is invoked in namespace
::a::b. Then eval $script [list x y] can be executed in any
namespace (assuming the value of script has been passed in
properly) and will have the same effect as the command ::namespace eval
::a::b {foo bar x y}. This command is needed because extensions like
Tk normally execute callback scripts in the global namespace. A scoped
command captures a command together with its namespace context in a way
that allows it to be executed properly later. See the section SCOPED
SCRIPTS for some examples of how this is used to create callback
scripts.
- namespace current
- Returns the fully-qualified name for the current namespace. The actual
name of the global namespace is
(i.e., an empty string), but this command returns
:: for the global
namespace as a convenience to programmers.
- namespace delete ?namespace namespace ...?
- Each namespace namespace is deleted and all variables, procedures,
and child namespaces contained in the namespace are deleted. If a
procedure is currently executing inside the namespace, the namespace will
be kept alive until the procedure returns; however, the namespace is
marked to prevent other code from looking it up by name. If a namespace
does not exist, this command returns an error. If no namespace names are
given, this command does nothing.
- namespace ensemble subcommand ?arg ...?
- Creates and manipulates a command that is formed out of an ensemble of
subcommands. See the section ENSEMBLES below for further
details.
- namespace eval namespace arg ?arg ...?
- Activates a namespace called namespace and evaluates some code in
that context. If the namespace does not already exist, it is created. If
more than one arg argument is specified, the arguments are
concatenated together with a space between each one in the same fashion as
the eval command, and the result is evaluated.
If
namespace has leading namespace qualifiers and any leading namespaces
do not exist, they are automatically created.
- namespace exists namespace
- Returns 1 if namespace is a valid namespace in the current
context, returns 0 otherwise.
- namespace export ?-clear? ?pattern pattern ...?
- Specifies which commands are exported from a namespace. The exported
commands are those that can be later imported into another namespace using
a namespace import command. Both commands defined in a namespace
and commands the namespace has previously imported can be exported by a
namespace. The commands do not have to be defined at the time the
namespace export command is executed. Each pattern may
contain glob-style special characters, but it may not include any
namespace qualifiers. That is, the pattern can only specify commands in
the current (exporting) namespace. Each pattern is appended onto
the namespace's list of export patterns. If the -clear flag is
given, the namespace's export pattern list is reset to empty before any
pattern arguments are appended. If no patterns are given and
the -clear flag is not given, this command returns the namespace's
current export list.
- namespace forget ?pattern pattern ...?
- Removes previously imported commands from a namespace. Each pattern
is a simple or qualified name such as x, foo::x or
a::b::p*. Qualified names contain double colons ( ::) and
qualify a name with the name of one or more namespaces. Each
“qualified pattern” is qualified with the name of an
exporting namespace and may have glob-style special characters in the
command name at the end of the qualified name. Glob characters may not
appear in a namespace name. For each “simple pattern” this
command deletes the matching commands of the current namespace that were
imported from a different namespace. For “qualified
patterns”, this command first finds the matching exported commands.
It then checks whether any of those commands were previously imported by
the current namespace. If so, this command deletes the corresponding
imported commands. In effect, this un-does the action of a namespace
import command.
- namespace import ?-force? ?pattern pattern
...?
- Imports commands into a namespace, or queries the set of imported commands
in a namespace. When no arguments are present, namespace import
returns the list of commands in the current namespace that have been
imported from other namespaces. The commands in the returned list are in
the format of simple names, with no namespace qualifiers at all. This
format is suitable for composition with namespace forget (see
EXAMPLES below). When pattern arguments are present, each
pattern is a qualified name like foo::x or a::p*.
That is, it includes the name of an exporting namespace and may have
glob-style special characters in the command name at the end of the
qualified name. Glob characters may not appear in a namespace name. All
the commands that match a pattern string and which are currently
exported from their namespace are added to the current namespace. This is
done by creating a new command in the current namespace that points to the
exported command in its original namespace; when the new imported command
is called, it invokes the exported command. This command normally returns
an error if an imported command conflicts with an existing command.
However, if the - force option is given, imported commands will
silently replace existing commands. The namespace import command
has snapshot semantics: that is, only requested commands that are
currently defined in the exporting namespace are imported. In other words,
you can import only the commands that are in a namespace at the time when
the namespace import command is executed. If another command is
defined and exported in this namespace later on, it will not be
imported.
- namespace inscope namespace script ?arg
...?
- Executes a script in the context of the specified namespace. This
command is not expected to be used directly by programmers; calls to it
are generated implicitly when applications use namespace code
commands to create callback scripts that the applications then register
with, e.g., Tk widgets. The namespace inscope command is much like
the namespace eval command except that the namespace must
already exist, and namespace inscope appends additional args
as proper list elements.
namespace inscope ::foo $script $x $y $z
is equivalent to
namespace eval ::foo [concat $script [list $x $y $z]]
thus additional arguments will not undergo a second round of substitution, as is
the case with
namespace eval.
- namespace origin command
- Returns the fully-qualified name of the original command to which the
imported command command refers. When a command is imported into a
namespace, a new command is created in that namespace that points to the
actual command in the exporting namespace. If a command is imported into a
sequence of namespaces a, b,...,n where each successive namespace
just imports the command from the previous namespace, this command returns
the fully-qualified name of the original command in the first namespace,
a. If command does not refer to an imported command, the
command's own fully-qualified name is returned.
- namespace parent ?namespace?
- Returns the fully-qualified name of the parent namespace for namespace
namespace. If namespace is not specified, the
fully-qualified name of the current namespace's parent is returned.
- namespace path ?namespaceList?
- Returns the command resolution path of the current namespace. If
namespaceList is specified as a list of named namespaces, the
current namespace's command resolution path is set to those namespaces and
returns the empty list. The default command resolution path is always
empty. See the section NAME RESOLUTION below for an explanation of
the rules regarding name resolution.
- namespace qualifiers string
- Returns any leading namespace qualifiers for string. Qualifiers are
namespace names separated by double colons ( ::). For the
string ::foo::bar::x, this command returns
::foo::bar, and for :: it returns an empty string. This
command is the complement of the namespace tail command. Note that
it does not check whether the namespace names are, in fact, the names of
currently defined namespaces.
- namespace tail string
- Returns the simple name at the end of a qualified string. Qualifiers are
namespace names separated by double colons ( ::). For the
string ::foo::bar::x, this command returns x, and for
:: it returns an empty string. This command is the complement of
the namespace qualifiers command. It does not check whether the
namespace names are, in fact, the names of currently defined
namespaces.
- namespace upvar namespace otherVar myVar ?otherVar
myVar ...
- This command arranges for one or more local variables in the current
procedure to refer to variables in namespace. The namespace name is
resolved as described in section NAME RESOLUTION. The command
namespace upvar $ns a b has the same behaviour as upvar 0
${ns}::a b, with the sole exception of the resolution rules used for
qualified namespace or variable names. namespace upvar returns an
empty string.
- namespace unknown ?script?
- Sets or returns the unknown command handler for the current namespace. The
handler is invoked when a command called from within the namespace cannot
be found (in either the current namespace or the global namespace). The
script argument, if given, should be a well formed list
representing a command name and optional arguments. When the handler is
invoked, the full invocation line will be appended to the script and the
result evaluated in the context of the namespace. The default handler for
all namespaces is ::unknown. If no argument is given, it returns
the handler for the current namespace.
- namespace which ?-command? ?-variable?
name
- Looks up name as either a command or variable and returns its
fully-qualified name. For example, if name does not exist in the
current namespace but does exist in the global namespace, this command
returns a fully-qualified name in the global namespace. If the command or
variable does not exist, this command returns an empty string. If the
variable has been created but not defined, such as with the
variable command or through a trace on the variable, this
command will return the fully-qualified name of the variable. If no flag
is given, name is treated as a command name. See the section
NAME RESOLUTION below for an explanation of the rules regarding
name resolution.
A namespace is a collection of commands and variables. It encapsulates the
commands and variables to ensure that they will not interfere with the
commands and variables of other namespaces. Tcl has always had one such
collection, which we refer to as the
global namespace. The global
namespace holds all global variables and commands. The
namespace eval
command lets you create new namespaces. For example,
namespace eval Counter {
namespace export bump
variable num 0
proc bump {} {
variable num
incr num
}
}
creates a new namespace containing the variable
num and the procedure
bump. The commands and variables in this namespace are separate from
other commands and variables in the same program. If there is a command named
bump in the global namespace, for example, it will be different from
the command
bump in the
Counter namespace.
Namespace variables resemble global variables in Tcl. They exist outside of the
procedures in a namespace but can be accessed in a procedure via the
variable command, as shown in the example above.
Namespaces are dynamic. You can add and delete commands and variables at any
time, so you can build up the contents of a namespace over time using a series
of
namespace eval commands. For example, the following series of
commands has the same effect as the namespace definition shown above:
namespace eval Counter {
variable num 0
proc bump {} {
variable num
return [incr num]
}
}
namespace eval Counter {
proc test {args} {
return $args
}
}
namespace eval Counter {
rename test ""
}
Note that the
test procedure is added to the
Counter namespace,
and later removed via the
rename command.
Namespaces can have other namespaces within them, so they nest hierarchically. A
nested namespace is encapsulated inside its parent namespace and can not
interfere with other namespaces.
Each namespace has a textual name such as
history or
::safe::interp. Since namespaces may nest, qualified names are used to
refer to commands, variables, and child namespaces contained inside
namespaces. Qualified names are similar to the hierarchical path names for
Unix files or Tk widgets, except that
:: is used as the separator
instead of
/ or
.. The topmost or global namespace has the name
(i.e., an empty string), although
:: is a synonym. As an example, the
name
::safe::interp::create refers to the command
create in the
namespace
interp that is a child of namespace
::safe, which in
turn is a child of the global namespace,
::.
If you want to access commands and variables from another namespace, you must
use some extra syntax. Names must be qualified by the namespace that contains
them. From the global namespace, we might access the
Counter procedures
like this:
Counter::bump 5
Counter::Reset
We could access the current count like this:
puts "count = $Counter::num"
When one namespace contains another, you may need more than one qualifier to
reach its elements. If we had a namespace
Foo that contained the
namespace
Counter, you could invoke its
bump procedure from the
global namespace like this:
You can also use qualified names when you create and rename commands. For
example, you could add a procedure to the
Foo namespace like this:
proc Foo::Test {args} {return $args}
And you could move the same procedure to another namespace like this:
rename Foo::Test Bar::Test
There are a few remaining points about qualified names that we should cover.
Namespaces have nonempty names except for the global namespace.
:: is
disallowed in simple command, variable, and namespace names except as a
namespace separator. Extra colons in any separator part of a qualified name
are ignored; i.e. two or more colons are treated as a namespace separator. A
trailing
:: in a qualified variable or command name refers to the
variable or command named {}. However, a trailing
:: in a qualified
namespace name is ignored.
In general, all Tcl commands that take variable and command names support
qualified names. This means you can give qualified names to such commands as
set,
proc,
rename, and
interp alias. If you
provide a fully-qualified name that starts with a
::, there is no
question about what command, variable, or namespace you mean. However, if the
name does not start with a
:: (i.e., is
relative), Tcl follows
basic rules for looking it up: Variable names are always resolved by looking
first in the current namespace, and then in the global namespace. Command
names are also always resolved by looking in the current namespace first. If
not found there, they are searched for in every namespace on the current
namespace's command path (which is empty by default). If not found there,
command names are looked up in the global namespace (or, failing that, are
processed by the
unknown command.) Namespace names, on the other hand,
are always resolved by looking in only the current namespace.
In the following example,
set traceLevel 0
namespace eval Debug {
printTrace $traceLevel
}
Tcl looks for
traceLevel in the namespace
Debug and then in the
global namespace. It looks up the command
printTrace in the same way.
If a variable or command name is not found in either context, the name is
undefined. To make this point absolutely clear, consider the following
example:
set traceLevel 0
namespace eval Foo {
variable traceLevel 3
namespace eval Debug {
printTrace $traceLevel
}
}
Here Tcl looks for
traceLevel first in the namespace
Foo::Debug.
Since it is not found there, Tcl then looks for it in the global namespace.
The variable
Foo::traceLevel is completely ignored during the name
resolution process.
You can use the
namespace which command to clear up any question about
name resolution. For example, the command:
namespace eval Foo::Debug {namespace which -variable traceLevel}
returns
::traceLevel. On the other hand, the command,
namespace eval Foo {namespace which -variable traceLevel}
returns
::Foo::traceLevel.
As mentioned above, namespace names are looked up differently than the names of
variables and commands. Namespace names are always resolved in the current
namespace. This means, for example, that a
namespace eval command that
creates a new namespace always creates a child of the current namespace unless
the new namespace name begins with
::.
Tcl has no access control to limit what variables, commands, or namespaces you
can reference. If you provide a qualified name that resolves to an element by
the name resolution rule above, you can access the element.
You can access a namespace variable from a procedure in the same namespace by
using the
variable command. Much like the
global command, this
creates a local link to the namespace variable. If necessary, it also creates
the variable in the current namespace and initializes it. Note that the
global command only creates links to variables in the global namespace.
It is not necessary to use a
variable command if you always refer to
the namespace variable using an appropriate qualified name.
Namespaces are often used to represent libraries. Some library commands are used
so frequently that it is a nuisance to type their qualified names. For
example, suppose that all of the commands in a package like BLT are contained
in a namespace called
Blt. Then you might access these commands like
this:
Blt::graph .g -background red
Blt::table . .g 0,0
If you use the
graph and
table commands frequently, you may want
to access them without the
Blt:: prefix. You can do this by importing
the commands into the current namespace, like this:
This adds all exported commands from the
Blt namespace into the current
namespace context, so you can write code like this:
graph .g -background red
table . .g 0,0
The
namespace import command only imports commands from a namespace that
that namespace exported with a
namespace export command.
Importing
every command from a namespace is generally a bad idea since
you do not know what you will get. It is better to import just the specific
commands you need. For example, the command
namespace import Blt::graph Blt::table
imports only the
graph and
table commands into the current
context.
If you try to import a command that already exists, you will get an error. This
prevents you from importing the same command from two different packages. But
from time to time (perhaps when debugging), you may want to get around this
restriction. You may want to reissue the
namespace import command to
pick up new commands that have appeared in a namespace. In that case, you can
use the
-force option, and existing commands will be silently
overwritten:
namespace import -force Blt::graph Blt::table
If for some reason, you want to stop using the imported commands, you can remove
them with a
namespace forget command, like this:
This searches the current namespace for any commands imported from
Blt.
If it finds any, it removes them. Otherwise, it does nothing. After this, the
Blt commands must be accessed with the
Blt:: prefix.
When you delete a command from the exporting namespace like this:
the command is automatically removed from all namespaces that import it.
You can export commands from a namespace like this:
namespace eval Counter {
namespace export bump reset
variable Num 0
variable Max 100
proc bump {{by 1}} {
variable Num
incr Num $by
Check
return $Num
}
proc reset {} {
variable Num
set Num 0
}
proc Check {} {
variable Num
variable Max
if {$Num > $Max} {
error "too high!"
}
}
}
The procedures
bump and
reset are exported, so they are included
when you import from the
Counter namespace, like this:
namespace import Counter::*
However, the
Check procedure is not exported, so it is ignored by the
import operation.
The
namespace import command only imports commands that were declared as
exported by their namespace. The
namespace export command specifies
what commands may be imported by other namespaces. If a
namespace
import command specifies a command that is not exported, the command is
not imported.
The
namespace code command is the means by which a script may be packaged
for evaluation in a namespace other than the one in which it was created. It
is used most often to create event handlers, Tk bindings, and traces for
evaluation in the global context. For instance, the following code indicates
how to direct a variable
trace callback into the current namespace:
namespace eval a {
variable b
proc theTraceCallback { n1 n2 op } {
upvar 1 $n1 var
puts "the value of $n1 has changed to $var"
return
}
trace add variable b write [ namespace code theTraceCallback]
}
set a::b c
When executed, it prints the message:
the value of a::b has changed to c
The
namespace ensemble is used to create and manipulate ensemble
commands, which are commands formed by grouping subcommands together. The
commands typically come from the current namespace when the ensemble was
created, though this is configurable. Note that there may be any number of
ensembles associated with any namespace (including none, which is true of all
namespaces by default), though all the ensembles associated with a namespace
are deleted when that namespace is deleted. The link between an ensemble
command and its namespace is maintained however the ensemble is renamed.
Three subcommands of the
namespace ensemble command are defined:
- namespace ensemble create ?option value ...?
- Creates a new ensemble command linked to the current namespace, returning
the fully qualified name of the command created. The arguments to
namespace ensemble create allow the configuration of the command as
if with the namespace ensemble configure command. If not overridden
with the -command option, this command creates an ensemble with
exactly the same name as the linked namespace. See the section ENSEMBLE
OPTIONS below for a full list of options supported and their
effects.
- namespace ensemble configure command ?option?
?value ...?
- Retrieves the value of an option associated with the ensemble command
named command, or updates some options associated with that
ensemble command. See the section ENSEMBLE OPTIONS below for a full
list of options supported and their effects.
- namespace ensemble exists command
- Returns a boolean value that describes whether the command command
exists and is an ensemble command. This command only ever returns an error
if the number of arguments to the command is wrong.
When called, an ensemble command takes its first argument and looks it up
(according to the rules described below) to discover a list of words to
replace the ensemble command and subcommand with. The resulting list of words
is then evaluated (with no further substitutions) as if that was what was
typed originally (i.e. by passing the list of words through
Tcl_EvalObjv) and returning the result of the command. Note that it is
legal to make the target of an ensemble rewrite be another (or even the same)
ensemble command. The ensemble command will not be visible through the use of
the
uplevel or
info level commands.
The following options, supported by the
namespace ensemble create
and
namespace ensemble configure commands, control how an ensemble
command behaves:
- -map
- When non-empty, this option supplies a dictionary that provides a mapping
from subcommand names to a list of prefix words to substitute in place of
the ensemble command and subcommand words (in a manner similar to an alias
created with interp alias; the words are not reparsed after
substitution); if the first word of any target is not fully qualified when
set, it is assumed to be relative to the current namespace and
changed to be exactly that (that is, it is always fully qualified when
read). When this option is empty, the mapping will be from the local name
of the subcommand to its fully-qualified name. Note that when this option
is non-empty and the -subcommands option is empty, the ensemble
subcommand names will be exactly those words that have mappings in the
dictionary.
- -prefixes
- This option (which is enabled by default) controls whether the ensemble
command recognizes unambiguous prefixes of its subcommands. When turned
off, the ensemble command requires exact matching of subcommand
names.
- -subcommands
- When non-empty, this option lists exactly what subcommands are in the
ensemble. The mapping for each of those commands will be either whatever
is defined in the -map option, or to the command with the same name
in the namespace linked to the ensemble. If this option is empty, the
subcommands of the namespace will either be the keys of the dictionary
listed in the -map option or the exported commands of the linked
namespace at the time of the invocation of the ensemble command.
- -unknown
- When non-empty, this option provides a partial command (to which all the
words that are arguments to the ensemble command, including the
fully-qualified name of the ensemble, are appended) to handle the case
where an ensemble subcommand is not recognized and would otherwise
generate an error. When empty (the default) an error (in the style of
Tcl_GetIndexFromObj) is generated whenever the ensemble is unable
to determine how to implement a particular subcommand. See UNKNOWN
HANDLER BEHAVIOUR for more details.
The following extra option is allowed by
namespace ensemble
create:
- -command
- This write-only option allows the name of the ensemble created by
namespace ensemble create to be anything in any existing namespace.
The default value for this option is the fully-qualified name of the
namespace in which the namespace ensemble create command is
invoked.
The following extra option is allowed by
namespace ensemble
configure:
- -namespace
- This read-only option allows the retrieval of the fully-qualified name of
the namespace which the ensemble was created within.
If an unknown handler is specified for an ensemble, that handler is called when
the ensemble command would otherwise return an error due to it being unable to
decide which subcommand to invoke. The exact conditions under which that
occurs are controlled by the
-subcommands,
-map and
-prefixes options as described above.
To execute the unknown handler, the ensemble mechanism takes the specified
-unknown option and appends each argument of the attempted ensemble
command invocation (including the ensemble command itself, expressed as a
fully qualified name). It invokes the resulting command in the scope of the
attempted call. If the execution of the unknown handler terminates normally,
the ensemble engine reparses the subcommand (as described below) and tries to
dispatch it again, which is ideal for when the ensemble's configuration has
been updated by the unknown subcommand handler. Any other kind of termination
of the unknown handler is treated as an error.
The result of the unknown handler is expected to be a list (it is an error if it
is not). If the list is an empty list, the ensemble command attempts to look
up the original subcommand again and, if it is not found this time, an error
will be generated just as if the
-unknown handler was not there (i.e.
for any particular invocation of an ensemble, its unknown handler will be
called at most once.) This makes it easy for the unknown handler to update the
ensemble or its backing namespace so as to provide an implementation of the
desired subcommand and reparse.
When the result is a non-empty list, the words of that list are used to replace
the ensemble command and subcommand, just as if they had been looked up in the
-map. It is up to the unknown handler to supply all namespace
qualifiers if the implementing subcommand is not in the namespace of the
caller of the ensemble command. Also note that when ensemble commands are
chained (e.g. if you make one of the commands that implement an ensemble
subcommand into an ensemble, in a manner similar to the
text widget's
tag and mark subcommands) then the rewrite happens in the context of the
caller of the outermost ensemble. That is to say that ensembles do not in
themselves place any namespace contexts on the Tcl call stack.
Where an empty
-unknown handler is given (the default), the ensemble
command will generate an error message based on the list of commands that the
ensemble has defined (formatted similarly to the error message from
Tcl_GetIndexFromObj). This is the error that will be thrown when the
subcommand is still not recognized during reparsing. It is also an error for
an
-unknown handler to delete its namespace.
Create a namespace containing a variable and an exported command:
namespace eval foo {
variable bar 0
proc grill {} {
variable bar
puts "called [incr bar] times"
}
namespace export grill
}
Call the command defined in the previous example in various ways.
# Direct call
::foo::grill
# Use the command resolution path to find the name
namespace eval boo {
namespace path ::foo
grill
}
# Import into current namespace, then call local alias
namespace import foo::grill
grill
# Create two ensembles, one with the default name and one with a
# specified name. Then call through the ensembles.
namespace eval foo {
namespace ensemble create
namespace ensemble create -command ::foobar
}
foo grill
foobar grill
Look up where the command imported in the previous example came from:
puts "grill came from [ namespace origin grill]"
Remove all imported commands from the current namespace:
namespace forget {*}[namespace import]
interp(n), upvar(n), variable(n)
command, ensemble, exported, internal, variable