The Forth Column

Forth continued to make inroads into artificial intelligence. Henry Harris (JPL) presented papers on conceptual dependency; William Dress (Oak Ridge National Lab) presented several on neural nets. Two implementations of OPS5 and two of "fuzzy" rule production systems were developed last year. Jack Park's popular Expert 2 system evolved to Expert 5. For a general summary of Forth's recent history in AI, see "The Forth Wave in AI" by Robert Trelease in Al Expert (October 1987).

Part of Forth's popularity in AI is the ease in which it can be implemented on experimental computer architectures. This makes Forth particularly attractive for simulating, controlling, and testing inference engines and neural networks. Once Forth is ported to a new hardware environment, it is possible to implement additional languages, such as BASIC, LISP, and PROLOG, rapidly by writing them in Forth. Panasonic, for example, implemented BASIC this way on the original HHC (handheld computer). Charles Duff's object-oriented NEON and Actor were both written as extensions to Forth, too.

By the way, a tiny Modula-2 has just been written in Forth by S. Lohr. You can download it from the East Coast Forth Board ([703] 442-8695) or from the new GENie Forth Board as the file TM2ARC. You will find an interesting discussion of language bootstrapping techniques in "Embeddings of Languages in Forth" by R.D. Dixon in the latest Journal of Forth Application and Research, vol. 4, no. 4, 1987.

This same issue contains two important articles on implementing PROLOG in Forth: "A Full PROLOG Interpreter Embedded in Forth" by Odette and Paloski and "Compiling PROLOG to Forth" by Odette. The latter article contains careful and expert notes on implementing the compiler, with complete source code. Compiling PROLOG to run on Forth hardware gives you an inference engine with truly awesome speed. Lou Odette reports that a "naive reverse benchmark" runs at 6,000 LIPS (logical inferences per second) on an NC4016 with a (conservative) 4-KHz clock. When the next generation of Forth processors appears later this year, they should run the same benchmark at the speed of compiled (Quintus) PROLOG on a VAX 11/780.

Flash! At this year's annual Forth Convention (San Jose, Calif., November 1987) Silicon Composers unveiled an IBM PC AT board containing the FORCE core set from Harris Semiconductor. FORCE is implemented on the board as five separate chips: the Forth-based CPU, a hardware multiplier, an interrupt controller, a data stack, and a return stack. All pertinent signals are bused to a prototyping area on the board. It has 32K of high-speed RAM, expandable to 128K (as soon as highdensity 35-nsec RAM chips become available).

The development system includes an optimizing compiler that reads standard ASCII text files. You could use this system to prototype and test hardware macros before integrating them into a custom VLSI Forth-based RISC machine. The AT/FORCE board is available from Silicon Composers ([415] 322-8763) starting mid-December 1987 and retails for $4,500.

/STRING ( a n n2 -a + n2  n-n2)
\ truncates leftmost n chars of string.
\n may be negative

EVAL ( a n )
\ evaluates ("text interprets") a string.

ASCII ( - c )
\ returns a value of following char.

CTO"" ( c - a 1)
\converts character to a string.

SKIP ( a I c - a2 12)
\ returns shorter string from
\ first position unequal to byte.

SCAN ( a 1 byter - a2 12)
\ returns shorter string from
\ first position equal to byte.

" ( - a)
\ STATE-smart string literal.

VAL? ( a n - d 2, n2 1 , 0)
\ string to number conversion. \ True if d is valid.
\ Returns d if number contains ",-./:"
\ and sets DPL = 0
\ Returns n if no punctuation present
\ and sets DPL = 0<

VAL ( a n - d f)
\ converts string to double number. \ True if number is valid.

-TEXT ( a n a2 - -1 , 0 , 1)
\ returns -1 if string a n < a2 n ,
\ 0 if equal, and 1 if >.

COMPARE ( a n a2 n2 - -1 , 0 , 1)
\ returns -1 if a n < a2 n2, \ 0 if equal, and 1 if >.

MATCH ( a n a2 n2 - ???? 0 , offset -1)
\ returns the position of
\ string a2 n2 in (a n).
\ Offset is zero if ( a n )
\ is found in first char position.
\ FAlse with valid offset
\ if ( a n ) isn't in a2 n2.

The string package was built on the Standard prelude (see DDJ, October 1987) and the DDJ Controlled Reference Word Set:

2* D2* HEX C, BL ERASE BLANK .R 2>R 2R> AGAIN DLITERAL S>D WITHIN TRUE

Definitions for these words are also in the listing.

This month's topic is accessing files from Forth. You may have heard that Forth is both a language and an operating system. It's true. Because Forth is often the first development system to work in a new environment, it needs to manage memory, handle interrupts, and access mass storage. The essential primitives for reading and writing mass storage are BLOCK and UPDATE. Eventually when other operating systems become available, Forth may be extended to coexist peacefully with them.

When Forth is itself the operating system, it divides mass storage into consecutively numbered (1,024-byte) blocks. Both source code and data are kept in these blocks. There are no "text" or "data" files in the normal sense. Any source or data read by Forth is previously written by Forth.

When Forth runs under an operating system, it takes advantage of operating system calls. Under CP/M, for example, any logical sector in a file can be read or written directly. Sectors can be grouped into blocks, and so any file can be accessed as a sequence of blocks.

But what if the file is not an integer number of blocks long? The file will only fill part of the last block. This leads to the first rule of standard file access from Forth:

1. BLOCK must be able to read the entire file. If the last block is partial, the contents of BLOCK past the end of the file are undefined. Reading a partial block is not an error condition.

What about writing to a partial block? The UPDATE command tells Forth only that some part of a block has been written to but not which part. This leads to a second rule:

2. UPDATE forces a partial block to be extended to a full block. The file length must be adjusted accordingly.

If you use Forth only to read Forth files, you will see no partial blocks and neither rule will apply. Otherwise, two operating system calls are required:

1. to determine the length of a file in some unit easily convertible to a double number of bytes

2. to extend the length of a file by a multiple of the same unit

The easiest way to keep track of the length of a file is to call the system when the file is first opened and to maintain its double-number length in a 2VARIABLE (or equivalent)--for example, CAPACITY. Furthermore, assume that you can constmct the word EXTEND, which extends the file by at least a given double number of bytes. Suppose, for example, that Forth provides the word MORE, which extends a file by a given number of blocks:

: MORE ( n )...;
: EXTEND (d)
\ extends file d bytes.
       1024 UM/MOD SWAP
       IF 1 + THEN (round up)
       MORE;

In the interests of keeping primitives primitive, assume that whoever calls EXTEND also maintains CAPACITY. Some operating systems extend files automatically, so you can use a null definition for EXTEND:

: EXTEND ( d  ) COMPILE 2DROP ;
\ null definition.
      IMMEDIATE

BLOCK and UPDATE give you direct access to a file. Data stream and text files, however, use sequential access, reading and writing the next group of characters or bytes. This implies that you should maintain a current (double-number) byte position for the file, which can be kept in a 2VARIABLE (or equivalent)--call it POSITION. POSITION is initialized to 0 when the file is first opened. The words GETDATA and PUTDATA can now be defined to read or write the next n bytes of a file to or from a memory location:

: GETDATA ( a n - n2) ...;
     \ reads n bytes of data from file
     \ into address, n < 64K. Returns
     \ n2 bytes not read, ie beyond
     \end of file. PUTDATA (a n) ...;
     \ writes n bytes of data to file
     \ from address, n < 64K.