Diff for /gforth/doc/gforth.ds between versions 1.5 and 1.6

version 1.5, 1997/07/31 16:17:24 version 1.6, 1997/08/02 20:19:21
Line 53  Copyright @copyright{} 1995-1997 Free So Line 53  Copyright @copyright{} 1995-1997 Free So
 @center for version 0.4  @center for version 0.4
 @sp 2  @sp 2
 @center Anton Ertl  @center Anton Ertl
 @center Jens Wilke  
 @center Bernd Paysan  @center Bernd Paysan
   @center Jens Wilke
 @sp 3  @sp 3
 @center This manual is under construction  @center This manual is permanently under construction
   
 @comment  The following two commands start the copyright page.  @comment  The following two commands start the copyright page.
 @page  @page
Line 756  then in @file{~}, then in the normal pat Line 756  then in @file{~}, then in the normal pat
 * Locals::                        * Locals::                      
 * Defining Words::                * Defining Words::              
 * Structures::                    * Structures::                  
 * Objects::                       * Objects::
   * Object Oriented Forth::                     
 * Tokens for Words::              * Tokens for Words::            
 * Wordlists::                     * Wordlists::                   
 * Files::                         * Files::                       
Line 2939  doc-%size Line 2940  doc-%size
 doc-struct  doc-struct
   
 @c -------------------------------------------------------------  @c -------------------------------------------------------------
 @node Objects, Tokens for Words, Structures, Words  @node Objects, Object Oriented Forth, Structures, Words
 @section Objects  @section Objects
 @cindex objects  @cindex objects
 @cindex object-oriented programming  @cindex object-oriented programming
