Forth Objects

ForthLanguage provides low-level access to control flow and memory access primitives, making it easy to create an ObjectOriented Forth (OOF). Dozens of implementations exist which explore many different object concepts.

One of the best OOFs (in the C++/Java style) is available at http://www.complang.tuwien.ac.at/forth/objects/ (see objects.html for the manual). In under 20K of heavily commented Forth code it implements:

Extensible data structures
Early (compile-time) and late (virtual) method lookup
Public and protected methods and variables
Constructors
Single inheritance
Interfaces (a class can implement multiple interfaces)

Other popular OOFs implement a SmallTalk style of method lookup at runtime, and some OOFs are just plain strange (smile, DREAMS).

For a simpler example, here is the complete implementation of "HYPE", a simple OOF using standard AnsForth. See http://home.netsurf.de/helge.horch/hype.html for more information on HYPE.


        : LIT, ( x) POSTPONE LITERAL ;

        : >SIZE ( ta - n) CELL+ @ ;

VALUE SELF


        : SELF+ ( n - a) SELF + ;

        : SEND ( a xt) SELF >R  SWAP TO SELF EXECUTE  R> TO SELF ;

        VARIABLE CLS ( contains ta)

        : SIZE^ ( - aa) CLS @ ?DUP 0= ABORT" scope?" CELL+ ;

        : MFIND ( ta ca u - xt n) 2>R BEGIN DUP WHILE DUP @ 2R@ ROT

        SEARCH-WORDLIST ?DUP IF ROT DROP 2R> 2DROP EXIT THEN

        CELL+ CELL+ @ REPEAT -1 ABORT" can't?" ;

        : SEND' ( a ta "m ") BL WORD COUNT MFIND 0< STATE @ AND

        IF SWAP LIT, LIT, POSTPONE SEND ELSE SEND THEN ;

        : SUPER ( "m ") SIZE^ CELL+ @ BL WORD COUNT MFIND 0>

        IF EXECUTE ELSE COMPILE, THEN ; IMMEDIATE

        : DEFS ( n "f ") CREATE SIZE^ @ , SIZE^ +! IMMEDIATE

        DOES> @ STATE @ IF LIT, POSTPONE SELF+ ELSE SELF+ THEN ;

        : METHODS ( ta) DUP CLS ! @ DUP SET-CURRENT

        >R GET-ORDER R> SWAP 1+ SET-ORDER ; ( ALSO CONTEXT !)

        : CLASS ( "c ") CREATE HERE 0 , 0 , 0 ,

        WORDLIST OVER ! METHODS ;

        : SUBCLASS ( ta "c ") CLASS SIZE^ OVER >SIZE OVER ! CELL+ ! ;

        : END ( ) SIZE^ DROP PREVIOUS DEFINITIONS 0 CLS ! ;

        : NEW ( ta "name ") CREATE DUP , >SIZE ALLOT IMMEDIATE

        DOES> DUP CELL+ SWAP @ SEND' ;

Notes:

This code implements classes and subclasses, with public methods and instance variables.
This is one of the simplest object-oriented Forths that is reasonably usable. The code is not pretty, but it is standard, compact, and reasonably well-factored.
The programmer is not SHOUTING--uppercase is required for *strict* AnsForth compliance. (Lowercase letter support is common, but optional.)
HYPE compiles into less than 2K of code on almost any Forth (1147 bytes on Win32Forth). On several platforms it would use less than 500 bytes.

Given the code above, a Forth programmer can write code like:


        : VAR 1 CELLS DEFS ;       \ Helper for creating instance vars


        CLASS BUTTON

        VAR TEXT

        VAR LEN

        VAR X

        VAR Y

        : DRAW ( )

        X @ Y @ AT-XY            \ Get X and Y, and position cursor on screen

        TEXT @ LEN @ TYPE ;      \ Get TEXT and LENgth, and type it

        : INIT ( ca u)   0 X ! 0 Y ! LEN ! TEXT ! ;

        END


        : BOLD   27 EMIT ." [1m" ;   \ Emit code to turn on BOLD TEXT

        : NORMAL 27 EMIT ." [0m" ;   \ Emit code to return to normal text


        BUTTON SUBCLASS BOLD-BUTTON

        : DRAW ( )   BOLD SUPER DRAW NORMAL ;

        END

...which could be used like:


        BUTTON NEW FOO                \ creates new button "FOO"

        S" thin foo" FOO INIT         \ calls init method on FOO with string arg.

        PAGE                          \ clear the screen

        FOO DRAW                      \ draw FOO

        BOLD-BUTTON NEW BAR           \ create new bold-button

        S" fat bar" BAR INIT          \ initialize

BAR Y ! \ change the Y instance variable


        BAR DRAW                      \ draw the BAR button

The preceding object system is an example of an object method syntax. The default object system in NeonLanguage, MopsLanguage, and Win32Forth instead uses a method: object syntax.


        :class Point 
        int x

        int y

        :m ClassInit: ( -- )

        ClassInit: super

to x 0 to y


        ;m

        :m set-xy: ( x y -- ) to y to x ;m

        :m show: ( -- ) ." ( " x . y . ." )" ;m

        ;class


        Point pt

3 set-xy: pt


        show: pt    \ ( 2 3 )

CategoryForth