ref: 976dc6c46d300c6838383b156193073c06f9edbe
parent: 9c2fa11a00741c380ff085eafda22170a98d9e01
author: asau <asau@ficl.sf.net>
date: Thu Aug 12 09:03:23 CDT 2010
Merging FICL 4.0.31.
binary files a/doc/Logo.jpg /dev/null differ
binary files a/doc/favicon.ico b/doc/favicon.ico differ
--- a/doc/ficl.html
+++ b/doc/ficl.html
@@ -1,561 +1,1269 @@
-<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
-<HTML>
- <HEAD>
- <META name="Author" content="john sadler">
- <META name="Description" content="Ficl - embedded scripting with object oriented programming">
- <META name="Keywords" content="scripting prototyping tcl OOP Forth interpreter C">
-
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
- <LINK rel="SHORTCUT ICON" href="ficl.ico">
- <TITLE>
- Ficl - Embedded Scripting
- </TITLE>
- </HEAD>
- <BODY>
- <H1>
- <B>Ficl Documentation</B>
- </H1>
-<SCRIPT language="javascript" src="ficlheader.js" type="text/javascript">
-</SCRIPT>
- <DIV style="width:675px">
- <BR>
-
- <H1>
- <A name="whatis"></A>What is ficl?
- </H1>
- Ficl is a complete programming language interpreter designed to be embedded into other systems (including firmware based ones) as a command, macro, and development prototype language. Unlike other scripting interpreters,
- Ficl:
- <UL>
- <LI>
- typically takes under 2 hours to port to a new system -- much less if the target operating system is one of several already supported (Win32, Linux, FreeBSD, RiscOS, and more)
- </LI>
- <LI>
- has a small memory footprint: a fully featured Win32 console version takes less than 100K of memory, and a minimal version is less than half that
- </LI>
- <LI>
- is relatively quick thanks to its threaded code virtual machine design and just in time compiling
- </LI>
- <LI>
- is a complete and powerful programming language
- </LI>
- <LI>
- is interactive
- </LI>
- <LI>
- has object oriented programming features that can be used to wrap data structures or classes of the host system without altering them - even if the host is mainly written in a non-OO
- language
- </LI>
- </UL>
- <P>
- Ficl syntax is based on ANS Forth and the code is Standard C. See below for examples of <A href="#includesficl">software and products that include ficl</A>. Ficl stands for "Forth inspired
- command language".
- </P>
- <H3>
- Ficl vs. other Forth interpreters
- </H3>
- Where Forths usually view themselves as the center of the system and expect the rest of the system to be coded in Forth, Ficl acts as a component of the system. It is easy to export code
- written in C or ASM to Ficl in the style of TCL, or to invoke Ficl code from a compiled module. This allows you to do incremental development in a way that combines the best features of
- threaded languages (rapid development, quick code/test/debug cycle, 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 and powerful object model that can act as an object oriented <I>adapter</I> for code written in C (or asm, Forth, C++...).
- <H3>
- Ficl Design goals
- </H3>
- <UL>
- <LI>
- Target 32 bit processors (<I>version 2.03 targets 64 bit processors too</I>)
- </LI>
- <LI>
- Scripting, prototyping, and extension language for systems written also in C
- </LI>
- <LI>
- Supportable - code is as transparent as I can make it
- </LI>
- <LI>
- Interface to functions written in C
- </LI>
- <LI>
- Conform to the Forth DPANS 94
- </LI>
- <LI>
- Minimize porting effort - require an ANSI C runtime environment and minimal glue code
- </LI>
- <LI>
- Provide object oriented extensions
- </LI>
- </UL>
- <HR>
- <h1><A name="links"></A>Links</H1>
- <UL>
- <LI>
- <B><A name="download" href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download ficl (latest release)</A></B>
- </LI>
- </UL>
- <H2>
- <A name="tutorials"></A>Getting Started: Forth Tutorials on the Web
- </H2>
- <ul>
- <LI>
- <A href="primer.html">Julian Noble's Forth Primer</A> (start here if you're new to Forth)
- </LI>
- <LI>
- <A href="http://ficl.sourceforge.net/pdf/Forth_Primer.pdf">An excellent Forth Primer by Hans Bezemer</A>
- </LI>
- <LI>
- <A href="http://www.taygeta.com/forth_intro/stackflo.html">An Introduction to Forth using Stack Flow</A>
- </LI>
- <LI>
- <A href="http://www.softsynth.com/pforth/pf_tut.htm">Phil Burk's Forth Tutorial</A>
- </LI>
- <LI>
- <A href="http://www.complang.tuwien.ac.at/forth/threaded-code.html">Anton Ertl's description of Threaded Code</A>
- </LI>
- </UL>
- <H2>
- More information on Ficl and Forth
- </H2>
- <UL>
- <LI>
- <A href="http://ficl.sourceforge.net">Web home of Ficl</A>
- </LI>
- <LI>
- <A href="ficlddj.pdf">Manuscript of Ficl article for January 1999 Dr. Dobb's Journal</A>
- </LI>
- <LI>
- <A href="jwsforml.pdf">1998 FORML Conference paper - OO Programming in Ficl</A>
- </LI>
- <LI>
- <A href="http://ficl.sourceforge.net/dpans/dpans.htm">Draft Proposed American National Standard for Forth</A> (quite readable, actually)
- </LI>
- <LI>
- <A href="http://www.taygeta.com/forthlit.html">Forth literature index on Taygeta</A>
- </LI>
- <LI>
- <A href="http://www.forth.org">Forth Interest Group</A>
- </LI>
- </ul>
- <H2>
- <A name="includesficl"></A>Some software that uses ficl
- </H2>
- <UL>
- <LI>
- <A href="http://www.freebsd.org/">FreeBSD</A> boot loader (Daniel Sobral, Jordan Hubbard)
- </LI>
- <LI>
- <A href="http://www.chipcenter.com/networking/images/prod/prod158a.pdf">SwitchCore</A> Gigabit Ethernet switches (Örjan Gustavsson )
- </LI>
- <LI>
- <A href="http://debuffer.sourceforge.net/">Palm Pilot Debuffer</A> (Eric Sessoms) Also see ficlx, a C++ interface to ficl, on the same site
- </LI>
- <LI>
- <A href="http://www.swcp.com/~jchavez/osmond.html">Osmond PC Board Layout tool</A>
- </LI>
- <LI>
- <A href="http://www.netcomsystems.com">NetCom Systems</A> ML7710
- </LI>
- <LI>
- <A href="http://www.parview.com/ds/homepage.html">ParView</A> GPS system
- </LI>
- <LI>
- <A href="http://www.thekompany.com/products/powerplant/software/Languages/Embedded.php3">PowerPlant Software</A> Development Environment for Linux
- </LI>
- <LI>
- <A href="http://www.vyyo.com/products/architecture_v3000.html">Vyyo V3000 Broadband Wireless Hub</A>
- </LI>
- <LI>
- <A href="mailto:john_sadler@alum.mit.edu"><I>Your Product Name Here!!!</I></A>
- </LI>
- </UL>
- <HR>
- <H2>
- <A name="lawyerbait"></A>LICENSE and DISCLAIMER
- </H2>
- <P>
- Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu) All rights reserved.
- </P>
- <P>
- I am interested in hearing from anyone who uses ficl. If you have a problem, a success story, a defect, an enhancement request, or if you would like to contribute to the ficl release, please
- <A href="mailto:john_sadler@alum.mit.edu">send me email</A>.
- </P>
-<PRE>
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:
-1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
-</PRE>
-
- <H2>
- <A name="features"></A>Ficl features
- </H2>
- <UL>
- <LI>
- Simple to integrate into existing systems: the sample implementation requires three Ficl function calls (see the example program in testmain.c).
- </LI>
- <LI>
- Written in ANSI C for portability.
- </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, EXCEPTION, MEMORY, and
- various extras.
- </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>
- <LI>
- Ficl and C/C++ can interact in two ways: Ficl can wrap C code, and C functions can invoke ficl code.
- </LI>
- <LI>
- Ficl code is thread safe and re-entrant: All Ficl Virtual Machines share one system dictionary (version 3.0 will permit multiple dictionaries); 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. <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.
- </LI>
- <LI>
- ROMable: 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>
- <LI>
- Written in 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++. Ports
- to several other toolchains and operating systems (notably FreeBSD and Linux flavors) exist.
- </LI>
- <LI>
- Does full 32 bit math (but you need to implement two mixed precision math primitives (see sysdep.c))
- </LI>
- </UL>
- <HR>
- <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, ficlRealloc</TT>, and <TT>ficlTextOut</TT> to work with your operating system. Finally, use <TT>testmain.c</TT>
- as a guide to installing the ficl system and one or more virtual machines into your code. You do not need to include <TT>testmain.c</TT> in your build.
- <P>
- Note: ficlLockDictionary can be left unimplemented in most multithreaded implementations - it's only necessary if you expect to have more than one thread modifying the dictionary at the same
- time. If you do decide to implement it, make sure calls to ficlLockDictionary can nest properly (see the comments in sysdep.h). You need to keep count of nested locks and unlocks and do the
- right thing.
- </P>
- <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.
- </P>
- <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 below the "build controls" section until you're confident of your port. 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>
- 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) and a PERL 5 script (softcore.pl) that convert Forth files into the file 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.
- <H3>
- To-Do List (target system dependent words)
- </H3>
- <UL>
- <LI>
- Unimplemented system dependent <TT>CORE</TT> word: <TT>KEY</TT> (implement this yourself if you need it)
- </LI>
- <LI>
- Kludged <TT>CORE</TT> word: <TT>ACCEPT</TT> (implement this better if you need to)
- </LI>
- </UL>
- <BR>
- <BR>
- <H2>
- <A name="api"></A>Application Programming Interface
- </H2>
- The following is a partial listing of functions that interface your system or program to ficl. For a complete listing, see ficl.h (heavily commented). For examples, see testmain.c and the
- ficlwin sources (<A href="#download">below</A>). <I>See the comments in ficl.c and ficl.h for additional information, and the example in file testmain.c.</I>
- <DL>
- <DT>
- <B>FICL_SYSTEM *ficlInitSystem(int nDictCells)</B>
- </DT>
- <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>
- <DT>
- <B>void ficlTermSystem(FICL_SYSTEM *pSys)</B>
- </DT>
- <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>
- <DT>
- <B>int ficlBuild(FICL_SYSTEM *pSys, char *name, FICL_CODE code, char flags)</B>
- </DT>
- <DD>
- Create a primitive word in ficl's main dictionary with the given name, 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>
- <DT>
- <B>int ficlExec(FICL_VM *pVM, char *text)</B>
- </DT>
- <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>
- <DT>
- <B>int ficlExecC(FICL_VM *pVM, char *text, int nChars)</B>
- </DT>
- <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>
- <DT>
- <B>int ficlExecXT(FICL_VM *pVM, FICL_WORD *pFW)</B>
- </DT>
- <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>
- <DT>
- <B>void ficlFreeVM(FICL_VM *pVM)</B>
- </DT>
- <DD>
- Removes the VM in question from the system VM list and deletes the memory allocated to it. This is an optional call, since ficlTermSystem will do this cleanup for you. This function
- is handy if you're going to do a lot of dynamic creation of VMs.
- </DD>
- <DT>
- <B>FICL_VM *ficlNewVM(FICL_SYSTEM *pSys)</B>
- </DT>
- <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>
- <DT>
- <B>FICL_WORD *ficlLookup(FICL_SYSTEM *pSys, char *name)</B>
- </DT>
- <DD>
- Returns the address (also known as an XT in this case) of the specified word in the main dictionary. If not found, returns NULL. The address can be used in a call to ficlExecXT.
- </DD>
- <DT>
- <B>FICL_DICT *ficlGetDict(FICL_SYSTEM *pSys)</B>
- </DT>
- <DD>
- Returns a pointer to the main system dictionary, or NULL if the system is uninitialized.
- </DD>
- <DT>
- <B>FICL_DICT *ficlGetEnv(FICL_SYSTEM *pSys)</B>
- </DT>
- <DD>
- Returns a pointer to the environment dictionary. This dictionary stores information that describes this implementation as required by the Standard.
- </DD>
- <DT>
- <B>void ficlSetEnv(FICL_SYSTEM *pSys, char *name, UNS32 value)</B>
- </DT>
- <DD>
- Enters a new constant into the environment dictionary, with the specified name and value.
- </DD>
- <DT>
- <B>void ficlSetEnvD(FICL_SYSTEM *pSys, char *name, UNS32 hi, UNS32 lo)</B>
- </DT>
- <DD>
- Enters a new double-cell constant into the environment dictionary with the specified name and value.
- </DD>
- <DT>
- <B>FICL_DICT *ficlGetLoc(FICL_SYSTEM *pSys)</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=
- "ficl_loc.html">local variables</A>.
- </DD>
- <DT>
- <B>void ficlCompileCore(FICL_SYSTEM *pSys)</B>
- </DT>
- <DD>
- Defined in words.c, this function builds ficl's primitives.
- </DD>
- <DT>
- <B>void ficlCompileSoftCore(FICL_SYSTEM *pSys)</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>
- <HR>
- <TABLE border="0" cellspacing="5" cols="2">
- <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>dict.c</B>
- </TD>
- <TD>
- Dictionary
- </TD>
- </TR>
- <TR>
- <TD>
- <B>ficl.c</B>
- </TD>
- <TD>
- System initialization, termination, and ficlExec
- </TD>
- </TR>
- <TR>
- <TD>
- <B>float.c</B>
- </TD>
- <TD>
- Adds precompiled definitions from the optional FLOAT word set. Most of the file is conditioned on FICL_WANT_FLOAT
- </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>prefix.c</B>
- </TD>
- <TD>
- The optional prefix parse step (conditioned on FICL_EXTENDED_PREFIX). This parse step handles numeric constructs like 0xa100, for example. See the release notes for more on parse steps.
- </TD>
- </TR>
- <TR>
- <TD>
- <B>search.c</B>
- </TD>
- <TD>
- Contains C implementations of several of the SEARCH and SEARCH EXT words
- </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>
- <TR>
- <TD>
- <B>softwords/</B>
- </TD>
- <TD>
- Directory contains sources and translation scripts for the words defined in softcore.c. Softcore.c depends on most of the files in this directory. See softcore.bat for the actual list of
- files that contribute to softcore.c. This is where you'll find source code for the object oriented extensions. PERL script softcore.pl converts the .fr files into softcore.c.
- </TD>
- </TR>
- <TR>
- <TD>
- <B>stack.c</B>
- </TD>
- <TD>
- Stack methods
- </TD>
- </TR>
- <TR>
- <TD>
- <B>sysdep.c</B>
- </TD>
- <TD>
- Implementation of system dependent functions declared in sysdep.h
- </TD>
- </TR>
- <TR>
- <TD>
- <B>testmain.c</B>
- </TD>
- <TD>
- The main() function for unix/linux/win32 console applications - use this as an example to integrate ficl into your system. Also contains some definitions for testing - also useful in
- unix/linux/win32 land.
- </TD>
- </TR>
- <TR>
- <TD>
- <B>tools.c</B>
- </TD>
- <TD>
- Contains C implementations of TOOLS and TOOLS EXT words, the debugger, and debugger support words.
- </TD>
- </TR>
- <TR>
- <TD>
- <B>vm.c</B>
- </TD>
- <TD>
- Virtual Machine methods
- </TD>
- </TR>
- <TR>
- <TD>
- <B>win32.c & unix.c</B>
- </TD>
- <TD>
- Platform extensions words loaded in ficl.c by ficlCompilePlatform() - conditioned on FICL_WANT_PLATFORM
- </TD>
- </TR>
- <TR>
- <TD>
- <B>words.c</B>
- </TD>
- <TD>
- Exports ficlCompileCore(), the run-time dictionary builder, and contains most precompiled CORE and CORE-EXT words.
- </TD>
- </TR>
- </TABLE>
- </DIV>
- </BODY>
-</HTML>
-
+<p><br>
+<a href=dpans.html><font face=arial,helvetica color=white><b>ANS</b></font></a><br>
+<a href=api.html><font face=arial,helvetica color=white><b>API</b></font></a><br>
+<a href=debugger.html><font face=arial,helvetica color=white><b>Debugger</b></font></a><br>
+<a href=http://sourceforge.net/project/showfiles.php?group_id=24441><font face=arial,helvetica color=white><b>Download</b></font></a><br>
+<a href=license.html><font face=arial,helvetica color=white><b>Licensing</b></font></a><br>
+<a href=links.html><font face=arial,helvetica color=white><b>Links</b></font></a><br>
+<a href=locals.html><font face=arial,helvetica color=white><b>Locals</b></font></a><br>
+<a href=oop.html><font face=arial,helvetica color=white><b>OOP In Ficl</b></font></a><br>
+<a href=parsesteps.html><font face=arial,helvetica color=white><b>Parse Steps</b></font></a><br>
+<a href=releases.html><font face=arial,helvetica color=white><b>Release History</b></font></a><br>
+<a href=upgrading.html><font face=arial,helvetica color=white><b>Upgrading To 4.0</b></font></a><br>
+<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
+
+<html>
+<head>
+ <meta name="Author" content="john sadler">
+ <meta name="Description" content="Ficl - embedded scripting with object oriented programming">
+ <meta name="Keywords" content="scripting prototyping tcl OOP Forth interpreter C">
+ <link rel="SHORTCUT ICON" href="favicon.ico">
+ <title>Ficl - Embedded Scripting</title>
+</head>
+
+<body>
+
+<h1>Ficl Documentation</h1>
+
+<script language="javascript" src="ficlheader.js" type="text/javascript">
+</script>
+
+<h1><a name="whatis">What is Ficl?</a></h1>
+Ficl is a complete programming language interpreter designed to be
+embedded into other systems (including firmware based ones) as a
+command, macro, and development prototype language. Unlike other
+scripting interpreters, Ficl:
+
+<ul>
+
+<li>
+typically takes under 2 hours to port to a new system—much
+less if the target operating system is one of several already supported
+(Win32, Linux, FreeBSD, RiscOS, and more)
+
+<li>
+has a small memory footprint: a fully featured Win32 console
+version takes less than 100K of memory, and a minimal version is less
+than half that
+
+<li>
+is relatively quick thanks to its "switch-threaded" virtual
+machine design and just in time compiling
+
+<li>
+is a complete and powerful programming language
+
+<li>
+is interactive
+
+<li>
+has object oriented programming features that can be used to wrap
+data structures or classes of the host system without altering them—even
+if the host is mainly written in a non-OO language
+
+</ul>
+
+<p>
+
+Ficl syntax is based on ANS Forth and the code is ANSI C. See
+below for examples of <a href="#includesficl">software and products
+that include ficl</a>. Ficl stands for "Forth inspired command language".
+
+
+<h3>Ficl Versus Other Forth Interpreters</h3>
+
+Where most Forths 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 you to do incremental development in a way that
+combines the best features of threaded languages (rapid
+development, quick code/test/debug cycle, 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
+and powerful object model that can act as an object oriented <i>adapter</i>
+for code written in C (or asm, Forth, C++...).
+
+
+<h3>Ficl Design Goals</h3>
+<ul>
+
+<li>
+Target 32- and 64-bit processors
+
+<li>
+Scripting, prototyping, and extension language for systems
+written also in C
+
+<li>
+Supportable—code is as transparent as I can make it
+
+<li>
+Interface to functions written in C
+
+<li>
+Conformant to the 1994 ANSI Standard for Forth (DPANS94)
+
+<li>
+Minimize porting effort—require an ANSI C runtime environment
+and minimal glue code
+
+<li>
+Provide object oriented extensions
+
+</ul>
+
+<hr>
+
+<h2><a name="download">Download</a></h2>
+
+<ul>
+
+<li> <b><a href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download Ficl (latest release)</a></b>
+
+</ul>
+
+<h2><a name="links">More information on Ficl and Forth</a></h2>
+
+<ul>
+
+<li>
+<a href="http://ficl.sourceforge.net">Web home of Ficl</a>
+
+<li>
+<a href="http://ficl.sourceforge.net/pdf/Forth_Primer.pdf">
+An excellent Forth Primer by Hans Bezemer
+</a>
+
+<li>
+<a href="ficlddj.pdf">
+Manuscript of Ficl article for January 1999 Dr. Dobb's Journal
+</a>
+
+<li>
+<a href="jwsforml.pdf">
+1998 FORML Conference paper—OO Programming in Ficl
+</a>
+
+<li>
+<a href="http://www.taygeta.com/forth_intro/stackflo.html">
+An Introduction to Forth using Stack Flow
+</a>
+(start here if you're new to Forth)
+
+<li>
+<a href="http://www.softsynth.com/pforth/pf_tut.htm">
+Phil Burk's Forth Tutorial
+</a>
+
+<li>
+<a href="http://www.complang.tuwien.ac.at/forth/threaded-code.html">
+Anton Ertl's description of Threaded Code
+</a>
+(Ficl now uses what he calls "switch threading")
+
+<li>
+<a href="http://ficl.sourceforge.net/dpans/dpans.htm">
+Draft Proposed American National Standard for Forth
+</a>
+(quite readable, actually)
+
+<li>
+<a href="http://www.taygeta.com/forthlit.html">
+Forth literature index on Taygeta
+</a>
+
+<li>
+<a href="http://www.forth.org">
+Forth Interest Group
+</a>
+
+</ul>
+
+<h2><a name="includesficl">Some software that uses Ficl</a></h2>
+
+<ul>
+<li>
+The <a href="http://www.freebsd.org/">FreeBSD</a> boot loader
+(Daniel Sobral, Jordan Hubbard)
+
+<li>
+<a href="http://www.chipcenter.com/networking/images/prod/prod158a.pdf">
+SwitchCore
+</a>
+Gigabit Ethernet switches (Örjan Gustavsson )
+
+<li>
+<a href="http://debuffer.sourceforge.net/">
+Palm Pilot Debuffer
+</a>
+(Eric Sessoms) Also see ficlx, a C++ interface to ficl, on the same site
+
+<li>
+<a href="http://www.swcp.com/%7Ejchavez/osmond.html">
+Osmond PC Board Layout tool
+</a>
+
+<li>
+<a href="http://www.netcomsystems.com">
+NetCom Systems
+</a>
+ML7710
+
+<li>
+<a href="http://www.parview.com/ds/homepage.html">
+ParView
+</a>
+GPS system
+
+<li>
+<a href="http://www.thekompany.com/products/powerplant/software/Languages/Embedded.php3">
+PowerPlant Software
+</a>
+Development Environment for Linux
+
+<li>
+<a href="http://www.vyyo.com/products/architecture_v3000.html">
+Vyyo V3000 Broadband Wireless Hub
+</a>
+
+<li>
+<a href="mailto:john_sadler@alum.mit.edu">
+<i>Your Product Name Here!!!</i>
+</a>
+
+</ul>
+
+
+<hr>
+<h2><a name="lawyerbait">License And Disclaimer</a></h2>
+
+Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
+<br>
+All rights reserved.
+<p>
+
+<b>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+<ol>
+
+<li>
+Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+<li>
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+</ol>
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+</b>
+<p>
+
+I am interested in hearing from anyone who uses Ficl. If you have a
+problem, a success story, a defect, an enhancement request, or if
+you would like to contribute to the ficl release, please
+<a href="mailto:john_sadler@alum.mit.edu">send me email</a>.
+<p>
+
+
+<h2><a name="features">Ficl Features</a></h2>
+
+<ul>
+
+<li>
+Simple to integrate into existing systems: the sample
+implementation requires three Ficl function calls (see the example
+program in <b>main.c</b>).
+
+<li>
+Written in ANSI C for portability.
+
+<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, EXCEPTION, MEMORY, and various extras.
+
+<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>
+Ficl and C/C++ can interact in two ways: Ficl can wrap C code,
+and C functions can invoke Ficl code.
+
+<li>
+Ficl code is thread safe and re-entrant: your program can have one or more
+Ficl "systems", and each "system" can have one or Ficl virtual machines.
+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.
+<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.
+
+<li>
+ROMable: 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>
+Written in ANSI C to be as simple as I can make it to understand,
+support, debug, and port. Compiles without complaint at <code>/Az /W4</code> (require
+ANSI C, max. warnings) under Microsoft Visual C++, and <code>-ansi</code>
+under GCC. Ports to several other toolchains and operating systems
+(notably FreeBSD and Linux flavors) exist.
+
+<li> Does full 32 bit math (but you need to implement two mixed
+precision math primitives (see sysdep.c)) </li>
+
+</ul>
+
+<hr>
+
+<h2><a name="porting">Porting Ficl</a></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 <b>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, ficlRealloc</tt>, and <tt>ficlTextOut</tt>
+to work with your operating system. Finally, use <tt>testmain.c</tt> as
+a guide to installing the ficl system and one or more virtual machines
+into your code. You do not need to include <tt>testmain.c</tt> in your
+build.
+<p>
+Note: ficlLockDictionary can be left unimplemented in most
+multithreaded implementations - it's only necessary if you expect to
+have more than one thread modifying the dictionary at the same
+time. If you do decide to implement it, make sure calls to
+ficlLockDictionary can nest properly (see the comments in sysdep.h). You
+need to keep count of nested locks and unlocks and do the right
+thing.
+<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>
+
+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 below the "build controls" section until you're confident
+of your port. 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>Softcore</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 <b>softcore</b>. There is a
+.bat file (softcore.bat) and a PERL 5 script (softcore.pl) that convert
+Forth files into the file 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
+<b>make.bat</b> to change the list of files that contribute to
+<b>softcore.c</b>.
+
+<h3>To-Do List (target system dependent words)</h3>
+
+<ul>
+
+<li>
+Unimplemented system dependent <tt>CORE</tt> word: <tt>KEY</tt>
+(implement this yourself if you need it)
+
+<li>
+Kludged <tt>CORE</tt> word: <tt>ACCEPT</tt> (implement this
+better if you need to)
+
+</ul>
+
+<h2><a name="api">Application Programming Interface</a></h2>
+
+The following is a partial listing of functions that interface your
+system or program to Ficl. For a complete listing, see <b>ficl.h</b>
+(which is heavily commented). For examples, see <b>main.c</b> and the
+FiclWin sources (<a href="#download">below</a>).
+
+<dl>
+ <dt> <b>FICL_SYSTEM *ficlInitSystem(int nDictCells)</b> </dt>
+ <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>
+ <dt> <b>void ficlTermSystem(FICL_SYSTEM *pSys)</b> </dt>
+ <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>
+ <dt> <b>int ficlBuild(FICL_SYSTEM *pSys, char *name, FICL_CODE code,
+char flags)</b> </dt>
+ <dd> Create a primitive word in ficl's main dictionary with the given
+name, 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>
+ <dt> <b>int ficlExec(FICL_VM *pVM, char *text)</b> </dt>
+ <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>
+ <dt> <b>int ficlExecC(FICL_VM *pVM, char *text, int nChars)</b> </dt>
+ <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>
+ <dt> <b>int ficlExecXT(FICL_VM *pVM, FICL_WORD *pFW)</b> </dt>
+ <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>
+ <dt> <b>void ficlFreeVM(FICL_VM *pVM)</b> </dt>
+ <dd> Removes the VM in question from the system VM list and deletes
+the memory allocated to it. This is an optional call, since
+ficlTermSystem will do this cleanup for you. This function is
+handy if you're going to do a lot of dynamic creation of VMs. </dd>
+ <dt> <b>FICL_VM *ficlNewVM(FICL_SYSTEM *pSys)</b> </dt>
+ <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>
+ <dt> <b>FICL_WORD *ficlLookup(FICL_SYSTEM *pSys, char *name)</b> </dt>
+ <dd> Returns the address (also known as an XT in this case) of the
+specified word in the main dictionary. If not found, returns NULL. The
+address can be used in a call to ficlExecXT. </dd>
+ <dt> <b>FICL_DICT *ficlGetDict(FICL_SYSTEM *pSys)</b> </dt>
+ <dd> Returns a pointer to the main system dictionary, or NULL if the
+system is uninitialized. </dd>
+ <dt> <b>FICL_DICT *ficlGetEnv(FICL_SYSTEM *pSys)</b> </dt>
+ <dd> Returns a pointer to the environment dictionary. This dictionary
+stores information that describes this implementation as required by the
+Standard. </dd>
+ <dt> <b>void ficlSetEnv(FICL_SYSTEM *pSys, char *name, UNS32 value)</b> </dt>
+ <dd> Enters a new constant into the environment dictionary, with the
+specified name and value. </dd>
+ <dt> <b>void ficlSetEnvD(FICL_SYSTEM *pSys, char *name, UNS32 hi,
+UNS32 lo)</b> </dt>
+ <dd> Enters a new double-cell constant into the environment dictionary
+with the specified name and value. </dd>
+ <dt> <b>FICL_DICT *ficlGetLoc(FICL_SYSTEM *pSys)</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="ficl_loc.html">local
+variables</a>. </dd>
+ <dt> <b>void ficlCompileCore(FICL_SYSTEM *pSys)</b> </dt>
+ <dd> Defined in words.c, this function builds ficl's primitives.
+ </dd>
+ <dt> <b>void ficlCompileSoftCore(FICL_SYSTEM *pSys)</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>
+<hr>
+<table border="0" cellspacing="5" cols="2">
+ <tbody>
+ <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>dict.c</b> </td>
+ <td> Dictionary </td>
+ </tr>
+ <tr>
+ <td> <b>ficl.c</b> </td>
+ <td> System initialization, termination, and ficlExec </td>
+ </tr>
+ <tr>
+ <td> <b>float.c</b> </td>
+ <td> Adds precompiled definitions from the optional FLOAT word
+set. Most of the file is conditioned on FICL_WANT_FLOAT </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>prefix.c</b> </td>
+ <td> The optional prefix parse step (conditioned on
+FICL_EXTENDED_PREFIX). This parse step handles numeric constructs like
+0xa100, for example. See the release notes for more on parse steps. </td>
+ </tr>
+ <tr>
+ <td> <b>search.c</b> </td>
+ <td> Contains C implementations of several of the SEARCH and
+SEARCH EXT words </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>
+ <tr>
+ <td> <b>softwords/</b> </td>
+ <td> Directory contains sources and translation scripts for the
+words defined in softcore.c. Softcore.c depends on most of the files in
+this directory. See softcore.bat for the actual list of
+files that contribute to softcore.c. This is where you'll find source
+code for the object oriented extensions. PERL script softcore.pl
+converts the .fr files into softcore.c. </td>
+ </tr>
+ <tr>
+ <td> <b>stack.c</b> </td>
+ <td> Stack methods </td>
+ </tr>
+ <tr>
+ <td> <b>sysdep.c</b> </td>
+ <td> Implementation of system dependent functions declared in
+sysdep.h </td>
+ </tr>
+ <tr>
+ <td> <b>testmain.c</b> </td>
+ <td> The main() function for unix/linux/win32 console applications
+- use this as an example to integrate ficl into your system. Also
+contains some definitions for testing - also useful in
+unix/linux/win32 land. </td>
+ </tr>
+ <tr>
+ <td> <b>tools.c</b> </td>
+ <td> Contains C implementations of TOOLS and TOOLS EXT words, the
+debugger, and debugger support words. </td>
+ </tr>
+ <tr>
+ <td> <b>vm.c</b> </td>
+ <td> Virtual Machine methods </td>
+ </tr>
+ <tr>
+ <td> <b>win32.c & unix.c</b> </td>
+ <td> Platform extensions words loaded in ficl.c by
+ficlCompilePlatform() - conditioned on FICL_WANT_PLATFORM </td>
+ </tr>
+ <tr>
+ <td> <b>words.c</b> </td>
+ <td> Exports ficlCompileCore(), the run-time dictionary builder,
+and contains most precompiled CORE and CORE-EXT words. </td>
+ </tr>
+ </tbody>
+</table>
+<hr>
+<h2> <a name="extras"></a>Ficl extras </h2>
+<h3> <a name="exnumber"></a>Number syntax </h3>
+You can precede a number with "0x", as in C, and it will be interpreted
+as a hex value regardless of the value of <code>BASE</code>. Likewise,
+numbers prefixed with "0d" will be interpreted as decimal values.
+Example:
+<pre>ok> decimal 123 . cr<br>123<br>ok> 0x123 . cr<br>291<br>ok> 0x123 x. cr<br>123<br></pre>
+Note: ficl2.05 and later - this behavior is controlled by the <a
+ href="ficl_parse.html">prefix parser</a> defined in <code>prefix.c</code>.
+You can add other prefixes by defining handlers for them in ficl
+or C.
+<h3> <a name="exsearch"></a> The <code>SEARCH</code> wordset and Ficl
+extensions </h3>
+<p> Ficl implements many of the search order words in terms of two
+primitives called <code><a href="#tosearch">>SEARCH</a></code> and <code><a
+ href="#searchfrom">SEARCH></a></code>. As their names
+suggest (assuming you're familiar with Forth), they push and pop the
+search order stack. </p>
+<p> The standard does not appear to specify any conditions under which
+the search order is reset to a sane state. Ficl resets the search order
+to its default state whenever <tt>ABORT</tt> happens. This includes
+stack underflows and overflows. <tt>QUIT</tt> does not affect the search
+order. The minimum search order (set by <tt>ONLY</tt>) is equivalent
+to </p>
+<pre>FORTH-WORDLIST 1 SET-ORDER<br></pre>
+<p> There is a default maximum of 16 wordlists in the search order. This
+can be changed by redefining FICL_DEFAULT_VOCS (declared in sysdep.h). </p>
+<p> <b>Note</b>: Ficl resets the search order whenever it does <tt>ABORT</tt>.
+If you don't like this behavior, just comment out the
+dictResetSearchOrder() lines in ficlExec(). </p>
+<dl>
+ <dt> <a name="tosearch"></a><code>>search ( wid -- )</code> </dt>
+ <dd> Push <tt>wid</tt> onto the search order. Many of the other search
+order words are written in terms of the <tt>SEARCH></tt> and <tt>>SEARCH</tt>
+primitives. This word can be defined in ANS Forth as follows </dd>
+ <dd> <tt>: >search >r get-order 1+ r> swap
+set-order ;</tt> </dd>
+ <dt> <a name="searchfrom"></a><tt>search> ( -- wid )</tt> </dt>
+ <dd> Pop <tt>wid</tt> off the search order (can be coded in ANS Forth
+as <tt>: search> get-order nip 1- set-order ;</tt> ) </dd>
+ <dt> <a name="ficlsetcurrent"></a><tt>ficl-set-current (
+wid -- old-wid )</tt> </dt>
+ <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>
+ <dd> Creates a <tt>ficl-wordlist</tt> with the specified number of
+hash table bins, binds it to the name, and associates the semantics of <tt>vocabulary</tt>
+with it (replaces the top wid in the search order list with
+its own wid when executed) </dd>
+ <dt> <a name="ficlwordlist"></a><tt>ficl-wordlist ( nBins
+-- wid )</tt> </dt>
+ <dd> Creates a wordlist 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 wordlist is single
+threaded by default. <tt> ficl-named-wordlist</tt> takes a name for the
+wordlist and creates a word that pushes the <tt>wid</tt>. This is by
+contrast to <tt>VOCABULARY</tt>, which also has a name, but replaces
+the top of the search order with its <tt>wid</tt>. </dd>
+ <dt> <a name="ficlforgetwid"></a><tt>forget-wid ( wid -- )</tt> </dt>
+ <dd> Iterates through the specified wordlist and unlinks all
+definitions whose xt addresses are greater than or equal to the value of <tt>HERE</tt>,
+the dictionary fill pointer. </dd>
+ <dt> <a name="ficlhide"></a><tt>hide ( -- current-wid-was
+)</tt> </dt>
+ <dd> Push the <tt>hidden</tt> wordlist onto the search order, and set
+it as the current compile wordlist (unsing <tt>ficl-set-current</tt>).
+Leaves the previous compile wordlist ID. I use this word to
+hide implementation factor words that have low reuse potential so that
+they don't clutter the default wordlist. To undo the effect of hide,
+execute <b><tt>previous set-current</tt></b> </dd>
+ <dt> <a name="ficlhidden"></a><tt>hidden ( -- wid )</tt> </dt>
+ <dd> Wordlist for storing implementation factors of ficl provided
+words. To see what's in there, try: <b><tt>hide words previous
+set-current</tt></b> </dd>
+ <dt> <a name="wid-get-name"></a><tt>wid-get-name ( wid --
+c-addr u )</tt> </dt>
+ <dd> Ficl wordlists (2.05 and later) have a name property that can be
+assigned. This is used by <tt>ORDER</tt> to list the names of wordlists
+in the search order. </dd>
+ <dt> <a name="wid-set-name"></a><tt>wid-set-name ( c-addr
+wid -- )</tt> </dt>
+ <dd> Ficl wordlists (2.05 and later) have a name property that can be
+assigned. This is used by <tt>ORDER</tt> to list the names of wordlists
+in the search order. The name is assumed to be a \0 terminated
+string (C style), which conveniently is how Ficl stores word
+names. See softwords/softcore.fr definition of <tt>brand-wordlist</tt> </dd>
+ <dt> <a name="wid-set-super"></a><tt>wid-set-super ( wid
+-- )</tt> </dt>
+ <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 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>
+<h3> <a name="exuser"></a>User variables </h3>
+<dl>
+ <dt> <tt>user ( -- ) name</tt> </dt>
+ <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. User variables behave like <tt>VARIABLE</tt>s
+in all other respects (you use @ and ! on them, for example).
+Example: </dd>
+ <dd>
+ <dl>
+ <dd> <tt>user current-class</tt> </dd>
+ <dd> <tt>0 current-class !</tt> </dd>
+ </dl>
+ </dd>
+</dl>
+<h3> <a name="exmisc"></a>Miscellaneous </h3>
+<dl>
+ <dt> <tt>-roll ( xu xu-1 ... x0 u -- x0 xu-1 ... x1
+) </tt> </dt>
+ <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>
+<dl>
+ <dt> <a name="minusrot"></a><tt>-rot ( a b c -- c a b )</tt> </dt>
+ <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>
+<dl>
+ <dt> <tt>.env ( -- )</tt> </dt>
+ <dd> List all environment variables of the system </dd>
+ <dt> <tt>.hash ( -- )</tt> </dt>
+ <dd> List hash table performance statistics of the wordlist that's
+first in the search order </dd>
+ <dt> <tt>.ver ( -- )</tt> </dt>
+ <dd> Display ficl version ID </dd>
+ <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>
+ <dt> <tt>body> ( a-addr -- xt )</tt> </dt>
+ <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>
+ <dd> Mark the most recently defined word as being executable only
+while in compile state. Many <tt>immediate</tt> words have this
+property. </dd>
+ <dt> <tt>empty ( -- )</tt> </dt>
+ <dd> Empty the parameter stack </dd>
+ <dt> <tt>endif</tt> </dt>
+ <dd> Synonym for <tt>THEN</tt> </dd>
+ <dt> <a name="last-word"></a><tt>last-word ( -- xt )</tt> </dt>
+ <dd> Pushes the xt address of the most recently defined word. This
+applies to colon definitions, constants, variables, and words that use <tt>create</tt>.
+You can print the name of the most recently defined word
+with </dd>
+ <dd> <b><tt>last-word >name type</tt> </b> </dd>
+ <dt> <tt>parse-word ( <spaces>name -- c-addr u )</tt> </dt>
+ <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. (From the Standard) </dd>
+ <dt> <a name="qfetch"></a><tt>q@ ( addr -- x )</tt> </dt>
+ <dd> Fetch a 32 bit quantity from the specified address </dd>
+ <dt> <a name="qbang"></a><tt>q! ( x addr -- )</tt> </dt>
+ <dd> Store a 32 bit quantity to the specified address </dd>
+ <dt> <tt>w@ ( addr -- x )</tt> </dt>
+ <dd> Fetch a 16 bit quantity from the specified address </dd>
+ <dt> <tt>w! ( x addr -- )</tt> </dt>
+ <dd> Store a 16 bit quantity to the specified address (the low 16 bits
+of the given value) </dd>
+ <dt> <a name="xdot"></a><tt>x. ( x -- )</tt> </dt>
+ <dd> Pop and display the value in hex format, regardless of the
+current value of <tt>BASE</tt> </dd>
+</dl>
+<h3> <a name="exficlwin"></a>Extra words defined in testmain.c (Win32
+and POSIX versions) </h3>
+<dl>
+ <dt> <tt>break ( -- )</tt> </dt>
+ <dd> Does nothing - just a handy place to set a debugger breakpoint </dd>
+ <dt> <tt>cd (
+"directory-name<newline>" -- )</tt> </dt>
+ <dd> Executes the Win32 chdir() function, changing the program's
+logged directory. </dd>
+ <dt> <a name="clock"></a><tt>clock ( -- now )</tt> </dt>
+ <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>
+ <dt> <tt>pwd ( -- )</tt> </dt>
+ <dd> Prints the current working directory as set by <tt>cd</tt> </dd>
+ <dt> <tt>system ( "command<newline>" -- )</tt> </dt>
+ <dd> Issues a command to a shell; implemented with the Win32 system()
+call. </dd>
+ <dt> <tt>spewhash ( "filename<newline>" -- )</tt> </dt>
+ <dd> Dumps all threads of the current compilation wordlist to the
+specified text file. This was useful when I thought there might be some
+point in attempting to optimize the hash function. I no longer
+harbor those illusions. </dd>
+</dl>
+<h3> Words defined in FiclWin only </h3>
+<dl>
+ <dt> <tt>!oreg ( c -- )</tt> </dt>
+ <dd> Set the value of the simulated LED register as specified (0..255)
+ </dd>
+ <dt> <tt>@ireg ( -- c )</tt> </dt>
+ <dd> Gets the value of the simulated switch block (0..255) </dd>
+ <dt> <tt>!dac ( c -- )</tt> </dt>
+ <dd> Sets the value of the bargraph control as specified. Valid values
+range from 0..255 </dd>
+ <dt> <tt>@adc ( -- c )</tt> </dt>
+ <dd> Fetches the current position of the slider control. Range is
+0..255 </dd>
+ <dt> <tt>status" ( "ccc<quote>" -- )</tt> </dt>
+ <dd> Set the mainframe window's status line to the text specified, up
+to the first trailing quote character. </dd>
+ <dt> <a name="ficlms"></a><tt><a
+ href="http://www.taygeta.com/forth/dpans10.htm#10.6.2.1905">ms</a>
+( u -- )</tt> </dt>
+ <dd> Causes the running virtual machine to sleep() for the number of
+milliseconds specified by the top-of-stack value. </dd>
+</dl>
+<hr>
+<h2> <a name="ansinfo"></a>ANS Required Information </h2>
+<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>
+ <li> <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>n</sup></b> byte boundaries, set
+FICL_ALIGN to <b>n</b>. </font> </li>
+ <li> <b>behavior of 6.1.1320 EMIT for non-graphic characters</b>; </li>
+ <li> <br>
+ <font color="#000000">Depends on target system, C runtime library,
+and your implementation of ficlTextOut().</font> </li>
+ <li> <b>character editing of 6.1.0695 ACCEPT and 6.2.1390 EXPECT</b>; </li>
+ <li> <br>
+ <font color="#000000">None implemented in the versions supplied in
+words.c. Because ficlExec() is supplied a text buffer externally, it's
+up to your system to define how that buffer will be obtained.</font> </li>
+ <li> <b>character set (3.1.2 Character types, 6.1.1320 EMIT, 6.1.1750
+KEY)</b>; </li>
+ <li> <br>
+ <font color="#000000">Depends on target system and implementation
+of ficlTextOut()</font> </li>
+ <li> <b>character-aligned address requirements (3.1.3.3 Addresses)</b>; </li>
+ <li> <br>
+ <font color="#000000">Ficl characters are one byte each. There are
+no alignment requirements.</font> </li>
+ <li> <b>character-set-extensions matching characteristics (3.4.2
+Finding definition n<font color="#000000">ames)</font></b><font
+ color="#000000">; </font> </li>
+ <li> <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>
+ <li> <b>conditions under which control characters match a space
+delimiter (3.4.1.1 Delimiters)</b>;<font color="#ff6666"> </font> </li>
+ <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>
+ <li> <b>format of the control-flow stack (3.2.3.2 Control-flow stack)</b>; </li>
+ <li> <br>
+ <font color="#000000">Uses the data stack</font> </li>
+ <li> <b>conversion of digits larger than thirty-five (3.2.1.2 Digit
+conversion)</b>; </li>
+ <li> <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>
+ <li> <b>display after input terminates in 6.1.0695 ACCEPT and
+6.2.1390 EXPECT</b>; </li>
+ <li> <br>
+ <font color="#000000">Target system dependent</font> </li>
+ <li> <b>exception abort sequence (as in 6.1.0680 ABORT")</b>; </li>
+ <li> <br>
+ <font color="#000000">Does <tt>ABORT</tt></font> </li>
+ <li> <b>input line terminator (3.2.4.1 User input device)</b>;<font
+ color="#ff0000"> </font> </li>
+ <li> <br>
+ <font color="#000000">Target system dependent (implementation of
+outer loop that calls ficlExec)</font> </li>
+ <li> <b>maximum size of a counted string, in characters (3.1.3.4
+Counted strings, 6.1.2450 WORD)</b>; </li>
+ <li> <br>
+ <font color="#000000">255</font> </li>
+ <li> <b>maximum size of a parsed string (3.4.1 Parsing)</b>; </li>
+ <li> <br>
+Limited by available memory and the maximum unsigned value that can fit
+in a CELL (2<sup>32</sup>-1). </li>
+ <li> <b>maximum size of a definition name, in characters (3.3.1.2
+Definition names)</b>; </li>
+ <li> <br>
+ <font color="#000000">Ficl stores the first 31 characters of a
+definition name.</font> </li>
+ <li> <b>maximum string length for 6.1.1345 ENVIRONMENT?, in characters</b>; </li>
+ <li> <br>
+ <font color="#000000">Same as maximum definition name length</font> </li>
+ <li> <b>method of selecting 3.2.4.1 User input device</b>; </li>
+ <li> <br>
+None supported. This is up to the target system </li>
+ <li> <b>method of selecting 3.2.4.2 User output device</b>; </li>
+ <li> <br>
+None supported. This is up to the target system </li>
+ <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> <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>
+ <li> <b>number representation and arithmetic (3.2.1.1 Internal number
+representation)</b>; </li>
+ <li> <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>
+ <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> <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>
+ <li> <b>read-only data-space regions (3.3.3 Data space)</b>; </li>
+ <li> <br>
+None </li>
+ <li> <b>size of buffer at 6.1.2450 WORD (3.3.3.6 Other transient
+regions)</b>; </li>
+ <li> <br>
+Default is 255. Depends on the setting of nPAD in ficl.h. </li>
+ <li> <b>size of one cell in address units (3.1.3 Single-cell types)</b>; </li>
+ <li> <br>
+ <font color="#000000">System dependent, generally four.</font> </li>
+ <li> <b>size of one character in address units (3.1.2 Character types)</b>; </li>
+ <li> <br>
+ <font color="#000000">System dependent, generally one.</font> </li>
+ <li> <b>size of the keyboard terminal input buffer (3.3.3.5 Input
+buffers)</b>; </li>
+ <li> <br>
+ <font color="#000000">This buffer is supplied by the host program.
+Ficl imposes no practical limit.</font> </li>
+ <li> <b>size of the pictured numeric output string buffer (3.3.3.6
+Other transient regions)</b>; </li>
+ <li> <br>
+Default is 255 characters. Depends on the setting of nPAD in
+ficl.h. </li>
+ <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>
+ <li> <br>
+Not presently supported </li>
+ <li> <b>system case-sensitivity characteristics (3.4.2 Finding
+definition names)</b>; </li>
+ <li> <br>
+ <font color="#000000">Ficl is not case sensitive</font> </li>
+ <li> <b>system prompt (3.4 The Forth text interpreter, 6.1.2050 QUIT)</b>; </li>
+ <li> <br>
+ <font color="#000000">"ok>"</font> </li>
+ <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>
+ <li> <br>
+ <font color="#000000">Symmetric</font> </li>
+ <li> <b>values of 6.1.2250 STATE when true</b>; </li>
+ <li> <br>
+ <font color="#000000">One (no others)</font> </li>
+ <li> <b>values returned after arithmetic overflow (3.2.2.2 Other
+integer operations)</b>; </li>
+ <li> <br>
+System dependent. Ficl makes no special checks for overflow. </li>
+ <li> <b>whether the current definition can be found after 6.1.1250
+DOES> (6.1.0450 :)</b>. </li>
+ <li> <br>
+ <font color="#000000">No. Definitions are unsmudged after ; only,
+and only then if no control structure matching problems have been
+detected.</font> </li>
+</ul>
+<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
+combination of factors: </p>
+<ul>
+ <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>
+ <li> <br>
+ <font color="#000000">Ficl does <tt>ABORT</tt> and prints the name
+followed by " not found".</font> </li>
+ <li> <b>a definition name exceeded the maximum length allowed
+(3.3.1.2 Definition names)</b>; </li>
+ <li> <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>
+ <li> <b>addressing a region not listed in 3.3.3 Data Space</b>;
+ </li>
+ <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>
+ <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>
+ <li> <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> </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>
+ <li> <br>
+ <font color="#000000">Ficl returns a valid token, but the result of
+executing that token while interpreting may be undesirable.</font> </li>
+ <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>
+ <li> <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>
+ <li> <b>insufficient data-stack space or return-stack space (stack
+overflow)</b>; </li>
+ <li> <br>
+ <font color="#000000">With FICL_ROBUST (sysdep.h) set >= 2, most
+parameter stack operations are checked for underflow and overflow. Ficl
+does not check the return stack.</font> </li>
+ <li> <b>insufficient space for loop-control parameters</b>; </li>
+ <li> <br>
+ <font color="#000000">No check - Evil results.</font> </li>
+ <li> <b>insufficient space in the dictionary</b>; </li>
+ <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 well, but it is possible to make an unchecked allocation
+request that overflows the dictionary.</font> </li>
+ <li> <b>interpreting a word with undefined interpretation semantics</b>; </li>
+ <li> <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>
+ <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>
+ <li> <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>
+ <li> <b>overflow of a pictured numeric output string</b>; </li>
+ <li> <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>
+ <li> <b>parsed string overflow</b>; </li>
+ <li> <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 string, otherwise bad things may
+happen. This is not usually a problem. </li>
+ <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>
+ <li> <br>
+ <font color="#000000">Value will be truncated</font> </li>
+ <li> <b>reading from an empty data stack or return stack (stack
+underflow)</b>; </li>
+ <li> <br>
+ <font color="#000000">Most stack underflows are detected and
+prevented if FICL_ROBUST (sysdep.h) is set to 2 or greater. Otherwise,
+the stack pointer and size are likely to be trashed.</font> </li>
+ <li> <b>unexpected end of input buffer, resulting in an attempt to
+use a zero-length string as a name</b>; </li>
+ <li> <br>
+ <font color="#000000">Ficl returns for a new input buffer until a
+non-empty one is supplied.</font> </li>
+</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>
+ <li> <br>
+Bad Things occur - unpredictable bacause the input buffer is supplied
+by the host program's outer loop. </li>
+ <li> <b>6.1.2120 RECURSE appears after 6.1.1250 DOES></b> </li>
+ <li> <br>
+It finds the address of the definition before <tt>DOES></tt> </li>
+ <li> <b>argument input source different than current input source for
+6.2.2148 RESTORE-INPUT</b> </li>
+ <li> <br>
+Not implemented </li>
+ <li> <b>data space containing definitions is de-allocated (3.3.3.2
+Contiguous regions)</b> </li>
+ <li> <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>
+ <li> <b>data space read/write with incorrect alignment (3.3.3.1
+Address alignment)</b> </li>
+ <li> <br>
+Target processor dependent. Consequences include: none (Intel), address
+error exception (68K). </li>
+ <li> <b>data-space pointer not properly aligned (6.1.0150 ,, 6.1.0860
+C,)</b> </li>
+ <li> <br>
+See above on data space read/write alignment </li>
+ <li> <b>less than u+2 stack items (6.2.2030 PICK, 6.2.2150 ROLL)</b> </li>
+ <li> <br>
+Ficl detects a stack underflow and reports it, executing <tt>ABORT,</tt>
+as long as FICL_ROBUST is two or larger. </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>
+ <li> <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>
+ <li> <b>most recent definition does not have a name (6.1.1710
+IMMEDIATE)</b> </li>
+ <li> <br>
+No problem. </li>
+ <li> <b>name not defined by 6.2.2405 VALUE used by 6.2.2295 TO</b> </li>
+ <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>
+ <li> <b>name not found (6.1.0070 ', 6.1.2033 POSTPONE, 6.1.2510 ['],
+6.2.2530 [COMPILE])</b> </li>
+ <li> <br>
+Ficl prints an error message and does <tt>ABORT</tt> </li>
+ <li> <b>parameters are not of the same type (6.1.1240 DO, 6.2.0620
+?DO, 6.2.2440 WITHIN)</b> </li>
+ <li> <br>
+No check. Results vary depending on the specific problem. </li>
+ <li> <b>6.1.2033 POSTPONE or 6.2.2530 [COMPILE] applied to 6.2.2295 TO</b> </li>
+ <li> <br>
+The word is postponed correctly. </li>
+ <li> <b>string longer than a counted string returned by 6.1.2450 WORD</b> </li>
+ <li> <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>
+ <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> <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>
+ <li> <b>word not defined via 6.1.1000 CREATE (6.1.0550 >BODY,
+6.1.1250 DOES>)</b> </li>
+ <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>,
+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. </li>
+</ul>
+<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>
+ <li> <br>
+Default is 16. Change by redefining FICL_MAX_LOCALS, defined in
+sysdep.h </li>
+</ul>
+<h3> Locals Ambiguous conditions </h3>
+<ul>
+ <li> <b>executing a named local while in interpretation state
+(13.6.1.0086 (LOCAL))</b> </li>
+ <li> <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>
+ <li> <b>name not defined by VALUE or LOCAL (13.6.1.2295 TO)</b> </li>
+ <li> <br>
+See the CORE ambiguous conditions, above (no change) </li>
+</ul>
+<h3> Programming Tools Implementation-defined options </h3>
+<ul>
+ <li> <b>source and format of display by 15.6.1.2194 SEE</b> </li>
+ <li> <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. </li>
+</ul>
+<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>
+ <li> <br>
+Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS,
+declared in sysdep.h </li>
+ <li> <b>minimum search order (16.6.1.2197 SET-ORDER, 16.6.2.1965 ONLY)</b> </li>
+ <li> <br>
+Equivalent to <tt>FORTH-WORDLIST 1 SET-ORDER</tt> </li>
+</ul>
+<h3> Search Order Ambiguous conditions </h3>
+<ul>
+ <li> <b>changing the compilation word list (16.3.3 Finding definition
+names)</b> </li>
+ <li> <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> compile wordlist. </li>
+ <li> <b>search order empty (16.6.2.2037 PREVIOUS)</b> </li>
+ <li> <br>
+Ficl prints an error message if the search order underflows, and resets
+the order to its default state. </li>
+ <li> <b>too many word lists in search order (16.6.2.0715 ALSO)</b> </li>
+ <li> <br>
+Ficl prints an error message if the search order overflows, and resets
+the order to its default state. </li>
+</ul>
+</div>
+</body>
+</html>
--- a/doc/ficl_ans.html
+++ /dev/null
@@ -1,578 +1,0 @@
-<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
-<HTML>
- <HEAD>
- <META name="Author" content="john sadler">
- <META name="Description" content="Ficl - embedded scripting with object oriented programming">
- <META name="Keywords" content="scripting prototyping tcl OOP Forth interpreter C">
-
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
- <LINK rel="SHORTCUT ICON" href="ficl.ico">
- <TITLE>
- Ficl ANS Forth Required Information
- </TITLE>
- </HEAD>
- <BODY>
- <H1>
- <B>Ficl ANS Forth Required Information</B>
- </H1>
-<SCRIPT language="javascript" src="ficlheader.js" type="text/javascript">
-</SCRIPT>
- <DIV style="width:675px">
- <HR>
- <H2>
- <A name="ansinfo"></A>ANS Required Information
- </H2>
- <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 the Exception Extensions word set</B><BR>
- <B>Providing the File-Access word set*</B><BR>
- <B>Providing the File-Access Extensions word set*</B><BR>
- *On Linux, Win32, and any other system that implements <code>ftruncate()</code><br>
- <B>Providing names from the Floating Point word set</B><BR>
- <B>Providing names from the Floating Point 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.
- <DL>
- <DT>
- <B>aligned address requirements (3.1.3.3 Addresses);</B>
- </DT>
- <DD>
- 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>n</SUP></B> byte boundaries, set FICL_ALIGN to <B>n</B>
- </DD>
- <DT>
- <B>behavior of 6.1.1320 EMIT for non-graphic characters</B>
- </DT>
- <DD>
- Depends on target system, C runtime library, and your implementation of ficlTextOut().
- </DD>
- <DT>
- <B>character editing of 6.1.0695 ACCEPT and 6.2.1390 EXPECT</B>
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>character set (3.1.2 Character types, 6.1.1320 EMIT, 6.1.1750 KEY)</B>
- </DT>
- <DD>
- Depends on target system and implementation of ficlTextOut()
- </DD>
- <DT>
- <B>character-aligned address requirements (3.1.3.3 Addresses)</B>
- </DT>
- <DD>
- Ficl characters are one address unit each. There are no alignment requirements.
- </DD>
- <DT>
- <B>character-set-extensions matching characteristics (3.4.2 Finding definition names)</B>
- </DT>
- <DD>
- No special processing is performed on characters beyond case-folding. Therefore, extended characters will not match their unaccented counterparts.
- </DD>
- <DT>
- <B>conditions under which control characters match a space delimiter (3.4.1.1 Delimiters)</B>
- </DT>
- <DD>
- Ficl uses the Standard C function isspace() to distinguish space characters. The rest is up to your library vendor.
- </DD>
- <DT>
- <B>format of the control-flow stack (3.2.3.2 Control-flow stack)</B>
- </DT>
- <DD>
- Uses the data stack
- </DD>
- <DT>
- <B>conversion of digits larger than thirty-five (3.2.1.2 Digit conversion)</B>
- </DT>
- <DD>
- The maximum supported value of <code>BASE</code> is 36. Ficl will assertion fail in function <code>ltoa()</code> of vm.c if the base is found to be larger than 36 or smaller than 2.
- There will be no effect if <code>NDEBUG</code> is defined, however, other than possibly unexpected behavior
- </DD>
- <DT>
- <B>display after input terminates in <code>6.1.0695 ACCEPT</code> and <code>6.2.1390 EXPECT</code></B>;
- </DT>
- <DD>
- Target system dependent
- </DD>
- <DT>
- <B>exception abort sequence (as in <code>6.1.0680 ABORT"</code>)</B>;
- </DT>
- <DD>
- Does <code>ABORT</code>
- </DD>
- <DT>
- <B>input line terminator (3.2.4.1 User input device)</B>
- </DT>
- <DD>
- Target system dependent (implementation of outer loop that calls ficlExec)
- </DD>
- <DT>
- <B>maximum size of a counted string, in characters (3.1.3.4 Counted strings, <code>6.1.2450 WORD</code>)</B>;
- </DT>
- <DD>
- 255 (assuming 8 bit characters - the limit is imposed by the Standard's specified size of the count character, and is not otherwise restricted by Ficl)
- </DD>
- <DT>
- <B>maximum size of a parsed string (3.4.1 Parsing)</B>
- </DT>
- <DD>
- Limited by available memory and the maximum unsigned value that can fit in a <code>CELL</code> (2<SUP>32</SUP>-1)
- </DD>
- <DT>
- <B>maximum size of a definition name, in characters (3.3.1.2 Definition names)</B>
- </DT>
- <DD>
- Ficl stores the first 31 characters of a definition name.
- </DD>
- <DT>
- <B>maximum string length for <code>6.1.1345 ENVIRONMENT?</code>, in characters</B>
- </DT>
- <DD>
- Same as maximum definition name length
- </DD>
- <DT>
- <B>method of selecting 3.2.4.1 User input device</B>
- </DT>
- <DD>
- None supported. This is up to the target system
- </DD>
- <DT>
- <B>method of selecting 3.2.4.2 User output device</B>
- </DT>
- <DD>
- None supported. This is up to the target system
- </DD>
- <DT>
- <B>methods of dictionary compilation (3.3 The Forth dictionary)</B>
- </DT>
- <DT>
- <B>number of bits in one address unit (3.1.3.3 Addresses)</B>;
- </DT>
- <DD>
- Target system dependent. Ficl generally supports processors that can address 8 bit quantities, but there is no dependency that I'm aware of.
- </DD>
- <DT>
- <B>number representation and arithmetic (3.2.1.1 Internal number representation)</B>
- </DT>
- <DD>
- System dependent. Ficl represents a CELL internally as a union that can hold FICL_INT (a signed register-width scalar value), FICL_UNS (register unsigned), and an untyped pointer. No specific byte
- ordering is assumed.
- </DD>
- <DT>
- <B>ranges for n, +n, u, d, +d, and ud (3.1.3 Single-cell types, 3.1.4 Cell-pair types)</B>
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>read-only data-space regions (3.3.3 Data space)</B>;
- </DT>
- <DD>
-
- None
- </DD>
- <DT>
- <B>size of buffer at 6.1.2450 WORD (3.3.3.6 Other transient regions)</B>;
- </DT>
- <DD>
- Default is 255. Depends on the setting of nPAD in ficl.h.
- </DD>
- <DT>
- <B>size of one cell in address units (3.1.3 Single-cell types)</B>;
- </DT>
- <DD>
- System dependent, generally four.
- </DD>
- <DT>
- <B>size of one character in address units (3.1.2 Character types)</B>;
- </DT>
- <DD>
- System dependent, generally one.
- </DD>
- <DT>
- <B>size of the keyboard terminal input buffer (3.3.3.5 Input buffers)</B>;
- </DT>
- <DD>
- This buffer is supplied by the host program. Ficl imposes no additional limit.
- </DD>
- <DT>
- <B>size of the pictured numeric output string buffer (3.3.3.6 Other transient regions)</B>
- </DT>
- <DD>
- Default is 255 characters. Depends on the setting of nPAD in ficl.h.
- </DD>
- <DT>
- <B>size of the scratch area whose address is returned by 6.2.2000 PAD (3.3.3.6 Other transient regions)</B>;
- </DT>
- <DD>
- Controlled by the value of <code>nPAD</code> in ficl.h - generally 256
- </DD>
- <DT>
- <B>system case-sensitivity characteristics (3.4.2 Finding definition names)</B>
- </DT>
- <DD>
- Ficl is not case sensitive
- </DD>
- <DT>
- <B>system prompt (3.4 The Forth text interpreter, 6.1.2050 QUIT)</B>
- </DT>
- <DD>
- "ok>"
- </DD>
- <DT>
- <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>;
- </DT>
- <DD>
- Symmetric
- </DD>
- <DT>
- <B>values of 6.1.2250 STATE when true</B>;
- </DT>
- <DD>
- One (no others)
- </DD>
- <DT>
- <B>values returned after arithmetic overflow (3.2.2.2 Other integer operations)</B>;
- </DT>
- <DD>
- System dependent. Ficl makes no special checks for overflow.
- </DD>
- <DT>
- <B>whether the current definition can be found after 6.1.1250 DOES> (6.1.0450 :)</B>.
- </DT>
- <DD>
- No. Definitions are unsmudged after <code>;</code> only, and only then if no control structure matching problems have been detected.
- </DD>
- </DL>
- <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 combination of factors:
- </P>
- <DL>
- <DT>
- <B>a name is neither a valid definition name nor a valid number during text interpretation (3.4 The Forth text interpreter)</B>;
- </DT>
- <DD>
- Ficl does <TT>ABORT</TT> and prints the name followed by " not found".
- </DD>
- <DT>
- <B>a definition name exceeded the maximum length allowed (3.3.1.2 Definition names)</B>;
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>addressing a region not listed in 3.3.3 Data Space</B>;
- </DT>
- <DD>
- No problem: all addresses in ficl are absolute. You can reach any 32 bit address in Ficl's address space.
- </DD>
- <DT>
- <B>argument type incompatible with specified input parameter, e.g., passing a flag to a word expecting an n (3.1 Data types)</B>;
- </DT>
- <DD>
- Ficl makes no check for argument type compatibility. Effects of a mismatch vary widely depending on the specific problem and operands.
- </DD>
- <DT>
- <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>;
- </DT>
- <DD>
- Ficl returns a valid token, but the result of executing that token while interpreting may be undesirable.
- </DD>
- <DT>
- <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>;
- </DT>
- <DD>
- Results are target procesor dependent. Generally, Ficl makes no check for divide-by-zero. The target processor will probably throw an exception.
- </DD>
- <DT>
- <B>insufficient data-stack space or return-stack space (stack overflow)</B>;
- </DT>
- <DD>
- With FICL_ROBUST (sysdep.h) set >= 2, most parameter stack operations are checked for underflow and overflow. Ficl does not check the return stack.
- </DD>
- <DT>
- <B>insufficient space for loop-control parameters</B>;
- </DT>
- <DD>
- No check - Evil results.
- </DD>
- <DT>
- <B>insufficient space in the dictionary</B>;
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>interpreting a word with undefined interpretation semantics</B>;
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <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>;
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>overflow of a pictured numeric output string</B>;
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>parsed string overflow</B>;
- </DT>
- <DD>
- 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 string, otherwise bad things may happen. This is not usually a problem.
- </DD>
- <DT>
- <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>;
- </DT>
- <DD>
- Value will be truncated
- </DD>
- <DT>
- <B>reading from an empty data stack or return stack (stack underflow)</B>;
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>unexpected end of input buffer, resulting in an attempt to use a zero-length string as a name</B>;
- </DT>
- <DD>
- Ficl returns for a new input buffer until a non-empty one is supplied.
- </DD>
- </DL>
- The following specific ambiguous conditions are noted in the glossary entries of the relevant words:
- <DL>
- <DT>
- <B>>IN greater than size of input buffer (3.4.1 Parsing)</B>
- </DT>
- <DD>
- Bad Things occur - unpredictable bacause the input buffer is supplied by the host program's outer loop.
- </DD>
- <DT>
- <B>6.1.2120 RECURSE appears after 6.1.1250 DOES></B>
- </DT>
- <DD>
- It finds the address of the definition before <TT>DOES></TT>
- </DD>
- <DT>
- <B>argument input source different than current input source for 6.2.2148 RESTORE-INPUT</B>
- </DT>
- <DD>
- Not implemented
- </DD>
- <DT>
- <B>data space containing definitions is de-allocated (3.3.3.2 Contiguous regions)</B>
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>data space read/write with incorrect alignment (3.3.3.1 Address alignment)</B>
- </DT>
- <DD>
- Target processor dependent. Consequences include: none (Intel), address error exception (68K).
- </DD>
- <DT>
- <B>data-space pointer not properly aligned (6.1.0150 ,, 6.1.0860 C,)</B>
- </DT>
- <DD>
- See above on data space read/write alignment
- </DD>
- <DT>
- <B>less than u+2 stack items (6.2.2030 PICK, 6.2.2150 ROLL)</B>
- </DT>
- <DD>
- Ficl detects a stack underflow and reports it, executing <TT>ABORT,</TT> as long as FICL_ROBUST is two or larger.
- </DD>
- <DT>
- <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>
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>most recent definition does not have a name (6.1.1710 IMMEDIATE)</B>
- </DT>
- <DD>
- No problem.
- </DD>
- <DT>
- <B>name not defined by 6.2.2405 VALUE used by 6.2.2295 TO</B>
- </DT>
- <DD>
- Ficl's version of <TT>TO</TT> works correctly with <TT>VALUE</TT>s, <TT>CONSTANT</TT>s and <TT>VARIABLE</TT>s.
- </DD>
- <DT>
- <B>name not found (6.1.0070 ', 6.1.2033 POSTPONE, 6.1.2510 ['], 6.2.2530 [COMPILE])</B>
- </DT>
- <DD>
- Ficl prints an error message and does <TT>ABORT</TT>
- </DD>
- <DT>
- <B>parameters are not of the same type (6.1.1240 DO, 6.2.0620 ?DO, 6.2.2440 WITHIN)</B>
- </DT>
- <DD>
- No check. Results vary depending on the specific problem.
- </DD>
- <DT>
- <B>6.1.2033 POSTPONE or 6.2.2530 [COMPILE] applied to 6.2.2295 TO</B>
- </DT>
- <DD>
- The word is postponed correctly.
- </DD>
- <DT>
- <B>string longer than a counted string returned by 6.1.2450 WORD</B>
- </DT>
- <DD>
- 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.)
- </DD>
- <DT>
- <B>u greater than or equal to the number of bits in a cell (6.1.1805 LSHIFT, 6.1.2162 RSHIFT)</B>
- </DT>
- <DD>
- 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.
- </DD>
- <DT>
- <B>word not defined via 6.1.1000 CREATE (6.1.0550 >BODY, 6.1.1250 DOES>)</B>
- </DT>
- <DT>
- <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>
- 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.
- </DT>
- </DL>
- <H3>
- Locals Implementation-defined options
- </H3>
- <DL>
- <DT>
- <B>maximum number of locals in a definition (13.3.3 Processing locals, 13.6.2.1795 LOCALS|)</B>
- </DT>
- <DD>
-
- Default is 16. Change by redefining FICL_MAX_LOCALS, defined in sysdep.h
- </DD>
- </DL>
- <H3>
- Locals Ambiguous conditions
- </H3>
- <DL>
- <DT>
- <B>executing a named local while in interpretation state (13.6.1.0086 (LOCAL))</B>
- </DT>
- <DD>
-
- 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.
- </DD>
- <DT>
- <B>name not defined by VALUE or LOCAL (13.6.1.2295 TO)</B>
- </DT>
- <DD>
-
- See the CORE ambiguous conditions, above (no change)
- </DD>
- </DL>
- <H3>
- Programming Tools Implementation-defined options
- </H3>
- <DL>
- <DT>
- <B>source and format of display by 15.6.1.2194 SEE</B>
- </DT>
- <DD>
-
- 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.
- </DD>
- </DL>
- <H3>
- Search Order Implementation-defined options
- </H3>
- <DL>
- <DT>
- <B>maximum number of word lists in the search order (16.3.3 Finding definition names, 16.6.1.2197 SET-ORDER)</B>
- </DT>
- <DD>
-
- Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS, declared in sysdep.h
- </DD>
- <DT>
- <B>minimum search order (16.6.1.2197 SET-ORDER, 16.6.2.1965 ONLY)</B>
- </DT>
- <DD>
-
- Equivalent to <TT>FORTH-WORDLIST 1 SET-ORDER</TT>
- </DD>
- </DL>
- <H3>
- Search Order Ambiguous conditions
- </H3>
- <DL>
- <DT>
- <B>changing the compilation word list (16.3.3 Finding definition names)</B>
- </DT>
- <DD>
-
- 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> compile wordlist.
- </DD>
- <DT>
- <B>search order empty (16.6.2.2037 PREVIOUS)</B>
- </DT>
- <DD>
-
- Ficl prints an error message if the search order underflows, and resets the order to its default state.
- </DD>
- <DT>
- <B>too many word lists in search order (16.6.2.0715 ALSO)</B>
- </DT>
- <DD>
-
- Ficl prints an error message if the search order overflows, and resets the order to its default state.
- </DD>
- </DL>
- </DIV>
- </BODY>
-</HTML>
-
--- a/doc/ficl_debug.html
+++ /dev/null
@@ -1,118 +1,0 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<html>
-<head>
- <meta name="Author" content="john sadler">
- <title>Ficl Debugger</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
-</head>
-<body>
-<link REL="SHORTCUT ICON" href="ficl.ico">
-<h1><b>Ficl Debugger</b></h1>
-
-<script language="javascript" src="ficlheader.js"></script>
-
-<table COLS=1 WIDTH="650" >
-<tr>
-<td>
-<p>Ficl release 2.05 includes a simple step debugger for colon definitions
-and does> words. If you use it and can suggest improvements (or better
-yet if you write some), please let me know.</p>
-<h2>Using the debugger</h2>
-To debug a word, set up the stack with any parameters the word requires,
-then type:
-
-<pre>
-debug <your word here>
-</pre>
-
-<p>If the word is unnamed, or all you have is an xt, you can instead use:</p>
-<pre>debug-xt ( xt -- )</pre>
-<p>The debugger invokes <tt>see</tt> on the word, printing a crude source
-listing, then stops at the first instruction of the definition. There are
-four (case insensitive) commands you can use from here onwards:</p>
-
-<dl>
-<dt>I (step in)</dt>
-<dd>If the next instruction is a colon defintion or does> word, steps into
-that word's code. If the word is a primitive, simply executes the word.</dd>
-
-<dt>O (step over)</dt>
-<dd>Executes the next instruction in its entirety</dd>
-
-<dt>G (go)</dt>
-<dd>Run the word to completion and exit the debugger</dd>
-
-<dt>L (list)</dt>
-<dd>Lists the source code of the word presently being stepped</dd>
-
-<dt>Q (quit)</dt>
-<dd>Abort the word and exit the debugger, clearing the stack</dd>
-
-<dt>X (eXecute)</dt>
-<dd>Interpret the remainder of the line as ficl words for their side effects.
-Any errors will abort the debug session and reset the VM. Usage example:
-<pre>
-x drop 3 \ fix argument on stack
-</pre>
-</dd>
-
-<dt>Anything else</dt>
-<dd>Prints a list of available debugger commands</dd>
-</dl>
-
-<h2>The on-step event</h2>
-<p>If there is a defined word named <code>on-step</code> when the debugger starts, that
-word will be executed before every step. As a guideline, this word should
-have no side effects. Its intended use is to display the stacks and any other
-VM state you're interested in, but you
-may have some better ideas. If so, please let me know. The default on-step is:<p>
-<pre>: on-step ." S: " .s cr ;</pre>
-
-<h3>Other useful words for debugging and on-step</h3>
-<dl>
-<dt><code>r.s ( -- )</code></dt>
-<dd>Prints a represention of the state of the return stack non-destructively. You have to have
-a good understanding of the return stack side-effects of control words to make sense of it,
-but it does give an accurate representation of what's there. Example: <code>DO .. LOOP</code>s stack
-three parameters on the return stack: the loop count and limit, and the <code>LEAVE</code> target
-address.</dd>
-<dt><code>.s ( -- )</code></dt>
-<dd>Prints the parameter stack non-destructively</dd>
-<dt><code>f.s ( -- )</code></dt>
-<dd>Prints the float stack non-destructively (only available if FICL_WANT_FLOAT is enabled)</dd>
-</dl>
-<h2>Debugger internals</h2>
-<p>
-The debugger words are mostly located in source file <tt>tools.c</tt>. There are
-supporting words (<code>debug</code> and <code>on-step</code>) in softcore.fr as well.
-There are two main words that make the debugger go: debug-xt and step-break.
-Debug-xt takes the xt of a word to debug (as returned by <tt>'</tt>, for example)
-checks to see if it is debuggable (not a primitive), sets a breakpoint at its
-first instruction, and runs <code>see</code> on it. To set a breakpoint,
-<code>debug-xt</code>
-replaces the instruction at the breakpoint with the xt of <code>step-break</code>, and
-stores the original instruction and its address in a static breakpoint
-record. To clear the breakpoint, <code>step-break</code> simply replaces the original
-instruction and adjusts the target virtual machine's instruction pointer
-to run it.
-</p>
-<p><code>Step-break</code> is responsible for processing debugger commands and setting
-breakpoints at subsequent instructions.</p>
-<h3>To Do</h3>
-<bl>
-<li>The debugger needs to exit automatically when it encounters the end of the word
-it was asked to debug. Perhaps this could be a special kind of breakpoint?
-</li>
-<li>Add user-set breakpoints</li>
-<li>Add "step out" command</li>
-</bl>
-</td>
-</tr>
-</table>
-
-</body>
-</html>
--- a/doc/ficl_gloss.html
+++ /dev/null
@@ -1,408 +1,0 @@
-<!DOCTYPE html PUBLIC "-//w3c//dtd html 4.0 transitional//en">
-<HTML>
- <HEAD>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
- DT {
- font-family: courier;
- }
-</STYLE>
- <LINK rel="SHORTCUT ICON" href="ficl.ico">
- <TITLE>
- Ficl Glossary
- </TITLE>
- </HEAD>
- <BODY>
- <H1>
- <B>Ficl Glossary</B>
- </H1>
-<SCRIPT language="javascript" src="ficlheader.js" type="text/javascript">
-</SCRIPT>
- <DIV style="width:675px">
- <HR>
- <h2>Standard wordsets
- </h2>
- <p>
- Ficl implements all words in the following Standard wordsets. Follow the links to the glossaries in the standard for descriptions.
-</P>
-<DL>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans6.htm#6.1">Core</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans9.htm#9.6.1">Exception</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans9.htm#9.6.2">Exception Extensions</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans11.htm#11.6.1">File Access</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans11.htm#11.6.2">File Access Extension</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans13.htm#13.6.1">Locals</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans13.htm#13.6.2">Locals Extensions</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans14.htm#14.6.1">Memory Allocation</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans15.htm#15.6.1">Programming Tools</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans16.htm#16.6.1">Search Order</a></dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans16.htm#16.6.2">Search Order Extensions</a></dt>
-</dl>
-<p>Ficl partially implements the following wordsets
-</p>
-<dl>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans6.htm#6.2">Core Extensions</a>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans12.htm#12.6.1">Floating Point</a>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans12.htm#12.6.2">Floating Point Extensions</a>
-</dt>
-<dt><a href="http://ficl.sourceforge.net/dpans/dpans15.htm#15.6.s\2">Programming Tools Extensions</a></dt>
-</dl>
- <H2>
- <A name="extras"></A>Ficl extras
- </H2>
- <H3>
- <A name="exnumber"></A>Number syntax
- </H3>
- You can precede a number with "0x", as in C, and it will be interpreted as a hex value regardless of the value of <CODE>BASE</CODE>. Likewise, numbers prefixed with "0d" will be interpreted as
- decimal values. Example:
-<PRE>
-decimal 123 . cr
-123
-ok> 0x123 . cr
-291
-ok> 0x123 x. cr
-123 ok>
-</PRE>
- Note: (ficl2.05 and later) This behavior is controlled by the <A href="ficl_parse.html">prefix parser</A> defined in <CODE>prefix.c</CODE>. You can add other prefixes by defining handlers for
- them in ficl or C.
- <H3>
- <A name="exsearch"></A>Ficl extensions to the <TT>SEARCH</TT> wordset
- </H3>
- <P>
- Ficl implements many of the search order words in terms of two primitives called <CODE><A href="#tosearch">>SEARCH</A></CODE> and <CODE><A href="#searchfrom">SEARCH></A></CODE>. As
- their names suggest, the search order list is treated as a stack, and these words push and pop it.
- </P>
- <P>
- The standard does not appear to specify any conditions under which the search order is reset to a sane state. Ficl resets the search order to its default state whenever <CODE>ABORT</CODE>
- happens. This includes stack underflows and overflows. <CODE>QUIT</CODE> does not affect the search order. The minimum search order (set by <CODE>ONLY</CODE>) is equivalent to
- </P>
-<PRE>
-FORTH-WORDLIST 1 SET-ORDER
-</PRE>
- <P>
- There is a default maximum of 16 wordlists in the search order. This can be changed by redefining <CODE>FICL_DEFAULT_VOCS</CODE> (declared in sysdep.h).
- </P>
- <P>
- <B>Note</B>: Ficl resets the search order whenever it does <CODE>ABORT</CODE>. If you don't like this behavior, just comment out the <CODE>dictResetSearchOrder()</CODE> lines in <CODE>
- ficlExec()</CODE>.
- </P>
- <DL>
- <DT>
- <A name="tosearch"></A>>search ( wid -- )
- </DT>
- <DD>
- Push <CODE>wid</CODE> onto the search order. Many of the other search order words are written in terms of the <CODE>SEARCH></CODE> and <CODE>>SEARCH</CODE> primitives. This word can
- be defined in ANS Forth as follows
- </DD>
- </DL>
-<PRE>
-: >search >r get-order 1+ r> swap set-order ;
-</PRE>
- <DL>
- <DT>
- <A name="searchfrom"></A>search> ( -- wid )
- </DT>
- <DD>
- Pop <CODE>wid</CODE> off the search order. Can be coded in ANS Forth as:
- </DD>
- </DL>
-<PRE>
-: search> get-order nip 1- set-order ;
-</PRE>
- <DL>
- <DT>
- <A name="ficlsetcurrent"></A>ficl-set-current ( wid -- old-wid )
- </DT>
- <DD>
- Set wid as compile wordlist, leaving the previous compile wordlist on the stack
- </DD>
- <DT>
- <A name="ficlvocabulary"></A>ficl-vocabulary ( nBins "name" -- )
- </DT>
- <DD>
- Creates a <CODE>ficl-wordlist</CODE> with the specified number of hash table bins, binds it to the name, and associates the semantics of <CODE>vocabulary</CODE> with it (replaces the top
- wid in the search order list with its own wid when executed)
- </DD>
- <DT>
- <A name="ficlwordlist"></A>ficl-wordlist ( nBins -- wid )
- </DT>
- <DD>
- Creates a wordlist with the specified number of hash table bins, and leaves the address of the wordlist on the stack. A <CODE>ficl-wordlist</CODE> 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 wordlist is single threaded by default. <CODE>
- ficl-named-wordlist</CODE> takes a name for the wordlist and creates a word that pushes the <CODE>wid</CODE>. This is by contrast to <CODE>VOCABULARY</CODE>, which also has a name, but
- replaces the top of the search order with its <CODE>wid</CODE>.
- </DD>
- <DT>
- <A name="ficlforgetwid"></A>forget-wid ( wid -- )
- </DT>
- <DD>
- Iterates through the specified wordlist and unlinks all definitions whose xt addresses are greater than or equal to the value of <CODE>HERE</CODE>, the dictionary fill pointer.
- </DD>
- <DT>
- <A name="ficlhide"></A>hide ( -- current-wid-was )
- </DT>
- <DD>
- Push the <CODE>hidden</CODE> wordlist onto the search order, and set it as the current compile wordlist (unsing <CODE>ficl-set-current</CODE>). 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 <CODE>hide</CODE>, execute <CODE>
- previous set-current</CODE>
- </DD>
- <DT>
- <A name="ficlhidden"></A>hidden ( -- wid )
- </DT>
- <DD>
- Wordlist for storing implementation factors of ficl provided words. To see what's in there, try: <CODE>hide words previous set-current</CODE>
- </DD>
- <DT>
- <A name="wid-get-name"></A>wid-get-name ( wid -- c-addr u )
- </DT>
- <DD>
- Ficl wordlists (2.05 and later) have a name property that can be assigned. This is used by <CODE>ORDER</CODE> to list the names of wordlists in the search order.
- </DD>
- <DT>
- <A name="wid-set-name"></A>wid-set-name ( c-addr wid -- )
- </DT>
- <DD>
- Ficl wordlists (2.05 and later) have a name property that can be assigned. This is used by <CODE>ORDER</CODE> to list the names of wordlists in the search order. The name is assumed to be a
- \0 terminated string (C style), which conveniently is how Ficl stores word names. See softwords/softcore.fr definition of <CODE>brand-wordlist</CODE>
- </DD>
- <DT>
- <A name="wid-set-super"></A>wid-set-super ( wid -- )
- </DT>
- <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 <CODE>SEARCH-WORDLIST</CODE> 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>
- <H3>
- <A name="exuser"></A>User variables
- </H3>
- <DL>
- <DT>
- user ( -- ) name
- </DT>
- <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. User variables behave like <CODE>VARIABLE</CODE>s in all other respects (you use @
- and ! on them, for example). Example:
- </DD>
- </DL>
-<PRE>
-user current-class
-0 current-class !
-</PRE>
- <H3>
- <A name="exmisc"></A>Miscellaneous
- </H3>
- <DL>
- <DT>
- -roll ( xu xu-1 ... x0 u -- x0 xu-1 ... x1 )
- </DT>
- <DD>
- Rotate u+1 items on top of the stack after removing u. Rotation is in the opposite sense to <CODE>ROLL</CODE>
- </DD>
- <DT>
- <A name="minusrot"></A>-rot ( a b c -- c a b )
- </DT>
- <DD>
- Rotate the top three stack entries, moving the top of stack to third place. I like to think of this as <CODE>1<SUP>1</SUP>/<SUB>2</SUB>swap</CODE> because it's good for tucking a single
- cell value behind a cell-pair (like an object).
- </DD>
- <DT>
- .env ( -- )
- </DT>
- <DD>
- List all environment variables of the system
- </DD>
- <DT>
- .hash ( -- )
- </DT>
- <DD>
- List hash table performance statistics of the wordlist that's first in the search order
- </DD>
- <DT>
- .ver ( -- )
- </DT>
- <DD>
- Display ficl version ID
- </DD>
- <DT>
- >name ( xt -- c-addr u )
- </DT>
- <DD>
- Convert a word's execution token into the address and length of its name
- </DD>
- <DT>
- body> ( a-addr -- xt )
- </DT>
- <DD>
- Reverses the effect of <CODE>CORE</CODE> word <CODE>>body</CODE> (converts a parameter field address to an execution token)
- </DD>
- <DT>
- compile-only
- </DT>
- <DD>
- Mark the most recently defined word as being executable only while in compile state. Many <CODE>immediate</CODE> words have this property.
- </DD>
- <DT>
- empty ( -- )
- </DT>
- <DD>
- Empty the parameter stack
- </DD>
- <DT>
- endif
- </DT>
- <DD>
- Synonym for <CODE>THEN</CODE>
- </DD>
- <DT>
- <A name="last-word"></A>last-word ( -- xt )
- </DT>
- <DD>
- Pushes the xt address of the most recently defined word. This applies to colon definitions, constants, variables, and words that use <CODE>create</CODE>. You can print the name of the most
- recently defined word with
- </DD>
- </DL>
-<PRE>
-last-word >name type
-</PRE>
- <DL>
- <DT>
- parse-word ( <spaces>name -- c-addr u )
- </DT>
- <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. (From the Standard)
- </DD>
- <DT>
- <A name="qfetch"></A>q@ ( addr -- x )
- </DT>
- <DD>
- Fetch a 32 bit quantity from the specified address
- </DD>
- <DT>
- <A name="qbang"></A>q! ( x addr -- )
- </DT>
- <DD>
- Store a 32 bit quantity to the specified address
- </DD>
- <DT>
- w@ ( addr -- x )
- </DT>
- <DD>
- Fetch a 16 bit quantity from the specified address
- </DD>
- <DT>
- w! ( x addr -- )
- </DT>
- <DD>
- Store a 16 bit quantity to the specified address (the low 16 bits of the given value)
- </DD>
- <DT>
- <A name="xdot"></A>x. ( x -- )
- </DT>
- <DD>
- Pop and display the value in hex format, regardless of the current value of <CODE>BASE</CODE>
- </DD>
- </DL>
- <H3>
- <A name="exficlwin"></A>Extra words defined in testmain.c (Win32 and POSIX versions)
- </H3>
- <DL>
- <DT>
- break ( -- )
- </DT>
- <DD>
- Does nothing - just a handy place to set a debugger breakpoint
- </DD>
- <DT>
- cd ( "directory-name<newline>" -- )
- </DT>
- <DD>
- Executes the Win32 chdir() function, changing the program's logged directory.
- </DD>
- <DT>
- <A name="clock"></A>clock ( -- now )
- </DT>
- <DD>
- Wrapper for the ANSI C clock() function. Returns the number of clock ticks elapsed since process start.
- </DD>
- <DT>
- <A name="clockspersec"></A>clocks/sec ( -- clocks_per_sec )
- </DT>
- <DD>
- Pushes the number of ticks in a second as returned by <CODE>clock</CODE>
- </DD>
- <DT>
- <A name="ficlload"></A>load ( "filename<newline>" -- )
- </DT>
- <DD>
- Opens the Forth source file specified and loads it one line at a time, like <CODE>INCLUDED (FILE)</CODE>
- </DD>
- <DT>
- pwd ( -- )
- </DT>
- <DD>
- Prints the current working directory as set by <CODE>cd</CODE>
- </DD>
- <DT>
- system ( "command<newline>" -- )
- </DT>
- <DD>
- Issues a command to a shell; implemented with the Win32 system() call.
- </DD>
- <DT>
- spewhash ( "filename<newline>" -- )
- </DT>
- <DD>
- Dumps all threads of the current compilation wordlist to the specified text file. This was useful when I thought there might be some point in attempting to optimize the hash function. I no
- longer harbor those illusions.
- </DD>
- </DL>
- <H3>
- Words defined in FiclWin only
- </H3>
- <DL>
- <DT>
- !oreg ( c -- )
- </DT>
- <DD>
- Set the value of the simulated LED register as specified (0..255)
- </DD>
- <DT>
- @ireg ( -- c )
- </DT>
- <DD>
- Gets the value of the simulated switch block (0..255)
- </DD>
- <DT>
- !dac ( c -- )
- </DT>
- <DD>
- Sets the value of the bargraph control as specified. Valid values range from 0..255
- </DD>
- <DT>
- @adc ( -- c )
- </DT>
- <DD>
- Fetches the current position of the slider control. Range is 0..255
- </DD>
- <DT>
- status" ( "ccc<quote>" -- )
- </DT>
- <DD>
- Set the mainframe window's status line to the text specified, up to the first trailing quote character.
- </DD>
- <DT>
- <A name="ficlms" href="http://ficl.sourceforge.net/dpans/dpans10.htm#10.6.2.1905">ms</A> ( u -- )
- </DT>
- <DD>
- Causes the running virtual machine to sleep() for the number of milliseconds specified by the top-of-stack value.
- </DD>
- </DL>
- </DIV>
- </BODY>
-</HTML>
-
--- a/doc/ficl_guts.html
+++ /dev/null
@@ -1,76 +1,0 @@
-<!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="Description" content="the coolest embedded scripting language ever">
- <title>Ficl - Internals</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
-</head>
-<body>
-<link REL="SHORTCUT ICON" href="ficl.ico">
-<h1><b>Ficl Internal Structures</b></h1>
-
-<script language="javascript" src="ficlheader.js"></script>
-
-<h2>Contents</h2>
-
-<img src="ficl_top.jpg" alt="Ficl under the hood pix">
-
-<h2>Major Data Structures</h2>
-<p>
-A running memory image of Ficl consists of one or more FICL_SYSTEMs,
-each of which owns exactly one dictionary (FICL_DICT),
-and one or more virtual machines (FICL_VM). Each VM owns two stacks
-(FICL_STACK) - one for parameters (the parameter stack)
-and one for return addresses (the return stack).
-Ficl is a permissive, untyped language by nature,
-so its fundamental unit of storage is a CELL: a chunk of memory
-large enough to hold an address or a scalar type.
-</p>
-<h3>FICL_SYSTEM</h3>
-The system structure associates one or more virtual machines with a dictionary. All FICL_SYSTEMS
-include a link pointer that is used to keep track of every allocated system so that memory
-can be freed by ficlTermSystem. Each system contains a list of virtual machines associated with
-it. Each system has at least one virtual machine. In a typical implementation, there is one virtual
-machine per native OS thread, and there may be several VMs sharing a single FICL_SYSTEM, or one
-FICL_SYSTEM per VM if the implementation needs to support multiple user sessions in a robust way.
-
-A FICL_SYSTEM also includes a special dictionary for local variable support (if enabled
-by FICL_WANT_LOCALS) and another for environment variable support. Environment variables
-describe the configuration of the system in conformance with American National Standard Forth
-(ANS Forth).
-<h3>FICL_DICT</h3>
-A dictionary manages a fixed-size block of contiguous memory. It serves two roles: to keep track
-of allocated memory, and to collect symbol tables called wordlists. Each dictionary contains at
-least one wordlist. The dictionary organized memory (perhaps this is too kind) as an array of
-CELLs that grows from low memory to high memory within fixed limits determined by the
-FICL_DEFAULT_DICT parameter in sysdep.h.
-
-A wordlist is the controlling structure of a Ficl symbol table. Each wordlist is a hash table
-containing pointers to FICL_WORDs. Each FICL_WORD associates a pointer to code with one or more
-CELLs of the dictionay. Each word usually has a name as well, but this is not required. It is
-possible to create anonymous words using :NONAME.
-
-Each word's code pointer determines that word's runtime behavior, and by implication the purpose
-of its payload data. Some words interpret their payload as a list of Ficl words, and execute them.
-This is how new behaviors of the language are defined. Other words view their payload field as
-a location in which one or more CELLs can be stored (VARIABLEs, for example). At runtime, such
-words push the address of their payload area onto the parameter stack.
-<h3>FICL_VM</h3>
-The virtual machine collects state related to execution of Ficl words. Each VM includes
-registers used by the inner interpreter, some state variables (AKA user variables) such as
-the current numeric base, and a jmpbuf.
-A VM has a pointer to the FICL_SYSTEM of which it is a part. It also has a pointer to an incoming
-text string that it is interpreting. There are VM methods that excute a word given its address
-(xt), and ones that interpret a text string.
-<h3>FICL_STACK</h3>
-Each VM owns a parameter stack, a return stack, and if float support is enabled, a float parameter
-stack. Parameters, return addresses, and floats are all CELL sized, and values may be
-moved back and forth among stacks using various Ficl words for that purpose.
-</BODY>
-</HTML>
--- a/doc/ficl_loc.html
+++ /dev/null
@@ -1,166 +1,0 @@
-<!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="Description" content="the coolest embedded scripting language ever">
- <meta name="GENERATOR" content="Mozilla/4.73 [en] (Win98; U) [Netscape]">
- <title>ficl Local Variables</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
-</head>
-<body>
-
-<h1>
-<b>Local Variables in Ficl</b></h1>
-
-
-<script language="javascript" src="ficlheader.js"></script>
-
-
-<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="675" >
-<tr>
-<td>
-<h2>
-<a NAME="locals"></a>Local Variables</h2>
-Named locally scoped variables came late to Forth. Purists feel that experienced
-Forth programmers can (and should) write supportable code using only anonymous
-stack variables and good factoring, but they complain that novices use
-global variables too much. Local variables cost little in terms of code
-size and execution speed, and are very convenient for OO programming, where
-stack effects are more complex. I use them a lot (maybe I'm a weenie).
-<br><a href="http://www.taygeta.com/forth/dpans13.htm">Please refer to
-the Standard</a> for more information on local variables.
-<h2>
-<a NAME="jhlocal"></a>Johns-Hopkins local variables</h2>
-ANS Forth does not specify a complete and satisfying local variable facility.
-Instead it defines a foundation upon which to build one. Ficl comes with
-an adaptation of the Johns-Hopkins local variable syntax developed by John
-Hayes et al. This is my preferred form, and I've extended it to make <a href="ficl_oop.html">OOP</a>
-a bit simpler. Local variables can only be declared inside a definition,
-and are only visible in that definition. Here's the syntax of a JH local
-variable declaration:
-<blockquote><tt><b>{ </b><initialized-locals><b> | </b><cleared-locals><b>
--- </b><ignored><b> }</b></tt></blockquote>
-The declaration is designed to look like a stack comment, but it uses curly
-braces instead of parens. The <initialized-locals> names get their initial
-values from the stack when the word executes. The <cleared-locals> names
-are (you guessed it) set to zero when the word executes, and any characters
-between -- and } are treated as a comment. The | and -- sections are optional,
-but they must appear in the order shown if they appear at all.
-<br><b>Double cell locals </b>(AKA 2locals): ordinarily, each local represents
-one cell. Local variable names prefixed with the characters "2:" in the declaration
-are double-cell locals. The prefix is not part of the local variable's name, only
-part of the declaration.
-They behave the same as single cell locals in all
-other respects. I use 2locals quite a bit in Ficl's OO classes, because
-objects in Ficl require two cells on the stack. You can modify the
-value of a double cell local with <tt><a href="http://www.taygeta.com/forth/dpans13.htm#13.6.1.2295">TO</a></tt>
-the same as you would a single cell local.
-<br>Following are some examples to illustrate usage (they are not intended
-to be good code otherwise). Try these out in FiclWin to get a feeling for
-how they work. Also see <code>softwords/string.fr</code> for an example of use of locals
-in OO code.
-<blockquote><b><tt>: local-demo { a b | c -- }</tt></b>
-<br><b><tt> ." a = " a . cr</tt></b>
-<br><b><tt> ." b = " b . cr</tt></b>
-<br><b><tt> ." c = " c . cr ;</tt></b>
-<br><b><tt>1 2 local-demo ( you should see 1 2 0 )</tt></b>
-<p><b><tt>: my2dup { 2:x } x x ; ( uses a 2local
-)</tt></b>
-<br><b><tt>1 2 my2dup .s </tt></b>
-<br><b><tt>.( you should see 1 2 1 2 on the stack ) cr empty</tt></b>
-<p><b><tt>: my2swap { 2:x 2:y -- y x } y x ;
-( note use of 2locals )</tt></b>
-<br><b><tt>1 2 3 4 my2swap .s</tt></b>
-<br><b><tt>.( you should see 3 4 1 2 on the stack ) cr empty</tt></b>
-<p><b><tt>: totally-lame-swap { x y | temp -- y x }</tt></b>
-<br><b><tt> y to temp</tt></b>
-<br><b><tt> x to y</tt></b>
-<br><b><tt> temp to x</tt></b>
-<br><b><tt> x y ;</tt></b></blockquote>
-The last definition introduces the use of <tt>TO</tt> applied to local
-variables. <tt>TO</tt> knows whether it's operating on a <tt>LOCAL</tt>,
-a <tt>2LOCAL</tt>, or a <tt>VALUE</tt>, and does the right thing accordingly.
-<br>
-<h2>Other local variable syntaxes (deprecated)</h2>
-There are other syntaxes in use for local variables. You get the same compiled
-code regardless of which style of local declaration you choose, but the
-Johns-Hopkins syntax is more readable, more flexible, and supports <tt>2LOCAL</tt>s
-- if you agree, then skip this section.
-<p>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> )
-<blockquote><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></blockquote>
-
-<ul><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>
-
-<h2>
-Build Controls</h2>
-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: <a href="ficl_oop.html">Ficl's OOP</a> code makes
-heavy use of local 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.
-<p>The default maximum number of local variables is 16. It's controlled
-by FICL_MAX_LOCALS in sysdep.h.
-<h2>
-Release notes for local variables</h2>
-<p>Ficl 2.05 adds 2LOCALS using the "2:" prefix</p>
-<p>Ficl 2.02 includes by default an implementation of the Johns Hopkins local
-syntax (as best I can determine it from examples on the web). This syntax
-lets you declare local variables that look very much like a stack comment.
-Variables in the declaration appear in the "correct" order for a stack
-comment. Everything after the -- is treated as a comment. In addition,
-you can insert a | before the -- to declare one or more zero-initialized
-locals. Example: </p>
-<blockquote><b><tt>:tuck0 { a b c | d -- 0 a b c }</tt></b>
-<br><b><tt> d a b c ;</tt></b></blockquote>
-The | and -- delimiters can appear at most once, and must appear in the
-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.
-<p><b>Deprecated</b>: 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:
-<blockquote><b><tt>{{ <initialized params> -- <cleared params> }}</tt></b></blockquote>
-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):
-<br>
-<blockquote>
-<pre><b><tt>: -rot ( a b c -- c a b )
- {{ a b c }}</tt></b>
- <b><tt>c a b </tt></b>
-<b><tt>;</tt></b>
-
-<b><tt>: tuck0 ( a b c -- 0 a b c )</tt></b>
-<b><tt> {{ a b c -- d }}</tt></b>
-<b><tt> d a b c </tt></b>
-<b><tt>; </tt></b></pre>
-</blockquote>
-</td>
-</tr>
-</table>
-
-</body>
-</html>
binary files a/doc/ficl_logo.jpg /dev/null differ
--- a/doc/ficl_oop.html
+++ /dev/null
@@ -1,1267 +1,0 @@
-<!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="Description" content="object oriented programming in the coolest embedded scripting language ever">
- <meta name="GENERATOR" content="Mozilla/4.73 [en] (Win98; U) [Netscape]">
- <title>Ficl Object Oriented Programming</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
- dt { font-family: monospace }
-</STYLE>
-
-</head>
-<body>
-
-<h1>
-<b>Object Oriented Programming in ficl</b></h1>
-
-
-<script language="javascript" src="ficlheader.js"></script>
-
-<DIV style="width:675px">
-
-<h2>
-Contents</h2>
-
-<ul>
-<li>
-<a href="#objects">Introduction</a></li>
-
-<li>
-<a href="#ootutorial">Tutorial</a></li>
-
-<li>
-<a href="#cstring">Ficl String Classes</a></li>
-
-<li>
-<a href="#theory">Theory</a></li>
-<li>
-
-<a href="#oopgloss">OOP glossary</a></li>
-
-<li>
-<a href="#glossinstance">Instance variable glossary</a></li>
-
-<li>
-<a href="#glossclass">Class methods glossary</a></li>
-
-<li>
-<a href="#objectgloss">OBJECT methods glossary</a></li>
-
-<li>
-<a href="#stockclasses">Supplied Classes</a></li>
-</ul>
-<br><hr>
-<h2><a NAME="objects">Introduction</a></h2>
-
-<h3>
-Review of <a href="http://whatis.techtarget.com/definition/0,289893,sid9_gci212681,00.html">OO</a> ideas</h3>
-Click <a href="oo_in_c.html#review">here</a> for a short review of OO ideas,
-terms, and implementations in other languages, or <a href="http://www.soft-design.com/softinfo/objects.html">here</a>
-for an introduction to the terms and principles of Object Oriented Programming
-<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>
-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>
-
-<li>
-Ficl OOP supports single inheritance, aggregation, and arrays of objects.</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>
-
-<li>
-Ficl OOP syntax is regular and unified over classes and objects. In ficl,
-all classes are objects. Class methods include the ability to subclass
-and instantiate.</li>
-
-<li>
-Ficl can adapt legacy data structures with object wrappers. You can model
-a structure in a Ficl class, and create an instance that refers to an address
-in memory that holds 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>
-
-<h3>Acknowledgements</h3>
-<p>Ficl is not the first Forth to include Object Oriented extensions. Ficl's
-OO syntax owes a debt to the work of John Hayes and Dick Pountain, among
-others. OO Ficl is different from other OO Forths in a few ways, though
-(some things never change). First, unlike several implementations, the
-syntax is documented (<a href="#ootutorial">below</a>) beyond the source
-code. In Ficl's spirit of working with C code, the OO syntax provides means
-to adapt existing data structures. I've tried to make Ficl's OO model simple
-and safe by unifying classes and objects, providing late binding by default,
-and separating namespaces so that methods and regular Forth words are not
-easily confused.</p>
-<br>
-<hr>
-<h2>
-<a NAME="ootutorial"></a>Tutorial</h2>
-It's helpful to have some familiarity with Forth and the customary Forth
-stack notation to understand this tutorial. To get started, take a look
-at this <a href="primer.html">Forth tutorial</a>.
-<p>
-This tutorial works best if you follow along by pasting the examples
-into ficlWin, the Win32 version of Ficl included with the release sources
-(or some other build that includes the OO part of softcore.c).
-<p>
-You need to use this incantation to make Ficl's OOP words visible to the interpreter:
-<pre>
-ONLY ( Reset to default search order )
-ALSO OOP DEFINITIONS ( Add OOP wordlist to search order )
-</pre>
-<dl>
-<dt>??? not found</dt>
-<dd>
-If you run into this error message you will need to repeat the above incantation to reset the search order. Ficl resets to a default search order if it runs into an error.
-</dd>
-<dt>For beginners</dt>
-<dd>
-To see the effect of the commands above, type <code>ORDER</code> after each word. You can repeat the sequence above if you like. All of the above words are described in the
-<a href="http://ficl.sourceforge.net/dpans/dpansf.htm">Standard</a>
-</dd>
-</dl>
-<p>To start, we'll work with the base class <code>OBJECT</code>.
-Try this:
-<pre>
-object
-</pre>
-FiclWin's stack viewer shows that the stack now holds two values - the one on top is the address of <code>class</code> and the other is the address of a special class called <code>METACLASS</code> that describes the behavior of all classes (including itself). If you're using someother version of Ficl, you can type <code>.s</code> to view the contents of the stack non-destructively.
-Now try:
-<pre>
-object --> methods
-</pre>
-The line above contains three words. The first is the name of a class,
-so it pushes its signature on the stack. The next word (<code>--></code>) finds a method in the context of class <code>object</code> and executes it. In this case, the name of the method is <code>methods</code>.
-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.
-<p>
-Now let's create a class that can do something interesting with the simulated hardware that FiclWin provides...
-<pre>
-object --> sub c-led
-</pre>
-<p>
-Causes base-class <code>OBJECT</code> to derive from itself a new class called
-<code>c-led</code>.</p>
-<dl>
-<dt>About class naming</dt>
-<dd> I like to prefix the names of classes with "c-", and the
-names of member variables with a dot, but this is just a convention. If
-you don't like it, you can pick your own.</dd>
-<dt>About !oreg</dt>
-<dd>The following methods use the !oreg word defined by FiclWin to control its simulated LED bar. Usage: <code>!oreg ( value -- )</code>. To test it, try <code>0xff !oreg</code> or <code>0 !oreg</code>.</dd>
-</dl>
-<p>
-Now we'll add some instance variables and methods to the new class...</p>
-<pre>
-
-c-byte obj: .state \ an instance variable
-
-: init { 2:this -- }
- 0 dup !oreg
- this --> .state --> set
- ." initializing an instance of "
- this --> class --> id type cr ;
-
-: on { led# 2:this -- }
- this --> .state --> get
- 1 led# lshift or dup !oreg
- this --> .state --> set ;
-: off { led# 2:this -- }
- this --> .state --> get
- 1 led# lshift invert and dup !oreg
- this --> .state --> set ;
-end-class
-</pre>
-The first line adds an instance variable called <code>.state</code> to the
-class. This particular instance variable is an object - it will be an instance
-of <code>c-byte</code>, one of ficl's stock classes (the source for which can be found in the distribution in sorftowrds/classes.fr). Try this...
-<pre>
-c-led --> see .state
-</pre>
-The <code>see</code> method (inherited from <code>object</code>) decompiles methods so that you can see exactly what they do. There's also a <code>debug</code> method that lets you step through a method.
-<p>
-Next we've defined a method called <code>init</code>. This line also declares
-a <a href="ficl_loc.html">local variable</a> called <code>this</code>
-(the 2 in front tells Ficl that this is a double-cell local). All methods
-by convention expect the address of the class and instance on top of the
-stack when called. The next four lines define <code>init</code>'s behavior.
-It first clears the simulated LED bar and <code>.state</code>. The rest displays some text and causes the instance to print its class name (<code>this --> class --> id</code>).
-<br>The <code>init</code> method is special for Ficl objects: whenever
-you create an initialized instance using <code>new</code> or <code>new-array</code>,
-Ficl calls the class's <code>init</code> method for you on that instance. The
-default <code>init</code> method supplied by <code>object</code> sets the instance variables to zero (see the source code in ficl/softwords/oo.fr).
-<br>The <code>ON</code> and <code>OFF</code> methods defined above hide the details
-of turning LEDs on and off. The interface to FiclWin's simulated hardware
-is handled by <code>!OREG</code>. The class keeps the LED state in a shadow
-variable (<code>.STATE</code>) so that <code>ON</code> and <code>OFF</code> can work
-in terms of LED number rather than a bitmask.
-<p>Now make an instance of the new class:
-<pre>
-c-led --> new led
-</pre>
-And try a few things...
-<pre>
-led --> methods
-led --> pedigree
-1 led --> on
-1 led --> off
-</pre>
-Or you could type this with the same effect:
-<pre>
-led 2dup --> methods --> pedigree
-</pre>
-Notice (from the output of <code>methods</code>) that we've overridden the
-init method supplied by object, and added two more methods for the member
-variables. If you type <code>WORDS</code>, you'll see that these methods are
-not visible outside the context of the class that contains them. The method
-finder <code>--></code> uses the class to look up methods. You can use
-this word in a definition, as we did in <code>init</code>, 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:
-<pre>
-c-led --> see init
-</pre>
-or
-<pre>
-led --> class --> see init
-</pre>
-
-<h3>
-More About Instance Variables</h3>
-<i>Untyped</i> instance variable methods (created by <code>cell: cells: char:</code>
-and <code>chars:</code>) 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.
-<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 <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):
-<pre>
-object subclass c-wordlist
- c-wordlist ref: .parent
- c-ptr obj: .name
- c-cell obj: .size
- c-word ref: .hash
- : ?
- 2drop ." ficl wordlist " cr ;
- : push drop >search ;
- : pop 2drop previous ;
- : set-current drop set-current ;
- : words --> push words previous ;
-end-class
-</pre>
-In this case, <code>c-wordlist</code> describes Ficl's wordlist structure;
-named-wid creates a wordlist and binds it to a ref instance of <code>c-wordlist</code>.
-The fancy footwork with <code>POSTPONE</code> and early binding is required
-because classes are immediate. An equivalent way to define named-wid with
-late binding is:
-<pre>
-: named-wid ( "name" -- )
- wordlist postpone c-wordlist --> ref ;
-</pre>
-To do the same thing at run-time (and call it my-wordlist):
-<pre>
-wordlist
-c-wordlist --> ref my-wordlist
-</pre>
-Now you can deal with the wordlist through the ref instance:
-<pre>
-my-wordlist --> push
-my-wordlist --> set-current
-order
-</pre>
-Ficl can also model linked lists and other structures that contain pointers
-to structures of the same or different types. The class constructor word
-<code><a href="#exampleref:">ref:</a></code>
-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> <code>array</code> and <code>new-array</code>
-create uninitialized and initialized arrays, respectively, of a class.
-In order to initialize an array, the class must define (or inherit) a reasonable
-<code>init</code>
-method. <code>New-array</code> invokes it on each member of the array
-in sequence from lowest to highest. Array instances and array members use
-the object methods <code>index</code>, <code>next</code>, and <code>prev</code>
-to navigate. Aggregate a member array of objects using <code><a href="#arraycolon">array:</a></code>.
-The objects are not automatically initialized in this case - your class
-initializer has to call <code>array-init</code> explicitly if you want
-this behavior.
-<p>For further examples of OOP in Ficl, please see the source file <code>ficl/softwords/ficlclass.fr</code>.
-This file wraps several Ficl internal data structures in objects and gives
-use examples.
-<br>
-<h3><a NAME="cstring"></a>Ficl String classes</h3>
-<code>c-string</code> (ficl 2.04 and later) is a reasonably useful dynamic string class. Source code for the class is located in <code>ficl/softwords/string.fr</code>. Features: dynamic creation and resizing; deletion, concatenation, output,
-comparison; creation from quoted string constant (<code>s"</code>).
-<p>Examples of use:
-<pre>
-c-string --> new homer
-s" In this house, " homer --> set
-s" we obey the laws of thermodynamics!" homer --> cat
-homer --> type
-</pre>
-<br>
-<h3>Early binding</h3>
-Ficl also provides early binding if you ask for it. Early binding is not
-as safe as late binding, but it produces code that is more compact and
-efficient because it compiles method addresses rather then their names.
-In the preferred uses of early binding, the class is assumed to be the
-one you're defining. This kind of early binding can only be used inside
-a class definition. Early bound methods still expect to find a class and
-instance cell-pair on top of the stack when they run.
-<br>Here's an example that illustrates a potential problem:
-<pre>
-object --> sub c1
-: m1 { 2:this -- } ." c1's m1" cr ;
-: m2 { 2:this -- } ." Running " this my=> m1 ; ( early )
-: m3 { 2:this -- } ." Running " this --> m1 ( late )
-end-class
-c1 --> sub c2
-: m1 { 2:this -- } ." c2's m1" cr ;
-end-class
-c2 --> new i2
-i2 --> m1 ( runs the m1 defined in c2 )
-i2 --> m2 ( is this what you wanted? )
-i2 --> m3 { runs the overridden m1)
-</pre>
-Even though we overrode method m1 in class c2, the definition of m2 with
-early binding forced the use of m1 as defined in c1. If that's what you
-want, great, but more often you'll want the flexibility of overriding parent
-class behaviors appropriately.
-<ol>
-<li>
-<code>my=></code> binds early to a method in the class being defined,
-as in the example above.
-</li>
-<li>
-<code>my=[ ]</code> binds a sequence of methods in the current class.
-Useful when the class has object members. Lines like <code>this --> state
---> set</code> in the definition of c-led above can be replaced with
-<code>this my=[ state set ]</code> to get early binding.
-</li>
-<li>
-<code>=></code> (dangerous) pops a class off the stack and compiles
-the method in that class. Since you have to specify the class explicitly,
-there is a real danger that this will be out of sync with the class you
-really wanted. I recommend the <code>my=</code> operations.
-</li>
-</ol>
-Early binding using <code>=></code> is dangerous because it partially
-defeats the data-to-code matching mechanism object oriented languages were
-created to provide, but it does increase run-time speed by binding the
-method at compile time. In many cases, such as the <code>init</code> method,
-you can be reasonably certain of the class of thing you're working on.
-This is also true when invoking class methods, since all classes are instances
-of <code>metaclass</code>. Here's an example from the definition of <code>metaclass</code>
-in oo.fr (don't paste this into ficlWin - it's already there):
-<pre>
-: new \ ( class metaclass "name" -- )
- metaclass => instance --> init ;
-</pre>
-Try this...
-<pre>
-metaclass --> see new
-</pre>
-<p>
-Decompiling the method with <code>SEE</code> shows the difference between the
-two strategies. The early bound method is compiled inline, while the late-binding
-operator compiles the method name and code to find and execute it in the
-context of whatever class is supplied on the stack at run-time.
-<br>Notice that the primitive early-binding operator <code>=></code> requires
-a class at compile time. For this reason, classes are <code>IMMEDIATE</code>,
-meaning that they push their signature at compile time or run time. I'd
-recommend that you avoid early binding until you're very comfortable with
-Forth, object-oriented programming, and Ficl's OOP syntax.
-</p>
-<br><hr>
-<h2><a name="theory"></a>Theory</h2>
-All classes in Ficl are derived from the common base class <code><a href="#objectgloss">OBJECT,</a></code>
-as shown in the <a href="#figure1">figure</a> below. All classes are instances
-of <code><a href="#glossclass">METACLASS</a></code>. This means that classes
-are objects, too. <code>METACLASS</code> implements the methods for messages
-sent to classes. Class methods create instances and subclasses, and give
-information about the class. Each class is represented by a data stucture
-of three elements:
-<ul>
-<li>
-The address (named <code>.CLASS</code> ) of a parent class, or zero if it's
-a base class (only <code>OBJECT</code> and <code>METACLASS</code> have this property)</li>
-
-<li>
-The size (named <code>.SIZE</code> ) in address units of an instance of the
-class</li>
-
-<li>
-A wordlist ID (named <code>.WID</code> ) for the methods of the class</li>
-</ul>
-In the figure below, <code>METACLASS</code> and <code>OBJECT</code> are real 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: <code>METACLASS</code> 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 <code>METACLASS</code>
-as an instance of itself.
-<br>
-
-<p><a NAME="figure1"></a><img SRC="ficl_oop.jpg" VSPACE=10 height=442 width=652>
-<br>
-<p>A Ficl <a href="oo_in_c.html#object-def">object</a> associates a <a href="oo_in_c.html#class-def">class</a>
-with an <a href="oo_in_c.html#instance-def">instance</a> (the storage for
-one set of instance variables). This is done explicitly on Ficl's stack:
-any Ficl object is represented by a cell pair:
-<pre>
-( instance-addr class-addr )
-</pre>
-The <code>instance-addr</code> is the address of the object's storage, and the <code>class-addr</code> is the address of its class. Whenever a named Ficl object executes (eg. when you type its name and press enter at the Ficl prompt), it leaves this "signature". All methods by convention expect a class and instance on the
-stack when they execute, too. In many other OO languages, including C++,
-instances contain information about their classes (a <a href="http://www.mvps.org/vbvision/vtable.htm">vtable</a>
-pointer, for example). By making this pairing explicit, Ficl can be OO about chunks of data that don't realize that they are objects, without sacrificing any robustness for native objects. That means that you can use Ficl to write object wrappers for data structures created in C, C++, or even assembly language, as long as you can determine how they're laid out in memory.
-<br>Whenever you create an object in Ficl, you specify its class.
-After that, the object always pushes its class and the address of its payload (instance variable space) when invoked by name.
-<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 <code>METACLASS</code>,
-and all classes inherit from class <code>OBJECT</code>. While confusing at
-first, this gives Ficl a very simple syntax for constructing
-and using objects. Class methods include subclassing (<code>SUB</code>), creating
-initialized and uninitialized instances (<code>NEW</code> and <code>INSTANCE</code>),
-and creating reference instances (<code>REF</code>), described later. Classes
-also have methods for disassembling their methods (<code>SEE</code>), identifying
-themselves (<code>ID</code>), and listing their pedigree (<code>PEDIGREE</code>).
-All objects inherit (from <code>OBJECT</code>) methods for initializing instances
-and arrays of instances, for performing array operations, and for getting
-information about themselves.
-
-<h3>Methods and messages</h3>
-Methods are the functions that objects execute in response to messages.
-A message is a request to an object for a behavior that the object supports.
-When it receives a message, the target object looks up a method that performs
-the behavior for its class, and executes it. Any specific message may be
-bound to different methods in different objects, according to class. This
-separation of messages and methods allows objects to behave <a href="http://whatis.techtarget.com/definition/0,,sid9_gci212803,00.html">
-polymorphically</a>.
-(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 <code>--></code> that sends messages
-to objects at run-time, and an early-binding operator <code>=></code>
-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.
-<br><hr>
-<h2><a NAME="oopgloss"></a>OOP Glossary</h2>
-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 <code>softwords/oo.fr</code>.
-<dl>
-<dt>
---> ( instance class "method-name" -- xn )
-</dt>
-<dd>
-Late binding: looks up and executes the given method in the context of
-the class on top of the stack.</dd>
-
-<dt>
-c-> ( instance class "method-name" -- xn exc )
-</dt>
-<dd>
-Late binding with <code>CATCH</code>: looks up and <code>CATCH</code>es the given
-method in the context of the class on top of the stack, pushes zero or
-exception code upon return.</dd>
-
-<dt>
-my=> comp: ( "method-name" -- ) exec: ( inst class -- xn )
-</dt>
-
-<dd>
-Early binding: compiles code to execute the method of the class being defined.
-Only visible and valid in the scope of a <code>--> sub</code> .. <code>end-class</code>
-class definition.</dd>
-
-<dt>
-my=[ comp: ( "obj1 obj2 .. method ]" -- ) exec:( inst class -- xn )
-</dt>
-<dd>
-Early binding: compiles code to execute a chain of methods of the class
-being defined. Only visible and valid in the scope of a <code>--> sub</code>
-.. <code>end-class</code> class definition.</dd>
-
-<dt>
-=> comp: ( class meta "method-name" -- ) exec: ( inst class -- xn )
-</dt>
-<dd>
-Early binding: compiles code to execute the method of the class specified
-at compile time.
-</dd>
-
-<dt>
-do-do-instance
-</dt>
-<dd>
-When executed, causes the instance to push its ( instance class ) stack
-signature. Implementation factor of <code>metaclass --> sub</code>.
-Compiles <code>.do-instance</code> in the context of a class; <code>.do-instance</code>
-implements the <code>does></code> part of a named instance.
-</dd>
-
-<dt>
-exec-method ( instance class c-addr u -- xn )
-</dt>
-<dd>
-Given the address and length of a message (method name) on the stack, finds
-the method in the context of the specified class and invokes it. Upon entry
-to the method, the instance and class are on top of the stack, as usual.
-If unable to find the method, prints an error message and aborts.
-</dd>
-
-<dt>
-find-method-xt ( class "method-name" -- class xt )
-</dt>
-<dd>
-Attempts to map the message to a method in the specified class. If successful,
-leaves the class and the execution token of the method on the stack. Otherwise
-prints an error message and aborts.
-</dd>
-
-<dt>
-lookup-method ( class c-addr u -- class xt )
-</dt>
-
-<dd>
-Given the address and length of a message (method name) on the stack, finds
-the method in the context of the specified class. If unable to find the
-method, prints an error message and aborts.
-</dd>
-
-<dt>
-parse-method comp: ( "method-name" -- ) exec: ( -- c-addr u )
-</dt>
-
-<dd>
-Parse "name" from the input stream and compile code to push its length
-and address when the enclosing definition runs.</dd>
-</dl>
-<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 <code>sub</code> method on <code>object</code> or any
-class derived from it (<i>not</i> <code>metaclass</code>). Source code for
-Ficl OOP is in ficl/softwords/oo.fr.
-<br>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 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:
-<pre>
-object subclass c-example
- cell: .cell0
- c-4byte obj: .nCells
- 4 c-4byte array: .quad
- char: .length
-79 chars: .name
-end-clas
-</pre>
-This class only defines instance variables, and it inherits some methods
-from <code>object</code>. 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.
-The word <code>subclass</code> is shorthand for <code>--> sub</code>
-<dl>
-<dt>cell: ( offset "name" -- offset' )
-<br>
-Execution: ( -- cell-addr )
-</dt>
-
-<dd>
-Create an untyped instance variable one cell wide. The instance variable
-leaves its payload's address when executed.</dd>
-
-<dt>
-cells: ( offset nCells "name" -- offset' )
-</dt>
-<dt>
-Execution: ( -- cell-addr )
-</dt>
-
-<dd>
-Create an untyped instance variable n cells wide.</dd>
-
-<dt>
-char: ( offset "name" -- offset' )
-</dt>
-
-<dt>
-Execution: ( -- char-addr )
-</dt>
-<dd>
-Create an untyped member variable one char wide</dd>
-
-<dt>
-chars: ( offset nChars "name" -- offset' )
-</dt>
-<dt>
-Execution: ( -- char-addr )
-</dt>
-<dd>
-Create an untyped member variable n chars wide.
-</dd>
-
-<dt>
-obj: ( offset class meta "name" -- offset' )
-</dt>
-<dt>
-Execution: ( -- instance class )
-</dt>
-<dd>
-Aggregate an uninitialized instance of <code>class</code> as a member variable
-of the class under construction.
-</dd>
-
-<dt>
-<a NAME="arraycolon"></a>
-array: ( offset n class meta "name" -- offset' )
-</dt>
-<dt>
-Execution: ( -- instance class )
-</dt>
-
-<dd>
-Aggregate an uninitialized array of instances of the class specified as
-a member variable of the class under construction.</dd>
-
-<dt>
-<a NAME="exampleref:"></a>
-ref: ( offset class meta "name" -- offset' )
-<br>
-Execution: ( -- ref-instance ref-class )
-</dt>
-<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>
-</dl>
-
-<pre>
-object subclass c-4list
-c-4list ref: .link
-c-4byte obj: .payload
-end-class;
-
-address-of-existing-list c-4list --> ref mylist
-</pre>
-<p>
-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).</p>
-
-<p>
-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.</p>
-
-<p>
-By the way, it is also possible to construct a pair of classes that contain
-aggregate pointers to each other. Here's an example:</p>
-
-<pre>
-object subclass akbar
-suspend-class \ put akbar on hold while we define jeff
-
-object subclass jeff
- akbar ref: .significant-other
- ( your additional methods here )
-
-end-class \ done with jeff
-
-akbar --> resume-class \ resume defining akbar
- jeff ref: .significant-other
- ( your additional methods here )
-end-class \ done with akbar
-</pre>
-
-<h3>
-<a NAME="glossclass"></a>
-Class Methods Glossary
-</h3>
-These words are methods of <code>metaclass</code>. 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 <code>softwords/oo.fr</code>.
-<dl>
-<dt>
-instance ( class metaclass "name" -- instance class )
-</dt>
-<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>
-</dl>
-<pre>
-c_ref --> instance uninit-ref 2drop
-</pre>
-<dl>
-<dt>
-new ( class metaclass "name" -- )
-</dt>
-<dd>
-Create an initialized instance of class, giving it the name specified.
-This method calls init to perform initialization.
-</dd>
-
-<dt>
-array ( nObj class metaclass "name" -- nObjs instance class )
-</dt>
-<dd>
-Create an array of nObj instances of the specified class. Instances are
-not initialized. Example:
-</dd>
-</dl>
-<pre>
-c_4byte --> array 40-raw-bytes 2drop drop
-</pre>
-<dl>
-<dt>
-new-array ( nObj class metaclass "name" -- )
-</dt>
-<dd>
-Creates an initialized array of nObj instances of the class. Same syntax
-as <code>array</code>
-
-<dt>
-<a NAME="alloc"></a>
-alloc ( class metaclass -- instance class )
-</dt>
-<dd>
-Creates an anonymous instance of <code>class</code> from the heap (using a call
-to ficlMalloc() to get the memory). Leaves the payload and class addresses
-on the stack. Usage example:
-</dd>
-</dl>
-<pre>
-c-ref --> alloc 2constant instance-of-ref
-</pre>
-<dl>
-<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>
-alloc-array ( nObj class metaclass -- instance class )
-</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
-<code>init</code> method
-</dd>
-
-<dt>
-<a NAME="allot"></a>
-allot ( class metaclass -- instance class )
-</dt>
-<dd>
-Creates an anonymous instance of <code>class</code> from the dictionary. Leaves
-the payload and class addresses on the stack. Usage example:
-</dd>
-</dl>
-<pre>
-c-ref --> allot 2constant instance-of-ref
-</pre>
-<dl>
-<dd>
-Creates a double-cell constant that pushes the payload and class address
-of a heap instance of c-ref.
-</dd>
-
-<dt>
-<a NAME="allotarray"></a>
-allot-array ( nObj class metaclass -- instance class )
-</dt>
-<dd>
-Same as new-array, but creates anonymous instances from the dictionary.
-Each instance is initialized using the class's
-<code>init</code> method
-</dd>
-
-<dt>
-ref ( instance-addr class metaclass "name" -- )
-</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>
-
-<dt>
-sub ( class metaclass -- old-wid addr[size] size )
-</dt>
-<dd>
-Derive a subclass. You can add or override methods, and add instance variables.
-Alias: <code>subclass</code>. Examples:
-</dd>
-</dl>
-<pre>
-c_4byte --> sub c_special4byte
-( your new methods and instance variables here )
-end-class
-
-( --OR-- )
-
-c_4byte subclass c_special4byte
-( your new methods and instance variables here )
-end-class
-</pre>
-<dl>
-<dt>
-.size ( class metaclass -- instance-size )
-</dt>
-<dd>
-Returns address of the class's instance size field, in address units. This
-is a metaclass member variable.</dd>
-
-<dt>
-.super ( class metaclass -- superclass )
-</dt>
-<dd>
-Returns address of the class's superclass field. This is a metaclass member
-variable.</dd>
-
-<dt>
-.wid ( class metaclass -- wid )
-</dt>
-<dd>
-Returns the address of the class's wordlist ID field. This is a metaclass
-member variable.</dd>
-
-<dt>
-get-size
-</dt>
-<dd>
-Returns the size of an instance of the class in address units. Imeplemented
-as</dd>
-</dl>
-
-<pre>
-: get-size metaclass => .size @ ;
-</pre>
-<dl>
-
-<dt>
-get-wid
-</dt>
-<dd>
-Returns the wordlist ID of the class. Implemented as</dd>
-
-</dl>
-<pre>
-: get-wid metaclass => .wid @ ;
-</pre>
-<dl>
-<dt>
-get-super</dt>
-<dd>
-Returns the class's superclass. Implemented as</dd>
-</dl><pre>
-: get-super metaclass => .super @ ;
-</pre>
-<dl>
-id ( class metaclass -- c-addr u )
-</dt>
-<dd>
-Returns the address and length of a string that names the class.</dd>
-
-<dt>
-methods ( class metaclass -- )
-</dt>
-<dd>
-Lists methods of the class and all its superclasses</dd>
-
-<dt>
-offset-of ( class metaclass "name" -- offset )
-</dt>
-<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>
-
-</dl>
-<pre>
-metaclass --> offset-of .wid
-</pre>
-<dl>
-<dt>
-pedigree ( class metaclass -- )
-</dt>
-<dd>
-Lists the pedigree of the class (inheritance trail)</dd>
-
-<dt>
-see ( class metaclass "name" -- )
-</dt>
-<dd>
-Decompiles the specified method - obect version of <code>SEE</code>, from the
-<code>TOOLS</code>
-wordset.
-</dd>
-<dt>
-debug ( class metaclass "name" -- )
-</dt>
-<dd>
-Invokes the debugger on the specified method - obect version of <code>DEBUG</code>.
-</dd>
-</dl>
-
-<h3>
-<a NAME="objectgloss"></a>
-OBJECT Methods Glossary
-</h3>
-These are methods that are defined for all instances by the base class
-<code>object</code>. The methods include default initialization, array manipulations, aliases of class methods, upcasting, and programming tools.
-<dl>
-<dt>
-init ( instance class -- )
-</dt>
-<dd>
-Default initializer called automatically for all instances created with
-<code>new</code> or <code>new-array</code>. Zero-fills the instance. You do not normally need to invoke <code>init</code> explicitly.</dd>
-
-<dt>
-array-init ( nObj instance class -- )
-</dt>
-<dd>
-Applies <code>init</code> to an array of objects created by <code>new-array</code>.
-Note that <code>array:</code> does not cause aggregate arrays to be initialized
-automatically. You do not normally need to invoke <code>array-init</code> explicitly.</dd>
-
-<dt>
-<a NAME="oofree"></a>
-free ( instance class -- )
-</dt>
-<dd>
-Releases memory used by an instance previously created with <code>alloc</code>
-or <code>alloc-array</code>. 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 <code>alloc</code> or <code>alloc-array</code>.
-</dd>
-
-<dt>
-class ( instance class -- class metaclass )
-</dt>
-<dd>
-Convert an object signature into that of its class. Useful for calling
-class methods that have no object aliases.</dd>
-
-<dt>
-super ( instance class -- instance parent-class )
-</dt>
-<dd>
-Upcast an object to its parent class. The parent class of <code>object</code>
-is zero. Useful for invoking an overridden parent class method.</dd>
-
-<dt>
-pedigree ( instance class -- )
-</dt>
-<dd>
-Display an object's pedigree - its chain of inheritance. This is an alias
-for the corresponding class method.</dd>
-
-<dt>
-size ( instance class -- sizeof(instance) )
-</dt>
-<dd>
-Returns the size, in address units, of one instance. Does not know about
-arrays! This is an alias for the class method <code>get-size</code></dd>
-
-<dt>
-methods ( instance class -- )
-</dt>
-<dd>
-Class method alias. Displays the list of methods of the class and all superclasses
-of the instance.</dd>
-
-<dt>
-index ( n instance class -- instance[n] class )
-</dt>
-<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>
-</dl>
-<pre>
-0 my-obj --> index
-\ is equivalent to
-my-obj
-</pre>
-<dl>
-<dd>
-Check out the <a href="#minusrot">description of <code>-ROT</code></a> for
-help in dealing with indices on the stack.</dd>
-
-<dt>
-next ( instance[n] class -- instance[n+1] class )
-</dt>
-<dd>
-Convert an array-object signature into the signature of the next
-object in the array. No check for bounds overflow.</dd>
-
-<dt>
-prev ( instance[n] class -- instance[n-1] class )
-</dt>
-<dd>Convert an object signature into the signature of the previous object
-in the array. No check for bounds underflow.
-</dd>
-</dl>
-
-<h3>
-<a NAME="stockclasses"></a>Supplied Classes (See classes.fr)</h3>
-
-<dl>
-<dt>metaclass</dt>
-
-<dd>
-Describes all classes of Ficl. Contains class methods. Should never be
-directly instantiated or subclassed. Defined in oo.fr. Methods described
-above.</dd>
-
-<dt>
-object
-</dt>
-<dd>
-Mother of all Ficl objects. Defines default initialization and array indexing
-methods. Defined in oo.fr. Methods described above.</dd>
-
-<dt>c-ref</dt>
-<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>
-</dl>
-
-<pre>
-get ( inst class -- ref-inst ref-class )
-set ( ref-inst ref-class inst class -- )
-.instance \ cell member that holds the instance
- ( inst class -- a-addr )
-.class \ cell member that holds the class
- ( inst class -- a-addr )
-</pre>
-<dl>
-<dt>
-c-byte
-</dt>
-<dd>
-Primitive class derived from <code>object</code>, with a 1-byte payload. Set
-and get methods perform correct width fetch and store. Methods and members:
-</dd>
-</dl>
-<pre>
-get ( inst class -- c )
-set ( c inst class -- )
-.payload \ member holds instance's value
- ( inst class -- addr )
-
-</pre>
-<dl>
-<dt>c-2byte</dt>
-<dd>
-Primitive class derived from <code>object</code>, with a 2-byte payload. Set
-and get methods perform correct width fetch and store. Methods and members:
-</dd>
-</dl>
-<pre>
-get ( inst class -- 2byte )
-set ( 2byte inst class -- )
-.payload \ member holds instance's value
- ( inst class -- addr )
-</pre>
-<dl>
-<dt>c-4byte</dt>
-<dd>
-Primitive class derived from <code>object</code>, with a 4-byte payload. Set
-and get methods perform correct width fetch and store. Methods and members:</dd>
-</dl>
-<pre>
-get ( inst class -- x )
-set ( x inst class -- )
-.payload \ member holds instance's value
- ( inst class -- addr )
-</pre>
-<dl>
-<dt>c-cell</dt>
-<dd>
-Primitive class derived from <code>object</code>, with a cell payload (equivalent
-to c-4byte in 32 bit implementations, 64 bits wide on Alpha). Set and get
-methods perform correct width fetch and store. Methods and members:
-</dd>
-</dl>
-<pre>
-get ( inst class -- x )
-set ( x inst class -- )
-.payload \ member holds instance's value
- ( inst class -- addr )
-</pre>
-<dl>
-<dt>c-ptr</dt>
-<dd>
-Base class derived from <code>object</code> for pointers to non-object types.
-This class is not complete by itself: several methods depend on a derived
-class definition of <code>@size</code>. Methods and members:</dd>
-</dl>
-<pre>
-.addr ( inst class -- a-addr )
-\ member variable - holds the pointer address
-
-get-ptr ( inst class -- ptr )
-set-ptr ( ptr inst class -- )
-inc-ptr ( inst class -- )
-\ Adds @size to pointer address
-dec-ptr ( inst class -- )
-\ Subtracts @size from pointer address
-
-index-ptr ( i inst class -- )
-\ Adds i*@size to pointer address
-</pre>
-<dl>
-<dt>c-bytePtr</dt>
-<dd>
-Pointer to byte derived from c-ptr. Methods and members:
-</dd>
-</dl>
-<pre>
-@size ( inst class -- size )
-\ Push size of the pointed-to thing
-
-get ( inst class -- c )
-\ Fetch the pointer's referent byte
-
-set ( c inst class -- )
-\ Store c at the pointer address
-</pre>
-<dl>
-<dt>c-2bytePtr</dt>
-<dd>
-Pointer to double byte derived from c-ptr. Methods and members:</dd>
-</dl>
-<pre>
-@size ( inst class -- size )
-\ Push size of the pointed-to thing
-
-get ( inst class -- n )
-\ Fetch the pointer's referent c-2byte
-
-set ( n inst class -- )
-\ Store n at the pointer address
-</pre>
-
-<dl>
-<dt>c-4bytePtr</dt>
-<dd>
-Pointer to quad-byte derived from c-ptr. Methods and members:
-</dd>
-</dl>
-<pre>
-@size ( inst class -- size )
-\ Push size of the pointed-to thing (a c-4byte)
-
-get ( inst class -- n )
-\ Fetch the pointer's referent c-4byte
-
-set ( n inst class -- )
-\ Store n at the pointer address
-</pre>
-
-<dl>
-<dt>c-cellPtr</dt>
-<dd>
-Pointer to cell derived from c-ptr. Methods and members:</dd>
-</dl>
-<pre>
-@size ( inst class -- size )
-\ Push size of the pointed-to thing (a cell)
-
-get ( inst class -- x )
-\ Fetch the pointer's referent cell
-
-set ( x inst class -- )
-\ Store n at the pointer address
-</pre>
-
-<dl>
-<dt>c-string (see string.fr)</dt>
-<dd>
-Dynamically allocated string similar to MFC CString (Partial list of methods
-follows)</dd>
-</dl>
-<pre>
-set ( c-addr u 2:this -- )
-\ Initialize buffer to the specified string
-
-get ( 2:this -- c-addr u )
-\ Return buffer contents as counted string
-
-cat ( c-addr u 2:this -- )
-\ Append given string to end of buffer
-
-compare ( 2string 2:this -- n )
-\ Return result of lexical compare
-
-type ( 2:this -- )
-\ Print buffer to the output stream
-
-
-hashcode ( 2:this -- x )
-\ Return hashcode of string (as in dictionary)
-
-free ( 2:this -- )
-\ Release internal buffer
-</pre>
-
-<dl>
-<dt>c-hashstring (see string.fr)</dt>
-<dd>
-Derived from c-string. This class adds a hashcode member variable.</dd>
-</dl>
-</div>
-</body>
-</html>
-
binary files a/doc/ficl_oop.jpg /dev/null differ
--- a/doc/ficl_parse.html
+++ /dev/null
@@ -1,201 +1,0 @@
-<!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="Description" content="the coolest embedded scripting language ever">
- <title>Ficl Parse Steps</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
-</head>
-<body>
-<link REL="SHORTCUT ICON" href="ficl.ico">
-<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="675" ><tr><td>
-<h1>Ficl Parse Steps</h1>
-<script language="javascript" src="ficlheader.js"></script>
-
-<h2>Overview</h2>
-<p>
-Ficl 2.05 and later includes an extensible parser chain. Ficl feeds every incoming token
-(chunk of text with no internal whitespace) to each step in the parse chain in turn. The
-first parse step that successfully matches the token applies semantics to it and returns
-a TRUE flag, ending the sequence. If all parse steps fire without a match, ficl prints
-an error message and resets the virtual machine. Parse steps can be written in precompiled
-code, or in ficl itself, and can be appended to the chain at run-time if you like.
-</p>
-<p>
-More detail:
-</p>
-<ul>
-<li>
-If compiling and local variable support is enabled, attempt to find the token in the local
-variable dictionary. If found, execute the token's compilation semantics and return
-</li>
-<li>
-Attempt to find the token in the system dictionary. If found, execute the token's semantics
-(may be different when compiling than when interpreting) and return
-</li>
-<li>
-If prefix support is enabled (Compile-time constant FICL_WANT_PREFIX in sysdep.h is non-zero),
-attempt to match the beginning of the token to the list of known prefixes. If there's a match,
-execute the associated prefix method.
-</li>
-<li>
-Attempt to convert the token to a number in the present <code>BASE</code>. If successful, push the
-value onto the stack if interpreting, compile it if compiling. Return
-</li>
-<li>
-All previous parse steps failed to recognize the token. Print "<token> not found" and abort
-</li>
-</ul>
-You can add steps to the parse chain, and you can add prefixes.
-<h2>Adding Parse Steps</h2>
-You can add a parse step in two ways. The first is to write a ficl word that
-has the correct stack signature for a parse step:
-<pre>
-my-parse-step ( c-addr u -- ??? flag )
-</pre>
-Where <code>c-addr u</code> are the address and length of the incoming token,
-and <code>flag</code> is <code>true</code> if the parse step recognizes the token
-and <code>false</code> otherwise.
-<br>
-Install the parse step using <code>add-parse-step</code>.
-A trivial example:
-<pre>
-: ?silly ( c-addr u -- flag )
- ." Oh no! Not another " type cr true ;
-' ?silly add-parse-step
-parse-order
-</pre>
-<p>
-The other way to add a parse step is by writing it in C, and inserting it into the
-parse chain with:
-</p>
-<pre>
-void ficlAddPrecompiledParseStep(FICL_SYSTEM *pSys, char *name, FICL_PARSE_STEP pStep);
-</pre>
-Where <code>name</code> is the display name of the parse step in the parse chain (as revealed
-by <code>parse-order</code>). Parameter pStep is a pointer to the code for the parse step itself,
-and must match the following declaration:
-<pre>
-typedef int (*FICL_PARSE_STEP)(FICL_VM *pVM, STRINGINFO si);
-</pre>
-<p>
-Upon entry to the parse step, <code>si</code> points to the incoming token. The parse step
-must return <code>FICL_TRUE</code> if it succeeds in matching the token, and
-<code>FICL_FALSE</code> otherwise. If it succeeds in matching a token, the parse step
-applies semantics to it before returning. See <code>ficlParseNumber()</code> in words.c for
-an example.
-</p>
-
-<h2>Adding Prefixes</h2>
-<p>
-What's a prefix, anyway? A prefix (contributed by Larry Hastings) is a token that's
-recognized as the beginning of another token. Its presence modifies the semantics of
-the rest of the token. An example is <code>0x</code>, which causes digits following
-it to be converted to hex regardless of the current value of <code>BASE</code>.
-</p><p>
-Caveat: Prefixes are matched in sequence, so the more of them there are,
-the slower the interpreter gets. On the other hand, because the prefix parse step occurs
-immediately after the dictionary lookup step, if you have a prefix for a particular purpose,
-using it may save time since it stops the parse process.
-</p><p>
-Each prefix is a ficl word stored in a special wordlist called <code><prefixes></code>. When the
-prefix parse step (<code>?prefix</code> AKA ficlParsePrefix()) fires, it searches each word
-in <code><prefixes></code> in turn, comparing it with the initial characters of the incoming
-token. If a prefix matches, the parse step returns the remainder of the token to the input stream
-and executes the code associated with the prefix. This code can be anything you like, but it would
-typically do something with the remainder of the token. If the prefix code does not consume the
-rest of the token, it will go through the parse process again (which may be what you want).
-</p><p>
-Prefixes are defined in <code>prefix.c</code> and in <code>softwords/prefix.fr</code>. The easiest way to add a new prefix is
-to insert it into <code>prefix.fr</code> and rebuild the system. You can also add prefixes interactively by bracketing prefix definitions as follows (see prefix.fr):
-</p>
-<pre>
-start-prefixes ( defined in prefix.fr )
-\ make dot-paren a prefix (create an alias for it in the prefixes list)
-: .( .( ;
-: 0b 2 __tempbase ; immediate
-end-prefixes
-</pre>
-<p>
-The precompiled word <code>__tempbase</code> is a helper for prefixes that specify a
-temporary value of <code>BASE</code>.
-</p><p>
-Constant <code>FICL_EXTENDED_PREFIX</code> controls the inclusion of a bunch of additional
-prefix definitions. This is turned off in the default build since several of these prefixes
-alter standard behavior, but you might like them.
-</p>
-
-<h2>Notes</h2>
-<p>
-Prefixes and parser extensions are non-standard, although with the exception of prefix support,
-ficl's default parse order follows the standard. Inserting parse steps in some other order
-will almost certainly break standard behavior.
-</p>
-<p>
-The number of parse steps that can be added to the system is limited by the value of
-<code>FICL_MAX_PARSE_STEPS</code> (defined in sysdep.h unless you define it first), which defaults
-to 8. More parse steps means slower average interpret and compile performance,
-so be sparing. Same applies to the number of prefixes defined for the system, since each one
-has to be matched in turn before it can be proven that no prefix matches. On the other hand,
-if prefixes are defined, use them when possible: since they are matched early in the parse order,
-a prefix match short circuits the parse process, saving time relative to
-(for example) using a number builder parse step at the end of the parse chain.
-</p>
-<p>
-Compile time constant <code>FICL_EXTENDED_PREFIX</code> enables several more prefix
-definitions in prefix.c and prefix.fr. Please note that this will slow average compile and
-interpret speed in most cases.
-</p>
-<h2>Parser Glossary</h2>
-<dl>
-<dt><b><code>parse-order ( -- )</code></b></dt>
-<dd>
-Prints the list of parse steps in the order in which they are evaluated.
-Each step is the name of a ficl word with the following signature:
-<pre>
-parse-step ( c-addr u -- ??? flag )
-</pre>
-A parse step consumes a counted string (the incoming token) from the stack,
-and exits leaving a flag on top of the stack (it may also leave other parameters as side effects).
-The flag is true if the parse step succeeded at recognizing the token, false otherwise.
-</dd>
-<dt><b><code>add-parse-step ( xt -- )</code></b></dt>
-<dd>
-Appends a parse step to the parse chain. XT is the adress (execution token) of a ficl
-word to use as the parse step. The word must have the following signature:
-<pre>
-parse-step ( c-addr u -- ??? flag )
-</pre>
-A parse step consumes a counted string (the incoming token) from the stack,
-and exits leaving a flag on top of the stack (it may also leave other parameters as side effects).
-The flag is true if the parse step succeeded at recognizing the token, false otherwise.
-</dd>
-<dt><b><code>show-prefixes ( -- )</code></b></dt>
-<dd>
-Defined in <code>softwords/prefix.fr</code>.
-Prints the list of all prefixes. Each prefix is a ficl word that is executed if its name
-is found at the beginning of a token. See <code>softwords/prefix.fr</code> and <code>prefix.c</code> for examples.
-</dd>
-<dt><b><code>start-prefixes ( -- )</code></b></dt>
-<dd>
-Defined in <code>softwords/prefix.fr</code>.
-Declares the beginning of one or more prefix definitions (it just switches the compile wordlist
-to <code><prefixes></code>
-</dd>
-<dt><b><code>end-prefixes ( -- )</code></b></dt>
-<dd>
-Defined in <code>softwords/prefix.fr</code>.
-Restores the compilation wordlist that was in effect before the last invocation of
-<code>start-prefixes</code>. Note: the prior wordlist ID is stored in a Ficl variable, so
-attempts to nest <code>start-prefixes end-prefixes</code> blocks wil result in mildly silly
-side effects.
-</dd>
-</dl>
-</td></tr></table>
-</body>
-</html>
\ No newline at end of file
--- a/doc/ficl_rel.html
+++ /dev/null
@@ -1,702 +1,0 @@
-<!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.73 [en] (Win98; U) [Netscape]">
- <title>Ficl Release Notes</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
-</head>
-<body>
-
-<h1>
-Ficl Release Notes
-</h1>
-
-<script language="javascript" src="ficlheader.js"></script>
-
-<br>
-<table BORDER=0 CELLPADDING=3 COLS=1 WIDTH="675" >
-<tr>
-<td>
-<h2><a NAME="whatsnew">Version 3.01</a></h2>
-<ul>
-<li>
-Major contribs by <a href="mailto:larry@hastings.org">Larry Hastings</a>:
-<ul>
-<li>
-FILE wordset (fileaccess.c)
-</li>
-<li>
-ficlEvaluate wrapper for ficlExec
-</li>
-<li>
-ficlInitSystemEx makes it possible to bind selectable properties to VMs at create time
-</li>
-<li>
-Python version of softcore builder ficl/softwords/softcore.py
-</li>
-</ul>
-</li>
-<li>
-<a href="http://www.swig.org">SWIG</a> wrapper for Ficl contributed by <a href="mailto:xiaoye@users.sf.net">Ye Xiaofeng</a>.
-SWIG is a software development tool that connects programs written in C, C++, and Objective-C with a variety of high-level programming languages - now including Ficl. SWIG writes the wrapper code so you don't have to.
-</li>
-<li>
-Environment contains <code>ficl-version</code> (double)
-</li>
-<li>
-<code>?number</code> handles trailing decimal point per DOUBLE wordset spec
-</li>
-<li>
-Fixed broken <code>.env</code> (thanks to Leonid Rosin for spotting this goof)
-</li>
-<li>
-Fixed broken floating point words that depended on evaluation order of stack pops.
-</li>
-<li>
-<code>env-constant</code>
-</li>
-<li>
-<code>env-2constant</code>
-</li>
-<li>
-dictHashSummary is now commented out unless FICL_WANT_FLOAT (thanks to Leonid Rosin again)
-</li>
-<li>
-Thanks to David McNab for pointing out that <code>.(</code> should be <code>IMMEDIATE</code>. Now it is.
-</li>
-</ul>
-
-
-<h2>Version 3.00a</h2>
-
-<ul>
-<li>
-Fixed broken oo.fr by commenting out vcall stuff using FICL_WANT_VCALL. Vcall is still broken.
-</li>
-</ul>
-
-<h2>Version 3.00</h2>
-
-<ul>
-<li>
-Added pSys parameter to most ficlXXXX functions for multiple system support. Affected functions:
-<ul>
-<li>dictLookupLoc renamed to ficlLookupLoc after addition of pSys param</li>
-<li>ficlInitSystem returns a FICL_SYSTEM*</li>
-<li>ficlTermSystem</li>
-<li>ficlNewVM</li>
-<li>ficlLookup</li>
-<li>ficlGetDict</li>
-<li>ficlGetEnv</li>
-<li>ficlSetEnv</li>
-<li>ficlSetEnvD</li>
-<li>ficlGetLoc</li>
-<li>ficlBuild</li>
-</ul>
-</li>
-
-<li>Fixed off-by-one bug in ficlParsePrefix</li>
-<li>Ficl parse-steps now work correctly - mods to interpret()</li>
-<li>Made tools.c:isAFiclWord more selective</li>
-<li>Tweaked makefiles and code to make gcc happy under linux</li>
-<li>Vetted all instances of LVALUEtoCELL to make sure they're working on CELL sized operands
-(for 64 bit compatibility)</li>
-</ul>
-
-<h2>Version 2.06</h2>
-<ul>
-<li>Debugger changes:</li>
-<ul>
-<li>New debugger command "x" to execute the rest of the command line as ficl</li>
-<li>New debugger command "l" lists the source of the innermost word being debugged</li>
-<li>If you attempt to debug a primitive, it gets executed rather than doing nothing</li>
-<li><code>R.S</code> displays the stack contents symbolically</li>
-<li>Debugger now operates correctly under ficlwin, although ficlwin's key handling leaves a lot to be desired. </li>
-<li><code>SEE</code> listing enhanced for use with the debugger</li>
-</ul>
-<li>Added Guy Carver's changes to oo.fr for VTABLE support</li>
-<li><code>float.c</code> words f> and >f to move floats to and from the param stack, analogous to >r and r></li>
-<li><code>LOOKUP</code> - Surrogate precompiled parse step for ficlParseWord (this step is hard
- coded in <code>INTERPRET</code>)</li>
-<li>License text at top of source files changed from LGPL to BSD by request</li>
-<li>Win32 console version now handles exceptions more gracefully rather than crashing - uses win32
-structured exception handling.</li>
-<li>Fixed <code>BASE</code> bug from 2.05 (was returning the value rather than the address) </li>
-<li>Fixed <code>ALLOT</code> bug - feeds address units to dictCheck, which expects Cells. Changed dictCheck to expect Address Units. </li>
-<li>Float stack display word renamed to <code>f.s</code> from <code>.f</code> to be consistent with <code>r.s</code> and <code>.s</code></li>
-</ul>
-
-<h2>Version 2.05</h2>
-<h3>General</h3>
-
-<ul>
-<li>HTML documentation extensively revised</li>
-<li>Incorporated Alpha (64 bit) patches from the freeBSD team.</li>
-<li>Split SEARCH and SEARCH EXT words from words.c to search.c</li>
-<li><a href="ficl_loc.html">2LOCALS</a> defined in <a href="ficl_loc.html#jhlocal">Johns Hopkins local syntax</a> now lose the first '2:' in their names.</li>
-<li>Simple step <a href="ficl_debug.html">debugger</a> (see tools.c)</li>
-<li>The text interpreter is now extensible - this is accomplished through the use
-of <code>ficlAddParseStep()</code>. <code>FICL_MAX_PARSE_STEPS</code> limits the number of parse steps
-(default: 8). You can write a precompiled parse step (see <code>ficlParseNumber</code>) and
-append it to the chain, or you can write one in ficl and use <code>ADD-PARSE-STEP</code>
-to append it. Default parse steps are initialized in <code>ficlInitSystem</code>. You can list
-the parse steps with <code>parse-order ( -- )</code>.</li>
-<li>There is now a FICL_SYSTEM structure. This is a transitional release - version 3.0
-will alter several API prototypes to take this as a parameter, allowing multiple
-systems per process (and therefore multiple dictionaries). For those who use ficl
-under a virtual memory O/S like Linux or Win NT, you can just create multiple ficl
-processes (not threads) instead and save youself the wait.</li>
-<li>Fixes for improved command line operation in testmain.c (Larry Hastings)</li>
-<li>Numerous extensions to OO facility, including a new allot methods, ability
-to catch method invocations (thanks to Daniel Sobral again)</li>
-<li>Incorporated Alpha (64 bit) patches contributed by Daniel Sobral and the freeBSD team
-Ficl is now 64 bit friendly! UNS32 is now FICL_UNS.</li>
-<li>Split SEARCH and SEARCH EXT words from words.c to search.c</li>
-<li>ABORT" now complies with the ANS (-2 THROWs)</li>
-<li>Floating point support contributed by Guy Carver (Enable FICL_WANT_FLOAT in sysdep.h).</li>
-<li>Win32 vtable model for objects (Guy Carver)</li>
-<li>Win32 dll load/call suport (Larry Hastings)</li>
-<li>Prefix support (Larry Hastings) (prefix.c prefix.fr FICL_EXTENDED_PREFIX) makes it
-easy to extend the parser to recignize prefixes like 0x and act on them. Use show-prefixes
-to see what's defined.</li>
-<li>Cleaned up initialization sequence so that it's all in ficlInitSystem, and so that
-a VM can be created successfully before the dictionary is created</li>
-</ul>
-
-<h3>
-Bug fixes</h3>
-
-<ul>
-<li>
-<a href="http://www.taygeta.com/forth/dpans9.htm#9.6.2.0680">ABORT"</a>
-now works correctly (I promise!)</li>
-
-<li>
-<a href="http://www.taygeta.com/forth/dpans6.htm#6.2.2125">REFILL</a> works
-better</li>
-
-<li>
-<a href="http://www.taygeta.com/forth/dpans6.htm#6.1.0710">ALLOT</a>'s
-use of dictCheck corrected (finally)</li>
-</ul>
-
-<h3>
-New words</h3>
-
-<ul>
-<li>
-<a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0415">2r@</a> <a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0410">2r></a> <a href="http://www.taygeta.com/forth/dpans6.htm#6.2.0340">2>r</a>
-(CORE EXT)</li>
-
-<li>
-<a href="http://www.taygeta.com/forth/dpans8.htm#8.6.1.0440">2VARIABLE</a>
-(DOUBLE)</li>
-
-<li>
-<a href="http://www.taygeta.com/forth/dpans16.htm#16.6.2.1985">ORDER</a>
-now lists wordlists by name</li>
-
-<li>
-<a href="http://www.taygeta.com/forth/dpans15.htm#15.6.1.0220">.S</a> now
-displays all stack entries on one line, like a stack comment</li>
-
-<li>
-<a href="ficl.html#wid-get-name"><tt>wid-get-name</tt> </a>
-given a wid, returns the address and count of its name. If no name, count
-is 0</li>
-
-<li>
-<tt><a href="ficl.html#wid-set-name">wid-set-name</a></tt>
-set optional wid name pointer to the \0 terminated string address specified.</li>
-
-<li>
-<tt><a href="ficl.html#ficlwordlist">ficl-named-wordlist</a></tt> creates
-a ficl-wordlist and names it. This is now used in <tt>vocabulary</tt> and
-<tt><a href="ficl.html#ficlvocabulary">ficl-vocabulary</a></tt> </li>
-
-<li>
-<tt><a href="ficl.html#last-word">last-word</a></tt> returns the
-xt of the word being defined or most recently defined.</li>
-
-<li>
-<tt><a href="ficl.html#qfetch">q@</a></tt> and <tt><a href="ficl.html#qbang">q!</a></tt>
-operate on quadbyte quantities for 64 bit friendliness</li>
-</ul>
-
-<h3>
-New OO stuff</h3>
-
-<ul>
-<li>
-<tt>ALLOT (class method)</tt></li>
-
-<li>
-<tt>ALLOT-ARRAY (class method)</tt></li>
-
-<li>
-<tt>METHOD</tt> define method names globally</li>
-
-<li>
-<tt>MY=></tt> early bind a method call to "this" class</li>
-
-<li>
-<tt>MY=[ ]</tt> early bind a string of method calls to "this" class and
-obj members</li>
-
-<li>
-<tt>C-></tt> late bind method invocation with CATCH</li>
-
-<li>
-Metaclass method <tt>resume-class</tt> and instance word <tt>suspend-class</tt>
-create mutually referring classes. Example in string.fr</li>
-
-<li>
-Early binding words are now in the instance-vars wordlist, not visible
-unless defining a class.</li>
-
-<li>Support for refs to classes with VTABLE methods (contributed by Guy Carver). Guy writes:
-<p>
-My next favorite change is a set of VCALL words that allow me
-to call C++ class virtual methods from my forth classes. This
-is accomplished by interfacing with the VTABLE of the class. The
-class instance currently must be created on the C++ side.
-C++ places methods in the VTABLE in order of declaration in the
-header file. To use this in FICL one only needs to ensure
-that the VCALL: declerations occur in the same order. I use this
-quite a bit to interface with the C++ classes. When I need access
-to a method I make sure it is virtual (Even if it ultimately will
-not be). I use Visual C++ 6.0 and have not tested this under
-any other compiler but I believe VTABLE implementation is standard.
-</p><p>
-Here is an example of how to use VCALL:
-</p>
-<b>C++ class declaration</b>
-<pre>
-class myclass
-{
-public:
- myclass();
- virtual ~myclass();
- virtual void Test( int iParam1 );
- virtual int Test( int iParam1, char cParam2 );
- virtual float Test();
-};
-</pre>
-<b>ficl class declaration</b>
-<pre>
-object subclass myfclass hasvtable \ hasvtable adds 4 to the offset to
- \ accommodate for the VTABLE pointer.
-0 VCALL: Destructor() \ VCALL: ( ParamCount -<MethodName>- )
-1 VCALL: Test(int) \ Test takes 1 int parameter.
-2 VCALLR: iTest(int,char) \ iTest takes 2 parameters and returns an int.
-0 VCALLF: fTest() \ fTest takes no parameters and returns a float.
-end-class
-
-MyCAddress \ Primitive to return a pointer to a "myclass" instance.
-myfclass -> ref dude \ This makes the MyCAddress pointer a myfclass
- \ instance with the name "dude".
-1234 dude -> Test(int) \ Calls the virtual method Test.
-1234 1 dude -> iTest(int,char) . \ Calls iTest and emits the returned int.
-dude -> fTest() f. \ Calls fTest and emits the returned float.
-</pre>
-</li>
-</ul>
-
-<h2>
-Version 2.04</h2>
-
-<h3>
-ficlwin</h3>
-
-<ul>
-<li>
-Catches exceptions thrown by VM in ficlThread (0 @ for example) rather
-than passing them off to the OS. </li>
-</ul>
-
-<h3>
-ficl bugs vanquished</h3>
-
-<ul>
-<li>
-Fixed leading delimiter bugs in s" ." .( and ( (reported by Reuben Thomas)</li>
-
-<li>
-Makefile tabs restored (thanks to Michael Somos)</li>
-
-<li>
-ABORT" now throws -2 per the DPANS (thanks to Daniel Sobral for sharp eyes
-again) </li>
-
-<li>
-ficlExec does not print the prompt string unless (source-id == 0)</li>
-
-<li>
-Various fixes contributed by the FreeBSD team.</li>
-</ul>
-
-<h3>
-ficl enhancements</h3>
-
-<ul>
-<li>
-Words.c: modified ficlCatch to use vmExecute and vmInnerLoop (request of
-Daniel Sobral) Added vmPop and vmPush functions (by request of Lars Krueger
-) in vm.c These are shortcuts to the param stack. (Use LVALUEtoCELL to
-get things into CELL form) </li>
-
-<li>
-Added function vmGetStringEx with a flag to specify whether or not to skip
-lead delimiters</li>
-
-<li>
-Added non-std word: number?</li>
-
-<li>
-Added CORE EXT word AGAIN (by request of Reuben Thomas) </li>
-
-<li>
-Added double cell local (2local) support</li>
-
-<li>
-Augmented Johns Hopkins local syntax so that locals whose names begin with
-char 2 are treated as 2locals (OK - it's goofy, but handy for OOP)</li>
-
-<li>
-C-string class revised and enhanced - now dynamically sized</li>
-
-<li>
-C-hashstring class derived from c-string computes hashcode too.</li>
-</ul>
-</td>
-</tr>
-
-<tr>
-<td>
-<h2>
-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 <i>ficlWin only</i>)</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>
-
-<tr>
-<td>
-<h2>
-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>
-
-<li>
-<tt><a href="http://www.taygeta.com/forth/dpans15.htm#15.6.2.1580">forget</a>
-(TOOLS EXT)</tt></li>
-
-<li>
-<tt><a href="#ficlforgetwid">forget-wid</a>
-(FICL)</tt></li>
-
-<li>
-<tt><a href="#ficlwordlist">ficl-wordlist</a> (FICL)</tt></li>
-
-<li>
-<tt><a href="#ficlvocabulary">ficl-vocabulary</a> (FICL)</tt></li>
-
-<li>
-<tt><a href="#ficlhide">hide</a>
-(FICL)</tt></li>
-
-<li>
-<tt><a href="#ficlhidden">hidden</a>
-(FICL)</tt></li>
-
-<li>
-<a href="#jhlocal">Johns Hopkins local variable syntax</a> (as best I can
-determine)</li>
-</ul>
-Bugs Fixed
-<ul>
-<li>
-<tt>forget</tt> now adjusts the dictionary pointer to remove the name of
-the word being forgotten (name chars come before the word header in ficl's
-dictionary)</li>
-
-<li>
-<tt>:noname</tt> used to push the colon control marker and its execution
-token in the wrong order</li>
-
-<li>
-<tt>source-id</tt> now behaves correctly when loading a file.</li>
-
-<li>
-<tt>refill</tt> returns zero at EOF (Win32 load). Win32 <tt><a href="#ficlload">load</a></tt>
-command continues to be misnamed. Really ought to be called <tt>included</tt>,
-but does not exactly conform to that spec either (because <tt>included</tt>
-expects a string signature on the stack, while Ficl's <tt><a href="#ficlload">load</a></tt>
-expects a filename upon invocation). The "real" <tt>LOAD</tt> is a <tt>BLOCK</tt>
-word.</li>
-</ul>
-Enhancements (IMHO)
-<ul>
-<li>
-dictUnsmudge no longer links anonymous definitions into the dictionary</li>
-
-<li>
-<tt>oop</tt> is no longer the default compile wordlist at startup, nor
-is it in the search order. Execute <b><tt>also oop definitions</tt></b>
-to use Ficl OOP.</li>
-
-<li>
-Revised oo.fr extensively to make more use of early binding</li>
-
-<li>
-Added <tt>meta</tt> - a constant that pushes the address of metaclass.
-See oo.fr for examples of use.</li>
-
-<li>
-Added classes: <tt>c-ptr c-bytePtr c-2bytePtr c-cellPtr
-</tt>These
-classes model pointers to non-object data, but each knows the size of its
-referent.</li>
-</ul>
-</td>
-</tr>
-
-<tr>
-<td>
-<h2>
-Version 2.01</h2>
-
-<ul>
-<li>
-Bug fix: <tt>(local)</tt> used to leave a value on the stack between the
-first and last locals declared. This value is now stored in a static.</li>
-
-<li>
-Added new local syntax with parameter re-ordering. <a href="#newlocal">See
-description below</a>. (No longer compiled in version 2.02, in favor of
-the Johns Hopkins syntax)</li>
-</ul>
-</td>
-</tr>
-
-<tr>
-<td>
-<h2>
-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>
-
-<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>
-Optional stack underflow and overflow checking in many CORE words (enabled
-when FICL_ROBUST >= 2)</li>
-
-<li>
-Various bug fixes</li>
-</ul>
-</td>
-</tr>
-</table>
-
-</body>
-</html>
binary files a/doc/ficl_top.jpg /dev/null differ
binary files a/doc/ficlddj.PDF /dev/null differ
--- a/doc/ficlheader.js
+++ /dev/null
@@ -1,19 +1,0 @@
-function ficlHeader()
-{
- document.write("<table BORDER=0 CELLSPACING=3 WIDTH='640' %>");
- document.write("<tr %>");
- document.write("<td %> <b %>Forth Inspired Command Language</b %></td %>");
- document.write("<td ROWSPAN='4' %><a href='http://ficl.sourceforge.net' %><img SRC='ficl_logo.jpg' border='0' alt='The ficl home page' border=0 height=64 width=64 %></a %></td %>");
- document.write("<td ROWSPAN='4' %><A href='http://sourceforge.net' %><IMG src='http://sourceforge.net/sflogo.php?group_id=24441' width='88' border=0 height='31' border='0' alt='Sourceforge Logo' %></A %></td %>");
- document.write("<td ROWSPAN='4' %><a href='http://www.links2go.net/topic/Forth' %><img SRC='skey.gif' ALT='Key Resources -- Forth' BORDER=0 height=81 width=81 %></a %></td %>");
- document.write("</tr %>");
- document.write("<tr %><td %><b %>Author: <a href='mailto:john_sadler@alum.mit.edu' %> John Sadler</a %></b %></td %></tr %>");
- document.write("<tr %><td %><b %>Created: 19 July 1997</b %></td %></tr %>");
- document.write("<tr %><td %><b %>Current Revision: 3.01 -- October 2001</b %></td %></tr %>");
- document.write("<tr %><td %><b %>Last Modified " + document.lastModified + "</b %></td %></tr %>");
- document.write("<tr %><td COLSPAN=4 %><b %><a href='index.html' %>Home</a %> | <a href='http://sourceforge.net/mail/?group_id=24441' %>Join Mailing Lists</a %> | <a href='http://sourceforge.net/projects/ficl' %>Project Page</a %> | <a href='http://sourceforge.net/project/showfiles.php?group_id=24441' %>Download</a %></b %></td %></tr %>");
- document.write("</table %>");
-}
-
-ficlHeader();
-
--- a/doc/index.html
+++ b/doc/index.html
@@ -1,122 +1,382 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<HTML>
- <HEAD>
- <META name="Author" content="john sadler">
- <META name="Description" content="Ficl - embedded scripting with object oriented programming">
- <META name="Keywords" content="scripting prototyping tcl OOP Forth interpreter C">
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
- <LINK rel="SHORTCUT ICON" href="ficl.ico">
- <TITLE>
- Ficl - Embedded Scripting - Index
- </TITLE>
- </HEAD>
- <BODY>
- <H1>
- <B>Ficl Documentation</B>
- </H1>
-<SCRIPT language="javascript" src="ficlheader.js" type="text/javascript">
-</SCRIPT>
- <TABLE summary="table of contents" border="0" cellspacing="3" cols="2" width="675">
- <TR>
- <TD width="500">
- <H2>
- Contents
- </H2>
- <UL>
- <LI>
- <A href="ficl_rel.html">Release notes</A>
- </LI>
- <LI>
- <A href="ficl.html#whatis">What is ficl?</A>
- </LI>
- <LI>
- <A href="ficl.html#links"><B>Getting Started</B> - Tutorials and References</A>
- </LI>
- <LI>
- <A href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download</A>
- </LI>
- <LI>
- <A href="http://sourceforge.net/projects/ficl">Ficl project page on Sourceforge</A>
- </LI>
- <LI>
- <A href="ficl.html#includesficl">Ficl Inside!</A>
- </LI>
- <LI>
- <A href="ficl.html#lawyerbait">Disclaimer and License</A>
- </LI>
- <LI>
- <A href="ficl.html#features">Ficl features</A>
- </LI>
- <LI>
- <A href="ficl.html#porting">Porting</A>
- </LI>
- <LI>
- <A href="ficl.html#api">Application Programming Interface</A>
- </LI>
- <LI>
- <A href="ficl.html#manifest">Distribution source files</A>
- </LI>
- <LI>
- <A href="ficl_guts.html">Internal Structures</A>
- </LI>
- <LI>
- <A href="ficl_gloss.html">Glossary</A>
- </LI>
- <LI>
- <A href="ficl_loc.html">Local variables</A>
- </LI>
- <LI>
- <A href="ficl_oop.html">Object Oriented Programming in ficl</A>
- </LI>
- <LI>
- <A href="ficl_debug.html">Debugger</A>
- </LI>
- <LI>
- <A href="ficl_gloss.html#exnumber">Number syntax</A>
- </LI>
- <LI>
- <A href="ficl_parse.html">Parser extensions and prefix support</A>
- </LI>
- <LI>
- <A href="ficl_gloss.html#exsearch">Search order words</A>
- </LI>
- <LI>
- <A href="ficl_gloss.html#exuser">User variables</A>
- </LI>
- <LI>
- <A href="ficl_gloss.html#exmisc">Miscellaneous useful words</A>
- </LI>
- <LI>
- <A href="ficl_gloss.html#exficlwin">FiclWin words</A>
- </LI>
- <LI>
- <A href="ficl_ans.html#ansinfo">ANS required information</A>
- </LI>
- <LI>
- <A href="http://ficl.sourceforge.net/dpans/dpans.htm">American National Standard Forth</A>
- </LI>
- <LI>
- <A href="http://ficl.sourceforge.net/dpans/dpansf.htm">Standard Forth Glossary</A>
- </LI>
- </UL>
- </TD>
- <TD width="175">
- <A href="http://nav.webring.yahoo.com/hub?ring=forth&list"><IMG src="http://www.iidbs.com/images/4ring.gif" width="155" height="140" border="0" alt="Forth Webring Logo"></A>
- <CENTER>
- <FONT size="3"><BR>
- <A href="http://www.webring.org/cgi-bin/webring?ring=forth;id=47;prev5">Previous 5 Sites</A><BR>
- <A href="http://www.webring.org/cgi-bin/webring?ring=forth;id=47;prev">Previous</A><BR>
- <A href="http://www.webring.org/cgi-bin/webring?ring=forth;id=47;next">Next</A><BR>
- <A href="http://www.webring.org/cgi-bin/webring?ring=forth;id=47;next5">Next 5 Sites</A><BR>
- <A href="http://www.webring.org/cgi-bin/webring?ring=forth;random">Random Site</A><BR>
- <A href="http://www.webring.org/cgi-bin/webring?ring=forth;list">List Sites</A></FONT>
- </CENTER>
- </TD>
- </TR>
- </TABLE>
- </BODY>
-</HTML>
-
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+<META name='Description' content='Ficl - embedded scripting with object oriented programming'>
+<META name='Keywords' content='scripting prototyping tcl OOP Forth interpreter C'>
+<LINK rel='SHORTCUT ICON' href='ficl.ico'>
+<TITLE>ficl</TITLE>
+<style>
+
+blockquote { margin-left: 1em }+
+</style>
+
+</HEAD>
+<BODY>
+
+<table border=0 cellspacing=0 width=100%%><tr>
+
+
+<td width=112 bgcolor=#004968 colspan=3>
+<img src=graphics/ficl.4.96.jpg height=96 width=96>
+</td>
+
+<td bgcolor=#004968>
+<font face=arial,helvetica color=white size=7><b><i>
+ficl
+</i></b></font>
+</td></tr>
+
+
+<tr>
+<td bgcolor=#004968 width=10></td>
+<td bgcolor=#004968 valign=top>
+<br><p>
+<a href=index.html><font face=arial,helvetica color=white><b>Index</b></font></a><p>
+<p><br>
+<a href=dpans.html><font face=arial,helvetica color=white><b>ANS</b></font></a><br>
+<a href=api.html><font face=arial,helvetica color=white><b>API</b></font></a><br>
+<a href=debugger.html><font face=arial,helvetica color=white><b>Debugger</b></font></a><br>
+<a href=http://sourceforge.net/project/showfiles.php?group_id=24441><font face=arial,helvetica color=white><b>Download</b></font></a><br>
+<a href=license.html><font face=arial,helvetica color=white><b>Licensing</b></font></a><br>
+<a href=links.html><font face=arial,helvetica color=white><b>Links</b></font></a><br>
+<a href=locals.html><font face=arial,helvetica color=white><b>Locals</b></font></a><br>
+<a href=oop.html><font face=arial,helvetica color=white><b>OOP In Ficl</b></font></a><br>
+<a href=parsesteps.html><font face=arial,helvetica color=white><b>Parse Steps</b></font></a><br>
+<a href=releases.html><font face=arial,helvetica color=white><b>Release History</b></font></a><br>
+<a href=upgrading.html><font face=arial,helvetica color=white><b>Upgrading To 4.0</b></font></a><br>
+</td><td bgcolor=#004968 width=5></td><td valign=top><blockquote><p>
+
+
+
+
+
+<p>
+</blockquote><table border=0 bgcolor=#a0a0a0 width=100%><tr>
+
+<td width=1em></td>
+<td>
+<font face=arial,helvetica color=#004968 size=5><b><i>
+<a name='WhatisFicl'>
+What is Ficl?
+</a></i></b></font></td></tr></table><p><blockquote>
+
+
+
+
+Ficl is a programming language interpreter designed to be embedded
+into other systems as a command, macro, and development prototyping
+language.
+<p>
+
+Ficl is an acronym for "Forth Inspired Command Language".
+
+
+
+<p>
+</blockquote><table border=0 bgcolor=#a0a0a0 width=100%><tr>
+
+<td width=1em></td>
+<td>
+<font face=arial,helvetica color=#004968 size=5><b><i>
+<a name='FiclFeatures'>
+Ficl Features
+</a></i></b></font></td></tr></table><p><blockquote>
+
+
+
+<dl>
+
+
+<p><dt>
+Ficl is <b><i>easy to port.</i></b>
+<dd>
+
+
+
+<ul>
+
+<li>
+It typically takes under 2 hours to port to a new platform.
+
+<li>
+Ficl is written in strict ANSI C.
+
+<li>
+Ficl can run natively on 32- and 64-bit processors.
+
+</ul>
+
+
+
+<p><dt>
+Ficl has a <b><i>small memory footprint.</i></b>
+<dd>
+
+
+
+A fully featured Win32 console version takes less than 100K
+of memory, and a minimal version is less
+than half that.
+
+
+
+<p><dt>
+Ficl is <b><i>easy to integrate</i></b> into your program.
+<dd>
+
+
+
+Where most Forths 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 your program. 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.
+
+
+
+<p><dt>
+Ficl is <b><i>fast.</i></b>
+<dd>
+
+
+
+Thanks to its
+<a href=http://www.complang.tuwien.ac.at/forth/threaded-code.html#switch-threading>"switch-threaded"</a>
+virtual machine design, Ficl 4 is faster than ever—about 3x the speed of Ficl 3.
+Ficl also features blindingly fast "just in time" compiling, removing the "compile" step from
+the usual compile-debug-edit iterative debugging cycle.
+
+
+
+<p><dt>
+Ficl is a <b><i>complete and powerful programming language.</i></b>
+<dd>
+
+
+
+Ficl is an implementation of the FORTH language, a language providing
+a wide range of standard programming language features:
+<ul>
+
+<li>
+Integer and floating-point numbers, with a rich set of operators.
+
+<li>
+Arrays.
+
+<li>
+File I/O.
+
+<li>
+Flow control (<code>if/then/else</code> and many looping structures).
+
+<li>
+Subroutines with named arguments.
+
+<li>
+Language extensibility.
+
+<li>
+Powerful code pre-processing features.
+
+</ul>
+
+
+
+<p><dt>
+Ficl is <b><i>standards-compliant.</i></b>
+<dd>
+
+
+
+Ficl conforms to the 1994 ANSI Standard for FORTH (DPANS94).
+See <a href=dpans.html>ANS Required Information</a> for
+more detail.
+
+
+<p><dt>
+Ficl is <b><i>extensible.</i></b>
+<dd>
+
+
+
+Ficl is extensible both at compile-time and at run-time.
+You can add new script functions, new native functions,
+even new control structures.
+
+
+
+
+<p><dt>
+Ficl adds <b><i>object oriented programming features.</i></b>
+<dd>
+
+
+
+Ficl's flexible OOP library can be used to wrap
+data structures or classes of the host system without altering them.
+(And remember how we said Ficl was extensible? Ficl's object-oriented
+programming extensions are written in Ficl.)
+
+
+
+<p><dt>
+Ficl is <b><i>interactive.</i></b>
+<dd>
+
+
+
+Ficl can be used interactively, like most other FORTHs, Python,
+and Smalltalk. You can inspect data, run commands, or even
+define new commands, all on a running Ficl VM.
+Ficl also has a built-in script debugger that allows you to
+step through Ficl code as it is executed.
+
+
+<p><dt>
+Ficl is <b><i>ROMable.</i></b>
+<dd>
+
+
+
+Ficl is designed to work in RAM based and ROM code / RAM
+data environments.
+
+
+
+<p><dt>
+Ficl is <b><i>safe for multithreaded programs.</i></b>
+<dd>
+
+
+
+Ficl is reentrant and thread-safe. After initialization,
+it does not write to any global data.
+
+
+<p><dt>
+Ficl is <b><i>open-source and free.</i></b>
+<dd>
+
+
+
+The <a href=license.html>Ficl licence</a> is a BSD-style
+license, requiring only that you document that you are
+using Ficl. There are no licensing costs for using Ficl.
+
+
+</dl>
+
+
+<a name=whatsnew>
+
+<p>
+</blockquote><table border=0 bgcolor=#a0a0a0 width=100%><tr>
+
+<td width=1em></td>
+<td>
+<font face=arial,helvetica color=#004968 size=5><b><i>
+<a name='WhatsNewInFicl40'>
+What's New In Ficl 4.0?
+</a></i></b></font></td></tr></table><p><blockquote>
+
+
+</a>
+
+Ficl 4.0 is a major change for Ficl. Ficl 4.0 is <i>smaller</i>,
+<i>faster</i>, <i>more powerful</i>, and <i>easier to use</i>
+than ever before. (Or your money back!)
+<p>
+
+Ficl 4.0 features a major engine rewrite. Previous versions
+of Ficl stored compiled words as an array of pointers to data
+structure; Ficl 4.0 adds "instructions", and changes over to
+mostly using a "switch-threaded" model. The result? Ficl 4.0
+is approximately <i>three times</i> as fast as Ficl 3.03.
+<p>
+
+Ficl 4.0 also adds the ability to store the "softcore" words
+as LZ77 compressed text. Decompression is so quick as to be
+nearly unmeasurable (0.00384 seconds on a 750MHz AMD Duron-based
+machine). And even with the runtime decompressor, the resulting
+Ficl executable is over 13k smaller!
+<p>
+
+Another new feature: Ficl 4.0 can take advantage of native
+support for double-word math. If your platform supports it,
+set the preprocessor symbol <code>FICL_HAVE_NATIVE_2INTEGER</code>
+to 1, and create <code>typedefs</code> for <code>ficl2Integer</code>
+and <code>ficl2Unsigned</code>.
+<p>
+
+Ficl 4.0 also features a retooled API, and a redesigned directory
+tree. The API is now far more consistent. But for those of you
+who are upgrading from Ficl 3.03 or before, you can enable API
+backwards compatibility by turning on the compile-time flag
+<code>FICL_WANT_COMPATIBILITY</code>.
+<p>
+
+Ficl 4.0 also extends support every kind of local and
+global value imaginable. Every values can individually
+be local or global, single-cell or double-cell, and
+integer or floating-point.
+And <code>TO</code> <i>always</i> does the right thing.
+<p>
+
+If you're using Ficl under Windows, you'll be happy
+to know that there's a brand-new build process.
+The Ficl build process now builds Ficl as
+<ul>
+
+<li>
+a static library (.LIB),
+
+<li>
+a dynamic library (.DLL, with a .LIB import library), and
+
+<li>
+a standalone executable (.EXE).
+
+</ul>
+
+Furthermore, each of these targets can be built in
+Debug or Release, Singlethreaded or Multithreaded,
+and optionally using the DLL version of the C runtime
+library for Multithreaded builds. (And, plus, the
+<code>/objects/common</code> nonsense is gone!)
+<p>
+
+
+Finally, Ficl 4.0 adds a <code>contrib</code>
+directory, a repository for user-contributed code that isn't
+part of the standard Ficl release. The only package there
+right now is <b>XClasses</b>, a Python-based IDL that generates
+the definition files for C++-based classes, the equivalent Ficl
+classes, and code to allow the Ficl classes to call the C++ methods.
+Using <b>XClasses</b> you can write your class once, and use it
+immediately from both C++ and Ficl.
+
+
+
+<p>
+</blockquote><table border=0 bgcolor=#a0a0a0 width=100%><tr>
+
+<td width=1em></td>
+<td>
+<font face=arial,helvetica color=#004968 size=5><b><i>
+<a name='GettingFicl'>
+Getting Ficl
+</a></i></b></font></td></tr></table><p><blockquote>
+
+
+
+You can download Ficl from the
+<a href=http://sourceforge.net/project/showfiles.php?group_id=24441>
+Ficl download page at Sourceforge</a>.
+
+
+
+</blockquote><p></td></tr></table></body></html>
+
+
binary files a/doc/jwsforml.PDF /dev/null differ
--- a/doc/oo_in_c.html
+++ /dev/null
@@ -1,228 +1,0 @@
-<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
-<html>
-<head>
- <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
- <title>Object Oriented Idioms in C</title>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
-
-</head>
-<body>
-
-<h1>
-<b><font face="Arial"><font size=+1>Object Oriented Idioms in C</font></font></b></h1>
-<font face="Arial"><font size=-1>John Sadler</font></font>
-<br><font face="Arial"><font size=-1>10 Aug 98</font></font>
-<br>
-<br>
-<table COLS=1 WIDTH="675" >
-<tr>
-<td><a NAME="review"></a><b><font face="Arial"><font size=+1>Review of
-Key OO Characteristics</font></font></b>
-<h3>
-<b><i><font face="Arial">Object</font></i></b></h3>
-<a NAME="object-def"></a><font face="Times New Roman,Times"><b>"A package
-of information and descriptions of its manipulation"</b> [<a href="#robson">Robson</a>]</font>
-<p><font face="Times New Roman,Times">Objects separate interface from implementation,
-"what" is wanted (on the outside) from "how" it is accomplished (on the
-inside). This idea of hiding the data inside a package with a fixed set
-of allowed manipulations is called encapsulation. Why? If the object always
-selects how to perform a requested manipulation, you guarantee that the
-procedure and the data it operates on always match.</font>
-<p><font face="Times New Roman,Times">A <b>message</b> denotes an operation
-that can be performed on an <b>object</b>. The code that describes how
-to perform an operation on a specific object type is called a <b>method</b>.
-From the outside, objects receive messages. On the inside, these messages
-are mapped to methods that perform appropriate actions for the specific
-kind of object. An object�s <b>interface</b> is the set of messages to
-which it can respond. For example, several object types may have a "dump"
-method to cause the object to display its state. Each kind of object will
-need a unique method to accomplish this. So the message-method idea separates
-the interface from the implementation. The idea that different kinds of
-objects might invoke different methods to respond to the same message is
-called <b>polymorphism</b>. Methods can be bound to messages as soon as
-the type of the object receiving the message is known (called <b>early
-binding</b>), or this mapping can wait until run-time (<b>late binding</b>).</font>
-<p><font face="Times New Roman,Times">Some languages (notably C++) make
-a syntactic distinction between early and late binding of methods to messages
-(virtual functions are bound late, while all others are bound early � at
-link time). Smalltalk makes no such distinction. The C++ approach has potentially
-dangerous consequences when you manipulate an object through a pointer
-to its parent class. If a method of the superclass is virtual, you get
-late binding to the appropriate function for the object�s class. On the
-other hand, if that method is not virtual, you get early binding to the
-parent class�s definition even if the child class has overridden it. Smalltalk
-adheres rigorously to the idea that the object itself has sole ownership
-of the mapping from methods to messages.</font>
-<br> </td>
-</tr>
-
-<tr>
-<td>
-<h3>
-<b><i><font face="Arial">Class</font></i></b></h3>
-<a NAME="class-def"></a><b><font face="Times New Roman,Times">"A description
-of one or more similar objects"</font></b> [<a href="#robson">Robson</a>]
-<p><a NAME="instance-def"></a>A specific object described by a particular
-class is called an <b>instance</b> of the class.
-<br>(Example: Dog is a class; Poodle is a subclass of Dog; FiFi is an object,
-an instance of Poodle).
-<br>A class is a kind of object that describes the behaviors (methods)
-of its instances, and whose methods provide for creation, initialization,
-and destruction of an instance. All instances of a particular class use
-the same method to respond to a given message. Classes may define other
-members that are shared by all instances of the class. These are called
-class variables. (In C++, these would be static members.)
-<br> </td>
-</tr>
-
-<tr>
-<td>
-<h3>
-<b><i><font face="Arial">Inheritance</font></i></b></h3>
-<font face="Times New Roman,Times">A means for creating a new object or
-class using an existing one as a starting place and defining only what
-changes. C++ only supports class-based inheritance, but some systems also
-allow objects to inherit directly from other objects. At minimum, inheritance
-requires that the child class override its parent�s name. In addition,
-a child class can:</font>
-<ul>
-<li>
-<font face="Times New Roman,Times">add instance variables</font></li>
-
-<li>
-<font face="Times New Roman,Times">add class variables</font></li>
-
-<li>
-<font face="Times New Roman,Times">define methods for new messages</font></li>
-
-<li>
-<font face="Times New Roman,Times">provide methods for (<b>override</b>)
-messages already handled by the parent class</font></li>
-</ul>
-</td>
-</tr>
-
-<tr>
-<td>
-<h3>
-<b><font face="Arial"><font size=+1>What C++ Does for you�</font></font></b></h3>
-<b><i><font face="Arial">Name mangling � separation of name spaces</font></i></b>
-<p><font face="Times New Roman,Times">This mechanism � decorating symbol
-names with extra characters that uniquely identify their class and prototype
-� is the traditional C++ method for operator overloading, method overloading,
-and namespace separation. C provides a much smaller set of namespaces than
-C++ requires, so this strategy allowed C++ to be implemented as a preprocessor
-for C compilers originally.</font>
-<p><b><i><font face="Arial">Rigorous type checking</font></i></b>
-<p>Because of the function prototype requirement and name mangling, a C++
-compiler can provide strict type checking for method invocations.
-<p><b><i><font face="Arial">Automatic lifetime control</font></i></b>
-<p>Guarantees constructor call upon creation and destructor call upon deletion
-<p><b><i><font face="Arial">Multiple Storage classes (same as C)</font></i></b>
-<p>Automatic, static, dynamically allocated
-<p><b><i><font face="Arial">Typed dynamic memory management</font></i></b>
-<p><b><i><font face="Arial">Default constructor, destructor, copy constructor,
-and assignment operator</font></i></b>
-<p><b><i><font face="Arial">Explicit early and late binding support</font></i></b>
-<p><b><i><font face="Arial">And more�</font></i></b>
-<br> </td>
-</tr>
-
-<tr>
-<td>
-<h3>
-<b><font face="Arial"><font size=+1>What other OO languages do (or don�t
-do)</font></font></b></h3>
-Just to make sure we don�t get caught in a C++ centered view of the world,
-here are some ways other OO systems differ.
-<p><b><i><font face="Arial">Run-time type identification</font></i></b>
-<p>This is a Big Deal in C++, but it�s relatively trivial in an interpreted
-language to know the type of a reference at run-time.
-<p><b><i><font face="Arial">Metaclasses</font></i></b>
-<p>Classes are objects, too (Smalltalk, Java?)
-<p><b><i><font face="Arial">Garbage collection</font></i></b>
-<p>Java and smalltalk both manage memory for you, freeing objects when
-they go out of scope or are no longer referenced anywhere.
-<p><b><i><font face="Arial">Single Inheritance only</font></i></b>
-<p>Java, Smalltalk 80
-<p><b><i><font face="Arial">Everything is an object</font></i></b>
-<p>Smalltalk
-<p><b><i><font face="Arial">Operator overloading</font></i></b>
-<p>Smalltalk makes no distinction between operators and other kinds of
-messages. The message syntax is flexible enough that you can define operators
-in the same way as any other kind of message.
-<p><b><i><font face="Arial">Visibility control</font></i></b>
-<p>Smalltalk 80 does not appear to provide options for visibility control
-(based on my quick survey). Instance variables are always private, methods
-are always public as far as I can tell.
-<p><b><i><font face="Arial">Pointers</font></i></b>
-<p>Not in Smalltalk, Java: Both languages deal with objects through implicit
-references. It is still possible to create data structures, but the language
-hides much of the memory management work.
-<p><b><i><font face="Arial">No Casting</font></i></b>
-<p>As far as I can tell, smalltalk has no equivalent of a C/C++ cast.
-<p><b><i><font face="Arial">Late binding</font></i></b>
-<p>Smalltalk makes no syntactic distinction between late and early bound
-methods (unlike C++ "virtual" methods)
-<br> </td>
-</tr>
-
-<tr>
-<td>
-<h3>
-<b><font face="Arial"><font size=+1>OO-C framework options</font></font></b></h3>
-<font face="Times New Roman,Times">Covered: objects (encapsulation, explicit
-construct and destruct), classes, inheritance, polymorphism</font>
-<br><font face="Times New Roman,Times">Not covered: multiple inheritance,
-automatic initialization / destruction,</font>
-<h3>
-<b><font face="Arial"><font size=+1>Strategy 1: message maps and aggregation</font></font></b></h3>
-<font face="Times New Roman,Times">Class: a struct with a pointer to a
-method table (message map). Contructor and destuctor are really initializer
-and destructor, and are invoked manually at beginning and end of lifetime.</font>
-<p><font face="Times New Roman,Times">Messages and methods: mapping table
-(first cut: use macros like MFC to create a mapping between messages and
-methods). Alternative: message map can be built at run-time (hash, tree,
-linked list) � method resolution may be slower.</font>
-<p><font face="Times New Roman,Times">Inheritance: aggregate the parent
-struct (recursively) at the beginning of the derived one, link the child
-method table to the parent and search recursively to resolve messages to
-methods</font>
-<p><font face="Times New Roman,Times">Pros and cons:</font>
-<blockquote><font face="Times New Roman,Times">+ flexible and minimal manual
-steps required</font>
-<br><font face="Times New Roman,Times">+ relatively simple � no need to
-write a preprocessor!</font>
-<br><font face="Times New Roman,Times">- all methods are late bound, run-time
-penalty</font>
-<br><font face="Times New Roman,Times">­ defeats compile time type
-checking, may require a single prototype for all methods</font></blockquote>
-
-<p><br><b><font face="Arial"><font size=+1>Strategy 2: manual name mangling</font></font></b>
-<br><font face="Times New Roman,Times">This is how the <a href="#samek">Samek</a>
-article handles encapsulation</font>
-<p><b><font face="Arial"><font size=+1>Strategy 3: preprocessor</font></font></b>
-<br><font face="Times New Roman,Times">This is how C++ started out.</font>
-<br> </td>
-</tr>
-
-<tr>
-<td><b><font face="Arial"><font size=+1>References</font></font></b>
-<ul>
-<li>
-<a NAME="robson"></a><font size=-1>David Robson, <i>Object Oriented Software
-Systems</i>. Byte, August 1981</font></li>
-
-<li>
-<a NAME="samek"></a><font size=-1>Miro Samek, <i>Portable Inheritance and
-Polymorphism in C</i>. Embedded Systems Programming, December 1997</font></li>
-</ul>
-</td>
-</tr>
-</table>
-
-</body>
-</html>
--- a/doc/primer.html
+++ /dev/null
@@ -1,972 +1,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<HTML>
- <HEAD>
- <TITLE>
- A Beginner's Guide to Forth
- </TITLE>
- <LINK media="screen" href="ficlstyle.css" type="text/css" rel="stylesheet">
-<STYLE type="text/css">
-
-</STYLE>
- </HEAD>
- <BODY>
- <DIV style="width:675px">
- <CENTER>
- <H1>
- A Beginner's Guide to Forth
- </H1>
- by<BR>
- J.V. Noble<BR>
- <I>[Adapted for Ficl by John Sadler - Nov 2001]</I>
- </CENTER>
- <H1>
- Contents
- </H1>
- <UL>
- <LI>
- <A href="#introduction">Introduction</A>
- </LI>
- <LI>
- <A href="#gettingstarted">Getting started</A>
- </LI>
- <LI>
- <A href="#extending">Extending the dictionary</A>
- </LI>
- <LI>
- <A href="#stacks">Stacks and reverse Polish notation (RPN)</A>
- <UL>
- <LI>
- <A href="#pstack">Manipulating the parameter stack</A>
- </LI>
- <LI>
- <A href="#rstack">The return stack and its uses</A>
- </LI>
- </UL>
- </LI>
- <LI>
- <A href="#fetching">Fetching and storing</A>
- </LI>
- <LI>
- <A href="#comparing">Comparing and branching</A>
- </LI>
- <LI>
- <A href="#documenting">Documenting and commenting Forth code</A>
- </LI>
- <LI>
- <A href="#arithmetic">Arithmetic operations</A>
- </LI>
- <LI>
- <A href="#looping">Looping and structured programming</A>
- </LI>
- <LI>
- <A href="#create">CREATE ... DOES> (the pearl of Forth)</A>
- <UL>
- <LI>
- <A href="#defining">Defining "defining" words</A>
- </LI>
- <LI>
- <A href="#runtime">Run-time vs. compile-time actions</A>
- </LI>
- <LI>
- <A href="#dimensioned">Dimensioned data (intrinsic units)</A>
- </LI>
- <LI>
- <A href="#advanced">Advanced uses of the compiler</A>
- </LI>
- </UL>
- </LI>
- <LI>
- <A href="#floating">Floating point arithmetic</A>
- </LI>
- </UL>
- <H2>
- <A name="introduction">Introduction</A>
- </H2>
- <p>
-Forth is an unusual computer language that has probably been applied to more varied projects than any other. It is the obvious choice when the project is exceptionally demanding in terms of completion schedule, speed of execution, compactness of code, or any combination of the above.
-</p><p>
-It has also been called "...one of the best-kept secrets in the computing world." This is no exaggeration: large corporations have purchased professional Forth development systems from vendors such as Laboratory Microsystems, Inc., Forth, Inc. or MicroProcessor Engineering, Ltd. and sworn them to secrecy.
-</p><p>
-Some speculate (unkindly) that corporate giants prefer to hide their shame at using Forth; but I believe they are actually concealing a secret weapon from their rivals. Whenever Forth has competed directly with a more conventional language like C it has won hands down, producing smaller, faster, more reliable code in far less time. I have searched for examples with the opposite outcome, but have been unable to find a single instance.</p>
- <H2>
- <A name="gettingstarted">Getting started</A>
- </H2>
- <p>
-We will use Ficl for these illustrations.
-<A href="http://sourceforge.net/project/showfiles.php?group_id=24441">Download</A> the latest release and unzip it. The Win32 releases contain executable files ficl.exe and ficlwin.exe. I suggest you use ficlwin.exe because it supports copy and paste better, which will make it easier to enter the sample code.
-</p><p>
-Now start ficlwin.exe by double clicking the file icon in Windows Explorer It should respond by opening a window and writing something like:
-<PRE>
-ficl Version 3.01
-Oct 28 2001
-loading ficlwin.fr
-</PRE>
-Ficl and Ficlwin are case-insensitive. Now type
-<PRE>
-bye <cr>
-</PRE>
-The Ficl window immediately closes.</p>
-<p>
-What just happened? Forth is an interactive programming language consisting entirely of subroutines, called "words". A word is executed (interactively) by naming it. We have just seen this happen: <CODE>BYE</CODE> is a Forth subroutine meaning "exit to the operating system". So when we entered <CODE>BYE</CODE> it was executed, and the system returned control to Windows.
-</p>
-<P>
-Click on the Ficlwin icon again to re-start Forth. Now we will try something a little more complicated. Enter
-</p>
-<PRE>
-2 17 + . <cr>
-19 ok>
-</PRE>
-<P>
-What happened? Forth is interpretive. An <I>outer interpreter</I> continually loops, waiting for input from the keyboard or mass storage device. The input is a sequence of text strings separated from each other by blank spaces -- ASCII 32decimal = 20hex -- the standard Forth delimiter.
-</P>
-<P>
-When the outer interpreter encounters text it first looks for it in the <I>dictionary</I> (a linked list of previously defined subroutine names). If it finds the word, it executes the corresponding code.
- </P>
- <P>
-If no dictionary entry exists, the interpreter tries to read the input as a number.
- </P>
- <P>
-If the input text string satisfies the rules defining a number, it is converted to a number and stored in a special memory location called "the top of the stack" (TOS).
- </P>
- <P>
-In the above example, Forth interpreted 2 and 17 as numbers, and pushed them both onto the stack.
- </P>
- <p>
- <CODE>+</CODE> is a pre-defined word as is <CODE>.</CODE>, so they were looked up and executed.</p>
-<p>
-<CODE>+</CODE> added 2 to 17 and left 19 on the stack.
-</p>
-<p>
-The word <CODE>.</CODE> (called "emit") removed 19 from the stack and displayed it on the standard output device (in this case, CRT).
-</p>
-<p>
-We might also have said
-<PRE>
-HEX 0A 14 * . <cr>
-C8 ok>
-</PRE>
-(Do you understand this? Hint: <code>DECIMAL</code> means "switch to decimal arithmetic", whereas <code>HEX</code> stands for "switch to hexadecimal arithmetic".) If the incoming text can neither be located in the dictionary nor interpreted as a number, Forth issues an error message. Try it: say X and see:
-</p>
-<PRE>
-X
-X not found
-</PRE>
-Or say THING and see
-<PRE>
-THING
-THING not found
-</PRE>
- <H2>
- <A name="extending">Extending the dictionary</A>
- </H2>
- <p>
- The compiler is one of Forth's most endearing features. Unlike all other high-level languages, the Forth compiler is part of the language. (LISP and its dialects also make components of the compilation mechanism available to the programmer.) That is, its components are Forth words available to the programmer, that can be used to solve his problems.</p>
-<p>
- In this section we discuss how the compiler extends the dictionary.</p>
- <p>
- Forth uses special words to create new dictionary entries, i.e., new words. The most important are <code>:</code> ("start a new definition") and <code>;</code> ("terminate the definition").
-</p>
-<p>
- Let's try this out: enter (where <code><cr></code> means "press the Enter key")
-<PRE>
-: *+ * + ; <cr>
-ok>
-</PRE>
-</P>
-What happened? The word <code>:</code> was executed because it was already in the dictionary. The action of <code>:</code> is
- <UL>
- <LI>
- Create a new dictionary entry named <code>*+</code> and switch from interpret to compile mode.
- </LI>
- <LI>
- In compile mode, the interpreter looks up words and -- rather than executing them -- installs pointers to their code. (If the text is a number, rather than pushing it on the stack, Forth builds the number into the dictionary space allotted for the new word, following special code that puts it on the stack when the word is executed.)
- </LI>
- <LI>
- The action of <code>*+</code> will be to execute sequentially the previously-defined words <code>*</code> and <code>+</code>.
- </LI>
- <LI>
- The word <code>;</code> is special: when it was defined a bit was turned on in its dictionary entry to mark it as <code>IMMEDIATE</code>. Thus, rather than writing down its address, the compiler executes <code>;</code> immediately. The action of <code>;</code> is first, to install the code that returns control to the next outer level of the interpreter; and second, to switch back from compile mode to interpret mode.
- </LI>
- <LI>
- When Ficl successfully interprets a line, it prints <code>ok></code> to acknowledge that something happened.
- </LI>
- </UL>
-Now try out <code>*+</code> :
- <pre>
-DECIMAL 5 6 7 *+ . <cr>
-47 ok>
- </pre>
-<p>This example illustrated two principles of Forth: adding a new word to the dictionary, and trying it out as soon as it was defined.
-</p>
-
- <H2>
- <A name="stacks">Stacks and reverse Polish notation (RPN)</A>
- </H2>
-<p>
-We now discuss the stack and the "reverse Polish" or "postfix" arithmetic based on it. (Anyone who has used a Hewlett-Packard calculator should be familiar with the concept.)
-</p><p>
-Virtually all modern CPU's are designed around stacks. Forth efficiently uses its CPU by reflecting this underlying stack architecture in its syntax.</p>
-<p>
- But what is a stack? As the name implies, a stack is the machine anlog of a pile of cards with numbers written on them. Numbers are always added to the top of the pile, and removed from the top of the pile. The Forth input line
-<pre>
-2 5 73 -16 <cr>
-ok>
-</pre>
-leaves the stack in the state
-<pre>
-cell # contents
-0 -16 (TOS)
-1 73 (NOS)
-2 5
-3 2
-</pre>
-where TOS stands for "top-of-stack", NOS for "next-on-stack", etc.
-<BR>
-<i>Ficl Note: If you're using ficlwin here, you can see the state of the stack in the stack view window to the right of the frame. You can also use the standard helper word <code>.s</code> to display the stack contents in a non-destructive way.</i>
-</p>
-<p>
-We usually employ zero-based relative numbering in Forth data structures (such as stacks, arrays, tables, etc.) so TOS is given relative #0, NOS #1, etc.</p>
-<p>
-Suppose we followed the above input line with the line
-<pre>
-+ - * . <cr>
-xxx ok>
-</pre>
-what would <code>xxx</code> be? The operations would produce the successive stacks
-<pre>
-
-initial + - * .
--16 57 -52 -104 (empty
- 73 5 2 stack)
- 5 2
- 2
-
-</pre>
-The operation <code>.</code> (EMIT) displays -104 to the screen, leaving the stack empty. That is, xxx is -104.
-</p>
-
- <H3>
- <A name="pstack">Manipulating the parameter stack</A>
- </H3>
-<p>Forth systems incorporate (at least) two stacks: the parameter stack and the return stack.
-</p><p>
-A stack-based system must provide ways to put numbers on the stack, to remove them, and to rearrange their order. Forth includes standard words for this purpose.
-</p><p>
-Putting numbers on the stack is easy: simply type the number (or incorporate it in the definition of a Forth word).
-</p>
-<p>
-The word <code>DROP</code> removes the number from TOS and moves up all the other numbers. (Since the stack usually grows downward in memory, <code>DROP</code> merely increments the pointer to TOS by 1 cell.)
- <BR>
-<code>SWAP</code> exchanges the top 2 numbers.
- <BR>
-<code>DUP</code> duplicates the TOS into NOS.
- <BR>
-<code>ROT</code> rotates the top 3 numbers.
-</p>
-These actions are shown below (we show what each word does to the initial stack)
-<PRE>
-cell | initial | DROP SWAP ROT DUP
-
- 0 | -16 | 73 73 5 -16
- 1 | 73 | 5 -16 -16 -16
- 2 | 5 | 2 5 73 73
- 3 | 2 | 2 2 5
- 4 | | 2
-</PRE>
-<p>
-Forth includes the words OVER, TUCK, PICK and ROLL that act as shown below (note <code>PICK</code> and <code>ROLL</code> must be preceded by an integer that says where on the stack an element gets PICK'ed or ROLL'ed):
-<PRE>
-cell | initial | OVER TUCK 4 PICK 4 ROLL
-
- 0 | -16 | 73 -16 2 2
- 1 | 73 | -16 73 -16 -16
- 2 | 5 | 73 -16 73 73
- 3 | 2 | 5 5 5 5
- 4 | | 2 2 2
-</PRE>
-Clearly, <code>1 PICK</code> is the same as <code>DUP</code>, <code>2 PICK</code> is a synonym for <code>OVER</code>, and <code>2 ROLL</code> means <code>SWAP</code>.
-</p>
- <H3>
- <A name="rstack">The return stack and its uses</A>
- </H3>
-<p>
- We have remarked above that compilation establishes links from the calling word to the previously-defined word being invoked. The linkage mechanism --during execution-- uses the return stack (rstack): the address of the next word to be invoked is placed on the rstack, so that when the current word is done executing, the system knows to jump to the next word. (This is so in most, but not all Forth implementations. But all have a return stack, whether or not they use them for linking subroutines.)
-</p><p>
-In addition to serving as a reservoir of return addresses (since words can be nested, the return addresses need a stack to be put on) the rstack is where the limits of a DO...LOOP construct are placed.
-</p>
-<p>
-The user can also store/retrieve to/from the rstack. This is an example of using a component for a purpose other than the one it was designed for. Such use is discouraged for novices since it adds the spice of danger to programming. See "Note of caution" below.
-</p>
-<p>
-To store to the rstack we say <code>>R</code>, and to retrieve we say <code>R></code>. The word <code>R@</code> copies the top of the rstack to the TOS.
-</p>
-<p>
-Why use the rstack when we have a perfectly good parameter stack to play with? Sometimes it becomes hard to read code that performs complex gymnastics on the stack. The rstack can reduce the complexity.
-</p>
-<p>
-Alternatively, <code>VARIABLE</code>s --named locations-- provide a place to store numbers --such as intermediate results in a calculation-- off the stack, again reducing the gymnastics. Try this:
-<PRE>
-\ YOU DO THIS \ EXPLANATION
-
-VARIABLE X <cr>
-ok> \ create a named storage location X;
- \ X executes by leaving its address
-
-3 X ! <cr>
-ok> \ ! ("store") expects a number and
- \ an address, and stores the number to
- \ that address
-
-X @ . <cr>
-3 ok> \ @ ("fetch") expects an address, and
- \ places its contents in TOS.
-</PRE>
-</p>
-<p>
-However, Forth encourages using as few named variables as possible. The reason: since <code>VARIABLE</code>s are typically global -- any subroutine can access them -- they can cause unwanted interactions among parts of a large program.
-</p>
-<p><i>Ficl note: Ficl supports named <a href="ficl_loc.html">local variables</a> efficiently. You can use them to simplify the stack logic of many words.</i></p>
-<p>
-Although Forth can make variables local to the subroutines that use them (see "headerless words" in FTR), the rstack can often replace local variables:
- <UL>
- <LI>
- The rstack already exists, so it need not be defined anew.
- </LI>
- <LI>
- When the numbers placed on it are removed, the rstack shrinks, reclaiming some memory.
- </LI>
- </UL>
-</p><p>
-A note of caution: since the rstack is critical to execution we mess with it at our peril. If we use the rstack for temporary storage we must restore it to its initial state. A word that places a number on the rstack must remove it --using <code>R></code> or <code>RDROP</code> (if it has been defined) -- before exiting that word. Since <code>DO...LOOP</code> and other control constructs also use the rstack for their internal bookkeeping, for each <code>>R</code> following <code>DO</code> there must be a corresponding <code>R></code> or <code>RDROP</code> preceding <code>LOOP</code>. Neglecting these precautions will probably crash the system.
-</p>
-
- <H2>
- <A name="fetching">Fetching and storing</A>
- </H2>
- <p>
- As we just saw, ordinary numbers are fetched from memory to the stack by <code>@</code> ("fetch"), and stored by <code>!</code> (store).
- </p>
- <p>
- <code>@</code> expects an address on the stack and replaces that address by its contents using, e.g., the phrase <code>X @</code></p>
- <p>
-<code>!</code> expects a number (NOS) and an address (TOS) to store it in, and places the number in the memory location referred to by the address, consuming both arguments in the process, as in the phrase <code>3 X !</code>
-</p>
-<p>
-Double length numbers can similarly be fetched and stored, by <code>D@</code> and <code>D!</code>, if the system has these words.
-</p>
-<p>
-Positive numbers smaller than 255 can be placed in single bytes of memory using <code>C@</code> and <code>C!</code>. This is convenient for operations with strings of ASCII text, for example screen and keyboard I/O.
-</p>
-<p>
-
- <H2>
- <A name="comparing">Comparing and branching</A>
- </H2>
- <p>
-Forth lets you compare two numbers on the stack, using relational operators <code>></code>, <code>lt;</code>, <code>=</code> . Thus, e.g., the phrase
- <pre>
-2 3 > <cr>
-ok>
-</pre>
-leaves 0 (<code>false</code>) on the stack, because 2 (NOS) is not greater than 3 (TOS). Conversely, the phrase
- <pre>
-2 3 < <cr>
-ok>
- </pre>
- leaves -1 (<code>true</code>) because 2 is less than 3.
- </p>
-Notes:
-<ul>
-<li>In non-standard Forths <code>true</code> is +1 rather than -1.
-</li>
-<li>
-Relational operators consume both arguments and leave a "flag" to show what happened.</li>
-</ul>
-<p>(Many Forths offer unary relational operators <code>0=</code>, <code>0<></code>, <code>0></code> and <code>0<</code>. These, as might be guessed, determine whether the TOS contains an integer that is 0, nonzero, positive or negative.)</p>
-<p>
-The relational words are used for branching and control. For example:
-<pre>
-: TEST CR 0<> IF ." Not zero!" ENDIF ;
-0 TEST <cr>
-ok> ( no action)
--14 TEST <cr>
-Not zero! ok>
-</pre>
-<p>
-The word <code>CR</code> issues a carriage return (newline). Then TOS is compared with zero, and the logical NOT operator (this flips <code>true</code> and <code>false</code>) applied to the resulting flag. Finally, if TOS is non-zero, <code>IF</code> swallows the flag and executes all the words between itself and the terminating <code>THEN</code> (Note: Ficl has <code>endif</code> as a less confusing synonym). If TOS is zero, execution jumps to the word following <code>THEN</code>.
-</p>
-<p>
-The word <code>ELSE</code> is used in the <code>IF...ELSE...THEN</code> statement: a nonzero value in TOS causes any words between <code>IF</code> and <code>ELSE</code> to be executed, and words between <code>ELSE</code> and <code>THEN</code> to be skipped. A zero value produces the opposite behavior. Thus, e.g.
-<pre>
-: TRUTH CR 0= IF ." false" ELSE ." true" THEN ;
-
-1 TRUTH <cr>
-true ok>
-
-0 TRUTH <cr>
-false ok>
-</pre>
-<p>
-Since THEN is used to terminate an IF statement rather than in its more conventional sense, some Forth writers prefer the name ENDIF.
-<br>
-<i>Ficl Note: Ficl defines <code>endif</code> as a synonym for <code>THEN</code>.</i>
-</p>
-
- <H2>
- <A name="documenting">Documenting and commenting Forth code</A>
- </H2>
-<p>
-Forth is sometimes accused of being a "write-only" language, i.e. some complain that Forth is cryptic. This is really a complaint against poor documentation and untelegraphic word names. Unreadability is equally a flaw of poorly written FORTRAN, PASCAL, C, etc.
-</p><p>
-Forth offers programmers who take the trouble tools for producing exceptionally clear code.
-</p>
-
- <H3>
- Parenthesized remarks
- </H3>
- <p>
- The word <code>(</code> -- a left parenthesis followed by a space -- says "disregard all following text until the next right parenthesis in the input stream". Thus we can intersperse explanatory remarks within colon definitions.
- </p>
-
- <H3>
- Stack comments
- </H3>
- <p>
- A particular form of parenthesized remark describes the effect of a word on the stack. In the example of a recursive loop (GCD below), stack comments are really all the documentation necessary.
-</p>
-<p>
- Glossaries generally explain the action of a word with a stack-effect comment. For example,
-<pre>
-( adr -- n)
-</pre>
-describes the word <code>@</code> ("fetch"): it says <code>@</code> expects to find an address (adr) on the stack, and to leave its contents (n) upon completion. The corresponding comment for <code>!</code> would be
-<pre>
-( n adr -- ) .
-</pre>
-
- <H3>
- Drop line (\)
- </H3>
- The word <code>\</code> (back-slash followed by space) is a method for including longer comments. It simply means "drop everything in the input stream until the next carriage return". Instructions to the user, clarifications or usage examples are most naturally expressed in a block of text with each line set off by <code>\</code>.
-
- <H3>
- Self-documenting code
- </H3>
- By eliminating ungrammatical phrases like CALL or GOSUB, Forth presents the opportunity --via telegraphic names for words-- to make code almost as self-documenting and transparent as a readable English or German sentence. Thus, for example, a robot control program could contain a phrase like
-<pre>
-2 TIMES LEFT EYE WINK
-</pre>
-which is clear (although it sounds like a stage direction for Brunhilde to vamp Siegfried). It would even be possible without much difficulty to define the words in the program so that the sequence could be made English-like:
-<pre>
-WINK LEFT EYE 2 TIMES
-</pre>
-
- <H2>
- <A name="arithmetic">Arithmetic operations</A>
- </H2>
-<p>
-The <a href="http://ficl.sourceforge.net/dpans/dpans.htm">American National Standard</a> requires that a conforming Forth system contain a certain minimum set of pre-defined words. These consist of arithmetic operators <code>+ - * / MOD /MOD */ </code> for (usually) 32-bit signed-integer arithmetic, and equivalents for unsigned, double-length and mixed-mode (32- mixed with 64-bit) arithmetic. The list will be found in the glossary accompanying your system, as well as in SF and FTR.
-</p>
-<p>
-Try this example of a non-trivial program that uses arithmetic and branching to compute the greatest common divisor of two integers using Euclid's algorithm:
-<PRE>
-: TUCK ( a b -- b a b) SWAP OVER ;
-: GCD ( a b -- gcd) ?DUP IF TUCK MOD GCD THEN ;
-</PRE>
-The word <code>?DUP</code> duplicates TOS if it is not zero, and leaves it alone otherwise. If the TOS is 0, therefore, <code>GCD</code> consumes it and does nothing else. However, if TOS is unequal to 0, then <code>GCD TUCK</code>s TOS under NOS (to save it); then divides NOS by TOS, keeping the remainder (<code>MOD</code>). There are now two numbers left on the stack, so we again take the <code>GCD</code> of them. That is, <code>GCD</code> calls itself. However, if you try the above code it will fail. A dictionary entry cannot be looked up and found until the terminating <code>;</code> has completed it. So in fact we must use the word <code>RECURSE</code> to achieve self-reference, as in
-<pre>
-: TUCK ( a b -- b a b) SWAP OVER ;
-: GCD ( a b -- gcd) ?DUP IF TUCK MOD RECURSE THEN ;
-</pre>
-Now try
-<pre>
-784 48 GCD .
-16 ok>
-</pre>
-</p>
- <H2>
- <A name="looping">Looping and structured programming</A>
- </H2>
-Forth has several ways to loop, including the implicit method of recursion, illustrated above. Recursion has a bad name as a looping method because in most languages that permit recursion, it imposes unacceptable running time overhead on the program. Worse, recursion can -- for reasons beyond the scope of this Introduction to Forth -- be an extremely inefficient method of expressing the problem. In Forth, there is virtually no excess overhead in recursive calls because Forth uses the stack directly. So there is no reason not to recurse if that is the best way to program the algorithm. But for those times when recursion simply isn't enough, here are some more standard methods.
-
- <H3>
- Indefinite loops
- </H3>
-The construct
-<PRE>
-BEGIN xxx ( -- flag) UNTIL
-</PRE>
-executes the words represented by xxx, leaving TOS (flag) set to TRUE -- at which point UNTIL terminates the loop-- or to FALSE --at which point UNTIL jumps back to BEGIN. Try:
-<PRE>
-: COUNTDOWN ( n --)
- BEGIN CR DUP . 1 - DUP 0 = UNTIL DROP ;
-5 COUNTDOWN
-5
-4
-3
-2
-1 ok>
-</PRE>
-A variant of <code>BEGIN...UNTIL</code> is
-<PRE>
-BEGIN xxx ( -- flag) WHILE yyy REPEAT<BR>
-</PRE>
-<p>
-Here xxx is executed, WHILE tests the flag and if it is <code>FALSE</code> leaves the loop; if the flag is <code>TRUE</code>, yyy is executed; <code>REPEAT</code> then branches back to <code>BEGIN</code>.
-</p><p>
-These forms can be used to set up loops that repeat until some external event (pressing a key at the keyboard, e.g.) sets the flag to exit the loop. They can also used to make endless loops (like the outer interpreter of Forth) by forcing the flag to be FALSE in a definition like
-<pre>
-: ENDLESS BEGIN xxx FALSE UNTIL ;
-</pre>
-</p>
- <H3>
- Definite loops
- </H3>
- Most Forths allow indexed loops using <code>DO...LOOP</code> (or <code>+LOOP</code>). These are permitted only within definitions
-<PRE>
-: BY-ONES ( n --) 0 TUCK DO CR DUP . 1 + LOOP DROP ;<BR>
-</PRE>
-<p>
-The words <code>CR DUP . 1 +</code> will be executed n times as the lower limit, 0, increases in unit steps to n-1.
-</p>
-<p>
-To step by 2's, we use the phrase <code>2 +LOOP</code> to replace <code>LOOP</code>, as with
-<PRE>
-: BY-TWOS ( n --) 0 TUCK
-DO CR DUP . 2 + 2 +LOOP DROP ;
-</PRE>
-</p>
- <H3>
- Structured programming
- </H3>
- <p>
-N. Wirth invented the Pascal language in reaction to program flow charts resembling a plate of spaghetti. Such flow diagrams were often seen in early languages like FORTRAN and assembler. Wirth intended to eliminate line labels and direct jumps (GOTOs), thereby forcing control flow to be clear and direct.
-</p>
-<p>
-The ideal was subroutines or functions that performed a single task, with unique entries and exits. Unfortunately, programmers insisted on GOTOs, so many Pascals and other modern languages now have them. Worse, the ideal of short subroutines that do one thing only is unreachable in such languages because the method for calling them and passing arguments imposes a large overhead. Thus execution speed requires minimizing calls, which in turn means longer, more complex subroutines that perform several related tasks. Today structured programming seems to mean little more than writing code with nested IFs indented by a pretty-printer.
-</p>
-<P>
-Paradoxically, Forth is the only truly structured language in common use, although it was not designed with that as its goal. In Forth word definitions are subroutine calls. The language contains no GOTO's so it is impossible to write "spaghetti code". Forth also encourages structure through short definitions. The additional running time incurred in breaking a long procedure into many small ones (this is called "factoring") is typically rather small in Forth. Each Forth subroutine (word) has one entry and one exit point, and can be written to perform a single job.
-</p>
-
- <H3>
- "Top-down" design
- </H3>
-"Top-down" programming is a doctrine that one should design the entire program from the general to the particular:
- <UL>
- <LI>
-Make an outline, flow chart or whatever, taking a broad overview of the whole problem.
- </LI>
- <LI>
- Break the problem into small pieces (decompose it).
- </LI>
- <LI>
- Then code the individual components.
- </LI>
- </UL>
- The natural programming mode in Forth is "bottom-up" rather than "top down" --the most general word appears last, whereas the definitions must progress from the primitive to the complex. This leads to a somewhat different approach from more familiar languages:
- <UL>
- <LI>
-In Forth, components are specified roughly, and then as they are coded they are immediately tested, debugged, redesigned and improved.
- </LI>
- <LI>
-The evolution of the components guides the evolution of the outer levels of the program.
- </LI>
- </UL>
- <H2>
- <A name="create">CREATE ... DOES> (the pearl of FORTH)</A>
- </H2>
-Michael Ham has called the word pair <code>CREATE...DOES></code>, the "pearl of Forth". CREATE is a component of the compiler, whose function is to make a new dictionary entry with a given name (the next name in the input stream) and nothing else. <code>DOES></code> assigns a specific run-time action to a newly <code>CREATE</code>d word.
-
- <H3>
- <A name="defining">Defining "defining" words</A>
- </H3>
- <p>
-<code>CREATE</code> finds its most important use in extending the powerful class of Forth words called "defining" words. The colon compiler <code>:</code> is such a word, as are <code>VARIABLE</code> and <code>CONSTANT</code>.
-</p><p>The definition of VARIABLE in high-level Forth is simple
-<PRE>
-: VARIABLE CREATE 1 CELLS ALLOT ;
-</PRE>
-We have already seen how <code>VARIABLE</code> is used in a program. (An alternative definition found in some Forths (not Ficl) is
-<PRE>
-: VARIABLE CREATE 0 , ;<BR>
-</PRE>
---these variables are initialized to 0.)
-</p><p>
-Forth lets us define words initialized to contain specific values: for example, we might want to define the number 17 to be a word. <code>CREATE</code> and <code>,</code> ("comma") can do this:
-<PRE>
-17 CREATE SEVENTEEN , <cr>
-ok>
-</PRE>
-Now test it via
-<PRE>
-SEVENTEEN @ . <cr>
-17 ok>
-</PRE>
- <BR>
- Remarks:
- <UL>
- <LI>
-The word <code>,</code> ("comma") puts TOS into the next cell of the dictionary and increments the dictionary pointer by that number of bytes.
- </LI>
- <LI>
-A word <code>C,</code> ("see-comma") exists also -- it puts a character into the next character-length slot of the dictionary and increments the pointer by 1 such slot. (If the character representation is ASCII the slots are 1 byte--Unicode requires 2 bytes.)
- </LI>
- </UL>
- <H3>
- <A name="runtime">Run-time vs. compile-time actions</A>
- </H3>
- <p>
-In the preceding example, we were able to initialize the variable <code>SEVENTEEN</code> to 17 when we <code>CREATE</code>d it, but we still have to fetch it to the stack via SEVENTEEN @ whenever we want it. This is not quite what we had in mind: we would like to find 17 in TOS when SEVENTEEN is named. The word <code>DOES></code> gives us the tool to do this.
-</p>
-<p>
-The function of <code>DOES></code> is to specify a run-time action for the "child" words of a defining word. Consider the defining word <code>CONSTANT</code>, defined in high-level (of course <code>CONSTANT</code> is usually defined in machine code for speed) Forth by
-<PRE>
-: CONSTANT CREATE , DOES> @ ;
-</PRE>
-and used as
-<PRE>
-53 CONSTANT PRIME <cr>
-ok>
-</PRE>
-Now test it:
-<PRE>
-PRIME . <cr> 53
-ok>
-</PRE>
-</p>
-What is happening here?
-
- <UL>
- <LI>
-<code>CREATE</code> (hidden in <code>CONSTANT</code>) makes an entry named <code>PRIME</code> (the first word in the input stream following <code>CONSTANT</code>). Then <code>,</code> places the TOS (the number 53) in the next cell of the dictionary.
- </LI>
- <LI>
-Then <code>DOES></code> (inside <code>CONSTANT</code>) appends the actions of all words between it and <code>;</code> (the end of the definition) -- in this case, <code>@</code> -- to the child word(s) defined by CONSTANT.
- </LI>
- </UL>
- <H3>
- <A name="dimensioned">Dimensioned data (intrinsic units)</A>
- </H3>
- <p>
- Here is an example of the power of defining words and of the distinction between compile-time and run-time behaviors.
- </p>
- <p>
-Physical problems generally involve quantities that have dimensions, usually expressed as mass (M), length (L) and time (T) or products of powers of these. Sometimes there is more than one system of units in common use to describe the same phenomena.
-</p>
-<p>
-For example, U.S. or English police reporting accidents might use inches, feet and yards; while Continental police would use centimeters and meters. Rather than write different versions of an accident analysis program it is simpler to write one program and make unit conversions part of the grammar. This is easy in Forth.
-</p>
-<p>
-The simplest method is to keep all internal lengths in millimeters, say, and convert as follows:
-<PRE>
-: INCHES 254 10 */ ;
-: FEET [ 254 12 * ] LITERAL 10 */ ;
-: YARDS [ 254 36 * ] LITERAL 10 */ ;
-: CENTIMETERS 10 * ;
-: METERS 1000 * ;
-</PRE>
-Note: This example is based on integer arithmetic. The word <code>*/</code>
-means "multiply the third number on the stack by NOS, keeping double precision, and divide by TOS". That is, the stack comment for <code>*/</code> is
-<code>( a b c -- a*b/c)</code>.
-</p>
-The usage would be
-<PRE>
-10 FEET . <cr>
-3048 ok>
-</PRE>
-<p>
-The word <code>[</code> switches from compile mode to interpret mode while compiling. (If the system is interpreting it changes nothing.) The word <code>]</code> switches from interpret to compile mode.
-</p>
-<p>
-Barring some error-checking, the "definition" of the colon compiler <code>:</code> is just
-<PRE>
-: : CREATE ] DOES> doLIST ;
-</PRE>
-and that of <code>;</code> is just
-<PRE>
-: ; next [ ; IMMEDIATE
-</PRE>
-Another use for these switches is to perform arithmetic at compile-time rather than at run-time, both for program clarity and for easy modification, as we did in the first try at dimensioned data (that is, phrases such as
-<pre>
-[ 254 12 * ] LITERAL
-</PRE>
-and
-<pre>
-[ 254 36 * ] LITERAL
-</pre>
-which allowed us to incorporate in a clear manner the number of tenths of millimeters in a foot or a yard.
-<p>
- The preceding method of dealing with units required unnecessarily many definitions and generated unnecessary code. A more compact approach uses a defining word, <code>UNITS</code>:
-<pre>
-: D, ( hi lo --) SWAP , , ;
-: D@ ( adr -- hi lo) DUP @ SWAP 2 + @ ;
-: UNITS CREATE D, DOES> D@ */ ;
-</pre>
-Then we could make the table
-<PRE>
-254 10 UNITS INCHES
-254 12 * 10 UNITS FEET
-254 36 * 10 UNITS YARDS
-10 1 UNITS CENTIMETERS
-1000 1 UNITS METERS
-
-\ Usage:
-10 FEET . <cr>
-3048 ok> 3 METERS . <cr>
-3000 ok>
-\ .......................
-\ etc.
-</PRE>
-This is an improvement, but Forth permits a simple extension that allows conversion back to the input units, for use in output:
-<PRE>
-VARIABLE <AS> 0 <AS> !
-: AS TRUE <AS> ! ;
-: ~AS FALSE <AS> ! ;
-: UNITS CREATE D, DOES> D@ <AS> @
- IF SWAP THEN
- */ ~AS ;
-
-\ UNIT DEFINITIONS REMAIN THE SAME.
-\ Usage:
-10 FEET . <cr>
-3048 ok> 3048 AS FEET . <cr>
-10 ok>
-</PRE>
-
- <H3>
- <A name="advanced">Advanced uses of the compiler</A>
- </H3>
-<p>
-Suppose we have a series of push-buttons numbered 0-3, and a word <code>WHAT</code>
-to read them. That is, WHAT waits for input from a keypad: when button #3 is pushed, for example, WHAT leaves 3 on the stack.
-</p><p>
-We would like to define a word BUTTON to perform the action of pushing the n'th button, so we could just say:
-<pre>
-WHAT BUTTON
-</pre>
-BUTTON could look something like
-<pre>
-: BUTTON DUP 0 = IF RING DROP EXIT THEN
- DUP 1 = IF OPEN DROP EXIT THEN
- DUP 2 = IF LAUGH DROP EXIT THEN
- DUP 3 = IF CRY DROP EXIT THEN
- ABORT" WRONG BUTTON!" ;
-</pre>
-That is, we would have to go through two decisions on the average. Forth makes possible a much neater algorithm, involving a "jump table". [Note: Forth never standardized the common CASE statement, but as you will see it is easy to implement one]. The mechanism by which Forth executes a subroutine is to feed its "execution token" (often an address, but not necessarily) to the word EXECUTE. If we have a table of execution tokens we need only look up the one corresponding to an index (offset into the table) fetch it to the stack and say EXECUTE.
-</p>
-<p>
- One way to code this is
-<pre>
-CREATE BUTTONS ' RING , ' OPEN , ' LAUGH , ' CRY ,
-: BUTTON ( nth --) 0 MAX 3 MIN
- CELLS BUTTONS + @ EXECUTE ;
-</pre>
-Note how the phrase <code>0 MAX 3 MIN</code> protects against an out-of-range index. Although the Forth philosophy is not to slow the code with unnecessary error checking (because words are checked as they are defined), when programming a user interface some form of error handling is vital. It is usually easier to prevent errors as we just did, than to provide for recovery after they are made.
-</p>
-How does the action-table method work?
- <UL>
- <LI>
- CREATE BUTTONS makes a dictionary entry BUTTONS.
- </LI>
- <LI>
- The word ' ("tick") finds the execution token (xt) of the following word, and the word , ("comma") stores it in the data field of the new word BUTTONS. This is repeated until all the subroutines we want to select among have their xt's stored in the table.
- </LI>
- <LI>
- The table <code>BUTTONS</code> now contains xt's of the various actions of BUTTON.
- </LI>
- <LI>
- CELLS then multiplies the index by the appropriate number of bytes per cell, to get the offset into the table <code>BUTTONS</code> of the desired xt.
- </LI>
- <LI>
- BUTTONS + then adds the base address of <code>BUTTONS</code> to get the absolute address where the xt is stored.
- </LI>
- <LI>
- <CODE>@</CODE> fetches the xt for <code>EXECUTE</code> to execute.
- </LI>
- <LI>
- <code>EXECUTE</code> then executes the word corresponding to the button pushed. Simple!
- </LI>
- </UL>
-If a program needs but one action table the preceding method suffices. However, more complex programs may require many such. In that case it may pay to set up a system for defining action tables, including both error-preventing code and the code that executes the proper choice. One way to code this is
-<PRE>
-: ;CASE ; \ do-nothing word
-: CASE:
- CREATE HERE -1 >R 0 , \ place for length
- BEGIN BL WORD FIND \ get next subroutine
- 0= IF CR COUNT TYPE ." not found" ABORT THEN
- R> 1+ >R
- DUP , ['] ;CASE =
- UNTIL R> 1- SWAP ! \ store length
- DOES>
- DUP @ ROT ( -- base_adr len n)
- MIN 0 MAX \ truncate index
- CELLS + CELL+ @ EXECUTE ;
-</PRE>
-Note the two forms of error checking. At compile-time, <CODE>CASE:</CODE> aborts compilation of the new word if we ask it to point to an undefined subroutine:
-<PRE>
-case: test1 DUP SWAP X ;case
-X not found
-</PRE>
-and we count how many subroutines are in the table (including the do-nothing one, <CODE>;case</CODE>) so that we can force the index to lie in the range [0,n].
-<PRE>
-CASE: TEST * / + - ;CASE ok
-15 3 0 TEST . 45 ok
-15 3 1 TEST . 5 ok
-15 3 2 TEST . 18 ok
-15 3 3 TEST . 12 ok
-15 3 4 TEST . . 3 15 ok
-</PRE>
-Just for a change of pace, here is another way to do it:
-<PRE>
-: jtab: ( Nmax --) \ starts compilation
-CREATE \ make a new dictionary entry
-1- , \ store Nmax-1 in its body
-; \ for bounds clipping
-
-: get_xt ( n base_adr -- xt_addr)
-DUP @ ( -- n base_adr Nmax-1)
-ROT ( -- base_adr Nmax-1 n)
-MIN 0 MAX \ bounds-clip for safety
-1+ CELLS+ ( -- xt_addr = base + 1_cell + offset)
-;
-
-: | ' , ; \ get an xt and store it in next cell
-
-: ;jtab DOES> ( n base_adr --) \ ends compilation
-get_xt @ EXECUTE \ get token and execute it
-; \ appends table lookup and execute code
-
-\ Example:
-: Snickers ." It's a Snickers Bar!" ; \ stub for test
-
-\ more stubs
-
-5 jtab: CandyMachine
-| Snickers
-| Payday
-| M&Ms
-| Hershey
-| AlmondJoy
-;jtab
-
-3 CandyMachine It's a Hershey Bar!
-ok> 1 CandyMachine It's a Payday!
-ok> 7 CandyMachine It's an Almond Joy!
-ok> 0 CandyMachine It's a Snickers Bar!
-ok> -1 CandyMachine It's a Snickers Bar!
-ok>
-</PRE>
- <H2>
- <A name="floating">Floating point arithmetic</A>
- </H2>
-<p>
-Although Forth at one time eschewed floating point arithmetic (because in the era before math co-processors integer arithmetic was 3x faster), in recent years a standard set of word names has been agreed upon. This permits the exchange of programs that will operate correctly on any computer, as well as the development of a Scientific Subroutine Library in Forth (FSL).
-</p>
-<p>
- Although the ANS Standard does not require a separate stack for floating point numbers, most programmers who use Forth for numerical analysis employ a separate floating point stack; and most of the routines in the FSL assume such. We shall do so here as well.
-</p>
-<p>
-The floating point operators have the following names and perform the actions indicated in the accompanying stack comments:
-<pre>
-@ ( adr --) ( f: -- x)
-F! ( adr --) ( f: x --)
-F+ ( f: x y -- x+y)
-F- ( f: x y -- x-y)
-F* ( f: x y -- x*y)
-F/ ( f: x y -- x/y)
-FEXP ( f: x -- e^x)
-FLN ( f: x -- ln[x])
-FSQRT ( f: x -- x^0.5)
-</pre>
-<p>
- Additional operators, functions, trigonometric functions, etc. can be found in the FLOATING and FLOATING EXT wordsets. (See <a href="http://ficl.sourceforge.net/dpans/dpans12.htm">dpANS12</a>)
-</p>
-<p>
- To aid in using floating point arithmetic I have created a simple FORTRAN-like interface for incorporating formulas into Forth words.
-</p>
-<p>
- The file ftest.f (included below) illustrates how <a href="http://www.phys.virginia.edu/classes/551.jvn.fall01/ftran111.f">ftran111.f</a> should be used.
-<pre>
-\ Test for ANS FORmula TRANslator
-marker-test
-fvariable a
-fvariable b
-fvariable c
-fvariable d
-fvariable x
-fvariable w
-: test0 f" b+c" cr fe.
-f" b-c" cr fe.
-f" (b-c)/(b+c)" cr fe. ;
-
-3.e0 b f!
-4.e0 c f!
-see test0
-test0
-
-: test1 f" a=b*c-3.17e-5/tanh(w)+abs(x)" a f@ cr fe. ;
-1.e-3 w f!
--2.5e0 x f!
-cr cr
-see test1
-test1
-
-cr cr
-: test2 f" c^3.75" cr fe.
-f" b^4" cr fe. ;
-see test2
-test2
-
-\ Baden's test case
-
-: quadroot c f! b f! a f!
-f" d = sqrt(b^2-4*a*c) "
-f" (-b+d)/(2*a) " f" (-b-d)/(2*a) "
-;
-cr cr
-see quadroot
-
-: goldenratio f" max(quad root(1,-1,-1)) " ;
-cr cr
-see goldenratio
-cr cr
-goldenratio f.
-</pre>
-Output should look like:
-<pre>
-: test0
-c f@ b f@ f+ cr fe. c f@ fnegate b f@ f+ cr fe. c f@ fnegate b f@
-f+ c f@ b f@ f+ f/ cr fe. ;
-7.00000000000000E0
--1.00000000000000E0
--142.857142857143E-3
-
-
-: test1
-x f@ fabs 3.17000000000000E-5 w f@ ftanh f/ fnegate b f@ c f@ f* f+
-f+ a f! a f@ cr fe. ;
-14.4682999894333E0
-ok>
-: test2
-c f@ noop 3.75000000000000E0 f** cr fe. b f@ f^4 cr fe. ;
-181.019335983756E0
-81.0000000000000E0
-ok>
-: QUADROOT C F! B F! A F! B F@ F^2 flit 4.00000 A F@
-C F@ F* F* F- FSQRT D F! B F@ FNEGATE D
-F@ F+ flit 2.00000 A F@ F* F/ B F@ FNEGATE
-D F@ F- flit 2.00000 A F@ F* F/ ;
-
-
-: GOLDENRATIO flit 1.00000 flit -1.00000 flit -1.00000
-QUADROOT FMAX ;
-
-1.61803
-ok>
-</pre>
-with more or fewer places.
- </DIV>
- </BODY>
-</HTML>
-
--- a/doc/primer.txt
+++ /dev/null
@@ -1,1164 +1,0 @@
- A Beginner's Guide to Forth
-
- by
-
- J.V. Noble
-
- Contents
-
- 0. Preliminaries
-
-
- 1. Getting started
-
- The structure of Forth
-
- 2. Extending the dictionary
-
- 3. Stacks and reverse Polish notation (RPN)
- 3.1 Manipulating the parameter stack
- 3.2 The return stack and its uses
-
- 4. Fetching and storing
-
- 5. Comparing and branching
-
- 6. Documenting and commenting Forth code
-
- 7. Arithmetic operations
-
- 8. Looping and structured programming
-
- 9. CREATE ... DOES> (the pearl of Forth)
- 9.1 Defining "defining" words
- 9.2 Run-time vs. compile-time actions
- 9.3 Dimensioned data (intrinsic units)
- 9.4 Advanced uses of the compiler
-
- 10. Floating point arithmetic
-
-
-
- 0. Introduction
-
- Forth is an unusual computer language that has probably been applied
- to more varied projects than any other. It is the obvious choice when
- the project is exceptionally demanding in terms of completion sched-
- ule, speed of execution, compactness of code, or any combination of
- the above.
-
- It has also been called "...one of the best-kept secrets in the com-
- puting world." This is no exaggeration: large corporations have pur-
- chased professional Forth development systems from vendors such as
- Laboratory Microsystems, Inc., Forth, Inc. or MicroProcessor Engineer-
- ing, Ltd. and sworn them to secrecy.
-
- Some speculate (unkindly) that corporate giants prefer to hide their
- shame at using Forth; but I believe they are actually concealing a
- secret weapon from their rivals. Whenever Forth has competed directly
- with a more conventional language like C it has won hands down, pro-
- ducing smaller, faster, more reliable code in far less time. I have
- searched for examples with the opposite outcome, but have been unable
- to find a single instance.
-
-
-
- 1. Getting started
-
- We will use Win32Forth for these illustrations. Download the file
-
- w32for35.exe
-
- and double-click on it to install on any Windows 95-equipped machine.
-
-
- The compressed files will then decompress themselves. They should also
- install a program group on your desktop.
-
- Now start Win32Forth by opening the program group and clicking on the
- appropriate icon.
-
-
- It should respond by opening a window and writing something like
-
- 32bit Forth for Windows 95, and NT
- Compiled: July 23rd, 1997, 5:11pm
- Version: 3.5 Build: 0008 Release Build
- Platform: Windows 95 Version: 4.0 Build: 16384
- 491k bytes free
- 2,719 Words in Application dictionary
- 1,466 Words in System dictionary
- 4,185 Words total in dictionaries
- 8,293 Windows Constants available
-
- Loading Win32For.CFG
-
- *** DON'T PANIC, Press: F1 NOW! ***
-
-
- Win32Forth is case-insensitive.
-
-
- Now type
-
- BYE <cr>.
-
- The Win32Forth window immediately closes.
-
-
- What just happened? Forth is an interactive programming language con-
- sisting entirely of subroutines, called "words".
-
- A word is executed (interactively) by naming it. We have just seen
- this happen: BYE is a Forth subroutine meaning "exit to the operating
- system". So when we entered BYE it was executed, and the system re-
- turned control to Windows.
-
-
- Click on the Win32Forth icon again to re-start Forth.
- Now we will try something a little more complicated. Enter
-
- 2 17 + . <cr> 19 ok
-
- What happened? Forth is interpretive. An "outer interpreter" continu-
- ally loops, waiting for input from the keyboard or mass storage de-
- vice. The input is a sequence of text strings separated from each
- other by blank spaces --ASCII 32decimal = 20hex-- the standard Forth
- delimiter.
-
- When the outer interpreter encounters text it first looks for it in
- the "dictionary" (a linked list of previously defined subroutine
- names). If it finds the word, it executes the corresponding code.
-
- If no dictionary entry exists, the interpreter tries to read the input
- as a number.
-
- If the input text string satisfies the rules defining a number, it is
- converted to a number and stored in a special memory location called
- "the top of the stack" (TOS).
-
-
- In the above example, Forth interpreted 2 and 17 as numbers, and
- pushed them both onto the stack.
-
- "+" is a pre-defined word as is ".", so they were looked up and exe-
- cuted.
-
- "+" added 2 to 17 and left 19 on the stack.
-
- The word "." (called "emit") removed 19 from the stack and displayed
- it on the standard output device (in this case, CRT).
-
-
- We might also have said
-
- HEX 0A 14 * . <cr> C8 ok
-
- (Do you understand this? Hint: DECIMAL means "switch to decimal arith-
- metic", whereas HEX stands for "switch to hexadecimal arithmetic".)
-
- If the incoming text can neither be located in the dictionary nor in-
- terpreted as a number, Forth issues an error message. Try it: say X
- and see
-
- X
- Error: X is undefined
-
- or say THING and see
-
- THING
- Error: THING is undefined
-
-
-
- 2. Extending the dictionary
-
- The compiler is one of Forth's most endearing features. Unlike
- all other high-level languages, the Forth compiler is part of the
- language. (LISP and its dialects also make components of the com-
- pilation mechanism available to the programmer.) That is, its com-
- ponents are Forth words available to the programmer, that can be
- used to solve his problems.
-
- In this section we discuss how the compiler extends the
- dictionary.
-
- Forth uses special words to create new dictionary entries, i.e.,
- new words. The most important are ":" ("start a new definition")- and ";" ("terminate the definition").-
- Let's try this out: enter
-
- : *+ * + ; <cr> ok
-
- What happened? The word ":" was executed because it was already
- in the dictionary. The action of ":" is
-
- > Create a new dictionary entry named "*+" and switch from
- interpret to compile mode.
-
- > In compile mode, the interpreter looks up words and
- --rather than executing them-- installs pointers to
- their code. (If the text is a number, rather than
- pushing it on the stack, Forth builds the number
- into the dictionary space allotted for the new word,
- following special code that puts it on the stack
- when the word is executed.)
-
- > The action of "*+" will be to execute sequentially
- the previously-defined words "*" and "+".
-
- > The word ";" is special: when it was defined a bit
- was turned on in its dictionary entry to mark it as
- IMMEDIATE. Thus, rather than writing down its
- address, the compiler executes ";" immediately. The
- action of ";" is first, to install the code that
- returns control to the next outer level of the
- interpreter; and second, to switch back from compile
- mode to interpret mode.
-
- Now try out "*+" :
-
- DECIMAL 5 6 7 *+ . <cr> 47 ok
-
- This example illustrated two principles of Forth: adding a new word to
- the dictionary, and trying it out as soon as it was defined.
-
-
-
- 3. Stacks and reverse Polish notation (RPN)
-
- We now discuss the stack and the "reverse Polish" or "postfix" arith-
- metic based on it. (Anyone who has used a Hewlett-Packard calculator
- should be familiar with the concept.)
-
- Virtually all modern CPU's are designed around stacks. Forth effi-
- ciently uses its CPU by reflecting this underlying stack architecture
- in its syntax.
-
-
- But what is a stack? As the name implies, a stack is the machine ana-
- log of a pile of cards with numbers written on them. Numbers are
- always added to the top of the pile, and removed from the top of the
- pile. The Forth input line
-
- 2 5 73 -16 <cr> ok
-
- leaves the stack in the state
-
- cell # contents
-
-
- 0 -16 (TOS)
-
- 1 73 (NOS)
-
- 2 5
-
- 3 2
-
-
- where TOS stands for "top-of-stack", NOS for "next-on-stack", etc.
-
- We usually employ zero-based relative numbering in Forth data struct-
- ures (such as stacks, arrays, tables, etc.) so TOS is given relative
- #0, NOS #1, etc.
-
- Suppose we followed the above input line with the line
-
- + - * . <cr> xxx ok
-
- what would xxx be? The operations would produce the successive stacks
-
- cell# initial + - * .
-
- 0 -16 57 -52 -104
- 1 73 5 2
- 2 5 2
- 3 2 empty
- stack
-
- The operation "." (EMIT) displays -104 to the screen, leaving the
- stack empty. That is, xxx is -104.
-
-
- 3.1 Manipulating the parameter stack
-
- Forth systems incorporate (at least) two stacks: the parameter stack
- and the return stack.
-
- A stack-based system must provide ways to put numbers on the stack, to
- remove them, and to rearrange their order. Forth includes standard
- words for this purpose.
-
- Putting numbers on the stack is easy: simply type the number (or in-
- corporate it in the definition of a Forth word).
-
- The word DROP removes the number from TOS and moves up all the other
- numbers. (Since the stack usually grows downward in memory, DROP mere-
- ly increments the pointer to TOS by 1 cell.)
-
- SWAP exchanges the top 2 numbers.
-
- DUP duplicates the TOS into NOS.
-
- ROT rotates the top 3 numbers.
-
-
- These actions are shown below (we show what each word does to the ini-
- tial stack)
-
- cell | initial | DROP SWAP ROT DUP
-
- 0 | -16 | 73 73 5 -16
- 1 | 73 | 5 -16 -16 -16
- 2 | 5 | 2 5 73 73
- 3 | 2 | 2 2 5
- 4 | | 2
-
-
- Forth includes the words OVER, TUCK, PICK and ROLL that act as shown
- below (note PICK and ROLL must be preceded by an integer that says
- where on the stack an element gets PICK'ed or ROLL'ed):
-
- cell | initial | OVER TUCK 4 PICK 4 ROLL
-
- 0 | -16 | 73 -16 2 2
- 1 | 73 | -16 73 -16 -16
- 2 | 5 | 73 -16 73 73
- 3 | 2 | 5 5 5 5
- 4 | | 2 2 2
-
- Clearly, 1 PICK is the same as DUP, 2 PICK is a synonym for OVER, and
- 2 ROLL means SWAP.
-
-
- 3.2 The return stack and its uses
-
- We have remarked above that compilation establishes links from the
- calling word to the previously-defined word being invoked. The linkage
- mechanism --during execution-- uses the return stack (rstack): the
- address of the next word to be invoked is placed on the rstack, so
- that when the current word is done executing, the system knows to jump
- to the next word. (This is so in most, but not all Forth implement-
- ations. But all have a return stack, whether or not they use them for
- linking subroutines.)
-
- In addition to serving as a reservoir of return addresses (since words
- can be nested, the return addresses need a stack to be put on) the
- rstack is where the limits of a DO...LOOP construct are placed.
-
- The user can also store/retrieve to/from the rstack. This is an ex-
- ample of using a component for a purpose other than the one it was
- designed for. Such use is discouraged for novices since it adds the
- spice of danger to programming. See "Note of caution" below.
-
- To store to the rstack we say >R , and to retrieve we say R> . The
- word R@ copies the top of the rstack to the TOS.
-
-
- Why use the rstack when we have a perfectly good parameter stack to
- play with? Sometimes it becomes hard to read code that performs com-
- plex gymnastics on the stack. The rstack can reduce the complexity.
-
- Alternatively, VARIABLEs --named locations-- provide a place to store
- numbers --such as intermediate results in a calculation-- off the
- stack, again reducing the gymnastics. Try this:
-
- \ YOU DO THIS \ EXPLANATION
-
- VARIABLE X <cr> ok \ create a named storage location X;
- \ X executes by leaving its address
-
- 3 X ! <cr> ok \ ! ("store") expects a number and- \ an address, and stores the number to
- \ that address
-
- X @ . <cr> 3 ok \ @ ("fetch") expects an address, and- \ places its contents in TOS.
-
- However, Forth encourages using as few named variables as possible.
- The reason: since VARIABLEs are typically global --any subroutine can
- access them-- they can cause unwanted interactions among parts of a
- large program.
-
- Although Forth can make variables local to the subroutines that use
- them (see "headerless words" in FTR), the rstack can often replace
- local variables:
-
- > The rstack already exists, so it need not be defined anew.
-
- > When the numbers placed on it are removed, the rstack shrinks,
- reclaiming some memory.
-
-
- A note of caution: since the rstack is critical to execution we mess
- with it at our peril. If we use the rstack for temporary storage we
- must restore it to its initial state. A word that places a number on
- the rstack must remove it --using R> or RDROP (if it has been defined)
- -- before exiting that word. Since DO...LOOP also uses the rstack,
- for each >R folowing DO there must be a corresponding R> or RDROP
- preceding LOOP. Neglecting these precautions will probably crash
- the system.
-
-
-
-
- 4. Fetching and storing
-
- As we just saw, ordinary numbers are fetched from memory to
- the stack by @ ("fetch"), and stored by ! (store).-
- @ expects an address on the stack and replaces that address by
- its contents using, e.g., the phrase X @
-
- ! expects a number (NOS) and an address (TOS) to store it in, and
- places the number in the memory location referred to by the address,
- consuming both arguments in the process, as in the phrase 3 X !
-
- Double length numbers can similarly be fetched and stored, by
- D@ and D!, if the system has these words.
-
- Positive numbers smaller than 255 can be placed in single bytes of
- memory using C@ and C!. This is convenient for operations with strings
- of ASCII text, for example screen and keyboard I/O.
-
-
-
- 5. Comparing and branching
-
- Forth lets you compare two numbers on the stack, using relational
- operators ">", "<", "=" . Ths, e.g., the phrase
-
- 2 3 > <cr> ok
-
- leaves 0 ("false") on the stack, because 2 (NOS) is not greater than 3 - (TOS). Conversely, the phrase
-
- 2 3 < <cr> ok
-
- leaves -1 ("true") because 2 is less than 3. -
- Notes: In some Forths "true" is +1 rather than -1.
-
- Relational operators consume both arguments and leave a "flag"
- to show what happened.
-
- (Many Forths offer unary relational operators "0=", "0>" and "0<".
- These, as might be guessed, determine whether the TOS contains an
- integer that is 0, positive or negative.)
-
- The relational words are used for branching and control. For example,
-
- : TEST CR 0 = NOT IF ." Not zero!" THEN ;
-
- 0 TEST <cr> ok ( no action)
- -14 TEST <cr>
- Not zero! ok
-
- The word CR issues a carriage return (newline). Then TOS is compared
- with zero, and the logical NOT operator (this flips "true" and
- "false") applied to the resulting flag. Finally, if TOS is non-zero,
- IF swallows the flag and executes all the words between itself and the
- terminating THEN. If TOS is zero, execution jumps to the word
- following THEN.
-
- The word ELSE is used in the IF...ELSE...THEN statement: a nonzero
- value in TOS causes any words between IF and ELSE to be executed, and
- words between ELSE and THEN to be skipped. A zero value produces the
- opposite behavior. Thus, e.g.
-
-
- : TRUTH CR 0 = IF ." false" ELSE ." true" THEN ;
-
- 1 TRUTH <cr>
- true ok
-
- 0 TRUTH <cr>
- false ok
-
- Since THEN is used to terminate an IF statement rather than in its
- usual sense, some Forth writers prefer the name ENDIF.
-
- 6. Documenting and commenting Forth code
-
- Forth is sometimes accused of being a "write-only" language, i.e. some
- complain that Forth is cryptic. This is really a complaint against
- poor documentation and untelegraphic word names. Unreadability is
- equally a flaw of poorly written FORTRAN, PASCAL, C, etc.
-
- Forth offers programmers who take the trouble tools for producing ex-
- ceptionally clear code.
-
-
- 6.1 Parenthesized remarks
-
- The word ( -- a left parenthesis followed by a space -- says "disre-
- gard all following text until the next right parenthesis in the
- input stream". Thus we can intersperse explanatory remarks within
- colon definitions.
-
-
- 6.2 Stack comments
-
- A particular form of parenthesized remark describes the effect of a
- word on the stack. In the example of a recursive loop (GCD below),
- stack comments are really all the documentation necessary.
-
- Glossaries generally explain the action of a word with a
- stack-effect comment. For example,
-
- ( adr -- n)
-
- describes the word @ ("fetch"): it says @ expects to find an address - (adr) on the stack, and to leave its contents (n) upon completion.
- The corresponding comment for ! would be
-
- ( n adr -- ) .
-
-
-
- 6.3 Drop line (\)
-
- The word "\" (back-slash followed by space) has recently gained favor
- as a method for including longer comments. It simply means "drop ev-
- erything in the input stream until the next carriage return". Instruc-
- tions to the user, clarifications or usage examples are most naturally
- expressed in a block of text with each line set off by "\" .
-
-
- 6.4 Self-documenting code
-
- By eliminating ungrammatical phrases like CALL or GOSUB, Forth pre-
- sents the opportunity --via telegraphic names for words-- to make code
- almost as self-documenting and transparent as a readable English or
- German sentence. Thus, for example, a robot control program could con-
- tain a phrase like
-
- 2 TIMES LEFT EYE WINK
-
- which is clear (although it sounds like a stage direction for Brun-
- hilde to vamp Siegfried). It would even be possible without much dif-
- ficulty to define the words in the program so that the sequence could
- be made English-like: WINK LEFT EYE 2 TIMES .
-
-
-
-
- 7. Arithmetic operations
-
- The 1979 or 1983 standards require that a conforming Forth system con-
- tain a certain minimum set of pre-defined words. These consist of
- arithmetic operators + - * / MOD /MOD */ for (usually) 16-bit signed-
- integer (-32767 to +32767) arithmetic, and equivalents for unsigned (0
- to 65535), double-length and mixed-mode (16- mixed with 32-bit) arith-
- metic. The list will be found in the glossary accompanying your
- system, as well as in SF and FTR.
-
- Try this example of a non-trivial program that uses arithmetic and
- branching to compute the greatest common divisor of two integers using
- Euclid's algorithm:
-
- : TUCK ( a b -- b a b) SWAP OVER ;
- : GCD ( a b -- gcd) ?DUP IF TUCK MOD GCD THEN ;
-
- The word ?DUP duplicates TOS if it is not zero, and leaves it alone
- otherwise. If the TOS is 0, therefore, GCD consumes it and does
- nothing else. However, if TOS is unequal to 0, then GCD TUCKs TOS
- under NOS (to save it); then divides NOS by TOS, keeping the remainder
- (MOD). There are now two numbers left on the stack, so we again take
- the GCD of them. That is, GCD calls itself. However, if you try the
- above code it will fail. A dictionary entry cannot be looked up and
- found until the terminating ";" has completed it. So in fact we must
- use the word RECURSE to achieve self-reference, as in
-
- : TUCK ( a b -- b a b) SWAP OVER ;
- : GCD ( a b -- gcd) ?DUP IF TUCK MOD RECURSE THEN ;
-
- Now try
-
- 784 48 GCD . 16 ok
-
-
- 8. Looping and structured programming
-
- Forth has several ways to loop, including the implicit method of re-
- cursion, illustrated above. Recursion has a bad name as a looping
- method because in most languages that permit recursion, it imposes
- unacceptable running time overhead on the program. Worse, recursion
- can --for reasons beyond the scope of this Introduction to Forth-- be
- an extremely inefficient method of expressing the problem. In Forth,
- there is virtually no excess overhead in recursive calls because Forth
- uses the stack directly. So there is no reason not to recurse if that
- is the best way to program the algorithm. But for those times when
- recursion simply isn't enough, here are some more standard methods.
-
- 8.1 Indefinite loops
-
- The construct
-
- BEGIN xxx ( -- flag) UNTIL
-
- executes the words represented by xxx, leaving TOS (flag) set to TRUE
- --at which point UNTIL terminates the loop-- or to FALSE --at which
- point UNTIL jumps back to BEGIN. Try:
-
- : COUNTDOWN ( n --)
- BEGIN CR DUP . 1 - DUP 0 = UNTIL DROP ;
-
- 5 COUNTDOWN
- 5
- 4
- 3
- 2
- 1 ok
-
- A variant of BEGIN...UNTIL is
-
- BEGIN xxx ( -- flag) WHILE yyy REPEAT
-
- Here xxx is executed, WHILE tests the flag and if it is FALSE
- leaves the loop; if the flag is TRUE, yyy is executed; REPEAT then
- branches back to BEGIN.
-
- These forms can be used to set up loops that repeat until some
- external event (pressing a key at the keyboard, e.g.) sets the
- flag to exit the loop. They can also used to make endless loops
- (like the outer interpreter of Forth) by forcing the flag
- to be FALSE in a definition like
-
-
- : ENDLESS BEGIN xxx FALSE UNTIL ;
-
-
- 8.2 Definite loops
-
- Most Forths allow indexed loops using DO...LOOP (or +LOOP or /LOOP).
- These are permitted only within definitions
-
- : BY-ONES ( n --) 0 TUCK DO CR DUP . 1 + LOOP DROP ;
-
- The words CR DUP . 1 + will be executed n times as the lower
- limit, 0, increases in unit steps to n-1.
-
- To step by 2's, we use the phrase 2 +LOOP to replace LOOP, as with
-
- : BY-TWOS ( n --) 0 TUCK
- DO CR DUP . 2 + 2 +LOOP DROP ;
-
-
- 8.4 Structured programming
-
- N. Wirth invented the Pascal language in reaction to program flow
- charts resembling a plate of spaghetti. Such flow diagrams were
- often seen in early languages like FORTRAN and assembler. Wirth
- intended to eliminate line labels and direct jumps (GOTOs), thereby
- forcing control flow to be clear and direct.
-
- The ideal was subroutines or functions that performed a single
- task, with unique entries and exits. Unfortunately, programmers
- insisted on GOTOs, so many Pascals and other modern languages now have
- them. Worse, the ideal of short subroutines that do one thing only is
- unreachable in such languages because the method for calling them and
- passing arguments imposes a large overhead. Thus execution speed re-
- quires minimizing calls, which in turn means longer, more complex sub-
- routines that perform several related tasks. Today structured program-
- ming seems to mean little more than writing code with nested IFs in-
- dented by a pretty-printer.
-
- Paradoxically, Forth is the only truly structured language in common
- use, although it was not designed with that as its goal. In Forth word
- definitions are subroutine calls. The language contains no GOTO's so
- it is impossible to write "spaghetti code". Forth also encourages
- structure through short definitions. The additional running time
- incurred in breaking a long procedure into many small ones (this is
- called "factoring") is typically rather small in Forth. Each Forth sub-
- routine (word) has one entry and one exit point, and can be written
- to perform a single job.
-
-
-
- 8.5 "Top-down" design
-
- "Top-down" programming is a doctrine that one should design the entire
- program from the general to the particular:
-
- > Make an outline, flow chart or whatever, taking a broad overview
- of the whole problem.
-
- > Break the problem into small pieces (decompose it).
-
- > Then code the individual components.
-
- The natural programming mode in Forth is "bottom-up" rather than "top-
- down" --the most general word appears last, whereas the definitions
- must progress from the primitive to the complex. This leads to a some-
- what different approach from more familiar languages:
-
- > In Forth, components are specified roughly, and then as they are
- coded they are immediately tested, debugged, redesigned and
- improved.
-
- > The evolution of the components guides the evolution of the outer
- levels of the program.
-
-
-
-
- 9. CREATE ... DOES> (the pearl of FORTH)
-
- Michael Ham has called the word pair CREATE...DOES>, the "pearl of
- Forth". CREATE is a component of the compiler, whose function is to
- make a new dictionary entry with a given name (the next name in the
- input stream) and nothing else. DOES> assigns a specific run-time ac-
- tion to a newly CREATEd word.
-
-
- 9.1 Defining "defining" words
-
- CREATE finds its most important use in extending the powerful class of
- Forth words called "defining" words. The colon compiler ":" is such
- a word, as are VARIABLE and CONSTANT.
-
- The definition of VARIABLE in high-level Forth is simple
-
- : VARIABLE CREATE 1 CELLS ALLOT ;
-
- We have already seen how VARIABLE is used in a program. (An altern-
- ative definition found in some Forths is
-
- : VARIABLE CREATE 0 , ;
-
- --these variables are initialized to 0.)
-
- Forth lets us define words initialized to contain specific values: for
- example, we might want to define the number 17 to be a word. CREATE
- and "," ("comma") can do this:-
- 17 CREATE SEVENTEEN , <cr> ok
-
- Now test it via
-
- SEVENTEEN @ . <cr> 17 ok .
-
-
- Remarks:
-
- > The word , ("comma") puts TOS into the next cell of the dic-- tionary and increments the dictionary pointer by that number of
- bytes.
-
- > A word "C," ("see-comma") exists also -- it puts a character into- the next character-length slot of the dictionary and increments
- the pointer by 1 such slot. (If the character representation is
- ASCII the slots are 1 byte--Unicode requires 2 bytes.)
-
-
- 9.2 Run-time vs. compile-time actions
-
- In the preceding example, we were able to initialize the variable
- SEVENTEEN to 17 when we CREATEd it, but we still have to fetch it to
- the stack via SEVENTEEN @ whenever we want it. This is not quite what
- we had in mind: we would like to find 17 in TOS when SEVENTEEN is
- named. The word DOES> gives us the tool to do this.
-
- The function of DOES> is to specify a run-time action for the "child"
- words of a defining word. Consider the defining word CONSTANT , de-
- fined in high-level (of course CONSTANT is usually defined in machine
- code for speed) Forth by
-
- : CONSTANT CREATE , DOES> @ ;
-
- and used as
-
- 53 CONSTANT PRIME <cr> ok
-
- Now test it:
-
- PRIME . <cr> 53 ok .
-
-
- What is happening here?
-
- > CREATE (hidden in CONSTANT) makes an entry named PRIME (the
- first word in the input stream following CONSTANT). Then ","
- places the TOS (the number 53) in the next cell of the dic-
- tionary.
-
- > Then DOES> (inside CONSTANT) appends the actions of all words be-
- tween it and ";" (the end of the definition) --in this case, "@"--
- to the child word(s) defined by CONSTANT.
-
-
- 9.3 Dimensioned data (intrinsic units)
-
- Here is an example of the power of defining words and of the distinc-
- tion between compile-time and run-time behaviors.
-
- Physical problems generally involve quantities that have dimensions,
- usually expressed as mass (M), length (L) and time (T) or products of
- powers of these. Sometimes there is more than one system of units in
- common use to describe the same phenomena.
-
- For example, U.S. or English police reporting accidents might use
- inches, feet and yards; while Continental police would use centimeters
- and meters. Rather than write different versions of an accident ana-
- lysis program it is simpler to write one program and make unit conver-
- sions part of the grammar. This is easy in Forth.
-
- The simplest method is to keep all internal lengths in millimeters,
- say, and convert as follows:
-
- : INCHES 254 10 */ ;
- : FEET [ 254 12 * ] LITERAL 10 */ ;
- : YARDS [ 254 36 * ] LITERAL 10 */ ;
- : CENTIMETERS 10 * ;
- : METERS 1000 * ;
-
- Note: This example is based on integer arithmetic. The word */
- means "multiply the third number on the stack by NOS, keeping
- double precision, and divide by TOS". That is, the stack com-
- ment for */ is ( a b c -- a*b/c).
-
-
- The usage would be
-
- 10 FEET . <cr> 3048 ok
-
-
- The word "[" switches from compile mode to interpret mode while com-
- piling. (If the system is interpreting it changes nothing.) The word
- "]" switches from interpret to compile mode.
-
- Barring some error-checking, the "definition" of the colon compiler
- ":" is just
-
- : : CREATE ] DOES> doLIST ;
-
- and that of ";" is just
-
- : ; next [ ; IMMEDIATE
-
- Another use for these switches is to perform arithmetic at compile-
- time rather than at run-time, both for program clarity and for easy
- modification, as we did in the first try at dimensioned data (that is,
- phrases such as
-
- [ 254 12 * ] LITERAL
-
- and
-
- [ 254 36 * ] LITERAL
-
- which allowed us to incorporate in a clear manner the number of
- tenths of millimeters in a foot or a yard.
-
-
- The preceding method of dealing with units required unnecessarily many
- definitions and generated unnecessary code. A more compact approach
- uses a defining word, UNITS :
-
- : D, ( hi lo --) SWAP , , ;
- : D@ ( adr -- hi lo) DUP @ SWAP 2 + @ ;
- : UNITS CREATE D, DOES> D@ */ ;
-
- Then we could make the table
-
- 254 10 UNITS INCHES
- 254 12 * 10 UNITS FEET
- 254 36 * 10 UNITS YARDS
- 10 1 UNITS CENTIMETERS
- 1000 1 UNITS METERS
-
- \ Usage:
- 10 FEET . <cr> 3048 ok
- 3 METERS . <cr> 3000 ok
- \ .......................
- \ etc.
-
- This is an improvement, but Forth permits a simple extension that
- allows conversion back to the input units, for use in output:
-
- VARIABLE <AS> 0 <AS> !
- : AS TRUE <AS> ! ;
- : ~AS FALSE <AS> ! ;
- : UNITS CREATE D, DOES> D@ <AS> @
- IF SWAP THEN
- */ ~AS ;
-
- \ UNIT DEFINITIONS REMAIN THE SAME.
- \ Usage:
- 10 FEET . <cr> 3048 ok
- 3048 AS FEET . <cr> 10 ok
-
-
-
- 9.4 Advanced uses of the compiler
-
- Suppose we have a series of push-buttons numbered 0-3, and a word WHAT
- to read them. That is, WHAT waits for input from a keypad: when button
- #3 is pushed, for example, WHAT leaves 3 on the stack.
-
- We would like to define a word BUTTON to perform the action of pushing
- the n'th button, so we could just say:
-
- WHAT BUTTON
-
- In a conventional language BUTTON would look something like
-
- : BUTTON DUP 0 = IF RING DROP EXIT THEN
- DUP 1 = IF OPEN DROP EXIT THEN
- DUP 2 = IF LAUGH DROP EXIT THEN
- DUP 3 = IF CRY DROP EXIT THEN
- ABORT" WRONG BUTTON!" ;
-
- That is, we would have to go through two decisions on the average.
-
- Forth makes possible a much neater algorithm, involving a "jump
- table". The mechanism by which Forth executes a subroutine is to
- feed its "execution token" (often an address, but not necessarily)
- to the word EXECUTE. If we have a table of execution tokens we need
- only look up the one corresponding to an index (offset into the table)
- fetch it to the stack and say EXECUTE.
-
- One way to code this is
-
- CREATE BUTTONS ' RING , ' OPEN , ' LAUGH , ' CRY ,
- : BUTTON ( nth --) 0 MAX 3 MIN
- CELLS BUTTONS + @ EXECUTE ;
-
- Note how the phrase 0 MAX 3 MIN protects against an out-of-range
- index. Although the Forth philosophy is not to slow the code with un-
- necessary error checking (because words are checked as they are de-
- fined), when programming a user interface some form of error handling
- is vital. It is usually easier to prevent errors as we just did, than
- to provide for recovery after they are made.
-
- How does the action-table method work?
-
- > CREATE BUTTONS makes a dictionary entry BUTTONS.
-
- > The word ' ("tick") finds the execution token (xt) of the- following word, and the word , ("comma") stores it in the- data field of the new word BUTTONS. This is repeated until
- all the subroutines we want to select among have their xt's
- stored in the table.
-
- > The table BUTTONS now contains xt's of the various actions of
- BUTTON.
-
- > CELLS then multiplies the index by the appropriate number of
- bytes per cell, to get the offset into the table BUTTONS
- of the desired xt.
-
- > BUTTONS + then adds the base address of BUTTONS to get the abso-
- lute address where the xt is stored.
-
- > @ fetches the xt for EXECUTE to execute.
-
- > EXECUTE then executes the word corresponding to the button pushed.
- Simple!
-
- If a program needs but one action table the preceding method suffices.
- However, more complex programs may require many such. In that case
- it may pay to set up a system for defining action tables, including
- both error-preventing code and the code that executes the proper
- choice. One way to code this is
-
- : ;CASE ; \ do-nothing word
- : CASE:
- CREATE HERE -1 >R 0 , \ place for length
- BEGIN BL WORD FIND \ get next subroutine
- 0= IF CR COUNT TYPE ." not found" ABORT THEN
- R> 1+ >R
- DUP , ['] ;CASE =
- UNTIL R> 1- SWAP ! \ store length
- DOES> DUP @ ROT ( -- base_adr len n)
- MIN 0 MAX \ truncate index
- CELLS + CELL+ @ EXECUTE ;
-
- Note the two forms of error checking. At compile-time, CASE:
- aborts compilation of the new word if we ask it to point to an
- undefined subroutine:
-
- case: test1 DUP SWAP X ;case
- X not found
-
- and we count how many subroutines are in the table (including
- the do-nothing one, ;case) so that we can force the index to
- lie in the range [0,n].
-
- CASE: TEST * / + - ;CASE ok
- 15 3 0 TEST . 45 ok
- 15 3 1 TEST . 5 ok
- 15 3 2 TEST . 18 ok
- 15 3 3 TEST . 12 ok
- 15 3 4 TEST . . 3 15 ok
-
- Just for a change of pace, here is another way to do it:
-
- : jtab: ( Nmax --) \ starts compilation
- CREATE \ make a new dictionary entry
- 1- , \ store Nmax-1 in its body
- ; \ for bounds clipping
-
- : get_xt ( n base_adr -- xt_addr)
- DUP @ ( -- n base_adr Nmax-1)
- ROT ( -- base_adr Nmax-1 n)
- MIN 0 MAX \ bounds-clip for safety
- 1+ CELLS+ ( -- xt_addr = base + 1_cell + offset)
- ;
-
- : | ' , ; \ get an xt and store it in next cell
-
- : ;jtab DOES> ( n base_adr --) \ ends compilation
- get_xt @ EXECUTE \ get token and execute it
- ; \ appends table lookup & execute code
-
- \ Example:
- : Snickers ." It's a Snickers Bar!" ; \ stub for test
-
- \ more stubs
-
- 5 jtab: CandyMachine
- | Snickers
- | Payday
- | M&Ms
- | Hershey
- | AlmondJoy
- ;jtab
-
- 3 CandyMachine It's a Hershey Bar! ok
- 1 CandyMachine It's a Payday! ok
- 7 CandyMachine It's an Almond Joy! ok
- 0 CandyMachine It's a Snickers Bar! ok
- -1 CandyMachine It's a Snickers Bar! ok
-
-
-
- 10. Floating point arithmetic
-
- Although Forth at one time eschewed floating point arithmetic
- (because in the era before math co-processors integer arithmetic
- was 3x faster), in recent years a standard set of word names has
- been agreed upon. This permits the exchange of programs that will
- operate correctly on any computer, as well as the development of
- a Scientific Subroutine Library in Forth (FSL).
-
- Although the ANS Standard does not require a separate stack for
- floating point numbers, most programmers who use Forth for numer-
- ical analysis employ a separate floating point stack; and most of
- the routines in the FSL assume such. We shall do so here as well.
-
- The floating point operators have the following names and perform
- the actions indicated in the accompanying stack comments:
-
- F@ ( adr --) ( f: -- x)
- F! ( adr --) ( f: x --)
- F+ ( f: x y -- x+y)
- F- ( f: x y -- x-y)
- F* ( f: x y -- x*y)
- F/ ( f: x y -- x/y)
- FEXP ( f: x -- e^x)
- FLN ( f: x -- ln[x])
- FSQRT ( f: x -- x^0.5)
-
- Additional operators, functions, trigonometric functions, etc. can
- be found in the FLOATING and FLOATING EXT wordsets. (See dpANS6--
- available in HTML, PostScript and MS Word formats. The HTML version
- can be accessed from this homepage.)
-
- To aid in using floating point arithmetic I have created a simple
- FORTRAN-like interface for incorporating formulas into Forth words.
-
- The file ftest.f (included below) illustrates how ftran111.f
- should be used.
-
-\ Test for ANS FORmula TRANslator
-
-marker -test
-fvariable a
-fvariable b
-fvariable c
-fvariable d
-fvariable x
-fvariable w
-
-: test0 f" b+c" cr fe.
- f" b-c" cr fe.
- f" (b-c)/(b+c)" cr fe. ;
-
-3.e0 b f!
-4.e0 c f!
-see test0
-test0
-
-: test1 f" a=b*c-3.17e-5/tanh(w)+abs(x)" a f@ cr fe. ;
-1.e-3 w f!
--2.5e0 x f!
-cr cr
-see test1
-test1
-
-cr cr
-: test2 f" c^3.75" cr fe.
- f" b^4" cr fe. ;
-see test2
-test2
-
-\ Baden's test case
-
-: quadroot c f! b f! a f!
- f" d = sqrt(b^2-4*a*c) "
- f" (-b+d)/(2*a) " f" (-b-d)/(2*a) "
-;
-cr cr
-see quadroot
-
-: goldenratio f" max(quad root(1,-1,-1)) " ;
-cr cr
-see goldenratio
-cr cr
-goldenratio f.
-
-
-
-0 [IF]
-Output should look like:
-
-: test0
- c f@ b f@ f+ cr fe. c f@ fnegate b f@ f+ cr fe. c f@ fnegate b f@
- f+ c f@ b f@ f+ f/ cr fe. ;
-7.00000000000000E0
--1.00000000000000E0
--142.857142857143E-3
-
-
-: test1
- x f@ fabs 3.17000000000000E-5 w f@ ftanh f/ fnegate b f@ c f@ f* f+
- f+ a f! a f@ cr fe. ;
-14.4682999894333E0 ok
-
-: test2
- c f@ noop 3.75000000000000E0 f** cr fe. b f@ f^4 cr fe. ;
-181.019335983756E0
-81.0000000000000E0 ok
-
-: QUADROOT C F! B F! A F! B F@ F^2 flit 4.00000 A F@
- C F@ F* F* F- FSQRT D F! B F@ FNEGATE D
- F@ F+ flit 2.00000 A F@ F* F/ B F@ FNEGATE
- D F@ F- flit 2.00000 A F@ F* F/ ;
-
-
-: GOLDENRATIO flit 1.00000 flit -1.00000 flit -1.00000
- QUADROOT FMAX ;
-
-1.61803 ok
-
-with more or fewer places.
-
-[THEN]
-
-
-
-
binary files a/doc/sigplan9906.doc /dev/null differ
binary files a/doc/skey.gif /dev/null differ
--- a/test/asm68k.4th
+++ b/test/asm68k.4th
@@ -298,11 +298,3 @@
: LABEL CREATE [COMPILE] ASSEMBLER ASSEMBLER WORD ;
: CODE LABEL HERE CELL- CELL- CELL- CP ! ;
-
-
-
---openmail-part-01d4752f-00000002--
-
---openmail-part-01d4752f-00000001--
-
-