ref: ca455597fd9acdc4f1b86e1cb62ee294a4c3bde9
dir: /doc/ficl.html/
<!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 release notes</title>
</head>
<body>
<center>
<h1>
<b>ficl 2.04 release notes</b></h1></center>
<table BORDER=0 CELLSPACING=3 WIDTH="600" >
<tr>
<td><b>Forth Inspired Command Language </b></td>
<td ROWSPAN="4"><img SRC="ficl_logo.jpg" height=64 width=64></td>
</tr>
<tr>
<td><b>Author: John Sadler (<a href="mailto:john_sadler@alum.mit.edu">john_sadler@alum.mit.edu</a>)</b></td>
</tr>
<tr>
<td><b>Created: 19 July 1997 </b></td>
</tr>
<tr>
<td><b>Revision 2.04: 20 May 2000</b></td>
</tr>
</table>
<h2>
Contents</h2>
<ul>
<li>
<a href="#whatsnew">Release notes</a></li>
<li>
<a href="#whatis">What is ficl?</a></li>
<li>
<a href="#features">Ficl features</a></li>
<li>
<a href="#porting">Porting</a></li>
<li>
<a href="#api">Application Programming Interface</a></li>
<li>
<a href="#manifest">Distribution source files</a></li>
<li>
<a href="#locals">Local variables</a></li>
<li>
<a href="ficl_oop.html">Object Oriented Programming in ficl</a></li>
<li>
<a href="#extras">Ficl extras</a></li>
<li>
<a href="#ansinfo">ANS required information</a></li>
<li>
<a href="#links">Forth and Ficl references, <b><font color="#000000">download</font></b></a></li>
<li>
<font color="#000000"><a href="#includesficl">Some software that includes
ficl</a></font></li>
<li>
<a href="#lawyerbait">Disclaimer & License</a></li>
</ul>
<br>
<table BORDER=0 CELLPADDING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<h2>
<a NAME="whatsnew"></a>What's new in 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>
What's new in version 2.03</h2>
This is the first version of Ficl that includes contributed code. Thanks
especially to Daniel Sobral, Michael Gauland for contributions and bug
finding.
<p>New words
<ul>
<li>
<tt><a href="#clock">clock</a>
(FICL)</tt></li>
<li>
<tt><a href="#clockspersec">clocks/sec</a>
(FICL)</tt></li>
<li>
<tt><a href="http://www.taygeta.com/forth/dpans8.htm#8.6.1.1230">dnegate</a>
(DOUBLE)</tt></li>
<li>
<tt><a href="http://www.taygeta.com/forth/dpans10.htm#10.6.2.1905">ms</a>
(FACILITY EXT - replaces MSEC <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>
<li>
</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>
What's new in version 2.02</h2>
New words
<ul>
<li>
<tt><a href="http://www.taygeta.com/forth/dpans6.htm#6.2.1850">marker</a>
(CORE EXT)</tt></li>
<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>
What's new in version 2.01</h2>
<ul>
<li>
Bug fix: <tt>(local)</tt> used to leave a value on the stack between the
first and last locals declared. This value is now stored in a static.</li>
<li>
Added new local syntax with parameter re-ordering. <a href="#newlocal">See
description below</a>. (No longer compiled in version 2.02, in favor of
the Johns Hopkins syntax)</li>
</ul>
</td>
</tr>
<tr>
<td>
<h2>
What's new in version 2.0</h2>
<ul>
<li>
New ANS Forth words: <tt>TOOLS</tt> and part of <tt>TOOLS EXT, SEARCH</tt>
and <tt>SEARCH EXT, LOCALS</tt> and <tt>LOCALS EXT</tt> word sets, additional
words from <tt>CORE EXT, DOUBLE</tt>, and <tt>STRING</tt>. (See the function
ficlCompileCore in words.c for an alphabetical list by word set).</li>
<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>
<hr>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<h1>
<a NAME="whatis"></a>What is ficl?</h1>
<font size=+1>Ficl (Forth inspired command language) is an ANS Forth interpreter
written in C. Unlike traditional Forths, this interpreter is designed to
be embedded into other systems as a command/macro/development prototype
language. Ficl provides object extensions that can be used to wrap methods
and structures of the host system without altering them. See below for
examples of <a href="#includesficl">software that includes ficl</a>.</font></td>
</tr>
<tr>
<td>Where Forths usually view themselves as the center of the system and
expect the rest of the system to be coded in Forth, Ficl acts as a component
of the system. It is easy to export code written in C or ASM to Ficl in
the style of TCL, or to invoke Ficl code from a compiled module. This allows
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 object model that can act as an object oriented
adapter for code written in C (or asm, Forth, C++...). </td>
</tr>
<tr>
<td><b>Ficl Design goals</b>
<ul>
<li>
Target 32 bit processors (<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>
</td>
</tr>
</table>
<br>
<br>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<h2>
<a NAME="features"></a>Ficl features</h2>
<ul>
<li>
Code is written in ANSI C for portability. </li>
<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 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 VMs share one system
dictionary; each Ficl virtual machine has an otherwise complete state,
and each can be bound to a separate I/O channel (or none at all). An optional
function called ficlLockDictionary() can control exclusive dictionary access.
This function is stubbed out by default (See FICL_MULTITHREAD in sysdep.h).
As long as there is only one "session" that can compile words into the
dictionary, you do not need exclusive dictionary access for multithreading.
<font color="#000099"><b>Note</b>: while the code is re-entrant, there
are still restrictions on how you can use it safely in a multithreaded
system. Specifically, the VM itself maintains state, so you generally need
a VM per thread in a multithreaded system. If interrupt service routines
make calls into Ficl code that alters VM state, then these generally need
their own VM as well. Alternatively, you could provide a mutual exclusion
mechanism to serialize access to a VM from multiple threads.</font></li>
<li>
Simple incorporation into existing systems: the sample implementation requires
three Ficl function calls (see the example program in testmain.c).</li>
<li>
ROM able: Ficl is designed to work in RAM based and ROM code / RAM data
environments. It does require somewhat more memory than a pure ROM implementation
because it builds its system dictionary in RAM at startup time.</li>
<li>
Written an ANSI C to be as simple as I can make it to understand, support,
debug, and port. Compiles without complaint at /Az /W4 (require ANSI C,
max. warnings) under Microsoft VC++</li>
<li>
Does full 32 bit math (but you need to implement two mixed precision math
primitives (see sysdep.c))</li>
<li>
Type 1 indirect threaded interpreter</li>
</ul>
</td>
</tr>
</table>
<hr>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<h2>
<a NAME="porting"></a>Porting ficl</h2>
To install ficl on your target system, you need an ANSI C compiler and
its runtime library. Inspect the system dependent macros and functions
in <tt>sysdep.h</tt> and <tt>sysdep.c</tt> and edit them to suit your system.
For example, <tt>INT16</tt> is a <tt>short</tt> on some compilers and an
<tt>int</tt> on others. Check the default <tt>CELL</tt> alignment controlled
by <tt>FICL_ALIGN</tt>. If necessary, add new definitions of <tt>ficlMalloc,
ficlFree, ficlLockDictionary</tt>, and <tt>ficlTextOut</tt> to work with
your operating system. Finally, use <tt>testmain.c</tt> as a guide to installing
the ficl system and one or more virtual machines into your code. You do
not need to include <tt>testmain.c</tt> in your build.
<p>Feel free to stub out the double precision math functions (which are
presently implemented as inline assembly because it's so easy on many 32
bit processors) with kludge code that only goes to 32 bit precision. In
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>
To-Do List (target system dependent words)</h3>
<ul>
<li>
Unimplemented system dependent <tt>CORE</tt> word: <tt>KEY</tt> </li>
<li>
Kludged <tt>CORE</tt> word: <tt>ACCEPT</tt></li>
</ul>
</td>
</tr>
</table>
<br>
<br>
<table BORDER=0 COLS=1 WIDTH="600" >
<tr>
<td>
<h2>
<a NAME="api"></a>Application Programming Interface</h2>
<i>See the comments in ficl.c and ficl.h for additional information, and
the example in file testmain.c.</i>
<dl>
<dt>
<b>void 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(void)</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(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>FICL_VM *ficlNewVM(void)</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(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(void)</b></dt>
<dd>
Returns a pointer to the main system dictionary, or NULL if the system
is uninitialized.</dd>
<dt>
<b>FICL_DICT *ficlGetEnv(void)</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(char *name, UNS32 value)</b></dt>
<dd>
Enters a new constant into the environment dictionary, with the specified
name and value.</dd>
<dt>
<b>void ficlSetEnvD(char *name, UNS32 hi, UNS32 lo)</b></dt>
<dd>
Enters a new double-cell constant into the environment dictionary with
the specified name and value.</dd>
<dt>
<b>FICL_DICT *ficlGetLoc(void)</b></dt>
<dd>
Returns a pointer to the locals dictionary. This function is defined only
if FICL_WANT_LOCALS is #defined as non-zero (see sysdep.h). The locals
dictionary is the symbol table for <a href="#locals">local variables</a>.</dd>
<dt>
<b>void ficlCompileCore(FICL_DICT *dp)</b></dt>
<dd>
Defined in words.c, this function builds ficl's primitives. </dd>
<dt>
<b>void ficlCompileSoftCore(FICL_VM *pVM)</b></dt>
<dd>
Defined in softcore.c, this function builds ANS required words and ficl
extras by evaluating a text string (think of it as a memory mapped file
;-) ). The string itself is built from files in the softwords directory
by PERL script softcore.pl. </dd>
</dl>
</td>
</tr>
</table>
<hr>
<table BORDER=0 CELLSPACING=5 WIDTH="600" >
<tr>
<td COLSPAN="2">
<h2>
<a NAME="manifest"></a>Ficl Source Files</h2>
</td>
</tr>
<tr>
<td><b>ficl.h</b></td>
<td>Declares most public functions and all data structures. Includes sysdep.h
and math.h</td>
</tr>
<tr>
<td><b>sysdep.h</b></td>
<td>Declares system dependent functions and contains build control macros.
Edit this file to port to another system.</td>
</tr>
<tr>
<td><b>math.h</b></td>
<td>Declares functions for 64 bit math</td>
</tr>
<tr>
<td><b>words.c</b></td>
<td>Exports ficlCompileCore(), the run-time dictionary builder, and contains
all primitive words as static functions.</td>
</tr>
<tr>
<td><b>vm.c</b></td>
<td>Virtual Machine methods</td>
</tr>
<tr>
<td><b>stack.c</b></td>
<td>Stack methods</td>
</tr>
<tr>
<td><b>ficl.c</b></td>
<td>System initialization, termination, and ficlExec</td>
</tr>
<tr>
<td><b>dict.c</b></td>
<td>Dictionary</td>
</tr>
<tr>
<td><b>math64.c</b></td>
<td>Implementation of 64 bit math words (except the two unsigned primitives
declared in sysdep.h and implemented in sysdep.c)</td>
</tr>
<tr>
<td><b>softcore.c</b></td>
<td>Contains all of the "soft" words - those written in Forth and compiled
by Ficl at startup time. Sources for these words are in the softwords directory.
The files softwords/softcore.bat and softwords/softcore.pl generate softcore.c
from the .fr sources.</td>
</tr>
<tr>
<td><b>sysdep.c</b></td>
<td>Implementation of system dependent functions declared in sysdep.h</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.</td>
</tr>
</table>
<hr>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<h2>
<a NAME="locals"></a>Local Variables</h2>
Locally scoped variables came late to Forth. Purists seem to feel that
experienced Forth programmers can 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.
<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>
Local variable support is optional because it adds a small amount of overhead
to the outer interpreter. You can disable it by setting FICL_WANT_LOCALS
to 0 in sysdep.h. Beware: much of the OOP code described below uses local
variables, so if you disable locals, you're going to lose other capabilities
too. Local variables can make Forth code quite a bit easier to read, so
I'd encourage you to experiment with them.
<br>The default maximum number of local variables is 16. It's controlled
by FICL_MAX_LOCALS in sysdep.h.
<p><a NAME="jhlocal"></a>Ficl 2.02 includes by default an implementation
of the Johns Hopkins local syntax (as best I can determine it from examples
on the web). This syntax lets you declare local variables that look very
much like a stack comment. Variables in the declaration appear in the "correct"
order for a stack comment. Everything after the -- is treated as a comment.
In addition, you can insert a | before the -- to declare one or more zero-initialized
locals. Example:
<blockquote><b><tt>:tuck0 { a b c | d -- 0 a b c }</tt></b>
<br><b><tt> d a b c ;</tt></b></blockquote>
The | and -- delimiters can appear at most once, and must appear in the
order shown in the example to work correctly. The local declaration ends
at the first occurrence of }. The declaration must all be on one line as
presently implemented.
<p>In ficl 2.04 and later, this facilty can also declare double cell locals
(this is handy for <a href="#ootutorial">OOP</a>, where objects take two
cells to represent on the stack). Double cell locals (AKA 2locals) have
names that start with 2. See ficl/softwords/string.fr for examples.
<p><a NAME="newlocal"></a>Ficl 2.01 added yet another local syntax that
models a stack comment. This one is not compiled in the release, but you
can add it by editing softwords/softcore.bat to include the file ficllocal.fr.
In this case, parameters are re-ordered so that the rightmost initialized
param comes from the top of the stack. The syntax is:
<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>
<h3>
Search Order</h3>
Ficl implements many of the search order words in terms of two primitives
called <tt><a href="#tosearch">>SEARCH</a></tt> and <tt><a href="#searchfrom">SEARCH></a></tt>.
As their names suggest (assuming you're familiar with Forth), they push
and pop the search order stack. See the list of <a href="#extras">Ficl
extras</a> for details.
<br>The standard does not appear to specify any conditions under which
the search order is reset to a sane state. Ficl resets the search order
to its default state whenever <tt>ABORT</tt> happens. This includes stack
underflows and overflows. <tt>QUIT</tt> does not affect the search order.
The minimum search order (set by <tt>ONLY</tt>) is equivalent to
<br><b><tt>FORTH-WORDLIST 1 SET-ORDER</tt></b>
<br>There is a default maximum of 16 wordlists in the search order. This
can be changed by redefining FICL_DEFAULT_VOCS (declared in sysdep.h).
<h3>
Soft Words</h3>
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. </td>
</tr>
</table>
<hr>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<dl>
<h2>
<a NAME="extras"></a>Ficl extras</h2>
<h3>
Number syntax</h3>
You can precede a number with "0x", as in C, and it will be interpreted
as a hex value regardless of the value of <tt>BASE</tt>. Example:
<dl>
<dt>
<tt>ok> decimal 123 . cr</tt> </dt>
<br><tt>123 </tt>
<br><tt>ok> 0x123 . cr</tt>
<br><tt>291 </tt></dl>
<h3>
Search order words</h3>
Note: Ficl resets the search order whenever it does <tt>ABORT</tt>. If
you don't like this behavior, just comment out the dictResetSearchOrder()
lines in ficlExec().
<br>
<dt>
<a NAME="tosearch"></a><tt>>search ( wid -- )</tt></dt>
<dd>
Push <tt>wid</tt> onto the search order. Many of the other search order
words are written in terms of the <tt>SEARCH></tt> and <tt>>SEARCH</tt>
primitives.</dd>
<dt>
<a NAME="searchfrom"></a><tt>search> ( -- wid )</tt></dt>
<dd>
Pop <tt>wid</tt> off the search order</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 <tt>wordlist</tt> is single threaded by default. </dd>
<dt>
<a NAME="ficlforgetwid"></a><tt>forget-wid ( wid -- )</tt></dt>
<dd>
Iterates through the specified wordlist and unlinks all definitions whose
xt addresses are greater than or equal to the value of <tt>HERE</tt>, the
dictionary fill pointer. </dd>
<dt>
<a NAME="ficlhide"></a><tt>hide ( -- current-wid-was )</tt></dt>
<dd>
Push the <tt>hidden</tt> wordlist onto the search order, and set it as
the current compile wordlist (unsing <tt>ficl-set-current</tt>). Leaves
the previous compile wordlist ID. I use this word to hide implementation
factor words that have low reuse potential so that they don't clutter the
default wordlist. To undo the effect of hide, execute <b><tt>previous
set-current</tt></b></dd>
<dt>
<a NAME="ficlhidden"></a><tt>hidden ( -- wid )</tt></dt>
<dd>
Wordlist for storing implementation factors of ficl provided words. To
see what's in there, try: <b><tt>hide words previous set-current</tt></b></dd>
<dt>
<tt>wid-set-super ( wid -- )</tt></dt>
<dd>
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>
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.</dd>
</dl>
<h3>
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>
<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>
<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>
<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>
FiclWin Extras (defined in testmain.c)</h3>
<dl>
<dt>
<tt>break ( -- )</tt></dt>
<dd>
Does nothing - just a handy place to set a debugger breakpoint</dd>
<dt>
<tt>cd ( "directory-name<newline>" --
)</tt></dt>
<dd>
Executes the Win32 chdir() function, changing the program's logged directory.</dd>
<dt>
<a NAME="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>
<h3>
FiclWin Exclusives (no source provided)</h3>
<dt>
<tt>!oreg ( c -- )</tt></dt>
<dd>
Set the value of the simulated LED register as specified (0..255)</dd>
<dt>
<tt>@ireg ( -- c )</tt></dt>
<dd>
Gets the value of the simulated switch block (0..255)</dd>
<dt>
<tt>!dac ( c -- )</tt></dt>
<dd>
Sets the value of the bargraph control as specified. Valid values range
from 0..255</dd>
<dt>
<tt>@adc ( -- c )</tt></dt>
<dd>
Fetches the current position of the slider control. Range is 0..255</dd>
<dt>
<tt>status" ( "ccc<quote>" -- )</tt></dt>
<dd>
Set the mainframe window's status line to the text specified, up to the
first trailing quote character.</dd>
<dt>
<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>
</td>
</tr>
</table>
<hr>
<p><a NAME="ansinfo"></a>
<p>ANS Required Information
<br>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td><b>ANS Forth System</b>
<br><b>Providing names from the Core Extensions word set </b>
<br><b>Providing the Exception word set</b>
<br><b>Providing names from the Exception Extensions word set</b>
<br><b>Providing the Locals word set </b>
<br><b>Providing the Locals Extensions word set </b>
<br><b>Providing the Memory Allocation word set</b>
<br><b>Providing the Programming-Tools word set</b>
<br><b>Providing names from the Programming-Tools Extensions word set</b>
<br><b>Providing the Search-Order word set</b>
<br><b>Providing the Search-Order Extensions word set</b>
<h3>
Implementation-defined Options</h3>
The implementation-defined items in the following list represent characteristics
and choices left to the discretion of the implementor, provided that the
requirements of the Standard are met. A system shall document the values
for, or behaviors of, each item.
<ul>
<li>
<b>aligned address requirements (3.1.3.3 Addresses);</b> </li>
<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>
<b>behavior of 6.1.1320 EMIT for non-graphic characters</b>; </li>
<li>
</li>
<br><font color="#000000">Depends on target system, C runtime library,
and your implementation of ficlTextOut().</font>
<li>
<b>character editing of 6.1.0695 ACCEPT and 6.2.1390 EXPECT</b>; </li>
<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>
<b>character set (3.1.2 Character types, 6.1.1320 EMIT, 6.1.1750 KEY)</b>; </li>
<li>
</li>
<br><font color="#000000">Depends on target system and implementation of
ficlTextOut()</font>
<li>
<b>character-aligned address requirements (3.1.3.3 Addresses)</b>; </li>
<li>
</li>
<br><font color="#000000">Ficl characters are one byte each. There are
no alignment requirements.</font>
<li>
<b>character-set-extensions matching characteristics (3.4.2 Finding definition
n<font color="#000000">ames)</font></b><font color="#000000">; </font></li>
<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>
<b>conditions under which control characters match a space delimiter (3.4.1.1
Delimiters)</b>;<font color="#FF6666"> </font></li>
<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>
<b>format of the control-flow stack (3.2.3.2 Control-flow stack)</b>; </li>
<li>
</li>
<br><font color="#000000">Uses the data stack</font>
<li>
<b>conversion of digits larger than thirty-five (3.2.1.2 Digit conversion)</b>; </li>
<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>
<b>display after input terminates in 6.1.0695 ACCEPT and 6.2.1390 EXPECT</b>; </li>
<li>
</li>
<br><font color="#000000">Target system dependent</font>
<li>
<b>exception abort sequence (as in 6.1.0680 ABORT")</b>; </li>
<li>
</li>
<br><font color="#000000">Does <tt>ABORT</tt></font>
<li>
<b>input line terminator (3.2.4.1 User input device)</b>;<font color="#FF0000"> </font></li>
<li>
</li>
<br><font color="#000000">Target system dependent (implementation of outer
loop that calls ficlExec)</font>
<li>
<b>maximum size of a counted string, in characters (3.1.3.4 Counted strings,
6.1.2450 WORD)</b>; </li>
<li>
</li>
<br><font color="#000000">255</font>
<li>
<b>maximum size of a parsed string (3.4.1 Parsing)</b>; </li>
<li>
</li>
<br>Limited by available memory and the maximum unsigned value that can
fit in a CELL (2<sup>32</sup>-1).
<li>
<b>maximum size of a definition name, in characters (3.3.1.2 Definition
names)</b>; </li>
<li>
</li>
<br><font color="#000000">Ficl stores the first 31 characters of a definition
name.</font>
<li>
<b>maximum string length for 6.1.1345 ENVIRONMENT?, in characters</b>; </li>
<li>
</li>
<br><font color="#000000">Same as maximum definition name length</font>
<li>
<b>method of selecting 3.2.4.1 User input device</b>; </li>
<li>
</li>
<br>None supported. This is up to the target system
<li>
<b>method of selecting 3.2.4.2 User output device</b>; </li>
<li>
</li>
<br>None supported. This is up to the target system
<li>
<b>methods of dictionary compilation (3.3 The Forth dictionary)</b>; </li>
<li>
<b>number of bits in one address unit (3.1.3.3 Addresses)</b>; </li>
<li>
</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>
<b>number representation and arithmetic (3.2.1.1 Internal number representation)</b>; </li>
<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>
<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>
</li>
<br>Assuming a 32 bit implementation, range for signed single-cell values
is -2<sup>31</sup>..2<sup>31</sup>-1. Range for unsigned single cell values
is 0..2<sup>32</sup>-1. Range for signed double-cell values is -2<sup>63</sup>..2<sup>63</sup>-1.
Range for unsigned single cell values is 0..2<sup>64</sup>-1.
<li>
<b>read-only data-space regions (3.3.3 Data space)</b>;</li>
<li>
</li>
<br>None
<li>
<b>size of buffer at 6.1.2450 WORD (3.3.3.6 Other transient regions)</b>; </li>
<li>
</li>
<br>Default is 255. Depends on the setting of nPAD in ficl.h.
<li>
<b>size of one cell in address units (3.1.3 Single-cell types)</b>; </li>
<li>
</li>
<br><font color="#000000">System dependent, generally four.</font>
<li>
<b>size of one character in address units (3.1.2 Character types)</b>; </li>
<li>
</li>
<br><font color="#000000">System dependent, generally one.</font>
<li>
<b>size of the keyboard terminal input buffer (3.3.3.5 Input buffers)</b>; </li>
<li>
</li>
<br><font color="#000000">This buffer is supplied by the host program.
Ficl imposes no practical limit.</font>
<li>
<b>size of the pictured numeric output string buffer (3.3.3.6 Other transient
regions)</b>; </li>
<li>
</li>
<br>Default is 255 characters. Depends on the setting of nPAD in ficl.h.
<li>
<b>size of the scratch area whose address is returned by 6.2.2000 PAD (3.3.3.6
Other transient regions)</b>; </li>
<li>
</li>
<br>Not presently supported
<li>
<b>system case-sensitivity characteristics (3.4.2 Finding definition names)</b>; </li>
<li>
</li>
<br><font color="#000000">Ficl is not case sensitive</font>
<li>
<b>system prompt (3.4 The Forth text interpreter, 6.1.2050 QUIT)</b>; </li>
<li>
</li>
<br><font color="#000000">"ok>"</font>
<li>
<b>type of division rounding (3.2.2.1 Integer division, 6.1.0100 */, 6.1.0110
*/MOD, 6.1.0230 /, 6.1.0240 /MOD, 6.1.1890 MOD)</b>; </li>
<li>
</li>
<br><font color="#000000">Symmetric</font>
<li>
<b>values of 6.1.2250 STATE when true</b>; </li>
<li>
</li>
<br><font color="#000000">One (no others)</font>
<li>
<b>values returned after arithmetic overflow (3.2.2.2 Other integer operations)</b>; </li>
<li>
</li>
<br>System dependent. Ficl makes no special checks for overflow.
<li>
<b>whether the current definition can be found after 6.1.1250 DOES> (6.1.0450
:)</b>. </li>
<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></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:
<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>
</li>
<br><font color="#000000">Ficl does <tt>ABORT</tt> and prints the name
followed by " not found".</font>
<li>
<b>a definition name exceeded the maximum length allowed (3.3.1.2 Definition
names)</b>; </li>
<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>
<b>addressing a region not listed in 3.3.3 Data Space</b>; </li>
<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>
<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>
</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>
<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>
</li>
<br><font color="#000000">Ficl returns a valid token, but the result of
executing that token while interpreting may be undesirable.</font>
<li>
<b>dividing by zero (6.1.0100 */, 6.1.0110 */MOD, 6.1.0230 /, 6.1.0240
/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>
</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>
<b>insufficient data-stack space or return-stack space (stack overflow)</b>; </li>
<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>
<b>insufficient space for loop-control parameters</b>; </li>
<li>
</li>
<br><font color="#000000">No check - Evil results.</font>
<li>
<b>insufficient space in the dictionary</b>; </li>
<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>
<b>interpreting a word with undefined interpretation semantics</b>; </li>
<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>
<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>
</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>
<b>overflow of a pictured numeric output string</b>;</li>
<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>
<b>parsed string overflow</b>;</li>
<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>
<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>
</li>
<br><font color="#000000">Value will be truncated</font>
<li>
<b>reading from an empty data stack or return stack (stack underflow)</b>; </li>
<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>
<b>unexpected end of input buffer, resulting in an attempt to use a zero-length
string as a name</b>; </li>
<li>
</li>
<br><font color="#000000">Ficl returns for a new input buffer until a non-empty
one is supplied.</font></ul>
The following specific ambiguous conditions are noted in the glossary entries
of the relevant words:
<ul>
<li>
<b>>IN greater than size of input buffer (3.4.1 Parsing)</b></li>
<li>
</li>
<br>Bad Things occur - unpredictable bacause the input buffer is supplied
by the host program's outer loop.
<li>
<b>6.1.2120 RECURSE appears after 6.1.1250 DOES></b></li>
<li>
</li>
<br>It finds the address of the definition before <tt>DOES></tt>
<li>
<b>argument input source different than current input source for 6.2.2148
RESTORE-INPUT</b></li>
<li>
</li>
<br>Not implemented
<li>
<b>data space containing definitions is de-allocated (3.3.3.2 Contiguous
regions)</b></li>
<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>
<b>data space read/write with incorrect alignment (3.3.3.1 Address alignment)</b></li>
<li>
</li>
<br>Target processor dependent. Consequences include: none (Intel), address
error exception (68K).
<li>
<b>data-space pointer not properly aligned (6.1.0150 ,, 6.1.0860 C,)</b></li>
<li>
</li>
<br>See above on data space read/write alignment
<li>
<b>less than u+2 stack items (6.2.2030 PICK, 6.2.2150 ROLL)</b></li>
<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>
<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>
</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>
<b>most recent definition does not have a name (6.1.1710 IMMEDIATE)</b></li>
<li>
</li>
<br>No problem.
<li>
<b>name not defined by 6.2.2405 VALUE used by 6.2.2295 TO</b></li>
<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>
<b>name not found (6.1.0070 ', 6.1.2033 POSTPONE, 6.1.2510 ['], 6.2.2530
[COMPILE])</b></li>
<li>
</li>
<br>Ficl prints an error message and does <tt>ABORT</tt>
<li>
<b>parameters are not of the same type (6.1.1240 DO, 6.2.0620 ?DO, 6.2.2440
WITHIN)</b></li>
<li>
</li>
<br>No check. Results vary depending on the specific problem.
<li>
<b>6.1.2033 POSTPONE or 6.2.2530 [COMPILE] applied to 6.2.2295 TO</b></li>
<li>
</li>
<br>The word is postponed correctly.
<li>
<b>string longer than a counted string returned by 6.1.2450 WORD</b></li>
<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>
<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>
</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>
<b>word not defined via 6.1.1000 CREATE (6.1.0550 >BODY, 6.1.1250 DOES>)</b></li>
<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.</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>
</li>
<br>Default is 16. Change by redefining FICL_MAX_LOCALS, defined in sysdep.h</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>
</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>
<b>name not defined by VALUE or LOCAL (13.6.1.2295 TO)</b></li>
<li>
</li>
<br>See the CORE ambiguous conditions, above (no change)</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>
</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.</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>
</li>
<br>Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS, declared
in sysdep.h
<li>
<b>minimum search order (16.6.1.2197 SET-ORDER, 16.6.2.1965 ONLY)</b> </li>
<li>
</li>
<br>Equivalent to <tt>FORTH-WORDLIST 1 SET-ORDER</tt></ul>
<h3>
Search Order Ambiguous conditions</h3>
<ul>
<li>
<b>changing the compilation word list (16.3.3 Finding definition names)</b></li>
<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>
<b>search order empty (16.6.2.2037 PREVIOUS)</b></li>
<li>
</li>
<br>Ficl prints an error message if the search order underflows, and resets
the order to its default state.
<li>
<b>too many word lists in search order (16.6.2.0715 ALSO)</b></li>
<li>
</li>
<br>Ficl prints an error message if the search order overflows, and resets
the order to its default state.</ul>
</td>
</tr>
</table>
<hr>
<p><a NAME="links"></a>
<p>For more information
<ul>
<li>
<a href="http://www.taygeta.com/ficl.html">Web home of ficl</a></li>
<li>
<b><a href="ftp://ftp.taygeta.com/pub/Forth/Compilers/native/misc/ficl204/ficl204.zip">Download
ficl 2.04</a></b></li>
<li>
<b><a href="ftp://ftp.taygeta.com/pub/Forth/Compilers/native/misc/ficl204/ficlwin.zip">Download
ficlWin</a> (not for resale. please contact me for resale license arrangements)</b></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</a></li>
<li>
<a href="http://www.taygeta.com/forthlit.html">Forth literature</a></li>
<ul>
<li>
<a href="http://www.softsynth.com/pforth/pf_tut.htm">Phil Burk's Forth
Tutorial</a></li>
<li>
<a href="http://www.taygeta.com/forth/dpans.html">Draft Proposed American
National Standard for Forth</a></li>
</ul>
<li>
<a href="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</li>
<li>
<a href="http://www.pagesz.net/~sessoms/debuffer/">Palm Pilot Debuffer</a>
(Eric Sessoms)</li>
<li>
<a href="http://www.swcp.com/~jchavez/osmond.html">Mac PC Board Layout
tool</a> (J Chavez)</li>
<li>
<a href="http://www.netcomsystems.com">NetCom Systems</a> ML7710 (Martin
Usher)</li>
</ul>
<hr>
<table BORDER=0 CELLSPACING=3 COLS=1 WIDTH="600" >
<tr>
<td>
<h2>
<a NAME="lawyerbait"></a>DISCLAIMER OF WARRANTY and LICENSE</h2>
<i>Ficl is freeware. Use it in any way that you like, with the understanding
that the code is not supported.</i>
<p>Any third party may reproduce, distribute, or modify the ficl software
code or any derivative works thereof without any compensation or license,
provided that the original author information and this disclaimer text
are retained in the source code files. The ficl software code is provided
on an "as is" basis without warranty of any kind, including, without limitation,
the implied warranties of merchantability and fitness for a particular
purpose and their equivalents under the laws of any jurisdiction.
<p>The FiclWin distribution, a derivative work of the ficl source code,
is hereby licensed for unrestricted non-commercial use under the ficl license
provided the user notifies the author (John Sadler) in writing or by electronic
mail or their intended use of the FiclWin sources. You may freely redistribute
the FiclWin distribution provided it contains this notice and adheres to
all other provisions of this license.
<p>Reselling the FiclWin source code, executable, or works derived from
the FiclWin source code is prohibited under this license. Please contact
me directly in order to discuss license terms for commercial use and distribution.
<p>I am interested in hearing from anyone who uses ficl. If you have a
problem, a success story, a defect, an enhancement request, or if you would
like to contribute to the ficl release, please <a href="mailto:john_sadler@alum.mit.edu">send
me email</a>. </td>
</tr>
</table>
</body>
</html>