body(n) \[incr Tcl] body(n)

```

```

# [NAME](#NAME)

itcl::body - change the body for a class method/proc

# [SYNOPSIS](#SYNOPSIS)

**itcl::body className::function args body**

```

```

# [DESCRIPTION](#DESCRIPTION)

The **body** command is used outside of an **\[incr Tcl]** class definition to define or redefine the body of a class method or proc. 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::function*" identifies the method/proc being changed.

If an *args* list was specified when the *function* was defined in the class definition, the *args* list for the **body** command must match in meaning. Variable names can change, but the argument lists must have the same required arguments and the same default values for optional arguments. The special **args** argument acts as a wildcard when included in the *args* list in the class definition; it will match zero or more arguments of any type when the body is redefined.

If the *body* string starts with "**@**", it is treated as the symbolic name for a C procedure. The *args* list has little meaning for the C procedure, except to document the expected usage. (The C procedure is not guaranteed to use arguments in this manner.) If *body* does not start with "**@**", it is treated as a Tcl command script. When the function is invoked, command line arguments are matched against the *args* list, and local variables are created to represent each argument. This is the usual behavior for a Tcl-style proc.

Symbolic names for C procedures are established by registering procedures via **Itcl\_RegisterObjC()**. 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\_FooObjCmd() is registered with the symbolic name "foo". This procedure can be referenced in the **body** command as "@foo".

```
int
Tcl_AppInit(interp)


    Tcl_Interp *interp;     /* Interpreter for application. */
{


    if (Itcl_Init(interp) == TCL_ERROR) {


        return TCL_ERROR;


    }


    if (Itcl_RegisterObjC(interp, "foo", My_FooObjCmd) != TCL_OK) {


        return TCL_ERROR;


    }
}
```

# [EXAMPLE](#EXAMPLE)

In the following example, a "File" class is defined to represent open files. The method bodies are included below the class definition via the **body** command. Note that the bodies of the constructor/destructor must be included in the class definition, but they can be redefined via the **body** command as well.

```
itcl::class File {


    private variable fid ""


    constructor {name access} {


        set fid [open $name $access]


    }


    destructor {


        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]
}
#
# See the File class in action:
#
File x /etc/passwd "r"
while {![x eof]} {


    puts "=> [x get]"
}
itcl::delete object x
```

# [KEYWORDS](#KEYWORDS)

class, object, procedure

3.0 itcl

---

Document: body(n) from tcl 9.1.0-r1 (Chainguard OS)
Source: https://downloads.sourceforge.net/project/tcl/Tcl/9.1.0/tcl9.1.0-src.tar.gz