ref: 5a81e15d663cfea8832155f39f0e8f3557ff3fae
parent: 1591d8a423dee113d543648ab5c3ea07cfb5c55b
author: jsadler <jsadler@ficl.sf.net>
date: Tue Jun 6 23:24:16 CDT 2000
<>
--- a/Makefile
+++ b/Makefile
@@ -8,7 +8,7 @@
LIB = ar cr
RANLIB = ranlib
-MAJOR = 1
+MAJOR = 2
MINOR = 0.3
lib: libficl.so.$(MAJOR).$(MINOR)
--- a/ReadMe.txt
+++ b/ReadMe.txt
@@ -1,3 +1,82 @@
+Edit paste works more sensibly if there's already text on the
+line being appended to...
+
+rel 2.03 (April 1999)
+
+ficlwin:
+- File Menu: recent file list and Open now load files.
+- Text ouput function is now faster through use of string
+ caching. Cache flushes at the end of each line and each
+ time ficlExec returns.
+- Edit/paste now behaves more reasonably for text. File/open
+ loads the specified file.
+- Registry entries specify dictionary and stack sizes. See
+ HKEY_CURRENT_USER/Software/CodeLab/ficlwin/Settings
+
+testmain:
+- Added CLOCK ( -- u) , wrapper for the ANSI C clock() function.
+ Returns the number of clock ticks elapsed since process start.
+- MSEC renamed to MS (in line with the ANS)
+- Added CLOCKS/SEC ( -- u) , wrapper for ANSI C CLOCKS_PER_SEC
+ constant
+- Changed gets() in testmain to fgets() to appease the security gods.
+
+
+Data structures are now 64 bit friendly.
+
+oo.fr: Added alloc and alloc-array methods of METACLASS to
+allocate objects and arrays of objects from the heap. Free method
+of OBJECT frees the storage. (requires MEMORY wordset)
+
+Added CORE EXT word WITHIN
+Added DOUBLE word DNEGATE
+
+Added ficlSetStackSize to specify param and return stack sizes. See ficl.h
+
+Added ficlExecXT in ficl.c/h - executes a FICL_WORD given its address.
+
+Added Michael Gauland's ficlLongMul and ficlLongDiv and support
+routines to math64.c and .h. These routines are coded in C, and are
+compiled only if PORTABLE_LONGMULDIV == 1 (default is 0).
+
+Added definition of ficlRealloc to sysdep.c (needed for memory
+allocation wordset). If your target OS supports realloc(),
+you'll probably want to redefine ficlRealloc in those terms.
+The default version does ficlFree followed by ficlMalloc.
+
+[Thanks to Daniel Sobral of FreeBSD for suggesting or implementing
+the next six changes!]
+- Added CATCH and THROW (EXCEPTION word set)
+- Added MEMORY allocation word set. Requires ficlRealloc
+- EVALUATE respects count parameter, and also passes exceptional
+ return conditions back out to the calling instance of ficlExec.
+- VM_QUIT clears locals dictionary in ficlExec()
+- ficlExec pushes ip and executes interpret at the right times so that
+ nested calls to ficlExec behave the way you'd expect them to.
+- Control word match check upgraded. Control structure mismatches
+ are now errors, not warnings, since the check accepts all
+ syntactally legal constructs.
+
+Added vmInnerLoop to vm.h. This function/macro factors the inner
+interpreter out of ficlExec so it can be used in other places.
+Function/macro behavior is conditioned on INLINE_INNER_LOOP
+in sysdep.h. Default: 1 unless _DEBUG is set. In part, this is because
+VC++ 5 goes apoplectic when trying to compile it as a function. See
+comments in vm.c
+
+Bug fix in isNumber(): used to treat chars between 'Z' and 'a'
+as valid in base 10... (harmless, but weird) (Ficl Finger of Fate
+award to Phil Martel for this one ;-) )
+
+softcore.pl now removes comments, spaces at the start and
+ end of lines. As a result:
+ sizeof (softWords) == 7663 bytes (used to be 20000)
+ and consumes 11384 bytes of dictionary when compiled
+ (so it's cheaper to store as text than code, for the
+ memory-conscious)
+
+Deleted 3Com license paste-o in this file (oops)
+
rel 2.02 -- 17 October 1998
Changed ficlExec so that the search order really does get reset
@@ -165,132 +244,6 @@
This is the standard header file, which defines new resource IDs.
Microsoft Developer Studio reads and updates this file.
-/////////////////////////////////////////////////////////////////////////////
-Other notes:
-AppWizard uses "TODO:" to indicate parts of the source code you
-should add to or customize.
-
-If your application uses MFC in a shared DLL, and your application is
-in a language other than the operating system's current language, you
-will need to copy the corresponding localized resources MFC40XXX.DLL
-from the Microsoft Visual C++ CD-ROM onto the system or system32 directory,
-and rename it to be MFCLOC.DLL. ("XXX" stands for the language abbreviation.-For example, MFC40DEU.DLL contains resources translated to German.) If you
-don't do this, some of the UI elements of your application will remain in the
-language of the operating system.
-
/////////////////////////////////////////////////////////////////////////////
-
-YOU SHOULD CAREFULLY READ THE FOLLOWING TERMS AND CONDITIONS BEFORE USING THIS PRODUCT.
-IT CONTAINS SOFTWARE, THE USE OF WHICH IS LICENSED BY PALM COMPUTING, INC., A SUBSIDIARY
-OF 3COM CORPORATION (COLLECTIVELY, "3COM"), TO ITS CUSTOMERS FOR THEIR USE ONLY AS SET
-FORTH BELOW. IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT,
-DO NOT USE THE SOFTWARE. USING ANY PART OF THE SOFTWARE INDICATES THAT YOU ACCEPT THESE
-TERMS.
-
-LICENSE: 3Com grants you a nonexclusive license to use the accompanying software program(s)
-(the "Software") subject to the terms and restrictions set forth in this License Agreement.
-You are not permitted to lease or rent (except under separate mutually agreeable terms set
-forth in writing), distribute or sublicense the Software or to use the Software in a
-time-sharing arrangement or in any other unauthorized manner. Further, no license is granted
-to you in the human readable code of the Software (source code). Except as provided below,
-this License Agreement does not grant you any rights to patents, copyrights, trade secrets,
-trademarks, or any other rights in respect to the Software.
-
-The Software is licensed to be used on any personal computer and/or any 3Com product, provided
-that the Software is used only in connection with 3Com products. With respect to the Desktop
-Software, you may reproduce and provide one (1) copy of such Software for each personal computer
-or 3Com product on which such Software is used as permitted hereunder. With respect to the
-Device Software, you may use such Software only on one (1) 3Com product. Otherwise, the Software
-and supporting documentation may be copied only as essential for backup or archive purposes in
-support of your use of the Software as permitted hereunder. You must reproduce and include all
-copyright notices and any other proprietary rights notices appearing on the Software on any
-copies that you make.
-
-NO Assignment; No Reverse Engineering: You may transfer the Software and this License
-Agreement to another party if the other party agrees in writing to accept the terms and
-conditions of this License Agreement. If you transfer the Software, you must at the same
-time either transfer all copies of the Software as well as the supporting documentation
-to the same party or destroy any such materials not transferred. Except as set forth
-above, you may not transfer or assign the Software or your rights under this License Agreement.
-
-Modification, reverse engineering, reverse compiling, or disassembly of the Software is
-expressly prohibited. However, if you are a European Community ("EC") resident, information -necessary to achieve interoperability of the Software with other programs within the meaning
-of the EC Directive on the Legal Protection of Computer Programs is available to you from
-3Com upon written request.
-
-EXPORT RESTRICTIONS: You agree that you will not export or re-export the Software or
-accompanying documentation (or any copies thereof) or any products utilizing the Software
-or such documentation in violation of any applicable laws or regulations of the United States
-or the country in which you obtained them.
-
-Trade Secrets; Title: You acknowledge and agree that the structure, sequence and organization
-of the Software are the valuable trade secrets of 3Com and its suppliers. You agree to hold
-such trade secrets in confidence. You further acknowledge and agree that ownership of, and
-title to, the Software and all subsequent copies thereof regardless of the form or media are
-held by 3Com and its suppliers.
-
-UNITED STATES Government Legend:
-
-The Software is commercial in nature and developed solely at private expense. The Software
-is delivered as "Commercial Computer Software" as defined in DFARS 252.227-7014 (June 1995)
-or as a commercial item as defined in FAR 2.101(a) and as such is provided with only such
-rights as are provided in this License Agreement, which is 3Com's standard commercial license
-for the Software. Technical data is provided with limited rights only as provided in
-DFAR 252.227-7015 (Nov. 1995) or FAR 52.227-14 (June 1987), whichever is applicable.
-
-TERM AND TERMINATION: This License Agreement is effective until terminated. You may
-terminate it at any time by destroying the Software and documentation together with
-all copies and merged portions in any form. It will also terminate immediately if
-you fail to comply with any term or condition of this License Agreement. Upon such
-termination you agree to destroy the Software and documentation, together with all copies
-and merged portions in any form.
-
-GOVERNING LAW: This License Agreement shall be governed by the laws of the State of
-California as such laws are applied to agreements entered into and to be performed
-entirely within California between California residents and by the laws of the United
-States. You agree that the United Nations Convention on Contracts for the International
-Sale of Goods (1980) is hereby excluded in its entirety from application to this License Agreement.
-
-NO WARRANTY: THE SOFTWARE AND ALL RELATED DOCUMENTATION ARE PROVIDED ON AN "AS IS" BASIS
-AND ALL RISK IS WITH YOU. BECAUSE THE SOFTWARE AND DOCUMENTATION ARE PROVIDED TO YOU FREE
-OF CHARGE, 3COM MAKES NO WARRANTIES, TERMS, OR CONDITIONS, EXPRESS, IMPLIED OR STATUTORY,
-AS TO ANY MATTER WHATSOEVER. IN PARTICULAR, ANY AND ALL WARRANTIES, TERMS OR CONDITIONS
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT OF THIRD PARTIES
-RIGHTS ARE EXPRESSLY EXCLUDED. FURTHER, 3COM MAKES NO REPRESENTATIONS, WARRANTIES, TERMS
-OR CONDITIONS THAT THE SOFTWARE AND DOCUMENTATION PROVIDED ARE FREE OF ERRORS OR VIRUSES
-OR THAT THE SOFTWARE AND DOCUMENTATION ARE SUITABLE FOR YOUR INTENDED USE.
-
-LIMITATION OF LIABILITY: IN NO EVENT SHALL 3COM OR ITS SUPPLIERS BE LIABLE TO YOU OR ANY
-OTHER PARTY FOR ANY INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES, LOSS OF DATA OR DATA
-BEING RENDERED INACCURATE, LOSS OF PROFITS OR REVENUE, OR INTERRUPTION OF BUSINESS IN
-ANY WAY ARISING OUT OF OR RELATED TO THE USE OR INABILITY TO USE THE SOFTWARE AND/OR
-DOCUMENTATION, REGARDLESS OF THE FORM OF ACTION, WHETHER IN CONTRACT, TORT
-(INCLUDING NEGLIGENCE), STRICT PRODUCT LIABILITY OR OTHERWISE, EVEN IF ANY REPRESENTATIVE
-OF 3COM OR ITS SUPPLIERS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. NOTHING IN
-THIS AGREEMENT SHALL HAVE THE EFFECT OF LIMITING OR EXCLUDING 3COM'S LIABILITY FOR DEATH
-OR PERSONAL INJURY CAUSED BY ITS OWN NEGLIGENCE. THIS DISCLAIMER OF LIABILITY FOR DAMAGES
-WILL NOT BE AFFECTED BY ANY FAILURE OF THE SOLE AND EXCLUSIVE REMEDIES HEREUNDER.
-
-DISCLAIMER: Some countries, states, or provinces do not allow the exclusion or
-limitation of implied warranties or the limitation of incidental or consequential
-damages for certain products supplied to consumers or the limitation of liability
-for personal injury, so the above limitations and exclusions may be limited in their
-application to you. When the implied warranties are not allowed to be excluded in
-their entirety, they will be limited to the duration of the applicable written
-warranty. This warranty gives you specific legal rights which may vary depending
-on local law.
-
-SEVERABILITY: In the event any provision of this License Agreement is found to be
-invalid, illegal or unenforceable, the validity, legality and enforceability of any
-of the remaining provisions shall not in any way be affected or impaired and a valid,
-legal and enforceable provision of similar intent and economic impact shall be
-substituted therefor.
-
-ENTIRE AGREEMENT: This License Agreement sets forth the entire understanding and
-agreement between you and 3Com, supersedes all prior agreements, whether written or
-oral, with respect to the Software, and may be amended only in a writing signed by
-both parties.
--- a/dict.c
+++ b/dict.c
@@ -193,7 +193,6 @@
UNS8 flags)
{FICL_COUNT len = (FICL_COUNT)SI_COUNT(si);
- char *name = SI_PTR(si);
char *pName;
FICL_WORD *pFW;
@@ -228,7 +227,7 @@
d i c t A p p e n d U N S 3 2
** Append the specified UNS32 to the dictionary
**************************************************************************/
-void dictAppendUNS32(FICL_DICT *pDict, UNS32 u)
+void dictAppendUNS(FICL_DICT *pDict, UNS32 u)
{*pDict->here++ = LVALUEtoCELL(u);
return;
--- a/doc/ficl.html
+++ b/doc/ficl.html
@@ -1,104 +1,113 @@
-<!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.07 [en] (Win95; U) [Netscape]">
- <TITLE>ficl 2.0 release notes</TITLE>
-</HEAD>
-<BODY>
+<!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.5 [en] (Win95; U) [Netscape]">
+ <meta name="Description" content="all about the coolest scripting language ever">
+ <title>ficl 2.03 release notes</title>
+</head>
+<body>
-<CENTER>
-<H1>
-<B>ficl 2.02 release notes</B></H1></CENTER>
+<center>
+<h1>
+<b>ficl 2.03 release notes</b></h1></center>
-<TABLE BORDER=0 CELLSPACING=3 WIDTH="600" >
-<TR>
-<TD><B>Forth Inspired Command Language </B></TD>
+<table BORDER=0 CELLSPACING=3 WIDTH="600" >
+<tr>
+<td><b>Forth Inspired Command Language </b></td>
-<TD ROWSPAN="4"><IMG SRC="ficl_logo.jpg" HEIGHT=64 WIDTH=64></TD>
-</TR>
+<td ROWSPAN="4"><img SRC="ficl_logo.jpg" height=64 width=64></td>
+</tr>
-<TR>
-<TD><B>Author: John Sadler (john_sadler@alum.mit.edu)</B></TD>
-</TR>
+<tr>
+<td><b>Author: John Sadler (<a href="mailto:john_sadler@alum.mit.edu">john_sadler@alum.mit.edu</a>)</b></td>
+</tr>
-<TR>
-<TD><B>Created: 19 July 1997 </B></TD>
-</TR>
+<tr>
+<td><b>Created: 19 July 1997 </b></td>
+</tr>
-<TR>
-<TD><B>Revision 2.02: 10 October 1998 </B></TD>
-</TR>
-</TABLE>
+<tr>
+<td><b>Revision 2.03: 20 May 1999 </b></td>
+</tr>
+</table>
-<H2>
-Contents</H2>
+<h2>
+Contents</h2>
-<UL>
-<LI>
-<A HREF="#whatis">What is ficl?</A></LI>
+<ul>
+<li>
+<a href="#whatis">What is ficl?</a></li>
-<LI>
-<A HREF="#features">Ficl features</A></LI>
+<li>
+<a href="#features">Ficl features</a></li>
-<LI>
-<A HREF="#porting">Porting</A></LI>
+<li>
+<a href="#porting">Porting</a></li>
-<LI>
-<A HREF="#manifest">Distribution source files</A></LI>
+<li>
+<a href="#api">Application Programming Interface</a></li>
-<LI>
-<A HREF="#whatsnew">What's new in this release</A></LI>
+<li>
+<a href="#manifest">Distribution source files</a></li>
-<LI>
-<A HREF="#objects">Objects in ficl</A></LI>
+<li>
+<a href="#whatsnew">What's new in this release</a></li>
-<UL>
-<LI>
-<A HREF="ficl.html#oopgloss">OOP glossary</A></LI>
+<li>
+<a href="#objects">Objects in ficl</a></li>
-<LI>
-<A HREF="#glossinstance">Instance variable glossary</A></LI>
+<ul>
+<li>
+<a href="ficl.html#oopgloss">OOP glossary</a></li>
-<LI>
-<A HREF="#glossclass">Class methods glossary</A></LI>
+<li>
+<a href="#glossinstance">Instance variable glossary</a></li>
-<LI>
-<A HREF="#objectgloss">Object base class methods glossary</A></LI>
+<li>
+<a href="#glossclass">Class methods glossary</a></li>
-<LI>
-<A HREF="#stockclasses">Supplied Classes</A></LI>
-</UL>
+<li>
+<a href="#objectgloss">Object base class methods glossary</a></li>
-<LI>
-<A HREF="#extras">Ficl extras</A></LI>
+<li>
+<a href="#stockclasses">Supplied Classes</a></li>
+</ul>
-<LI>
-<A HREF="#ansinfo">ANS required information</A></LI>
+<li>
+<a href="#extras">Ficl extras</a></li>
-<LI>
-<A HREF="#links">Forth references</A></LI>
+<li>
+<a href="#ansinfo">ANS required information</a></li>
-<LI>
-<A HREF="#lawyerbait">Disclaimer & License</A></LI>
-</UL>
+<li>
+<a href="#links">Forth and Ficl references, <b><font color="#000000">download</font></b></a></li>
-<HR WIDTH="100%">
-<TABLE CELLSPACING=3 COLS=1 WIDTH="600" >
-<TR>
-<TD>
-<H2>
-<A NAME="whatis"></A>What is ficl?</H2>
+<li>
+<font color="#000000"><a href="#includesficl">Some software that includes
+ficl</a></font></li>
+
+<li>
+<a href="#lawyerbait">Disclaimer & License</a></li>
+</ul>
+
+<hr WIDTH="100%">
+<table CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<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>
+of the host system without altering them. See below for examples of <a href="#includesficl">software
+that includes ficl</a>.</td>
+</tr>
-<TR>
-<TD>Where Forths usually view themselves as the center of the system and
+<tr>
+<td>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
@@ -107,125 +116,133 @@
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++...). </TD>
-</TR>
+adapter for code written in C (or asm, Forth, C++...). </td>
+</tr>
-<TR>
-<TD><B>Ficl Design goals</B>
-<UL>
-<LI>
-Target 32 bit processors </LI>
+<tr>
+<td><b>Ficl Design goals</b>
+<ul>
+<li>
+Target 32 bit processors (<i>version 2.03 targets 64 bit processors too</i>)</li>
-<LI>
+<li>
Scripting, prototyping, and extension language for systems written also
-in C</LI>
+in C</li>
-<LI>
-Supportable - code is as transparent as I can make it</LI>
+<li>
+Supportable - code is as transparent as I can make it</li>
-<LI>
-Interface to functions written in C</LI>
+<li>
+Interface to functions written in C</li>
-<LI>
-Conform to the Forth DPANS 94</LI>
+<li>
+Conform to the Forth DPANS 94</li>
-<LI>
+<li>
Minimize porting effort - require an ANSI C runtime environment and minimal
-glue code</LI>
+glue code</li>
-<LI>
-Provide object oriented extensions</LI>
-</UL>
-</TD>
-</TR>
-</TABLE>
+<li>
+Provide object oriented extensions</li>
+</ul>
+</td>
+</tr>
+</table>
-<BR>
-<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
-<TR>
-<TD>
-<H2>
-<A NAME="features"></A>Ficl features</H2>
+<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>
+<ul>
+<li>
+Code is written in ANSI C for portability. </li>
-<LI>
+<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
-LOCAL EXT and various extras.</LI>
+LOCAL EXT, EXCEPTION, MEMORY, and various extras.</li>
-<LI>
+<li>
Extensible: you can export code written in Forth, C, or asm in a straightforward
way. Ficl provides open facilities for extending the language in an application
specific way. You can even add new control structures (not surprising if
-you're familiar with Forth)</LI>
+you're familiar with Forth)</li>
-<LI>
+<li>
Ficl and C can interact in two ways: Ficl can wrap C code, and C functions
-can invoke ficl code.</LI>
+can invoke ficl code.</li>
-<LI>
-Ficl is thread safe and re-entrant: All Ficl VMs share one system
+<li>
+Ficl code 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
-dictionary, you do not need exclusive dictionary access for multithreading.</LI>
+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
+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>
-<LI>
+<li>
Simple incorporation into existing systems: the sample implementation requires
-three Ficl function calls (see the example program in testmain.c).</LI>
+three Ficl function calls (see the example program in testmain.c).</li>
-<LI>
+<li>
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>
+because it builds its system dictionary in RAM at startup time.</li>
-<LI>
+<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++</li>
-<LI>
+<li>
Does full 32 bit math (but you need to implement two mixed precision math
-primitives (see sysdep.c))</LI>
+primitives (see sysdep.c))</li>
-<LI>
-Type 1 indirect threaded interpreter</LI>
-</UL>
-</TD>
-</TR>
-</TABLE>
+<li>
+Type 1 indirect threaded interpreter</li>
+</ul>
+</td>
+</tr>
+</table>
-<P>
-<HR WIDTH="100%">
-<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
-<TR>
-<TD>
-<H2>
-<A NAME="porting"></A>Porting ficl</H2>
+<p>
+<hr WIDTH="100%">
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<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>
+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
+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
+<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
most applications, you won't notice the difference. If you're doing a lot
of number crunching, consider implementing them correctly.
-<H3>
-Build controls</H3>
+<h3>
+Build controls</h3>
The file sysdep.h contains default values for build controls. Most of these
are written such that if you define them on the compiler command line,
the defaults are overridden. I suggest you take the defaults on everything
@@ -233,273 +250,603 @@
Beware of declaring too small a dictionary, for example. You need about
3200 cells for a full system, about 2000 if you strip out most of the "soft"
words.
-<H3>
-To-Do List (target system dependent words)</H3>
+<h3>
+To-Do List (target system dependent words)</h3>
-<UL>
-<LI>
-Unimplemented system dependent <TT>CORE</TT> word: <TT>KEY</TT> </LI>
+<ul>
+<li>
+Unimplemented system dependent <tt>CORE</tt> word: <tt>KEY</tt> </li>
-<LI>
-Kludged <TT>CORE</TT> word: <TT>ACCEPT</TT></LI>
-</UL>
-</TD>
-</TR>
-</TABLE>
+<li>
+Kludged <tt>CORE</tt> word: <tt>ACCEPT</tt></li>
+</ul>
+</td>
+</tr>
+</table>
-<TABLE BORDER=0 CELLSPACING=5 WIDTH="600" >
-<TR>
-<TD COLSPAN="2">
-<H2>
- <A NAME="manifest"></A>Ficl Source Files</H2>
-</TD>
-</TR>
+<br>
+<table COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h2>
+<a NAME="api"></a>Application Programming Interface</h2>
+<i>See the comments in ficl.c and ficl.h for additional information, and
+the example in file testmain.c.</i>
+<br>
+<dl>
+<dt>
+<b>void ficlInitSystem(int nDictCells)</b></dt>
-<TR>
-<TD><B>ficl.h</B></TD>
+<dd>
+Initializes Ficl's shared system data structures, and creates the dictionary
+allocating the specified number of CELLs from the heap (by a call to ficlMalloc)</dd>
-<TD>Declares most public functions and all data structures. Includes sysdep.h
-and math.h</TD>
-</TR>
+<dt>
+<b>void ficlTermSystem(void)</b></dt>
-<TR>
-<TD><B>sysdep.h</B></TD>
+<dd>
+Reclaims memory allocated for the ficl system including all dictionaries
+and all virtual machines created by vmCreate. Any uses of the memory allocation
+words (allocate and resize) are your problem.</dd>
-<TD>Declares system dependent functions and contains build control macros.
-Edit this file to port to another system.</TD>
-</TR>
+<dt>
+<b>int ficlBuild(char *name, FICL_CODE code, char flags)</b></dt>
-<TR>
-<TD><B>math.h</B></TD>
+<dd>
+Create a primitive word in ficl's main dictionary with the given name,
+code pointer, and properties (immediate, compile only, etc) as described
+by the flags (see ficl.h for flag descriptions of the form FW_XXXX)</dd>
-<TD>Declares functions for 64 bit math</TD>
-</TR>
+<dt>
+<b>int ficlExec(FICL_VM *pVM, char *text)</b></dt>
-<TR>
-<TD><B>words.c</B></TD>
+<dd>
+Feed the specified C string ('\0' terminated) to the given virtual machine+for evaluation. Returns various exception codes (VM_XXXX in ficl.h) to
+indicate the reason for returning. Normal exit condition is VM_OUTOFTEXT,
+indicating that the VM consumed the string successfully and is back for
+more. ficlExec calls can be nested, and the function itself is re-entrant,
+but note that a VM is static, so you have to take reasonable precautions
+(for example, use one VM per thread in a multithreaded system if you want
+multiple threads to be able to execute commands).</dd>
-<TD>Exports ficlCompileCore(), the run-time dictionary builder, and contains
-all primitive words as static functions.</TD>
-</TR>
+<dt>
+<b>int ficlExecC(FICL_VM *pVM, char *text, int nChars)</b></dt>
-<TR>
-<TD><B>vm.c</B></TD>
+<dd>
+Same as ficlExec, but takes a count indicating the length of the supplied
+string. Setting nChars to -1 is equivalent to ficlExec (expects '\0' termination).</dd>
-<TD>Virtual Machine methods</TD>
-</TR>
+<dt>
+<b>int ficlExecXT(FICL_VM *pVM, FICL_WORD *pFW)</b></dt>
-<TR>
-<TD><B>stack.c</B></TD>
+<dd>
+Same as ficlExec, but takes a pointer to a FICL_WORD instead of a string.
+Executes the word and returns after it has finished. If executing the word
+results in an exception, this function will re-throw the same code if it
+is nested under another ficlExec family function, or return the exception
+code directly if not. This function is useful if you need to execute the
+same word repeatedly - you save the dictionary search and outer interpreter
+overhead.</dd>
-<TD>Stack methods</TD>
-</TR>
+<dt>
+<b>FICL_VM *ficlNewVM(void)</b></dt>
-<TR>
-<TD><B>ficl.c</B></TD>
+<dd>
+Create, initialize, and return a VM from the heap using ficlMalloc. Links
+the VM into the system VM list for later reclamation by ficlTermSystem.</dd>
-<TD>System initialization, termination, and ficlExec</TD>
-</TR>
+<dt>
+<b>FICL_WORD *ficlLookup(char *name)</b></dt>
-<TR>
-<TD><B>dict.c</B></TD>
+<dd>
+Returns the address (also known as an XT in this case) of the specified
+word in the main dictionary. If not found, returns NULL. The address can
+be used in a call to ficlExecXT.</dd>
-<TD>Dictionary</TD>
-</TR>
+<dt>
+<b>FICL_DICT *ficlGetDict(void)</b></dt>
-<TR>
-<TD><B>math64.c</B></TD>
+<dd>
+Returns a pointer to the main system dictionary, or NULL if the system
+is uninitialized.</dd>
-<TD>Implementation of 64 bit math words (except the two unsigned primitives
-declared in sysdep.h and implemented in sysdep.c)</TD>
-</TR>
+<dt>
+<b>FICL_DICT *ficlGetEnv(void)</b></dt>
-<TR>
-<TD><B>softcore.c</B></TD>
+<dd>
+Returns a pointer to the environment dictionary. This dictionary stores
+information that describes this implementation as required by the Standard.</dd>
-<TD>Contains all of the "soft" words - those written in Forth and compiled
+<dt>
+<b>void ficlSetEnv(char *name, UNS32 value)</b></dt>
+
+<dd>
+Enters a new constant into the environment dictionary, with the specified
+name and value.</dd>
+
+<dt>
+<b>void ficlSetEnvD(char *name, UNS32 hi, UNS32 lo)</b></dt>
+
+<dd>
+Enters a new double-cell constant into the environment dictionary with
+the specified name and value.</dd>
+
+<dt>
+<b>FICL_DICT *ficlGetLoc(void)</b></dt>
+
+<dd>
+Returns a pointer to the locals dictionary. This function is defined only
+if FICL_WANT_LOCALS is #defined as non-zero (see sysdep.h). The locals
+dictionary is the symbol table for <a href="#locals">local variables</a>.</dd>
+
+<dt>
+<b>void ficlCompileCore(FICL_DICT *dp)</b></dt>
+
+<dd>
+Defined in words.c, this function builds ficl's primitives. </dd>
+
+<dt>
+<b>void ficlCompileSoftCore(FICL_VM *pVM)</b></dt>
+
+<dd>
+Defined in softcore.c, this function builds ANS required words and ficl
+extras by evaluating a text string (think of it as a memory mapped file
+;-) ). The string itself is built from files in the softwords directory
+by PERL script softcore.pl. </dd>
+</dl>
+</td>
+</tr>
+</table>
+
+<hr WIDTH="100%">
+<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
+and math.h</td>
+</tr>
+
+<tr>
+<td><b>sysdep.h</b></td>
+
+<td>Declares system dependent functions and contains build control macros.
+Edit this file to port to another system.</td>
+</tr>
+
+<tr>
+<td><b>math.h</b></td>
+
+<td>Declares functions for 64 bit math</td>
+</tr>
+
+<tr>
+<td><b>words.c</b></td>
+
+<td>Exports ficlCompileCore(), the run-time dictionary builder, and contains
+all primitive words as static functions.</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>
+</tr>
+
+<tr>
+<td><b>dict.c</b></td>
+
+<td>Dictionary</td>
+</tr>
+
+<tr>
+<td><b>math64.c</b></td>
+
+<td>Implementation of 64 bit math words (except the two unsigned primitives
+declared in sysdep.h and implemented in sysdep.c)</td>
+</tr>
+
+<tr>
+<td><b>softcore.c</b></td>
+
+<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 softwords/softcore.bat and softwords/softcore.pl generate softcore.c
-from the .fr sources.</TD>
-</TR>
+from the .fr sources.</td>
+</tr>
-<TR>
-<TD><B>sysdep.c</B></TD>
+<tr>
+<td><b>sysdep.c</b></td>
-<TD>Implementation of system dependent functions declared in sysdep.h</TD>
-</TR>
+<td>Implementation of system dependent functions declared in sysdep.h</td>
+</tr>
-<TR>
-<TD><B>softwords/</B></TD>
+<tr>
+<td><b>softwords/</b></td>
-<TD>Directory contains sources and translation scripts for the words defined
+<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>
-</TABLE>
+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>
+<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.03</h2>
+This is the first version of Ficl that includes contributed code. Thanks
+especially to Daniel Sobral, Michael Gauland for contributions and bug
+finding.
+<p>New words
+<ul>
+<li>
+<tt><a href="#clock">clock</a>
+(FICL)</tt></li>
+
+<li>
+<tt><a href="#clockspersec">clocks/sec</a>
+(FICL)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans8.htm#8.6.1.1230">dnegate</a>
+(DOUBLE)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans10.htm#10.6.2.1905">ms</a>
+(FACILITY EXT - replaces MSEC)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans9.htm#9.6.1.2275">throw</a>
+(EXCEPTION)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans9.htm#9.6.1.0875">catch</a>
+(EXCEPTION)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans14.htm#14.6.1.0707">allocate</a>
+(MEMORY)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans14.htm#14.6.1.1605">free</a>
+(MEMORY)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans14.htm#14.6.1.2145">resize</a>
+(MEMORY)</tt></li>
+
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans6.htm#6.2.2440">within</a>
+(CORE EXT)</tt></li>
+
+<li>
+<tt><a href="#alloc">alloc</a>
+(class method)</tt></li>
+
+<li>
+<tt><a href="#allocarray">alloc-array</a>
+(class method)</tt></li>
+
+<li>
+<tt><a href="#oofree">free</a>
+(class method)</tt></li>
+</ul>
+Bugs Fixed
+<ul>
+<li>
+Bug fix in isNumber(): used to treat chars between 'Z' and 'a' as valid
+in base 10... (harmless, but weird)</li>
+
+<li>
+ficlExec pushes the <i>ip</i> and <tt>interpret</tt>s at the right times
+so that nested calls to ficlExec behave the way you'd expect them to.</li>
+
+<li>
+<tt>evaluate</tt> respects count parameter, and also passes exceptional
+return conditions back out to the calling instance of ficlExec.</li>
+
+<li>
+VM_QUIT now clears the locals dictionary in ficlExec.</li>
+</ul>
+Ficlwin Enhancements
+<ul>
+<li>
+File Menu: recent file list and Open now load files.</li>
+
+<li>
+Text ouput function is now faster through use of string caching. Cache
+flushes at the end of each line and each time ficlExec returns.</li>
+
+<li>
+Edit/paste now behaves more reasonably for text. File/open loads the specified
+file.</li>
+
+<li>
+Registry entries specify dictionary and stack sizes, default window placement,
+and whether or not to create a splitter for multiple VMs. See HKEY_CURRENT_USER/Software/CodeLab/ficlwin/Settings</li>
+</ul>
+Ficl Enhancements
+<ul>
+<li>
+This version includes changes to make it <b>64 bit friendly</b>. This unfortunately
+meant that I had to tweak some core data types and structures. I've tried
+to make this transparent to 32 bit code, but a couple of things got renamed.
+INT64 is now DPINT. UNS64 is now DPUNS. FICL_INT and FICL_UNS are synonyms
+for INT32 and UNS32 in 32 bit versions, but a are obsolescent. Please use
+the new data types instead. Typed stack operations on INT32 and UNS32 have
+been renamed because they operate on CELL scalar types, which are 64 bits
+wide on 64 bit systems. Added BITS_PER_CELL, which has legal values of
+32 or 64. Default is 32.</li>
+
+<li>
+ficl.c: Added ficlExecXT() - executes an xt completely before returning,
+passing back any exception codes generated in the process. Normal exit
+code is VM_INNEREXIT.</li>
+
+<li>
+ficl.c: Added ficlExecC() to operate on counted strings as opposed to zero
+terminated ones.</li>
+
+<li>
+ficlExec pushes ip and executes interpret at the right times so that nested
+calls to ficlExec behave the way you'd expect them to.</li>
+
+<li>
+ficlSetStackSize() allows specification of stack size at run-time (affects
+subsequent invocations of ficlNewVM()).</li>
+
+<li>
+vm.c: vmThrow() checks for (pVM->pState != NULL) before longjmping it.
+vmCreate nulls this pointer initially. </li>
+
+<li>
+EXCEPTION wordset contributed by Daniel Sobral of FreeBSD</li>
+
+<li>
+MEMORY-ALLOC wordset contributed by Daniel Sobral, too. Added class methods
+<tt>alloc</tt>
+and <tt>alloc-array</tt> in softwords/oo.fr to allocate objects from the
+heap.</li>
+
+<li>
+Control structure match check upgraded (thanks to Daniel Sobral for this
+suggestion). Control structure mismatches are now errors, not warnings,
+since the check accepts all syntactally legal constructs.</li>
+
+<li>
+Added vmInnerLoop() to vm.h. This function/macro factors the inner
+interpreter out of ficlExec so it can be used in other places. Function/macro
+behavior is conditioned on INLINE_INNER_LOOP in sysdep.h. Default: 1 unless
+_DEBUG is set. In part, this is because VC++ 5 goes apoplectic when trying
+to compile it as a function. See </li>
+
+<br>comments in vm.c
+<li>
+EVALUATE respects the count parameter, and also passes exceptional return
+conditions back out to the calling instance of ficlExec.</li>
+
+<li>
+VM_QUIT clears locals dictionary in ficlExec()</li>
+
+<li>
+Added Michael Gauland's ficlLongMul and ficlLongDiv and support routines
+to math64.c and .h. These routines are coded in C, and are compiled only
+if PORTABLE_LONGMULDIV == 1 (default is 0).</li>
+
+<li>
+Added definition of ficlRealloc to sysdep.c (needed for memory allocation
+wordset). If your target OS supports realloc(), you'll probably want to
+redefine ficlRealloc in those terms. The default version does ficlFree
+followed by ficlMalloc.</li>
+
+<li>
+testmain.c: Changed gets() in testmain to fgets() to appease the security
+gods.</li>
+
+<li>
+testmain: <tt>msec</tt> renamed to <tt><a href="#ficlms">ms</a></tt> in
+line with the ANS</li>
+
+<li>
+softcore.pl now removes comments & spaces at the start and end of lines.
+As a result: sizeof (softWords) == 7663 bytes (used to be 20000)
+and consumes 11384 bytes of dictionary when compiled</li>
+
+<li>
+Deleted license paste-o in readme.txt (oops).</li>
+</ul>
+</td>
+</tr>
+</table>
+
+<hr WIDTH="100%">
+<table BORDER=0 CELLPADDING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h2>
+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>
+<ul>
+<li>
+<tt><a href="http://www.taygeta.com/forth/dpans6.htm#6.2.1850">marker</a>
+(CORE EXT)</tt></li>
-<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="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="#ficlforgetwid">forget-wid</a>
+(FICL)</tt></li>
-<LI>
-<TT><A HREF="#ficlwordlist">ficl-wordlist</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="#ficlvocabulary">ficl-vocabulary</a> (FICL)</tt></li>
-<LI>
-<TT><A HREF="#ficlhide">hide</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>
+<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>
+<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
+<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>
+dictionary)</li>
-<LI>
-<TT>:noname</TT> used to push the colon control marker and its execution
-token in the wrong order</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>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>
+<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>
+<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>
+<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>
+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 <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
+<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>
+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>
+<hr WIDTH="100%">
+<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>
+<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>
+<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>
+<hr WIDTH="100%">
+<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>
+<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>
-<LI>
-Simple <TT>USER</TT> variable support - a user variable is a virtual machine
-instance variable. User variables behave as <TT>VARIABLE</TT>s in all other
-respects.</LI>
+<li>
+Simple <tt>USER</tt> variable support - a user variable is a virtual machine
+instance variable. User variables behave as <tt>VARIABLE</tt>s in all other
+respects.</li>
-<LI>
-Object oriented syntax extensions (see below)</LI>
+<li>
+Object oriented syntax extensions (see below)</li>
-<LI>
+<li>
Optional stack underflow and overflow checking in many CORE words (enabled
-when FICL_ROBUST is set to 2)</LI>
+when FICL_ROBUST >= 2)</li>
-<LI>
-Various bug fixes</LI>
-</UL>
-</TD>
-</TR>
-</TABLE>
+<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 includes support for <TT>LOCALS</TT> and <TT>LOCALS EXT</TT> words
+<hr WIDTH="100%">
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h3>
+<a NAME="locals"></a>Local Variables</h3>
+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
@@ -506,9 +853,9 @@
variables, so if you disable locals, you're going to lose other capabilities
too. Local variables can make Forth code quite a bit easier to read, so
I'd encourage you to experiment with them.
-<BR>The default maximum number of local variables is 16. It's controlled
+<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
+<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"
@@ -515,47 +862,47 @@
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>
+<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
+<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>+<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>
+<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>
+<h3>
+Search Order</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>.
+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
+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>There is a default maximum of 16 wordlists in the search order. This
+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>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>
-Soft Words</H3>
+<h3>
+Soft Words</h3>
Many words from all the supported wordsets are written in Forth, and stored
as a big string that Ficl compiles when it starts. The sources for all
of these words are in directory ficl/softwords. There is a .bat file (softcore.bat)
@@ -563,115 +910,115 @@
softcore.c, so softcore.c is really dependent on the Forth sources. This
is not reflected in the Visual C++ project database. For the time being,
it's a manual step. You can edit softcore.bat to change the list of files
-that contribute to softcore.c. </TD>
-</TR>
-</TABLE>
+that contribute to softcore.c. </td>
+</tr>
+</table>
-<H2>
+<h2>
-<HR WIDTH="100%"></H2>
+<hr WIDTH="100%"></h2>
-<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
-<TR>
-<TD>
-<H2>
-<A NAME="objects"></A>Objects in ficl</H2>
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<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
+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,
and separating namespaces so that methods and regular Forth words are not
easily confused.
-<H3>
-Design goals of Ficl OO syntax</H3>
+<h3>
+Design goals of Ficl OO syntax</h3>
Ficl's object extensions provide the traditional OO benefits of associating
data with the code that manipulates it, and reuse through single inheritance.
Ficl also has some unusual capabilities that support interoperation with
systems written in C.
-<UL>
-<LI>
+<ul>
+<li>
Ficl objects are normally late bound for safety (late binding guarantees
that the appropriate method will always be invoked for a particular object).
Early binding is also available, provided you know the object's class at
-compile-time.</LI>
+compile-time.</li>
-<LI>
-Ficl OOP supports single inheritance, aggregation, and arrays of objects.</LI>
+<li>
+Ficl OOP supports single inheritance, aggregation, and arrays of objects.</li>
-<LI>
+<li>
Classes have independent name spaces for their methods: methods are only
visible in the context of a class or object. Methods can be overridden
or added in subclasses; there is no fixed limit on the number of methods
-of a class or subclass.</LI>
+of a class or subclass.</li>
-<LI>
+<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>
+instantiate.</li>
-<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 an instance of the structure. The <I>ref object</I>
+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>
+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><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
+<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><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
-class (only <TT>OBJECT</TT> and <TT>METACLASS</TT> have this property)</LI>
+three elements:
+<ul>
+<li>
+The address ( <tt>.CLASS</tt> ) of a parent class, or zero if it's a base
+class (only <tt>OBJECT</tt> and <tt>METACLASS</tt> have this property)</li>
-<LI>
-The size ( <TT>.SIZE</TT> ) in address units of an instance of the class</LI>
+<li>
+The size ( <tt>.SIZE</tt> ) in address units of an instance of the class</li>
-<LI>
-A wordlist ID ( <TT>.WID</TT> ) for the methods of the class</LI>
-</UL>
-In the figure below, <TT>METACLASS</TT> and <TT>OBJECT</TT> are system-supplied
+<li>
+A wordlist ID ( <tt>.WID</tt> ) for the methods of the class</li>
+</ul>
+In the figure below, <tt>METACLASS</tt> and <tt>OBJECT</tt> are system-supplied
classes. The others are contrived to illustrate the relationships among
derived classes, instances, and the two system base classes. The dashed
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
+<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>
+want to twist your brain in knots, you can think of <tt>METACLASS</tt>
as an instance of itself.
-<BR> </TD>
-</TR>
-</TABLE>
-<IMG SRC="ficl_oop.jpg" VSPACE=10 HEIGHT=442 WIDTH=652>
-<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
-<TR>
-<TD>
-<H2>
-<A NAME="ootutorial"></A>Ficl OO Syntax Tutorial</H2>
+<br> </td>
+</tr>
+</table>
+<img SRC="ficl_oop.jpg" VSPACE=10 height=442 width=652>
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h2>
+<a NAME="ootutorial"></a>Ficl OO Syntax Tutorial</h2>
-<H3>
-Introduction</H3>
+<h3>
+Introduction</h3>
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
@@ -680,21 +1027,21 @@
don't realize that they are objects, without sacrificing any robustness
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
+of its payload (instance variable space) 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>,
-and all classes inherit from class <TT>OBJECT</TT>. This is confusing at
+Classes themselves are instances of a special base class called <tt>METACLASS</tt>,
+and all classes inherit from class <tt>OBJECT</tt>. This is confusing at
first, but it means that Ficl has a very simple syntax for constructing
-and using objects. Class methods include subclassing (<TT>SUB</TT>), creating
-initialized and uninitialized instances (<TT>NEW</TT> and <TT>INSTANCE</TT>),
-and creating reference instances (<TT>REF</TT>). Classes also have methods
-for disassembling their methods (<TT>SEE</TT>), identifying themselves
-(<TT>ID</TT>), and listing their pedigree (<TT>PEDIGREE</TT>). All objects
+and using objects. Class methods include subclassing (<tt>SUB</tt>), creating
+initialized and uninitialized instances (<tt>NEW</tt> and <tt>INSTANCE</tt>),
+and creating reference instances (<tt>REF</tt>). Classes also have methods
+for disassembling their methods (<tt>SEE</tt>), identifying themselves
+(<tt>ID</tt>), and listing their pedigree (<tt>PEDIGREE</tt>). All objects
inherit methods for initializing instances and arrays of instances, for
performing array operations, and for getting information about themselves.
-<H3>
-Methods and messages</H3>
+<h3>
+Methods and messages</h3>
Methods are the chunks of code that objects execute in response to messages.
A message is a request to an object for a behavior that the object supports.
When it receives a message, the target object looks up a method that performs
@@ -704,89 +1051,91 @@
(In Ficl, methods are words defined in the context of a class, and messages
are the names of those words.) Ficl classes associate messages with methods
for their instances (a fancy way of saying that each class owns a wordlist).
-Ficl provides a late-binding operator <B><TT>--></TT></B> that sends messages
+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>
+<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>
+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
+<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 pasting
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>,
+with Forth. If not, please see one of the <a href="#links">references</a>,
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>.
+(as set by <tt>ONLY</tt>), type:
+<ul><b><tt>ONLY ( reset to default search order )</tt></b>
+<br><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
+of <tt>METACLASS</tt>, <tt>METACLASS</tt> behaves as if it is an instance
of itself (this is the only class with this property). It pushes the same
-address twice: once for the class and once for the instance variables,
-since they are the same. The next word finds a method in the context of
-a class and executes it. In this case, the name of the method is <TT>methods</TT>.
+address twice: once for the class and once for the payload, since they
+are the same. The next word finds a method in the context of a class and
+executes it. In this case, the name of the method is <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>
-Causes base-class <TT>OBJECT</TT> to derive from itself a new class called
+<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>
-<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>
-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
+<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>
+The first two lines add named instance variables to the class, and create
+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
address of the corresponding instance variable when invoked on an instance
of the class. It's up to you to remember the size of the instance variable
-and manipulate it with the usual Forth words for fetching and storing.
-We've also defined a method called <TT>init</TT> that clears the instance
-variables. Notice that the method expects the addresses of the class and
-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
-default <TT>init</TT> method supplied by class <TT>object</TT> clears the
+and manipulate it with the usual Forth words for fetching and storing (we'll
+see below how to aggregate objects, which do know their size). We've also
+defined a method called <tt>init</tt> that clears the instance variables.
+Notice that the method expects the addresses of the class and 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
+default <tt>init</tt> method supplied by class <tt>object</tt> clears the
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>
+<br>Now make an instance of the new class:
+<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
contains them. The method finder --> uses the class to look up methods.
-You can use this word in a definition, as we did in init, and it performs
-late binding, meaning that the mapping from message (method name) to method
-(the code) is deferred until run-time. To see this, you can decompile the
-init method like this:
-<UL><B><TT>c-foo --> see init</TT></B>
-<BR>or
-<BR><B><TT>foo-instance --> class --> see init</TT></B></UL>
+You can use this word in a definition, as we did in <tt>init</tt>, and
+it performs late binding, meaning that the mapping from message (method
+name) to method (the code) is deferred until run-time. To see this, you
+can decompile the init method like this:
+<ul><b><tt>c-foo --> see init</tt></b>
+<br>or
+<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
@@ -795,1652 +1144,1749 @@
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 <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
+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):
+<ul><b><tt>: new \ ( class metaclass "name" -- )</tt></b>
+<br><b><tt> metaclass => instance --> init ;</tt></b></ul>
+Try this...
+<ul><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
context of whatever class is supplied on the stack at run-time.
-<BR>Notice that the early-binding operator requires a class at compile
-time. For this reason, classes are <TT>IMMEDIATE</TT>, meaning that they
+<br>Notice that the early-binding operator requires a class at compile
+time. For this reason, classes are <tt>IMMEDIATE</tt>, 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.
-<P>As advertised earlier, Ficl provides ways to objectify existing data
+<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,
-supplying the address of the structure. After that, the ref instance behaves
-as a Ficl object, but its instance variables take on the values in the
-existing structure. Example (from ficlclass.fr):
-<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>
-<BR><B><TT> wordlist postpone c-wordlist
-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
+that models the structure, and instantiate a <b>ref </b>from this class,
+supplying the address of the structure. After that, the <i>ref instance</i>
+behaves 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>
+<br><b><tt> wordlist postpone c-wordlist
+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>
-<BR><B><TT> wordlist postpone c-wordlist
---> ref ;</TT></B></UL>
+<ul><b><tt>: named-wid ( "name" -- )</tt></b>
+<br><b><tt> wordlist postpone c-wordlist
+--> 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>.
-<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>
+<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.
-In order to initialize an array, the class must define a reasonable <B><TT>init</TT></B>
-method. <B><TT>New-array</TT></B> invokes it on each member of the array
+In order to initialize an array, the class must define (or inherit) a reasonable
+<b><tt>init</tt></b>
+method. <b><tt>New-array</tt></b> invokes it on each member of the array
in sequence from lowest to highest. Array instances and array members use
-the object methods <B><TT>index</TT></B>, <B><TT>next</TT></B>, and <B><TT>prev</TT></B>
-to navigate. Aggregate a member array of objects using <B><TT><A HREF="#arraycolon">array:</A></TT></B>.
+the object methods <b><tt>index</tt></b>, <b><tt>next</tt></b>, and <b><tt>prev</tt></b>
+to navigate. Aggregate a member array of objects using <b><tt><a href="#arraycolon">array:</a></tt></b>.
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
+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.
+<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. </TD>
-</TR>
-</TABLE>
+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>
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h3>
+<a NAME="oopgloss"></a>OOP Glossary</h3>
+Note: with the exception of the binding operators (the first two definitions
+here), all of the words in this section are internal factors that you don't
+need to worry about. 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>
+<dd>
Late binding: looks up and executes the given method in the context of
-the class on top of the stack. </DD>
+the class on top of the stack. </dd>
-<DT>
-<B><TT>=> comp: ( class meta "method-name" -- ) exec:
-( inst class -- xn )</TT></B></DT>
+<dt>
+<b><tt>=> comp: ( class meta "method-name" -- ) exec:
+( inst class -- xn )</tt></b></dt>
-<DD>
+<dd>
Early binding: compiles code to execute the method of the class specified
-at compile time.</DD>
+at compile time.</dd>
-<DT>
-<B><TT>do-do-instance</TT></B></DT>
+<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>
+<dd>
+When executed, causes the instance to push its ( instance class ) stack
+signature. 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. </dd>
-<DT>
-<B><TT>exec-method ( instance class c-addr u -- xn )</TT></B></DT>
+<dt>
+<b><tt>exec-method ( instance class c-addr u -- xn )</tt></b></dt>
-<DD>
+<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>
+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>
+<dt>
+<b><tt>find-method-xt ( class "method-name" -- class xt )</tt></b></dt>
-<DD>
+<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>
+prints an error message and aborts.</dd>
-<DT>
-<B><TT>lookup-method ( class c-addr u -- class xt )</TT></B></DT>
+<dt>
+<b><tt>lookup-method ( class c-addr u -- class xt )</tt></b></dt>
-<DD>
+<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>
+method, prints an error message and aborts.</dd>
-<DT>
-<B><TT>parse-method comp: ( "method-name" -- ) exec:
-( -- c-addr u )</TT></B></DT>
+<dt>
+<b><tt>parse-method comp: ( "method-name" -- ) exec:
+( -- c-addr u )</tt></b></dt>
-<DD>
+<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>
+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>
-<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>
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h3>
+<a NAME="glossinstance"></a>Instance Variable Glossary</h3>
+<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
reserve space in the class template for the instance variable. We'll use
-the term <I>instance variable</I> to refer both to the method that gives
+the term <i>instance variable</i> to refer both to the method that gives
access to a particular field of an object, and to the field itself. Rather
than give esentially the same example over and over, here's one example
-that shows several of the instance variable construction words in use:</DT>
+that shows several of the instance variable construction words in use:</dt>
-<UL>
-<DT>
-<TT>object subclass c-example</TT></DT>
+<ul>
+<dt>
+<tt>object subclass c-example</tt></dt>
-<DT>
-<TT> cell:
-.cell0</TT></DT>
+<dt>
+<tt> cell:
+.cell0</tt></dt>
-<BR><TT> c-4byte obj: .nCells</TT>
-<BR><TT> 4 c-4byte array: .quad</TT>
-<BR><TT> char:
-.length</TT>
-<BR><TT> 79 chars:
-.name</TT>
-<BR><TT>end-class</TT></UL>
+<br><tt> c-4byte obj: .nCells</tt>
+<br><tt> 4 c-4byte array: .quad</tt>
+<br><tt> char:
+.length</tt>
+<br><tt> 79 chars:
+.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,
+from <tt>object</tt>. Each untyped instance variable (.cell0, .length,
.name) pushes its address when executed. Each object instance variable
pushes the address and class of the aggregate object. Similar to C, an
-array instance variable leaves its base address (and its class) when executed.
-<BR>
-<DT>
-<B><TT>cell: ( offset "name"
--- offset' )</TT></B></DT>
+array instance variable leaves its base address (and its class) when executed.
+The word <tt>subclass</tt> is shorthand for "<tt>--> sub</tt>"
+<br>
+<dt>
+<b><tt>cell: ( offset "name"
+-- offset' )</tt></b></dt>
-<DT>
-<B><TT>
-Execution: ( -- cell-addr )</TT></B></DT>
+<dt>
+<b><tt>
+Execution: ( -- cell-addr )</tt></b></dt>
-<DL>
-<DD>
+<dl>
+<dd>
Create an untyped instance variable one cell wide. The instance variable
-leaves its payload's address when executed. </DD>
+leaves its payload's address when executed. </dd>
-<DT>
-<B><TT>cells: ( offset nCells "name"
--- offset' )</TT></B></DT>
+<dt>
+<b><tt>cells: ( offset nCells "name"
+-- offset' )</tt></b></dt>
-<DT>
-<B><TT>
-Execution: ( -- cell-addr )</TT></B></DT>
+<dt>
+<b><tt>
+Execution: ( -- cell-addr )</tt></b></dt>
-<DD>
-Create an untyped instance variable n cells wide.</DD>
+<dd>
+Create an untyped instance variable n cells wide.</dd>
-<DT>
-<B><TT>char: ( offset "name"
--- offset' )</TT></B></DT>
+<dt>
+<b><tt>char: ( offset "name"
+-- offset' )</tt></b></dt>
-<DT>
-<B><TT>
-Execution: ( -- char-addr )</TT></B></DT>
+<dt>
+<b><tt>
+Execution: ( -- char-addr )</tt></b></dt>
-<DD>
-Create an untyped member variable one char wide</DD>
+<dd>
+Create an untyped member variable one char wide</dd>
-<DT>
-<B><TT>chars: ( offset nChars "name"
--- offset' )</TT></B></DT>
+<dt>
+<b><tt>chars: ( offset nChars "name"
+-- offset' )</tt></b></dt>
-<DT>
-<B><TT>
-Execution: ( -- char-addr )</TT></B></DT>
+<dt>
+<b><tt>
+Execution: ( -- char-addr )</tt></b></dt>
-<DD>
-Create an untyped member variable n chars wide.</DD>
+<dd>
+Create an untyped member variable n chars wide.</dd>
-<DT>
-<B><TT>obj: ( offset class
-meta "name" -- offset' )</TT></B></DT>
+<dt>
+<b><tt>obj: ( offset class
+meta "name" -- offset' )</tt></b></dt>
-<DT>
-<B><TT>
-Execution: ( -- instance class )</TT></B></DT>
+<dt>
+<b><tt>
+Execution: ( -- instance class )</tt></b></dt>
-<DT>
-Aggregate an uninitialized instance of class as a member variable of the
-class under construction.<A NAME="arraycolon"></A><B><TT>array:
-( offset n class meta "name" -- offset' )</TT></B></DT>
+<dd>
+Aggregate an uninitialized instance of <b>class</b> as a member variable
+of the class under construction.</dd>
-<DT>
-<B><TT>
-Execution: ( -- instance class )</TT></B></DT>
+<dt>
+<a NAME="arraycolon"></a><b><tt>array:
+( offset n class meta "name" -- offset' )</tt></b></dt>
-<DD>
+<dt>
+<b><tt>
+Execution: ( -- instance class )</tt></b></dt>
+
+<dd>
Aggregate an uninitialized array of instances of the class specified as
-a member variable of the class under construction.</DD>
+a member variable of the class under construction.</dd>
-<DT>
-<A NAME="exampleref:"></A><B><TT>ref:
-( offset class meta "name" -- offset' )</TT></B></DT>
+<dt>
+<a NAME="exampleref:"></a><b><tt>ref:
+( offset class meta "name" -- offset' )</tt></b></dt>
-<DT>
-<B><TT>
-Execution: ( -- ref-instance ref-class )</TT></B></DT>
+<dt>
+<b><tt>
+Execution: ( -- ref-instance ref-class )</tt></b></dt>
-<DD>
+<dd>
Aggregate a reference to a class instance. There is no way to set the value
of an aggregated ref - it's meant as a way to manipulate existing data
structures with a Ficl OO model. For example, if your system contains a
linked list of 4 byte quantities, you can make a class that represents
-a list element like this: </DD>
+a list element like this: </dd>
-<DL>
-<DD>
-<TT>object subclass c-4list</TT></DD>
+<dl>
+<dd>
+<tt>object subclass c-4list</tt></dd>
-<DD>
-<TT>c-4list ref: .link</TT></DD>
+<dd>
+<tt>c-4list ref: .link</tt></dd>
-<DD>
-<TT>c-4byte obj: .payload</TT></DD>
+<dd>
+<tt>c-4byte obj: .payload</tt></dd>
-<DD>
-<TT>end-class;</TT></DD>
+<dd>
+<tt>end-class;</tt></dd>
-<DD>
-<TT>address-of-existing-list c-4list --> ref mylist</TT></DD>
-</DL>
+<dd>
+<tt>address-of-existing-list c-4list --> ref mylist</tt></dd>
+</dl>
-<DD>
+<dd>
The last line binds the existing structure to an instance of the class
we just created. The link method pushes the link value and the class c_4list,
so that the link looks like an object to Ficl and like a struct to C (it
-doesn;t carry any extra baggage for the object model - the Ficl methods
-alone take care of storing the class information). </DD>
+doesn't carry any extra baggage for the object model - the Ficl methods
+alone take care of storing the class information). </dd>
-<DD>
+<dd>
Note: Since a ref: aggregate can only support one class, it's good for
modeling static structures, but not appropriate for polymorphism. If you
want polymorphism, aggregate a c_ref (see classes.fr for source) into your
-class - it has methods to set and get an object.</DD>
+class - it has methods to set and get an object.</dd>
-<DD>
+<dd>
By the way, it is also possible to construct a pair of classes that contain
-aggregate pointers to each other. Here's a rough example:</DD>
+aggregate pointers to each other. Here's a rough example:</dd>
-<DL>
-<DD>
-<TT>object subclass c-fee</TT></DD>
+<dl>
+<dd>
+<tt>object subclass c-fee</tt></dd>
-<DD>
-<TT>object subclass c-fie</TT></DD>
+<dd>
+<tt>object subclass c-fie</tt></dd>
-<DD>
-<TT> c-fee ref: .fee</TT></DD>
+<dd>
+<tt> c-fee ref: .fee</tt></dd>
-<DD>
-<TT>end-class \ done with
-c-fie</TT></DD>
+<dd>
+<tt>end-class \ done with
+c-fie</tt></dd>
-<DD>
-<TT> c-fie ref: .fie</TT></DD>
+<dd>
+<tt> c-fie ref: .fie</tt></dd>
-<BR><TT>end-class
-\ done with c-fee</TT></DL>
-</DL>
-</TD>
-</TR>
-</TABLE>
+<br><tt>end-class
+\ done with c-fee</tt></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
+<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
-class )</TT></B> </DT>
+<dl>
+<dt>
+<b><tt>instance ( class metaclass "name" -- instance
+class )</tt></b> </dt>
-<DD>
+<dd>
Create an uninitialized instance of the class, giving it the name specified.
The method leaves the instance 's signature on the stack (handy if you
-want to initialize). Example:</DD>
+want to initialize). Example:</dd>
-<DD>
-<TT>c_ref --> instance uninit-ref 2drop</TT></DD>
+<dd>
+<tt>c_ref --> instance uninit-ref 2drop</tt></dd>
-<DT>
-<B><TT>new ( class
-metaclass "name" -- )</TT></B> </DT>
+<dt>
+<b><tt>new ( class
+metaclass "name" -- )</tt></b> </dt>
-<DD>
+<dd>
Create an initialized instance of class, giving it the name specified.
-This method calls init to perform initialization. </DD>
+This method calls init to perform initialization. </dd>
-<DT>
-<B><TT>array ( nObj class metaclass
-"name" -- nObjs instance class )</TT></B> </DT>
+<dt>
+<b><tt>array ( nObj class metaclass
+"name" -- nObjs instance class )</tt></b> </dt>
-<DD>
+<dd>
Create an array of nObj instances of the specified class. Instances are
-not initialized. Example:</DD>
+not initialized. Example:</dd>
-<DD>
-<TT>10 c_4byte --> array 40-raw-bytes 2drop drop</TT></DD>
+<dd>
+<tt>10 c_4byte --> array 40-raw-bytes 2drop drop</tt></dd>
-<DT>
-<B><TT>new-array ( nObj class metaclass "name" -- )</TT></B> </DT>
+<dt>
+<b><tt>new-array ( nObj class metaclass "name" -- )</tt></b> </dt>
-<DD>
+<dd>
Creates an initialized array of nObj instances of the class. Same syntax
-as <TT>array</TT></DD>
+as <tt>array</tt></dd>
-<DT>
-<B><TT>ref ( instance-addr
-class metaclass "name" -- )</TT></B> </DT>
+<dt>
+<a NAME="alloc"></a><b><tt>alloc ( class metaclass -- instance
+class )</tt></b></dt>
-<DD>
+<dd>
+Creates an anonymous instance of <b>class</b> from the heap (using a call
+to ficlMalloc() to get the memory). Leaves the payload and class addresses
+on the stack. Usage example:</dd>
+
+<dd>
+<tt>c-ref --> alloc 2constant instance-of-ref</tt></dd>
+
+<dd>
+Creates a double-cell constant that pushes the payload and class address
+of a heap instance of c-ref.</dd>
+
+<dt>
+<a NAME="allocarray"></a><b><tt>alloc-array ( nObj class metaclass
+-- instance class )</tt></b></dt>
+
+<dd>
+Same as new-array, but creates anonymous instances from the heap using
+a call to ficlMalloc(). Each instance is initialized using the class's
+<tt>init</tt>
+method</dd>
+
+<dt>
+<b><tt>ref ( instance-addr
+class metaclass "name" -- )</tt></b> </dt>
+
+<dd>
Make a ref instance of the class that points to the supplied instance address.
No new instance space is allotted. Instead, the instance refers to the
address supplied on the stack forever afterward. For wrapping existing
-structures.</DD>
-</DL>
+structures.</dd>
+</dl>
-<DL>
-<DT>
-<B><TT>sub ( class
-metaclass -- old-wid addr[size] size )</TT></B></DT>
+<dl>
+<dt>
+<b><tt>sub ( class
+metaclass -- old-wid addr[size] size )</tt></b></dt>
-<DD>
+<dd>
Derive a subclass. You can add or override methods, and add instance variables.
-Alias: <TT>subclass</TT>. Examples:</DD>
+Alias: <tt>subclass</tt>. Examples:</dd>
-<DL>
-<DD>
-<TT>c_4byte --> sub c_special4byte</TT></DD>
+<dl>
+<dd>
+<tt>c_4byte --> sub c_special4byte</tt></dd>
-<DD>
-<TT>( your new methods and instance variables here )</TT></DD>
+<dd>
+<tt>( your new methods and instance variables here )</tt></dd>
-<DD>
-<TT>end-class</TT></DD>
+<dd>
+<tt>end-class</tt></dd>
-<DD>
-or</DD>
+<dd>
+or</dd>
-<DD>
-<TT>c_4byte subclass c_special4byte</TT></DD>
+<dd>
+<tt>c_4byte subclass c_special4byte</tt></dd>
-<DD>
-<TT>( your new methods and instance variables here )</TT></DD>
+<dd>
+<tt>( your new methods and instance variables here )</tt></dd>
-<DD>
-<TT>end-class</TT></DD>
-</DL>
+<dd>
+<tt>end-class</tt></dd>
+</dl>
-<DT>
-<B><TT>.size ( class metaclass
--- instance-size )</TT></B> </DT>
+<dt>
+<b><tt>.size ( class metaclass
+-- instance-size )</tt></b> </dt>
-<DD>
+<dd>
Returns address of the class's instance size field, in address units. This
-is a metaclass member variable.</DD>
+is a metaclass member variable.</dd>
-<DT>
-<B><TT>.super ( class metaclass --
-superclass )</TT></B> </DT>
+<dt>
+<b><tt>.super ( class metaclass --
+superclass )</tt></b> </dt>
-<DD>
+<dd>
Returns address of the class's superclass field. This is a metaclass member
-variable.</DD>
+variable.</dd>
-<DT>
-<B><TT>.wid ( class metaclass
--- wid )</TT></B> </DT>
+<dt>
+<b><tt>.wid ( class metaclass
+-- wid )</tt></b> </dt>
-<DD>
+<dd>
Returns the address of the class's wordlist ID field. This is a metaclass
-member variable.</DD>
+member variable.</dd>
-<DT>
-<B><TT>get-size</TT></B></DT>
+<dt>
+<b><tt>get-size</tt></b></dt>
-<DD>
+<dd>
Returns the size of an instance of the class in address units. Imeplemented
-as</DD>
+as</dd>
-<DD>
-<TT>: get-size metaclass => .size @ ;</TT></DD>
+<dd>
+<tt>: get-size metaclass => .size @ ;</tt></dd>
-<DT>
-<B><TT>get-wid</TT></B></DT>
+<dt>
+<b><tt>get-wid</tt></b></dt>
-<DD>
-Returns the wordlist ID of the class. Implemented as </DD>
+<dd>
+Returns the wordlist ID of the class. Implemented as </dd>
-<DD>
-<TT>: get-wid metaclass => .wid @ ;</TT></DD>
+<dd>
+<tt>: get-wid metaclass => .wid @ ;</tt></dd>
-<DT>
-<B><TT>get-super</TT></B></DT>
+<dt>
+<b><tt>get-super</tt></b></dt>
-<DD>
-Returns the class's superclass. Implemented as</DD>
+<dd>
+Returns the class's superclass. Implemented as</dd>
-<DD>
-<TT>: get-super metaclass => .super @ ;</TT></DD>
+<dd>
+<tt>: get-super metaclass => .super @ ;</tt></dd>
-<DT>
-<B><TT>id (
-class metaclass -- c-addr u )</TT></B> </DT>
+<dt>
+<b><tt>id (
+class metaclass -- c-addr u )</tt></b> </dt>
-<DD>
-Returns the address and length of a string that names the class.</DD>
+<dd>
+Returns the address and length of a string that names the class.</dd>
-<DT>
-<B><TT>methods ( class metaclass -- )</TT></B> </DT>
+<dt>
+<b><tt>methods ( class metaclass -- )</tt></b> </dt>
-<DD>
-Lists methods of the class and all its superclasses</DD>
+<dd>
+Lists methods of the class and all its superclasses</dd>
-<DT>
-<B><TT>offset-of ( class metaclass "name" -- offset )</TT></B></DT>
+<dt>
+<b><tt>offset-of ( class metaclass "name" -- offset )</tt></b></dt>
-<DD>
+<dd>
Pushes the offset from the instance base address of the named member variable.
If the name is not that of an instance variable method, you get garbage.
-There is presently no way to detect this error. Example:</DD>
+There is presently no way to detect this error. Example:</dd>
-<DL>
-<DD>
-<TT>metaclass --> offset-of .wid</TT></DD>
-</DL>
+<dl>
+<dd>
+<tt>metaclass --> offset-of .wid</tt></dd>
+</dl>
-<DT>
-<B><TT>pedigree ( class metaclass -- )</TT></B> </DT>
+<dt>
+<b><tt>pedigree ( class metaclass -- )</tt></b> </dt>
-<DD>
-Lists the pedigree of the class (inheritance trail)</DD>
+<dd>
+Lists the pedigree of the class (inheritance trail)</dd>
-<DT>
-<B><TT>see ( class
-metaclass "name" -- )</TT></B> </DT>
+<dt>
+<b><tt>see ( class
+metaclass "name" -- )</tt></b> </dt>
-<BR>Decompiles the specified method - obect version of <TT>SEE</TT>, from
-the <TT>TOOLS</TT> wordset.</DL>
-</TD>
-</TR>
-</TABLE>
+<dd>
+Decompiles the specified method - obect version of <tt>SEE</tt>, from the
+<tt>TOOLS</tt>
+wordset.</dd>
+</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.
+<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
+<tt>object</tt>.
The methods include default initialization, array manipulations, aliases
of class methods, upcasting, and programming tools.
-<DL>
-<DT>
-<B><TT>init ( instance
-class -- )</TT> </B></DT>
+<dl>
+<dt>
+<b><tt>init ( instance
+class -- )</tt> </b></dt>
-<DD>
+<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>
+<dt>
+<b><tt>array-init ( nObj instance class -- )</tt></b> </dt>
-<DD>
-Applies <TT>init</TT> to an array of objects created by <TT>new-array</TT>.
-Note that <TT>array:</TT> does not cause aggregate arrays to be initialized
-automatically. You do not normally need to invoke <TT>array-init</TT> explicitly.</DD>
+<dd>
+Applies <tt>init</tt> to an array of objects created by <tt>new-array</tt>.
+Note that <tt>array:</tt> does not cause aggregate arrays to be initialized
+automatically. You do not normally need to invoke <tt>array-init</tt> explicitly.</dd>
-<DT>
-<B><TT>class ( instance class
--- class metaclass )</TT></B> </DT>
+<dt>
+<a NAME="oofree"></a><b><tt>free ( instance class -- )</tt></b></dt>
-<DD>
+<dd>
+Releases memory used by an instance previously created with <tt>alloc</tt>
+or <tt>alloc-array</tt>. Note - this method is not presently protected
+against accidentally deleting something from the dictionary. If you do
+this, Bad Things are likely to happen. Be careful for the moment to apply
+free only to instances created with <tt>alloc</tt> or <tt>alloc-array</tt>.</dd>
+
+<dt>
+<b><tt>class ( instance class
+-- class metaclass )</tt></b> </dt>
+
+<dd>
Convert an object signature into that of its class. Useful for calling
-class methods that have no object aliases.</DD>
+class methods that have no object aliases.</dd>
-<DT>
-<B><TT>super ( instance class
--- instance parent-class )</TT></B> </DT>
+<dt>
+<b><tt>super ( instance class
+-- instance parent-class )</tt></b> </dt>
-<DD>
-Upcast an object to its parent class. The parent class of <TT>object</TT>
-is zero. Useful for invoking an overridden parent class method.</DD>
+<dd>
+Upcast an object to its parent class. The parent class of <tt>object</tt>
+is zero. Useful for invoking an overridden parent class method.</dd>
-<DT>
-<B><TT>pedigree ( instance class -- )</TT></B> </DT>
+<dt>
+<b><tt>pedigree ( instance class -- )</tt></b> </dt>
-<DD>
+<dd>
Display an object's pedigree - its chain of inheritance. This is an alias
-for the corresponding class method.</DD>
+for the corresponding class method.</dd>
-<DT>
-<B><TT>size ( instance
-class -- sizeof(instance) )</TT></B> </DT>
+<dt>
+<b><tt>size ( instance
+class -- sizeof(instance) )</tt></b> </dt>
-<DD>
+<dd>
Returns the size, in address units, of one instance. Does not know about
-arrays! This is an alias for the class method <TT>get-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>
+<dt>
+<b><tt>methods ( instance class -- )</tt></b> </dt>
-<DD>
+<dd>
Class method alias. Displays the list of methods of the class and all superclasses
-of the instance.</DD>
+of the instance.</dd>
-<DT>
-<B><TT>index ( n instance class
--- instance[n] class )</TT></B> </DT>
+<dt>
+<b><tt>index ( n instance class
+-- instance[n] class )</tt></b> </dt>
-<DD>
+<dd>
Convert array-of-objects base signature into signature for array element
-n. No check for bounds overflow. Index is zero-based, like C, so </DD>
+n. No check for bounds overflow. Index is zero-based, like C, so </dd>
-<DL>
-<DD>
-<TT>0 my-obj --> index</TT> </DD>
-</DL>
+<dl>
+<dd>
+<tt>0 my-obj --> index</tt> </dd>
+</dl>
-<DD>
-is equivalent to </DD>
+<dd>
+is equivalent to </dd>
-<DL>
-<DD>
-<TT>my-obj</TT></DD>
-</DL>
+<dl>
+<dd>
+<tt>my-obj</tt></dd>
+</dl>
-<DD>
-Check out the <A HREF="#minusrot">description of <TT>-ROT</TT></A> for
-help in dealing with indices on the stack.</DD>
+<dd>
+Check out the <a href="#minusrot">description of <tt>-ROT</tt></a> for
+help in dealing with indices on the stack.</dd>
-<DT>
-<B><TT>next ( instance[n]
-class -- instance[n+1] class )</TT></B> </DT>
+<dt>
+<b><tt>next ( instance[n]
+class -- instance[n+1] class )</tt></b> </dt>
-<DD>
+<dd>
Convert an array-object signature into the signature of the next
-object in the array. No check for bounds overflow.</DD>
+object in the array. No check for bounds overflow.</dd>
-<DT>
-<B><TT>prev ( instance[n]
-class -- instance[n-1] class )</TT></B> </DT>
+<dt>
+<b><tt>prev ( instance[n]
+class -- instance[n-1] class )</tt></b> </dt>
-<BR>Convert an object signature into the signature of the previous object
-in the array. No check for bounds underflow.</DL>
-</TD>
-</TR>
-</TABLE>
+<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>
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<h3>
+<a NAME="stockclasses"></a>Supplied Classes (See classes.fr)</h3>
-<DL>
-<DT>
-<B><TT>metaclass </TT></B></DT>
+<dl>
+<dt>
+<b><tt>metaclass </tt></b></dt>
-<DD>
+<dd>
Describes all classes of Ficl. Contains class methods. Should never be
directly instantiated or subclassed. Defined in oo.fr. Methods described
-above.</DD>
+above.</dd>
-<DT>
-<B><TT>object</TT> </B></DT>
+<dt>
+<b><tt>object</tt> </b></dt>
-<DD>
+<dd>
Mother of all Ficl objects. Defines default initialization and array indexing
-methods. Defined in oo.fr. Methods described above.</DD>
+methods. Defined in oo.fr. Methods described above.</dd>
-<DT>
-<B><TT>c-ref</TT> </B></DT>
+<dt>
+<b><tt>c-ref</tt> </b></dt>
-<DD>
+<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>
+members: </dd>
-<DD>
-<TT>get ( inst class -- ref-inst ref-class )</TT></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>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>.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>
+<dd>
+<tt>.class ( inst class -- a-addr ) </tt>cell member that holds
+the class</dd>
-<DT>
-<B><TT>c-byte </TT></B></DT>
+<dt>
+<b><tt>c-byte </tt></b></dt>
-<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>
+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>get ( inst class -- c )</tt></dd>
-<DD>
-<TT>set ( c inst class -- )</TT></DD>
+<dd>
+<tt>set ( c inst class -- )</tt></dd>
-<DD>
-<TT>.payload ( inst class -- addr ) </TT>member holds instance's
-value</DD>
+<dd>
+<tt>.payload ( inst class -- addr ) </tt>member holds instance's
+value</dd>
-<DT>
-<B><TT>c-2byte</TT></B> </DT>
+<dt>
+<b><tt>c-2byte</tt></b> </dt>
-<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>
+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>get ( inst class -- 2byte )</tt></dd>
-<DD>
-<TT>set ( 2byte inst class -- )</TT></DD>
+<dd>
+<tt>set ( 2byte inst class -- )</tt></dd>
-<DD>
-<TT>.payload ( inst class -- addr ) </TT>member holds instance's
-value</DD>
+<dd>
+<tt>.payload ( inst class -- addr ) </tt>member holds instance's
+value</dd>
-<DT>
-<B><TT>c-4byte</TT></B> </DT>
+<dt>
+<b><tt>c-4byte</tt></b> </dt>
-<DD>
-Primitive class derived from <TT>object</TT>, with a 4-byte (cell) payload.
+<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>
+members:</dd>
-<DD>
-<TT>get ( inst class -- x )</TT></DD>
+<dd>
+<tt>get ( inst class -- x )</tt></dd>
-<DD>
-<TT>set ( x inst class -- )</TT></DD>
+<dd>
+<tt>set ( x inst class -- )</tt></dd>
-<DD>
-<TT>.payload ( inst class -- addr ) </TT>member holds instance's
-value</DD>
+<dd>
+<tt>.payload ( inst class -- addr ) </tt>member holds instance's
+value</dd>
-<DT>
-<B><TT>c-ptr</TT></B></DT>
+<dt>
+<b><tt>c-ptr</tt></b></dt>
-<DD>
-Base class derived from <TT>object</TT> for pointers to non-object types.
+<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>
+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>.addr ( inst class -- a-addr )</tt> member variable - holds
+the pointer address</dd>
-<DD>
-<TT>get-ptr ( inst class -- ptr )</TT></DD>
+<dd>
+<tt>get-ptr ( inst class -- ptr )</tt></dd>
-<DD>
-<TT>set-ptr ( ptr inst class -- )</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>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>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>
+<dd>
+<tt>index-ptr ( i inst class -- )</tt> Adds i*@size to pointer
+address</dd>
-<DT>
-<B><TT>c-bytePtr</TT></B></DT>
+<dt>
+<b><tt>c-bytePtr</tt></b></dt>
-<DD>
-Pointer to byte derived from c-ptr. Methods & members:</DD>
+<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>@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>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>
+<dd>
+<tt>set ( c inst class -- ) </tt>Store c at the pointer address</dd>
-<DT>
-<B><TT>c-2bytePtr</TT></B></DT>
+<dt>
+<b><tt>c-2bytePtr</tt></b></dt>
-<DD>
-Pointer to double byte derived from c-ptr. Methods & members:</DD>
+<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>@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>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>
+<dd>
+<tt>set ( x inst class -- )</tt> Store 2byte x at the pointer
+address</dd>
-<DT>
-<B><TT>c-cellPtr</TT></B></DT>
+<dt>
+<b><tt>c-cellPtr</tt></b></dt>
-<DD>
-Pointer to cell derived from c-ptr. Methods & members:</DD>
+<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>@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>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>
+<dd>
+<tt>set ( x inst class -- )</tt> Storex at the pointer address</dd>
-<DT>
-<B><TT>c-string</TT></B> </DT>
+<dt>
+<b><tt>c-string</tt></b> </dt>
-<DD>
-Counted string (thin)</DD>
-</DL>
-</TD>
-</TR>
-</TABLE>
+<dd>
+Counted string (thin)</dd>
+</dl>
+</td>
+</tr>
+</table>
-<H2>
+<h2>
-<HR WIDTH="100%"></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>
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<td>
+<dl>
+<h2>
+<a NAME="extras"></a>Ficl extras</h2>
-<H3>
-Number syntax</H3>
+<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>
-<BR><TT>291 </TT></DL>
+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>
+<br><tt>291 </tt></dl>
-<H3>
-Search order words</H3>
-Note: Ficl resets the search order whenever it does <TT>ABORT</TT>. If
+<h3>
+Search order words</h3>
+Note: Ficl resets the search order whenever it does <tt>ABORT</tt>. If
you don't like this behavior, just comment out the dictResetSearchOrder()
-line in ficlExec().
-<BR>
-<DT>
-<A NAME="tosearch"></A><TT>>search ( wid -- )</TT></DT>
+lines in ficlExec().
+<br>
+<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
-words are written in terms of the <TT>SEARCH></TT> and <TT>>SEARCH</TT>
-primitives.</DD>
+<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>
+primitives.</dd>
-<DT>
-<A NAME="searchfrom"></A><TT>search> ( -- wid )</TT></DT>
+<dt>
+<a NAME="searchfrom"></a><tt>search> ( -- wid )</tt></dt>
-<DD>
-Pop <TT>wid</TT> off the search order</DD>
+<dd>
+Pop <tt>wid</tt> off the search order</dd>
-<DT>
-<A NAME="ficlsetcurrent"></A><TT>ficl-set-current ( wid --
-old-wid )</TT></DT>
+<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>
+<dd>
+Set wid as compile wordlist, leaving the previous compile wordlist on the
+stack</dd>
-<DT>
-<A NAME="ficlvocabulary"></A><TT>ficl-vocabulary ( nBins "name"
--- )</TT></DT>
+<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>
+<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>
+when executed)</dd>
-<DT>
-<A NAME="ficlwordlist"></A><TT>ficl-wordlist ( nBins -- wid
-)</TT></DT>
+<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>
+<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>
+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>
+<dt>
+<a NAME="ficlforgetwid"></a><tt>forget-wid ( wid -- )</tt></dt>
-<DD>
+<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>
+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>
+<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
+<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>
+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>
+<dt>
+<a NAME="ficlhidden"></a><tt>hidden ( -- wid )</tt></dt>
-<DD>
+<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>
+see what's in there, try: <b><tt>hide words previous set-current</tt></b></dd>
-<DT>
-<TT>wid-set-super ( wid -- )</TT></DT>
+<dt>
+<tt>wid-set-super ( wid -- )</tt></dt>
-<DD>
+<dd>
Ficl wordlists have a parent wordlist pointer that is not specified in
standard Forth. Ficl initializes this pointer to NULL whenever it creates
a wordlist, so it ordinarily has no effect. This word sets the parent pointer
to the wordlist specified on the top of the stack. Ficl's implementation
-of <TT>SEARCH-WORDLIST</TT> will chain backward through the parent link
+of <tt>SEARCH-WORDLIST</tt> will chain backward through the parent link
of the wordlist when searching. This simplifies Ficl's object model in
that the search order does not need to reflect an object's class hierarchy
when searching for a method. It is possible to implement Ficl object syntax
in strict ANS Forth, but method finders need to manipulate the search order
-explicitly.</DD>
-</DL>
+explicitly.</dd>
+</dl>
-<H3>
-User variables</H3>
+<h3>
+User variables</h3>
-<DL>
-<DT>
-<TT>user ( -- ) name</TT></DT>
+<dl>
+<dt>
+<tt>user ( -- ) name</tt></dt>
-<DD>
+<dd>
Create a user variable with the given name. User variables are virtual
machine local. Each VM allocates a fixed amount of storage for them. You
can change the maximum number of user variables allowed by defining FICL_USER_CELLS
-on your compiiler's command line. Default is 16 user cells.</DD>
-</DL>
+on your compiiler's command line. Default is 16 user cells.</dd>
+</dl>
-<H3>
-Miscellaneous</H3>
+<h3>
+Miscellaneous</h3>
-<DL>
-<DT>
-<TT>-roll ( xu xu-1 ... x0 u -- x0 xu-1 ... x1 ) </TT></DT>
+<dl>
+<dt>
+<tt>-roll ( xu xu-1 ... x0 u -- x0 xu-1 ... x1 ) </tt></dt>
-<DD>
+<dd>
Rotate u+1 items on top of the stack after removing u. Rotation is in the
-opposite sense to <TT>ROLL</TT></DD>
-</DL>
+opposite sense to <tt>ROLL</tt></dd>
+</dl>
-<DL>
-<DT>
-<A NAME="minusrot"></A><TT>-rot ( a b c -- c a b )</TT></DT>
+<dl>
+<dt>
+<a NAME="minusrot"></a><tt>-rot ( a b c -- c a b )</tt></dt>
-<DD>
+<dd>
Rotate the top three stack entries, moving the top of stack to third place.
-I like to think of this as <TT>1<SUP>1</SUP>/<SUB>2</SUB>swap</TT> because
-it's good for tucking a single cell value behind a cell-pair (like an object). </DD>
-</DL>
+I like to think of this as <tt>1<sup>1</sup>/<sub>2</sub>swap</tt> because
+it's good for tucking a single cell value behind a cell-pair (like an object). </dd>
+</dl>
-<DL>
-<DT>
-<TT>.env ( -- )</TT></DT>
+<dl>
+<dt>
+<tt>.env ( -- )</tt></dt>
-<DD>
-List all environment variables of the system</DD>
+<dd>
+List all environment variables of the system</dd>
-<DT>
-<TT>.hash ( -- )</TT></DT>
+<dt>
+<tt>.hash ( -- )</tt></dt>
-<DD>
+<dd>
List hash table performance statistics of the wordlist that's first in
-the search order</DD>
+the search order</dd>
-<DT>
-<TT>.ver ( -- )</TT></DT>
+<dt>
+<tt>.ver ( -- )</tt></dt>
-<DD>
-Display ficl version ID</DD>
+<dd>
+Display ficl version ID</dd>
-<DT>
-<TT>>name ( xt -- c-addr u )</TT></DT>
+<dt>
+<tt>>name ( xt -- c-addr u )</tt></dt>
-<DD>
-Convert a word's execution token into the address and length of its name</DD>
+<dd>
+Convert a word's execution token into the address and length of its name</dd>
-<DT>
-<TT>body> ( a-addr -- xt )</TT></DT>
+<dt>
+<tt>body> ( a-addr -- xt )</tt></dt>
-<DD>
-Reverses the effect of <TT>CORE</TT> word <TT>>body</TT></DD>
+<dd>
+Reverses the effect of <tt>CORE</tt> word <tt>>body </tt>(converts a parameter
+field address to an execution token)</dd>
-<DT>
-<TT>compile-only</TT></DT>
+<dt>
+<tt>compile-only</tt></dt>
-<DD>
+<dd>
Mark the most recently defined word as being executable only while in compile
-state. Many immediate words have this property.</DD>
+state. Many <tt>immediate</tt> words have this property.</dd>
-<DT>
-<TT>empty ( -- )</TT> </DT>
+<dt>
+<tt>empty ( -- )</tt> </dt>
-<DD>
-Empty the parameter stack</DD>
+<dd>
+Empty the parameter stack</dd>
-<DT>
-<TT>endif</TT></DT>
+<dt>
+<tt>endif</tt></dt>
-<DD>
-Synonym for <TT>THEN</TT></DD>
+<dd>
+Synonym for <tt>THEN</tt></dd>
-<DT>
-<TT>parse-word ( <spaces>name -- c-addr u )</TT></DT>
+<dt>
+<tt>parse-word ( <spaces>name -- c-addr u )</tt></dt>
-<DD>
+<dd>
Skip leading spaces and parse name delimited by a space. c-addr is the
address within the input buffer and u is the length of the selected string.
-If the parse area is empty, the resulting string has a zero length</DD>
+If the parse area is empty, the resulting string has a zero length. (From
+the Standard)</dd>
-<DT>
-<TT>w@ ( addr -- x )</TT></DT>
+<dt>
+<tt>w@ ( addr -- x )</tt></dt>
-<DD>
-Fetch a 16 bit quantity from the specified address</DD>
+<dd>
+Fetch a 16 bit quantity from the specified address</dd>
-<DT>
-<TT>w! ( x addr -- )</TT></DT>
+<dt>
+<tt>w! ( x addr -- )</tt></dt>
-<DD>
+<dd>
Store a 16 bit quantity to the specified address (the low 16 bits of the
-given value)</DD>
+given value)</dd>
-<DT>
-<TT>x. ( x -- )</TT></DT>
+<dt>
+<tt>x. ( x -- )</tt></dt>
-<DD>
+<dd>
Pop and display the value in hex format, regardless of the current value
-of <TT>BASE</TT></DD>
-</DL>
+of <tt>BASE</tt></dd>
+</dl>
-<H3>
-FiclWin Extras (defined in testmain.c)</H3>
+<h3>
+FiclWin Extras (defined in testmain.c)</h3>
-<DL>
-<DT>
-<TT>break ( -- )</TT></DT>
+<dl>
+<dt>
+<tt>break ( -- )</tt></dt>
-<DD>
-Does nothing - just a handy place to set a debugger breakpoint</DD>
+<dd>
+Does nothing - just a handy place to set a debugger breakpoint</dd>
-<DT>
-<TT>cd ( "directory-name<newline>" --
-)</TT></DT>
+<dt>
+<tt>cd ( "directory-name<newline>" --
+)</tt></dt>
-<DD>
-Executes the Win32 chdir() function, changing the program's logged directory.</DD>
+<dd>
+Executes the Win32 chdir() function, changing the program's logged directory.</dd>
-<DT>
-<A NAME="ficlload"></A><TT>load ( "filename<newline>"
--- )</TT></DT>
+<dt>
+<a NAME="clock"></a><tt>clock ( -- now )</tt></dt>
-<DD>
+<dd>
+Wrapper for the ANSI C clock() function. Returns the number of clock ticks
+elapsed since process start.</dd>
+
+<dt>
+<a NAME="clockspersec"></a><tt>clocks/sec ( -- clocks_per_sec
+)</tt></dt>
+
+<dd>
+Pushes the number of ticks in a second as returned by <tt>clock</tt></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>
+like <tt>INCLUDED (FILE)</tt></dd>
-<DT>
-<TT>pwd ( -- )</TT></DT>
+<dt>
+<tt>pwd ( -- )</tt></dt>
-<DD>
-Prints the current working directory as set by <TT>cd</TT></DD>
+<dd>
+Prints the current working directory as set by <tt>cd</tt></dd>
-<DT>
-<TT>system ( "command<newline>" -- )</TT></DT>
+<dt>
+<tt>system ( "command<newline>" -- )</tt></dt>
-<DD>
-Issues a command to a shell; implemented with the Win32 system() call.</DD>
+<dd>
+Issues a command to a shell; implemented with the Win32 system() call.</dd>
-<DT>
-<TT>spewhash ( "filename<newline>" -- )</TT></DT>
+<dt>
+<tt>spewhash ( "filename<newline>" -- )</tt></dt>
-<DD>
+<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>
+attempting to optimize the hash function. I no longer harbor those illusions.</dd>
-<H3>
-FiclWin Exclusives (no source provided)</H3>
+<h3>
+FiclWin Exclusives (no source provided)</h3>
-<DT>
-<TT>!oreg ( c -- )</TT></DT>
+<dt>
+<tt>!oreg ( c -- )</tt></dt>
-<DD>
-Set the value of the simulated LED register as specified (0..255)</DD>
+<dd>
+Set the value of the simulated LED register as specified (0..255)</dd>
-<DT>
-<TT>@ireg ( -- c )</TT></DT>
+<dt>
+<tt>@ireg ( -- c )</tt></dt>
-<DD>
-Gets the value of the simulated switch block (0..255)</DD>
+<dd>
+Gets the value of the simulated switch block (0..255)</dd>
-<DT>
-<TT>!dac ( c -- )</TT></DT>
+<dt>
+<tt>!dac ( c -- )</tt></dt>
-<DD>
+<dd>
Sets the value of the bargraph control as specified. Valid values range
-from 0..255</DD>
+from 0..255</dd>
-<DT>
-<TT>@adc ( -- c )</TT></DT>
+<dt>
+<tt>@adc ( -- c )</tt></dt>
-<DD>
-Fetches the current position of the slider control. Range is 0..255</DD>
+<dd>
+Fetches the current position of the slider control. Range is 0..255</dd>
-<DT>
-<TT>status" ( "ccc<quote>" -- )</TT></DT>
+<dt>
+<tt>status" ( "ccc<quote>" -- )</tt></dt>
-<DD>
+<dd>
Set the mainframe window's status line to the text specified, up to the
-first trailing quote character.</DD>
+first trailing quote character.</dd>
-<DT>
-<TT>msec ( u -- )</TT></DT>
+<dt>
+<a NAME="ficlms"></a><tt><a href="http://www.taygeta.com/forth/dpans10.htm#10.6.2.1905">ms</a>
+( u -- )</tt></dt>
-<DD>
+<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>
+specified by the top-of-stack value.</dd>
+</dl>
+</td>
+</tr>
+</table>
-<H2>
+<h2>
-<HR WIDTH="100%"><A NAME="ansinfo"></A>ANS Required Information</H2>
+<hr WIDTH="100%"><a NAME="ansinfo"></a>ANS Required Information</h2>
-<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>
-<H3>
-Implementation-defined Options</H3>
+<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 Exception word set</b>
+<br><b>Providing names from the Exception 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 Memory Allocation 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
and choices left to the discretion of the implementor, provided that the
requirements of the Standard are met. A system shall document the values
for, or behaviors of, each item.
-<UL>
-<LI>
-<B>aligned address requirements (3.1.3.3 Addresses);</B> </LI>
+<ul>
+<li>
+<b>aligned address requirements (3.1.3.3 Addresses);</b> </li>
-<BR><FONT COLOR="#000000">System dependent. You can change the default
+<br><font color="#000000">System dependent. You can change the default
address alignment by defining FICL_ALIGN on your compiler's command line.
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>
-<LI>
-<B>behavior of 6.1.1320 EMIT for non-graphic characters</B>; </LI>
+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>
+<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>
-<LI>
-<B>character editing of 6.1.0695 ACCEPT and 6.2.1390 EXPECT</B>; </LI>
+<br><font color="#000000">Depends on target system, C runtime library,
+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
+<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>
-<LI>
-<B>character set (3.1.2 Character types, 6.1.1320 EMIT, 6.1.1750 KEY)</B>; </LI>
+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>
-<LI>
-<B>character-aligned address requirements (3.1.3.3 Addresses)</B>; </LI>
+<br><font color="#000000">Depends on target system and implementation of
+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>
-<LI>
-<B>character-set-extensions matching characteristics (3.4.2 Finding definition
-n<FONT COLOR="#000000">ames)</FONT></B><FONT COLOR="#000000">; </FONT></LI>
+<br><font color="#000000">Ficl characters are one byte each. There are
+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>
-<BR><FONT COLOR="#000000">No special processing is performed on characters
+<br><font color="#000000">No special processing is performed on characters
beyond case-folding. Therefore, extended characters will not match their
-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>
+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>
-<LI>
-<B>format of the control-flow stack (3.2.3.2 Control-flow stack)</B>; </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>
+<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>
-<LI>
-<B>conversion of digits larger than thirty-five (3.2.1.2 Digit conversion)</B>; </LI>
+<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>
-<BR><FONT COLOR="#000000">The maximum supported value of <TT>BASE</TT>
+<br><font color="#000000">The maximum supported value of <tt>BASE</tt>
is 36. Ficl will assertion fail in function ltoa of vm.c if the base is
found to be larger than 36 or smaller than 2. There will be no effect if
-NDEBUG is defined</FONT>, however, other than possibly unexpected behavior.
-<LI>
-<B>display after input terminates in 6.1.0695 ACCEPT and 6.2.1390 EXPECT</B>; </LI>
+NDEBUG is defined</font>, however, other than possibly unexpected behavior.
+<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>
-<LI>
-<B>exception abort sequence (as in 6.1.0680 ABORT")</B>; </LI>
+<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>
-<LI>
-<B>input line terminator (3.2.4.1 User input device)</B>;<FONT COLOR="#FF0000"> </FONT></LI>
+<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>
-<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">Target system dependent (implementation of outer
+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>
-<LI>
-<B>maximum size of a parsed string (3.4.1 Parsing)</B>; </LI>
+<br><font color="#000000">255</font>
+<li>
+<b>maximum size of a parsed string (3.4.1 Parsing)</b>; </li>
-<BR>Limited by available memory and the maximum unsigned value that can
-fit in a CELL (2<SUP>32</SUP>-1).
-<LI>
-<B>maximum size of a definition name, in characters (3.3.1.2 Definition
-names)</B>; </LI>
+<br>Limited by available memory and the maximum unsigned value that can
+fit in a CELL (2<sup>32</sup>-1).
+<li>
+<b>maximum size of a definition name, in characters (3.3.1.2 Definition
+names)</b>; </li>
-<BR><FONT COLOR="#000000">Ficl stores the first 31 characters of a definition
-name.</FONT>
-<LI>
-<B>maximum string length for 6.1.1345 ENVIRONMENT?, in characters</B>; </LI>
+<br><font color="#000000">Ficl stores the first 31 characters of a definition
+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>
-<LI>
-<B>method of selecting 3.2.4.1 User input device</B>; </LI>
+<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>
-<BR>None supported. This is up to the target system
-<LI>
-<B>method of selecting 3.2.4.2 User output device</B>; </LI>
+<br>None supported. This is up to the target system
+<li>
+<b>method of selecting 3.2.4.2 User output device</b>; </li>
-<BR>None supported. This is up to the target system
-<LI>
-<B>methods of dictionary compilation (3.3 The Forth dictionary)</B>; </LI>
+<br>None supported. This is up to the target system
+<li>
+<b>methods of dictionary compilation (3.3 The Forth dictionary)</b>; </li>
-<LI>
-<B>number of bits in one address unit (3.1.3.3 Addresses)</B>; </LI>
+<li>
+<b>number of bits in one address unit (3.1.3.3 Addresses)</b>; </li>
-<BR><FONT COLOR="#000000">Target system dependent. Ficl generally supports
+<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>
-<LI>
-<B>number representation and arithmetic (3.2.1.1 Internal number representation)</B>; </LI>
+that I'm aware of.</font>
+<li>
+<b>number representation and arithmetic (3.2.1.1 Internal number representation)</b>; </li>
-<BR>System dependent. Ficl represents a CELL internally as a union that
+<br>System dependent. Ficl represents a CELL internally as a union that
can hold INT32 (a signed 32 bit scalar value), UNS32 (32 bits unsigned),
and an untyped pointer. No specific byte ordering is assumed.
-<LI>
-<B>ranges for n, +n, u, d, +d, and ud (3.1.3 Single-cell types, 3.1.4 Cell-pair
-types)</B>; </LI>
+<li>
+<b>ranges for n, +n, u, d, +d, and ud (3.1.3 Single-cell types, 3.1.4 Cell-pair
+types)</b>; </li>
-<BR>Assuming a 32 bit implementation, range for signed single-cell values
-is -2<SUP>31</SUP>..2<SUP>31</SUP>-1. Range for unsigned single cell values
-is 0..2<SUP>32</SUP>-1. Range for signed double-cell values is -2<SUP>63</SUP>..2<SUP>63</SUP>-1.
-Range for unsigned single cell values is 0..2<SUP>64</SUP>-1.
-<LI>
-<B>read-only data-space regions (3.3.3 Data space)</B>;</LI>
+<br>Assuming a 32 bit implementation, range for signed single-cell values
+is -2<sup>31</sup>..2<sup>31</sup>-1. Range for unsigned single cell values
+is 0..2<sup>32</sup>-1. Range for signed double-cell values is -2<sup>63</sup>..2<sup>63</sup>-1.
+Range for unsigned single cell values is 0..2<sup>64</sup>-1.
+<li>
+<b>read-only data-space regions (3.3.3 Data space)</b>;</li>
-<BR>None
-<LI>
-<B>size of buffer at 6.1.2450 WORD (3.3.3.6 Other transient regions)</B>; </LI>
+<br>None
+<li>
+<b>size of buffer at 6.1.2450 WORD (3.3.3.6 Other transient regions)</b>; </li>
-<BR>Default is 255. Depends on the setting of nPAD in ficl.h.
-<LI>
-<B>size of one cell in address units (3.1.3 Single-cell types)</B>; </LI>
+<br>Default is 255. Depends on the setting of nPAD in ficl.h.
+<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>
-<LI>
-<B>size of one character in address units (3.1.2 Character types)</B>; </LI>
+<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>
-<LI>
-<B>size of the keyboard terminal input buffer (3.3.3.5 Input buffers)</B>; </LI>
+<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>
-<LI>
-<B>size of the pictured numeric output string buffer (3.3.3.6 Other transient
-regions)</B>; </LI>
+<br><font color="#000000">This buffer is supplied by the host program.
+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>
-<BR>Default is 255 characters. Depends on the setting of nPAD in ficl.h.
-<LI>
-<B>size of the scratch area whose address is returned by 6.2.2000 PAD (3.3.3.6
-Other transient regions)</B>; </LI>
+<br>Default is 255 characters. Depends on the setting of nPAD in ficl.h.
+<li>
+<b>size of the scratch area whose address is returned by 6.2.2000 PAD (3.3.3.6
+Other transient regions)</b>; </li>
-<BR>Not presently supported
-<LI>
-<B>system case-sensitivity characteristics (3.4.2 Finding definition names)</B>; </LI>
+<br>Not presently supported
+<li>
+<b>system case-sensitivity characteristics (3.4.2 Finding definition names)</b>; </li>
-<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">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>
-<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">"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>
-<LI>
-<B>values of 6.1.2250 STATE when true</B>; </LI>
+<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>
-<LI>
-<B>values returned after arithmetic overflow (3.2.2.2 Other integer operations)</B>; </LI>
+<br><font color="#000000">One (no others)</font>
+<li>
+<b>values returned after arithmetic overflow (3.2.2.2 Other integer operations)</b>; </li>
-<BR>System dependent. Ficl makes no special checks for overflow.
-<LI>
-<B>whether the current definition can be found after 6.1.1250 DOES> (6.1.0450
-:)</B>. </LI>
+<br>System dependent. Ficl makes no special checks for overflow.
+<li>
+<b>whether the current definition can be found after 6.1.1250 DOES> (6.1.0450
+:)</b>. </li>
-<BR><FONT COLOR="#000000">No. Definitions are unsmudged after ; only, and
-only then if no control structure matching problems have been detected.</FONT></UL>
+<br><font color="#000000">No. Definitions are unsmudged after ; only, and
+only then if no control structure matching problems have been detected.</font></ul>
-<H3>
-Ambiguous Conditions</H3>
+<h3>
+Ambiguous Conditions</h3>
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
+<p>The following general ambiguous conditions could occur because of a
combination of factors:
-<UL>
-<DL>
-<LI>
-<B>a name is neither a valid definition name nor a valid number during
-text interpretation (3.4 The Forth text interpreter)</B>; </LI>
+<ul>
+<dl>
+<li>
+<b>a name is neither a valid definition name nor a valid number during
+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>
-<LI>
-<B>a definition name exceeded the maximum length allowed (3.3.1.2 Definition
-names)</B>; </LI>
+<br><font color="#000000">Ficl does <tt>ABORT</tt> and prints the name
+followed by " not found".</font>
+<li>
+<b>a definition name exceeded the maximum length allowed (3.3.1.2 Definition
+names)</b>; </li>
-<BR><FONT COLOR="#000000">Ficl stores the first 31 characters of the definition
+<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>
-<LI>
-<B>addressing a region not listed in 3.3.3 Data Space</B>; </LI>
+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>
-<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>
+<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>
+<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>
-<BR><FONT COLOR="#000000">Ficl makes no check for argument type compatibility.
+<br><font color="#000000">Ficl makes no check for argument type compatibility.
Effects of a mismatch vary widely depending on the specific problem and
-operands.</FONT></DL>
+operands.</font></dl>
-<LI>
-<B>attempting to obtain the execution token, (e.g., with 6.1.0070 ', 6.1.1550
-FIND, etc.) of a definition with undefined interpretation semantics</B>; </LI>
+<li>
+<b>attempting to obtain the execution token, (e.g., with 6.1.0070 ', 6.1.1550
+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>
-<LI>
-<B>dividing by zero (6.1.0100 */, 6.1.0110 */MOD, 6.1.0230 /, 6.1.0240
+<br><font color="#000000">Ficl returns a valid token, but the result of
+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,
-8.6.1.1820 M*/)</B>;</LI>
+8.6.1.1820 M*/)</b>;</li>
-<BR><FONT COLOR="#000000">Results are target procesor dependent. Generally,
+<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>
-<LI>
-<B>insufficient data-stack space or return-stack space (stack overflow)</B>; </LI>
+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
+<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>
-<LI>
-<B>insufficient space for loop-control parameters</B>; </LI>
+check the return stack.</font>
+<li>
+<b>insufficient space for loop-control parameters</b>; </li>
-<BR><FONT COLOR="#000000">No check - Evil results.</FONT>
-<LI>
-<B>insufficient space in the dictionary</B>; </LI>
+<br><font color="#000000">No check - Evil results.</font>
+<li>
+<b>insufficient space in the dictionary</b>; </li>
-<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
+<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>
-<LI>
-<B>interpreting a word with undefined interpretation semantics</B>; </LI>
+the dictionary.</font>
+<li>
+<b>interpreting a word with undefined interpretation semantics</b>; </li>
-<BR><FONT COLOR="#000000">Ficl protects all ANS Forth words with undefined
+<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>
-<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>
+It is possible to defeat this protection using ' (tick) and <tt>EXECUTE</tt>,
+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>
-<BR><FONT COLOR="#000000">Varies depending on the nature of the buffer.
+<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>
-<LI>
-<B>overflow of a pictured numeric output string</B>;</LI>
+String literals are stored in the dictionary, and are writable.</font>
+<li>
+<b>overflow of a pictured numeric output string</b>;</li>
-<BR>In the unlikely event you are able to construct a pictured numeric
+<br>In the unlikely event you are able to construct a pictured numeric
string of more than 255 characters, the system will be corrupted unpredictably.
The buffer area that holds pictured numeric output is at the end of the
virtual machine. Whatever is mapped after the offending VM in memory will
be trashed, along with the heap structures that contain it.
-<LI>
-<B>parsed string overflow</B>;</LI>
+<li>
+<b>parsed string overflow</b>;</li>
-<BR>Ficl does not copy parsed strings unless asked to. Ordinarily, a string
+<br>Ficl does not copy parsed strings unless asked to. Ordinarily, a string
parsed from the input buffer during normal interpretation is left in-place,
so there is no possibility of overflow. If you ask to parse a string into
-the dictionary, as in <TT>SLITERAL</TT>, you need to have enough room for
+the dictionary, as in <tt>SLITERAL</tt>, you need to have enough room for
the string, otherwise bad things may happen. This is not usually a problem.
-<LI>
-<B>producing a result out of range, e.g., multiplication (using *) results
+<li>
+<b>producing a result out of range, e.g., multiplication (using *) results
in a value too big to be represented by a single-cell integer (6.1.0090
*, 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>
+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>
-<LI>
-<B>reading from an empty data stack or return stack (stack underflow)</B>; </LI>
+<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
+<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>
-<LI>
-<B>unexpected end of input buffer, resulting in an attempt to use a zero-length
-string as a name</B>; </LI>
+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>
-<BR><FONT COLOR="#000000">Ficl returns for a new input buffer until a non-empty
-one is supplied.</FONT></UL>
+<br><font color="#000000">Ficl returns for a new input buffer until a non-empty
+one is supplied.</font></ul>
The following specific ambiguous conditions are noted in the glossary entries
of the relevant words:
-<UL>
-<LI>
-<B>>IN greater than size of input buffer (3.4.1 Parsing)</B></LI>
+<ul>
+<li>
+<b>>IN greater than size of input buffer (3.4.1 Parsing)</b></li>
-<BR>Bad Things occur - unpredictable bacause the input buffer is supplied
+<br>Bad Things occur - unpredictable bacause the input buffer is supplied
by the host program's outer loop.
-<LI>
-<B>6.1.2120 RECURSE appears after 6.1.1250 DOES></B></LI>
+<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>
-<LI>
-<B>argument input source different than current input source for 6.2.2148
-RESTORE-INPUT</B></LI>
+<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>
-<BR>Not implemented
-<LI>
-<B>data space containing definitions is de-allocated (3.3.3.2 Contiguous
-regions)</B></LI>
+<br>Not implemented
+<li>
+<b>data space containing definitions is de-allocated (3.3.3.2 Contiguous
+regions)</b></li>
-<BR>This is OK until the cells are overwritten with something else. The
+<br>This is OK until the cells are overwritten with something else. The
dictionary maintains a hash table, and the table must be updated in order
to de-allocate words without corruption.
-<LI>
-<B>data space read/write with incorrect alignment (3.3.3.1 Address alignment)</B></LI>
+<li>
+<b>data space read/write with incorrect alignment (3.3.3.1 Address alignment)</b></li>
-<BR>Target processor dependent. Consequences include: none (Intel), address
+<br>Target processor dependent. Consequences include: none (Intel), address
error exception (68K).
-<LI>
-<B>data-space pointer not properly aligned (6.1.0150 ,, 6.1.0860 C,)</B></LI>
+<li>
+<b>data-space pointer not properly aligned (6.1.0150 ,, 6.1.0860 C,)</b></li>
-<BR>See above on data space read/write alignment
-<LI>
-<B>less than u+2 stack items (6.2.2030 PICK, 6.2.2150 ROLL)</B></LI>
+<br>See above on data space read/write alignment
+<li>
+<b>less than u+2 stack items (6.2.2030 PICK, 6.2.2150 ROLL)</b></li>
-<BR>Ficl detects a stack underflow and reports it, executing <TT>ABORT,</TT>
+<br>Ficl detects a stack underflow and reports it, executing <tt>ABORT,</tt>
as long as FICL_ROBUST is two or larger.
-<LI>
-<B>loop-control parameters not available ( 6.1.0140 +LOOP, 6.1.1680 I,
-6.1.1730 J, 6.1.1760 LEAVE, 6.1.1800 LOOP, 6.1.2380 UNLOOP)</B></LI>
+<li>
+<b>loop-control parameters not available ( 6.1.0140 +LOOP, 6.1.1680 I,
+6.1.1730 J, 6.1.1760 LEAVE, 6.1.1800 LOOP, 6.1.2380 UNLOOP)</b></li>
-<BR>Loop initiation words are responsible for checking the stack and guaranteeing
+<br>Loop initiation words are responsible for checking the stack and guaranteeing
that the control parameters are pushed. Any underflows will be detected
early if FICL_ROBUST is set to two or greater. Note however that Ficl only
checks for return stack underflows at the end of each line of text.
-<LI>
-<B>most recent definition does not have a name (6.1.1710 IMMEDIATE)</B></LI>
+<li>
+<b>most recent definition does not have a name (6.1.1710 IMMEDIATE)</b></li>
-<BR>No problem.
-<LI>
-<B>name not defined by 6.2.2405 VALUE used by 6.2.2295 TO</B></LI>
+<br>No problem.
+<li>
+<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.
-<LI>
-<B>name not found (6.1.0070 ', 6.1.2033 POSTPONE, 6.1.2510 ['], 6.2.2530
-[COMPILE])</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.
+<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>
-<LI>
-<B>parameters are not of the same type (6.1.1240 DO, 6.2.0620 ?DO, 6.2.2440
-WITHIN)</B></LI>
+<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>
-<BR>No check. Results vary depending on the specific problem.
-<LI>
-<B>6.1.2033 POSTPONE or 6.2.2530 [COMPILE] applied to 6.2.2295 TO</B></LI>
+<br>No check. Results vary depending on the specific problem.
+<li>
+<b>6.1.2033 POSTPONE or 6.2.2530 [COMPILE] applied to 6.2.2295 TO</b></li>
-<BR>The word is postponed correctly.
-<LI>
-<B>string longer than a counted string returned by 6.1.2450 WORD</B></LI>
+<br>The word is postponed correctly.
+<li>
+<b>string longer than a counted string returned by 6.1.2450 WORD</b></li>
-<BR>Ficl stores the first FICL_STRING_MAX-1 chars in the destination buffer.
+<br>Ficl stores the first FICL_STRING_MAX-1 chars in the destination buffer.
(The extra character is the trailing space required by the standard. Yuck.)
-<LI>
-<B>u greater than or equal to the number of bits in a cell (6.1.1805 LSHIFT,
-6.1.2162 RSHIFT)</B></LI>
+<li>
+<b>u greater than or equal to the number of bits in a cell (6.1.1805 LSHIFT,
+6.1.2162 RSHIFT)</b></li>
-<BR>Depends on target process or and C runtime library implementations
+<br>Depends on target process or and C runtime library implementations
of the << and >> operators on unsigned values. For I386, the processor
appears to shift modulo the number of bits in a cell.
-<LI>
-<B>word not defined via 6.1.1000 CREATE (6.1.0550 >BODY, 6.1.1250 DOES>)</B></LI>
+<li>
+<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>
-<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>,
+<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>
+<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
not what you want. Likewise, pictured numeric words assume that there is
a string under construction in the VM's scratch buffer. If that's not the
-case, results may be unpleasant.</UL>
+case, results may be unpleasant.</ul>
-<H3>
-Locals Implementation-defined options</H3>
+<h3>
+Locals Implementation-defined options</h3>
-<UL>
-<LI>
-<B>maximum number of locals in a definition (13.3.3 Processing locals,
-13.6.2.1795 LOCALS|)</B></LI>
+<ul>
+<li>
+<b>maximum number of locals in a definition (13.3.3 Processing locals,
+13.6.2.1795 LOCALS|)</b></li>
-<BR>Default is 16. Change by redefining FICL_MAX_LOCALS, defined in sysdep.h</UL>
+<br>Default is 16. Change by redefining FICL_MAX_LOCALS, defined in sysdep.h</ul>
-<H3>
-Locals Ambiguous conditions</H3>
+<h3>
+Locals Ambiguous conditions</h3>
-<UL>
-<LI>
-<B>executing a named local while in interpretation state (13.6.1.0086 (LOCAL))</B></LI>
+<ul>
+<li>
+<b>executing a named local while in interpretation state (13.6.1.0086 (LOCAL))</b></li>
-<BR>Locals can be found in interpretation state while in the context of
+<br>Locals can be found in interpretation state while in the context of
a definition under construction. Under these circumstances, locals behave
correctly. Locals are not visible at all outside the scope of a definition.
-<LI>
-<B>name not defined by VALUE or LOCAL (13.6.1.2295 TO)</B></LI>
+<li>
+<b>name not defined by VALUE or LOCAL (13.6.1.2295 TO)</b></li>
-<BR>See the CORE ambiguous conditions, above (no change)</UL>
+<br>See the CORE ambiguous conditions, above (no change)</ul>
-<H3>
-Programming Tools Implementation-defined options</H3>
+<h3>
+Programming Tools Implementation-defined options</h3>
-<UL>
-<LI>
-<B>source and format of display by 15.6.1.2194 SEE</B></LI>
+<ul>
+<li>
+<b>source and format of display by 15.6.1.2194 SEE</b></li>
-<BR>SEE de-compiles definitions from the dictionary. Because Ficl words
+<br>SEE de-compiles definitions from the dictionary. Because Ficl words
are threaded by their header addresses, it is very straightforward to print
the name and other characteristics of words in a definition. Primitives
are so noted. Colon definitions are decompiled, but branch target labels
are not reconstructed. Literals and string literals are so noted, and their
-contents displayed.</UL>
+contents displayed.</ul>
-<H3>
-Search Order Implementation-defined options</H3>
+<h3>
+Search Order Implementation-defined options</h3>
-<UL>
-<LI>
-<B>maximum number of word lists in the search order (16.3.3 Finding definition
-names, 16.6.1.2197 SET-ORDER)</B> </LI>
+<ul>
+<li>
+<b>maximum number of word lists in the search order (16.3.3 Finding definition
+names, 16.6.1.2197 SET-ORDER)</b> </li>
-<BR>Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS, declared
+<br>Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS, declared
in sysdep.h
-<LI>
-<B>minimum search order (16.6.1.2197 SET-ORDER, 16.6.2.1965 ONLY)</B> </LI>
+<li>
+<b>minimum search order (16.6.1.2197 SET-ORDER, 16.6.2.1965 ONLY)</b> </li>
-<BR>Equivalent to <TT>FORTH-WORDLIST 1 SET-ORDER</TT></UL>
+<br>Equivalent to <tt>FORTH-WORDLIST 1 SET-ORDER</tt></ul>
-<H3>
-Search Order Ambiguous conditions</H3>
+<h3>
+Search Order Ambiguous conditions</h3>
-<UL>
-<LI>
-<B>changing the compilation word list (16.3.3 Finding definition names)</B></LI>
+<ul>
+<li>
+<b>changing the compilation word list (16.3.3 Finding definition names)</b></li>
-<BR>Ficl stores a link to the current definition independently of the compile
+<br>Ficl stores a link to the current definition independently of the compile
wordlist while it is being defined, and links it into the compile wordlist
only after the definition completes successfully. Changing the compile
-wordlist mid-definition will cause the definition to link into the <I>new</I>
+wordlist mid-definition will cause the definition to link into the <i>new</i>
compile wordlist.
-<LI>
-<B>search order empty (16.6.2.2037 PREVIOUS)</B></LI>
+<li>
+<b>search order empty (16.6.2.2037 PREVIOUS)</b></li>
-<BR>Ficl prints an error message if the search order underflows, and resets
+<br>Ficl prints an error message if the search order underflows, and resets
the order to its default state.
-<LI>
-<B>too many word lists in search order (16.6.2.0715 ALSO)</B></LI>
+<li>
+<b>too many word lists in search order (16.6.2.0715 ALSO)</b></li>
-<BR>Ficl prints an error message if the search order overflows, and resets
-the order to its default state.</UL>
- </TD>
-</TR>
-</TABLE>
+<br>Ficl prints an error message if the search order overflows, and resets
+the order to its default state.</ul>
+ </td>
+</tr>
+</table>
-<H2>
+<h2>
-<HR WIDTH="100%"><A NAME="links"></A>For more information</H2>
+<hr WIDTH="100%"><a NAME="links"></a>For more information</h2>
-<UL>
-<LI>
-<A HREF="http://www.taygeta.com/forthcomp.html">Web home of ficl</A></LI>
+<ul>
+<li>
+<a href="http://www.taygeta.com/ficl.html">Web home of ficl</a></li>
-<LI>
-<A HREF="http://www.taygeta.com/forthlit.html">Forth literature</A></LI>
+<li>
+<b><a href="ftp://ftp.taygeta.com/pub/Forth/Compilers/native/misc/ficl203/ficl203.zip">Download
+ficl 2.03</a></b></li>
-<UL>
-<LI>
-<A HREF="http://www.softsynth.com/pforth/pf_tut.htm">Phil Burk's Forth
-Tutorial</A></LI>
+<li>
+<a href="ficlddj.pdf">Manuscript of Ficl article for January 1999 Dr. Dobb's
+Journal</a></li>
-<LI>
-<A HREF="http://www.taygeta.com/forth/dpans.html">Draft Proposed American
-National Standard for Forth</A></LI>
-</UL>
+<li>
+<a href="jwsforml.pdf">1998 FORML Conference paper</a></li>
-<LI>
-<A HREF="http://www.forth.org">Forth Interest Group</A></LI>
+<li>
+<a href="http://www.taygeta.com/forthlit.html">Forth literature</a></li>
-<LI>
-<A HREF="ftp://ftp.taygeta.com/pub/Forth/Compilers/native/misc/ficl202/ficl202.zip">Download
-ficl 2.02</A></LI>
-</UL>
+<ul>
+<li>
+<a href="http://www.softsynth.com/pforth/pf_tut.htm">Phil Burk's Forth
+Tutorial</a></li>
-<H2>
+<li>
+<a href="http://www.taygeta.com/forth/dpans.html">Draft Proposed American
+National Standard for Forth</a></li>
+</ul>
-<HR WIDTH="100%"></H2>
+<li>
+<a href="http://www.forth.org">Forth Interest Group</a></li>
+</ul>
-<TABLE BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
-<TR>
-<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
+<h2>
+<a NAME="includesficl"></a>Some software that uses ficl</h2>
+
+<ul>
+<li>
+<a href="http://www.freebsd.org/">FreeBSD</a> boot loader</li>
+
+<li>
+<a href="http://www.pagesz.net/~sessoms/debuffer/">Palm Pilot Debuffer</a>
+(Eric Sessoms)</li>
+
+<li>
+<a href="http://www.swcp.com/~jchavez/osmond.html">Mac PC Board Layout
+tool</a> (J Chavez)</li>
+
+<li>
+<a href="http://www.netcomsystems.com">NetCom Systems</a> ML7710 (Martin
+Usher)</li>
+</ul>
+
+<h2>
+
+<hr WIDTH="100%"></h2>
+
+<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
+<tr>
+<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
are retained in the source code files. The ficl software code is provided
@@ -2447,12 +2893,12 @@
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
+<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
-the address above. </TD>
-</TR>
-</TABLE>
+like to contribute to the ficl release (yay!), please <a href="mailto:john_sadler@alum.mit.edu">send
+me email</a>. </td>
+</tr>
+</table>
-</BODY>
-</HTML>
+</body>
+</html>
--- a/ficl.c
+++ b/ficl.c
@@ -168,16 +168,29 @@
**************************************************************************/
int ficlExec(FICL_VM *pVM, char *pText)
{+ return ficlExecC(pVM, pText, -1);
+}
+
+int ficlExecC(FICL_VM *pVM, char *pText, FICL_INT size)
+{+ static FICL_WORD *pInterp = NULL;
+
int except;
- FICL_WORD *tempFW;
jmp_buf vmState;
jmp_buf *oldState;
TIB saveTib;
+ if (!pInterp)
+ pInterp = ficlLookup("interpret");+
+ assert(pInterp);
assert(pVM);
- vmPushTib(pVM, pText, &saveTib);
+ if (size < 0)
+ size = strlen(pText);
+ vmPushTib(pVM, pText, size, &saveTib);
+
/*
** Save and restore VM's jmp_buf to enable nested calls to ficlExec
*/
@@ -193,22 +206,12 @@
pVM->fRestart = 0;
pVM->runningWord->code(pVM);
}
-
- /*
- ** the mysterious inner interpreter...
- ** vmThrow gets you out of this loop with a longjmp()
- */
- for (;;)
- {- tempFW = *pVM->ip++;
- /*
- ** inline code for
- ** vmExecute(pVM, tempFW);
- */
- pVM->runningWord = tempFW;
- tempFW->code(pVM);
+ else
+ { /* set VM up to interpret text */+ vmPushIP(pVM, &pInterp);
}
+ vmInnerLoop(pVM);
break;
case VM_RESTART:
@@ -217,20 +220,29 @@
break;
case VM_OUTOFTEXT:
+ vmPopIP(pVM);
if ((pVM->state != COMPILE) && (pVM->sourceID.i == 0))
ficlTextOut(pVM, FICL_PROMPT, 0);
break;
case VM_USEREXIT:
+ case VM_INNEREXIT:
break;
case VM_QUIT:
if (pVM->state == COMPILE)
+ {dictAbortDefinition(dp);
+#if FICL_WANT_LOCALS
+ dictEmpty(localp, localp->pForthWords->size);
+#endif
+ }
vmQuit(pVM);
break;
case VM_ERREXIT:
+ case VM_ABORT:
+ case VM_ABORTQ:
default: /* user defined exit code?? */
if (pVM->state == COMPILE)
{@@ -251,6 +263,79 @@
/**************************************************************************
+ f i c l E x e c X T
+** Given a pointer to a FICL_WORD, push an inner interpreter and
+** execute the word to completion. This is in contrast with vmExecute,
+** which does not guarantee that the word will have completed when
+** the function returns (ie in the case of colon definitions, which
+** need an inner interpreter to finish)
+**
+** Returns one of the VM_XXXX exception codes listed in ficl.h. Normal
+** exit condition is VM_INNEREXIT, ficl's private signal to exit the
+** inner loop under normal circumstances. If another code is thrown to
+** exit the loop, this function will re-throw it if it's nested under
+** itself or ficlExec.
+**
+** NOTE: this function is intended so that C code can execute ficlWords
+** given their address in the dictionary (xt).
+**************************************************************************/
+int ficlExecXT(FICL_VM *pVM, FICL_WORD *pWord)
+{+ static FICL_WORD *pQuit = NULL;
+ int except;
+ jmp_buf vmState;
+ jmp_buf *oldState;
+
+ if (!pQuit)
+ pQuit = ficlLookup("exit-inner");+
+ assert(pVM);
+ assert(pQuit);
+
+ /*
+ ** Save and restore VM's jmp_buf to enable nested calls
+ */
+ oldState = pVM->pState;
+ pVM->pState = &vmState; /* This has to come before the setjmp! */
+ except = setjmp(vmState);
+
+ if (except)
+ vmPopIP(pVM);
+ else
+ vmPushIP(pVM, &pQuit);
+
+ switch (except)
+ {+ case 0:
+ vmExecute(pVM, pWord);
+ vmInnerLoop(pVM);
+ break;
+
+ case VM_INNEREXIT:
+ break;
+
+ case VM_RESTART:
+ case VM_OUTOFTEXT:
+ case VM_USEREXIT:
+ case VM_QUIT:
+ case VM_ERREXIT:
+ case VM_ABORT:
+ case VM_ABORTQ:
+ default: /* user defined exit code?? */
+ if (oldState)
+ {+ pVM->pState = oldState;
+ vmThrow(pVM, except);
+ }
+ break;
+ }
+
+ pVM->pState = oldState;
+ return (except);
+}
+
+
+/**************************************************************************
f i c l L o o k u p
** Look in the system dictionary for a match to the given name. If
** found, return the address of the corresponding FICL_WORD. Otherwise
@@ -289,7 +374,7 @@
** Create an environment variable with a one-CELL payload. ficlSetEnvD
** makes one with a two-CELL payload.
**************************************************************************/
-void ficlSetEnv(char *name, UNS32 value)
+void ficlSetEnv(char *name, FICL_UNS value)
{STRINGINFO si;
FICL_WORD *pFW;
@@ -310,7 +395,7 @@
return;
}
-void ficlSetEnvD(char *name, UNS32 hi, UNS32 lo)
+void ficlSetEnvD(char *name, FICL_UNS hi, FICL_UNS lo)
{FICL_WORD *pFW;
STRINGINFO si;
@@ -344,6 +429,23 @@
return localp;
}
#endif
+
+
+
+/**************************************************************************
+ f i c l S e t S t a c k S i z e
+** Set the stack sizes (return and parameter) to be used for all
+** subsequently created VMs. Returns actual stack size to be used.
+**************************************************************************/
+int ficlSetStackSize(int nStackCells)
+{+ if (nStackCells >= FICL_DEFAULT_STACK)
+ defaultStack = nStackCells;
+ else
+ defaultStack = FICL_DEFAULT_STACK;
+
+ return defaultStack;
+}
/**************************************************************************
binary files a/ficl.exe b/ficl.exe differ
--- a/ficl.h
+++ b/ficl.h
@@ -153,6 +153,17 @@
/*
** Revision History:
+**
+** 15 Apr 1999 (sadler) Merged FreeBSD changes for exception wordset and
+** counted strings in ficlExec.
+** 12 Jan 1999 (sobral) Corrected EVALUATE behavior. Now TIB has an
+** "end" field, and all words respect this. ficlExec is passed a "size"
+** of TIB, as well as vmPushTib. This size is used to calculate the "end"
+** of the string, ie, base+size. If the size is not known, pass -1.
+**
+** 10 Jan 1999 (sobral) EXCEPTION word set has been added, and existing
+** words has been modified to conform to EXCEPTION EXT word set.
+**
** 27 Aug 1998 (sadler) testing and corrections for LOCALS, LOCALS EXT,
** SEARCH / SEARCH EXT, TOOLS / TOOLS EXT.
** Added .X to display in hex, PARSE and PARSE-WORD to supplement WORD,
@@ -206,8 +217,10 @@
/*
** the Good Stuff starts here...
*/
-#define FICL_VER "2.02"
+#define FICL_VER "2.03"
+#if !defined (FICL_PROMPT)
#define FICL_PROMPT "ok> "
+#endif
/*
** ANS Forth requires false to be zero, and true to be the ones
@@ -221,13 +234,13 @@
/*
** A CELL is the main storage type. It must be large enough
-** to contain a pointer or a scalar. Let's be picky and make
-** a 32 bit cell explicitly...
+** to contain a pointer or a scalar. In order to accommodate
+** 32 bit and 64 bit processors, use abstract types for i and u.
*/
typedef union _cell
{- INT32 i;
- UNS32 u;
+ FICL_INT i;
+ FICL_UNS u;
void *p;
} CELL;
@@ -290,10 +303,19 @@
** the block of text it's working on and an index to the next
** unconsumed character in the string. Traditionally, this is
** done by a Text Input Buffer, so I've called this struct TIB.
+**
+** Since this structure also holds the size of the input buffer,
+** and since evaluate requires that, let's put the size here.
+** The size is stored as an end-pointer because that is what the
+** null-terminated string aware functions find most easy to deal
+** with.
+** Notice, though, that nobody really uses this except evaluate,
+** so it might just be moved to FICL_VM instead. (sobral)
*/
typedef struct
{INT32 index;
+ char *end;
char *cp;
} TIB;
@@ -309,7 +331,7 @@
*/
typedef struct _ficlStack
{- UNS32 nCells; /* size of the stack */
+ FICL_UNS nCells; /* size of the stack */
CELL *pFrame; /* link reg for stack frame */
CELL *sp; /* stack pointer */
CELL base[1]; /* Bottom of the stack */
@@ -328,12 +350,12 @@
void stackPick (FICL_STACK *pStack, int n);
CELL stackPop (FICL_STACK *pStack);
void *stackPopPtr (FICL_STACK *pStack);
-UNS32 stackPopUNS32 (FICL_STACK *pStack);
-INT32 stackPopINT32 (FICL_STACK *pStack);
+FICL_UNS stackPopUNS(FICL_STACK *pStack);
+FICL_INT stackPopINT(FICL_STACK *pStack);
void stackPush (FICL_STACK *pStack, CELL c);
void stackPushPtr (FICL_STACK *pStack, void *ptr);
-void stackPushUNS32(FICL_STACK *pStack, UNS32 u);
-void stackPushINT32(FICL_STACK *pStack, INT32 i);
+void stackPushUNS(FICL_STACK *pStack, FICL_UNS u);
+void stackPushINT(FICL_STACK *pStack, FICL_INT i);
void stackReset (FICL_STACK *pStack);
void stackRoll (FICL_STACK *pStack, int n);
void stackSetTop(FICL_STACK *pStack, CELL c);
@@ -426,6 +448,12 @@
*/
typedef void (*FICL_CODE)(FICL_VM *pVm);
+#if 0
+#define VM_ASSERT(pVM) assert((*(pVM->ip - 1)) == pVM->runningWord)
+#else
+#define VM_ASSERT(pVM)
+#endif
+
/*
** Ficl models memory as a contiguous space divided into
** words in a linked list called the dictionary.
@@ -468,11 +496,14 @@
/*
** Exit codes for vmThrow
*/
-#define VM_OUTOFTEXT 1 /* hungry - normal exit */
-#define VM_RESTART 2 /* word needs more text to suxcceed - re-run it */
-#define VM_USEREXIT 3 /* user wants to quit */
-#define VM_ERREXIT 4 /* interp found an error */
-#define VM_QUIT 5 /* like errexit, but leave pStack & base alone */
+#define VM_INNEREXIT -256 /* tell ficlExecXT to exit inner loop */
+#define VM_OUTOFTEXT -257 /* hungry - normal exit */
+#define VM_RESTART -258 /* word needs more text to succeed - re-run it */
+#define VM_USEREXIT -259 /* user wants to quit */
+#define VM_ERREXIT -260 /* interp found an error */
+#define VM_ABORT -1 /* like errexit -- abort */
+#define VM_ABORTQ -2 /* like errexit -- abort" */
+#define VM_QUIT -56 /* like errexit, but leave pStack & base alone */
void vmBranchRelative(FICL_VM *pVM, int offset);
@@ -493,7 +524,29 @@
void vmThrow (FICL_VM *pVM, int except);
void vmThrowErr(FICL_VM *pVM, char *fmt, ...);
+#define vmGetRunningWord(pVM) ((pVM)->runningWord)
+
+
/*
+** The inner interpreter - coded as a macro (see note for
+** INLINE_INNER_LOOP in sysdep.h for complaints about VC++ 5
+*/
+#define M_INNER_LOOP(pVM) \
+ for (;;) \
+ { \+ FICL_WORD *tempFW = *(pVM)->ip++; \
+ (pVM)->runningWord = tempFW; \
+ tempFW->code(pVM); \
+ }
+
+
+#if INLINE_INNER_LOOP != 0
+#define vmInnerLoop(pVM) M_INNER_LOOP(pVM)
+#else
+void vmInnerLoop(FICL_VM *pVM);
+#endif
+
+/*
** vmCheckStack needs a vm pointer because it might have to say
** something if it finds a problem. Parms popCells and pushCells
** correspond to the number of parameters on the left and right of
@@ -511,9 +564,11 @@
** PopTib restores the TIB state given a saved TIB from PushTib
** GetInBuf returns a pointer to the next unused char of the TIB
*/
-void vmPushTib(FICL_VM *pVM, char *text, TIB *pSaveTib);
+void vmPushTib(FICL_VM *pVM, char *text, INT32 nChars, TIB *pSaveTib);
void vmPopTib(FICL_VM *pVM, TIB *pTib);
#define vmGetInBuf(pVM) ((pVM)->tib.cp + (pVM)->tib.index)
+#define vmGetInBufLen(pVM) ((pVM)->tib.end - (pVM)->tib.cp)
+#define vmGetInBufEnd(pVM) ((pVM)->tib.end)
#define vmSetTibIndex(pVM, i) (pVM)->tib.index = i
#define vmUpdateTib(pVM, str) (pVM)->tib.index = (str) - (pVM)->tib.cp
@@ -529,11 +584,13 @@
#pragma warning(disable: 4273)
#endif
-char *ltoa( INT32 value, char *string, int radix );
-char *ultoa(UNS32 value, char *string, int radix );
+int isPowerOfTwo(FICL_UNS u);
+
+char *ltoa( FICL_INT value, char *string, int radix );
+char *ultoa(FICL_UNS value, char *string, int radix );
char digit_to_char(int value);
char *strrev( char *string );
-char *skipSpace(char *cp);
+char *skipSpace(char *cp, char *end);
char *caseFold(char *cp);
int strincmp(char *cp1, char *cp2, FICL_COUNT count);
@@ -548,7 +605,7 @@
** A WORDLIST (see the search order word set in DPANS) is
** just a pointer to a FICL_HASH in this implementation.
*/
-#if !defined HASHSIZE /* Default size of hash table. For best */
+#if !defined HASHSIZE /* Default size of hash table. For most uniform */
#define HASHSIZE 127 /* performance, use a prime number! */
#endif
@@ -625,7 +682,7 @@
STRINGINFO si,
FICL_CODE pCode,
UNS8 flags);
-void dictAppendUNS32(FICL_DICT *pDict, UNS32 u);
+void dictAppendUNS(FICL_DICT *pDict, FICL_UNS u);
int dictCellsAvail(FICL_DICT *pDict);
int dictCellsUsed (FICL_DICT *pDict);
void dictCheck(FICL_DICT *pDict, FICL_VM *pVM, int nCells);
@@ -675,7 +732,8 @@
** f i c l E x e c
** Evaluates a block of input text in the context of the
** specified interpreter. Emits any requested output to the
-** interpreter's output function
+** interpreter's output function. If the input string is NULL
+** terminated, you can pass -1 as nChars rather than count it.
** Execution returns when the text block has been executed,
** or an error occurs.
** Returns one of the VM_XXXX codes defined in ficl.h:
@@ -687,10 +745,14 @@
** to shut down the interpreter. This would be a good
** time to delete the vm, etc -- or you can ignore this
** signal.
+** VM_ABORT and VM_ABORTQ are generated by 'abort' and 'abort"'
+** commands.
** Preconditions: successful execution of ficlInitSystem,
** Successful creation and init of the VM by ficlNewVM (or equiv)
*/
-int ficlExec(FICL_VM *pVM, char *pText);
+int ficlExec (FICL_VM *pVM, char *pText);
+int ficlExecC(FICL_VM *pVM, char *pText, INT32 nChars);
+int ficlExecXT(FICL_VM *pVM, FICL_WORD *pWord);
/*
** Create a new VM from the heap, and link it into the system VM list.
@@ -699,6 +761,12 @@
** Precondition: successful execution of ficlInitSystem
*/
FICL_VM *ficlNewVM(void);
+
+/*
+** Set the stack sizes (return and parameter) to be used for all
+** subsequently created VMs. Returns actual stack size to be used.
+*/
+int ficlSetStackSize(int nStackCells);
/*
** Returns the address of the most recently defined word in the system
--- a/softwords/classes.fr
+++ b/softwords/classes.fr
@@ -4,6 +4,7 @@
\ Needs oop.fr
.( loading ficl utility classes ) cr
+also oop definitions
\ REF subclass holds a pointer to an object. It's
\ mainly for aggregation to help in making data structures.
@@ -40,47 +41,100 @@
end-class
-\ ** C - C E L L P T R C L A S S
-\ Models a pointer to cell.
-\ This class is simple enough that its methods could easily
-\ be written in straight Forth, but this implementation is OO
-\ so that I'm practicing what I preach. Also, it would be
-\ safe in this case to use early binding, but it's more
-\ maintainable not to.
-object subclass c-cellPtr
+\ ** C - P T R
+\ Base class for pointers to scalars (not objects).
+\ Note: use c-ref to make references to objects. C-ptr
+\ subclasses refer to untyped quantities of various sizes.
+
+\ Derived classes must specify the size of the thing
+\ they point to, and supply get and set methods.
+
+\ All derived classes must define the @size method:
+\ @size ( inst class -- addr-units )
+\ Returns the size in address units of the thing the pointer
+\ refers to.
+object subclass c-ptr
c-4byte obj: .addr
\ get the value of the pointer
: get-ptr ( inst class -- addr )
- --> .addr --> get ;
+ c-ptr => .addr
+ c-4byte => get
+ ;
\ set the pointer to address supplied
: set-ptr ( addr inst class -- )
- --> .addr --> set ;
+ c-ptr => .addr
+ c-4byte => set
+ ;
+ \ increment the pointer in place
+ : inc-ptr ( inst class -- )
+ 2dup 2dup ( i c i c i c )
+ c-ptr => get-ptr -rot ( i c addr i c )
+ --> @size + -rot ( addr' i c )
+ c-ptr => set-ptr
+ ;
+
+ \ decrement the pointer in place
+ : dec-ptr ( inst class -- )
+ 2dup 2dup ( i c i c i c )
+ c-ptr => get-ptr -rot ( i c addr i c )
+ --> @size - -rot ( addr' i c )
+ c-ptr => set-ptr
+ ;
+
+ \ index the pointer in place
+ : index-ptr ( index inst class -- )
+ locals| class inst index |
+ inst class c-ptr => get-ptr ( addr )
+ inst class --> @size index * + ( addr' )
+ inst class c-ptr => set-ptr
+ ;
+
+end-class
+
+
+\ ** C - C E L L P T R
+\ Models a pointer to cell (a 32 bit scalar).
+c-ptr subclass c-cellPtr
+ : @size 2drop 4 ;
\ fetch and store through the pointer
: get ( inst class -- cell )
- --> get-ptr @ ;
- : set ( cell inst class -- )
- --> get-ptr ! ;
+ c-ptr => get-ptr @
+ ;
+ : set ( value inst class -- )
+ c-ptr => get-ptr !
+ ;
+end-class
- \ increment the pointer in-place
- : inc-ptr ( inst class -- )
- 0 locals| ptr |
- --> .addr \ ( a-inst a-class )
- 2dup --> get to ptr \ ( a-inst a-class )
- 2dup --> size ptr swap + \ ( a-inst a-class ptr' )
- rot rot --> set
+
+\ ** C - 2 B Y T E P T R
+\ Models a pointer to a 16 bit scalar
+c-ptr subclass c-2bytePtr
+ : @size 2drop 2 ;
+ \ fetch and store through the pointer
+ : get ( inst class -- value )
+ c-ptr => get-ptr w@
;
+ : set ( value inst class -- )
+ c-ptr => get-ptr w!
+ ;
+end-class
- \ Decrement the pointer in-place
- : dec-ptr ( inst class -- )
- 0 locals| ptr |
- --> .addr \ ( a-inst a-class )
- 2dup --> get to ptr \ ( a-inst a-class )
- 2dup --> size ptr swap - \ ( a-inst a-class ptr' )
- rot rot --> set
+
+\ ** C - B Y T E P T R
+\ Models a pointer to an 8 bit scalar
+c-ptr subclass c-bytePtr
+ : @size 2drop 1 ;
+ \ fetch and store through the pointer
+ : get ( inst class -- value )
+ c-ptr => get-ptr c@
;
+ : set ( value inst class -- )
+ c-ptr => get-ptr c!
+ ;
end-class
+previous definitions
--- a/softwords/ficlclass.fr
+++ b/softwords/ficlclass.fr
@@ -11,14 +11,14 @@
c-2byte obj: .hashcode
c-byte obj: .flags
c-byte obj: .nName
- c-4byte obj: .pName
- c-4byte obj: .pCode
+ c-bytePtr obj: .pName
+ c-cellPtr obj: .pCode
c-4byte obj: .param0
\ Push word's name...
: get-name ( inst class -- c-addr u )
2dup
- --> .pName --> get -rot
+ --> .pName --> get-ptr -rot
--> .nName --> get
;
@@ -25,7 +25,7 @@
: next ( inst class -- link-inst class )
--> .link ;
- : info
+ : ?
." ficl word: "
2dup --> get-name type cr
." hash = "
@@ -39,9 +39,9 @@
\ ** C - W O R D L I S T
\ Example of use:
\ get-current c-wordlist --> ref current
-\ current --> info
-\ current --> .hash --> info
-\ current --> .hash --> next --> info
+\ current --> ?
+\ current --> .hash --> ?
+\ current --> .hash --> next --> ?
object subclass c-wordlist
c-wordlist ref: .parent
@@ -48,7 +48,7 @@
c-4byte obj: .size
c-word ref: .hash
- : info
+ : ?
2drop ." ficl wordlist " cr ;
: push drop >search ;
: pop 2drop previous ;
@@ -67,7 +67,7 @@
c-4byte obj: .stackBase
: init 2drop ;
- : info 2drop
+ : ? 2drop
." ficl stack " cr ;
: top
--> .sp --> .addr --> prev --> get ;
@@ -78,6 +78,10 @@
\ 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...
+\ Creation example:
+\ 80 c-string --> new str80
+\ s" arf arf!!" str80 --> set
+\ str80 --> type cr
\
object subclass c-string
c-byte obj: .count
@@ -96,5 +100,11 @@
dup
inst class --> .count --> set
inst class --> .text swap move ;
+
+ : get ( inst class -- c-addr u )
+ 2dup
+ --> .text -rot
+ --> .count --> get
+ ;
end-class
--- a/softwords/ifbrack.fr
+++ b/softwords/ifbrack.fr
@@ -1,10 +1,9 @@
\ ** ficl/softwords/ifbrack.fr
\ ** ANS conditional compile directives [if] [else] [then]
\ ** Requires ficl 2.0 or greater...
-\ Does not work correctly with ficl's load command
-\ bacause load sets SOURCE-ID to -1, causing REFILL to
-\ return FALSE.
+hidden dup >search ficl-set-current
+
: ?[if] ( c-addr u -- c-addr u flag )
2dup 2dup
s" [if]" compare 0= >r
@@ -26,6 +25,8 @@
or
;
+set-current
+
: [else] ( -- )
1 \ ( level )
begin
@@ -50,3 +51,4 @@
: [then] ( -- ) ; immediate
+previous
--- a/softwords/oo.fr
+++ b/softwords/oo.fr
@@ -295,6 +295,24 @@
--> array-init
;
+\ Create an anonymous initialized instance from the heap
+: alloc \ ( class metaclass -- instance class )
+ locals| meta class |
+ class meta metaclass => get-size allocate ( -- addr fail-flag )
+ abort" allocate failed " ( -- addr )
+ class
+;
+
+\ Create an anonymous array of initialized instances from the heap
+: alloc-array \ ( n class metaclass -- instance class )
+ locals| meta class nobj |
+ class meta metaclass => get-size
+ nobj * allocate ( -- addr fail-flag )
+ abort" allocate failed " ( -- addr )
+ nobj over class --> array-init
+ class
+;
+
\ create a proxy object with initialized payload address given
: ref ( instance-addr class metaclass "name" -- )
drop create , ,
@@ -410,6 +428,14 @@
&init execute
&next execute drop to inst
loop
+;
+
+\ free storage allocated to a heap instance by alloc or alloc-array
+\ NOTE: not protected against errors like FREEing something that's
+\ really in the dictionary.
+: free \ ( instance class -- )
+ drop free
+ abort" free failed "
;
\ Instance aliases for common class methods
--- a/softwords/softcore.bat
+++ b/softwords/softcore.bat
@@ -1,1 +1,1 @@
-\perl\bin\perl.exe softcore.pl softcore.fr oo.fr classes.fr >..\softcore.c
+\perl\bin\perl.exe softcore.pl softcore.fr jhlocal.fr marker.fr oo.fr classes.fr >..\softcore.c
--- a/softwords/softcore.fr
+++ b/softwords/softcore.fr
@@ -47,6 +47,8 @@
: erase ( addr u -- ) 0 fill ;
: nip ( y x -- x ) swap drop ;
: tuck ( y x -- x y x) swap over ;
+: within ( test low high -- flag ) over - >r - r> u< ;
+
\ ** LOCAL EXT word set
\ #if FICL_WANT_LOCALS
--- a/sysdep.c
+++ b/sysdep.c
@@ -13,15 +13,16 @@
#include <stdio.h>
#include "ficl.h"
-
+
/*
******************* P C / W I N 3 2 P O R T B E G I N S H E R E ***********************
*/
#if defined (_M_IX86)
-UNS64 ficlLongMul(UNS32 x, UNS32 y)
+#if PORTABLE_LONGMULDIV == 0
+DPUNS ficlLongMul(FICL_UNS x, FICL_UNS y)
{- UNS64 q;
+ DPUNS q;
__asm
{@@ -35,7 +36,7 @@
return q;
}
-UNSQR ficlLongDiv(UNS64 q, UNS32 y)
+UNSQR ficlLongDiv(DPUNS q, FICL_UNS y)
{UNSQR result;
@@ -51,6 +52,8 @@
return result;
}
+#endif
+
#if !defined (_WINDOWS)
void ficlTextOut(FICL_VM *pVM, char *msg, int fNewline)
@@ -72,11 +75,21 @@
return malloc(size);
}
+
void ficlFree (void *p)
{free(p);
}
+
+void *ficlRealloc(void *p, size_t size)
+{+ if (p)
+ free(p);
+
+ return malloc(size);
+}
+
/*
** Stub function for dictionary access control - does nothing
** by default, user can redefine to guarantee exclusive dict
@@ -102,9 +115,10 @@
*/
#elif defined (MOTO_CPU32)
-UNS64 ficlLongMul(UNS32 x, UNS32 y)
+#if PORTABLE_LONGMULDIV == 0
+DPUNS ficlLongMul(FICL_UNS x, FICL_UNS y)
{- UNS64 q;
+ DPUNS q;
IGNORE(q); /* suppress goofy compiler warnings */
IGNORE(x);
IGNORE(y);
@@ -119,7 +133,7 @@
return q;
}
-UNSQR ficlLongDiv(UNS64 q, UNS32 y)
+UNSQR ficlLongDiv(DPUNS q, FICL_UNS y)
{UNSQR result;
IGNORE(result); /* suppress goofy compiler warnings */
@@ -137,6 +151,8 @@
return result;
}
+#endif
+
void ficlTextOut(FICL_VM *pVM, char *msg, int fNewline)
{return;
@@ -150,6 +166,17 @@
{}
+
+void *ficlRealloc(void *p, size_t size)
+{+ if (p)
+ free(p);
+
+ return malloc(size);
+}
+
+
+
/*
** Stub function for dictionary access control - does nothing
** by default, user can redefine to guarantee exclusive dict
@@ -178,9 +205,10 @@
#ifdef linux
-UNS64 ficlLongMul(UNS32 x, UNS32 y)
+#if PORTABLE_LONGMULDIV == 0
+DPUNS ficlLongMul(FICL_UNS x, FICL_UNS y)
{- UNS64 q;
+ DPUNS q;
__u64 qx;
qx = (__u64)x * (__u64) y;
@@ -191,7 +219,7 @@
return q;
}
-UNSQR ficlLongDiv(UNS64 q, UNS32 y)
+UNSQR ficlLongDiv(DPUNS q, FICL_UNS y)
{UNSQR result;
__u64 qx, qh;
@@ -205,6 +233,8 @@
return result;
}
+#endif
+
void ficlTextOut(FICL_VM *pVM, char *msg, int fNewline)
{IGNORE(pVM);
@@ -226,6 +256,15 @@
{free(p);
}
+
+void *ficlRealloc(void *p, size_t size)
+{+ if (p)
+ free(p);
+
+ return malloc(size);
+}
+
/*
** Stub function for dictionary access control - does nothing
--- a/sysdep.h
+++ b/sysdep.h
@@ -37,7 +37,6 @@
#include <stddef.h> /* size_t, NULL */
#include <setjmp.h>
-
#include <assert.h>
#if !defined IGNORE /* Macro to silence unused param warnings */
@@ -44,7 +43,6 @@
#define IGNORE(x) &x
#endif
-
/*
** TRUE and FALSE for C boolean operations, and
** portable 32 bit types for CELLs
@@ -58,6 +56,9 @@
#endif
+/*
+** System dependent data type declarations...
+*/
#if !defined INT32
#define INT32 long
#endif
@@ -78,28 +79,52 @@
#define NULL ((void *)0)
#endif
+/*
+** FICL_UNS and FICL_INT must have the same size as a void* on
+** the target system. A CELL is a union of void*, FICL_UNS, and
+** FICL_INT.
+*/
+#if !defined FICL_INT
+#define FICL_INT INT32
+#endif
+
+#if !defined FICL_UNS
+#define FICL_UNS UNS32
+#endif
+
+/*
+** Ficl presently supports values of 32 and 64 for BITS_PER_CELL
+*/
+#if !defined BITS_PER_CELL
+#define BITS_PER_CELL 32
+#endif
+
+#if ((BITS_PER_CELL != 32) && (BITS_PER_CELL != 64))
+ Error!
+#endif
+
typedef struct
{- UNS32 hi;
- UNS32 lo;
-} UNS64;
+ FICL_UNS hi;
+ FICL_UNS lo;
+} DPUNS;
typedef struct
{- UNS32 quot;
- UNS32 rem;
+ FICL_UNS quot;
+ FICL_UNS rem;
} UNSQR;
typedef struct
{- INT32 hi;
- INT32 lo;
-} INT64;
+ FICL_INT hi;
+ FICL_INT lo;
+} DPINT;
typedef struct
{- INT32 quot;
- INT32 rem;
+ FICL_INT quot;
+ FICL_INT rem;
} INTQR;
@@ -113,6 +138,30 @@
#endif
/*
+** PORTABLE_LONGMULDIV causes ficlLongMul and ficlLongDiv to be
+** defined in C in sysdep.c. Use this if you cannot easily
+** generate an inline asm definition
+*/
+#if !defined (PORTABLE_LONGMULDIV)
+#define PORTABLE_LONGMULDIV 0
+#endif
+
+
+/*
+** INLINE_INNER_LOOP causes the inner interpreter to be inline code
+** instead of a function call. This is mainly because MS VC++ 5
+** chokes with an internal compiler error on the function version.
+** in release mode. Sheesh.
+*/
+#if !defined INLINE_INNER_LOOP
+#if defined _DEBUG
+#define INLINE_INNER_LOOP 0
+#else
+#define INLINE_INNER_LOOP 1
+#endif
+#endif
+
+/*
** FICL_ROBUST enables bounds checking of stacks and the dictionary.
** This will detect stack over and underflows and dictionary overflows.
** Any exceptional condition will result in an assertion failure.
@@ -190,7 +239,7 @@
** pointer address must be aligned. This value is usually
** either 1 or 2, depending on the memory architecture
** of the target system; 2 is safe on any 16 or 32 bit
-** machine.
+** machine. 3 would be appropriate for a 64 bit machine.
*/
#if !defined FICL_ALIGN
#define FICL_ALIGN 2
@@ -214,7 +263,7 @@
void ficlTextOut(struct vm *pVM, char *msg, int fNewline);
void *ficlMalloc (size_t size);
void ficlFree (void *p);
-
+void *ficlRealloc(void *p, size_t size);
/*
** Stub function for dictionary access control - does nothing
** by default, user can redefine to guarantee exclusive dict
@@ -238,12 +287,12 @@
/*
** 64 bit integer math support routines: multiply two UNS32s
-** to get a 64 bit prodict, & divide the product by an UNS32
+** to get a 64 bit product, & divide the product by an UNS32
** to get an UNS32 quotient and remainder. Much easier in asm
** on a 32 bit CPU than in C, which usually doesn't support
** the double length result (but it should).
*/
-UNS64 ficlLongMul(UNS32 x, UNS32 y);
-UNSQR ficlLongDiv(UNS64 q, UNS32 y);
+DPUNS ficlLongMul(FICL_UNS x, FICL_UNS y);
+UNSQR ficlLongDiv(DPUNS q, FICL_UNS y);
#endif /*__SYSDEP_H__*/
--- a/testmain.c
+++ b/testmain.c
@@ -113,7 +113,7 @@
int nLine = 0;
FILE *fp;
int result;
- UNS32 id;
+ CELL id;
#ifdef WIN32
struct _stat buf;
#else
@@ -154,7 +154,7 @@
}
id = pVM->sourceID;
- pVM->sourceID = -1;
+ pVM->sourceID.p = (void *)fp;
/* feed each line to ficlExec */
while (fgets(cp, nLINEBUF, fp))
@@ -177,6 +177,12 @@
break;
}
}
+ /*
+ ** Pass an empty line with SOURCE-ID == 0 to flush
+ ** any pending REFILLs (as required by FILE wordset)
+ */
+ pVM->sourceID.i = -1;
+ ficlExec(pVM, "");
pVM->sourceID = id;
fclose(fp);
--- a/vm.c
+++ b/vm.c
@@ -43,11 +43,9 @@
if (pVM == NULL)
{pVM = (FICL_VM *)ficlMalloc(sizeof (FICL_VM));
- pVM->pStack = NULL;
- pVM->rStack = NULL;
- pVM->link = NULL;
+ assert (pVM);
+ memset(pVM, 0, sizeof (FICL_VM));
}
- assert (pVM);
if (pVM->pStack)
stackDelete(pVM->pStack);
@@ -83,7 +81,10 @@
/**************************************************************************
v m E x e c u t e
-**
+** Sets up the specified word to be run by the inner interpreter.
+** Executes the word's code part immediately, but in the case of
+** colon definition, the definition itself needs the inner interp
+** to complete. This does not happen until control reaches ficlExec
**************************************************************************/
void vmExecute(FICL_VM *pVM, FICL_WORD *pWord)
{@@ -94,6 +95,24 @@
/**************************************************************************
+ v m I n n e r L o o p
+** the mysterious inner interpreter...
+** This loop is the address interpreter that makes colon definitions
+** work. Upon entry, it assumes that the IP points to an entry in
+** a definition (the body of a colon word). It runs one word at a time
+** until something does vmThrow. The catcher for this is expected to exist
+** in the calling code.
+** vmThrow gets you out of this loop with a longjmp()
+** Visual C++ 5 chokes on this loop in Release mode. Aargh.
+**************************************************************************/
+#if INLINE_INNER_LOOP == 0
+void vmInnerLoop(FICL_VM *pVM)
+{+ M_INNER_LOOP(pVM);
+}
+#endif
+
+/**************************************************************************
v m G e t S t r i n g
** Parses a string out of the VM input buffer and copies up to the first
** FICL_STRING_MAX characters to the supplied destination buffer, a
@@ -147,15 +166,16 @@
**************************************************************************/
STRINGINFO vmGetWord0(FICL_VM *pVM)
{- char *pSrc = vmGetInBuf(pVM);
+ char *pSrc = vmGetInBuf(pVM);
+ char *pEnd = vmGetInBufEnd(pVM);
STRINGINFO si;
UNS32 count = 0;
char ch;
- pSrc = skipSpace(pSrc);
+ pSrc = skipSpace(pSrc, pEnd);
SI_SETPTR(si, pSrc);
- for (ch = *pSrc; ch != '\0' && !isspace(ch); ch = *++pSrc)
+ for (ch = *pSrc; (pEnd != pSrc) && !isspace(ch); ch = *++pSrc)
{count++;
}
@@ -162,7 +182,7 @@
SI_SETLEN(si, count);
- if (isspace(ch)) /* skip one trailing delimiter */
+ if ((pEnd != pSrc) && isspace(ch)) /* skip one trailing delimiter */
pSrc++;
vmUpdateTib(pVM, pSrc);
@@ -206,15 +226,16 @@
{STRINGINFO si;
char *pSrc = vmGetInBuf(pVM);
+ char *pEnd = vmGetInBufEnd(pVM);
char ch;
- while (*pSrc == delim) /* skip lead delimiters */
+ while ((pSrc != pEnd) && (*pSrc == delim)) /* skip lead delimiters */
pSrc++;
SI_SETPTR(si, pSrc); /* mark start of text */
- for (ch = *pSrc; (ch != delim)
- && (ch != '\0')
+ for (ch = *pSrc; (pSrc != pEnd)
+ && (ch != delim)
&& (ch != '\r')
&& (ch != '\n'); ch = *++pSrc)
{@@ -224,7 +245,7 @@
/* set length of result */
SI_SETLEN(si, pSrc - SI_PTR(si));
- if (*pSrc == delim) /* gobble trailing delimiter */
+ if ((pSrc != pEnd) && (*pSrc == delim)) /* gobble trailing delimiter */
pSrc++;
vmUpdateTib(pVM, pSrc);
@@ -259,7 +280,7 @@
v m P u s h T i b
** Binds the specified input string to the VM and clears >IN (the index)
**************************************************************************/
-void vmPushTib(FICL_VM *pVM, char *text, TIB *pSaveTib)
+void vmPushTib(FICL_VM *pVM, char *text, FICL_INT nChars, TIB *pSaveTib)
{if (pSaveTib)
{@@ -267,6 +288,7 @@
}
pVM->tib.cp = text;
+ pVM->tib.end = text + nChars;
pVM->tib.index = 0;
}
@@ -298,6 +320,7 @@
pVM->runningWord = pInterp;
pVM->state = INTERPRET;
pVM->tib.cp = NULL;
+ pVM->tib.end = NULL;
pVM->tib.index = 0;
pVM->pad[0] = '\0';
pVM->sourceID.i = 0;
@@ -354,7 +377,8 @@
**************************************************************************/
void vmThrow(FICL_VM *pVM, int except)
{- longjmp(*(pVM->pState), except);
+ if (pVM->pState)
+ longjmp(*(pVM->pState), except);
}
@@ -426,32 +450,65 @@
/**************************************************************************
+ i s P o w e r O f T w o
+** Tests whether supplied argument is an integer power of 2 (2**n)
+** where 32 > n > 1, and returns n if so. Otherwise returns zero.
+**************************************************************************/
+int isPowerOfTwo(FICL_UNS u)
+{+ int i = 1;
+ FICL_UNS t = 2;
+
+ for (; ((t <= u) && (t != 0)); i++, t <<= 1)
+ {+ if (u == t)
+ return i;
+ }
+
+ return 0;
+}
+
+
+/**************************************************************************
l t o a
**
**************************************************************************/
-char *ltoa( INT32 value, char *string, int radix )
+char *ltoa( FICL_INT value, char *string, int radix )
{ /* convert long to string, any base */char *cp = string;
int sign = ((radix == 10) && (value < 0));
- UNSQR result;
- UNS64 v;
+ int pwr;
assert(radix > 1);
assert(radix < 37);
assert(string);
+ pwr = isPowerOfTwo((FICL_UNS)radix);
+
if (sign)
value = -value;
if (value == 0)
*cp++ = '0';
+ else if (pwr != 0)
+ {+ FICL_UNS v = (FICL_UNS) value;
+ FICL_UNS mask = (FICL_UNS) ~(-1 << pwr);
+ while (v)
+ {+ *cp++ = digits[v & mask];
+ v >>= pwr;
+ }
+ }
else
{+ UNSQR result;
+ DPUNS v;
v.hi = 0;
- v.lo = (UNS32)value;
+ v.lo = (FICL_UNS)value;
while (v.lo)
{- result = ficlLongDiv(v, (UNS32)radix);
+ result = ficlLongDiv(v, (FICL_UNS)radix);
*cp++ = digits[result.rem];
v.lo = result.quot;
}
@@ -470,10 +527,10 @@
u l t o a
**
**************************************************************************/
-char *ultoa(UNS32 value, char *string, int radix )
+char *ultoa(FICL_UNS value, char *string, int radix )
{ /* convert long to string, any base */char *cp = string;
- UNS64 ud;
+ DPUNS ud;
UNSQR result;
assert(radix > 1);
@@ -547,12 +604,14 @@
s k i p S p a c e
** Given a string pointer, returns a pointer to the first non-space
** char of the string, or to the NULL terminator if no such char found.
+** If the pointer reaches "end" first, stop there. Pass NULL to
+** suppress this behavior.
**************************************************************************/
-char *skipSpace(char *cp)
+char *skipSpace(char *cp, char *end)
{assert(cp);
- while (isspace(*cp))
+ while ((cp != end) && isspace(*cp))
cp++;
return cp;
--- a/words.c
+++ b/words.c
@@ -24,12 +24,12 @@
** check for structure completion.
*/
static char doTag[] = "do";
-static char ifTag[] = "if";
static char colonTag[] = "colon";
static char leaveTag[] = "leave";
-static char beginTag[] = "begin";
-static char whileTag[] = "while";
+static char destTag[] = "target";
+static char origTag[] = "origin";
+
/*
** Pointers to various words in the dictionary
** -- initialized by ficlCompileCore, below --
@@ -90,8 +90,7 @@
char *cp = (char *)stackPopPtr(pVM->pStack);
if ( strcmp(cp, tag) )
{- vmTextOut(pVM, "Warning -- unmatched control word: ", 0);
- vmTextOut(pVM, tag, 1);
+ vmThrowErr(pVM, "Error -- unmatched control structure \"%s\"", tag);
}
return;
@@ -169,7 +168,7 @@
static int isNumber(FICL_VM *pVM, STRINGINFO si)
{- INT32 accum = 0;
+ FICL_INT accum = 0;
char isNeg = FALSE;
unsigned base = pVM->base;
char *cp = SI_PTR(si);
@@ -195,7 +194,7 @@
while (count-- && ((ch = *cp++) != '\0'))
{- if (ch < '0')
+ if (!isalnum(ch))
return FALSE;
digit = ch - '0';
@@ -202,10 +201,7 @@
if (digit > 9)
digit = tolower(ch) - 'a' + 10;
- /*
- ** Note: following test also catches chars between 9 and a
- ** because 'digit' is unsigned!
- */
+
if (digit >= base)
return FALSE;
@@ -213,9 +209,9 @@
}
if (isNeg)
- accum = -accum;
+ accum = -accum;
- stackPushINT32(pVM->pStack, accum);
+ stackPushINT(pVM->pStack, accum);
return TRUE;
}
@@ -228,11 +224,11 @@
static void add(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 2, 1);
#endif
- i = stackPopINT32(pVM->pStack);
+ i = stackPopINT(pVM->pStack);
i += stackGetTop(pVM->pStack).i;
stackSetTop(pVM->pStack, LVALUEtoCELL(i));
return;
@@ -240,11 +236,11 @@
static void sub(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 2, 1);
#endif
- i = stackPopINT32(pVM->pStack);
+ i = stackPopINT(pVM->pStack);
i = stackGetTop(pVM->pStack).i - i;
stackSetTop(pVM->pStack, LVALUEtoCELL(i));
return;
@@ -252,11 +248,11 @@
static void mul(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 2, 1);
#endif
- i = stackPopINT32(pVM->pStack);
+ i = stackPopINT(pVM->pStack);
i *= stackGetTop(pVM->pStack).i;
stackSetTop(pVM->pStack, LVALUEtoCELL(i));
return;
@@ -264,22 +260,22 @@
static void negate(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
- i = -stackPopINT32(pVM->pStack);
- stackPushINT32(pVM->pStack, i);
+ i = -stackPopINT(pVM->pStack);
+ stackPushINT(pVM->pStack, i);
return;
}
static void ficlDiv(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 2, 1);
#endif
- i = stackPopINT32(pVM->pStack);
+ i = stackPopINT(pVM->pStack);
i = stackGetTop(pVM->pStack).i / i;
stackSetTop(pVM->pStack, LVALUEtoCELL(i));
return;
@@ -296,26 +292,26 @@
*/
static void slashMod(FICL_VM *pVM)
{- INT64 n1;
- INT32 n2;
+ DPINT n1;
+ FICL_INT n2;
INTQR qr;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 2, 2);
#endif
- n2 = stackPopINT32(pVM->pStack);
- n1.lo = stackPopINT32(pVM->pStack);
+ n2 = stackPopINT(pVM->pStack);
+ n1.lo = stackPopINT(pVM->pStack);
i64Extend(n1);
qr = m64SymmetricDivI(n1, n2);
- stackPushINT32(pVM->pStack, qr.rem);
- stackPushINT32(pVM->pStack, qr.quot);
+ stackPushINT(pVM->pStack, qr.rem);
+ stackPushINT(pVM->pStack, qr.quot);
return;
}
static void onePlus(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
@@ -327,7 +323,7 @@
static void oneMinus(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
@@ -339,7 +335,7 @@
static void twoMul(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
@@ -351,7 +347,7 @@
static void twoDiv(FICL_VM *pVM)
{- INT32 i;
+ FICL_INT i;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
@@ -363,19 +359,19 @@
static void mulDiv(FICL_VM *pVM)
{- INT32 x, y, z;
- INT64 prod;
+ FICL_INT x, y, z;
+ DPINT prod;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 3, 1);
#endif
- z = stackPopINT32(pVM->pStack);
- y = stackPopINT32(pVM->pStack);
- x = stackPopINT32(pVM->pStack);
+ z = stackPopINT(pVM->pStack);
+ y = stackPopINT(pVM->pStack);
+ x = stackPopINT(pVM->pStack);
prod = m64MulI(x,y);
x = m64SymmetricDivI(prod, z).quot;
- stackPushINT32(pVM->pStack, x);
+ stackPushINT(pVM->pStack, x);
return;
}
@@ -382,21 +378,21 @@
static void mulDivRem(FICL_VM *pVM)
{- INT32 x, y, z;
- INT64 prod;
+ FICL_INT x, y, z;
+ DPINT prod;
INTQR qr;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 3, 2);
#endif
- z = stackPopINT32(pVM->pStack);
- y = stackPopINT32(pVM->pStack);
- x = stackPopINT32(pVM->pStack);
+ z = stackPopINT(pVM->pStack);
+ y = stackPopINT(pVM->pStack);
+ x = stackPopINT(pVM->pStack);
prod = m64MulI(x,y);
qr = m64SymmetricDivI(prod, z);
- stackPushINT32(pVM->pStack, qr.rem);
- stackPushINT32(pVM->pStack, qr.quot);
+ stackPushINT(pVM->pStack, qr.rem);
+ stackPushINT(pVM->pStack, qr.quot);
return;
}
@@ -619,11 +615,11 @@
static void uDot(FICL_VM *pVM)
{- UNS32 u;
+ FICL_UNS u;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 0);
#endif
- u = stackPopUNS32(pVM->pStack);
+ u = stackPopUNS(pVM->pStack);
ultoa(u, pVM->pad, pVM->base);
strcat(pVM->pad, " ");
vmTextOut(pVM, pVM->pad, 0);
@@ -633,11 +629,11 @@
static void hexDot(FICL_VM *pVM)
{- UNS32 u;
+ FICL_UNS u;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 0);
#endif
- u = stackPopUNS32(pVM->pStack);
+ u = stackPopUNS(pVM->pStack);
ultoa(u, pVM->pad, 16);
strcat(pVM->pad, " ");
vmTextOut(pVM, pVM->pad, 0);
@@ -683,7 +679,7 @@
vmCheckStack(pVM, 0, 1);
#endif
i = stackDepth(pVM->pStack);
- stackPushINT32(pVM->pStack, i);
+ stackPushINT(pVM->pStack, i);
return;
}
@@ -843,7 +839,7 @@
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 0);
#endif
- i = stackPopINT32(pVM->pStack);
+ i = stackPopINT(pVM->pStack);
cp[0] = (char)i;
cp[1] = '\0';
vmTextOut(pVM, cp, 0);
@@ -860,10 +856,11 @@
static void commentLine(FICL_VM *pVM)
{- char *cp = vmGetInBuf(pVM);
+ char *cp = vmGetInBuf(pVM);
+ char *pEnd = vmGetInBufEnd(pVM);
char ch = *cp;
- while ((ch != '\0') && (ch != '\r') && (ch != '\n'))
+ while ((cp != pEnd) && (ch != '\r') && (ch != '\n'))
{ch = *++cp;
}
@@ -873,11 +870,11 @@
** Check for /r, /n, /r/n, or /n/r end-of-line sequences,
** and point cp to next char. If EOL is \0, we're done.
*/
- if (ch != '\0')
+ if (cp != pEnd)
{cp++;
- if ( (ch != *cp)
+ if ( (cp != pEnd) && (ch != *cp)
&& ((*cp == '\r') || (*cp == '\n')) )
cp++;
}
@@ -987,7 +984,7 @@
vmCheckStack(pVM, 1, 1);
#endif
pw = (UNS16 *)stackPopPtr(pVM->pStack);
- stackPushUNS32(pVM->pStack, (UNS32)*pw);
+ stackPushUNS(pVM->pStack, (FICL_UNS)*pw);
return;
}
@@ -1008,7 +1005,7 @@
vmCheckStack(pVM, 1, 1);
#endif
pc = (UNS8 *)stackPopPtr(pVM->pStack);
- stackPushUNS32(pVM->pStack, (UNS32)*pc);
+ stackPushUNS(pVM->pStack, (FICL_UNS)*pc);
return;
}
@@ -1038,8 +1035,8 @@
assert(pIfParen);
dictAppendCell(dp, LVALUEtoCELL(pIfParen));
- markBranch(dp, pVM, ifTag);
- dictAppendUNS32(dp, 1);
+ markBranch(dp, pVM, origTag);
+ dictAppendUNS(dp, 1);
return;
}
@@ -1053,12 +1050,12 @@
static void ifParen(FICL_VM *pVM)
{- UNS32 flag;
+ FICL_UNS flag;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 0);
#endif
- flag = stackPopUNS32(pVM->pStack);
+ flag = stackPopUNS(pVM->pStack);
if (flag)
{ /* fall through */@@ -1094,11 +1091,11 @@
assert(pBranchParen);
/* (1) compile branch runtime */
dictAppendCell(dp, LVALUEtoCELL(pBranchParen));
- matchControlTag(pVM, ifTag);
+ matchControlTag(pVM, origTag);
patchAddr =
(CELL *)stackPopPtr(pVM->pStack); /* (2) pop "if" patch addr */
- markBranch(dp, pVM, ifTag); /* (4) push "else" patch addr */
- dictAppendUNS32(dp, 1); /* (1) compile patch placeholder */
+ markBranch(dp, pVM, origTag); /* (4) push "else" patch addr */
+ dictAppendUNS(dp, 1); /* (1) compile patch placeholder */
offset = dp->here - patchAddr;
*patchAddr = LVALUEtoCELL(offset); /* (3) Patch "if" */
@@ -1128,7 +1125,7 @@
static void endifCoIm(FICL_VM *pVM)
{FICL_DICT *dp = ficlGetDict();
- resolveForwardBranch(dp, pVM, ifTag);
+ resolveForwardBranch(dp, pVM, origTag);
return;
}
@@ -1160,7 +1157,7 @@
vmBranchRelative(pVM, -1);
/*
- // Get next word...if out of text, we're done.
+ ** Get next word...if out of text, we're done.
*/
if (si.count == 0)
{@@ -1270,7 +1267,7 @@
#if FICL_ROBUST > 1
vmCheckStack(pVM, 0, 1);
#endif
- stackPushINT32(pVM->pStack, *(INT32 *)(pVM->ip));
+ stackPushINT(pVM->pStack, *(FICL_INT *)(pVM->ip));
vmBranchRelative(pVM, 1);
return;
}
@@ -1393,7 +1390,7 @@
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
- c.i = FICL_BOOL(stackPopINT32(pVM->pStack) == 0);
+ c.i = FICL_BOOL(stackPopINT(pVM->pStack) == 0);
stackPush(pVM->pStack, c);
return;
}
@@ -1404,7 +1401,7 @@
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
- c.i = FICL_BOOL(stackPopINT32(pVM->pStack) < 0);
+ c.i = FICL_BOOL(stackPopINT(pVM->pStack) < 0);
stackPush(pVM->pStack, c);
return;
}
@@ -1415,7 +1412,7 @@
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
- c.i = FICL_BOOL(stackPopINT32(pVM->pStack) > 0);
+ c.i = FICL_BOOL(stackPopINT(pVM->pStack) > 0);
stackPush(pVM->pStack, c);
return;
}
@@ -1429,7 +1426,7 @@
#endif
x = stackPop(pVM->pStack);
y = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, FICL_BOOL(x.i == y.i));
+ stackPushINT(pVM->pStack, FICL_BOOL(x.i == y.i));
return;
}
@@ -1441,19 +1438,19 @@
#endif
y = stackPop(pVM->pStack);
x = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, FICL_BOOL(x.i < y.i));
+ stackPushINT(pVM->pStack, FICL_BOOL(x.i < y.i));
return;
}
static void uIsLess(FICL_VM *pVM)
{- UNS32 u1, u2;
+ FICL_UNS u1, u2;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 2, 1);
#endif
- u2 = stackPopUNS32(pVM->pStack);
- u1 = stackPopUNS32(pVM->pStack);
- stackPushINT32(pVM->pStack, FICL_BOOL(u1 < u2));
+ u2 = stackPopUNS(pVM->pStack);
+ u1 = stackPopUNS(pVM->pStack);
+ stackPushINT(pVM->pStack, FICL_BOOL(u1 < u2));
return;
}
@@ -1465,7 +1462,7 @@
#endif
y = stackPop(pVM->pStack);
x = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, FICL_BOOL(x.i > y.i));
+ stackPushINT(pVM->pStack, FICL_BOOL(x.i > y.i));
return;
}
@@ -1477,7 +1474,7 @@
#endif
x = stackPop(pVM->pStack);
y = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, x.i & y.i);
+ stackPushINT(pVM->pStack, x.i & y.i);
return;
}
@@ -1489,7 +1486,7 @@
#endif
x = stackPop(pVM->pStack);
y = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, x.i | y.i);
+ stackPushINT(pVM->pStack, x.i | y.i);
return;
}
@@ -1501,7 +1498,7 @@
#endif
x = stackPop(pVM->pStack);
y = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, x.i ^ y.i);
+ stackPushINT(pVM->pStack, x.i ^ y.i);
return;
}
@@ -1512,7 +1509,7 @@
vmCheckStack(pVM, 1, 1);
#endif
x = stackPop(pVM->pStack);
- stackPushINT32(pVM->pStack, ~x.i);
+ stackPushINT(pVM->pStack, ~x.i);
return;
}
@@ -1554,7 +1551,7 @@
** of the loop - "leave" uses this...
*/
markBranch(dp, pVM, leaveTag);
- dictAppendUNS32(dp, 0);
+ dictAppendUNS(dp, 0);
/*
** Mark location of head of loop...
*/
@@ -1594,7 +1591,7 @@
** of the loop - "leave" uses this...
*/
markBranch(dp, pVM, leaveTag);
- dictAppendUNS32(dp, 0);
+ dictAppendUNS(dp, 0);
/*
** Mark location of head of loop...
*/
@@ -1680,8 +1677,8 @@
static void loopParen(FICL_VM *pVM)
{- INT32 index = stackGetTop(pVM->rStack).i;
- INT32 limit = stackFetch(pVM->rStack, 1).i;
+ FICL_INT index = stackGetTop(pVM->rStack).i;
+ FICL_INT limit = stackFetch(pVM->rStack, 1).i;
index++;
@@ -1702,9 +1699,9 @@
static void plusLoopParen(FICL_VM *pVM)
{- INT32 index = stackGetTop(pVM->rStack).i;
- INT32 limit = stackFetch(pVM->rStack, 1).i;
- INT32 increment = stackPop(pVM->pStack).i;
+ FICL_INT index = stackGetTop(pVM->rStack).i;
+ FICL_INT limit = stackFetch(pVM->rStack, 1).i;
+ FICL_INT increment = stackPop(pVM->pStack).i;
int flag;
index += increment;
@@ -1840,7 +1837,7 @@
static void allot(FICL_VM *pVM)
{FICL_DICT *dp = ficlGetDict();
- INT32 i = stackPopINT32(pVM->pStack);
+ FICL_INT i = stackPopINT(pVM->pStack);
#if FICL_ROBUST
dictCheck(dp, pVM, i);
#endif
@@ -1869,7 +1866,7 @@
static void cComma(FICL_VM *pVM)
{FICL_DICT *dp = ficlGetDict();
- char c = (char)stackPopINT32(pVM->pStack);
+ char c = (char)stackPopINT(pVM->pStack);
dictAppendChar(dp, c);
return;
}
@@ -1877,8 +1874,8 @@
static void cells(FICL_VM *pVM)
{- INT32 i = stackPopINT32(pVM->pStack);
- stackPushINT32(pVM->pStack, i * (INT32)sizeof (CELL));
+ FICL_INT i = stackPopINT(pVM->pStack);
+ stackPushINT(pVM->pStack, i * (FICL_INT)sizeof (CELL));
return;
}
@@ -2013,7 +2010,7 @@
FICL_COUNT count = sp->count;
char *cp = sp->text;
stackPushPtr(pVM->pStack, cp);
- stackPushUNS32(pVM->pStack, count);
+ stackPushUNS(pVM->pStack, count);
cp += count + 1;
cp = alignPtr(cp);
pVM->ip = (IPTYPE)(void *)cp;
@@ -2033,17 +2030,18 @@
static void dotParen(FICL_VM *pVM)
{- char *pSrc = vmGetInBuf(pVM);
- char *pDest = pVM->pad;
+ char *pSrc = vmGetInBuf(pVM);
+ char *pEnd = vmGetInBufEnd(pVM);
+ char *pDest = pVM->pad;
char ch;
- pSrc = skipSpace(pSrc);
+ pSrc = skipSpace(pSrc, pEnd);
- for (ch = *pSrc; (ch != '\0') && (ch != ')'); ch = *++pSrc)
+ for (ch = *pSrc; (pEnd != pSrc) && (ch != ')'); ch = *++pSrc)
*pDest++ = ch;
*pDest = '\0';
- if (ch == ')')
+ if ((pEnd != pSrc) && (ch == ')'))
pSrc++;
vmTextOut(pVM, pVM->pad, 0);
@@ -2068,8 +2066,8 @@
{FICL_DICT *dp = ficlGetDict();
char *cp, *cpDest;
- UNS32 u;
- u = stackPopUNS32(pVM->pStack);
+ FICL_UNS u;
+ u = stackPopUNS(pVM->pStack);
cp = stackPopPtr(pVM->pStack);
dictAppendCell(dp, LVALUEtoCELL(pStringLit));
@@ -2201,7 +2199,7 @@
{FICL_WORD *pFW = stackPopPtr(pVM->pStack);
stackPushPtr(pVM->pStack, pFW->name);
- stackPushUNS32(pVM->pStack, pFW->nName);
+ stackPushUNS(pVM->pStack, pFW->nName);
return;
}
@@ -2250,7 +2248,7 @@
static void numberSign(FICL_VM *pVM)
{FICL_STRING *sp = PTRtoSTRING pVM->pad;
- UNS64 u;
+ DPUNS u;
UNS16 rem;
u = u64Pop(pVM->pStack);
@@ -2273,7 +2271,7 @@
strrev(sp->text);
stackDrop(pVM->pStack, 2);
stackPushPtr(pVM->pStack, sp->text);
- stackPushUNS32(pVM->pStack, sp->count);
+ stackPushUNS(pVM->pStack, sp->count);
return;
}
@@ -2287,7 +2285,7 @@
static void numberSignS(FICL_VM *pVM)
{FICL_STRING *sp = PTRtoSTRING pVM->pad;
- UNS64 u;
+ DPUNS u;
UNS16 rem;
u = u64Pop(pVM->pStack);
@@ -2311,7 +2309,7 @@
static void hold(FICL_VM *pVM)
{FICL_STRING *sp = PTRtoSTRING pVM->pad;
- int i = stackPopINT32(pVM->pStack);
+ int i = stackPopINT(pVM->pStack);
sp->text[sp->count++] = (char) i;
return;
}
@@ -2325,7 +2323,7 @@
static void sign(FICL_VM *pVM)
{FICL_STRING *sp = PTRtoSTRING pVM->pad;
- int i = stackPopINT32(pVM->pStack);
+ int i = stackPopINT(pVM->pStack);
if (i < 0)
sp->text[sp->count++] = '-';
return;
@@ -2345,16 +2343,15 @@
** was entirely converted. u2 is the number of unconverted characters in the
** string. An ambiguous condition exists if ud2 overflows during the
** conversion.
-** TO DO: presently does not use ud1 hi cell - use it!
**************************************************************************/
static void toNumber(FICL_VM *pVM)
{- UNS32 count = stackPopUNS32(pVM->pStack);
+ FICL_UNS count = stackPopUNS(pVM->pStack);
char *cp = (char *)stackPopPtr(pVM->pStack);
- UNS64 accum;
- UNS32 base = pVM->base;
- UNS32 ch;
- UNS32 digit;
+ DPUNS accum;
+ FICL_UNS base = pVM->base;
+ FICL_UNS ch;
+ FICL_UNS digit;
accum = u64Pop(pVM->pStack);
@@ -2379,7 +2376,7 @@
u64Push(pVM->pStack, accum);
stackPushPtr (pVM->pStack, cp);
- stackPushUNS32(pVM->pStack, count);
+ stackPushUNS(pVM->pStack, count);
return;
}
@@ -2409,7 +2406,7 @@
static void ficlAbort(FICL_VM *pVM)
{- vmThrow(pVM, VM_ERREXIT);
+ vmThrow(pVM, VM_ABORT);
return;
}
@@ -2430,25 +2427,32 @@
** Implementation: if there's more text in the TIB, use it. Otherwise
** throw out for more text. Copy characters up to the max count into the
** address given, and return the number of actual characters copied.
+**
+** Note (sobral) this may not be the behavior you'd expect if you're
+** trying to get user input at load time!
**************************************************************************/
static void accept(FICL_VM *pVM)
{- UNS32 count, len;
+ FICL_INT count;
char *cp;
- char *pBuf = vmGetInBuf(pVM);
+ char *pBuf = vmGetInBuf(pVM);
+ char *pEnd = vmGetInBufEnd(pVM);
+ FICL_INT len = pEnd - pBuf;
- len = strlen(pBuf);
if (len == 0)
vmThrow(pVM, VM_RESTART);
- /* OK - now we have something in the text buffer - use it */
- count = stackPopUNS32(pVM->pStack);
+
+ /*
+ ** Now we have something in the text buffer - use it
+ */
+ count = stackPopINT(pVM->pStack);
cp = stackPopPtr(pVM->pStack);
- strncpy(cp, vmGetInBuf(pVM), count);
len = (count < len) ? count : len;
+ strncpy(cp, vmGetInBuf(pVM), len);
pBuf += len;
vmUpdateTib(pVM, pBuf);
- stackPushUNS32(pVM->pStack, len);
+ stackPushINT(pVM->pStack, len);
return;
}
@@ -2493,7 +2497,7 @@
static void beginCoIm(FICL_VM *pVM)
{FICL_DICT *dp = ficlGetDict();
- markBranch(dp, pVM, beginTag);
+ markBranch(dp, pVM, destTag);
return;
}
@@ -2504,7 +2508,7 @@
assert(pIfParen);
dictAppendCell(dp, LVALUEtoCELL(pIfParen));
- resolveBackBranch(dp, pVM, beginTag);
+ resolveBackBranch(dp, pVM, destTag);
return;
}
@@ -2515,9 +2519,9 @@
assert(pIfParen);
dictAppendCell(dp, LVALUEtoCELL(pIfParen));
- markBranch(dp, pVM, whileTag);
+ markBranch(dp, pVM, origTag);
twoSwap(pVM);
- dictAppendUNS32(dp, 1);
+ dictAppendUNS(dp, 1);
return;
}
@@ -2529,9 +2533,9 @@
dictAppendCell(dp, LVALUEtoCELL(pBranchParen));
/* expect "begin" branch marker */
- resolveBackBranch(dp, pVM, beginTag);
+ resolveBackBranch(dp, pVM, destTag);
/* expect "while" branch marker */
- resolveForwardBranch(dp, pVM, whileTag);
+ resolveForwardBranch(dp, pVM, origTag);
return;
}
@@ -2553,7 +2557,7 @@
static void ficlChar(FICL_VM *pVM)
{STRINGINFO si = vmGetWord(pVM);
- stackPushUNS32(pVM->pStack, (UNS32)(si.cp[0]));
+ stackPushUNS(pVM->pStack, (FICL_UNS)(si.cp[0]));
return;
}
@@ -2591,8 +2595,8 @@
{if (sizeof (char) > 1)
{- INT32 i = stackPopINT32(pVM->pStack);
- stackPushINT32(pVM->pStack, i * sizeof (char));
+ FICL_INT i = stackPopINT(pVM->pStack);
+ stackPushINT(pVM->pStack, i * sizeof (char));
}
/* otherwise no-op! */
return;
@@ -2614,7 +2618,7 @@
{FICL_STRING *sp = stackPopPtr(pVM->pStack);
stackPushPtr(pVM->pStack, sp->text);
- stackPushUNS32(pVM->pStack, sp->count);
+ stackPushUNS(pVM->pStack, sp->count);
return;
}
@@ -2634,11 +2638,13 @@
static void environmentQ(FICL_VM *pVM)
{FICL_DICT *envp = ficlGetEnv();
- FICL_COUNT len = (FICL_COUNT)stackPopUNS32(pVM->pStack);
+ FICL_COUNT len = (FICL_COUNT)stackPopUNS(pVM->pStack);
char *cp = stackPopPtr(pVM->pStack);
FICL_WORD *pFW;
STRINGINFO si;
+
+ &len; /* silence compiler warning... */
SI_PSZ(si, cp);
pFW = dictLookup(envp, si);
@@ -2645,11 +2651,11 @@
if (pFW != NULL)
{vmExecute(pVM, pFW);
- stackPushINT32(pVM->pStack, FICL_TRUE);
+ stackPushINT(pVM->pStack, FICL_TRUE);
}
else
{- stackPushINT32(pVM->pStack, FICL_FALSE);
+ stackPushINT(pVM->pStack, FICL_FALSE);
}
return;
@@ -2664,21 +2670,21 @@
** When the parse area is empty, restore the prior input source
** specification. Other stack effects are due to the words EVALUATEd.
**
-** DEFICIENCY: this version does not handle errors or restarts.
**************************************************************************/
static void evaluate(FICL_VM *pVM)
{- UNS32 count = stackPopUNS32(pVM->pStack);
+ FICL_INT count = stackPopINT(pVM->pStack);
char *cp = stackPopPtr(pVM->pStack);
CELL id;
+ int result;
- IGNORE(count);
id = pVM->sourceID;
pVM->sourceID.i = -1;
- vmPushIP(pVM, &pInterpret);
- ficlExec(pVM, cp);
- vmPopIP(pVM);
+ result = ficlExecC(pVM, cp, count);
pVM->sourceID = id;
+ if (result != VM_OUTOFTEXT)
+ vmThrow(pVM, result);
+
return;
}
@@ -2700,7 +2706,7 @@
FICL_STRING *sp = (FICL_STRING *) dp->here;
vmGetString(pVM, sp, '\"');
stackPushPtr(pVM->pStack, sp->text);
- stackPushUNS32(pVM->pStack, sp->count);
+ stackPushUNS(pVM->pStack, sp->count);
}
else /* COMPILE state */
{@@ -2718,7 +2724,7 @@
**************************************************************************/
static void type(FICL_VM *pVM)
{- UNS32 count = stackPopUNS32(pVM->pStack);
+ FICL_UNS count = stackPopUNS(pVM->pStack);
char *cp = stackPopPtr(pVM->pStack);
/*
@@ -2757,7 +2763,7 @@
static void ficlWord(FICL_VM *pVM)
{FICL_STRING *sp = (FICL_STRING *)pVM->pad;
- char delim = (char)stackPopINT32(pVM->pStack);
+ char delim = (char)stackPopINT(pVM->pStack);
STRINGINFO si;
si = vmParseString(pVM, delim);
@@ -2785,7 +2791,7 @@
{STRINGINFO si = vmGetWord0(pVM);
stackPushPtr(pVM->pStack, SI_PTR(si));
- stackPushUNS32(pVM->pStack, SI_COUNT(si));
+ stackPushUNS(pVM->pStack, SI_COUNT(si));
return;
}
@@ -2802,23 +2808,26 @@
static void parse(FICL_VM *pVM)
{char *pSrc = vmGetInBuf(pVM);
+ char *pEnd = vmGetInBufEnd(pVM);
char *cp;
- UNS32 count;
- char delim = (char)stackPopINT32(pVM->pStack);
+ FICL_UNS count;
+ char delim = (char)stackPopINT(pVM->pStack);
cp = pSrc; /* mark start of text */
- while ((*pSrc != delim) && (*pSrc != '\0'))
+ while ((pSrc != pEnd) && (*pSrc != delim))
+ {pSrc++; /* find next delimiter or end */
+ }
count = pSrc - cp; /* set length of result */
- if (*pSrc == delim) /* gobble trailing delimiter */
+ if ((pSrc != pEnd) && (*pSrc == delim)) /* gobble trailing delimiter */
pSrc++;
vmUpdateTib(pVM, pSrc);
stackPushPtr(pVM->pStack, cp);
- stackPushUNS32(pVM->pStack, count);
+ stackPushUNS(pVM->pStack, count);
return;
}
@@ -2831,8 +2840,8 @@
**************************************************************************/
static void fill(FICL_VM *pVM)
{- char ch = (char)stackPopINT32(pVM->pStack);
- UNS32 u = stackPopUNS32(pVM->pStack);
+ char ch = (char)stackPopINT(pVM->pStack);
+ FICL_UNS u = stackPopUNS(pVM->pStack);
char *cp = (char *)stackPopPtr(pVM->pStack);
while (u > 0)
@@ -2866,12 +2875,12 @@
if (pFW)
{stackPushPtr(pVM->pStack, pFW);
- stackPushINT32(pVM->pStack, (wordIsImmediate(pFW) ? 1 : -1));
+ stackPushINT(pVM->pStack, (wordIsImmediate(pFW) ? 1 : -1));
}
else
{stackPushPtr(pVM->pStack, sp);
- stackPushUNS32(pVM->pStack, 0);
+ stackPushUNS(pVM->pStack, 0);
}
return;
}
@@ -2887,15 +2896,15 @@
**************************************************************************/
static void fmSlashMod(FICL_VM *pVM)
{- INT64 d1;
- INT32 n1;
+ DPINT d1;
+ FICL_INT n1;
INTQR qr;
- n1 = stackPopINT32(pVM->pStack);
+ n1 = stackPopINT(pVM->pStack);
d1 = i64Pop(pVM->pStack);
qr = m64FlooredDivI(d1, n1);
- stackPushINT32(pVM->pStack, qr.rem);
- stackPushINT32(pVM->pStack, qr.quot);
+ stackPushINT(pVM->pStack, qr.rem);
+ stackPushINT(pVM->pStack, qr.quot);
return;
}
@@ -2910,15 +2919,15 @@
**************************************************************************/
static void smSlashRem(FICL_VM *pVM)
{- INT64 d1;
- INT32 n1;
+ DPINT d1;
+ FICL_INT n1;
INTQR qr;
- n1 = stackPopINT32(pVM->pStack);
+ n1 = stackPopINT(pVM->pStack);
d1 = i64Pop(pVM->pStack);
qr = m64SymmetricDivI(d1, n1);
- stackPushINT32(pVM->pStack, qr.rem);
- stackPushINT32(pVM->pStack, qr.quot);
+ stackPushINT(pVM->pStack, qr.rem);
+ stackPushINT(pVM->pStack, qr.quot);
return;
}
@@ -2925,15 +2934,15 @@
static void ficlMod(FICL_VM *pVM)
{- INT64 d1;
- INT32 n1;
+ DPINT d1;
+ FICL_INT n1;
INTQR qr;
- n1 = stackPopINT32(pVM->pStack);
- d1.lo = stackPopINT32(pVM->pStack);
+ n1 = stackPopINT(pVM->pStack);
+ d1.lo = stackPopINT(pVM->pStack);
i64Extend(d1);
qr = m64SymmetricDivI(d1, n1);
- stackPushINT32(pVM->pStack, qr.rem);
+ stackPushINT(pVM->pStack, qr.rem);
return;
}
@@ -2948,15 +2957,15 @@
*************************************************************************/
static void umSlashMod(FICL_VM *pVM)
{- UNS64 ud;
- UNS32 u1;
+ DPUNS ud;
+ FICL_UNS u1;
UNSQR qr;
- u1 = stackPopUNS32(pVM->pStack);
+ u1 = stackPopUNS(pVM->pStack);
ud = u64Pop(pVM->pStack);
qr = ficlLongDiv(ud, u1);
- stackPushUNS32(pVM->pStack, qr.rem);
- stackPushUNS32(pVM->pStack, qr.quot);
+ stackPushUNS(pVM->pStack, qr.rem);
+ stackPushUNS(pVM->pStack, qr.quot);
return;
}
@@ -2977,10 +2986,10 @@
**************************************************************************/
static void lshift(FICL_VM *pVM)
{- UNS32 nBits = stackPopUNS32(pVM->pStack);
- UNS32 x1 = stackPopUNS32(pVM->pStack);
+ FICL_UNS nBits = stackPopUNS(pVM->pStack);
+ FICL_UNS x1 = stackPopUNS(pVM->pStack);
- stackPushUNS32(pVM->pStack, x1 << nBits);
+ stackPushUNS(pVM->pStack, x1 << nBits);
return;
}
@@ -2987,10 +2996,10 @@
static void rshift(FICL_VM *pVM)
{- UNS32 nBits = stackPopUNS32(pVM->pStack);
- UNS32 x1 = stackPopUNS32(pVM->pStack);
+ FICL_UNS nBits = stackPopUNS(pVM->pStack);
+ FICL_UNS x1 = stackPopUNS(pVM->pStack);
- stackPushUNS32(pVM->pStack, x1 >> nBits);
+ stackPushUNS(pVM->pStack, x1 >> nBits);
return;
}
@@ -3002,9 +3011,9 @@
**************************************************************************/
static void mStar(FICL_VM *pVM)
{- INT32 n2 = stackPopINT32(pVM->pStack);
- INT32 n1 = stackPopINT32(pVM->pStack);
- INT64 d;
+ FICL_INT n2 = stackPopINT(pVM->pStack);
+ FICL_INT n1 = stackPopINT(pVM->pStack);
+ DPINT d;
d = m64MulI(n1, n2);
i64Push(pVM->pStack, d);
@@ -3014,9 +3023,9 @@
static void umStar(FICL_VM *pVM)
{- UNS32 u2 = stackPopUNS32(pVM->pStack);
- UNS32 u1 = stackPopUNS32(pVM->pStack);
- UNS64 ud;
+ FICL_UNS u2 = stackPopUNS(pVM->pStack);
+ FICL_UNS u1 = stackPopUNS(pVM->pStack);
+ DPUNS ud;
ud = ficlLongMul(u1, u2);
u64Push(pVM->pStack, ud);
@@ -3030,19 +3039,19 @@
**************************************************************************/
static void ficlMax(FICL_VM *pVM)
{- INT32 n2 = stackPopINT32(pVM->pStack);
- INT32 n1 = stackPopINT32(pVM->pStack);
+ FICL_INT n2 = stackPopINT(pVM->pStack);
+ FICL_INT n1 = stackPopINT(pVM->pStack);
- stackPushINT32(pVM->pStack, (n1 > n2) ? n1 : n2);
+ stackPushINT(pVM->pStack, (n1 > n2) ? n1 : n2);
return;
}
static void ficlMin(FICL_VM *pVM)
{- INT32 n2 = stackPopINT32(pVM->pStack);
- INT32 n1 = stackPopINT32(pVM->pStack);
+ FICL_INT n2 = stackPopINT(pVM->pStack);
+ FICL_INT n1 = stackPopINT(pVM->pStack);
- stackPushINT32(pVM->pStack, (n1 < n2) ? n1 : n2);
+ stackPushINT(pVM->pStack, (n1 < n2) ? n1 : n2);
return;
}
@@ -3059,7 +3068,7 @@
**************************************************************************/
static void move(FICL_VM *pVM)
{- UNS32 u = stackPopUNS32(pVM->pStack);
+ FICL_UNS u = stackPopUNS(pVM->pStack);
char *addr2 = stackPopPtr(pVM->pStack);
char *addr1 = stackPopPtr(pVM->pStack);
@@ -3108,11 +3117,11 @@
**************************************************************************/
static void sToD(FICL_VM *pVM)
{- INT32 s = stackPopINT32(pVM->pStack);
+ FICL_INT s = stackPopINT(pVM->pStack);
/* sign extend to 64 bits.. */
- stackPushINT32(pVM->pStack, s);
- stackPushINT32(pVM->pStack, (s < 0) ? -1 : 0);
+ stackPushINT(pVM->pStack, s);
+ stackPushINT(pVM->pStack, (s < 0) ? -1 : 0);
return;
}
@@ -3126,7 +3135,7 @@
static void source(FICL_VM *pVM)
{stackPushPtr(pVM->pStack, pVM->tib.cp);
- stackPushINT32(pVM->pStack, strlen(pVM->tib.cp));
+ stackPushINT(pVM->pStack, vmGetInBufLen(pVM));
return;
}
@@ -3225,7 +3234,7 @@
stackPushPtr(pVM->pStack, pDict->pSearch[i]);
}
- stackPushUNS32(pVM->pStack, nLists);
+ stackPushUNS(pVM->pStack, nLists);
ficlLockDictionary(FALSE);
return;
}
@@ -3246,7 +3255,7 @@
FICL_WORD *pFW;
FICL_HASH *pHash = stackPopPtr(pVM->pStack);
- si.count = (FICL_COUNT)stackPopUNS32(pVM->pStack);
+ si.count = (FICL_COUNT)stackPopUNS(pVM->pStack);
si.cp = stackPopPtr(pVM->pStack);
hashCode = hashHashCode(si);
@@ -3257,11 +3266,11 @@
if (pFW)
{stackPushPtr(pVM->pStack, pFW);
- stackPushINT32(pVM->pStack, (wordIsImmediate(pFW) ? 1 : -1));
+ stackPushINT(pVM->pStack, (wordIsImmediate(pFW) ? 1 : -1));
}
else
{- stackPushUNS32(pVM->pStack, 0);
+ stackPushUNS(pVM->pStack, 0);
}
return;
@@ -3298,7 +3307,7 @@
static void setOrder(FICL_VM *pVM)
{int i;
- int nLists = stackPopINT32(pVM->pStack);
+ int nLists = stackPopINT(pVM->pStack);
FICL_DICT *dp = ficlGetDict();
if (nLists > FICL_DEFAULT_VOCS)
@@ -3345,12 +3354,12 @@
{FICL_DICT *dp = ficlGetDict();
FICL_HASH *pHash;
- UNS32 nBuckets;
+ FICL_UNS nBuckets;
#if FICL_ROBUST > 1
vmCheckStack(pVM, 1, 1);
#endif
- nBuckets = stackPopUNS32(pVM->pStack);
+ nBuckets = stackPopUNS(pVM->pStack);
dictAlign(dp);
pHash = (FICL_HASH *)dp->here;
@@ -3449,7 +3458,7 @@
#if FICL_WANT_USER
static void userParen(FICL_VM *pVM)
{- INT32 i = pVM->runningWord->param[0].i;
+ FICL_INT i = pVM->runningWord->param[0].i;
stackPushPtr(pVM->pStack, &pVM->user[i]);
return;
}
@@ -3533,7 +3542,7 @@
**************************************************************************/
static void linkParen(FICL_VM *pVM)
{- INT32 nLink = *(INT32 *)(pVM->ip);
+ FICL_INT nLink = *(FICL_INT *)(pVM->ip);
vmBranchRelative(pVM, 1);
stackLink(pVM->rStack, nLink);
return;
@@ -3555,7 +3564,7 @@
**************************************************************************/
static void getLocalParen(FICL_VM *pVM)
{- INT32 nLocal = *(INT32 *)(pVM->ip++);
+ FICL_INT nLocal = *(FICL_INT *)(pVM->ip++);
stackPush(pVM->pStack, pVM->rStack->pFrame[nLocal]);
return;
}
@@ -3563,7 +3572,7 @@
static void toLocalParen(FICL_VM *pVM)
{- INT32 nLocal = *(INT32 *)(pVM->ip++);
+ FICL_INT nLocal = *(FICL_INT *)(pVM->ip++);
pVM->rStack->pFrame[nLocal] = stackPop(pVM->pStack);
return;
}
@@ -3663,7 +3672,7 @@
static CELL *pMark = NULL;
FICL_DICT *pDict = ficlGetDict();
STRINGINFO si;
- SI_SETLEN(si, stackPopUNS32(pVM->pStack));
+ SI_SETLEN(si, stackPopUNS(pVM->pStack));
SI_SETPTR(si, (char *)stackPopPtr(pVM->pStack));
if (SI_COUNT(si) > 0)
@@ -3700,7 +3709,7 @@
}
else if (nLocals > 0)
{ /* write nLocals to (link) param area in dictionary */- *(INT32 *)pMark = nLocals;
+ *(FICL_INT *)pMark = nLocals;
}
return;
@@ -3749,7 +3758,6 @@
*/
static int isAFiclWord(FICL_WORD *pFW)
{- void *pv = (void *)pFW;
FICL_DICT *pd = ficlGetDict();
if (!dictIncludes(pd, pFW))
@@ -3855,7 +3863,6 @@
*/
static void see(FICL_VM *pVM)
{- FICL_DICT *pd = ficlGetDict();
FICL_WORD *pFW;
tick(pVM);
@@ -3925,13 +3932,13 @@
static void compareString(FICL_VM *pVM)
{char *cp1, *cp2;
- UNS32 u1, u2, uMin;
+ FICL_UNS u1, u2, uMin;
int n = 0;
vmCheckStack(pVM, 4, 1);
- u2 = stackPopUNS32(pVM->pStack);
+ u2 = stackPopUNS(pVM->pStack);
cp2 = (char *)stackPopPtr(pVM->pStack);
- u1 = stackPopUNS32(pVM->pStack);
+ u1 = stackPopUNS(pVM->pStack);
cp1 = (char *)stackPopPtr(pVM->pStack);
uMin = (u1 < u2)? u1 : u2;
@@ -3948,7 +3955,7 @@
else if (n > 0)
n = 1;
- stackPushINT32(pVM->pStack, n);
+ stackPushINT(pVM->pStack, n);
return;
}
@@ -3968,8 +3975,8 @@
**************************************************************************/
static void refill(FICL_VM *pVM)
{- INT32 ret = (pVM->sourceID.i == -1) ? FICL_FALSE : FICL_TRUE;
- stackPushINT32(pVM->pStack, ret);
+ FICL_INT ret = (pVM->sourceID.i == -1) ? FICL_FALSE : FICL_TRUE;
+ stackPushINT(pVM->pStack, ret);
if (ret)
vmThrow(pVM, VM_OUTOFTEXT);
return;
@@ -4015,6 +4022,225 @@
}
+/**************************************************************************
+ freebsd exception handling words
+** Catch, from ANS Forth standard. Installs a safety net, then EXECUTE
+** the word in ToS. If an exception happens, restore the state to what
+** it was before, and pushes the exception value on the stack. If not,
+** push zero.
+**
+** Notice that Catch implements an inner interpreter. This is ugly,
+** but given how ficl works, it cannot be helped. The problem is that
+** colon definitions will be executed *after* the function returns,
+** while "code" definitions will be executed immediately. I considered
+** other solutions to this problem, but all of them shared the same
+** basic problem (with added disadvantages): if ficl ever changes it's
+** inner thread modus operandi, one would have to fix this word.
+**
+** More comments can be found throughout catch's code.
+**
+** BUGS: do not handle locals unnesting correctly... I think...
+**
+** Daniel C. Sobral Jan 09/1999
+**************************************************************************/
+
+static void ficlCatch(FICL_VM *pVM)
+{+ int except;
+ jmp_buf vmState;
+ FICL_VM VM;
+ FICL_STACK pStack;
+ FICL_STACK rStack;
+ FICL_WORD *pFW;
+ IPTYPE exitIP;
+
+ /*
+ ** Get xt.
+ ** We need this *before* we save the stack pointer, or
+ ** we'll have to pop one element out of the stack after
+ ** an exception. I prefer to get done with it up front. :-)
+ */
+#if FICL_ROBUST > 1
+ vmCheckStack(pVM, 1, 0);
+#endif
+ pFW = stackPopPtr(pVM->pStack);
+
+ /*
+ ** Save vm's state -- a catch will not back out environmental
+ ** changes.
+ **
+ ** We are *not* saving dictionary state, since it is
+ ** global instead of per vm, and we are not saving
+ ** stack contents, since we are not required to (and,
+ ** thus, it would be useless). We save pVM, and pVM
+ ** "stacks" (a structure containing general information
+ ** about it, including the current stack pointer).
+ */
+ memcpy((void*)&VM, (void*)pVM, sizeof(FICL_VM));
+ memcpy((void*)&pStack, (void*)pVM->pStack, sizeof(FICL_STACK));
+ memcpy((void*)&rStack, (void*)pVM->rStack, sizeof(FICL_STACK));
+
+ /*
+ ** Give pVM a jmp_buf
+ */
+ pVM->pState = &vmState;
+
+ /*
+ ** Safety net
+ */
+ except = setjmp(vmState);
+
+ /*
+ ** And now, choose what to do depending on except.
+ */
+
+ /* Things having gone wrong... */
+ if(except)
+ {+ /* Restore vm's state */
+ memcpy((void*)pVM, (void*)&VM, sizeof(FICL_VM));
+ memcpy((void*)pVM->pStack, (void*)&pStack, sizeof(FICL_STACK));
+ memcpy((void*)pVM->rStack, (void*)&rStack, sizeof(FICL_STACK));
+
+ /* Push error */
+ stackPushINT(pVM->pStack, except);
+
+ }
+ else /* Things being ok... */
+ { + /*
+ * We need to know when to exit the inner loop
+ * Colonp, the "code" for colon words, just pushes
+ * the word's IP onto the RP, and expect the inner
+ * interpreter to do the rest. Well, I'd rather have
+ * it done *before* I return from this function,
+ * losing the automatic variables I'm using to save
+ * state. Sure, I could save this on dynamic memory
+ * and save state on RP, or I could even implement
+ * the poor man's version of this word in Forth with
+ * sp@, sp!, rp@ and rp!, but we have a lot of state
+ * neatly tucked away in pVM, so why not save it?
+ */
+ exitIP = pVM->ip;
+
+ /* Execute the xt -- inline code for vmExecute */
+
+ pVM->runningWord = pFW;
+ pFW->code(pVM);
+
+ /*
+ ** Run the inner loop until we get back to exitIP
+ */
+ for (; pVM->ip != exitIP;)
+ {+ pFW = *pVM->ip++;
+
+ /* Inline code for vmExecute */
+ pVM->runningWord = pFW;
+ pFW->code(pVM);
+ }
+
+
+ /* Restore just the setjmp vector */
+ pVM->pState = VM.pState;
+
+ /* Push 0 -- everything is ok */
+ stackPushINT(pVM->pStack, 0);
+ }
+}
+
+/*
+ * Throw -- From ANS Forth standard.
+ *
+ * Throw takes the ToS and, if that's different from zero,
+ * returns to the last executed catch context. Further throws will
+ * unstack previously executed "catches", in LIFO mode.
+ *
+ * Daniel C. Sobral Jan 09/1999
+ */
+
+static void ficlThrow(FICL_VM *pVM)
+{+ int except;
+
+ except = stackPopINT(pVM->pStack);
+
+ if (except)
+ vmThrow(pVM, except);
+}
+
+
+static void ansAllocate(FICL_VM *pVM)
+{+ size_t size;
+ void *p;
+
+ size = stackPopINT(pVM->pStack);
+ p = ficlMalloc(size);
+ stackPushPtr(pVM->pStack, p);
+ if (p)
+ stackPushINT(pVM->pStack, 0);
+ else
+ stackPushINT(pVM->pStack, 1);
+}
+
+
+static void ansFree(FICL_VM *pVM)
+{+ void *p;
+
+ p = stackPopPtr(pVM->pStack);
+ ficlFree(p);
+ stackPushINT(pVM->pStack, 0);
+}
+
+
+static void ansResize(FICL_VM *pVM)
+{+ size_t size;
+ void *new, *old;
+
+ size = stackPopINT(pVM->pStack);
+ old = stackPopPtr(pVM->pStack);
+ new = ficlRealloc(old, size);
+ if (new)
+ {+ stackPushPtr(pVM->pStack, new);
+ stackPushINT(pVM->pStack, 0);
+ }
+ else
+ {+ stackPushPtr(pVM->pStack, old);
+ stackPushINT(pVM->pStack, 1);
+ }
+}
+
+
+/*
+** exit-inner
+** Signals execXT that an inner loop has completed
+*/
+static void ficlExitInner(FICL_VM *pVM)
+{+ vmThrow(pVM, VM_INNEREXIT);
+}
+
+
+/**************************************************************************
+ d n e g a t e
+** DOUBLE ( d1 -- d2 )
+** d2 is the negation of d1.
+**************************************************************************/
+static void dnegate(FICL_VM *pVM)
+{+ DPINT i = i64Pop(pVM->pStack);
+ i = m64Negate(i);
+ i64Push(pVM->pStack, i);
+
+ return;
+}
+
+
#if 0
/**************************************************************************
@@ -4209,6 +4435,15 @@
ficlSetEnv("stack-cells", FICL_DEFAULT_STACK);/*
+ ** EXCEPTION word set
+ */
+ dictAppendWord(dp, "catch", ficlCatch, FW_DEFAULT);
+ dictAppendWord(dp, "throw", ficlThrow, FW_DEFAULT);
+
+ ficlSetEnv("exception", FICL_TRUE);+ ficlSetEnv("exception-ext", FICL_FALSE); /* abort" does not comply yet */+
+ /*
** LOCAL and LOCAL EXT
** see softcore.c for implementation of locals|
*/
@@ -4238,6 +4473,17 @@
#endif
/*
+ ** Optional MEMORY-ALLOC word set
+ */
+
+ dictAppendWord(dp, "allocate", ansAllocate, FW_DEFAULT);
+ dictAppendWord(dp, "free", ansFree, FW_DEFAULT);
+ dictAppendWord(dp, "resize", ansResize, FW_DEFAULT);
+
+ ficlSetEnv("memory-alloc", FICL_TRUE);+ ficlSetEnv("memory-alloc-ext", FICL_FALSE);+
+ /*
** optional SEARCH-ORDER word set
*/
dictAppendWord(dp, ">search", searchPush, FW_DEFAULT);
@@ -4291,6 +4537,7 @@
dictAppendWord(dp, "compare", compareString, FW_DEFAULT); /* STRING */
dictAppendWord(dp, "compile-only",
compileOnly, FW_DEFAULT);
+ dictAppendWord(dp, "dnegate", dnegate, FW_DEFAULT); /* DOUBLE */
dictAppendWord(dp, "endif", endifCoIm, FW_COMPIMMED);
dictAppendWord(dp, "forget-wid",forgetWid, FW_DEFAULT);
dictAppendWord(dp, "parse-word",parseNoCopy, FW_DEFAULT);
@@ -4333,7 +4580,9 @@
dictAppendWord(dp, "interpret", interpret, FW_DEFAULT);
dictAppendWord(dp, "(variable)",variableParen, FW_COMPILE);
dictAppendWord(dp, "(constant)",constantParen, FW_COMPILE);
+ dictAppendWord(dp, "exit-inner",ficlExitInner, FW_DEFAULT);
+ assert(dictCellsAvail(dp) > 0);
return;
}