ref: 6392a3ec4af354a4fbf364ed21238e39a49b7ee1
parent: 7d5ecf643890a51e98c800310bdc29f1481d2b7c
author: jsadler <jsadler@ficl.sf.net>
date: Tue Jul 24 00:01:29 CDT 2001
Linux/gcc tweaks, commented out vcall support in oo.fr. Added ooptest.fr to regression suite
--- a/Makefile.linux
+++ b/Makefile.linux
@@ -14,6 +14,9 @@
lib: libficl.so.$(MAJOR).$(MINOR)
+ficl: testmain.o ficl.h sysdep.h libficl.a
+ $(CC) testmain.o -o ficl -L. -lficl -lm
+
# static library build
libficl.a: $(OBJECTS)
$(LIB) libficl.a $(OBJECTS)
--- a/Makefile.riscos
+++ b/Makefile.riscos
@@ -11,9 +11,10 @@
lib: o.libficl
+ficl: testmain.o ficl.h sysdep.h o.libficl
+ $(CC) testmain.o -o ficl -L. -lficl -lm
+
# static library build
o.libficl: $(OBJECTS)
$(LIB) o.libficl $(OBJECTS)
-testmain: testmain.o ficl.h sysdep.h libficl.so.$(MAJOR).$(MINOR)
- $(CC) testmain.o -o testmain -L. -lficl -luname
--- a/ReadMe.txt
+++ b/ReadMe.txt
@@ -1,3 +1,9 @@
+rel 3.00a -- July 2001
+
+- Fixed broken oo.fr by commenting out vcall stuff using FICL_WANT_VCALL.
+ Vcall is still broken.
+
+
rel 3.00 -- June 2001
- Added pSys parameter to most ficlXXXX functions - multiple system support
--- a/doc/ficl.html
+++ b/doc/ficl.html
@@ -22,14 +22,16 @@
<font size=+1><a href="#whatis">What is ficl?</a></font></li>
<li>
-<font size=+1><a href="#download">Download</a></font></li>
+<font size=+1><a href="http://sourceforge.net/projects/ficl">Ficl project page on Sourceforge</a></font></li>
<li>
+<font size=+1><a href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download</a></font></li>
+
+<li>
<font size=+1><a href="#links">Tutorials and References</a></font></li>
<li>
-<font size=+1><a href="#includesficl">Some software
-that incorporates Ficl</a></font></li>
+<font size=+1><a href="#includesficl">Ficl Inside!</a></font></li>
<li>
<font size=+1><a href="#lawyerbait">Disclaimer & License</a></font></li>
@@ -61,8 +63,9 @@
<ul>
<li>
<font size=+1><a href="#exnumber">Number syntax</a></font></li>
-
<li>
+<font size=+1><a href="ficl_parse.html">Parser extensions and prefix support</a></font></li>
+<li>
<font size=+1><a href="#exsearch">Search order words</a></font></li>
<li>
@@ -83,20 +86,36 @@
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="675" >
<tr>
<td>
-<h1>
-<a NAME="whatis"></a>What is ficl?
-</h1>
+<h1><a NAME="whatis"></a>What is ficl?</h1>
+
Ficl is a complete programming language interpreter 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. The syntax is
-based on ANS Forth and the code is Standard C. See below for examples of
-<a href="#includesficl">software
-that includes ficl</a>. Ficl stands for "Forth inspired command language". </td>
+to be embedded into other systems as a command, macro, and development prototype
+language. Unlike other scripting interpreters, Ficl:
+<bl>
+<li>typically takes under 2 hours to port to a new system -- much less if the target
+operating system is one of several already supported (Win32, Linux, FreeBSD, RiscOS, and more)</li>
+<li>has a small memory footprint: a fully featured Win32 console version takes less
+than 100K of memory, and a minimal version is less than half that
+</li>
+<li>is relatively quick thanks to its threaded code virtual machine design
+and just in time compiling</li>
+<li>is a complete and powerful programming language</li>
+<li>is interactive</li>
+<li>has object oriented programming features that can be used to wrap data
+structures or classes of the host system without altering them - even if the host is
+mainly written in a non-OO language</li>
+</bl>
+<p>
+Ficl syntax is based on ANS Forth and the code is Standard C. See below for examples of
+<a href="#includesficl">software and products that include ficl</a>.
+Ficl stands for "Forth inspired command language". </p>
+</td>
</tr>
<tr>
-<td>Where Forths usually view themselves as the center of the system and
+<td>
+<h3>Ficl vs. other Forth interpreters</h3>
+Where Forths usually view themselves as the center of the system and
expect the rest of the system to be coded in Forth, Ficl acts as a component
of the system. It is easy to export code written in C or ASM to Ficl in
the style of TCL, or to invoke Ficl code from a compiled module. This allows
@@ -109,7 +128,8 @@
</tr>
<tr>
-<td><b>Ficl Design goals</b>
+<td>
+<h3>Ficl Design goals</h3>
<ul>
<li>
Target 32 bit processors (<i>version 2.03 targets 64 bit processors too</i>)</li>
@@ -148,11 +168,6 @@
<b><a href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download
ficl (latest release)</a></b>
</li>
-
-<li>
-<b><a href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download
-ficlWin</a> (not for resale. please contact me for resale license arrangements)</b>
-</li>
</ul>
<h2>
@@ -234,33 +249,41 @@
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="675" >
<tr>
<td>
-<h2>
-<a NAME="lawyerbait"></a>DISCLAIMER OF WARRANTY and LICENSE</h2>
-<p>Ficl is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.</p>
-
-<p>The ficl software code is provided 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.
-See the <a HREF="http://www.fsf.org/copyleft/lesser.html">
-GNU Lesser General Public License</a> for more details.</p>
-
-<p>Any third party may reproduce, distribute, or modify the ficl
-software code or any derivative works thereof without any
-compensation, provided that the author information
-and license text are retained in the source code files.</p>
-
+<h2><a NAME="lawyerbait"></a>LICENSE and DISCLAIMER</h2>
+<p>
+Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
+All rights reserved.</p>
<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, please <a href="mailto:john_sadler@alum.mit.edu">send
-me email</a>. </td>
+me email</a>.
+<pre>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+</pre>
+</td>
</tr>
</table>
-<br>
+
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="675" >
<tr>
<td>
@@ -299,14 +322,13 @@
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
dictionary, you do not need exclusive dictionary access for multithreading.
-<font color="#000099"><b>Note</b>:
-while the code is re-entrant, there are still restrictions on how you can
+<b>Note</b>: while the code is re-entrant, there are still restrictions on how you can
use it safely in a multithreaded system. Specifically, the VM itself maintains
state, so you generally need a VM per thread in a multithreaded system.
If interrupt service routines make calls into Ficl code that alters VM
state, then these generally need their own VM as well. Alternatively, you
could provide a mutual exclusion mechanism to serialize access to a VM
-from multiple threads.</font></li>
+from multiple threads.</li>
<li>
ROMable: Ficl is designed to work in RAM based and ROM code / RAM data
@@ -405,7 +427,7 @@
in file testmain.c.</i>
<dl>
<dt>
-<b>void ficlInitSystem(int nDictCells)</b></dt>
+<b>FICL_SYSTEM *ficlInitSystem(int nDictCells)</b></dt>
<dd>
Initializes Ficl's shared system data structures, and creates the dictionary
@@ -412,7 +434,7 @@
allocating the specified number of CELLs from the heap (by a call to ficlMalloc)</dd>
<dt>
-<b>void ficlTermSystem(void)</b></dt>
+<b>void ficlTermSystem(FICL_SYSTEM *pSys)</b></dt>
<dd>
Reclaims memory allocated for the ficl system including all dictionaries
@@ -420,7 +442,7 @@
words (allocate and resize) are your problem.</dd>
<dt>
-<b>int ficlBuild(char *name, FICL_CODE code, char flags)</b></dt>
+<b>int ficlBuild(FICL_SYSTEM *pSys, char *name, FICL_CODE code, char flags)</b></dt>
<dd>
Create a primitive word in ficl's main dictionary with the given name,
@@ -469,7 +491,7 @@
do a lot of dynamic creation of VMs.</dd>
<dt>
-<b>FICL_VM *ficlNewVM(void)</b></dt>
+<b>FICL_VM *ficlNewVM(FICL_SYSTEM *pSys)</b></dt>
<dd>
Create, initialize, and return a VM from the heap using ficlMalloc. Links
@@ -476,7 +498,7 @@
the VM into the system VM list for later reclamation by ficlTermSystem.</dd>
<dt>
-<b>FICL_WORD *ficlLookup(char *name)</b></dt>
+<b>FICL_WORD *ficlLookup(FICL_SYSTEM *pSys, char *name)</b></dt>
<dd>
Returns the address (also known as an XT in this case) of the specified
@@ -484,7 +506,7 @@
be used in a call to ficlExecXT.</dd>
<dt>
-<b>FICL_DICT *ficlGetDict(void)</b></dt>
+<b>FICL_DICT *ficlGetDict(FICL_SYSTEM *pSys)</b></dt>
<dd>
Returns a pointer to the main system dictionary, or NULL if the system
@@ -491,7 +513,7 @@
is uninitialized.</dd>
<dt>
-<b>FICL_DICT *ficlGetEnv(void)</b></dt>
+<b>FICL_DICT *ficlGetEnv(FICL_SYSTEM *pSys)</b></dt>
<dd>
Returns a pointer to the environment dictionary. This dictionary stores
@@ -498,7 +520,7 @@
information that describes this implementation as required by the Standard.</dd>
<dt>
-<b>void ficlSetEnv(char *name, UNS32 value)</b></dt>
+<b>void ficlSetEnv(FICL_SYSTEM *pSys, char *name, UNS32 value)</b></dt>
<dd>
Enters a new constant into the environment dictionary, with the specified
@@ -505,7 +527,7 @@
name and value.</dd>
<dt>
-<b>void ficlSetEnvD(char *name, UNS32 hi, UNS32 lo)</b></dt>
+<b>void ficlSetEnvD(FICL_SYSTEM *pSys, char *name, UNS32 hi, UNS32 lo)</b></dt>
<dd>
Enters a new double-cell constant into the environment dictionary with
@@ -512,7 +534,7 @@
the specified name and value.</dd>
<dt>
-<b>FICL_DICT *ficlGetLoc(void)</b></dt>
+<b>FICL_DICT *ficlGetLoc(FICL_SYSTEM *pSys)</b></dt>
<dd>
Returns a pointer to the locals dictionary. This function is defined only
@@ -520,13 +542,13 @@
dictionary is the symbol table for <a href="ficl_loc.html">local variables</a>.</dd>
<dt>
-<b>void ficlCompileCore(FICL_DICT *dp)</b></dt>
+<b>void ficlCompileCore(FICL_SYSTEM *pSys)</b></dt>
<dd>
Defined in words.c, this function builds ficl's primitives. </dd>
<dt>
-<b>void ficlCompileSoftCore(FICL_VM *pVM)</b></dt>
+<b>void ficlCompileSoftCore(FICL_SYSTEM *pSys)</b></dt>
<dd>
Defined in softcore.c, this function builds ANS required words and ficl
@@ -568,25 +590,12 @@
</tr>
<tr>
-<td><b>words.c</b></td>
+<td><b>dict.c</b></td>
-<td>Exports ficlCompileCore(), the run-time dictionary builder, and contains
-all primitive words as static functions.</td>
+<td>Dictionary</td>
</tr>
<tr>
-<td><b>vm.c</b></td>
-
-<td>Virtual Machine methods</td>
-</tr>
-
-<tr>
-<td><b>stack.c</b></td>
-
-<td>Stack methods</td>
-</tr>
-
-<tr>
<td><b>ficl.c</b></td>
<td>System initialization, termination, and ficlExec</td>
@@ -593,9 +602,10 @@
</tr>
<tr>
-<td><b>dict.c</b></td>
+<td><b>float.c</b></td>
-<td>Dictionary</td>
+<td>Adds precompiled definitions from the optional FLOAT word set. Most of the file
+is conditioned on FICL_WANT_FLOAT</td>
</tr>
<tr>
@@ -606,6 +616,14 @@
</tr>
<tr>
+<td><b>prefix.c</b></td>
+
+<td>The optional prefix parse step (conditioned on FICL_EXTENDED_PREFIX). This parse step
+handles numeric constructs like 0xa100, for example. See the release notes for more
+on parse steps.</td>
+</tr>
+
+<tr>
<td><b>search.c</b></td>
<td>Contains C implementations of several of the SEARCH and SEARCH EXT
@@ -621,7 +639,22 @@
from the .fr sources.</td>
</tr>
+<td><b>softwords/</b></td>
+
+<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.
+This is where you'll find source code for the object oriented extensions. PERL
+script softcore.pl converts the .fr files into softcore.c.</td>
+</tr>
+
<tr>
+<td><b>stack.c</b></td>
+
+<td>Stack methods</td>
+</tr>
+
+<tr>
<td><b>sysdep.c</b></td>
<td>Implementation of system dependent functions declared in sysdep.h</td>
@@ -628,13 +661,39 @@
</tr>
<tr>
-<td><b>softwords/</b></td>
+<td><b>testmain.c</b></td>
+<td>The main() function for unix/linux/win32 console applications - use this as an
+example to integrate ficl into your system. Also contains some definitions for
+testing - also useful in unix/linux/win32 land.
+</td>
+</tr>
-<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.
-This is where you'll find source code for the object oriented extensions.</td>
+<tr>
+<td><b>tools.c</b></td>
+
+<td>Contains C implementations of TOOLS and TOOLS EXT
+words, the debugger, and debugger support words.</td>
</tr>
+<tr>
+
+<tr>
+<td><b>vm.c</b></td>
+
+<td>Virtual Machine methods</td>
+</tr>
+
+<tr>
+<td><b>win32.c & unix.c</b></td>
+<td>Platform extensions words loaded in ficl.c by ficlCompilePlatform() - conditioned on FICL_WANT_PLATFORM</td>
+</tr>
+
+<tr>
+<td><b>words.c</b></td>
+
+<td>Exports ficlCompileCore(), the run-time dictionary builder, and contains
+most precompiled CORE and CORE-EXT words.</td>
+</tr>
+
</table>
<hr WIDTH="100%">
@@ -641,7 +700,6 @@
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="675" >
<tr>
<td>
-<dl>
<h2>
<a NAME="extras"></a>Ficl extras</h2>
@@ -648,38 +706,41 @@
<h3>
<a NAME="exnumber"></a>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>
-<dt>
-<tt>ok> decimal 123 . cr</tt> </dt>
+as a hex value regardless of the value of <code>BASE</code>. Likewise, numbers
+prefixed with "0d" will be interpreted as decimal values. Example:
+<pre>
+ok> decimal 123 . cr
+123
+ok> 0x123 . cr
+291
+ok> 0x123 x. cr
+123
+</pre>
+Note: ficl2.05 and later - this behavior is controlled by the <a href="ficl_parse.html">prefix parser</a> defined in
+<code>prefix.c</code>. You can add other prefixes by defining handlers for them in ficl or C.
-<br><tt>123 </tt>
-<br><tt>ok> 0x123 . cr</tt>
-<br><tt>291</tt>
-<br><tt>ok> 0x123 <a href="#xdot">x.</a> cr</tt>
-<br><tt>123</tt></dl>
-
-<h3>
-<a NAME="exsearch"></a>Search order words</h3>
-Ficl implements many of the search order words in terms of two primitives
-called <tt><a href="#tosearch">>SEARCH</a></tt> and <tt><a href="#searchfrom">SEARCH></a></tt>.
+<h3><a NAME="exsearch"></a>
+The <code>SEARCH</code> wordset and Ficl extensions
+</h3>
+<p>Ficl implements many of the search order words in terms of two primitives
+called <code><a href="#tosearch">>SEARCH</a></code> and <code><a href="#searchfrom">SEARCH></a></code>.
As their names suggest (assuming you're familiar with Forth), they push
-and pop the search order stack.
-<br>The standard does not appear to specify any conditions under which
+and pop the search order stack.</p>
+<p>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
-<dl><b><tt>FORTH-WORDLIST 1 SET-ORDER</tt></b></dl>
-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).
+The minimum search order (set by <tt>ONLY</tt>) is equivalent to</p>
+<pre>
+FORTH-WORDLIST 1 SET-ORDER
+</pre>
+<p>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).</p>
<p><b>Note</b>: Ficl resets the search order whenever it does <tt>ABORT</tt>.
If you don't like this behavior, just comment out the dictResetSearchOrder()
-lines in ficlExec().
-<br>
-<dt>
-<a NAME="tosearch"></a><tt>>search ( wid -- )</tt></dt>
-
+lines in ficlExec().</p>
+<dl>
+<dt><a NAME="tosearch"></a><code>>search ( wid -- )</code></dt>
<dd>
Push <tt>wid</tt> onto the search order. Many of the other search order
words are written in terms of the <tt>SEARCH></tt> and <tt>>SEARCH</tt>
--- a/doc/ficl_debug.html
+++ b/doc/ficl_debug.html
@@ -3,84 +3,108 @@
<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.73 [en] (Win98; U) [Netscape]">
- <title>FIcl Debugger</title>
+ <title>Ficl Debugger</title>
</head>
<body>
<link REL="SHORTCUT ICON" href="ficl.ico">
-<h1>
-<b>Ficl Debugger</b></h1>
+<h1><b>Ficl Debugger</b></h1>
<script language="javascript" src="ficlheader.js"></script>
-
-<br>
<table COLS=1 WIDTH="650" >
<tr>
-<td>Ficl release 2.05 includes a simple step debugger for colon definitions
+<td>
+<p>Ficl release 2.05 includes a simple step debugger for colon definitions
and does> words. If you use it and can suggest improvements (or better
-yet if you write some), please let me know.
-<h2>
-Using the debugger</h2>
+yet if you write some), please let me know.</p>
+<h2>Using the debugger</h2>
To debug a word, set up the stack with any parameters the word requires,
then type:
-<br>debug <your word here>
-<br>If the word is unnamed, or all you have is an xt, you can instead use:
-<br>debug-xt ( xt -- )
+
+<b><pre>debug <your word here></pre></b>
+
+<p>If the word is unnamed, or all you have is an xt, you can instead use:</p>
+<b><code>debug-xt ( xt -- )</code></b>
<p>The debugger invokes <tt>see</tt> on the word, printing a crude source
listing, then stops at the first instruction of the definition. There are
-four (case insensitive) commands you can use from here onwards:
-<dl>
-<dt>
-I (step in)</dt>
+four (case insensitive) commands you can use from here onwards:</p>
-<dd>
-If the next instruction is a colon defintion or does> word, steps into
+<dl>
+<dt>I (step in)</dt>
+<dd>If the next instruction is a colon defintion or does> word, steps into
that word's code. If the word is a primitive, simply executes the word.</dd>
-<dt>
-O (step over)</dt>
+<dt>O (step over)</dt>
+<dd>Executes the next instruction in its entirety</dd>
-<dd>
-Executes the next instruction in its entirety</dd>
+<dt>G (go)</dt>
+<dd>Run the word to completion and exit the debugger</dd>
-<dt>
-G (go)</dt>
+<dt>L (list)</dt>
+<dd>Lists the source code of the word presently being stepped</dd>
-<dd>
-Run the word to completion and exit the debugger</dd>
+<dt>Q (quit)</dt>
+<dd>Abort the word and exit the debugger, clearing the stack</dd>
-<dt>
-Q (quit)</dt>
+<dt>X (eXecute)</dt>
+<dd>Interpret the remainder of the line as ficl words for their side effects.
+Any errors will abort the debug session and reset the VM. Usage example:
+<pre>
+x drop 3 \ fix argument on stack
+</pre>
+</dd>
-<dd>
-Abort the word and exit the debugger, clearing the stack</dd>
+<dt>Anything else</dt>
+<dd>Prints a list of available debugger commands</dd>
</dl>
-<h2>
-The on-step event </h2>
-If there is a defined word named on-step when the debugger starts, that
+<h2>The on-step event</h2>
+<p>If there is a defined word named <code>on-step</code> when the debugger starts, that
word will be executed before every step. As a guideline, this word should
-have no side effects. Its intended use is to display the stack, but you
-may have some better ideas. Please let me know.
-<br><b><tt>: on-step ." Stack: " .s cr ;</tt></b>
-<br>
-<h2>
-Debugger internals</h2>
-The debugger words are mostly located in source file tools.c. There is
-one supporting word (debug) in softcore.fr as well. There are two main
-words that make the debugger go: debug-xt and step-break. Debug-xt takes
-the xt of a word to debug (as returned by <tt>'</tt>, for example) checks
-to see if it is debuggable (not a primitive), sets a breakpoint at its
-first instruction, and runs <tt>see</tt> on it. To set a breakpoint, debug-xt
-replaces the instruction at the breakpoint with the xt of step-break, and
+have no side effects. Its intended use is to display the stacks and any other
+VM state you're interested in, but you
+may have some better ideas. If so, please let me know. The default on-step is:<p>
+<b><code>: on-step ." S: " .s cr ;</code></b>
+
+<h3>Other useful words for debugging and on-step</h3>
+<dl>
+<dt><code>r.s ( -- )</code></dt>
+<dd>Prints a represention of the state of the return stack non-destructively. You have to have
+a good understanding of the return stack side-effects of control words to make sense of it,
+but it does give an accurate representation of what's there. Example: <code>DO .. LOOP</code>s stack
+three parameters on the return stack: the loop count and limit, and the <code>LEAVE</code> target
+address.</dd>
+<dt><code>.s ( -- )</code></dt>
+<dd>Prints the parameter stack non-destructively</dd>
+<dt><code>f.s ( -- )</code></dt>
+<dd>Prints the float stack non-destructively (only available if FICL_WANT_FLOAT is enabled)</dd>
+</dl>
+<h2>Debugger internals</h2>
+<p>
+The debugger words are mostly located in source file <tt>tools.c</tt>. There are
+supporting words (<code>debug</code> and <code>on-step</code>) in softcore.fr as well.
+There are two main words that make the debugger go: debug-xt and step-break.
+Debug-xt takes the xt of a word to debug (as returned by <tt>'</tt>, for example)
+checks to see if it is debuggable (not a primitive), sets a breakpoint at its
+first instruction, and runs <code>see</code> on it. To set a breakpoint,
+<code>debug-xt</code>
+replaces the instruction at the breakpoint with the xt of <code>step-break</code>, and
stores the original instruction and its address in a static breakpoint
-record. To clear the breakpoint, step-break simply replaces the original
+record. To clear the breakpoint, <code>step-break</code> simply replaces the original
instruction and adjusts the target virtual machine's instruction pointer
-to run it.
-<br>Step-break is responsible for processing debugger commands and setting
-breakpoints at subsequent instructions.
-<br> </td>
+to run it.
+</p>
+<p><code>Step-break</code> is responsible for processing debugger commands and setting
+breakpoints at subsequent instructions.</p>
+<h3>To Do</h3>
+<bl>
+<li>The debugger needs to exit automatically when it encounters the end of the word
+it was asked to debug. Perhaps this could be a special kind of breakpoint?
+</li>
+<li>Add user-set breakpoints</li>
+<li>Add "step out" command</li>
+</bl>
+</td>
</tr>
</table>
--- a/doc/ficl_loc.html
+++ b/doc/ficl_loc.html
@@ -47,8 +47,10 @@
between -- and } are treated as a comment. The | and -- sections are optional,
but they must appear in the order shown if they appear at all.
<br><b>Double cell locals </b>(AKA 2locals): ordinarily, each local represents
-one cell. Local variable names prefixed with the character '2' in the declaration
-are double-cell locals. They behave the same as single cell locals in all
+one cell. Local variable names prefixed with the characters "2:" in the declaration
+are double-cell locals. The prefix is not part of the local variable's name, only
+part of the declaration.
+They behave the same as single cell locals in all
other respects. I use 2locals quite a bit in Ficl's OO classes, because
objects in Ficl require two cells on the stack. You can modify the
value of a double cell local with <tt><a href="http://www.taygeta.com/forth/dpans13.htm#13.6.1.2295">TO</a></tt>
@@ -55,17 +57,18 @@
the same as you would a single cell local.
<br>Following are some examples to illustrate usage (they are not intended
to be good code otherwise). Try these out in FiclWin to get a feeling for
-how they work...
+how they work. Also see <code>softwords/string.fr</code> for an example of use of locals
+in OO code.
<blockquote><b><tt>: local-demo { a b | c -- }</tt></b><br><b><tt> ." a = " a . cr</tt></b>
<br><b><tt> ." b = " b . cr</tt></b>
<br><b><tt> ." c = " c . cr ;</tt></b>
<br><b><tt>1 2 local-demo ( you should see 1 2 0 )</tt></b>
-<p><b><tt>: my2dup { 2x } x x ; ( uses a 2local+<p><b><tt>: my2dup { 2:x } x x ; ( uses a 2local)</tt></b>
<br><b><tt>1 2 my2dup .s </tt></b>
<br><b><tt>.( you should see 1 2 1 2 on the stack ) cr empty</tt></b>
-<p><b><tt>: my2swap { 2x 2y -- y x } y x ; +<p><b><tt>: my2swap { 2:x 2:y -- y x } y x ; ( note use of 2locals )</tt></b>
<br><b><tt>1 2 3 4 my2swap .s</tt></b>
<br><b><tt>.( you should see 3 4 1 2 on the stack ) cr empty</tt></b>
@@ -78,8 +81,7 @@
variables. <tt>TO</tt> knows whether it's operating on a <tt>LOCAL</tt>,
a <tt>2LOCAL</tt>, or a <tt>VALUE</tt>, and does the right thing accordingly.
<br>
-<h2>
-Other local variable syntaxes (deprecated)</h2>
+<h2>Other local variable syntaxes (deprecated)</h2>
There are other syntaxes in use for local variables. You get the same compiled
code regardless of which style of local declaration you choose, but the
Johns-Hopkins syntax is more readable, more flexible, and supports <tt>2LOCAL</tt>s
@@ -116,13 +118,14 @@
by FICL_MAX_LOCALS in sysdep.h.
<h2>
Release notes for local variables</h2>
-Ficl 2.02 includes by default an implementation of the Johns Hopkins local
+<p>Ficl 2.05 adds 2LOCALS using the "2:" prefix</p>
+<p>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:
+locals. Example: </p>
<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
--- a/doc/ficl_oop.html
+++ b/doc/ficl_oop.html
@@ -159,7 +159,7 @@
stack notation to understand this tutorial. To get started, take a look
at this <a href="http://www.taygeta.com/forth_intro/stackflo.html">web-based
Forth tutorial</a>. If you're comfortable with both OO and Forth, you can
-<a href="#ootutoial-finally">jump
+<a href="#ootutorial-finally">jump
ahead</a>.
<p>A Ficl <a href="oo_in_c.html#object-def">object</a> associates a <a href="oo_in_c.html#class-def">class</a>
with an <a href="oo_in_c.html#instance-def">instance</a> (the storage for
@@ -219,7 +219,7 @@
<tr>
<td>
<h3>
-<a NAME="ootutoial-finally"></a>Tutorial (finally!)</h3>
+<a NAME="ootutorial-finally"></a>Tutorial (finally!)</h3>
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
@@ -226,14 +226,18 @@
not familiar with Forth, please see one of these <a href="#links">references</a>.
Ficl's OOP words are in vocabulary <tt>OOP</tt>. To put <tt>OOP</tt> in
the search order and make it the compilation wordlist, type:
-<blockquote><b><tt>ONLY ( reset to default search order )</tt></b>
-<br><b><tt>ALSO OOP DEFINITIONS</tt></b></blockquote>
+<pre>
+ONLY ( reset to default search order )
+ALSO OOP DEFINITIONS
+</pre>
(<b>Note for beginners</b>: to see the effect of the commands above, type
<tt>ORDER</tt>
after each line. You can repeat the sequence above if you like.)
<p>To start, we'll work with the two base classes <tt>OBJECT</tt> and <tt>METACLASS</tt>.
Try this:
-<blockquote><b><tt>metaclass --> methods</tt></b></blockquote>
+<pre>
+metaclass --> methods
+</pre>
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
@@ -243,27 +247,30 @@
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.
-<blockquote><b><tt>object --> sub c-led</tt></b></blockquote>
+<pre>
+object --> sub c-led
+</pre>
Causes base-class <tt>OBJECT</tt> to derive from itself a new class called
c-led. Now we'll add some instance variables and methods to the new class...
<br><b>Note</b>: 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.
-<blockquote>
-<pre><b><tt>c-byte obj: .state</tt></b></pre>
-<b><tt>: init { 2this -- }</tt></b>-<br><b><tt> this --> super --> init</tt></b>
-<br><b><tt> ." initializing an instance of " </tt></b>
-<br><b><tt> this --> class --> id type cr ;</tt></b>
-<p><b><tt>: on { led# 2this -- }</tt></b>-<br><b><tt> this --> .state --> get</tt></b>
-<br><b><tt> 1 led# lshift or dup !oreg</tt></b>
-<br><b><tt> this --> .state --> set ;</tt></b>
-<p><b><tt>: off { led# 2this -- }</tt></b>-<br><b><tt> this --> .state --> get</tt></b>
-<br><b><tt> 1 led# lshift invert and dup !oreg</tt></b>
-<br><b><tt> this --> .state --> set ;</tt></b>
-<p><b><tt>end-class</tt></b></blockquote>
+<pre>
+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-class
+</pre>
The first line adds an instance variable called <tt>.state</tt> 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
@@ -289,14 +296,20 @@
variable (<tt>.STATE</tt>) so that <tt>ON</tt> and <tt>OFF</tt> can work
in terms of LED number rather than a bitmask.
<p>Now make an instance of the new class:
-<blockquote><b><tt>c-led --> new led</tt></b></blockquote>
+<pre>
+c-led --> new led
+</pre>
And try a few things...
-<blockquote><b><tt>led --> methods</tt></b>
-<br><b><tt>led --> pedigree</tt></b>
-<br><b><tt>1 led --> on</tt></b>
-<br><b><tt>1 led --> off</tt></b></blockquote>
+<pre>
+led --> methods
+led --> pedigree
+1 led --> on
+1 led --> off
+</pre>
Or you could type this with the same effect:
-<blockquote><b><tt>led 2dup --> methods --> pedigree</tt></b></blockquote>
+<pre>
+led 2dup --> methods --> pedigree
+</pre>
Notice (from the output of <tt>methods</tt>) that we've overridden the
init method supplied by object, and added two more methods for the member
variables. If you type <tt>WORDS</tt>, you'll see that these methods are
@@ -306,34 +319,38 @@
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:
-<blockquote><b><tt>c-led --> see init</tt></b>
-<br>or
-<br><b><tt>led --> class --> see init</tt></b></blockquote>
+<pre>
+c-led --> see init
+</pre>
+or
+<pre>
+led --> class --> see init
+</pre>
<h3>
Early binding</h3>
Ficl 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
-effiecient because it compiles method addresses rather then their names.
+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.
<br>Here's an example that illustrates a potential problem:
-<blockquote><b><tt>object --> sub c1</tt></b>
-<br><b><tt>: m1 { 2this -- } ." c1's m1" cr ;</tt></b>-<br><b><tt>: m2 { 2this -- } ." Running " this-my=> m1 ; ( early )</tt></b>
-<br><b><tt>: m3 { 2this -- } ." Running " this---> m1 ; ( late )</tt></b>
-<br><b><tt>end-class</tt></b>
-<p><b><tt>c1 --> sub c2</tt></b>
-<br><b><tt>: m1 { 2this -- } ." c2's m1" cr ;</tt></b>-<br><b><tt>end-class</tt></b>
-<p><b><tt>c2 --> new i2</tt></b>
-<br><b><tt>i2 --> m1 ( runs the m1 defined in c2 )</tt></b>
-<br><b><tt>i2 --> m2 ( is this what you wanted? )</tt></b>
-<br><b><tt>i2 --> m3 { runs the overridden m1)</tt></b></blockquote>+<pre>
+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)+</pre>
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
@@ -340,44 +357,48 @@
class behaviors appropriately.
<ol>
<li>
-<b><tt>my=> </tt></b>binds early to a method in the class being defined,
-as in the example above.</li>
-
+<code>my=></code> binds early to a method in the class being defined,
+as in the example above.
+</li>
<li>
-<b><tt>my=[ ] </tt></b>binds a sequence of methods in the current class.
-Useful when the class has object members. Lines like <b><tt>this --> state
---> set</tt></b> in the definition of c-led above can be replaced with
-<b><tt>this
-my=[ state set ]</tt></b> to get early binding.</li>
-
+<code>my=[ ]</code> binds a sequence of methods in the current class.
+Useful when the class has object members. Lines like <code>this --> state
+--> set</code> in the definition of c-led above can be replaced with
+<code>this my=[ state set ]</code> to get early binding.
+</li>
<li>
-<b><tt>=> </tt>(dangerous)</b> pops a class off the stack and compiles
-the method in that class. Since you have to specify the class explicitly,
+<code>=></code> (dangerous) pops a class off the stack and compiles
+the method in that class. Since you have to specify the class explicitly,
there is a real danger that this will be out of sync with the class you
-really wanted. I recommend the <b><tt>my=</tt></b> operations.</li>
+really wanted. I recommend the <code>my=</code> operations.
+</li>
</ol>
-Early binding using <b><tt>=></tt></b> is dangerous because it partially
+Early binding using <code>=></code> 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 <tt>init</tt> method,
+method at compile time. In many cases, such as the <code>init</code> 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 <tt>metaclass</tt>. Here's an example from the definition of <tt>metaclass</tt>
-in oo.fr (don't paste this into ficlWin - it's already there):
-<blockquote><b><tt>: new \ ( class metaclass "name" -- )</tt></b>
-<br><b><tt> metaclass => instance --> init ;</tt></b></blockquote>
-Try this...
-<blockquote><b><tt>metaclass --> see new</tt></b></blockquote>
-Decompiling the method with <tt>SEE</tt> shows the difference between the
+of <code>metaclass</code>. Here's an example from the definition of <code>metaclass</code>
+in oo.fr (don't paste this into ficlWin - it's already there):
+<pre>
+: new \ ( class metaclass "name" -- )
+ metaclass => instance --> init ;
+</pre>
+Try this...
+<pre>
+metaclass --> see new
+</pre>
+Decompiling the method with <code>SEE</code> 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.
-<br>Notice that the primitive early-binding operator <tt>=></tt> requires
-a class at compile time. For this reason, classes are <tt>IMMEDIATE</tt>,
+context of whatever class is supplied on the stack at run-time.
+<br>Notice that the primitive early-binding operator <code>=></code> requires
+a class at compile time. For this reason, classes are <code>IMMEDIATE</code>,
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.
-<br>
+Forth, object-oriented programming, and Ficl's OOP syntax.
+<br>
<h3>
More About Instance Variables</h3>
<i>Untyped</i> instance variable methods (created by <tt>cell: cells: char:</tt>
@@ -1325,31 +1346,31 @@
follows)</dd>
<dd>
-<font face="Courier New"><font size=-1>set ( c-addr u 2this -- ) </font></font><font size=+0>Initialize
+<font face="Courier New"><font size=-1>set ( c-addr u 2:this -- ) </font></font><font size=+0>Initialize
buffer to the specified string</font></dd>
<dd>
-<font face="Courier New"><font size=-1>get ( 2this -- c-addr u ) Return
+<font face="Courier New"><font size=-1>get ( 2:this -- c-addr u ) Return
buffer contents as counted string</font></font></dd>
<dd>
-<font face="Courier New"><font size=-1>cat ( c-addr u 2this -- ) Append
+<font face="Courier New"><font size=-1>cat ( c-addr u 2:this -- ) Append
given string to end of buffer</font></font></dd>
<dd>
-<font face="Courier New"><font size=-1>compare ( 2string 2this -- n ) Return
+<font face="Courier New"><font size=-1>compare ( 2string 2:this -- n ) Return
result of lexical compare</font></font></dd>
<dd>
-<font face="Courier New"><font size=-1>type ( 2this -- ) Print buffer to
+<font face="Courier New"><font size=-1>type ( 2:this -- ) Print buffer to
the output stream</font></font></dd>
<dd>
-<font face="Courier New"><font size=-1>hashcode ( 2this -- x ) Return hashcode
+<font face="Courier New"><font size=-1>hashcode ( 2:this -- x ) Return hashcode
of string (as in dictionary)</font></font></dd>
<dd>
-<font face="Courier New"><font size=-1>free ( 2this -- ) Release internal
+<font face="Courier New"><font size=-1>free ( 2:this -- ) Release internal
buffer</font></font></dd>
<dt>
--- a/doc/ficl_rel.html
+++ b/doc/ficl_rel.html
@@ -19,27 +19,102 @@
<table BORDER=0 CELLPADDING=3 COLS=1 WIDTH="675" >
<tr>
<td>
-<h2>
-<a NAME="whatsnew"></a>What's new in version 2.05</h2>
+<h2><a NAME="whatsnew">Version 3.00a</a></h2>
-<h3>
-General </h3>
-
<ul>
<li>
-HTML documentation extensively revised</li>
+Fixed broken oo.fr by commenting out vcall stuff using FICL_WANT_VCALL. Vcall is still broken.
+</li>
-<li>
-Incorporated Alpha (64 bit) patches from the freeBSD team.</li>
+<h2>Version 3.00</h2>
+<ul>
<li>
-Split SEARCH and SEARCH EXT words from words.c to search.c</li>
+Added pSys parameter to most ficlXXXX functions for multiple system support. Affected functions:
+<ul>
+<li>dictLookupLoc renamed to ficlLookupLoc after addition of pSys param</li>
+<li>ficlInitSystem returns a FICL_SYSTEM*</li>
+<li>ficlTermSystem</li>
+<li>ficlNewVM</li>
+<li>ficlLookup</li>
+<li>ficlGetDict</li>
+<li>ficlGetEnv</li>
+<li>ficlSetEnv</li>
+<li>ficlSetEnvD</li>
+<li>ficlGetLoc</li>
+<li>ficlBuild</li>
+</ul>
+</li>
-<li>
-2LOCALS defined in <a href="ficl_loc.html#jhlocal">Johns Hopkins local
-syntax</a> now lose the first '2' in their names.</li>
+<li>Fixed off-by-one bug in ficlParsePrefix</li>
+<li>Ficl parse-steps now work correctly - mods to interpret()</li>
+<li>Made tools.c:isAFiclWord more selective</li>
+<li>Tweaked makefiles and code to make gcc happy under linux</li>
+<li>Vetted all instances of LVALUEtoCELL to make sure they're working on CELL sized operands
+(for 64 bit compatibility)</li>
</ul>
+<h2>Version 2.06</h2>
+<ul>
+<li>Debugger changes:</li>
+<ul>
+<li>New debugger command "x" to execute the rest of the command line as ficl</li>
+<li>New debugger command "l" lists the source of the innermost word being debugged</li>
+<li>If you attempt to debug a primitive, it gets executed rather than doing nothing</li>
+<li><code>R.S</code> displays the stack contents symbolically</li>
+<li>Debugger now operates correctly under ficlwin, although ficlwin's key handling leaves a lot to be desired. </li>
+<li><code>SEE</code> listing enhanced for use with the debugger</li>
+</ul>
+<li>Added Guy Carver's changes to oo.fr for VTABLE support</li>
+<li><code>float.c</code> words f> and >f to move floats to and from the param stack, analogous to >r and r></li>
+<li><code>LOOKUP</code> - Surrogate precompiled parse step for ficlParseWord (this step is hard
+ coded in <code>INTERPRET</code>)</li>
+<li>License text at top of source files changed from LGPL to BSD by request</li>
+<li>Win32 console version now handles exceptions more gracefully rather than crashing - uses win32
+structured exception handling.</li>
+<li>Fixed BASE bug from 2.05 (was returning the value rather than the address) </li>
+<li>Fixed ALLOT bug - feeds address units to dictCheck, which expects Cells. Changed dictCheck
+to expect AU. </li>
+<li>Float stack display word renamed to f.s from .f to be consistent with r.s and .s</li>
+</ul>
+
+<h2>Version 2.05</h2>
+<h3>General</h3>
+
+<ul>
+<li>HTML documentation extensively revised</li>
+<li>Incorporated Alpha (64 bit) patches from the freeBSD team.</li>
+<li>Split SEARCH and SEARCH EXT words from words.c to search.c</li>
+<li><a href="ficl_loc.html">2LOCALS</a> defined in <a href="ficl_loc.html#jhlocal">Johns Hopkins local syntax</a> now lose the first '2:' in their names.</li>
+<li>Simple step <a href="ficl_debug.html">debugger</a> (see tools.c)</li>
+<li>The text interpreter is now extensible - this is accomplished through the use
+of <code>ficlAddParseStep()</code>. <code>FICL_MAX_PARSE_STEPS</code> limits the number of parse steps
+(default: 8). You can write a precompiled parse step (see <code>ficlParseNumber</code>) and
+append it to the chain, or you can write one in ficl and use <code>ADD-PARSE-STEP</code>
+to append it. Default parse steps are initialized in <code>ficlInitSystem</code>. You can list
+the parse steps with <code>parse-order ( -- )</code>.</li>
+<li>There is now a FICL_SYSTEM structure. This is a transitional release - version 3.0
+will alter several API prototypes to take this as a parameter, allowing multiple
+systems per process (and therefore multiple dictionaries). For those who use ficl
+under a virtual memory O/S like Linux or Win NT, you can just create multiple ficl
+processes (not threads) instead and save youself the wait.</li>
+<li>Fixes for improved command line operation in testmain.c (Larry Hastings)</li>
+<li>Numerous extensions to OO facility, including a new allot methods, ability
+to catch method invocations (thanks to Daniel Sobral again)</li>
+<li>Incorporated Alpha (64 bit) patches contributed by Daniel Sobral and the freeBSD team
+Ficl is now 64 bit friendly! UNS32 is now FICL_UNS.</li>
+<li>Split SEARCH and SEARCH EXT words from words.c to search.c</li>
+<li>ABORT" now complies with the ANS (-2 THROWs)</li>
+<li>Floating point support contributed by Guy Carver (Enable FICL_WANT_FLOAT in sysdep.h).</li>
+<li>Win32 vtable model for objects (Guy Carver)</li>
+<li>Win32 dll load/call suport (Larry Hastings)</li>
+<li>Prefix support (Larry Hastings) (prefix.c prefix.fr FICL_EXTENDED_PREFIX) makes it
+easy to extend the parser to recignize prefixes like 0x and act on them. Use show-prefixes
+to see what's defined.</li>
+<li>Cleaned up initialization sequence so that it's all in ficlInitSystem, and so that
+a VM can be created successfully before the dictionary is created</li>
+</ul>
+
<h3>
Bug fixes</h3>
@@ -62,11 +137,11 @@
<ul>
<li>
-<a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0415">2r@</a><a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0410">2r></a><a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0340">2>r</a>
+<a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0415">2r@</a> <a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0410">2r></a> <a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0340">2>r</a>
(CORE EXT)</li>
<li>
-<a href="http://www.taygeta.com/forth/dpans8.htm#8.6.1.0440">2VARIABLE</a>
+<a href="http://www.taygeta.com/forth/dpans8.htm#8.6.1.0440">2VARIABLE</a>
(DOUBLE)</li>
<li>
@@ -83,7 +158,7 @@
is 0</li>
<li>
-<tt><a href="ficl.html#wid-set-name">wid-set-name</a></tt>
+<tt><a href="ficl.html#wid-set-name">wid-set-name</a></tt>
set optional wid name pointer to the \0 terminated string address specified.</li>
<li>
@@ -105,11 +180,10 @@
<ul>
<li>
-<tt>ALLOT
-(class method)</tt></li>
+<tt>ALLOT (class method)</tt></li>
<li>
-<tt>ALLOT-ARRAY (class method)</tt></li>
+<tt>ALLOT-ARRAY (class method)</tt></li>
<li>
<tt>METHOD</tt> define method names globally</li>
@@ -131,6 +205,53 @@
<li>
Early binding words are now in the instance-vars wordlist, not visible
unless defining a class.</li>
+
+<li>Support for refs to classes with VTABLE methods (contributed by Guy Carver). Guy writes:
+<p>
+My next favorite change is a set of VCALL words that allow me
+to call C++ class virtual methods from my forth classes. This
+is accomplished by interfacing with the VTABLE of the class. The
+class instance currently must be created on the C++ side.
+C++ places methods in the VTABLE in order of declaration in the
+header file. To use this in FICL one only needs to ensure
+that the VCALL: declerations occur in the same order. I use this
+quite a bit to interface with the C++ classes. When I need access
+to a method I make sure it is virtual (Even if it ultimately will
+not be). I use Visual C++ 6.0 and have not tested this under
+any other compiler but I believe VTABLE implementation is standard.
+</p><p>
+Here is an example of how to use VCALL:
+</p>
+<b>C++ class declaration</b>
+<pre>
+class myclass
+{+public:
+ myclass();
+ virtual ~myclass();
+ virtual void Test( int iParam1 );
+ virtual int Test( int iParam1, char cParam2 );
+ virtual float Test();
+};
+</pre>
+<b>ficl class declaration</b>
+<pre>
+object subclass myfclass hasvtable \ hasvtable adds 4 to the offset to
+ \ accommodate for the VTABLE pointer.
+0 VCALL: Destructor() \ VCALL: ( ParamCount -<MethodName>- )
+1 VCALL: Test(int) \ Test takes 1 int parameter.
+2 VCALLR: iTest(int,char) \ iTest takes 2 parameters and returns an int.
+0 VCALLF: fTest() \ fTest takes no parameters and returns a float.
+end-class
+
+MyCAddress \ Primitive to return a pointer to a "myclass" instance.
+myfclass -> ref dude \ This makes the MyCAddress pointer a myfclass
+ \ instance with the name "dude".
+1234 dude -> Test(int) \ Calls the virtual method Test.
+1234 1 dude -> iTest(int,char) . \ Calls iTest and emits the returned int.
+dude -> fTest() f. \ Calls fTest and emits the returned float.
+</pre>
+</li>
</ul>
<h2>
--- a/float.c
+++ b/float.c
@@ -4,7 +4,7 @@
** ANS Forth FLOAT word-set written in C
** Author: Guy Carver & John Sadler (john_sadler@alum.mit.edu)
** Created: Apr 2001
-** $Id: float.c,v 1.4 2001/06/12 08:24:34 jsadler Exp $
+** $Id: float.c,v 1.5 2001/07/24 05:01:24 jsadler Exp $
*******************************************************************/
/*
** Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
@@ -806,7 +806,7 @@
#define NUMISNEG 1
#define EXPISNEG 2
-enum _floatParseState
+typedef enum _floatParseState
{FPS_START,
FPS_ININT,
@@ -831,7 +831,7 @@
float mant = 0.1f;
FICL_INT exponent = 0;
char flag = 0;
- enum FloatParseState estate = FPS_START;
+ FloatParseState estate = FPS_START;
#if FICL_ROBUST > 1
vmCheckFStack(pVM, 0, 1);
@@ -883,7 +883,7 @@
else
{digit = (unsigned char)(ch - '0');
- if ((digit > 9) || (digit < 0))
+ if (digit > 9)
return(0);
accum = accum * 10 + digit;
@@ -904,7 +904,7 @@
else
{digit = (unsigned char)(ch - '0');
- if ((digit > 9) || (digit < 0))
+ if (digit > 9)
return(0);
accum += digit * mant;
@@ -935,7 +935,7 @@
case FPS_INEXP:
{digit = (unsigned char)(ch - '0');
- if ((digit > 9) || (digit < 0))
+ if (digit > 9)
return(0);
exponent = exponent * 10 + digit;
--- a/softwords/oo.fr
+++ b/softwords/oo.fr
@@ -234,6 +234,7 @@
2swap drop + @ swap
;
+\ #if FICL_WANT_VCALL
\ vcall extensions contributed by Guy Carver
: vcall: ( paramcnt "name" -- )
current-class @ 8 + dup @ dup 1+ rot ! \ Kludge fix to get to .vtCount before it's defined.
@@ -252,7 +253,8 @@
does> \ ( inst class pfa -- ptr-inst ptr-class )
nip 2@ vcall f> \ ( params offset inst class offset -- f: r )
;
-\ #endif
+\ #endif /* FLOAT */
+\ #endif /* VCALL */
\ END-CLASS terminates construction of a class by storing
\ the size of its instance variables in the class's size field
@@ -302,7 +304,11 @@
immediate
0 , \ NULL parent class
dup , \ wid
+\ #if FICL_WANT_VCALL
4 cells , \ instance size
+\ #else
+ 3 cells , \ instance size
+\ #endif
ficl-set-current
does> dup
; execute metaclass
@@ -323,17 +329,24 @@
create .wid ( class metaclass -- wid ) \ return wid of class
1 cells , do-instance-var
+\ #if FICL_WANT_VCALL
create .vtCount \ Number of VTABLE methods, if any
2 cells , do-instance-var
create .size ( class metaclass -- size ) \ return class's payload size
3 cells , do-instance-var
+\ #else
+create .size ( class metaclass -- size ) \ return class's payload size
+ 2 cells , do-instance-var
+\ #endif
: get-size metaclass => .size @ ;
: get-wid metaclass => .wid @ ;
: get-super metaclass => .super @ ;
+\ #if FICL_WANT_VCALL
: get-vtCount metaclass => .vtCount @ ;
: get-vtAdd metaclass => .vtCount ;
+\ #endif
\ create an uninitialized instance of a class, leaving
\ the address of the new instance and its class
@@ -442,7 +455,9 @@
here current-class ! \ prep for do-do-instance
parent , \ save parent class
wid , \ save wid
+\ #if FICL_WANT_VCALL
parent meta --> get-vtCount ,
+\ #endif
here parent meta --> get-size dup , ( addr[size] size )
metaclass => .do-instance
wid ficl-set-current -rot
@@ -503,9 +518,11 @@
\ This method is late bound for safety...
: subclass --> sub ;
+\ #if FICL_WANT_VCALL
\ VTABLE Support extensions (Guy Carver)
\ object --> sub mine hasvtable
: hasvtable 4 + ; immediate
+\ #endif
\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
--- a/sysdep.c
+++ b/sysdep.c
@@ -6,7 +6,7 @@
** Implementations of FICL external interface functions...
**
** (simple) port to Linux, Skip Carter 26 March 1998
-** $Id: sysdep.c,v 1.8 2001/07/16 14:21:52 jsadler Exp $
+** $Id: sysdep.c,v 1.9 2001/07/24 05:01:24 jsadler Exp $
*******************************************************************/
/*
** Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
@@ -324,10 +324,8 @@
#if PORTABLE_LONGMULDIV == 0
-#if defined(riscos)
typedef unsigned long long __u64;
typedef unsigned long __u32;
-#endif
DPUNS ficlLongMul(FICL_UNS x, FICL_UNS y)
{--- a/test/ficltest.fr
+++ b/test/ficltest.fr
@@ -83,3 +83,7 @@
testing prefixes
{ 0x10 -> decimal 16 } { hex 0d10 -> decimal 10 }+{ hex 100+-> decimal 256 }
+
+load ooptest.fr
--- a/test/ooptest.fr
+++ b/test/ooptest.fr
@@ -1,5 +1,6 @@
\ OOP test stuff
+only
also oop definitions
object subclass c-aggregate
@@ -42,7 +43,7 @@
end-class
\ test stuff from ficl.html
-.( metaclass methods )
+.( metaclass methods ) cr
metaclass --> methods
cr .( c-foo class ) cr