Provided by: itcl3-doc_3.4.3-3_all bug


       body - change the body for a class method/proc


       itcl::body className::function args body


       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".
                  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;


       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


       class, object, procedure