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

# body(n)

change the body for a class method/proc

## NAME

body - change the body for a class method/proc

## SYNOPSIS

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

## 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\_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 **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\_RegisterC(interp, "foo", My\_FooCmd) != TCL\_OK) {\
         return TCL\_ERROR;\
     } }

## 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

class, object, procedure