Object Oriented Programming in ficlReview of OO ideasClick here for a short review of OO ideas, terms, and implementations in other languages, or here for an introduction to the terms and principles of Object Oriented ProgrammingDesign goals of Ficl OO syntaxFicl's object extensions provide the traditional OO benefits of associating data with the code that manipulates it, and reuse through single inheritance. Ficl also has some unusual capabilities that support interoperation with systems written in C.
AcknowledgementsFicl is not the first Forth to include Object Oriented extensions. Ficl's OO syntax owes a debt to the work of John Hayes and Dick Pountain, among others. OO Ficl is different from other OO Forths in a few ways, though (some things never change). First, unlike several implementations, the syntax is documented (below) beyond the source code. In Ficl's spirit of working with C code, the OO syntax provides means to adapt existing data structures. I've tried to make Ficl's OO model simple and safe by unifying classes and objects, providing late binding by default, and separating namespaces so that methods and regular Forth words are not easily confused. |
Ficl Object ModelAll classes in Ficl are derived from the common base class OBJECT, as shown in the figure below. All classes are instances of METACLASS. This means that classes are objects, too. METACLASS implements the methods for messages sent to classes. Class methods create instances and subclasses, and give information about the class. Each class is represented by a data stucture of three elements:
Note for the curious: METACLASS behaves like a class - it responds
to class messages and has the same properties as any other class. If you
want to twist your brain in knots, you can think of METACLASS
as an instance of itself.
|
Ficl OO Syntax TutorialIntroductionIt's helpful to have some familiarity with Forth and the customary Forth stack notation to understand this tutorial. To get started, take a look at this web-based Forth tutorial. If you're comfortable with both OO and Forth, you can jump ahead.A Ficl object associates a class with an instance (the storage for one set of instance variables). This is done explicitly on Ficl's stack, in that any Ficl object is represented by a cell pair: ( instance-addr class-addr )The instance-addr is the address of the object's storage, and the class-addr is the address of its class. Whenever a named Ficl object executes (eg. when you type its name and press enter at the Ficl prompt), it leaves this "signature". All methods by convention expect a class and instance on the stack when they execute, too. In many other OO languages, including C++, instances contain information about their classes (a vtable pointer, for example). By making this pairing explicit rather than implicit, Ficl can be OO about chunks of data that don't realize that they are objects, without sacrificing any robustness for native objects. That means that you can use Ficl to write object wrappers for data structures created in C or assembly language, as long as you can determine how they're laid out in memory. Whenever you create an object in Ficl, you specify its class. After that, the object always pushes its class and the address of its payload (instance variable space) when invoked by name. Classes are special kinds of objects that store the methods of their instances, the size of an instance's payload, and a parent class pointer. Classes themselves are instances of a special base class called METACLASS, and all classes inherit from class OBJECT. This is confusing at first, but it means that Ficl has a very simple syntax for constructing and using objects. Class methods include subclassing (SUB), creating initialized and uninitialized instances (NEW and INSTANCE), and creating reference instances (REF), described later. Classes also have methods for disassembling their methods (SEE), identifying themselves (ID), and listing their pedigree (PEDIGREE). All objects inherit (from OBJECT) methods for initializing instances and arrays of instances, for performing array operations, and for getting information about themselves. Methods and messagesMethods are the functions that objects execute in response to messages. A message is a request to an object for a behavior that the object supports. When it receives a message, the target object looks up a method that performs the behavior for its class, and executes it. Any specific message may be bound to different methods in different objects, according to class. This separation of messages and methods allows objects to behave polymorphically. (In Ficl, methods are words defined in the context of a class, and messages are the names of those words.) Ficl classes associate messages with methods for their instances (a fancy way of saying that each class owns a wordlist). Ficl provides a late-binding operator --> that sends messages to objects at run-time, and an early-binding operator => that compiles a specific class's method. These operators are the only supported way to invoke methods. Regular Forth words are not visible to the method-binding operators, so there's no chance of confusing a message with a regular word of the same name. |
Tutorial (finally!)This is a tutorial. It works best if you follow along by pasting the examples into ficlWin, the Win32 version of Ficl included with the release sources (or some other build that includes the OO part of softcore.c). If you're not familiar with Forth, please see one of these references. Ficl's OOP words are in vocabulary OOP. To put OOP in the search order and make it the compilation wordlist, type:ONLY ( reset to default search order ) ALSO OOP DEFINITIONS(Note for beginners: to see the effect of the commands above, type ORDER after each line. You can repeat the sequence above if you like.) To start, we'll work with the two base classes OBJECT and METACLASS. Try this: metaclass --> methodsThe line above contains three words. The first is the name of a class, so it pushes its signature on the stack. Since all classes are instances of METACLASS, METACLASS behaves as if it is an instance of itself (this is the only class with this property). It pushes the same address twice: once for the class and once for the payload, since they are the same. The next word finds a method in the context of a class and executes it. In this case, the name of the method is methods. Its job is to list all the methods that a class knows. What you get when you execute this line is a list of all the class methods Ficl provides. object --> sub c-ledCauses base-class OBJECT to derive from itself a new class called c-led. Now we'll add some instance variables and methods to the new class... Note: I like to prefix the names of classes with "c-", and the names of member variables with a dot, but this is just a convention. If you don't like it, you can pick your own. c-byte obj: .state : init { 2:this -- } this --> super --> init ." initializing an instance of " this --> class --> id type cr ; : on { led# 2:this -- } this --> .state --> get 1 led# lshift or dup !oreg this --> .state --> set ; : off { led# 2:this -- } this --> .state --> get 1 led# lshift invert and dup !oreg this --> .state --> set ; end-classThe first line adds an instance variable called .state to the class. This particular instance variable is an object - it will be an instance of c-byte, one of ficl's stock classes (the source for which can be found in the distribution in sorftowrds/classes.fr). Next we've defined a method called init. This line also declares a local variable called this (the 2 in front tells Ficl that this is a double-cell local). All methods by convention expect the address of the class and instance on top of the stack when called. The next three lines define init's behavior. It first calls its superclass's version of init (which in this case is object => init - this default implementation clears all instance variables). The rest displays some text and causes the instance to print its class name (this --> class --> id). The init method is special for Ficl objects: whenever you create an initialized instance using new or new-array, Ficl calls the class's init method for you on that instance. The default init method supplied by object clears the instance, so we didn't really need to override it in this case (see the source code in ficl/softwords/oo.fr). The ON and OFF methods defined above hide the details of turning LEDs on and off. The interface to FiclWin's simulated hardware is handled by !OREG. The class keeps the LED state in a shadow variable (.STATE) so that ON and OFF can work in terms of LED number rather than a bitmask. Now make an instance of the new class: c-led --> new ledAnd try a few things... led --> methods led --> pedigree 1 led --> on 1 led --> offOr you could type this with the same effect: led 2dup --> methods --> pedigreeNotice (from the output of methods) that we've overridden the init method supplied by object, and added two more methods for the member variables. If you type WORDS, you'll see that these methods are not visible outside the context of the class that contains them. The method finder --> uses the class to look up methods. You can use this word in a definition, as we did in init, and it performs late binding, meaning that the mapping from message (method name) to method (the code) is deferred until run-time. To see this, you can decompile the init method like this: c-led --> see initor led --> class --> see init Early bindingFicl also provides early binding if you ask for it. Early binding is not as safe as late binding, but it produces code that is more compact and efficient because it compiles method addresses rather then their names. In the preferred uses of early binding, the class is assumed to be the one you're defining. This kind of early binding can only be used inside a class definition. Early bound methods still expect to find a class and instance cell-pair on top of the stack when they run.Here's an example that illustrates a potential problem: object --> sub c1 : m1 { 2:this -- } ." c1's m1" cr ; : m2 { 2:this -- } ." Running " this my=> m1 ; ( early ) : m3 { 2:this -- } ." Running " this --> m1 ( late ) end-class c1 --> sub c2 : m1 { 2:this -- } ." c2's m1" cr ; end-class c2 --> new i2 i2 --> m1 ( runs the m1 defined in c2 ) i2 --> m2 ( is this what you wanted? ) i2 --> m3 { runs the overridden m1)Even though we overrode method m1 in class c2, the definition of m2 with early binding forced the use of m1 as defined in c1. If that's what you want, great, but more often you'll want the flexibility of overriding parent class behaviors appropriately.
=> is dangerous because it partially
defeats the data-to-code matching mechanism object oriented languages were
created to provide, but it does increase run-time speed by binding the
method at compile time. In many cases, such as the init method,
you can be reasonably certain of the class of thing you're working on.
This is also true when invoking class methods, since all classes are instances
of metaclass . Here's an example from the definition of metaclass
in oo.fr (don't paste this into ficlWin - it's already there):
: new \ ( class metaclass "name" -- ) metaclass => instance --> init ;Try this... metaclass --> see newDecompiling the method with SEE shows the difference between the
two strategies. The early bound method is compiled inline, while the late-binding
operator compiles the method name and code to find and execute it in the
context of whatever class is supplied on the stack at run-time.
Notice that the primitive early-binding operator => requires
a class at compile time. For this reason, classes are IMMEDIATE ,
meaning that they push their signature at compile time or run time. I'd
recommend that you avoid early binding until you're very comfortable with
Forth, object-oriented programming, and Ficl's OOP syntax.
More About Instance VariablesUntyped instance variable methods (created by cell: cells: char: and chars:) just push the address of the corresponding instance variable when invoked on an instance of the class. It's up to you to remember the size of the instance variable and manipulate it with the usual Forth words for fetching and storing.As advertised earlier, Ficl provides ways to objectify existing data structures without changing them. Instead, you can create a Ficl class that models the structure, and instantiate a ref from this class, supplying the address of the structure. After that, the ref instance behaves as a Ficl object, but its instance variables take on the values in the existing structure. Example (from ficlclass.fr): object subclass c-wordlistIn this case, c-wordlist describes Ficl's wordlist structure; named-wid creates a wordlist and binds it to a ref instance of c-wordlist. The fancy footwork with POSTPONE and early binding is required because classes are immediate. An equivalent way to define named-wid with late binding is: : named-wid ( "name" -- )To do the same thing at run-time (and call it my-wordlist): wordlist c-wordlist --> ref my-wordlistNow you can deal with the wordlist through the ref instance: my-wordlist --> pushFicl can also model linked lists and other structures that contain pointers to structures of the same or different types. The class constructor word ref: makes an aggregate reference to a particular class. See the instance variable glossary for an example. Ficl can make arrays of instances, and aggregate arrays into class descripions. The class methods array and new-array create uninitialized and initialized arrays, respectively, of a class. In order to initialize an array, the class must define (or inherit) a reasonable init method. New-array invokes it on each member of the array in sequence from lowest to highest. Array instances and array members use the object methods index, next, and prev to navigate. Aggregate a member array of objects using array:. The objects are not automatically initialized in this case - your class initializer has to call array-init explicitly if you want this behavior. For further examples of OOP in Ficl, please see the source file ficl/softwords/ficlclass.fr. This file wraps several Ficl internal data structures in objects and gives use examples. |
Ficl String classesc-string (ficl 2.04 and later) is a reasonably useful dynamic string class. Source code for the class is located in ficl/softwords/string.fr. Features: dynamic creation and resizing; deletion, char cout, concatenation, output, comparison; creation from quoted string constant (s").Examples of use: c-string --> new homer s" In this house, " homer --> set s" we obey the laws of thermodynamics!" homer --> cat homer --> type |
object base-class Methods GlossaryThese are methods that are defined for all instances by the base class object. The methods include default initialization, array manipulations, aliases of class methods, upcasting, and programming tools.
Convert an object signature into the signature of the previous object in the array. No check for bounds underflow. |