---
name: "configbody"
section: "n"
platform: "linux"
package: "tcl"
version: "8.6.16-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux", "macos"]
url: "https://new.carta.tech/configbody/n"
---

# configbody(n)

change the "config" code for a public variable

```

```

## NAME

itcl::configbody - change the "config" code for a public variable

## SYNOPSIS

**itcl::configbody** *className***::***varName body*

```

```

## DESCRIPTION

The **configbody** command is used outside of an **\[incr Tcl\]** class definition to define or redefine the configuration code associated with a public variable.  Public variables act like configuration options for an object.  They can be modified outside the class scope using the built-in **configure** method. Each variable can have a bit of "config" code associate with it that is automatically executed when the variable is configured. The **configbody** command can be used to define or redefine this body of code.

Like the **body** command, this facility allows a class definition to have separate "interface" and "implementation" parts. The "interface" part is a **class** command with declarations for methods, procs, instance variables and common variables. The "implementation" part is a series of **body** and **configbody** commands.  If the "implementation" part is kept in a separate file, it can be sourced again and again as bugs are fixed, to support interactive development. When using the "tcl" mode in the **emacs** editor, the "interface" and "implementation" parts can be kept in the same file; as bugs are fixed, individual bodies can be highlighted and sent to the test application.

The name "*className***::***varName*" identifies the public variable being updated. If the *body* string starts with "**@**", it is treated as the symbolic name for a C procedure.  Otherwise, it is treated as a Tcl command script.

Symbolic names for C procedures are established by registering procedures via **Itcl\_RegisterC()**.  This is usually done in the **Tcl\_AppInit()** procedure, which is automatically called when the interpreter starts up.  In the following example, the procedure `My_FooCmd()` is registered with the symbolic name "foo".  This procedure can be referenced in the **configbody** command as "`@foo`".

```
int
Tcl_AppInit(interp)
    Tcl_Interp *interp;     /* Interpreter for application. */
{
    if (Itcl_Init(interp) == TCL_ERROR) {
        return TCL_ERROR;
    }
    if (Itcl_RegisterC(interp, "foo", My_FooCmd) != TCL_OK) {
        return TCL_ERROR;
    }
}
```

## EXAMPLE

In the following example, a "File" class is defined to represent open files.  Whenever the "-name" option is configured, the existing file is closed, and a new file is opened.  Note that the "config" code for a public variable is optional.  The "-access" option, for example, does not have it.

```
itcl::class File {
    private variable fid ""
    public variable name ""
    public variable access "r"
    constructor {args} {
        eval configure $args
    }
    destructor {
        if {$fid != ""} {
            close $fid
        }
    }
    method get {}
    method put {line}
    method eof {}
}
itcl::body File::get {} {
    return [gets $fid]
}
itcl::body File::put {line} {
    puts $fid $line
}
itcl::body File::eof {} {
    return [::eof $fid]
}
itcl::configbody File::name {
    if {$fid != ""} {
        close $fid
    }
    set fid [open $name $access]
}
#
# See the File class in action:
#
File x
x configure -name /etc/passwd
while {![x eof]} {
    puts "=> [x get]"
}
itcl::delete object x
```

## KEYWORDS

class, object, variable, configure