ref: 33880546bb44783dffbe3ef58a0068daab7355f6
parent: 25cb3c9b645d3b3e1a74a7a931df4602ff014c69
author: asau <asau@ficl.sf.net>
date: Thu Aug 12 08:38:15 CDT 2010
Merge FICL 4.0.31.
--- a/Makefile.linux
+++ b/Makefile.linux
@@ -1,5 +1,5 @@
-OBJECTS= dict.o ficl.o fileaccess.o float.o math64.o prefix.o search.o softcore.o stack.o sysdep.o tools.o unix.o vm.o words.o
-HEADERS= ficl.h math64.h sysdep.h
+OBJECTS= dictionary.o system.o fileaccess.o float.o double.o prefix.o search.o softcore.o stack.o tools.o vm.o primitives.o bit.o lzuncompress.o unix.o utility.o hash.o callback.o word.o extras.o
+HEADERS= ficl.h ficlplatform/unix.h
#
# Flags for shared library
TARGET= -Dlinux # riscos MOTO_CPU32
@@ -9,11 +9,11 @@
LIB = ar cr
RANLIB = ranlib
-MAJOR = 3
-MINOR = 0.1
+MAJOR = 4
+MINOR = 0.31
-ficl: testmain.o ficl.h sysdep.h libficl.a
- $(CC) testmain.o -o ficl -L. -lficl -lm
+ficl: main.o $(HEADERS) libficl.a
+ $(CC) main.o -o ficl -L. -lficl -lm
lib: libficl.so.$(MAJOR).$(MINOR)
@@ -28,9 +28,12 @@
-o libficl.so.$(MAJOR).$(MINOR) $(OBJECTS)
ln -sf libficl.so.$(MAJOR).$(MINOR) libficl.so
-testmain: testmain.o ficl.h sysdep.h libficl.so.$(MAJOR).$(MINOR)
- $(CC) testmain.o -o testmain -L. -lficl -lm
+main: main.o ficl.h sysdep.h libficl.so.$(MAJOR).$(MINOR)
+ $(CC) main.o -o main -L. -lficl -lm
ln -sf libficl.so.$(MAJOR).$(MINOR) libficl.so.$(MAJOR)
+
+unix.o: ficlplatform/unix.c $(HEADERS)
+ $(CC) $(CFLAGS) -c ficlplatform/unix.c
#
# generic object code
--- a/Makefile.riscos
+++ /dev/null
@@ -1,20 +1,0 @@
-OBJECTS= dict.o ficl.o fileaccess.o float.o math64.o prefix.o search.o softcore.o stack.o sysdep.o tools.o unix.o vm.o words.o
-HEADERS= ficl.h math64.h sysdep.h
-#
-# Flags for shared library
-CFLAGS= -O -c -mstubs -D__UNAME
-CC=gcc
-LIB = makealf -qls -o
-
-MAJOR = 3
-MINOR = 0.0
-
-lib: o.libficl
-
-ficl: testmain.o ficl.h sysdep.h o.libficl
- $(CC) testmain.o -o ficl -L. -lficl -lm
-
-# static library build
-o.libficl: $(OBJECTS)
- $(LIB) o.libficl $(OBJECTS)
-
--- a/ReadMe.txt
+++ b/ReadMe.txt
@@ -1,367 +1,51 @@
-rel 3.02 -- December 2001
-
-Fixed a bug in "environment?" - was ignoring the length of the supplied string.
-"my=[" detects object members (using ?object) and assumes all other members leave class unchanged
-Added "objectify" and "?object" for use by OO infrastructure
-Ficl OO tutorial expanded and revised. Thanks to David McNab for his demo and suggestions.
-Consolidated context and pExtend pointers of FICL_SYSTEM - VM's pExtend pointer
- is initialized from the copy in FICL_SYSTEM upon VM creation.
-Ficlwin character handling is more robust
-SEE improvements - SEE (and consequently DEBUG) have improved source listings
- with instruction offsets
-Corrected various bugs in docs.
-Added ficl-ized version of JV Noble's Forth Primer
-Ficlwin uses multi-system constructs (see ficlthread.c)
-MEMORY-EXT environment variable removed (there is no such wordset)
-
-rel 3.01 -- October 2001
-
-Major contribs by Larry Hastings (larry@hastings.org)
-- FILE wordset
-- ficlEvaluate wrapper for ficlExec
-- ficlInitSystemEx makes it possible to bind selectable properties to VMs at create time
-- softcore.py (python version)
-
-Environment contains ficl-version (double)
-?number handles trailing decimal point per DOUBLE wordset spec
-
-Fixed broken .env (thanks to Leonid Rosin for spotting this goof)
-Fixed broken floating point words that depended on evaluation order of stack pops.
-env-constant
-env-2constant
-dictHashSummary is now commented out unless FICL_WANT_FLOAT (thanks to Leonid Rosin again)
-
-Thanks to David McNab for pointing out that .( should be IMMEDIATE. Now it is.
-
-rel 3.00a -- July 2001
-
-- Fixed broken oo.fr by commenting out vcall stuff using FICL_WANT_VCALL.
- Vcall is still broken.
-
-
-rel 3.00 -- June 2001
-
-- Added pSys parameter to most ficlXXXX functions - multiple system support
- dictLookupLoc renamed to ficlLookupLoc after addition of pSys param
- ficlInibtSystem returns a FICL_SYSTEM*
- ficlTermSystem
- ficlNewVM
- ficlLookup
- ficlGetDict
- ficlGetEnv
- ficlSetEnv
- ficlSetEnvD
- ficlGetLoc
- ficlBuild
-
-- Fixed off-by-one bug in ficlParsePrefix
-- Ficl parse-steps now work correctly - mods to interpret()
-- Made tools.c:isAFiclWord more selective
-- Tweaked makefiles and code to make gcc happy under linux
-- Vetted all instances of LVALUEtoCELL to make sure they're working on CELL sized operands
- (for 64 bit compatibility)
-- Doc updates
-
-rel 2.06 -- May 2001 (feast or famine around here)
-
-- Debugger changes:
- New debugger command "x" to execute the rest of the command line as ficl
- New debugger command "l" lists the source of the innermost word being debugged
- If you attempt to debug a primitive, it gets executed rather than doing nothing
- r.s displays the stack contents symbolically
-- Debugger now runs correctly under ficlwin.
-- SEE listing enhanced for use with the debugger
-- Added Guy Carver's changes to oo.fr for VTABLE support
-- float.c words f> and >f to move floats to and from the param stack, analogous to >r and r>
-- LOOKUP - Surrogate precompiled parse step for ficlParseWord (this step is hard
- coded in INTERPRET)
-- License text at top of source files changed from LGPL to BSD by request
-- Win32 console version now handles exceptions more gracefully rather than crashing - uses win32
- structured exception handling.
-- Fixed BASE bug from 2.05 (was returning the value rather than the address)
-- Fixed ALLOT bug - feeds address units to dictCheck, which expects Cells. Changed dictCheck
- to expect AU.
-- Float stack display word renamed to f.s from .f to be consistent with r.s and .s
-
-
-rel 2.05 -- April 2001
-
-This is a transitional release, but it adds a lot of new features.
-Ficl 3.0 will change the API to allow multiple concurrent FICL_SYSTEMs.
-This involves the addition of a single parameter to several functions
-(the parameter is a pointer to a FICL_SYSTEM).
-
-* Thanks to everyone who contributed fixes and features for this release! Especially
-* Guy Carver, Orjan Gustafson, Larry Hastings, Daniel Sobral, and Reuben Thomas.
-
-- HTML documentation extensively revised
-- Simple source debugger -- see tools.c
-- The text interpreter is now extensible - this is accomplished through the use
- of ficlAddParseStep. FICL_MAX_PARSE_STEPS limits the number of parse steps
- (default: 8). You can write a precompiled parse step (see ficlParseNumber) and
- append it to the chain, or you can write one in ficl and use ADD-PARSE-STEP
- to append it. Default parse steps are initialized in ficlInitSystem. You can list
- the parse steps with parse-order ( -- ).
-- There is now a FICL_SYSTEM structure. This is a transitional release - version 3.0
- will alter several API prototypes to take this as a parameter, allowing multiple
- systems per process (and therefore multiple dictionaries). For those who use ficl
- under a virtual memory O/S like Linux or Win NT, you can just create multiple ficl
- processes (not threads) instead and save youself the wait.
-- Fixes for improved command line operation in testmain.c (Larry Hastings)
-- Numerous extensions to OO facility, including a new allot methods, ability
- to catch method invocations (thanks to Daniel Sobral again)
-- Incorporated Alpha (64 bit) patches contributed by Daniel Sobral and the freeBSD team
- Ficl is now 64 bit friendly! UNS32 is now FICL_UNS.
-- Split SEARCH and SEARCH EXT words from words.c to search.c
-- ABORT" now complies with the ANS (-2 THROWs)
-- 2LOCALS defined in jhlocal syntax now lose the "2:" in their names. See ficl_loc.html
-- Floating point support contributed by Guy Carver (Enable FICL_WANT_FLOAT in sysdep.h).
-- Win32 vtable model for objects (Guy Carver)
-- Win32 dll load/call suport (Larry Hastings)
-- Prefix support (Larry Hastings) (prefix.c prefix.fr FICL_EXTENDED_PREFIX) makes it
- easy to extend the parser to recignize prefixes like 0x and act on them. Use show-prefixes
- to see what's defined.
-- Cleaned up initialization sequence so that it's all in ficlInitSystem
-
-Ficl words
-- ABORT" and REFILL fixed (thanks to Daniel Sobral)
-- ANS CORE EXT words: 2r@ 2r> 2>r
-- Numerous ANS FLOAT and FLOAT EXT words (Larry Carver) -- see float.c
-- ANS DOUBLE words: 2variable
-- .S now displays all stack entries on one line, like a stack comment
-- wid-get-name ( -- c-adr u )
- given a wid, returns the address and count of its name. If no name, count is 0
-- wid-set-name ( c-addr -- )
- set optional wid name pointer to the \0 terminated string address specified.
-- ficl-named-wordlist ( -- wid ) "name"
- creates a ficl-wordlist and names it
-- last-word ( -- xt )
- returns the xt of the word being defined or most recently defined.
-- q@ and q! operate on quadbyte quantities for 64 bit friendliness
-- add-parse-step ( xt -- )
- Allows the parser to be extended. To create a parse step, define a word that
- consumes a counted string from the stack and returns (minimally) a flag. Once installed in the
- parse chain, this word will be called when the previous steps in the chain have failed to
- parse the current token. Upon entry, the token's address and count will be on the stack.
- If the parse step succeeds in parsing the token, it should apply whatever semantics the token
- requires, then push FICL_TRUE on the stack. If it fails, the step should push FICL_FALSE.
- To install the parse step, use add-parse-step passing it the xt of the new parse step.
- Add-parse-step may fail silently if the parse list is full. You can confirm success using
- parse-order ( -- ).
-- (parse-step) ( c-addr u -- ??? flag )
- Runtime support for precompiled parse steps (see ficl.c: AddPrecompiledParseStep)
-- env-constant ( u -- ) "name"
-- env-2constant ( ud -- ) "name"
- set environment values from Ficl. Use .env ( -- ) to view defined symbols
- in the environment, or environment? (CORE) to find their values.
-
-softcore.fr words
-- ORDER now lists wordlists by name
-- ficl-named-wordlist
-- brand-wordlist
-
-New OO stuff
-- Double width locals - prefix a local name with "2:" and it is automatically
- created as a double cell local. Handy for objects. Example:
- : method { 2:this -- } this --> do-nothing ;
-- Class methods ALLOT and ALLOT-ARRAY
-- METHOD define method names globally
-- my=> early bind a method call to "this" class
-- my=[ ] early bind a string of method calls to "this" class and obj members
-- c-> late bind method invocation with CATCH
-- metaclass method RESUME-CLASS and instance word SUSPEND-CLASS to create
- mutually referring classes. Example in string.fr
-- early binding words are now in the instance-vars wordlist,
- not visible unless defining a class.
-- string.fr enhanced for dynamic allocation and resize of string contents
-
-
-rel 2.04 -- May 2000
-ficlwin:
-- Catches exceptions thrown by VM in ficlThread (0 @ for example) rather than
- passing them off to the OS.
-
-ficl bugs vanquished
-- Fixed leading delimiter bugs in s" ." .( and ( (reported by Reuben Thomas)
-- Makefile tabs restored (thanks to Michael Somos)
-- ABORT" now throws -2 per the DPANS (thanks to Daniel Sobral for sharp eyes again)
-- ficlExec does not print the prompt string unless (source-id == 0)
-- Various fixes from the FreeBSD team
-
-ficl enhancements
-- 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)
-- Added function vmGetStringEx with a flag to specify whether or not to
- skip lead delimiters
-- Added non-std word: number?
-- Added CORE EXT word AGAIN (by request of Reuben Thomas)
-- Added double cell local (2local) support
-- 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)
-- C-string class revised and enhanced - now dynamically sized
-- C-hashstring class derived from c-string computes hashcode too.
-
-rel 2.03 -- April 1999
-
-ficlwin:
-- Edit paste works more sensibly if there's already text on the
- line being appended to...
-- File Menu: recent file list and Open now load files.
-- Text ouput function is now faster through use of string
- caching. Cache flushes at the end of each line and each
- time ficlExec returns.
-- Edit/paste now behaves more reasonably for text. File/open
- loads the specified file.
-- Registry entries specify dictionary and stack sizes. See
- HKEY_CURRENT_USER/Software/CodeLab/ficlwin/Settings
-
-testmain:
-- Added CLOCK ( -- u) , wrapper for the ANSI C clock() function.
- Returns the number of clock ticks elapsed since process start.
-- MSEC renamed to MS (in line with the ANS)
-- Added CLOCKS/SEC ( -- u) , wrapper for ANSI C CLOCKS_PER_SEC
- constant
-- Changed gets() in testmain to fgets() to appease the security gods.
-
-
-Data structures are now 64 bit friendly.
-
-oo.fr: Added alloc and alloc-array methods of METACLASS to
-allocate objects and arrays of objects from the heap. Free method
-of OBJECT frees the storage. (requires MEMORY wordset)
-
-Added CORE EXT word WITHIN
-Added DOUBLE word DNEGATE
-
-Added ficlSetStackSize to specify param and return stack sizes. See ficl.h
-
-Added ficlExecXT in ficl.c/h - executes a FICL_WORD given its address.
-
-Added Michael Gauland's ficlLongMul and ficlLongDiv and support
-routines to math64.c and .h. These routines are coded in C, and are
-compiled only if PORTABLE_LONGMULDIV == 1 (default is 0).
-
-Added definition of ficlRealloc to sysdep.c (needed for memory
-allocation wordset). If your target OS supports realloc(),
-you'll probably want to redefine ficlRealloc in those terms.
-The default version does ficlFree followed by ficlMalloc.
-
-[Thanks to Daniel Sobral of FreeBSD for suggesting or implementing
-the next six changes!]
-- Added CATCH and THROW (EXCEPTION word set)
-- Added MEMORY allocation word set. Requires ficlRealloc
-- EVALUATE respects count parameter, and also passes exceptional
- return conditions back out to the calling instance of ficlExec.
-- VM_QUIT clears locals dictionary in ficlExec()
-- ficlExec pushes ip and executes interpret at the right times so that
- nested calls to ficlExec behave the way you'd expect them to.
-- Control word match check upgraded. Control structure mismatches
- are now errors, not warnings, since the check accepts all
- syntactally legal constructs.
-
-Added vmInnerLoop to vm.h. This function/macro factors the inner
-interpreter out of ficlExec so it can be used in other places.
-Function/macro behavior is conditioned on INLINE_INNER_LOOP
-in sysdep.h. Default: 1 unless _DEBUG is set. In part, this is because
-VC++ 5 goes apoplectic when trying to compile it as a function. See
-comments in vm.c
-
-Bug fix in isNumber(): used to treat chars between 'Z' and 'a'
-as valid in base 10... (harmless, but weird) (Ficl Finger of Fate
-award to Phil Martel for this one ;-) )
-
-softcore.pl now removes comments, spaces at the start and
- end of lines. As a result:
- sizeof (softWords) == 7663 bytes (used to be 20000)
- and consumes 11384 bytes of dictionary when compiled
- (so it's cheaper to store as text than code, for the
- memory-conscious)
-
-Deleted 3Com license paste-o in this file (oops)
-
-rel 2.02 -- 17 October 1998
-
-Changed ficlExec so that the search order really does get reset
-on an ERREXIT as advertised.
-
-marker ( "name" -- )
-forget ( "name" -- )
-forget-wid ( wid -- )
-
-SOURCE-ID is now equal to the (<>0) file id when loading a file
-(Win32 only), and -1 when doing EVALUATE. This means that
-REFILL now works correctly when loading a file...
-Win32 LOAD command (oops) now complies with the FILE wordset
-specification of FILE-INCLUDE (REFILL returns FALSE at EOF)
-
-ficl-wordlist ( nBins -- wid )
- Creates a hashed wordlist with the number of bins specified.
- Best hash performance if nBins is prime!
-ficl-vocabulary ( nBins "name" -- )
- Uses ficl-wordlist to make a vocabulary with the given name
- and number of hash bins
-
-:NONAME (bug fix) no longer pushes control marker for colon and
- exec token in wrong order.
-WORDS ignores :noname (anonymous) definitions
-
-dictUnsmudge no longer links anonymous definitions into the hash
-
-HIDE ( -- wid-was )
-new wordlist called HIDDEN and word HIDE for keeping execution
-factors from cluttering the default namespace any worse than it
-already is... HIDE sets HIDDEN as the compile wordlist and pushes
-it onto the search order. When finished compiling execution factors,
-a call to SET-CURRENT restores the previous compile wordlist. When
-finished compiling words that use the execution factors, use PREVIOUS
-to restore the prior search order.
-
-Added (my current understanding of) the Johns Hopkins local syntax
-in file softwords/jhlocal.fr. This is in the default version of softcore.c
-instead of the previous {{ }} local syntax. That syntax is still available
-in softwords/ficllocal.fr if you want it instead. Ficl's implementation
-of the Johns Hopkins local syntax:
- { a b c | d -- e f }
- ^^^^^ ^ ^^ this is a comment
- ||||| \ this local is cleared initially
- \\\\\ these come off the stack in the correct order
-
-A, b, and c are initialized off the stack in right to left order
-(c gets the top of stack). D is initialized to zero. E and f are
-treated as comments. The | and -- delimiters are optional. If they
-appear, they must appear once only, and in the order shown.
-
-
-OOP vocabulary - no longer in the search order at startup.
-No longer default compile voc at startup
-
-oo.fr
-
-Revised to make more extensive use of early binding for speed.
-
-META (constant) pushes the address of METACLASS. This word is
- not immediate. Makes it easier to deal with early binding of
- class methods.
-
-object::init now uses metaclass::get-size explicitly rather
- than object::size.
-
-classes.fr
-
-Added c-ptr base class for all pointer classes. derived
- c-cellPtr, c-bytePtr, and c-wordPtr from c-ptr. These
- classes model pointers to raw scalar types.
-
-
-rel 2.01
-18 sep 98 -- (local) changed so that it does not leave anything
-on the stack after it runs (previously left a marker after the
-first local, consumed it after the last local). Marker is now
-a static of (local).
-
-Added {{ -- }} local syntax with variable reordering
-
-
-
-
+FICL 4.0.31
+June 2003
+
+________
+OVERVIEW
+
+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. Ficl stands for "Forth Inspired
+Command Language".
+
+For more information, please see the "doc" directory.
+For release notes, please see "doc/releases.html".
+
+____________
+INSTALLATION
+
+Ficl builds out-of-the-box on the following platforms:
+ * Linux: use "Makefile.linux".
+ * Win32: use "ficl.dsw" / "ficl.dsp".
+To port to other platforms, we suggest you start with the Linux
+makefile and the "unix.c" / "unix.h" platform-specific implementation
+files. (And please--feel free to submit your portability changes!)
+
+(Note: Ficl used to build under RiscOS, but we broke everything
+for the 4.0 release. Please fix it and send us the diffs!)
+
+____________
+FICL LICENSE
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.
+
--- a/dict.c
+++ /dev/null
@@ -1,836 +1,0 @@
-/*******************************************************************
-** d i c t . c
-** Forth Inspired Command Language - dictionary methods
-** Author: John Sadler (john_sadler@alum.mit.edu)
-** Created: 19 July 1997
-** $Id: dict.c,v 1.14 2001/12/05 07:21:34 jsadler Exp $
-*******************************************************************/
-/*
-** This file implements the dictionary -- FICL's model of
-** memory management. All FICL words are stored in the
-** dictionary. A word is a named chunk of data with its
-** associated code. FICL treats all words the same, even
-** precompiled ones, so your words become first-class
-** extensions of the language. You can even define new
-** control structures.
-**
-** 29 jun 1998 (sadler) added variable sized hash table support
-*/
-/*
-** Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
-** All rights reserved.
-**
-** Get the latest Ficl release at http://ficl.sourceforge.net
-**
-** 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
-** contact me by email at the address above.
-**
-** L I C E N S E and D I S C L A I M E R
-**
-** Redistribution and use in source and binary forms, with or without
-** modification, are permitted provided that the following conditions
-** are met:
-** 1. Redistributions of source code must retain the above copyright
-** notice, this list of conditions and the following disclaimer.
-** 2. Redistributions in binary form must reproduce the above copyright
-** notice, this list of conditions and the following disclaimer in the
-** documentation and/or other materials provided with the distribution.
-**
-** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-** SUCH DAMAGE.
-*/
-
-#include <stdlib.h>
-#include <stdio.h> /* sprintf */
-#include <string.h>
-#include <ctype.h>
-#include "ficl.h"
-
-static char *dictCopyName(FICL_DICT *pDict, STRINGINFO si);
-
-/**************************************************************************
- d i c t A b o r t D e f i n i t i o n
-** Abort a definition in process: reclaim its memory and unlink it
-** from the dictionary list. Assumes that there is a smudged
-** definition in process...otherwise does nothing.
-** NOTE: this function is not smart enough to unlink a word that
-** has been successfully defined (ie linked into a hash). It
-** only works for defs in process. If the def has been unsmudged,
-** nothing happens.
-**************************************************************************/
-void dictAbortDefinition(FICL_DICT *pDict)
-{
- FICL_WORD *pFW;
- ficlLockDictionary(TRUE);
- pFW = pDict->smudge;
-
- if (pFW->flags & FW_SMUDGE)
- pDict->here = (CELL *)pFW->name;
-
- ficlLockDictionary(FALSE);
- return;
-}
-
-
-/**************************************************************************
- a l i g n P t r
-** Aligns the given pointer to FICL_ALIGN address units.
-** Returns the aligned pointer value.
-**************************************************************************/
-void *alignPtr(void *ptr)
-{
-#if FICL_ALIGN > 0
- char *cp;
- CELL c;
- cp = (char *)ptr + FICL_ALIGN_ADD;
- c.p = (void *)cp;
- c.u = c.u & (~FICL_ALIGN_ADD);
- ptr = (CELL *)c.p;
-#endif
- return ptr;
-}
-
-
-/**************************************************************************
- d i c t A l i g n
-** Align the dictionary's free space pointer
-**************************************************************************/
-void dictAlign(FICL_DICT *pDict)
-{
- pDict->here = alignPtr(pDict->here);
-}
-
-
-/**************************************************************************
- d i c t A l l o t
-** Allocate or remove n chars of dictionary space, with
-** checks for underrun and overrun
-**************************************************************************/
-int dictAllot(FICL_DICT *pDict, int n)
-{
- char *cp = (char *)pDict->here;
-#if FICL_ROBUST
- if (n > 0)
- {
- if ((unsigned)n <= dictCellsAvail(pDict) * sizeof (CELL))
- cp += n;
- else
- return 1; /* dict is full */
- }
- else
- {
- n = -n;
- if ((unsigned)n <= dictCellsUsed(pDict) * sizeof (CELL))
- cp -= n;
- else /* prevent underflow */
- cp -= dictCellsUsed(pDict) * sizeof (CELL);
- }
-#else
- cp += n;
-#endif
- pDict->here = PTRtoCELL cp;
- return 0;
-}
-
-
-/**************************************************************************
- d i c t A l l o t C e l l s
-** Reserve space for the requested number of cells in the
-** dictionary. If nCells < 0 , removes space from the dictionary.
-**************************************************************************/
-int dictAllotCells(FICL_DICT *pDict, int nCells)
-{
-#if FICL_ROBUST
- if (nCells > 0)
- {
- if (nCells <= dictCellsAvail(pDict))
- pDict->here += nCells;
- else
- return 1; /* dict is full */
- }
- else
- {
- nCells = -nCells;
- if (nCells <= dictCellsUsed(pDict))
- pDict->here -= nCells;
- else /* prevent underflow */
- pDict->here -= dictCellsUsed(pDict);
- }
-#else
- pDict->here += nCells;
-#endif
- return 0;
-}
-
-
-/**************************************************************************
- d i c t A p p e n d C e l l
-** Append the specified cell to the dictionary
-**************************************************************************/
-void dictAppendCell(FICL_DICT *pDict, CELL c)
-{
- *pDict->here++ = c;
- return;
-}
-
-
-/**************************************************************************
- d i c t A p p e n d C h a r
-** Append the specified char to the dictionary
-**************************************************************************/
-void dictAppendChar(FICL_DICT *pDict, char c)
-{
- char *cp = (char *)pDict->here;
- *cp++ = c;
- pDict->here = PTRtoCELL cp;
- return;
-}
-
-
-/**************************************************************************
- d i c t A p p e n d W o r d
-** Create a new word in the dictionary with the specified
-** name, code, and flags. Name must be NULL-terminated.
-**************************************************************************/
-FICL_WORD *dictAppendWord(FICL_DICT *pDict,
- char *name,
- FICL_CODE pCode,
- UNS8 flags)
-{
- STRINGINFO si;
- SI_SETLEN(si, strlen(name));
- SI_SETPTR(si, name);
- return dictAppendWord2(pDict, si, pCode, flags);
-}
-
-
-/**************************************************************************
- d i c t A p p e n d W o r d 2
-** Create a new word in the dictionary with the specified
-** STRINGINFO, code, and flags. Does not require a NULL-terminated
-** name.
-**************************************************************************/
-FICL_WORD *dictAppendWord2(FICL_DICT *pDict,
- STRINGINFO si,
- FICL_CODE pCode,
- UNS8 flags)
-{
- FICL_COUNT len = (FICL_COUNT)SI_COUNT(si);
- char *pName;
- FICL_WORD *pFW;
-
- ficlLockDictionary(TRUE);
-
- /*
- ** NOTE: dictCopyName advances "here" as a side-effect.
- ** It must execute before pFW is initialized.
- */
- pName = dictCopyName(pDict, si);
- pFW = (FICL_WORD *)pDict->here;
- pDict->smudge = pFW;
- pFW->hash = hashHashCode(si);
- pFW->code = pCode;
- pFW->flags = (UNS8)(flags | FW_SMUDGE);
- pFW->nName = (char)len;
- pFW->name = pName;
- /*
- ** Point "here" to first cell of new word's param area...
- */
- pDict->here = pFW->param;
-
- if (!(flags & FW_SMUDGE))
- dictUnsmudge(pDict);
-
- ficlLockDictionary(FALSE);
- return pFW;
-}
-
-
-/**************************************************************************
- d i c t A p p e n d U N S
-** Append the specified FICL_UNS to the dictionary
-**************************************************************************/
-void dictAppendUNS(FICL_DICT *pDict, FICL_UNS u)
-{
- *pDict->here++ = LVALUEtoCELL(u);
- return;
-}
-
-
-/**************************************************************************
- d i c t C e l l s A v a i l
-** Returns the number of empty cells left in the dictionary
-**************************************************************************/
-int dictCellsAvail(FICL_DICT *pDict)
-{
- return pDict->size - dictCellsUsed(pDict);
-}
-
-
-/**************************************************************************
- d i c t C e l l s U s e d
-** Returns the number of cells consumed in the dicionary
-**************************************************************************/
-int dictCellsUsed(FICL_DICT *pDict)
-{
- return pDict->here - pDict->dict;
-}
-
-
-/**************************************************************************
- d i c t C h e c k
-** Checks the dictionary for corruption and throws appropriate
-** errors.
-** Input: +n number of ADDRESS UNITS (not Cells) proposed to allot
-** -n number of ADDRESS UNITS proposed to de-allot
-** 0 just do a consistency check
-**************************************************************************/
-void dictCheck(FICL_DICT *pDict, FICL_VM *pVM, int n)
-{
- if ((n >= 0) && (dictCellsAvail(pDict) * (int)sizeof(CELL) < n))
- {
- vmThrowErr(pVM, "Error: dictionary full");
- }
-
- if ((n <= 0) && (dictCellsUsed(pDict) * (int)sizeof(CELL) < -n))
- {
- vmThrowErr(pVM, "Error: dictionary underflow");
- }
-
- if (pDict->nLists > FICL_DEFAULT_VOCS)
- {
- dictResetSearchOrder(pDict);
- vmThrowErr(pVM, "Error: search order overflow");
- }
- else if (pDict->nLists < 0)
- {
- dictResetSearchOrder(pDict);
- vmThrowErr(pVM, "Error: search order underflow");
- }
-
- return;
-}
-
-
-/**************************************************************************
- d i c t C o p y N a m e
-** Copy up to nFICLNAME characters of the name specified by si into
-** the dictionary starting at "here", then NULL-terminate the name,
-** point "here" to the next available byte, and return the address of
-** the beginning of the name. Used by dictAppendWord.
-** N O T E S :
-** 1. "here" is guaranteed to be aligned after this operation.
-** 2. If the string has zero length, align and return "here"
-**************************************************************************/
-static char *dictCopyName(FICL_DICT *pDict, STRINGINFO si)
-{
- char *oldCP = (char *)pDict->here;
- char *cp = oldCP;
- char *name = SI_PTR(si);
- int i = SI_COUNT(si);
-
- if (i == 0)
- {
- dictAlign(pDict);
- return (char *)pDict->here;
- }
-
- if (i > nFICLNAME)
- i = nFICLNAME;
-
- for (; i > 0; --i)
- {
- *cp++ = *name++;
- }
-
- *cp++ = '\0';
-
- pDict->here = PTRtoCELL cp;
- dictAlign(pDict);
- return oldCP;
-}
-
-
-/**************************************************************************
- d i c t C r e a t e
-** Create and initialize a dictionary with the specified number
-** of cells capacity, and no hashing (hash size == 1).
-**************************************************************************/
-FICL_DICT *dictCreate(unsigned nCells)
-{
- return dictCreateHashed(nCells, 1);
-}
-
-
-FICL_DICT *dictCreateHashed(unsigned nCells, unsigned nHash)
-{
- FICL_DICT *pDict;
- size_t nAlloc;
-
- nAlloc = sizeof (FICL_DICT) + nCells * sizeof (CELL)
- + sizeof (FICL_HASH) + (nHash - 1) * sizeof (FICL_WORD *);
-
- pDict = ficlMalloc(nAlloc);
- assert(pDict);
-
- pDict->size = nCells;
- dictEmpty(pDict, nHash);
- return pDict;
-}
-
-
-/**************************************************************************
- d i c t C r e a t e W o r d l i s t
-** Create and initialize an anonymous wordlist
-**************************************************************************/
-FICL_HASH *dictCreateWordlist(FICL_DICT *dp, int nBuckets)
-{
- FICL_HASH *pHash;
-
- dictAlign(dp);
- pHash = (FICL_HASH *)dp->here;
- dictAllot(dp, sizeof (FICL_HASH)
- + (nBuckets-1) * sizeof (FICL_WORD *));
-
- pHash->size = nBuckets;
- hashReset(pHash);
- return pHash;
-}
-
-
-/**************************************************************************
- d i c t D e l e t e
-** Free all memory allocated for the given dictionary
-**************************************************************************/
-void dictDelete(FICL_DICT *pDict)
-{
- assert(pDict);
- ficlFree(pDict);
- return;
-}
-
-
-/**************************************************************************
- d i c t E m p t y
-** Empty the dictionary, reset its hash table, and reset its search order.
-** Clears and (re-)creates the hash table with the size specified by nHash.
-**************************************************************************/
-void dictEmpty(FICL_DICT *pDict, unsigned nHash)
-{
- FICL_HASH *pHash;
-
- pDict->here = pDict->dict;
-
- dictAlign(pDict);
- pHash = (FICL_HASH *)pDict->here;
- dictAllot(pDict,
- sizeof (FICL_HASH) + (nHash - 1) * sizeof (FICL_WORD *));
-
- pHash->size = nHash;
- hashReset(pHash);
-
- pDict->pForthWords = pHash;
- pDict->smudge = NULL;
- dictResetSearchOrder(pDict);
- return;
-}
-
-
-/**************************************************************************
- d i c t H a s h S u m m a r y
-** Calculate a figure of merit for the dictionary hash table based
-** on the average search depth for all the words in the dictionary,
-** assuming uniform distribution of target keys. The figure of merit
-** is the ratio of the total search depth for all keys in the table
-** versus a theoretical optimum that would be achieved if the keys
-** were distributed into the table as evenly as possible.
-** The figure would be worse if the hash table used an open
-** addressing scheme (i.e. collisions resolved by searching the
-** table for an empty slot) for a given size table.
-**************************************************************************/
-#if FICL_WANT_FLOAT
-void dictHashSummary(FICL_VM *pVM)
-{
- FICL_DICT *dp = vmGetDict(pVM);
- FICL_HASH *pFHash;
- FICL_WORD **pHash;
- unsigned size;
- FICL_WORD *pFW;
- unsigned i;
- int nMax = 0;
- int nWords = 0;
- int nFilled;
- double avg = 0.0;
- double best;
- int nAvg, nRem, nDepth;
-
- dictCheck(dp, pVM, 0);
-
- pFHash = dp->pSearch[dp->nLists - 1];
- pHash = pFHash->table;
- size = pFHash->size;
- nFilled = size;
-
- for (i = 0; i < size; i++)
- {
- int n = 0;
- pFW = pHash[i];
-
- while (pFW)
- {
- ++n;
- ++nWords;
- pFW = pFW->link;
- }
-
- avg += (double)(n * (n+1)) / 2.0;
-
- if (n > nMax)
- nMax = n;
- if (n == 0)
- --nFilled;
- }
-
- /* Calc actual avg search depth for this hash */
- avg = avg / nWords;
-
- /* Calc best possible performance with this size hash */
- nAvg = nWords / size;
- nRem = nWords % size;
- nDepth = size * (nAvg * (nAvg+1))/2 + (nAvg+1)*nRem;
- best = (double)nDepth/nWords;
-
- sprintf(pVM->pad,
- "%d bins, %2.0f%% filled, Depth: Max=%d, Avg=%2.1f, Best=%2.1f, Score: %2.0f%%",
- size,
- (double)nFilled * 100.0 / size, nMax,
- avg,
- best,
- 100.0 * best / avg);
-
- ficlTextOut(pVM, pVM->pad, 1);
-
- return;
-}
-#endif
-
-/**************************************************************************
- d i c t I n c l u d e s
-** Returns TRUE iff the given pointer is within the address range of
-** the dictionary.
-**************************************************************************/
-int dictIncludes(FICL_DICT *pDict, void *p)
-{
- return ((p >= (void *) &pDict->dict)
- && (p < (void *)(&pDict->dict + pDict->size))
- );
-}
-
-
-/**************************************************************************
- d i c t L o o k u p
-** Find the FICL_WORD that matches the given name and length.
-** If found, returns the word's address. Otherwise returns NULL.
-** Uses the search order list to search multiple wordlists.
-**************************************************************************/
-FICL_WORD *dictLookup(FICL_DICT *pDict, STRINGINFO si)
-{
- FICL_WORD *pFW = NULL;
- FICL_HASH *pHash;
- int i;
- UNS16 hashCode = hashHashCode(si);
-
- assert(pDict);
-
- ficlLockDictionary(1);
-
- for (i = (int)pDict->nLists - 1; (i >= 0) && (!pFW); --i)
- {
- pHash = pDict->pSearch[i];
- pFW = hashLookup(pHash, si, hashCode);
- }
-
- ficlLockDictionary(0);
- return pFW;
-}
-
-
-/**************************************************************************
- f i c l L o o k u p L o c
-** Same as dictLookup, but looks in system locals dictionary first...
-** Assumes locals dictionary has only one wordlist...
-**************************************************************************/
-#if FICL_WANT_LOCALS
-FICL_WORD *ficlLookupLoc(FICL_SYSTEM *pSys, STRINGINFO si)
-{
- FICL_WORD *pFW = NULL;
- FICL_DICT *pDict = pSys->dp;
- FICL_HASH *pHash = ficlGetLoc(pSys)->pForthWords;
- int i;
- UNS16 hashCode = hashHashCode(si);
-
- assert(pHash);
- assert(pDict);
-
- ficlLockDictionary(1);
- /*
- ** check the locals dict first...
- */
- pFW = hashLookup(pHash, si, hashCode);
-
- /*
- ** If no joy, (!pFW) --------------------------v
- ** iterate over the search list in the main dict
- */
- for (i = (int)pDict->nLists - 1; (i >= 0) && (!pFW); --i)
- {
- pHash = pDict->pSearch[i];
- pFW = hashLookup(pHash, si, hashCode);
- }
-
- ficlLockDictionary(0);
- return pFW;
-}
-#endif
-
-
-/**************************************************************************
- d i c t R e s e t S e a r c h O r d e r
-** Initialize the dictionary search order list to sane state
-**************************************************************************/
-void dictResetSearchOrder(FICL_DICT *pDict)
-{
- assert(pDict);
- pDict->pCompile = pDict->pForthWords;
- pDict->nLists = 1;
- pDict->pSearch[0] = pDict->pForthWords;
- return;
-}
-
-
-/**************************************************************************
- d i c t S e t F l a g s
-** Changes the flags field of the most recently defined word:
-** Set all bits that are ones in the set parameter, clear all bits
-** that are ones in the clr parameter. Clear wins in case the same bit
-** is set in both parameters.
-**************************************************************************/
-void dictSetFlags(FICL_DICT *pDict, UNS8 set, UNS8 clr)
-{
- assert(pDict->smudge);
- pDict->smudge->flags |= set;
- pDict->smudge->flags &= ~clr;
- return;
-}
-
-
-/**************************************************************************
- d i c t S e t I m m e d i a t e
-** Set the most recently defined word as IMMEDIATE
-**************************************************************************/
-void dictSetImmediate(FICL_DICT *pDict)
-{
- assert(pDict->smudge);
- pDict->smudge->flags |= FW_IMMEDIATE;
- return;
-}
-
-
-/**************************************************************************
- d i c t U n s m u d g e
-** Completes the definition of a word by linking it
-** into the main list
-**************************************************************************/
-void dictUnsmudge(FICL_DICT *pDict)
-{
- FICL_WORD *pFW = pDict->smudge;
- FICL_HASH *pHash = pDict->pCompile;
-
- assert(pHash);
- assert(pFW);
- /*
- ** :noname words never get linked into the list...
- */
- if (pFW->nName > 0)
- hashInsertWord(pHash, pFW);
- pFW->flags &= ~(FW_SMUDGE);
- return;
-}
-
-
-/**************************************************************************
- d i c t W h e r e
-** Returns the value of the HERE pointer -- the address
-** of the next free cell in the dictionary
-**************************************************************************/
-CELL *dictWhere(FICL_DICT *pDict)
-{
- return pDict->here;
-}
-
-
-/**************************************************************************
- h a s h F o r g e t
-** Unlink all words in the hash that have addresses greater than or
-** equal to the address supplied. Implementation factor for FORGET
-** and MARKER.
-**************************************************************************/
-void hashForget(FICL_HASH *pHash, void *where)
-{
- FICL_WORD *pWord;
- unsigned i;
-
- assert(pHash);
- assert(where);
-
- for (i = 0; i < pHash->size; i++)
- {
- pWord = pHash->table[i];
-
- while ((void *)pWord >= where)
- {
- pWord = pWord->link;
- }
-
- pHash->table[i] = pWord;
- }
-
- return;
-}
-
-
-/**************************************************************************
- h a s h H a s h C o d e
-**
-** Generate a 16 bit hashcode from a character string using a rolling
-** shift and add stolen from PJ Weinberger of Bell Labs fame. Case folds
-** the name before hashing it...
-** N O T E : If string has zero length, returns zero.
-**************************************************************************/
-UNS16 hashHashCode(STRINGINFO si)
-{
- /* hashPJW */
- UNS8 *cp;
- UNS16 code = (UNS16)si.count;
- UNS16 shift = 0;
-
- if (si.count == 0)
- return 0;
-
- /* changed to run without errors under Purify -- lch */
- for (cp = (UNS8 *)si.cp; si.count && *cp; cp++, si.count--)
- {
- code = (UNS16)((code << 4) + tolower(*cp));
- shift = (UNS16)(code & 0xf000);
- if (shift)
- {
- code ^= (UNS16)(shift >> 8);
- code ^= (UNS16)shift;
- }
- }
-
- return (UNS16)code;
-}
-
-
-
-
-/**************************************************************************
- h a s h I n s e r t W o r d
-** Put a word into the hash table using the word's hashcode as
-** an index (modulo the table size).
-**************************************************************************/
-void hashInsertWord(FICL_HASH *pHash, FICL_WORD *pFW)
-{
- FICL_WORD **pList;
-
- assert(pHash);
- assert(pFW);
-
- if (pHash->size == 1)
- {
- pList = pHash->table;
- }
- else
- {
- pList = pHash->table + (pFW->hash % pHash->size);
- }
-
- pFW->link = *pList;
- *pList = pFW;
- return;
-}
-
-
-/**************************************************************************
- h a s h L o o k u p
-** Find a name in the hash table given the hashcode and text of the name.
-** Returns the address of the corresponding FICL_WORD if found,
-** otherwise NULL.
-** Note: outer loop on link field supports inheritance in wordlists.
-** It's not part of ANS Forth - ficl only. hashReset creates wordlists
-** with NULL link fields.
-**************************************************************************/
-FICL_WORD *hashLookup(FICL_HASH *pHash, STRINGINFO si, UNS16 hashCode)
-{
- FICL_UNS nCmp = si.count;
- FICL_WORD *pFW;
- UNS16 hashIdx;
-
- if (nCmp > nFICLNAME)
- nCmp = nFICLNAME;
-
- for (; pHash != NULL; pHash = pHash->link)
- {
- if (pHash->size > 1)
- hashIdx = (UNS16)(hashCode % pHash->size);
- else /* avoid the modulo op for single threaded lists */
- hashIdx = 0;
-
- for (pFW = pHash->table[hashIdx]; pFW; pFW = pFW->link)
- {
- if ( (pFW->nName == si.count)
- && (!strincmp(si.cp, pFW->name, nCmp)) )
- return pFW;
-#if FICL_ROBUST
- assert(pFW != pFW->link);
-#endif
- }
- }
-
- return NULL;
-}
-
-
-/**************************************************************************
- h a s h R e s e t
-** Initialize a FICL_HASH to empty state.
-**************************************************************************/
-void hashReset(FICL_HASH *pHash)
-{
- unsigned i;
-
- assert(pHash);
-
- for (i = 0; i < pHash->size; i++)
- {
- pHash->table[i] = NULL;
- }
-
- pHash->link = NULL;
- pHash->name = NULL;
- return;
-}
-
-
--- a/ficl.c
+++ /dev/null
@@ -1,691 +1,0 @@
-/*******************************************************************
-** f i c l . c
-** Forth Inspired Command Language - external interface
-** Author: John Sadler (john_sadler@alum.mit.edu)
-** Created: 19 July 1997
-** $Id: ficl.c,v 1.16 2001/12/05 07:21:34 jsadler Exp $
-*******************************************************************/
-/*
-** This is an ANS Forth interpreter written in C.
-** Ficl uses Forth syntax for its commands, but turns the Forth
-** model on its head in other respects.
-** Ficl provides facilities for interoperating
-** with programs written in C: C functions can be exported to Ficl,
-** and Ficl commands can be executed via a C calling interface. The
-** interpreter is re-entrant, so it can be used in multiple instances
-** in a multitasking system. Unlike Forth, Ficl's outer interpreter
-** expects a text block as input, and returns to the caller after each
-** text block, so the data pump is somewhere in external code in the
-** style of TCL.
-**
-** Code is written in ANSI C for portability.
-*/
-/*
-** Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
-** All rights reserved.
-**
-** Get the latest Ficl release at http://ficl.sourceforge.net
-**
-** 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
-** contact me by email at the address above.
-**
-** L I C E N S E and D I S C L A I M E R
-**
-** Redistribution and use in source and binary forms, with or without
-** modification, are permitted provided that the following conditions
-** are met:
-** 1. Redistributions of source code must retain the above copyright
-** notice, this list of conditions and the following disclaimer.
-** 2. Redistributions in binary form must reproduce the above copyright
-** notice, this list of conditions and the following disclaimer in the
-** documentation and/or other materials provided with the distribution.
-**
-** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
-** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-** SUCH DAMAGE.
-*/
-
-#include <stdlib.h>
-#include <string.h>
-#include "ficl.h"
-
-
-/*
-** System statics
-** Each FICL_SYSTEM builds a global dictionary during its start
-** sequence. This is shared by all virtual machines of that system.
-** Therefore only one VM can update the dictionary
-** at a time. The system imports a locking function that
-** you can override in order to control update access to
-** the dictionary. The function is stubbed out by default,
-** but you can insert one: #define FICL_MULTITHREAD 1
-** and supply your own version of ficlLockDictionary.
-*/
-static int defaultStack = FICL_DEFAULT_STACK;
-
-
-static void ficlSetVersionEnv(FICL_SYSTEM *pSys);
-
-
-/**************************************************************************
- f i c l I n i t S y s t e m
-** Binds a global dictionary to the interpreter system.
-** You specify the address and size of the allocated area.
-** After that, ficl manages it.
-** First step is to set up the static pointers to the area.
-** Then write the "precompiled" portion of the dictionary in.
-** The dictionary needs to be at least large enough to hold the
-** precompiled part. Try 1K cells minimum. Use "words" to find
-** out how much of the dictionary is used at any time.
-**************************************************************************/
-FICL_SYSTEM *ficlInitSystemEx(FICL_SYSTEM_INFO *fsi)
-{
- int nDictCells;
- int nEnvCells;
- FICL_SYSTEM *pSys = ficlMalloc(sizeof (FICL_SYSTEM));
-
- assert(pSys);
- assert(fsi->size == sizeof (FICL_SYSTEM_INFO));
-
- memset(pSys, 0, sizeof (FICL_SYSTEM));
-
- nDictCells = fsi->nDictCells;
- if (nDictCells <= 0)
- nDictCells = FICL_DEFAULT_DICT;
-
- nEnvCells = fsi->nEnvCells;
- if (nEnvCells <= 0)
- nEnvCells = FICL_DEFAULT_DICT;
-
- pSys->dp = dictCreateHashed((unsigned)nDictCells, HASHSIZE);
- pSys->dp->pForthWords->name = "forth-wordlist";
-
- pSys->envp = dictCreate((unsigned)nEnvCells);
- pSys->envp->pForthWords->name = "environment";
-
- pSys->textOut = fsi->textOut;
- pSys->pExtend = fsi->pExtend;
-
-#if FICL_WANT_LOCALS
- /*
- ** The locals dictionary is only searched while compiling,
- ** but this is where speed is most important. On the other
- ** hand, the dictionary gets emptied after each use of locals
- ** The need to balance search speed with the cost of the 'empty'
- ** operation led me to select a single-threaded list...
- */
- pSys->localp = dictCreate((unsigned)FICL_MAX_LOCALS * CELLS_PER_WORD);
-#endif
-
- /*
- ** Build the precompiled dictionary and load softwords. We need a temporary
- ** VM to do this - ficlNewVM links one to the head of the system VM list.
- ** ficlCompilePlatform (defined in win32.c, for example) adds platform specific words.
- */
- ficlCompileCore(pSys);
- ficlCompilePrefix(pSys);
-#if FICL_WANT_FLOAT
- ficlCompileFloat(pSys);
-#endif
-#if FICL_PLATFORM_EXTEND
- ficlCompilePlatform(pSys);
-#endif
- ficlSetVersionEnv(pSys);
-
- /*
- ** Establish the parse order. Note that prefixes precede numbers -
- ** this allows constructs like "0b101010" which might parse as a
- ** hex value otherwise.
- */
- ficlAddPrecompiledParseStep(pSys, "?prefix", ficlParsePrefix);
- ficlAddPrecompiledParseStep(pSys, "?number", ficlParseNumber);
-#if FICL_WANT_FLOAT
- ficlAddPrecompiledParseStep(pSys, ">float", ficlParseFloatNumber);
-#endif
-
- /*
- ** Now create a temporary VM to compile the softwords. Since all VMs are
- ** linked into the vmList of FICL_SYSTEM, we don't have to pass the VM
- ** to ficlCompileSoftCore -- it just hijacks whatever it finds in the VM list.
- ** ficl 2.05: vmCreate no longer depends on the presence of INTERPRET in the
- ** dictionary, so a VM can be created before the dictionary is built. It just
- ** can't do much...
- */
- ficlNewVM(pSys);
- ficlCompileSoftCore(pSys);
- ficlFreeVM(pSys->vmList);
-
-
- return pSys;
-}
-
-
-FICL_SYSTEM *ficlInitSystem(int nDictCells)
-{
- FICL_SYSTEM_INFO fsi;
- ficlInitInfo(&fsi);
- fsi.nDictCells = nDictCells;
- return ficlInitSystemEx(&fsi);
-}
-
-
-/**************************************************************************
- f i c l A d d P a r s e S t e p
-** Appends a parse step function to the end of the parse list (see
-** FICL_PARSE_STEP notes in ficl.h for details). Returns 0 if successful,
-** nonzero if there's no more room in the list.
-**************************************************************************/
-int ficlAddParseStep(FICL_SYSTEM *pSys, FICL_WORD *pFW)
-{
- int i;
- for (i = 0; i < FICL_MAX_PARSE_STEPS; i++)
- {
- if (pSys->parseList[i] == NULL)
- {
- pSys->parseList[i] = pFW;
- return 0;
- }
- }
-
- return 1;
-}
-
-
-/*
-** Compile a word into the dictionary that invokes the specified FICL_PARSE_STEP
-** function. It is up to the user (as usual in Forth) to make sure the stack
-** preconditions are valid (there needs to be a counted string on top of the stack)
-** before using the resulting word.
-*/
-void ficlAddPrecompiledParseStep(FICL_SYSTEM *pSys, char *name, FICL_PARSE_STEP pStep)
-{
- FICL_DICT *dp = pSys->dp;
- FICL_WORD *pFW = dictAppendWord(dp, name, parseStepParen, FW_DEFAULT);
- dictAppendCell(dp, LVALUEtoCELL(pStep));
- ficlAddParseStep(pSys, pFW);
-}
-
-
-/*
-** This word lists the parse steps in order
-*/
-void ficlListParseSteps(FICL_VM *pVM)
-{
- int i;
- FICL_SYSTEM *pSys = pVM->pSys;
- assert(pSys);
-
- vmTextOut(pVM, "Parse steps:", 1);
- vmTextOut(pVM, "lookup", 1);
-
- for (i = 0; i < FICL_MAX_PARSE_STEPS; i++)
- {
- if (pSys->parseList[i] != NULL)
- {
- vmTextOut(pVM, pSys->parseList[i]->name, 1);
- }
- else break;
- }
- return;
-}
-
-
-/**************************************************************************
- f i c l N e w V M
-** Create a new virtual machine and link it into the system list
-** of VMs for later cleanup by ficlTermSystem.
-**************************************************************************/
-FICL_VM *ficlNewVM(FICL_SYSTEM *pSys)
-{
- FICL_VM *pVM = vmCreate(NULL, defaultStack, defaultStack);
- pVM->link = pSys->vmList;
- pVM->pSys = pSys;
- pVM->pExtend = pSys->pExtend;
- vmSetTextOut(pVM, pSys->textOut);
-
- pSys->vmList = pVM;
- return pVM;
-}
-
-
-/**************************************************************************
- f i c l F r e e V M
-** 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.
-**************************************************************************/
-void ficlFreeVM(FICL_VM *pVM)
-{
- FICL_SYSTEM *pSys = pVM->pSys;
- FICL_VM *pList = pSys->vmList;
-
- assert(pVM != 0);
-
- if (pSys->vmList == pVM)
- {
- pSys->vmList = pSys->vmList->link;
- }
- else for (; pList != NULL; pList = pList->link)
- {
- if (pList->link == pVM)
- {
- pList->link = pVM->link;
- break;
- }
- }
-
- if (pList)
- vmDelete(pVM);
- return;
-}
-
-
-/**************************************************************************
- f i c l B u i l d
-** Builds a word into the dictionary.
-** Preconditions: system must be initialized, and there must
-** be enough space for the new word's header! Operation is
-** controlled by ficlLockDictionary, so any initialization
-** required by your version of the function (if you overrode
-** it) must be complete at this point.
-** Parameters:
-** name -- duh, the name of the word
-** code -- code to execute when the word is invoked - must take a single param
-** pointer to a FICL_VM
-** flags -- 0 or more of F_IMMEDIATE, F_COMPILE, use bitwise OR!
-**
-**************************************************************************/
-int ficlBuild(FICL_SYSTEM *pSys, char *name, FICL_CODE code, char flags)
-{
-#if FICL_MULTITHREAD
- int err = ficlLockDictionary(TRUE);
- if (err) return err;
-#endif /* FICL_MULTITHREAD */
-
- assert(dictCellsAvail(pSys->dp) > sizeof (FICL_WORD) / sizeof (CELL));
- dictAppendWord(pSys->dp, name, code, flags);
-
- ficlLockDictionary(FALSE);
- return 0;
-}
-
-
-/**************************************************************************
- f i c l E v a l u a t e
-** Wrapper for ficlExec() which sets SOURCE-ID to -1.
-**************************************************************************/
-int ficlEvaluate(FICL_VM *pVM, char *pText)
-{
- int returnValue;
- CELL id = pVM->sourceID;
- pVM->sourceID.i = -1;
- returnValue = ficlExecC(pVM, pText, -1);
- pVM->sourceID = id;
- return returnValue;
-}
-
-
-/**************************************************************************
- f i c l E x e c
-** Evaluates a block of input text in the context of the
-** specified interpreter. Emits any requested output to the
-** interpreter's output function.
-**
-** Contains the "inner interpreter" code in a tight loop
-**
-** Returns one of the VM_XXXX codes defined in ficl.h:
-** VM_OUTOFTEXT is the normal exit condition
-** VM_ERREXIT means that the interp encountered a syntax error
-** and the vm has been reset to recover (some or all
-** of the text block got ignored
-** VM_USEREXIT means that the user executed the "bye" command
-** to shut down the interpreter. This would be a good
-** time to delete the vm, etc -- or you can ignore this
-** signal.
-**************************************************************************/
-int ficlExec(FICL_VM *pVM, char *pText)
-{
- return ficlExecC(pVM, pText, -1);
-}
-
-int ficlExecC(FICL_VM *pVM, char *pText, FICL_INT size)
-{
- FICL_SYSTEM *pSys = pVM->pSys;
- FICL_DICT *dp = pSys->dp;
-
- int except;
- jmp_buf vmState;
- jmp_buf *oldState;
- TIB saveTib;
-
- assert(pVM);
- assert(pSys->pInterp[0]);
-
- if (size < 0)
- size = strlen(pText);
-
- vmPushTib(pVM, pText, size, &saveTib);
-
- /*
- ** Save and restore VM's jmp_buf to enable nested calls to ficlExec
- */
- oldState = pVM->pState;
- pVM->pState = &vmState; /* This has to come before the setjmp! */
- except = setjmp(vmState);
-
- switch (except)
- {
- case 0:
- if (pVM->fRestart)
- {
- pVM->runningWord->code(pVM);
- pVM->fRestart = 0;
- }
- else
- { /* set VM up to interpret text */
- vmPushIP(pVM, &(pSys->pInterp[0]));
- }
-
- vmInnerLoop(pVM);
- break;
-
- case VM_RESTART:
- pVM->fRestart = 1;
- except = VM_OUTOFTEXT;
- break;
-
- case VM_OUTOFTEXT:
- vmPopIP(pVM);
- if ((pVM->state != COMPILE) && (pVM->sourceID.i == 0))
- ficlTextOut(pVM, FICL_PROMPT, 0);
- break;
-
- case VM_USEREXIT:
- case VM_INNEREXIT:
- case VM_BREAK:
- break;
-
- case VM_QUIT:
- if (pVM->state == COMPILE)
- {
- dictAbortDefinition(dp);
-#if FICL_WANT_LOCALS
- dictEmpty(pSys->localp, pSys->localp->pForthWords->size);
-#endif
- }
- vmQuit(pVM);
- break;
-
- case VM_ERREXIT:
- case VM_ABORT:
- case VM_ABORTQ:
- default: /* user defined exit code?? */
- if (pVM->state == COMPILE)
- {
- dictAbortDefinition(dp);
-#if FICL_WANT_LOCALS
- dictEmpty(pSys->localp, pSys->localp->pForthWords->size);
-#endif
- }
- dictResetSearchOrder(dp);
- vmReset(pVM);
- break;
- }
-
- pVM->pState = oldState;
- vmPopTib(pVM, &saveTib);
- return (except);
-}
-
-
-/**************************************************************************
- f i c l E x e c X T
-** Given a pointer to a FICL_WORD, push an inner interpreter and
-** execute the word to completion. This is in contrast with vmExecute,
-** which does not guarantee that the word will have completed when
-** the function returns (ie in the case of colon definitions, which
-** need an inner interpreter to finish)
-**
-** Returns one of the VM_XXXX exception codes listed in ficl.h. Normal
-** exit condition is VM_INNEREXIT, ficl's private signal to exit the
-** inner loop under normal circumstances. If another code is thrown to
-** exit the loop, this function will re-throw it if it's nested under
-** itself or ficlExec.
-**
-** NOTE: this function is intended so that C code can execute ficlWords
-** given their address in the dictionary (xt).
-**************************************************************************/
-int ficlExecXT(FICL_VM *pVM, FICL_WORD *pWord)
-{
- int except;
- jmp_buf vmState;
- jmp_buf *oldState;
- FICL_WORD *oldRunningWord;
-
- assert(pVM);
- assert(pVM->pSys->pExitInner);
-
- /*
- ** Save the runningword so that RESTART behaves correctly
- ** over nested calls.
- */
- oldRunningWord = pVM->runningWord;
- /*
- ** Save and restore VM's jmp_buf to enable nested calls
- */
- oldState = pVM->pState;
- pVM->pState = &vmState; /* This has to come before the setjmp! */
- except = setjmp(vmState);
-
- if (except)
- vmPopIP(pVM);
- else
- vmPushIP(pVM, &(pVM->pSys->pExitInner));
-
- switch (except)
- {
- case 0:
- vmExecute(pVM, pWord);
- vmInnerLoop(pVM);
- break;
-
- case VM_INNEREXIT:
- case VM_BREAK:
- break;
-
- case VM_RESTART:
- case VM_OUTOFTEXT:
- case VM_USEREXIT:
- case VM_QUIT:
- case VM_ERREXIT:
- case VM_ABORT:
- case VM_ABORTQ:
- default: /* user defined exit code?? */
- if (oldState)
- {
- pVM->pState = oldState;
- vmThrow(pVM, except);
- }
- break;
- }
-
- pVM->pState = oldState;
- pVM->runningWord = oldRunningWord;
- return (except);
-}
-
-
-/**************************************************************************
- f i c l L o o k u p
-** Look in the system dictionary for a match to the given name. If
-** found, return the address of the corresponding FICL_WORD. Otherwise
-** return NULL.
-**************************************************************************/
-FICL_WORD *ficlLookup(FICL_SYSTEM *pSys, char *name)
-{
- STRINGINFO si;
- SI_PSZ(si, name);
- return dictLookup(pSys->dp, si);
-}
-
-
-/**************************************************************************
- f i c l G e t D i c t
-** Returns the address of the system dictionary
-**************************************************************************/
-FICL_DICT *ficlGetDict(FICL_SYSTEM *pSys)
-{
- return pSys->dp;
-}
-
-
-/**************************************************************************
- f i c l G e t E n v
-** Returns the address of the system environment space
-**************************************************************************/
-FICL_DICT *ficlGetEnv(FICL_SYSTEM *pSys)
-{
- return pSys->envp;
-}
-
-
-/**************************************************************************
- f i c l S e t E n v
-** Create an environment variable with a one-CELL payload. ficlSetEnvD
-** makes one with a two-CELL payload.
-**************************************************************************/
-void ficlSetEnv(FICL_SYSTEM *pSys, char *name, FICL_UNS value)
-{
- STRINGINFO si;
- FICL_WORD *pFW;
- FICL_DICT *envp = pSys->envp;
-
- SI_PSZ(si, name);
- pFW = dictLookup(envp, si);
-
- if (pFW == NULL)
- {
- dictAppendWord(envp, name, constantParen, FW_DEFAULT);
- dictAppendCell(envp, LVALUEtoCELL(value));
- }
- else
- {
- pFW->param[0] = LVALUEtoCELL(value);
- }
-
- return;
-}
-
-void ficlSetEnvD(FICL_SYSTEM *pSys, char *name, FICL_UNS hi, FICL_UNS lo)
-{
- FICL_WORD *pFW;
- STRINGINFO si;
- FICL_DICT *envp = pSys->envp;
- SI_PSZ(si, name);
- pFW = dictLookup(envp, si);
-
- if (pFW == NULL)
- {
- dictAppendWord(envp, name, twoConstParen, FW_DEFAULT);
- dictAppendCell(envp, LVALUEtoCELL(lo));
- dictAppendCell(envp, LVALUEtoCELL(hi));
- }
- else
- {
- pFW->param[0] = LVALUEtoCELL(lo);
- pFW->param[1] = LVALUEtoCELL(hi);
- }
-
- return;
-}
-
-
-/**************************************************************************
- f i c l G e t L o c
-** Returns the address of the system locals dictionary. This dict is
-** only used during compilation, and is shared by all VMs.
-**************************************************************************/
-#if FICL_WANT_LOCALS
-FICL_DICT *ficlGetLoc(FICL_SYSTEM *pSys)
-{
- return pSys->localp;
-}
-#endif
-
-
-
-/**************************************************************************
- f i c l S e t S t a c k S i z e
-** Set the stack sizes (return and parameter) to be used for all
-** subsequently created VMs. Returns actual stack size to be used.
-**************************************************************************/
-int ficlSetStackSize(int nStackCells)
-{
- if (nStackCells >= FICL_DEFAULT_STACK)
- defaultStack = nStackCells;
- else
- defaultStack = FICL_DEFAULT_STACK;
-
- return defaultStack;
-}
-
-
-/**************************************************************************
- f i c l T e r m S y s t e m
-** Tear the system down by deleting the dictionaries and all VMs.
-** This saves you from having to keep track of all that stuff.
-**************************************************************************/
-void ficlTermSystem(FICL_SYSTEM *pSys)
-{
- if (pSys->dp)
- dictDelete(pSys->dp);
- pSys->dp = NULL;
-
- if (pSys->envp)
- dictDelete(pSys->envp);
- pSys->envp = NULL;
-
-#if FICL_WANT_LOCALS
- if (pSys->localp)
- dictDelete(pSys->localp);
- pSys->localp = NULL;
-#endif
-
- while (pSys->vmList != NULL)
- {
- FICL_VM *pVM = pSys->vmList;
- pSys->vmList = pSys->vmList->link;
- vmDelete(pVM);
- }
-
- ficlFree(pSys);
- pSys = NULL;
- return;
-}
-
-
-/**************************************************************************
- f i c l S e t V e r s i o n E n v
-** Create a double cell environment constant for the version ID
-**************************************************************************/
-static void ficlSetVersionEnv(FICL_SYSTEM *pSys)
-{
- int major = 0;
- int minor = 0;
- sscanf(FICL_VER, "%d.%d", &major, &minor);
- ficlSetEnvD(pSys, "ficl-version", major, minor);
- ficlSetEnv (pSys, "ficl-robust", FICL_ROBUST);
- return;
-}
-
--- a/ficl.dsp
+++ /dev/null
@@ -1,301 +1,0 @@
-# Microsoft Developer Studio Project File - Name="ficl" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Console Application" 0x0103
-
-CFG=ficl - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE
-!MESSAGE NMAKE /f "ficl.mak".
-!MESSAGE
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE
-!MESSAGE NMAKE /f "ficl.mak" CFG="ficl - Win32 Debug"
-!MESSAGE
-!MESSAGE Possible choices for configuration are:
-!MESSAGE
-!MESSAGE "ficl - Win32 Release" (based on "Win32 (x86) Console Application")
-!MESSAGE "ficl - Win32 Debug" (based on "Win32 (x86) Console Application")
-!MESSAGE
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF "$(CFG)" == "ficl - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "/objects/common/ficl/release"
-# PROP Intermediate_Dir "/objects/common/ficl/release"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /W4 /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
-# SUBTRACT CPP /Fr /YX
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
-
-!ELSEIF "$(CFG)" == "ficl - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "/objects/common/ficl/debug"
-# PROP Intermediate_Dir "/objects/common/ficl/debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
-# ADD CPP /nologo /Za /W4 /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
-
-!ENDIF
-
-# Begin Target
-
-# Name "ficl - Win32 Release"
-# Name "ficl - Win32 Debug"
-# Begin Group "Sources"
-
-# PROP Default_Filter "*.c"
-# Begin Source File
-
-SOURCE=.\dict.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\ficl.c
-
-!IF "$(CFG)" == "ficl - Win32 Release"
-
-# ADD CPP /FAcs
-
-!ELSEIF "$(CFG)" == "ficl - Win32 Debug"
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=.\fileaccess.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\float.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\math64.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\prefix.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\search.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\softcore.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\stack.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\sysdep.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\testmain.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\tools.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\vm.c
-# End Source File
-# Begin Source File
-
-SOURCE=.\win32.c
-
-!IF "$(CFG)" == "ficl - Win32 Release"
-
-!ELSEIF "$(CFG)" == "ficl - Win32 Debug"
-
-# ADD CPP /Ze
-
-!ENDIF
-
-# End Source File
-# Begin Source File
-
-SOURCE=.\words.c
-# End Source File
-# End Group
-# Begin Group "Headers"
-
-# PROP Default_Filter "*.h"
-# Begin Source File
-
-SOURCE=.\ficl.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\math64.h
-# End Source File
-# Begin Source File
-
-SOURCE=.\sysdep.h
-# End Source File
-# End Group
-# Begin Group "softcore"
-
-# PROP Default_Filter ".fr"
-# Begin Source File
-
-SOURCE=.\softwords\classes.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\ficlclass.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\ficllocal.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\fileaccess.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\forml.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\ifbrack.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\jhlocal.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\marker.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\oo.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\prefix.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\softcore.bat
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\softcore.fr
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\softcore.pl
-# End Source File
-# Begin Source File
-
-SOURCE=.\softwords\string.fr
-# End Source File
-# End Group
-# Begin Group "doc"
-
-# PROP Default_Filter "*.html. *.txt"
-# Begin Source File
-
-SOURCE=.\doc\ficl.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficl_ans.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficl_debug.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\ficl_guts.htm
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficl_loc.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficl_oop.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficl_parse.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficl_rel.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\ficlheader.js
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\index.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\oo_in_c.html
-# End Source File
-# Begin Source File
-
-SOURCE=.\doc\primer.txt
-# End Source File
-# End Group
-# Begin Source File
-
-SOURCE=.\ReadMe.txt
-# End Source File
-# End Target
-# End Project