ref: d210d6548b86799554676b4dc5146ff0f4174999
parent: 90bf6a12d969275fb47171207dcfd89c65d17895
author: jsadler <jsadler@ficl.sf.net>
date: Tue Jun 6 23:20:38 CDT 2000
<>
--- a/dict.c
+++ b/dict.c
@@ -277,7 +277,7 @@
dictResetSearchOrder(pDict);
vmThrowErr(pVM, "Error: search order overflow");
}
- else if (pDict->nLists < 1)
+ else if (pDict->nLists < 0)
{dictResetSearchOrder(pDict);
vmThrowErr(pVM, "Error: search order underflow");
@@ -602,7 +602,11 @@
assert(pHash);
assert(pFW);
- hashInsertWord(pHash, pFW);
+ /*
+ ** :noname words never get linked into the list...
+ */
+ if (pFW->nName > 0)
+ hashInsertWord(pHash, pFW);
pFW->flags &= ~(FW_SMUDGE);
return;
}
@@ -620,7 +624,37 @@
/**************************************************************************
- h a s h H a s h C o d e
+ h a s h F o r g e t
+** Unlink all words in the hash that have addresses greater than or
+** equal to the address supplied. Implementation factor for FORGET
+** and MARKER.
+**************************************************************************/
+void hashForget(FICL_HASH *pHash, void *where)
+{+ FICL_WORD *pWord;
+ unsigned i;
+
+ assert(pHash);
+ assert(where);
+
+ for (i = 0; i < pHash->size; i++)
+ {+ pWord = pHash->table[i];
+
+ while ((void *)pWord >= where)
+ {+ pWord = pWord->link;
+ }
+
+ pHash->table[i] = pWord;
+ }
+
+ return;
+}
+
+
+/**************************************************************************
+ h a s h H a s h C o d e
**
** Generate a 16 bit hashcode from a character string using a rolling
** shift and add stolen from PJ Weinberger of Bell Labs fame. Case folds
@@ -653,27 +687,7 @@
/**************************************************************************
- h a s h R e s e t
-** Initialize a FICL_HASH to empty state.
-**************************************************************************/
-void hashReset(FICL_HASH *pHash)
-{- unsigned i;
-
- assert(pHash);
-
- for (i = 0; i < pHash->size; i++)
- {- pHash->table[i] = NULL;
- }
-
- pHash->link = NULL;
- return;
-}
-
-
-/**************************************************************************
- h a s h I n s e r t W o r d
+ h a s h I n s e r t W o r d
** Put a word into the hash table using the word's hashcode as
** an index (modulo the table size).
**************************************************************************/
@@ -700,7 +714,7 @@
/**************************************************************************
- h a s h L o o k u p
+ h a s h L o o k u p
** Find a name in the hash table given the hashcode and text of the name.
** Returns the address of the corresponding FICL_WORD if found,
** otherwise NULL.
@@ -737,4 +751,25 @@
return NULL;
}
+
+
+/**************************************************************************
+ h a s h R e s e t
+** Initialize a FICL_HASH to empty state.
+**************************************************************************/
+void hashReset(FICL_HASH *pHash)
+{+ unsigned i;
+
+ assert(pHash);
+
+ for (i = 0; i < pHash->size; i++)
+ {+ pHash->table[i] = NULL;
+ }
+
+ pHash->link = NULL;
+ return;
+}
+
--- a/doc/ficl.html
+++ b/doc/ficl.html
@@ -1,8 +1,9 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<META NAME="Author" CONTENT="john sadler">
- <META NAME="GENERATOR" CONTENT="Mozilla/4.04 [en] (Win95; I) [Netscape]">
+ <META NAME="GENERATOR" CONTENT="Mozilla/4.07 [en] (Win95; U) [Netscape]">
<TITLE>ficl 2.0 release notes</TITLE>
</HEAD>
<BODY>
@@ -9,13 +10,13 @@
<CENTER>
<H1>
-<B>ficl 2.0 release notes</B></H1></CENTER>
+<B>ficl 2.02 release notes</B></H1></CENTER>
<TABLE BORDER=0 CELLSPACING=3 WIDTH="600" >
<TR>
<TD><B>Forth Inspired Command Language </B></TD>
-<TD ROWSPAN="4"><IMG SRC="Logo.jpg" HEIGHT=64 WIDTH=64></TD>
+<TD ROWSPAN="4"><IMG SRC="ficl_logo.jpg" HEIGHT=64 WIDTH=64></TD>
</TR>
<TR>
@@ -27,7 +28,7 @@
</TR>
<TR>
-<TD><B>Revision 2.0: 14 September 1998 </B></TD>
+<TD><B>Revision 2.02: 10 October 1998 </B></TD>
</TR>
</TABLE>
@@ -48,7 +49,7 @@
<A HREF="#manifest">Distribution source files</A></LI>
<LI>
-<A HREF="#whatsnew">What's new in Ficl 2.0</A></LI>
+<A HREF="#whatsnew">What's new in this release</A></LI>
<LI>
<A HREF="#objects">Objects in ficl</A></LI>
@@ -55,6 +56,9 @@
<UL>
<LI>
+<A HREF="ficl.html#oopgloss">OOP glossary</A></LI>
+
+<LI>
<A HREF="#glossinstance">Instance variable glossary</A></LI>
<LI>
@@ -61,7 +65,7 @@
<A HREF="#glossclass">Class methods glossary</A></LI>
<LI>
-<A HREF="#objectgloss">Object base-class methods glossary</A></LI>
+<A HREF="#objectgloss">Object base class methods glossary</A></LI>
<LI>
<A HREF="#stockclasses">Supplied Classes</A></LI>
@@ -80,16 +84,17 @@
<A HREF="#lawyerbait">Disclaimer & License</A></LI>
</UL>
-<H2>
-
-<HR WIDTH="100%"><A NAME="whatis"></A>What is ficl?</H2>
-
+<HR WIDTH="100%">
<TABLE CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
-<TD>Ficl (Forth-inspired command language) is an ANS Forth interpreter
-written in C. Unlike traditional Forths, this interpreter is designed to
-be embedded into other systems as a command/macro/development prototype
-language.</TD>
+<TD>
+<H2>
+<A NAME="whatis"></A>What is ficl?</H2>
+Ficl (Forth inspired command language) is an ANS Forth interpreter written
+in C. Unlike traditional Forths, this interpreter is designed to be embedded
+into other systems as a command/macro/development prototype language. Ficl
+provides object extensions that can be used to wrap methods and structures
+of the host system without altering them.</TD>
</TR>
<TR>
@@ -102,12 +107,11 @@
reasonably fast) with the best features of C (everyone knows it, easier
to support large blocks of code, efficient, type checking). In addition,
Ficl provides a simple object model that can act as an object oriented
-adapter for code written in C (or asm, Forth, C++...).
-<BR> </TD>
+adapter for code written in C (or asm, Forth, C++...). </TD>
</TR>
<TR>
-<TD><B>Ficl Design goals</B>
+<TD><B>Ficl Design goals</B>
<UL>
<LI>
Target 32 bit processors </LI>
@@ -135,13 +139,14 @@
</TD>
</TR>
</TABLE>
-
-<H3>
-<A NAME="features"></A>Ficl features</H3>
-
+
+<BR>
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
<TD>
+<H2>
+<A NAME="features"></A>Ficl features</H2>
+
<UL>
<LI>
Code is written in ANSI C for portability.</LI>
@@ -148,7 +153,7 @@
<LI>
Standard: Implements the ANS Forth CORE word set, part of the CORE EXT
-word-set, SEARCH and SEARCH EXT, TOOLS and part of TOOLS EXT, LOCAL and
+word set, SEARCH and SEARCH EXT, TOOLS and part of TOOLS EXT, LOCAL and
LOCAL EXT and various extras.</LI>
<LI>
@@ -162,9 +167,9 @@
can invoke ficl code.</LI>
<LI>
-Ficl is thread safe and re-entrant: Each Ficl virtual machine has
-an otherwise complete state, and each can be bound to a separate I/O channel
-(or none at all). All Ficl VMs share one system dictionary. An optional
+Ficl is thread safe and re-entrant: All Ficl VMs share one system
+dictionary; each Ficl virtual machine has an otherwise complete state,
+and each can be bound to a separate I/O channel (or none at all). An optional
function called ficlLockDictionary() can control exclusive dictionary access.
This function is stubbed out by default (See FICL_MULTITHREAD in sysdep.h).
As long as there is only one "session" that can compile words into the
@@ -175,7 +180,7 @@
three Ficl function calls (see the example program in testmain.c).</LI>
<LI>
-ROMable: Ficl is designed to work in RAM-based and ROM code / RAM data
+ROM able: Ficl is designed to work in RAM based and ROM code / RAM data
environments. It does require somewhat more memory than a pure ROM implementation
because it builds its system dictionary in RAM at startup time.</LI>
@@ -182,7 +187,7 @@
<LI>
Written an ANSI C to be as simple as I can make it to understand, support,
debug, and port. Compiles without complaint at /Az /W4 (require ANSI C,
-max warnings) under Microsoft VC++ 5.</LI>
+max. warnings) under Microsoft VC++ 5.</LI>
<LI>
Does full 32 bit math (but you need to implement two mixed precision math
@@ -194,24 +199,26 @@
</TD>
</TR>
</TABLE>
-
-<H3>
-<HR WIDTH="100%"><A NAME="porting"></A>Porting ficl</H3>
-
+<P>
+<HR WIDTH="100%">
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
-<TD>To install ficl on your target system, you need an ANSI C compiler
-and its runtime library. Inspect the system dependent macros and functions
+<TD>
+<H2>
+<A NAME="porting"></A>Porting ficl</H2>
+To install ficl on your target system, you need an ANSI C compiler and
+its runtime library. Inspect the system dependent macros and functions
in <TT>sysdep.h</TT> and <TT>sysdep.c</TT> and edit them to suit your system.
For example, <TT>INT16</TT> is a <TT>short</TT> on some compilers and an
-<TT>int</TT> on others. Check the default <TT>CELL</TT> alignment controlled
-by <TT>FICL_ALIGN</TT>. If necessary, add new definitions of <TT>ficlMalloc,
-ficlFree, ficlLockDictionary</TT>, and <TT>ficlTextOut</TT> to work with
-your operating system. Finally, use <TT>testmain.c</TT> as a guide to installing
-the ficl system and one or more virtual machines into your code. You do
-not need to include <TT>testmain.c</TT> in your build.
-
+<TT>int</TT>
+on others. Check the default <TT>CELL</TT> alignment controlled by <TT>FICL_ALIGN</TT>.
+If necessary, add new definitions of <TT>ficlMalloc, ficlFree, ficlLockDictionary</TT>,
+and <TT>ficlTextOut</TT> to work with your operating system. Finally, use
+<TT>testmain.c</TT>
+as a guide to installing the ficl system and one or more virtual machines
+into your code. You do not need to include <TT>testmain.c</TT> in your
+build.
<P>Feel free to stub out the double precision math functions (which are
presently implemented as inline assembly because it's so easy on many 32
bit processors) with kludge code that only goes to 32 bit precision. In
@@ -240,11 +247,15 @@
</TR>
</TABLE>
-<H3>
- <A NAME="manifest"></A>Ficl Source Files</H3>
-
<TABLE BORDER=0 CELLSPACING=5 WIDTH="600" >
<TR>
+<TD COLSPAN="2">
+<H2>
+ <A NAME="manifest"></A>Ficl Source Files</H2>
+</TD>
+</TR>
+
+<TR>
<TD><B>ficl.h</B></TD>
<TD>Declares most public functions and all data structures. Includes sysdep.h
@@ -307,8 +318,8 @@
<TD>Contains all of the "soft" words - those written in Forth and compiled
by Ficl at startup time. Sources for these words are in the softwords directory.
-The files softcore.bat and softcore.pl generate softcore.c from the .fr
-sources.</TD>
+The files softwords/softcore.bat and softwords/softcore.pl generate softcore.c
+from the .fr sources.</TD>
</TR>
<TR>
@@ -322,23 +333,130 @@
<TD>Directory contains sources and translation scripts for the words defined
in softcore.c. Softcore.c depends on most of the files in this directory.
-See softcore.bat for the actual list of files that contribute to softcore.c.</TD>
+See softcore.bat for the actual list of files that contribute to softcore.c.
+This is where you'll find source code for the object oriented extensions.</TD>
</TR>
</TABLE>
-
+
+<HR WIDTH="100%">
+<TABLE BORDER=0 CELLPADDING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H2>
+<A NAME="whatsnew"></A>What's new in version 2.02</H2>
+New words
+<UL>
+<LI>
+<TT><A HREF="http://www.taygeta.com/forth/dpans6.htm#6.2.1850">marker</A>
+(CORE EXT)</TT></LI>
-<HR WIDTH="100%"><A NAME="whatsnew"></A>What's new in version 2.0</H2>
+<LI>
+<TT><A HREF="http://www.taygeta.com/forth/dpans15.htm#15.6.2.1580">forget</A>
+(TOOLS EXT)</TT></LI>
+<LI>
+<TT><A HREF="#ficlforgetwid">forget-wid</A>
+(FICL)</TT></LI>
+
+<LI>
+<TT><A HREF="#ficlwordlist">ficl-wordlist</A> (FICL)</TT></LI>
+
+<LI>
+<TT><A HREF="#ficlvocabulary">ficl-vocabulary</A> (FICL)</TT></LI>
+
+<LI>
+<TT><A HREF="#ficlhide">hide</A>
+(FICL)</TT></LI>
+
+<LI>
+<TT><A HREF="#ficlhidden">hidden</A>
+(FICL)</TT></LI>
+
+<LI>
+<A HREF="#jhlocal">Johns Hopkins local variable syntax</A> (as best I can
+determine)</LI>
+</UL>
+Bugs Fixed
+<UL>
+<LI>
+<TT>forget</TT> now adjusts the dictionary pointer to remove the name of
+the word being forgotten (name chars come before the word header in ficl's
+dictionary)</LI>
+
+<LI>
+<TT>:noname</TT> used to push the colon control marker and its execution
+token in the wrong order</LI>
+
+<LI>
+<TT>source-id</TT> now behaves correctly when loading a file.</LI>
+
+<LI>
+<TT>refill</TT> returns zero at EOF (Win32 load). Win32 <TT><A HREF="#ficlload">load</A></TT>
+command continues to be misnamed. Really ought to be called <TT>included</TT>,
+but does not exactly conform to that spec either (because <TT>included</TT>
+expects a string signature on the stack, while Ficl's <TT><A HREF="#ficlload">load</A></TT>
+expects a filename upon invocation). The "real" <TT>LOAD</TT> is a <TT>BLOCK</TT>
+word.</LI>
+</UL>
+Enhancements (IMHO)
+<UL>
+<LI>
+dictUnsmudge no longer links anonymous definitions into the dictionary</LI>
+
+<LI>
+<TT>oop</TT> is no longer the default compile wordlist at startup, nor
+is it in the search order. Execute <B><TT>also oop definitions</TT></B>
+to use Ficl OOP.</LI>
+
+<LI>
+Revised oo.fr extensively to make more use of early binding</LI>
+
+<LI>
+Added <TT>meta</TT> - a constant that pushes the address of metaclass.
+See oo.fr for examples of use.</LI>
+
+<LI>
+Added classes: <TT>c-ptr c-bytePtr c-2bytePtr c-cellPtr
+</TT>These
+classes model pointers to non-object data, but each knows the size of its
+referent.</LI>
+</UL>
+</TD>
+</TR>
+</TABLE>
+
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
<TD>
+<H2>
+What's new in version 2.01</H2>
+
<UL>
<LI>
+Bug fix: <TT>(local)</TT> used to leave a value on the stack between the
+first and last locals declared. This value is now stored in a static.</LI>
+
+<LI>
+Added new local syntax with parameter re-ordering. <A HREF="#newlocal">See
+description below</A>. (No longer compiled in version 2.02, in favor of
+the Johns Hopkins syntax)</LI>
+</UL>
+</TD>
+</TR>
+</TABLE>
+
+<TABLE BORDER=0 CELLPADDING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
+<H2>
+What's new in version 2.0</H2>
+
+<UL>
+<LI>
New ANS Forth words: <TT>TOOLS</TT> and part of <TT>TOOLS EXT, SEARCH</TT>
and <TT>SEARCH EXT, LOCALS</TT> and <TT>LOCALS EXT</TT> word sets, additional
words from <TT>CORE EXT, DOUBLE</TT>, and <TT>STRING</TT>. (See the function
-ficlCompileCore in words.c for an alphabetical list by word-set).</LI>
+ficlCompileCore in words.c for an alphabetical list by word set).</LI>
<LI>
Simple <TT>USER</TT> variable support - a user variable is a virtual machine
@@ -355,26 +473,33 @@
<LI>
Various bug fixes</LI>
</UL>
+</TD>
+</TR>
+</TABLE>
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H3>
Local Variables</H3>
-Ficl now includes support for <TT>LOCALS</TT> and <TT>LOCALS EXT</TT> words
+Ficl includes support for <TT>LOCALS</TT> and <TT>LOCALS EXT</TT> words
(all three of them!). I've implemented both of the local variable syntaxes
suggested in DPANS Appendix A.13. Examples: (By the way, Ficl implements
-<TT>-ROT</TT> as <TT>: -rot 2 -roll ;</TT> )
-<UL><B><TT>\ Using LOCALS| from LOCALS EXT</TT></B>
-<BR><B><TT>: -rot ( a b c -- c a b )</TT></B>
-<BR><B><TT> locals| c b a |</TT></B>
-<BR><B><TT> c a b </TT></B>
-<BR><B><TT>;</TT></B>
-<BR><B><TT>\ Using LOCAL END-LOCAL</TT></B>
-<BR><B><TT>: -rot ( a b c -- c a b )</TT></B>
-<BR><B><TT> local c</TT></B>
-<BR><B><TT> local b</TT></B>
-<BR><B><TT> local a</TT></B>
-<BR><B><TT> end-locals</TT></B>
-<BR><B><TT> c a b</TT></B>
-<BR><B><TT>;</TT></B> </UL>
+<TT>-ROT</TT>
+as <TT>: -rot 2 -roll ;</TT> )
+<UL><B><TT>\ Using LOCALS| from LOCALS EXT</TT></B>
+<BR><B><TT>: -rot ( a b c -- c a b )</TT></B>
+<BR><B><TT> locals| c b a |</TT></B>
+<BR><B><TT> c a b </TT></B>
+<BR><B><TT>;</TT></B>
+<BR><B><TT>\ Using LOCAL END-LOCAL</TT></B>
+<BR><B><TT>: -rot ( a b c -- c a b )</TT></B>
+<BR><B><TT> local c</TT></B>
+<BR><B><TT> local b</TT></B>
+<BR><B><TT> local a</TT></B>
+<BR><B><TT> end-locals</TT></B>
+<BR><B><TT> c a b</TT></B>
+<BR><B><TT>;</TT></B></UL>
Local variable support is optional because it adds a small amount of overhead
to the outer interpreter. You can disable it by setting FICL_WANT_LOCALS
to 0 in sysdep.h. Beware: much of the OOP code described below uses local
@@ -383,18 +508,50 @@
I'd encourage you to experiment with them.
<BR>The default maximum number of local variables is 16. It's controlled
by FICL_MAX_LOCALS in sysdep.h.
+<BR><A NAME="jhlocal"></A>Ficl 2.02 includes by default an implementation
+of the Johns Hopkins local syntax (as best I can determine it from examples
+on the web). This syntax lets you declare local variables that look very
+much like a stack comment. Variables in the declaration appear in the "correct"
+order for a stack comment. Everything after the -- is treated as a comment.
+In addition, you can insert a | before the -- to declare one or more zero-initialized
+locals. Example:
+<BLOCKQUOTE><B><TT>:tuck0 { a b c | d -- 0 a b c }</TT></B>+<BR><B><TT> d a b c ;</TT></B></BLOCKQUOTE>
+The | and -- delimiters can appear at most once, and must appear in the
+order shown in the example to work correctly. The local declaration ends
+at the first occurrence of }. The declaration must all be on one line as
+presently implemented.
+<BR><A NAME="newlocal"></A>Ficl 2.01 added yet another local syntax that
+models a stack comment. This one is not compiled in the release, but you
+can add it by editing softwords/softcore.bat to include the file ficllocal.fr.
+In this case, parameters are re-ordered so that the rightmost initialized
+param comes from the top of the stack. The syntax is:
+<UL><B><TT>{{ <initialized params> -- <cleared params> }}</TT></B></UL>+You can omit either the initialized or the cleared parameters. Parameters
+after the double dash are set to zero initially. Those to the left are
+initialized from the stack at execution time. Examples (lame ones, admittedly):
+<UL><B><TT>: -rot ( a b c -- c a b )</TT></B>
+<BR><B><TT> {{ a b c }}</TT></B>+<BR><B><TT> c a b </TT></B>
+<BR><B><TT>;</TT></B>
+<BR><B><TT>: tuck0 ( a b c -- 0 a b c )</TT></B>
+<BR><B><TT> {{ a b c -- d }}</TT></B>+<BR><B><TT> d a b c </TT></B>
+<BR><B><TT>; </TT></B></UL>
+
<H3>
Search Order</H3>
Ficl implements many of the search order words in terms of two primitives
-called <TT>>SEARCH</TT> and <TT>SEARCH></TT>. As their names suggest (assuming
-you're familiar with Forth), they push and pop the search order stack.
-See the list of <A HREF="#extras">Ficl extras</A> for details.
+called <TT><A HREF="#tosearch">>SEARCH</A></TT> and <TT><A HREF="#searchfrom">SEARCH></A></TT>.
+As their names suggest (assuming you're familiar with Forth), they push
+and pop the search order stack. See the list of <A HREF="#extras">Ficl
+extras</A> for details.
<BR>The standard does not appear to specify any conditions under which
the search order is reset to a sane state. Ficl resets the search order
to its default state whenever <TT>ABORT</TT> happens. This includes stack
underflows and overflows. <TT>QUIT</TT> does not affect the search order.
The minimum search order (set by <TT>ONLY</TT>) is equivalent to
-<BR><B><TT>FORTH-WORDLIST 1 SET-ORDER</TT></B>
+<BR><B><TT>FORTH-WORDLIST 1 SET-ORDER</TT></B>
<BR>There is a default maximum of 16 wordlists in the search order. This
can be changed by redefining FICL_DEFAULT_VOCS (declared in sysdep.h).
<H3>
@@ -409,21 +566,21 @@
that contribute to softcore.c. </TD>
</TR>
</TABLE>
-
+
<H2>
<HR WIDTH="100%"></H2>
-<H2>
-<A NAME="objects"></A>Objects in ficl</H2>
-
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
-<TD>Ficl 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 (<A HREF="#ootutorial">below</A>) beyond the source
+<TD>
+<H2>
+<A NAME="objects"></A>Objects in ficl</H2>
+Ficl 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 (<A HREF="#ootutorial">below</A>) 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,
@@ -452,31 +609,32 @@
of a class or subclass.</LI>
<LI>
-Ficl OOP syntax is regular and unified over classes and objects. This means
-that classes are a kind of object. Class methods include the ability to
-subclass and instantiate.</LI>
+Ficl OOP syntax is regular and unified over classes and objects. In ficl,
+a classes are objects. Class methods include the ability to subclass and
+instantiate.</LI>
<LI>
Ficl can adapt legacy data structures with object wrappers. You can model
a structure in a Ficl class, and create an instance that refers to an address
-in memory that holds the structure. The ref object can them manipulate
-the structure directly. This lets you wrap data structures written and
-instantiated in C.</LI>
+in memory that holds an instance of the structure. The <I>ref object</I>
+can then manipulate the structure directly. This lets you wrap data structures
+written and instantiated in C.</LI>
</UL>
</TD>
</TR>
</TABLE>
-
+
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
<TD>
<H3>
Ficl Object Model</H3>
-All classes in Ficl are derived from the common base class <TT>OBJECT</TT>.
-All classes are instances of <TT>METACLASS</TT>. This means that classes
-are objects, too. <TT>METACLASS</TT> implements the methods for messages
-sent to classes. Class methods create instances and subclasses, and give
-information about the class. Classes have exactly three elements:
+All classes in Ficl are derived from the common base class <TT><A HREF="#objectgloss">OBJECT</A></TT>.
+All classes are instances of <TT><A HREF="#glossclass">METACLASS</A></TT>.
+This means that classes are objects, too. <TT>METACLASS</TT> implements
+the methods for messages sent to classes. Class methods create instances
+and subclasses, and give information about the class. Classes have exactly
+three elements:
<UL>
<LI>
The address ( <TT>.CLASS</TT> ) of a parent class, or zero if it's a base
@@ -494,7 +652,6 @@
line with an arrow at the end indicates that the object/class at the arrow
end is an instance of the class at the other end. The vertical line with
a triangle denotes inheritance.
-
<P>Note for the curious: <TT>METACLASS</TT> 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 <TT>METACLASS</TT>
@@ -514,7 +671,7 @@
Ficl objects associate a class with an instance (really the storage for
one set of instance variables). This is done explicitly, in that any Ficl
object is represented by the cell pair:
-<UL><B><TT>( instance-addr class-addr )</TT></B> </UL>
+<UL><B><TT>( instance-addr class-addr )</TT></B></UL>
on the stack. Whenever a named Ficl object executes, it leaves this "signature".
All methods expect a class and instance on the stack when they execute,
too. In many other OO languages, including C++, instances contain information
@@ -524,7 +681,6 @@
for native objects. 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 when invoked by name.
-
<P>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 <TT>METACLASS</TT>,
@@ -546,13 +702,21 @@
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 names with methods
-for their instances. Ficl provides a late-binding operator <TT>--></TT>
-that sends messages to objects at run-time, and an early-binding operator
-<TT>=></TT> 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.
+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 <B><TT>--></TT></B> that sends messages
+to objects at run-time, and an early-binding operator
+<B><TT>=></TT></B>
+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. </TD>
+</TR>
+</TABLE>
+
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H3>
Tutorial (finally!)</H3>
Since this is a tutorial, I'm assuming you're following along by typing
@@ -559,14 +723,13 @@
the examples into ficlWin, the Win32 version of Ficl (or some other build
that includes the OO part of softcore.c). I also assume that you're familiar
with Forth. If not, please see one of the <A HREF="#links">references</A>,
-below. Ficl's OOP words are in vocabulary OOP, which is in the search order
-and is the compile wordlist when you start one of the executables from
-the release. To get to this state from the default search order (as set
-by <TT>ONLY</TT>), type:
-<UL><B><TT>ALSO OOP DEFINITIONS</TT></B> </UL>
+below. Ficl's OOP words are in vocabulary OOP. To put OOP in the search
+order and make it the compilation wordlist from the default search order
+(as set by <TT>ONLY</TT>), type:
+<UL><B><TT>ALSO OOP DEFINITIONS</TT></B></UL>
To start, we'll work with the two base classes <TT>OBJECT</TT> and <TT>METACLASS</TT>.
Try this:
-<UL><B><TT>metaclass --> methods</TT> </B> </UL>
+<UL><B><TT>metaclass --> methods</TT></B></UL>
The 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 <TT>METACLASS</TT>, <TT>METACLASS</TT> behaves as if it is an instance
@@ -576,19 +739,19 @@
a class and executes it. In this case, the name of the method is <TT>methods</TT>.
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.
-<UL><B><TT>object --> sub c-foo</TT></B> </UL>
+<UL><B><TT>object --> sub c-foo</TT></B></UL>
Causes base-class <TT>OBJECT</TT> to derive from itself a new class called
c-foo. Now we'll add some instance variables and methods to the new class...
-<UL><B><TT>cell: m_cell1</TT></B>
-<BR><B><TT>4 chars: m_chars</TT></B>
-<BR><B><TT>: init ( inst class -- )</TT></B>
-<BR><B><TT> locals| class inst |</TT></B>
-<BR><B><TT> 0 inst class --> m_cell1 !</TT></B>
-<BR><B><TT> inst class --> m_chars 4 0 fill</TT></B>
+<UL><B><TT>cell: m_cell1</TT></B>
+<BR><B><TT>4 chars: m_chars</TT></B>
+<BR><B><TT>: init ( inst class -- )</TT></B>
+<BR><B><TT> locals| class inst |</TT></B>
+<BR><B><TT> 0 inst class --> m_cell1 !</TT></B>
+<BR><B><TT> inst class --> m_chars 4 0 fill</TT></B>
<BR><B><TT> ." initializing an instance of c_foo at "
-inst x. cr</TT></B>
-<BR><B><TT>;</TT></B>
-<BR><B><TT>end-class</TT></B> </UL>
+inst x. cr</TT></B>
+<BR><B><TT>;</TT></B>
+<BR><B><TT>end-class</TT></B></UL>
The first two lines add named instance variables to the class, and creates
a method for each. <I>Untyped</I> instance variable methods (like those
created by <TT>cell: cells: char:</TT> and <TT>chars:</TT>) just push the
@@ -600,7 +763,6 @@
instance when it's called. It stashes those in local variables to avoid
stack tricks, and puts them onto the stack whenever it calls a method.
In this case, we're storing zero to the two member variables.
-
<P>The <TT>init</TT> method is special for Ficl objects: whenever you create
an initialized instance using <B><TT>new</TT></B> or <B><TT>new-array</TT></B>,
Ficl calls the class's <TT>init</TT> method for you on that instance. The
@@ -608,12 +770,12 @@
instance, so we didn't really need to override it in this case (see the
source code in ficl/softwords/oo.fr).
<BR>Now make an instance of the new class:
-<UL><B><TT>c-foo --> new foo-instance</TT></B> </UL>
+<UL><B><TT>c-foo --> new foo-instance</TT></B></UL>
And try a few things...
-<UL><B><TT>foo-instance --> methods</TT></B>
-<BR><B><TT>foo-instance --> pedigree</TT></B> </UL>
+<UL><B><TT>foo-instance --> methods</TT></B>
+<BR><B><TT>foo-instance --> pedigree</TT></B></UL>
Or you could type this with the same effect:
-<UL><B><TT>foo-instance 2dup --> methods --> pedigree</TT></B> </UL>
+<UL><B><TT>foo-instance 2dup --> methods --> pedigree</TT></B></UL>
Notice 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
@@ -622,9 +784,9 @@
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:
-<UL><B><TT>c-foo --> see init</TT></B>
+<UL><B><TT>c-foo --> see init</TT></B>
<BR>or
-<BR><B><TT>foo-instance --> class --> see init</TT></B> </UL>
+<BR><B><TT>foo-instance --> class --> see init</TT></B></UL>
Ficl also provides early binding, but you have to ask for it. Ficl's early
binding operator pops a class off the stack and compiles the method you've
named, so that that method executes regardless of the class of object it's
@@ -633,10 +795,11 @@
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 oo.fr:
-<UL><B><TT>: new \ ( class metaclass "name" -- )</TT></B>
-<BR><B><TT> metaclass => instance --> init ;</TT></B>
-<BR><B><TT>metaclass --> see new</TT></B> </UL>
+since all classes are instances of <TT>metaclass</TT>. Here's an example
+from oo.fr:
+<UL><B><TT>: new \ ( class metaclass "name" -- )</TT></B>
+<BR><B><TT> metaclass => instance --> init ;</TT></B>
+<BR><B><TT>metaclass --> see new</TT></B></UL>
Decompiling the method with <TT>SEE</TT> 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
@@ -646,7 +809,6 @@
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.
-
<P>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 <B>ref </B>from this class,
@@ -654,40 +816,37 @@
as a Ficl object, but its instance variables take on the values in the
existing structure. Example (from ficlclass.fr):
<BR>
-<UL><B><TT>object subclass c-wordlist \ OO model of FICL_HASH</TT></B>
-<BR><B><TT> cell: .parent</TT></B>
-<BR><B><TT> cell: .size</TT></B>
-<BR><B><TT> cell: .hash</TT></B>
-
-<P><B><TT> : push drop >search ;</TT></B>
-<BR><B><TT> : pop 2drop previous ;</TT></B>
-<BR><B><TT> : set-current drop set-current ;</TT></B>
-<BR><B><TT> : words --> push words previous ;</TT></B>
-<BR><B><TT>end-class</TT></B>
-
-<P><B><TT>: named-wid ( "name" -- ) </TT></B>
+<UL><B><TT>object subclass c-wordlist \ OO model of FICL_HASH</TT></B>
+<BR><B><TT> cell: .parent</TT></B>
+<BR><B><TT> cell: .size</TT></B>
+<BR><B><TT> cell: .hash</TT></B>
+<P><B><TT> : push drop >search ;</TT></B>
+<BR><B><TT> : pop 2drop previous ;</TT></B>
+<BR><B><TT> : set-current drop set-current ;</TT></B>
+<BR><B><TT> : words --> push words previous ;</TT></B>
+<BR><B><TT>end-class</TT></B>
+<P><B><TT>: named-wid ( "name" -- ) </TT></B>
<BR><B><TT> wordlist postpone c-wordlist
-metaclass => ref ;</TT></B> </UL>
+metaclass => ref ;</TT></B></UL>
In this case, <TT>c-wordlist</TT> describes Ficl's wordlist structure;
named-wid creates a wordlist and binds it to a ref instance of <TT>c-wordlist</TT>.
The fancy footwork with <TT>POSTPONE</TT> and early binding is required
because classes are immediate. An equivalent way to define named-wid with
late binding is:
-<UL><B><TT>: named-wid ( "name" -- )</TT></B>
+<UL><B><TT>: named-wid ( "name" -- )</TT></B>
<BR><B><TT> wordlist postpone c-wordlist
---> ref ;</TT></B> </UL>
+--> ref ;</TT></B></UL>
To do the same thing at run-time (and call it my-wordlist):
-<UL><B><TT>wordlist c-wordlist --> ref my-wordlist</TT></B> </UL>
+<UL><B><TT>wordlist c-wordlist --> ref my-wordlist</TT></B></UL>
Now you can deal with the wordlist through the ref instance:
-<UL><B><TT>my-wordlist --> push</TT></B>
-<BR><B><TT>my-wordlist --> set-current</TT></B>
-<BR><B><TT>order</TT></B> </UL>
+<UL><B><TT>my-wordlist --> push</TT></B>
+<BR><B><TT>my-wordlist --> set-current</TT></B>
+<BR><B><TT>order</TT></B></UL>
Ficl can also model linked lists and other structures that contain pointers
to structures of the same or different types. The class constructor word
-<B><TT><A HREF="#exampleref:">ref:</A></TT></B> makes an aggregate reference
-to a particular class. See the <A HREF="#glossinstance">instance variable
-glossary</A> for an <A HREF="#exampleref:">example</A>.
-
+<B><TT><A HREF="#exampleref:">ref:</A></TT></B>
+makes an aggregate reference to a particular class. See the <A HREF="#glossinstance">instance
+variable glossary</A> for an <A HREF="#exampleref:">example</A>.
<P>Ficl can make arrays of instances, and aggregate arrays into class descripions.
The <A HREF="#glossclass">class methods</A> <B><TT>array</TT></B> and <B><TT>new-array</TT></B>
create uninitialized and initialized arrays, respectively, of a class.
@@ -699,16 +858,91 @@
The objects are not automatically initialized in this case - your class
initializer has to call <B><TT>array-init</TT></B> explicitly if you want
this behavior.
-
<P>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.
+use examples. </TD>
+</TR>
+</TABLE>
+
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H3>
+<A NAME="oopgloss"></A>OOP Glossary</H3>
+These words provide method binding for all classes and instances. Also
+described are supporting words and execution factors. All are defined in
+softwords/oo.fr.
+<DL>
+<DT>
+<B><TT>--> ( instance class "method-name" -- xn )</TT></B></DT>
+
+<DD>
+Late binding: looks up and executes the given method in the context of
+the class on top of the stack. </DD>
+
+<DT>
+<B><TT>=> comp: ( class meta "method-name" -- ) exec:
+( inst class -- xn )</TT></B></DT>
+
+<DD>
+Early binding: compiles code to execute the method of the class specified
+at compile time.</DD>
+
+<DT>
+<B><TT>do-do-instance</TT></B></DT>
+
+<DD>
+Implementation factor of <B><TT>metaclass --> sub</TT></B>. Compiles <B><TT>.do-instance</TT></B>
+in the context of a class; <TT>.do-instance</TT> implements the <TT>does></TT>
+part of a named instance. When executed, causes the instance to push its
+( instance class ) stack signature.</DD>
+
+<DT>
+<B><TT>exec-method ( instance class c-addr u -- xn )</TT></B></DT>
+
+<DD>
+Given the address and length of a message (method name) on the stack, finds
+the method in the context of the specified class and invokes it. Upon entry
+to the method, the instance and class are on top of the stack, as usual.
+If unable to find the method, prints an error message and aborts.</DD>
+
+<DT>
+<B><TT>find-method-xt ( class "method-name" -- class xt )</TT></B></DT>
+
+<DD>
+Attempts to map the message to a method in the specified class. If successful,
+leaves the class and the execution token of the method on the stack. Otherwise
+prints an error message and aborts.</DD>
+
+<DT>
+<B><TT>lookup-method ( class c-addr u -- class xt )</TT></B></DT>
+
+<DD>
+Given the address and length of a message (method name) on the stack, finds
+the method in the context of the specified class. If unable to find the
+method, prints an error message and aborts.</DD>
+
+<DT>
+<B><TT>parse-method comp: ( "method-name" -- ) exec:
+( -- c-addr u )</TT></B></DT>
+
+<DD>
+Parse "name" from the input stream and compile code to push its length
+and address when the enclosing definition runs.</DD>
+</DL>
+</TD>
+</TR>
+</TABLE>
+
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
+<H3>
<A NAME="glossinstance"></A>Instance Variable Glossary</H3>
-Note: these words are only visible when creating a subclass! To create
-a subclass, use the <TT>sub</TT> method on <TT>object</TT> or any class
-derived from it (<I>not</I> <TT>metaclass</TT>). Source code for Ficl OOP
-is in ficl/softwords/oo.fr.
+<B>Note</B>: these words are only visible when creating a subclass! To
+create a subclass, use the <TT>sub</TT> method on <TT>object</TT> or any
+class derived from it (<I>not</I> <TT>metaclass</TT>). Source code for
+Ficl OOP is in ficl/softwords/oo.fr.
<DT>
Instance variable words do two things: they create methods that do an action
appropriate for the type of instance variable they represent, and they
@@ -726,12 +960,12 @@
<TT> cell:
.cell0</TT></DT>
-<BR><TT> c-4byte obj: .nCells</TT>
-<BR><TT> 4 c-4byte array: .quad</TT>
+<BR><TT> c-4byte obj: .nCells</TT>
+<BR><TT> 4 c-4byte array: .quad</TT>
<BR><TT> char:
-.length</TT>
+.length</TT>
<BR><TT> 79 chars:
-.name</TT>
+.name</TT>
<BR><TT>end-class</TT></UL>
This class only defines instance variables, and it inherits some methods
from <TT>object</TT>. Each untyped instance variable (.cell0, .length,
@@ -866,21 +1100,28 @@
<TT> c-fee ref: .fee</TT></DD>
<DD>
-<TT>end-class
-\ done with c-fie</TT></DD>
+<TT>end-class \ done with
+c-fie</TT></DD>
<DD>
<TT> c-fie ref: .fie</TT></DD>
-<DD>
-<TT>end-class
-\ done with c-fee</TT></DD>
+<BR><TT>end-class
+\ done with c-fee</TT></DL>
</DL>
-</DL>
+</TD>
+</TR>
+</TABLE>
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H3>
<A NAME="glossclass"></A>Class Methods Glossary</H3>
-
+These words are methods of <TT>metaclass</TT>. They define the manipulations
+that can be performed on classes. Methods include various kinds of instantiation,
+programming tools, and access to member variables of classes. Source is
+in softwords/oo.fr.
<DL>
<DT>
<B><TT>instance ( class metaclass "name" -- instance
@@ -1001,7 +1242,7 @@
<B><TT>get-wid</TT></B></DT>
<DD>
-<TT>Returns the wordlist ID of the class. Implemented as </TT></DD>
+Returns the wordlist ID of the class. Implemented as </DD>
<DD>
<TT>: get-wid metaclass => .wid @ ;</TT></DD>
@@ -1010,7 +1251,7 @@
<B><TT>get-super</TT></B></DT>
<DD>
-<TT>Returns the class's superclass. Implemented as</TT></DD>
+Returns the class's superclass. Implemented as</DD>
<DD>
<TT>: get-super metaclass => .super @ ;</TT></DD>
@@ -1051,14 +1292,20 @@
<B><TT>see ( class
metaclass "name" -- )</TT></B> </DT>
-<DD>
-Decompiles the specified method - obect version of <TT>SEE</TT>, from the
-<TT>TOOLS</TT> wordset.</DD>
-</DL>
+<BR>Decompiles the specified method - obect version of <TT>SEE</TT>, from
+the <TT>TOOLS</TT> wordset.</DL>
+</TD>
+</TR>
+</TABLE>
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H3>
<A NAME="objectgloss"></A><TT>object</TT> base-class Methods Glossary</H3>
-
+These are methods that are defined for all instances by the base class.
+The methods include default initialization, array manipulations, aliases
+of class methods, upcasting, and programming tools.
<DL>
<DT>
<B><TT>init ( instance
@@ -1066,8 +1313,9 @@
<DD>
Default initializer called automatically for all instances created with
-<TT>new</TT> or <TT>new-array</TT>. Zero-fills the instance. You do not
-normally need to invoke <TT>init</TT> explicitly.</DD>
+<TT>new</TT>
+or <TT>new-array</TT>. Zero-fills the instance. You do not normally need
+to invoke <TT>init</TT> explicitly.</DD>
<DT>
<B><TT>array-init ( nObj instance class -- )</TT></B> </DT>
@@ -1106,7 +1354,7 @@
<DD>
Returns the size, in address units, of one instance. Does not know about
-arrays! This is an alias for the class method <TT>.size</TT></DD>
+arrays! This is an alias for the class method <TT>get-size</TT></DD>
<DT>
<B><TT>methods ( instance class -- )</TT></B> </DT>
@@ -1152,11 +1400,15 @@
<B><TT>prev ( instance[n]
class -- instance[n-1] class )</TT></B> </DT>
-<DD>
-Convert an object signature into the signature of the previous object in
-the array. No check for bounds underflow.</DD>
-</DL>
+<BR>Convert an object signature into the signature of the previous object
+in the array. No check for bounds underflow.</DL>
+</TD>
+</TR>
+</TABLE>
+<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<TR>
+<TD>
<H3>
<A NAME="stockclasses"></A>Supplied Classes (See classes.fr)</H3>
@@ -1166,7 +1418,8 @@
<DD>
Describes all classes of Ficl. Contains class methods. Should never be
-directly instantiated or subclassed.</DD>
+directly instantiated or subclassed. Defined in oo.fr. Methods described
+above.</DD>
<DT>
<B><TT>object</TT> </B></DT>
@@ -1173,67 +1426,191 @@
<DD>
Mother of all Ficl objects. Defines default initialization and array indexing
-methods.</DD>
+methods. Defined in oo.fr. Methods described above.</DD>
<DT>
<B><TT>c-ref</TT> </B></DT>
<DD>
-Holds the signature of another object. Aggregate on of these into a data
-structure class to get polymorphism type stuff.</DD>
+Holds the signature of another object. Aggregate one of these into a data
+structure or container class to get polymorphic behavior. Methods &
+members: </DD>
+<DD>
+<TT>get ( inst class -- ref-inst ref-class )</TT></DD>
+
+<DD>
+<TT>set ( ref-inst ref-class inst class -- )</TT></DD>
+
+<DD>
+<TT>.instance ( inst class -- a-addr ) </TT>cell member that
+holds the instance</DD>
+
+<DD>
+<TT>.class ( inst class -- a-addr ) </TT>cell member that holds
+the class</DD>
+
<DT>
<B><TT>c-byte </TT></B></DT>
<DD>
-Primitive class with a 1-byte payload. Set and get methods perform correct-length
-fetch and store.</DD>
+Primitive class derived from <TT>object</TT>, with a 1-byte payload. Set
+and get methods perform correct width fetch and store. Methods & members:</DD>
+<DD>
+<TT>get ( inst class -- c )</TT></DD>
+
+<DD>
+<TT>set ( c inst class -- )</TT></DD>
+
+<DD>
+<TT>.payload ( inst class -- addr ) </TT>member holds instance's
+value</DD>
+
<DT>
<B><TT>c-2byte</TT></B> </DT>
<DD>
-Primitive class with a 2-byte payload. Set and get methods perform correct-length
-fetch and store.</DD>
+Primitive class derived from <TT>object</TT>, with a 2-byte payload. Set
+and get methods perform correct width fetch and store. Methods & members:</DD>
+<DD>
+<TT>get ( inst class -- 2byte )</TT></DD>
+
+<DD>
+<TT>set ( 2byte inst class -- )</TT></DD>
+
+<DD>
+<TT>.payload ( inst class -- addr ) </TT>member holds instance's
+value</DD>
+
<DT>
<B><TT>c-4byte</TT></B> </DT>
<DD>
-Primitive class with a 4-byte payload. Set and get methods perform correct-length
-fetch and store.</DD>
+Primitive class derived from <TT>object</TT>, with a 4-byte (cell) payload.
+Set and get methods perform correct width fetch and store. Methods &
+members:</DD>
+<DD>
+<TT>get ( inst class -- x )</TT></DD>
+
+<DD>
+<TT>set ( x inst class -- )</TT></DD>
+
+<DD>
+<TT>.payload ( inst class -- addr ) </TT>member holds instance's
+value</DD>
+
<DT>
-<B><TT>c-cellptr</TT></B></DT>
+<B><TT>c-ptr</TT></B></DT>
<DD>
-Models a pointer-to-cell.</DD>
+Base class derived from <TT>object</TT> for pointers to non-object types.
+This class is not complete by itself: several methods depend on a derived
+class definition of <TT>@size</TT>. Methods & members:</DD>
+<DD>
+<TT>.addr ( inst class -- a-addr )</TT> member variable - holds
+the pointer address</DD>
+
+<DD>
+<TT>get-ptr ( inst class -- ptr )</TT></DD>
+
+<DD>
+<TT>set-ptr ( ptr inst class -- )</TT></DD>
+
+<DD>
+<TT>inc-ptr ( inst class -- )</TT> Adds @size to pointer address</DD>
+
+<DD>
+<TT>dec-ptr ( inst class -- )</TT> Subtracts @size from pointer
+address</DD>
+
+<DD>
+<TT>index-ptr ( i inst class -- )</TT> Adds i*@size to pointer
+address</DD>
+
<DT>
+<B><TT>c-bytePtr</TT></B></DT>
+
+<DD>
+Pointer to byte derived from c-ptr. Methods & members:</DD>
+
+<DD>
+<TT>@size ( inst class -- size )</TT> Push size of the pointed-to
+thing</DD>
+
+<DD>
+<TT>get ( inst class -- c ) </TT>Fetch the pointer's
+referent byte</DD>
+
+<DD>
+<TT>set ( c inst class -- ) </TT>Store c at the pointer address</DD>
+
+<DT>
+<B><TT>c-2bytePtr</TT></B></DT>
+
+<DD>
+Pointer to double byte derived from c-ptr. Methods & members:</DD>
+
+<DD>
+<TT>@size ( inst class -- size )</TT> Push size of the pointed-to
+thing</DD>
+
+<DD>
+<TT>get ( inst class -- x ) </TT>Fetch the pointer's
+referent 2byte</DD>
+
+<DD>
+<TT>set ( x inst class -- )</TT> Store 2byte x at the pointer
+address</DD>
+
+<DT>
+<B><TT>c-cellPtr</TT></B></DT>
+
+<DD>
+Pointer to cell derived from c-ptr. Methods & members:</DD>
+
+<DD>
+<TT>@size ( inst class -- size )</TT> Push size of the pointed-to
+thing</DD>
+
+<DD>
+<TT>get ( inst class -- x ) </TT>Fetch the pointer's
+referent cell</DD>
+
+<DD>
+<TT>set ( x inst class -- )</TT> Storex at the pointer address</DD>
+
+<DT>
<B><TT>c-string</TT></B> </DT>
<DD>
-Models a counted string..</DD>
+Counted string (thin)</DD>
</DL>
- </TD>
+</TD>
</TR>
</TABLE>
<H2>
-<HR WIDTH="100%"><A NAME="extras"></A>Ficl extras</H2>
+<HR WIDTH="100%"></H2>
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
<TD>
<DL>
+<H2>
+<A NAME="extras"></A>Ficl extras</H2>
+
<H3>
Number syntax</H3>
You can precede a number with "0x", as in C, and it will be interpreted
as a hex value regardless of the value of <TT>BASE</TT>. Example:
-<DL><TT>ok> decimal 123 . cr</TT>
-<BR><TT>123 </TT>
-<BR><TT>ok> 0x123 . cr</TT>
+<DL><TT>ok> decimal 123 . cr</TT>
+<BR><TT>123 </TT>
+<BR><TT>ok> 0x123 . cr</TT>
<BR><TT>291 </TT></DL>
<H3>
@@ -1243,7 +1620,7 @@
line in ficlExec().
<BR>
<DT>
-<TT>>search ( wid -- )</TT></DT>
+<A NAME="tosearch"></A><TT>>search ( wid -- )</TT></DT>
<DD>
Push <TT>wid</TT> onto the search order. Many of the other search order
@@ -1251,18 +1628,67 @@
primitives.</DD>
<DT>
-<TT>search> ( -- wid )</TT></DT>
+<A NAME="searchfrom"></A><TT>search> ( -- wid )</TT></DT>
<DD>
Pop <TT>wid</TT> off the search order</DD>
<DT>
-<TT>ficl-set-current ( wid -- old-wid )</TT></DT>
+<A NAME="ficlsetcurrent"></A><TT>ficl-set-current ( wid --
+old-wid )</TT></DT>
<DD>
Set wid as compile wordlist, leave previous compile wordlist on stack</DD>
<DT>
+<A NAME="ficlvocabulary"></A><TT>ficl-vocabulary ( nBins "name"
+-- )</TT></DT>
+
+<DD>
+Creates a <TT>ficl-wordlist</TT> with the specified number of hash table
+bins, binds it to the name, and associates the semantics of <TT>vocabulary</TT>
+with it (replaces the top wid in the search order list with its own wid
+when executed)</DD>
+
+<DT>
+<A NAME="ficlwordlist"></A><TT>ficl-wordlist ( nBins -- wid
+)</TT></DT>
+
+<DD>
+Creates a <FONT FACE="">wordlist</FONT> with the specified number of hash
+table bins, and leaves the address of the wordlist on the stack. A <TT>ficl-wordlist</TT>
+behaves exactly as a regular wordlist, but it may search faster depending
+on the number of bins chosen and the number of words it contains at search
+time. As implemented in ficl, a <TT>wordlist</TT> is single threaded by
+default. </DD>
+
+<DT>
+<A NAME="ficlforgetwid"></A><TT>forget-wid ( wid -- )</TT></DT>
+
+<DD>
+Iterates through the specified wordlist and unlinks all definitions whose
+xt addresses are greater than or equal to the value of <TT>HERE</TT>, the
+dictionary fill pointer. </DD>
+
+<DT>
+<A NAME="ficlhide"></A><TT>hide ( -- current-wid-was )</TT></DT>
+
+<DD>
+Push the <TT>hidden</TT> wordlist onto the search order, and set it as
+the current compile wordlist (unsing <TT>ficl-set-current</TT>). Leaves
+the previous compile wordlist ID. I use this word to hide implementation
+factor words that have low reuse potential so that they don't clutter the
+default wordlist. To undo the effect of hide, execute <B><TT>previous
+set-current</TT></B></DD>
+
+<DT>
+<A NAME="ficlhidden"></A><TT>hidden ( -- wid )</TT></DT>
+
+<DD>
+Wordlist for storing implementation factors of ficl provided words. To
+see what's in there, try <B><TT>hide words previous set-current</TT></B></DD>
+
+<DT>
<TT>wid-set-super ( wid -- )</TT></DT>
<DD>
@@ -1393,6 +1819,94 @@
Pop and display the value in hex format, regardless of the current value
of <TT>BASE</TT></DD>
</DL>
+
+<H3>
+FiclWin Extras (defined in testmain.c)</H3>
+
+<DL>
+<DT>
+<TT>break ( -- )</TT></DT>
+
+<DD>
+Does nothing - just a handy place to set a debugger breakpoint</DD>
+
+<DT>
+<TT>cd ( "directory-name<newline>" --
+)</TT></DT>
+
+<DD>
+Executes the Win32 chdir() function, changing the program's logged directory.</DD>
+
+<DT>
+<A NAME="ficlload"></A><TT>load ( "filename<newline>"
+-- )</TT></DT>
+
+<DD>
+Opens the Forth source file specified and loads it one line at a time,
+like <TT>INCLUDED (FILE)</TT></DD>
+
+<DT>
+<TT>pwd ( -- )</TT></DT>
+
+<DD>
+Prints the current working directory as set by <TT>cd</TT></DD>
+
+<DT>
+<TT>system ( "command<newline>" -- )</TT></DT>
+
+<DD>
+Issues a command to a shell; implemented with the Win32 system() call.</DD>
+
+<DT>
+<TT>spewhash ( "filename<newline>" -- )</TT></DT>
+
+<DD>
+Dumps all threads of the current compilation wordlist to the specified
+text file. This was useful when I thought there might be some point in
+attempting to optimize the hash function. I no longer harbor those illusions.</DD>
+
+<H3>
+FiclWin Exclusives (no source provided)</H3>
+
+<DT>
+<TT>!oreg ( c -- )</TT></DT>
+
+<DD>
+Set the value of the simulated LED register as specified (0..255)</DD>
+
+<DT>
+<TT>@ireg ( -- c )</TT></DT>
+
+<DD>
+Gets the value of the simulated switch block (0..255)</DD>
+
+<DT>
+<TT>!dac ( c -- )</TT></DT>
+
+<DD>
+Sets the value of the bargraph control as specified. Valid values range
+from 0..255</DD>
+
+<DT>
+<TT>@adc ( -- c )</TT></DT>
+
+<DD>
+Fetches the current position of the slider control. Range is 0..255</DD>
+
+<DT>
+<TT>status" ( "ccc<quote>" -- )</TT></DT>
+
+<DD>
+Set the mainframe window's status line to the text specified, up to the
+first trailing quote character.</DD>
+
+<DT>
+<TT>msec ( u -- )</TT></DT>
+
+<DD>
+Causes the running virtual machine to sleep() for the number of milliseconds
+specified by the top-of-stack value.</DD>
+</DL>
</TD>
</TR>
</TABLE>
@@ -1403,14 +1917,14 @@
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
-<TD><B>ANS Forth System</B>
-<BR><B>Providing names from the Core Extensions word set </B>
-<BR><B>Providing the Locals word set </B>
-<BR><B>Providing the Locals Extensions word set </B>
-<BR><B>Providing the Programming-Tools word set</B>
-<BR><B>Providing names from the Programming-Tools Extensions word set</B>
-<BR><B>Providing the Search-Order word set</B>
-<BR><B>Providing the Search-Order Extensions word set </B>
+<TD><B>ANS Forth System</B>
+<BR><B>Providing names from the Core Extensions word set </B>
+<BR><B>Providing the Locals word set </B>
+<BR><B>Providing the Locals Extensions word set </B>
+<BR><B>Providing the Programming-Tools word set</B>
+<BR><B>Providing names from the Programming-Tools Extensions word set</B>
+<BR><B>Providing the Search-Order word set</B>
+<BR><B>Providing the Search-Order Extensions word set</B>
<H3>
Implementation-defined Options</H3>
The implementation-defined items in the following list represent characteristics
@@ -1426,28 +1940,28 @@
The default value is set to 2 in sysdep.h. This causes dictionary entries
and <TT>ALIGN</TT> and <TT>ALIGNED</TT> to align on 4 byte boundaries.
To align on <B>2<SUP><FONT FACE="">n</FONT></SUP></B> byte boundaries,
-set FICL_ALIGN to <B>n</B>. </FONT>
+set FICL_ALIGN to <B>n</B>. </FONT>
<LI>
<B>behavior of 6.1.1320 EMIT for non-graphic characters</B>; </LI>
<BR><FONT COLOR="#000000">Depends on target system, C runtime library,
-and your implementation of ficlTextOut().</FONT>
+and your implementation of ficlTextOut().</FONT>
<LI>
<B>character editing of 6.1.0695 ACCEPT and 6.2.1390 EXPECT</B>; </LI>
<BR><FONT COLOR="#000000">None implemented in the versions supplied in
words.c. Because ficlExec() is supplied a text buffer externally, it's
-up to your system to define how that buffer will be obtained.</FONT>
+up to your system to define how that buffer will be obtained.</FONT>
<LI>
<B>character set (3.1.2 Character types, 6.1.1320 EMIT, 6.1.1750 KEY)</B>; </LI>
<BR><FONT COLOR="#000000">Depends on target system and implementation of
-ficlTextOut()</FONT>
+ficlTextOut()</FONT>
<LI>
<B>character-aligned address requirements (3.1.3.3 Addresses)</B>; </LI>
<BR><FONT COLOR="#000000">Ficl characters are one byte each. There are
-no alignment requirements.</FONT>
+no alignment requirements.</FONT>
<LI>
<B>character-set-extensions matching characteristics (3.4.2 Finding definition
n<FONT COLOR="#000000">ames)</FONT></B><FONT COLOR="#000000">; </FONT></LI>
@@ -1454,17 +1968,17 @@
<BR><FONT COLOR="#000000">No special processing is performed on characters
beyond case-folding. Therefore, extended characters will not match their
-unaccented counterparts.</FONT>
+unaccented counterparts.</FONT>
<LI>
<B>conditions under which control characters match a space delimiter (3.4.1.1
Delimiters)</B>;<FONT COLOR="#FF6666"> </FONT></LI>
<BR><FONT COLOR="#000000">Ficl uses the Standard C function isspace() to
-distinguish space characters. The rest is up to your library vendor.</FONT>
+distinguish space characters. The rest is up to your library vendor.</FONT>
<LI>
<B>format of the control-flow stack (3.2.3.2 Control-flow stack)</B>; </LI>
-<BR><FONT COLOR="#000000">Uses the data stack</FONT>
+<BR><FONT COLOR="#000000">Uses the data stack</FONT>
<LI>
<B>conversion of digits larger than thirty-five (3.2.1.2 Digit conversion)</B>; </LI>
@@ -1475,21 +1989,21 @@
<LI>
<B>display after input terminates in 6.1.0695 ACCEPT and 6.2.1390 EXPECT</B>; </LI>
-<BR><FONT COLOR="#000000">Target system dependent</FONT>
+<BR><FONT COLOR="#000000">Target system dependent</FONT>
<LI>
<B>exception abort sequence (as in 6.1.0680 ABORT")</B>; </LI>
-<BR><FONT COLOR="#000000">Does <TT>ABORT</TT></FONT>
+<BR><FONT COLOR="#000000">Does <TT>ABORT</TT></FONT>
<LI>
<B>input line terminator (3.2.4.1 User input device)</B>;<FONT COLOR="#FF0000"> </FONT></LI>
<BR><FONT COLOR="#000000">Target system dependent (implementation of outer
-loop that calls ficlExec)</FONT>
+loop that calls ficlExec)</FONT>
<LI>
<B>maximum size of a counted string, in characters (3.1.3.4 Counted strings,
6.1.2450 WORD)</B>; </LI>
-<BR><FONT COLOR="#000000">255</FONT>
+<BR><FONT COLOR="#000000">255</FONT>
<LI>
<B>maximum size of a parsed string (3.4.1 Parsing)</B>; </LI>
@@ -1500,11 +2014,11 @@
names)</B>; </LI>
<BR><FONT COLOR="#000000">Ficl stores the first 31 characters of a definition
-name.</FONT>
+name.</FONT>
<LI>
<B>maximum string length for 6.1.1345 ENVIRONMENT?, in characters</B>; </LI>
-<BR><FONT COLOR="#000000">Same as maximum definition name length</FONT>
+<BR><FONT COLOR="#000000">Same as maximum definition name length</FONT>
<LI>
<B>method of selecting 3.2.4.1 User input device</B>; </LI>
@@ -1521,7 +2035,7 @@
<BR><FONT COLOR="#000000">Target system dependent. Ficl generally supports
processors that can address 8 bit quantities, but there is no dependency
-that I'm aware of.</FONT>
+that I'm aware of.</FONT>
<LI>
<B>number representation and arithmetic (3.2.1.1 Internal number representation)</B>; </LI>
@@ -1547,16 +2061,16 @@
<LI>
<B>size of one cell in address units (3.1.3 Single-cell types)</B>; </LI>
-<BR><FONT COLOR="#000000">System dependent, generally four.</FONT>
+<BR><FONT COLOR="#000000">System dependent, generally four.</FONT>
<LI>
<B>size of one character in address units (3.1.2 Character types)</B>; </LI>
-<BR><FONT COLOR="#000000">System dependent, generally one.</FONT>
+<BR><FONT COLOR="#000000">System dependent, generally one.</FONT>
<LI>
<B>size of the keyboard terminal input buffer (3.3.3.5 Input buffers)</B>; </LI>
<BR><FONT COLOR="#000000">This buffer is supplied by the host program.
-Ficl imposes no practical limit.</FONT>
+Ficl imposes no practical limit.</FONT>
<LI>
<B>size of the pictured numeric output string buffer (3.3.3.6 Other transient
regions)</B>; </LI>
@@ -1570,20 +2084,20 @@
<LI>
<B>system case-sensitivity characteristics (3.4.2 Finding definition names)</B>; </LI>
-<BR><FONT COLOR="#000000">Ficl is not case sensitive</FONT>
+<BR><FONT COLOR="#000000">Ficl is not case sensitive</FONT>
<LI>
<B>system prompt (3.4 The Forth text interpreter, 6.1.2050 QUIT)</B>; </LI>
-<BR><FONT COLOR="#000000">"ok>"</FONT>
+<BR><FONT COLOR="#000000">"ok>"</FONT>
<LI>
<B>type of division rounding (3.2.2.1 Integer division, 6.1.0100 */, 6.1.0110
*/MOD, 6.1.0230 /, 6.1.0240 /MOD, 6.1.1890 MOD)</B>; </LI>
-<BR><FONT COLOR="#000000">Symmetric</FONT>
+<BR><FONT COLOR="#000000">Symmetric</FONT>
<LI>
<B>values of 6.1.2250 STATE when true</B>; </LI>
-<BR><FONT COLOR="#000000">One (no others)</FONT>
+<BR><FONT COLOR="#000000">One (no others)</FONT>
<LI>
<B>values returned after arithmetic overflow (3.2.2.2 Other integer operations)</B>; </LI>
@@ -1600,7 +2114,6 @@
A system shall document the system action taken upon each of the general
or specific ambiguous conditions identified in this Standard. See 3.4.4
Possible actions on an ambiguous condition.
-
<P>The following general ambiguous conditions could occur because of a
combination of factors:
<UL>
@@ -1610,7 +2123,7 @@
text interpretation (3.4 The Forth text interpreter)</B>; </LI>
<BR><FONT COLOR="#000000">Ficl does <TT>ABORT</TT> and prints the name
-followed by " not found".</FONT>
+followed by " not found".</FONT>
<LI>
<B>a definition name exceeded the maximum length allowed (3.3.1.2 Definition
names)</B>; </LI>
@@ -1618,12 +2131,12 @@
<BR><FONT COLOR="#000000">Ficl stores the first 31 characters of the definition
name, and uses all characters of the name in computing its hash code. The
actual length of the name, up to 255 characters, is stored in the definition's
-length field.</FONT>
+length field.</FONT>
<LI>
<B>addressing a region not listed in 3.3.3 Data Space</B>; </LI>
<BR><FONT COLOR="#000000">No problem: all addresses in ficl are absolute.
-You can reach any 32 bit address in Ficl's address space.</FONT>
+You can reach any 32 bit address in Ficl's address space.</FONT>
<LI>
<B>argument type incompatible with specified input parameter, e.g., passing
a flag to a word expecting an n (3.1 Data types)</B>; </LI>
@@ -1637,7 +2150,7 @@
FIND, etc.) of a definition with undefined interpretation semantics</B>; </LI>
<BR><FONT COLOR="#000000">Ficl returns a valid token, but the result of
-executing that token while interpreting may be undesirable.</FONT>
+executing that token while interpreting may be undesirable.</FONT>
<LI>
<B>dividing by zero (6.1.0100 */, 6.1.0110 */MOD, 6.1.0230 /, 6.1.0240
/MOD, 6.1.1561 FM/MOD, 6.1.1890 MOD, 6.1.2214 SM/REM, 6.1.2370 UM/MOD,
@@ -1645,17 +2158,17 @@
<BR><FONT COLOR="#000000">Results are target procesor dependent. Generally,
Ficl makes no check for divide-by-zero. The target processor will probably
-throw an exception.</FONT>
+throw an exception.</FONT>
<LI>
<B>insufficient data-stack space or return-stack space (stack overflow)</B>; </LI>
<BR><FONT COLOR="#000000">With FICL_ROBUST (sysdep.h) set >= 2, most parameter
stack operations are checked for underflow and overflow. Ficl does not
-check the return stack.</FONT>
+check the return stack.</FONT>
<LI>
<B>insufficient space for loop-control parameters</B>; </LI>
-<BR><FONT COLOR="#000000">No check - Evil results.</FONT>
+<BR><FONT COLOR="#000000">No check - Evil results.</FONT>
<LI>
<B>insufficient space in the dictionary</B>; </LI>
@@ -1662,7 +2175,7 @@
<BR><FONT COLOR="#000000">Ficl generates an error message if the dictionary
is too full to create a definition header. It checks <TT>ALLOT</TT> as
well, but it is possible to make an unchecked allocation request that overflows
-the dictionary.</FONT>
+the dictionary.</FONT>
<LI>
<B>interpreting a word with undefined interpretation semantics</B>; </LI>
@@ -1669,7 +2182,7 @@
<BR><FONT COLOR="#000000">Ficl protects all ANS Forth words with undefined
interpretation semantics from being executed while in interpret state.
It is possible to defeat this protection using ' (tick) and <TT>EXECUTE</TT>,
-though.</FONT>
+though.</FONT>
<LI>
<B>modifying the contents of the input buffer or a string literal (3.3.3.4
Text-literal regions, 3.3.3.5 Input buffers)</B>; </LI>
@@ -1677,7 +2190,7 @@
<BR><FONT COLOR="#000000">Varies depending on the nature of the buffer.
The input buffer is supplied by ficl's host function, and may reside in
read-only memory. If so, writing the input buffer can ganerate an exception.
-String literals are stored in the dictionary, and are writable.</FONT>
+String literals are stored in the dictionary, and are writable.</FONT>
<LI>
<B>overflow of a pictured numeric output string</B>;</LI>
@@ -1700,13 +2213,13 @@
*, 6.1.0100 */, 6.1.0110 */MOD, 6.1.0570 >NUMBER, 6.1.1561 FM/MOD, 6.1.2214
SM/REM, 6.1.2370 UM/MOD, 6.2.0970 CONVERT, 8.6.1.1820 M*/)</B>; </LI>
-<BR><FONT COLOR="#000000">Value will be truncated</FONT>
+<BR><FONT COLOR="#000000">Value will be truncated</FONT>
<LI>
<B>reading from an empty data stack or return stack (stack underflow)</B>; </LI>
<BR><FONT COLOR="#000000">Most stack underflows are detected and prevented
if FICL_ROBUST (sysdep.h) is set to 2 or greater. Otherwise, the stack
-pointer and size are likely to be trashed.</FONT>
+pointer and size are likely to be trashed.</FONT>
<LI>
<B>unexpected end of input buffer, resulting in an attempt to use a zero-length
string as a name</B>; </LI>
@@ -1724,7 +2237,7 @@
<LI>
<B>6.1.2120 RECURSE appears after 6.1.1250 DOES></B></LI>
-<BR>It finds the address of the definition before <TT>DOES></TT>
+<BR>It finds the address of the definition before <TT>DOES></TT>
<LI>
<B>argument input source different than current input source for 6.2.2148
RESTORE-INPUT</B></LI>
@@ -1767,12 +2280,13 @@
<B>name not defined by 6.2.2405 VALUE used by 6.2.2295 TO</B></LI>
<BR>Ficl's version of <TT>TO</TT> works correctly with <TT>VALUE</TT>s,
-<TT>CONSTANT</TT>s and <TT>VARIABLE</TT>s.
+<TT>CONSTANT</TT>s
+and <TT>VARIABLE</TT>s.
<LI>
<B>name not found (6.1.0070 ', 6.1.2033 POSTPONE, 6.1.2510 ['], 6.2.2530
[COMPILE])</B></LI>
-<BR>Ficl prints an error message and does <TT>ABORT</TT>
+<BR>Ficl prints an error message and does <TT>ABORT</TT>
<LI>
<B>parameters are not of the same type (6.1.1240 DO, 6.2.0620 ?DO, 6.2.2440
WITHIN)</B></LI>
@@ -1798,7 +2312,7 @@
<B>word not defined via 6.1.1000 CREATE (6.1.0550 >BODY, 6.1.1250 DOES>)</B></LI>
<BR><B>words improperly used outside 6.1.0490 <# and 6.1.0040 #> (6.1.0030
-#, 6.1.0050 #S, 6.1.1670 HOLD, 6.1.2210 SIGN)</B>
+#, 6.1.0050 #S, 6.1.1670 HOLD, 6.1.2210 SIGN)</B>
<BR>Don't. <TT>CREATE</TT> reserves a field in words it builds for <TT>DOES></TT>
to fill in. If you use <TT>DOES></TT> on a word not made by <TT>CREATE</TT>,
it will overwrite the first cell of its parameter area. That's probably
@@ -1854,7 +2368,7 @@
names, 16.6.1.2197 SET-ORDER)</B> </LI>
<BR>Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS, declared
-in sysdep.h
+in sysdep.h
<LI>
<B>minimum search order (16.6.1.2197 SET-ORDER, 16.6.2.1965 ONLY)</B> </LI>
@@ -1882,8 +2396,7 @@
<BR>Ficl prints an error message if the search order overflows, and resets
the order to its default state.</UL>
-
-<BR> </TD>
+ </TD>
</TR>
</TABLE>
@@ -1893,7 +2406,7 @@
<UL>
<LI>
-<A HREF="http://www.taygeta.com/forth/compilers">Web home of ficl</A></LI>
+<A HREF="http://www.taygeta.com/forthcomp.html">Web home of ficl</A></LI>
<LI>
<A HREF="http://www.taygeta.com/forthlit.html">Forth literature</A></LI>
@@ -1909,11 +2422,11 @@
</UL>
<LI>
-<A HREF="http://www.fig.org">Forth Interest Group</A></LI>
+<A HREF="http://www.forth.org">Forth Interest Group</A></LI>
<LI>
-<A HREF="ftp://ftp.taygeta.com/pub/Forth/Compilers/native/misc/ficl200.zip">Download
-ficl 2.0</A></LI>
+<A HREF="ftp://ftp.taygeta.com/pub/Forth/Compilers/native/misc/ficl202/ficl202.zip">Download
+ficl 2.02</A></LI>
</UL>
<H2>
@@ -1920,14 +2433,13 @@
<HR WIDTH="100%"></H2>
-<H2>
-<A NAME="lawyerbait"></A>DISCLAIMER OF WARRANTY and LICENSE</H2>
-
<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<TR>
-<TD><I>Ficl is freeware. Use it in any way that you like, with the understanding
-that the code is not supported.</I>
-
+<TD>
+<H2>
+<A NAME="lawyerbait"></A>DISCLAIMER OF WARRANTY and LICENSE</H2>
+<I>Ficl is freeware. Use it in any way that you like, with the understanding
+that the code is not supported.</I>
<P>Any third party may reproduce, distribute, or modify the ficl software
code or any derivative works thereof without any compensation or license,
provided that the original author information and this disclaimer text
@@ -1935,7 +2447,6 @@
on an "as is" basis without warranty of any kind, including, without limitation,
the implied warranties of merchantability and fitness for a particular
purpose and their equivalents under the laws of any jurisdiction.
-
<P>I am interested in hearing from anyone who uses ficl. If you have a
problem, a success story, a defect, an enhancement request, or if you would
like to contribute to the ficl release (yay!), please send me email at
@@ -1942,6 +2453,6 @@
the address above. </TD>
</TR>
</TABLE>
-
+
</BODY>
</HTML>
--- a/ficl.c
+++ b/ficl.c
@@ -217,7 +217,7 @@
break;
case VM_OUTOFTEXT:
- if ((pVM->state != COMPILE) && (pVM->sourceID == 0))
+ if ((pVM->state != COMPILE) && (pVM->sourceID.i == 0))
ficlTextOut(pVM, FICL_PROMPT, 0);
break;
@@ -235,11 +235,11 @@
if (pVM->state == COMPILE)
{dictAbortDefinition(dp);
- dictResetSearchOrder(dp);
#if FICL_WANT_LOCALS
dictEmpty(localp, localp->pForthWords->size);
#endif
}
+ dictResetSearchOrder(dp);
vmReset(pVM);
break;
}
--- a/ficl.h
+++ b/ficl.h
@@ -9,7 +9,8 @@
** N O T I C E -- DISCLAIMER OF WARRANTY
**
** Ficl is freeware. Use it in any way that you like, with
-** the understanding that the code is not supported.
+** the understanding that the code is supported on a "best effort"
+** basis only.
**
** Any third party may reproduce, distribute, or modify the ficl
** software code or any derivative works thereof without any
@@ -205,7 +206,7 @@
/*
** the Good Stuff starts here...
*/
-#define FICL_VER "2.00"
+#define FICL_VER "2.02"
#define FICL_PROMPT "ok> "
/*
@@ -404,7 +405,7 @@
UNS32 base; /* number conversion base */
FICL_STACK *pStack; /* param stack */
FICL_STACK *rStack; /* return stack */
- INT32 sourceID; /* -1 if string, 0 if normal input */
+ CELL sourceID; /* -1 if string, 0 if normal input */
TIB tib; /* address of incoming text string */
#if FICL_WANT_USER
CELL user[FICL_USER_CELLS];
@@ -558,12 +559,13 @@
FICL_WORD *table[1];
} FICL_HASH;
+void hashForget(FICL_HASH *pHash, void *where);
UNS16 hashHashCode(STRINGINFO si);
-void hashReset(FICL_HASH *pHash);
void hashInsertWord(FICL_HASH *pHash, FICL_WORD *pFW);
FICL_WORD *hashLookup(struct ficl_hash *pHash,
STRINGINFO si,
UNS16 hashCode);
+void hashReset(FICL_HASH *pHash);
/*
** A Dictionary is a linked list of FICL_WORDs. It is also Ficl's
--- a/softwords/ficlclass.fr
+++ b/softwords/ficlclass.fr
@@ -72,3 +72,29 @@
: top
--> .sp --> .addr --> prev --> get ;
end-class
+
+
+\ ** C - S T R I N G
+\ counted string, size set at creation time (if by NEW)
+\ Can also be ref instantiated to wrap an existing string
+\ No check for bounds overrun...
+\
+object subclass c-string
+ c-byte obj: .count
+ char: .text
+
+ : type ( inst class -- )
+ 2dup --> .text
+ -rot --> .count --> get
+ type ;
+
+ : init ( size inst class -- )
+ rot allot object => init ;
+
+ : set ( c-addr u inst class )
+ locals| class inst |
+ dup
+ inst class --> .count --> set
+ inst class --> .text swap move ;
+
+end-class
--- a/softwords/oo.fr
+++ b/softwords/oo.fr
@@ -3,7 +3,7 @@
\ ** john sadler aug 1998
.( loading ficl O-O extensions ) cr
-vocabulary oop
+7 ficl-vocabulary oop
also oop definitions
\ Design goals:
@@ -68,7 +68,9 @@
2 pick cell+ @ ( -- class c-addr u wid )
search-wordlist ( -- class 0 | xt 1 | xt -1 )
0= if
- ." Method <" c-addr u type ." > not found" cr abort
+ c-addr u type ." not found in "
+ body> >name type
+ cr abort
endif
;
@@ -105,7 +107,7 @@
\ my-class get-wid ( -- wid-of-my-class )
\
: => \ c:( class meta -- ) run: ( -- ??? ) invokes compiled method
- drop find-method-xt , drop
+ drop find-method-xt compile, drop
; immediate compile-only
@@ -215,8 +217,9 @@
\ the wordlist of every class by the SUB method.
\ PRECONDITION: current-class contains the class address
\
-: do-do-instance \ c:( -- ) r: ( -- )
- s" : .do-instance does> [ current-class @ ] literal ;" evaluate
+: do-do-instance ( -- )
+ s" : .do-instance does> [ current-class @ ] literal ;"
+ evaluate
;
\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
@@ -227,7 +230,7 @@
\ Classes are IMMEDIATE to make early binding simpler
\ See above...
\
-: meta-class
+:noname
wordlist
create immediate
0 , \ NULL parent class
@@ -235,10 +238,8 @@
3 cells , \ instance size
ficl-set-current
does> dup
-;
+; execute metaclass
-meta-class metaclass
-
metaclass drop current-class !
do-do-instance
@@ -269,7 +270,7 @@
locals| meta parent |
create
here parent --> .do-instance \ ( inst class )
- parent meta --> get-size
+ parent meta metaclass => get-size
allot \ allocate payload space
;
@@ -278,7 +279,7 @@
locals| meta parent nobj |
create nobj
here parent --> .do-instance \ ( nobj inst class )
- parent meta --> get-size
+ parent meta metaclass => get-size
nobj * allot \ allocate payload space
;
@@ -290,7 +291,7 @@
\ create an initialized array of instances
: new-array ( n class metaclass "name" -- )
- --> array
+ metaclass => array
--> array-init
;
@@ -312,7 +313,7 @@
wid , \ save wid
here parent meta --> get-size dup , ( addr[size] size )
metaclass => .do-instance
- wid ficl-set-current rot rot
+ wid ficl-set-current -rot
do-do-instance
instance-vars >search \ push struct builder wordlist
;
@@ -351,11 +352,14 @@
\ decompile a method
: see ( class meta -- )
- --> get-wid >search see previous ;
+ metaclass => get-wid >search see previous ;
set-current
\ E N D M E T A C L A S S
+\ META is a nickname for the address of METACLASS...
+metaclass drop
+constant meta
\ SUBCLASS is a nickname for a class's SUB method...
\ Subclass compilation ends when you invoke end-class
@@ -366,7 +370,7 @@
\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
\ ** O B J E C T
\ Root of all classes
-: root-class
+:noname
wordlist
create immediate
0 , \ NULL parent class
@@ -373,19 +377,23 @@
dup , \ wid
0 , \ instance size
ficl-set-current
- does> [ metaclass drop ] literal
-;
+ does> meta
+; execute object
-root-class object
-
object drop current-class !
do-do-instance
\ O B J E C T M E T H O D S
+\ Convert instance cell-pair to class cell-pair
+\ Useful for binding class methods from an instance
+: class ( instance class -- class metaclass )
+ nip meta ;
+
\ default INIT method zero fills an instance
: init ( instance class -- )
- over swap ( inst inst class )
- --> size 0 fill ;
+ meta
+ metaclass => get-size ( inst size )
+ erase ;
\ Apply INIT to an array of NOBJ objects...
\
@@ -404,24 +412,22 @@
loop
;
-\ Convert object cell-pair to class cell-pair
-: class ( instance class -- class metaclass )
- nip [ metaclass nip ] literal
-;
-
\ Instance aliases for common class methods
\ Upcast to parent class
: super ( instance class -- instance parent-class )
- dup --> class --> get-super ;
+ meta metaclass => get-super ;
: pedigree ( instance class -- )
- --> class --> pedigree ;
+ object => class
+ metaclass => pedigree ;
: size ( instance class -- sizeof-instance )
- --> class --> get-size ;
+ object => class
+ metaclass => get-size ;
: methods ( instance class -- )
- --> class --> methods ;
+ object => class
+ metaclass => methods ;
\ Array indexing methods...
\ Usage examples:
@@ -430,13 +436,15 @@
\
: index ( n instance class -- instance[n] class )
locals| class inst |
- inst class --> class
+ inst class
+ object => class
metaclass => get-size * ( n*size )
inst + class ;
: next ( instance[n] class -- instance[n+1] class )
locals| class inst |
- inst class --> class
+ inst class
+ object => class
metaclass => get-size
inst +
class ;
@@ -443,7 +451,8 @@
: prev ( instance[n] class -- instance[n-1] class )
locals| class inst |
- inst class --> class
+ inst class
+ object => class
metaclass => get-size
inst swap -
class ;
@@ -452,3 +461,4 @@
\ E N D O B J E C T
+previous definitions
--- a/softwords/softcore.fr
+++ b/softwords/softcore.fr
@@ -1,8 +1,25 @@
-\ ** softcore.fr
+\ ** ficl/softwords/softcore.fr
\ ** FICL soft extensions
\ ** John Sadler (john_sadler@alum.mit.edu)
\ ** September, 1998
+\ ** Ficl USER variables
+\ ** See words.c for primitive def'n of USER
+\ #if FICL_WANT_USER
+
+variable nUser 0 nUser !
+: user \ name ( -- )
+ nUser dup @ user 1 swap +! ;
+
+\ #endif
+
+\ ** ficl extras
+\ EMPTY cleans the parameter stack
+: empty ( xn..x1 -- ) depth 0 ?do drop loop ;
+\ CELL- undoes CELL+
+: cell- ( addr -- addr ) [ 1 cells ] literal - ;
+: -rot ( a b c -- c a b ) 2 -roll ;
+
\ ** CORE
: abs ( x -- x )
dup 0< if negate endif ;
@@ -59,8 +76,11 @@
loop drop
;
-\ ** SEARCH EXT words and ficl helpers
+\ ** SEARCH+EXT words and ficl helpers
\
+: wordlist ( -- )
+ 1 ficl-wordlist ;
+
\ DO_VOCABULARY handles the DOES> part of a VOCABULARY
\ When executed, new voc replaces top of search stack
: do-vocabulary ( -- )
@@ -69,6 +89,9 @@
: vocabulary ( name -- )
wordlist create , do-vocabulary ;
+: ficl-vocabulary ( nBuckets name -- )
+ ficl-wordlist create , do-vocabulary ;
+
\ ALSO dups the search stack...
: also ( -- )
search> dup >search >search ;
@@ -95,23 +118,8 @@
: ficl-set-current ( wid -- old-wid )
get-current swap set-current ;
-
-\ ** Ficl USER variables
-\ ** See words.c for primitive def'n of USER
-\ #if FICL_WANT_USER
-
-variable nUser 0 nUser !
-: user \ name ( -- )
- nUser dup @ user 1 swap +! ;
-
-\ #endif
-
-\ ** ficl extras
-\ EMPTY cleans the parameter stack
-: empty ( xn..x1 -- ) depth 0 ?do drop loop ;
-\ CELL- undoes CELL+
-: cell- ( addr -- addr ) [ 1 cells ] literal - ;
-: -rot ( a b c -- c a b ) 2 -roll ;
+wordlist constant hidden
+: hide hidden dup >search ficl-set-current ;
\ ** E N D S O F T C O R E . F R
--- a/testmain.c
+++ b/testmain.c
@@ -260,9 +260,9 @@
FICL_VM *pVM;
ficlInitSystem(10000);
+ buildTestInterface();
pVM = ficlNewVM();
- buildTestInterface();
ficlExec(pVM, ".ver .( " __DATE__ " ) cr quit");
/*
--- a/vm.c
+++ b/vm.c
@@ -300,7 +300,7 @@
pVM->tib.cp = NULL;
pVM->tib.index = 0;
pVM->pad[0] = '\0';
- pVM->sourceID = 0;
+ pVM->sourceID.i = 0;
return;
}
--- a/words.c
+++ b/words.c
@@ -1317,6 +1317,9 @@
{for (wp = pHash->table[i]; wp != NULL; wp = wp->link, nWords++)
{+ if (wp->nName == 0) /* ignore :noname defs */
+ continue;
+
cp = wp->name;
nChars += sprintf(pPad + nChars, "%s", cp);
@@ -1958,7 +1961,12 @@
static void execute(FICL_VM *pVM)
{- FICL_WORD *pFW = stackPopPtr(pVM->pStack);
+ FICL_WORD *pFW;
+#if FICL_ROBUST > 1
+ vmCheckStack(pVM, 1, 0);
+#endif
+
+ pFW = stackPopPtr(pVM->pStack);
vmExecute(pVM, pFW);
return;
@@ -2662,11 +2670,11 @@
{UNS32 count = stackPopUNS32(pVM->pStack);
char *cp = stackPopPtr(pVM->pStack);
- UNS32 id;
+ CELL id;
IGNORE(count);
id = pVM->sourceID;
- pVM->sourceID = -1;
+ pVM->sourceID.i = -1;
vmPushIP(pVM, &pInterpret);
ficlExec(pVM, cp);
vmPopIP(pVM);
@@ -3326,19 +3334,30 @@
** lists or may be dynamically allocated in data space. A system shall
** allow the creation of at least 8 new word lists in addition to any
** provided as part of the system.
-** Note: ficl creates a new single-list hash in the dictionary and returns
-** its address.
+** Notes:
+** 1. ficl creates a new single-list hash in the dictionary and returns
+** its address.
+** 2. ficl-wordlist takes an arg off the stack indicating the number of
+** hash entries in the wordlist. Ficl 2.02 and later define WORDLIST as
+** : wordlist 1 ficl-wordlist ;
**************************************************************************/
static void wordlist(FICL_VM *pVM)
{FICL_DICT *dp = ficlGetDict();
FICL_HASH *pHash;
+ UNS32 nBuckets;
+
+#if FICL_ROBUST > 1
+ vmCheckStack(pVM, 1, 1);
+#endif
+ nBuckets = stackPopUNS32(pVM->pStack);
dictAlign(dp);
pHash = (FICL_HASH *)dp->here;
- dictAllot(dp, sizeof (FICL_HASH));
+ dictAllot(dp, sizeof (FICL_HASH)
+ + (nBuckets-1) * sizeof (FICL_WORD *));
- pHash->size = 1;
+ pHash->size = nBuckets;
hashReset(pHash);
stackPushPtr(pVM->pStack, pHash);
@@ -3404,9 +3423,9 @@
SI_SETPTR(si, NULL);
pVM->state = COMPILE;
- markControlTag(pVM, colonTag);
pFW = dictAppendWord2(dp, si, colonParen, FW_DEFAULT | FW_SMUDGE);
stackPushPtr(pVM->pStack, pFW);
+ markControlTag(pVM, colonTag);
return;
}
@@ -3641,6 +3660,7 @@
**************************************************************************/
static void localParen(FICL_VM *pVM)
{+ static CELL *pMark = NULL;
FICL_DICT *pDict = ficlGetDict();
STRINGINFO si;
SI_SETLEN(si, stackPopUNS32(pVM->pStack));
@@ -3660,7 +3680,8 @@
if (nLocals == 0)
{ /* compile code to create a local stack frame */dictAppendCell(pDict, LVALUEtoCELL(pLinkParen));
- stackPushPtr(pVM->pStack, pDict->here);
+ /* save location in dictionary for #locals */
+ pMark = pDict->here;
dictAppendCell(pDict, LVALUEtoCELL(nLocals));
/* compile code to initialize first local */
dictAppendCell(pDict, LVALUEtoCELL(pToLocal0));
@@ -3678,9 +3699,8 @@
nLocals++;
}
else if (nLocals > 0)
- { /* pop address of frame link parameter, set value to nLocals */- INT32 *pI32 = stackPopPtr(pVM->pStack);
- *pI32 = nLocals;
+ { /* write nLocals to (link) param area in dictionary */+ *(INT32 *)pMark = nLocals;
}
return;
@@ -3948,7 +3968,7 @@
**************************************************************************/
static void refill(FICL_VM *pVM)
{- INT32 ret = (pVM->sourceID == -1) ? FICL_FALSE : FICL_TRUE;
+ INT32 ret = (pVM->sourceID.i == -1) ? FICL_FALSE : FICL_TRUE;
stackPushINT32(pVM->pStack, ret);
if (ret)
vmThrow(pVM, VM_OUTOFTEXT);
@@ -3956,6 +3976,45 @@
}
+/**************************************************************************
+ f o r g e t
+** TOOLS EXT ( "<spaces>name" -- )
+** Skip leading space delimiters. Parse name delimited by a space.
+** Find name, then delete name from the dictionary along with all
+** words added to the dictionary after name. An ambiguous
+** condition exists if name cannot be found.
+**
+** If the Search-Order word set is present, FORGET searches the
+** compilation word list. An ambiguous condition exists if the
+** compilation word list is deleted.
+**************************************************************************/
+static void forgetWid(FICL_VM *pVM)
+{+ FICL_DICT *pDict = ficlGetDict();
+ FICL_HASH *pHash;
+
+ pHash = (FICL_HASH *)stackPopPtr(pVM->pStack);
+ hashForget(pHash, pDict->here);
+
+ return;
+}
+
+
+static void forget(FICL_VM *pVM)
+{+ void *where;
+ FICL_DICT *pDict = ficlGetDict();
+ FICL_HASH *pHash = pDict->pCompile;
+
+ tick(pVM);
+ where = ((FICL_WORD *)stackPopPtr(pVM->pStack))->name;
+ hashForget(pHash, where);
+ pDict->here = PTRtoCELL where;
+
+ return;
+}
+
+
#if 0
/**************************************************************************
@@ -4195,7 +4254,7 @@
dictAppendWord(dp, "set-current",
setCurrent, FW_DEFAULT);
dictAppendWord(dp, "set-order", setOrder, FW_DEFAULT);
- dictAppendWord(dp, "wordlist", wordlist, FW_DEFAULT);
+ dictAppendWord(dp, "ficl-wordlist", wordlist, FW_DEFAULT);
/*
** Set SEARCH environment query values
@@ -4209,6 +4268,7 @@
*/
dictAppendWord(dp, ".s", displayStack, FW_DEFAULT);
dictAppendWord(dp, "bye", bye, FW_DEFAULT);
+ dictAppendWord(dp, "forget", forget, FW_DEFAULT);
dictAppendWord(dp, "see", see, FW_DEFAULT);
dictAppendWord(dp, "words", listWords, FW_DEFAULT);
@@ -4232,6 +4292,7 @@
dictAppendWord(dp, "compile-only",
compileOnly, FW_DEFAULT);
dictAppendWord(dp, "endif", endifCoIm, FW_COMPIMMED);
+ dictAppendWord(dp, "forget-wid",forgetWid, FW_DEFAULT);
dictAppendWord(dp, "parse-word",parseNoCopy, FW_DEFAULT);
dictAppendWord(dp, "sliteral", sLiteralCoIm, FW_COMPIMMED); /* STRING */
dictAppendWord(dp, "wid-set-super",