Line 3758  doc-to-this Line 3759  doc-to-this
 doc-xt-new  doc-xt-new
   
 @c -------------------------------------------------------------  @c -------------------------------------------------------------
 @node Tokens for Words, Wordlists, Objects, Words  @node Object Oriented Forth, Objects, Tokens for Words, Words
   @section Object oriented Forth
   @cindex oof
   @cindex object-oriented programming
   
   @cindex @file{objects.fs}
   @cindex @file{oof.fs}
   Gforth comes with two packets for object-oriented programming,
   @file{objects.fs} and @file{oof.fs}; none of them is preloaded, so you
   have to @code{include} them before use. This section describes the
   @file{oof.fs} packet. Both packets are written in ANS Forth and can be
   used with any other standard Forth (@exref{Objects}). This section uses
   the same rationale why using object-oriented programming, and the same
   terminology.
   
   The packet described in this section is used in bigFORTH since 1991, and
   used for two large applications: a chromatographic system used to
   create new medicaments, and a graphic user interface library (MINOS).
   
   @menu
   * Properties of the OOF model::
   * Basic OOF Usage::
   * The base class object::
   @end menu
   
   @node Properties of the OOF model, Object Oriented Forth, Basic OOF Usage, Object Oriented Forth
   @subsection Properties of the OOF model
   @cindex @file{oof.fs} properties
   
   @itemize @bullet
   @item
   This model combines object oriented programming with information
   hiding. It helps you writing large application, where scoping is
   necessary, because it provides class-oriented scoping.
   
   @item
   Named objects, object pointers, and object arrays can be created,
   selector invocation uses the "object selector" syntax. Selector invocation
   to objects and/or selectors on the stack is a bit less convenient, but
   possible.
   
   @item
   Selector invocation and instance variable usage of the active object is
   straight forward, since both make use of the active object.
   
   @item
   Late binding is efficient and easy to use.
   
   @item
   State-smart objects parse selectors. However, extensibility is provided
   using a (parsing) selector @code{postpone} and a selector @code{'}.
   
   @item
   An implementation in ANS Forth is available.
   
   @end itemize
   
   
   @node Basic OOF Usage, Properties of the OOF model, The base class object, Object Oriented Forth
   @subsection Basic OOF Usage
   @cindex @file{oof.fs} usage
   
   Here, I use the same example as for @code{objects} (@pxref{Basic Objects Usage}).
   
   You can define a class for graphical objects like this:
   
   @cindex @code{class} usage
   @cindex @code{class;} usage
   @cindex @code{method} usage
   @example
   object class graphical \ "object" is the parent class
     method draw ( x y graphical -- )
   class;
   @end example
   
   This code defines a class @code{graphical} with an
   operation @code{draw}.  We can perform the operation
   @code{draw} on any @code{graphical} object, e.g.:
   
   @example
   100 100 t-rex draw
   @end example
   
   where @code{t-rex} is an object or object pointer, created with e.g.
   @code{graphical : trex}.
   
   @cindex abstract class
   How do we create a graphical object? With the present definitions,
   we cannot create a useful graphical object. The class
   @code{graphical} describes graphical objects in general, but not
   any concrete graphical object type (C++ users would call it an
   @emph{abstract class}); e.g., there is no method for the selector
   @code{draw} in the class @code{graphical}.
   
   For concrete graphical objects, we define child classes of the
   class @code{graphical}, e.g.:
   
   @example
   graphical class circle \ "graphical" is the parent class
     cell var circle-radius
   how:
     : draw ( x y -- )
       circle-radius @@ draw-circle ;
   
     : init ( n-radius -- (
       circle-radius ! ;
   class;
   @end example
   
   Here we define a class @code{circle} as a child of @code{graphical},
   with a field @code{circle-radius}; it defines new methods for the
   selectors @code{draw} and @code{init} (@code{init} is defined in
   @code{object}, the parent class of @code{graphical}).
   
   Now we can create a circle in the dictionary with
   
   @example
   50 circle : my-circle
   @end example
   
   @code{:} invokes @code{init}, thus initializing the field
   @code{circle-radius} with 50. We can draw this new circle at (100,100)
   with
   
   @example
   100 100 my-circle draw
   @end example
   
   @cindex selector invocation, restrictions
   @cindex class definition, restrictions
   Note: You can invoke a selector only if the receiving object belongs to
   the class where the selector was defined or one of its descendents;
   e.g., you can invoke @code{draw} only for objects belonging to
   @code{graphical} or its descendents (e.g., @code{circle}). The scoping
   mechanism will check if you try to invocate a selector that is not
   defined in this class hierarchy, so you'll get an error at compilation
   time.
   
   
   @node The base class object, Basic OOF Usage, Tokes for Words, Object Oriented Forth
   @subsection The base class @file{object}
   @cindex @file{oof.fs} base class
   
   When you define a class, you have to specify a parent class.  So how do
   you start defining classes? There is one class available from the start:
   @code{object}. You have to use it as ancestor for all classes. It is the
   only class that has no parent. Classes are also objects, except that
   they don't have instance variables; class manipulation such as
   inheritance or changing definitions of a class is handled through
   selectors of the class @code{object}.
   
   @code{object} provides a number of selectors:
   
   @itemize @bullet
   @item
   @code{class} for subclassing, @code{definitions} to add definitions
   later on, and @code{class?} to get type informations (is the class a
   subclass of the class passed on the stack?).
   
   @item
   @code{init} and @code{dispose} as constructor and destroctor of the
   object. @code{init} is invocated after the object's memory is allocated,
   while @code{dispose} also handles deallocation. Thus if you redefine
   @code{dispose}, you have to call the parent's dispose with @code{super
   dispose}, too.
   
   @item
   @code{new}, @code{new[]}, @code{:}, @code{ptr}, and @code{[]} to create
   named and unnamed objects and object arrays or object pointers.
   
   @item
   @code{::} and @code{super} for expicit scoping. You should use expicit
   scoping only for super classes or classes with the same set of instance
   variables. Explicit scoped selectors use early binding.
   
   @item
   @code{self} to get the address of the object
   
   @item
   @code{bind}, @code{bound}, @code{link}, and @code{is} to assign object
   pointers and instance defers.
   
   @item
   @code{'} to obtain selector tokens, @code{send} to invocate selectors
   form the stack, and @code{postpone} to generate selector invocation code.
   
   @item
   @code{with} and @code{endwith} to select the active object from the
   stack, and enabling it's scope. Using @code{with} and @code{endwith}
   also allows to create code using selector @code{postpone} without being
   trapped bye the state-smart objects.
   
   @end itemize
   
   @c -------------------------------------------------------------
   @node Tokens for Words, Wordlists, Object Oriented Forth, Words
 @section Tokens for Words  @section Tokens for Words
 @cindex tokens for words  @cindex tokens for words
   
Line 3852  doc-name>string Line 4048  doc-name>string
 @menu  @menu
 * Debugging::                   Simple and quick.  * Debugging::                   Simple and quick.
 * Assertions::                  Making your programs self-checking.  * Assertions::                  Making your programs self-checking.
 * Singlestep debugger::         Executing your program word by word.  * Singlestep Debugger::         Executing your program word by word.
 @end menu  @end menu
   
 @node Debugging, Assertions, Programming Tools, Programming Tools  @node Debugging, Assertions, Programming Tools, Programming Tools

Removed from v.1.5  
changed lines
  Added in v.1.6


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>