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:
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)
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
is relatively quick thanks to its "switch-threaded" virtual
machine design and just in time compiling
is a complete and powerful programming language
has object oriented programming features that can be used to wrap
data structures or classes of the host system without altering themeven
if the host is mainly written in a non-OO language
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 adapter
for code written in C (or asm, Forth, C++...).
Ficl Design Goals
Target 32- and 64-bit processors
Scripting, prototyping, and extension language for systems
written also in C
Supportable—code is as transparent as I can make it
Interface to functions written in C
Conformant to the 1994 ANSI Standard for Forth (DPANS94)
Minimize porting effort—require an ANSI C runtime environment
and minimal glue code
Copyright (c) 1997-2001 John Sadler (email@example.com)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
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
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
send me email.
Simple to integrate into existing systems: the sample
implementation requires three Ficl function calls (see the example
program in main.c).
Written in ANSI C for portability.
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.
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)
Ficl and C/C++ can interact in two ways: Ficl can wrap C code,
and C functions can invoke Ficl code.
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.
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.
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.
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 Visual C++, and -ansi
under GCC. Ports to several other toolchains and operating systems
(notably FreeBSD and Linux flavors) exist.
Does full 32 bit math (but you need to implement two mixed
precision math primitives (see sysdep.c))
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 sysdep.h and sysdep.c and edit them to suit
your system. For example, INT16 is a short on some
compilers and an int on others. Check the default CELL
alignment controlled by FICL_ALIGN. If necessary, add new
definitions of ficlMalloc, ficlFree, ficlRealloc, and ficlTextOut
to work with your operating system. Finally, use testmain.c as
a guide to installing the ficl system and one or more virtual machines
into your code. You do not need to include testmain.c in your
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
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
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.
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 softcore. 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
make.bat to change the list of files that contribute to
To-Do List (target system dependent words)
Unimplemented system dependent CORE word: KEY
(implement this yourself if you need it)
Kludged CORE word: ACCEPT (implement this
better if you need to)
The following is a partial listing of functions that interface your
system or program to Ficl. For a complete listing, see ficl.h
(which is heavily commented). For examples, see main.c and the
FiclWin sources (below).
FICL_SYSTEM *ficlInitSystem(int nDictCells)
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)
void ficlTermSystem(FICL_SYSTEM *pSys)
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
int ficlBuild(FICL_SYSTEM *pSys, char *name, FICL_CODE code,
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)
int ficlExec(FICL_VM *pVM, char *text)
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).
int ficlExecC(FICL_VM *pVM, char *text, int nChars)
Same as ficlExec, but takes a count indicating the length of the
supplied string. Setting nChars to -1 is equivalent to ficlExec (expects
int ficlExecXT(FICL_VM *pVM, FICL_WORD *pFW)
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.
void ficlFreeVM(FICL_VM *pVM)
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.
FICL_VM *ficlNewVM(FICL_SYSTEM *pSys)
Create, initialize, and return a VM from the heap using
ficlMalloc. Links the VM into the system VM list for later reclamation
Enters a new double-cell constant into the environment dictionary
with the specified name and value.
FICL_DICT *ficlGetLoc(FICL_SYSTEM *pSys)
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 local
void ficlCompileCore(FICL_SYSTEM *pSys)
Defined in words.c, this function builds ficl's primitives.
void ficlCompileSoftCore(FICL_SYSTEM *pSys)
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.
Ficl Source Files
Declares most public functions and all data structures.
Includes sysdep.h and math.h
Declares system dependent functions and contains build
control macros. Edit this file to port to another system.
Declares functions for 64 bit math
System initialization, termination, and ficlExec
Adds precompiled definitions from the optional FLOAT word
set. Most of the file is conditioned on FICL_WANT_FLOAT
Implementation of 64 bit math words (except the two unsigned
primitives declared in sysdep.h and implemented in sysdep.c)
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.
Contains C implementations of several of the SEARCH and
SEARCH EXT words
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.
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.
Implementation of system dependent functions declared in
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
Contains C implementations of TOOLS and TOOLS EXT words, the
debugger, and debugger support words.
Virtual Machine methods
win32.c & unix.c
Platform extensions words loaded in ficl.c by
ficlCompilePlatform() - conditioned on FICL_WANT_PLATFORM
Exports ficlCompileCore(), the run-time dictionary builder,
and contains most precompiled CORE and CORE-EXT words.
You can precede a number with "0x", as in C, and it will be interpreted
as a hex value regardless of the value of BASE. Likewise,
numbers prefixed with "0d" will be interpreted as decimal values.
Note: ficl2.05 and later - this behavior is controlled by the prefix parser defined in prefix.c.
You can add other prefixes by defining handlers for them in ficl
The SEARCH wordset and Ficl
Ficl implements many of the search order words in terms of two
primitives called >SEARCH and SEARCH>. As their names
suggest (assuming you're familiar with Forth), they push and pop the
search order stack.
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 ABORT happens. This includes
stack underflows and overflows. QUIT does not affect the search
order. The minimum search order (set by ONLY) is equivalent
FORTH-WORDLIST 1 SET-ORDER
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).
Note: Ficl resets the search order whenever it does ABORT.
If you don't like this behavior, just comment out the
dictResetSearchOrder() lines in ficlExec().
>search ( wid -- )
Push wid onto the search order. Many of the other search
order words are written in terms of the SEARCH> and >SEARCH
primitives. This word can be defined in ANS Forth as follows
: >search >r get-order 1+ r> swap
search> ( -- wid )
Pop wid off the search order (can be coded in ANS Forth
as : search> get-order nip 1- set-order ; )
wid -- old-wid )
Set wid as compile wordlist, leaving the previous compile
wordlist on the stack
nBins "name" -- )
Creates a ficl-wordlist with the specified number of
hash table bins, binds it to the name, and associates the semantics of vocabulary
with it (replaces the top wid in the search order list with
its own wid when executed)
ficl-wordlist ( nBins
-- wid )
Creates a wordlist with the specified number of hash table bins,
and leaves the address of the wordlist on the stack. A ficl-wordlist
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. ficl-named-wordlist takes a name for the
wordlist and creates a word that pushes the wid. This is by
contrast to VOCABULARY, which also has a name, but replaces
the top of the search order with its wid.
forget-wid ( wid -- )
Iterates through the specified wordlist and unlinks all
definitions whose xt addresses are greater than or equal to the value of HERE,
the dictionary fill pointer.
hide ( -- current-wid-was
Push the hidden wordlist onto the search order, and set
it as the current compile wordlist (unsing ficl-set-current).
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 previous set-current
hidden ( -- wid )
Wordlist for storing implementation factors of ficl provided
words. To see what's in there, try: hide words previous
wid-get-name ( wid --
c-addr u )
Ficl wordlists (2.05 and later) have a name property that can be
assigned. This is used by ORDER to list the names of wordlists
in the search order.
wid-set-name ( c-addr
wid -- )
Ficl wordlists (2.05 and later) have a name property that can be
assigned. This is used by ORDER 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 brand-wordlist
wid-set-super ( wid
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 SEARCH-WORDLIST 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
user ( -- ) name
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 VARIABLEs
in all other respects (you use @ and ! on them, for example).
0 current-class !
-roll ( xu xu-1 ... x0 u -- x0 xu-1 ... x1
Rotate u+1 items on top of the stack after removing u. Rotation
is in the opposite sense to ROLL
-rot ( a b c -- c a b )
Rotate the top three stack entries, moving the top of stack to
third place. I like to think of this as 11/2swap
because it's good for tucking a single cell value behind a
cell-pair (like an object).
.env ( -- )
List all environment variables of the system
.hash ( -- )
List hash table performance statistics of the wordlist that's
first in the search order
.ver ( -- )
Display ficl version ID
>name ( xt -- c-addr u )
Convert a word's execution token into the address and length of
body> ( a-addr -- xt )
Reverses the effect of CORE word >body
(converts a parameter field address to an execution token)
Mark the most recently defined word as being executable only
while in compile state. Many immediate words have this
empty ( -- )
Empty the parameter stack
Synonym for THEN
last-word ( -- xt )
Pushes the xt address of the most recently defined word. This
applies to colon definitions, constants, variables, and words that use create.
You can print the name of the most recently defined word
last-word >name type
parse-word ( <spaces>name -- c-addr u )
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)
q@ ( addr -- x )
Fetch a 32 bit quantity from the specified address
q! ( x addr -- )
Store a 32 bit quantity to the specified address
w@ ( addr -- x )
Fetch a 16 bit quantity from the specified address
w! ( x addr -- )
Store a 16 bit quantity to the specified address (the low 16 bits
of the given value)
x. ( x -- )
Pop and display the value in hex format, regardless of the
current value of BASE
Extra words defined in testmain.c (Win32
and POSIX versions)
break ( -- )
Does nothing - just a handy place to set a debugger breakpoint
"directory-name<newline>" -- )
Executes the Win32 chdir() function, changing the program's
clock ( -- now )
Wrapper for the ANSI C clock() function. Returns the number of
clock ticks elapsed since process start.
clocks/sec ( --
Pushes the number of ticks in a second as returned by clock
"filename<newline>" -- )
Opens the Forth source file specified and loads it one line at a
time, like INCLUDED (FILE)
pwd ( -- )
Prints the current working directory as set by cd
system ( "command<newline>" -- )
Issues a command to a shell; implemented with the Win32 system()
spewhash ( "filename<newline>" -- )
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.
Words defined in FiclWin only
!oreg ( c -- )
Set the value of the simulated LED register as specified (0..255)
@ireg ( -- c )
Gets the value of the simulated switch block (0..255)
!dac ( c -- )
Sets the value of the bargraph control as specified. Valid values
range from 0..255
@adc ( -- c )
Fetches the current position of the slider control. Range is
status" ( "ccc<quote>" -- )
Set the mainframe window's status line to the text specified, up
to the first trailing quote character.
Causes the running virtual machine to sleep() for the number of
milliseconds specified by the top-of-stack value.
ANS Required Information
ANS Forth System Providing names from the Core Extensions word set Providing the Exception word set Providing names from the Exception Extensions word set Providing the Locals word set Providing the Locals Extensions word set Providing the Memory Allocation word set Providing the Programming-Tools word set Providing names from the Programming-Tools Extensions word set Providing the Search-Order word set Providing the Search-Order Extensions word set
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.
aligned address requirements (126.96.36.199 Addresses);
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 ALIGN and ALIGNED to align on 4
byte boundaries. To align on 2n byte boundaries, set
FICL_ALIGN to n.
behavior of 6.1.1320 EMIT for non-graphic characters;
Depends on target system, C runtime library,
and your implementation of ficlTextOut().
character editing of 6.1.0695 ACCEPT and 6.2.1390 EXPECT;
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.
character set (3.1.2 Character types, 6.1.1320 EMIT, 6.1.1750
Depends on target system and implementation
No special processing is performed on
characters beyond case-folding. Therefore, extended characters will not
match their unaccented counterparts.
conditions under which control characters match a space
delimiter (188.8.131.52 Delimiters);
Ficl uses the Standard C function isspace()
to distinguish space characters. The rest is up to your library vendor.
format of the control-flow stack (184.108.40.206 Control-flow stack);
Uses the data stack
conversion of digits larger than thirty-five (220.127.116.11 Digit
The maximum supported value of BASE
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, however, other than possibly
display after input terminates in 6.1.0695 ACCEPT and
Target system dependent
exception abort sequence (as in 6.1.0680 ABORT");
input line terminator (18.104.22.168 User input device);
Target system dependent (implementation of
outer loop that calls ficlExec)
maximum size of a counted string, in characters (22.214.171.124
Counted strings, 6.1.2450 WORD);
maximum size of a parsed string (3.4.1 Parsing);
Limited by available memory and the maximum unsigned value that can fit
in a CELL (232-1).
maximum size of a definition name, in characters (126.96.36.199
Ficl stores the first 31 characters of a
maximum string length for 6.1.1345 ENVIRONMENT?, in characters;
Same as maximum definition name length
method of selecting 188.8.131.52 User input device;
None supported. This is up to the target system
method of selecting 184.108.40.206 User output device;
None supported. This is up to the target system
methods of dictionary compilation (3.3 The Forth dictionary);
number of bits in one address unit (220.127.116.11 Addresses);
Target system dependent. Ficl generally
supports processors that can address 8 bit quantities, but there is no
dependency that I'm aware of.
number representation and arithmetic (18.104.22.168 Internal number
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
ranges for n, +n, u, d, +d, and ud (3.1.3 Single-cell types,
3.1.4 Cell-pair types);
Assuming a 32 bit implementation, range for signed single-cell values
is -231..231-1. Range for unsigned single cell
values is 0..232-1. Range for signed double-cell
values is -263..263-1. Range for unsigned single
cell values is 0..264-1.
read-only data-space regions (3.3.3 Data space);
size of buffer at 6.1.2450 WORD (22.214.171.124 Other transient
Default is 255. Depends on the setting of nPAD in ficl.h.
size of one cell in address units (3.1.3 Single-cell types);
System dependent, generally four.
size of one character in address units (3.1.2 Character types);
System dependent, generally one.
size of the keyboard terminal input buffer (126.96.36.199 Input
This buffer is supplied by the host program.
Ficl imposes no practical limit.
size of the pictured numeric output string buffer (188.8.131.52
Other transient regions);
Default is 255 characters. Depends on the setting of nPAD in
size of the scratch area whose address is returned by
6.2.2000 PAD (184.108.40.206 Other transient regions);
Not presently supported
system case-sensitivity characteristics (3.4.2 Finding
Ficl is not case sensitive
system prompt (3.4 The Forth text interpreter, 6.1.2050 QUIT);
type of division rounding (220.127.116.11 Integer division, 6.1.0100
*/, 6.1.0110 */MOD, 6.1.0230 /, 6.1.0240 /MOD, 6.1.1890 MOD);
values of 6.1.2250 STATE when true;
One (no others)
values returned after arithmetic overflow (18.104.22.168 Other
System dependent. Ficl makes no special checks for overflow.
whether the current definition can be found after 6.1.1250
DOES> (6.1.0450 :).
No. Definitions are unsmudged after ; only,
and only then if no control structure matching problems have been
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.
The following general ambiguous conditions could occur because of a
combination of factors:
a name is neither a valid definition name nor a valid number
during text interpretation (3.4 The Forth text interpreter);
Ficl does ABORT and prints the name
followed by " not found".
a definition name exceeded the maximum length allowed
(22.214.171.124 Definition names);
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.
addressing a region not listed in 3.3.3 Data Space;
No problem: all addresses in ficl are
absolute. You can reach any 32 bit address in Ficl's address space.
argument type incompatible with specified input parameter,
e.g., passing a flag to a word expecting an n (3.1 Data types);
Ficl makes no check for argument type
compatibility. Effects of a mismatch vary widely depending on the
specific problem and operands.
attempting to obtain the execution token, (e.g., with
6.1.0070 ', 6.1.1550 FIND, etc.) of a definition with undefined
Ficl returns a valid token, but the result of
executing that token while interpreting may be undesirable.
Results are target procesor dependent.
Generally, Ficl makes no check for divide-by-zero. The target processor
will probably throw an exception.
insufficient data-stack space or return-stack space (stack
With FICL_ROBUST (sysdep.h) set >= 2, most
parameter stack operations are checked for underflow and overflow. Ficl
does not check the return stack.
insufficient space for loop-control parameters;
No check - Evil results.
insufficient space in the dictionary;
Ficl generates an error message if the
dictionary is too full to create a definition header. It checks ALLOT
as well, but it is possible to make an unchecked allocation
request that overflows the dictionary.
interpreting a word with undefined interpretation semantics;
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 EXECUTE, though.
modifying the contents of the input buffer or a string
literal (126.96.36.199 Text-literal regions, 188.8.131.52 Input buffers);
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
overflow of a pictured numeric output string;
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.
parsed string overflow;
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 SLITERAL, you
need to have enough room for the string, otherwise bad things may
happen. This is not usually a problem.
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, 184.108.40.2060 M*/);
Value will be truncated
reading from an empty data stack or return stack (stack
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.
unexpected end of input buffer, resulting in an attempt to
use a zero-length string as a name;
Ficl returns for a new input buffer until a
non-empty one is supplied.
The following specific ambiguous conditions are noted in the glossary
entries of the relevant words:
>IN greater than size of input buffer (3.4.1 Parsing)
Bad Things occur - unpredictable bacause the input buffer is supplied
by the host program's outer loop.
6.1.2120 RECURSE appears after 6.1.1250 DOES>
It finds the address of the definition before DOES>
argument input source different than current input source for
data space containing definitions is de-allocated (220.127.116.11
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.
data space read/write with incorrect alignment (18.104.22.168
data-space pointer not properly aligned (6.1.0150 ,, 6.1.0860
See above on data space read/write alignment
less than u+2 stack items (6.2.2030 PICK, 6.2.2150 ROLL)
Ficl detects a stack underflow and reports it, executing ABORT,
as long as FICL_ROBUST is two or larger.
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)
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.
most recent definition does not have a name (6.1.1710
name not defined by 6.2.2405 VALUE used by 6.2.2295 TO
Ficl's version of TO works correctly with VALUEs, CONSTANTs
name not found (6.1.0070 ', 6.1.2033 POSTPONE, 6.1.2510 ['],
Ficl prints an error message and does ABORT
parameters are not of the same type (6.1.1240 DO, 6.2.0620
?DO, 6.2.2440 WITHIN)
No check. Results vary depending on the specific problem.
6.1.2033 POSTPONE or 6.2.2530 [COMPILE] applied to 6.2.2295 TO
The word is postponed correctly.
string longer than a counted string returned by 6.1.2450 WORD
Ficl stores the first FICL_STRING_MAX-1 chars in the destination
buffer. (The extra character is the trailing space required by the
u greater than or equal to the number of bits in a cell
(6.1.1805 LSHIFT, 6.1.2162 RSHIFT)
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
word not defined via 6.1.1000 CREATE (6.1.0550 >BODY,
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)
Don't. CREATE reserves a field in words it builds for DOES>to
fill in. If you use DOES> on a word not made by CREATE,
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.
Locals Implementation-defined options
maximum number of locals in a definition (13.3.3 Processing
locals, 22.214.171.1245 LOCALS|)
Default is 16. Change by redefining FICL_MAX_LOCALS, defined in
Locals Ambiguous conditions
executing a named local while in interpretation state
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
name not defined by VALUE or LOCAL (126.96.36.1995 TO)
See the CORE ambiguous conditions, above (no change)
Programming Tools Implementation-defined options
source and format of display by 188.8.131.524 SEE
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.
Search Order Implementation-defined options
maximum number of word lists in the search order (16.3.3
Finding definition names, 184.108.40.2067 SET-ORDER)
Defaults to 16. Can be changed by redefining FICL_DEFAULT_VOCS,
declared in sysdep.h
minimum search order (220.127.116.117 SET-ORDER, 18.104.22.1685 ONLY)
Equivalent to FORTH-WORDLIST 1 SET-ORDER
Search Order Ambiguous conditions
changing the compilation word list (16.3.3 Finding definition
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 new compile wordlist.
search order empty (22.214.171.1247 PREVIOUS)
Ficl prints an error message if the search order underflows, and resets
the order to its default state.
too many word lists in search order (16.6.2.0715 ALSO)
Ficl prints an error message if the search order overflows, and resets
the order to its default state.