man n body

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

______________________________________________________________________________

NAME
       body - change the body for a class method/proc

SYNOPSIS
       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 "implementa-
       tion" parts.  The "interface" part is a class command with declarations
       for  methods, procs, instance variables and common variables.  The "im-
       plementation" 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 "im-
       plementation" 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 proce-
       dure, 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 proce-
       dures 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.
              class File {
                  private variable fid ""
                  constructor {name access} {
                      set fid [open $name $access]
                  }
                  destructor {
                      close $fid
                  }

                  method get {}
                  method put {line}
                  method eof {}
              }

              body File::get {} {
                  return [gets $fid]
              }
              body File::put {line} {
                  puts $fid $line
              }
              body File::eof {} {
                  return [::eof $fid]
              }

              #
              # See the File class in action:
              #
              File x /etc/passwd "r"
              while {![x eof]} {
                  puts "=> [x get]"
              }
              delete object x

KEYWORDS
       class, object, procedure

itcl                                  3.0                              body(n)