| Forth Programming Language |
Article Index for Forth |
Articles about Forth |
Website Links For Forth |
Information AboutForth Programming Language |
|
Forth is a in 1994 . Forth is sometimes spelled in all capital letters following the customary usage during its earlier years, although the name is not an Acronym . A Procedural , Stack-oriented , Reflective , and Typeless programming language, Forth features both interactive execution of commands (making it suitable as a Shell for systems that lack a more formal Operating System ) and the ability to Compile sequences of commands for later execution. Some Forth versions (especially early ones) compile Threaded Code , but many implementations today generate Optimized Machine Code like other language compilers. Forth is so named because " file holding the interpreter was labeled FORTH, for 4th (next) generation software - but the operating system restricted file names to 5 characters.[http://www.colorforth.com/HOPL.html " Moore's use of the phrase ''4th (next) generation software'' appears to predate the definition of Fourth-generation Programming Language s; he saw Forth as a successor to compile-link-go Third-generation Programming Language s, or software for "4th generation" hardware, not a 4GL as we understand the term today. OVERVIEW Forth offers a standalone programming environment consisting of a Stack-oriented , interactive, incremental Interpreter and Compiler . Programming is done by extending the language with ''words'' (the term used for Forth Subroutine s), which become part of the language once defined. A typical Forth package will consist of a pre-compiled kernel of the core words, which the programmer uses to define new words for the application. The application, once complete, can be saved as an image, with the programmer specified words already compiled. Generally, programmers extend the initial core with words that are useful to the types of applications that they write, and save this as their working foundation. The logical structure of Forth resembles a Virtual Machine . Forth, especially early versions, implement an ''inner interpreter'' tracing Indirectly Threaded Machine Code , giving compact and fast high-level code that can be compiled rapidly. More modern implementations generate optimized machine code like other language compilers. Forth became very popular in the 1980s because it was well suited to the small , efficient memory use, shortened development time, and fast execution speed. It has been implemented efficiently on modern RISC Processor s, and Processors That Use Forth As Machine Language have been produced. Other uses of Forth include the Open Firmware Boot ROMs used by Apple , IBM , the Boot Loader on Sun SPARC computers and by the FreeBSD operating system as the First Stage Boot Controller . Forth is one of the simplest extensible languages; the modular and extensible nature of Forth permits the writing of high-level applications such as CAD systems. Unfortunately, extensibility also helps poor programmers to write incomprehensible code, which has caused Forth to acquire a reputation as a "write-only" language. However, Forth has been used successfully in large and complex projects, and applications developed by competent and disciplined professionals have been shown to be easily maintained over decades of use on evolving hardware platforms. FORTH FROM A PROGRAMMER'S PERSPECTIVE
''300 ok''
: FLOOR5 ( n -- n' ) DUP 6 < IF DROP 5 ELSE 1 - THEN ; This code defines a new word (again, 'word' is the term used for a subroutine) called FLOOR5 using the following commands: DUP simply duplicates the number on the stack; < compares the two numbers on the stack and replaces them with a true-or-false value; IF takes a true-or-false value and chooses to execute commands immediately after it or to skip to the ELSE; DROP discards the value on the stack; and THEN ends the conditional. The text in parentheses is a comment, advising that this word expects a number on the stack and will return a possibly changed number. The net result is a function that performs similarly to this function written in the Python Programming Language :def floor5(v): if v < 6: return 5 else: return v - 1 and similarly to this function written in the C Programming Language : int floor5(int v) { return v < 6 ? 5 : v - 1; } An even terser Forth definition of FLOOR5 that gives the same result:: FLOOR5 ( n -- n' ) 1- 5 MAX ; FACILITIES OF A FORTH SYSTEM Interpreter Forth has no Formal Grammar , so Parsing is very simple. The interpreter reads a line of input from the user input device, which is then parsed for a word using spaces as a Delimiter ; some systems recognise additional Whitespace characters. When the interpreter finds a word, it tries to look the word up in the ''dictionary''. If the word is found, the interpreter executes the code associated with the word, and then returns to parse what is left of the input stream. If the word isn't found, the word is assumed to be a number, and an attempt is made to convert it into a number and push it on the stack; if successful, the interpreter continues parsing the input stream. Otherwise, if both the lookup or number conversion fails, the interpreter prints the word followed by an error message indicating the word is not recognised, flushes the input stream, and waits for new user input. Compiler The compiler extends the interpreter. If the word is found, the interpreter ''compiles'' instead of executing the code associated with the word. (An exception to this rule are words that are marked IMMEDIATE; they are always executed, not compiled, in either state.) Compilation is started with : (colon), which takes a name as a parameter and creates a ''dictionary'' entry. Forth returns to interpreter mode with ; (semi-colon). The simplicity of the interpreter is therefore extended to the compiler; for instance10 DUP 1+ . . will interpret the line and print 11 10 on the output device.: X DUP 1+ . . ; will compile the word X. When executed by typing 10 X at the console this will print 11 10.Assembler Most Forth systems include a specialized Assembler that produces executable words. Forth assemblers often use a reverse-polish syntax in which the parameters of an instruction precede the instruction. The usual design of a Forth assembler is to construct the instruction on the stack, then copy it into memory as the last step. Registers may be referenced by the name used by the manufacturer, numbered (0..n, as used in the actual operation code) or named for their purpose in the Forth system: e.g. "S" for the register used as a stack pointer. Operating System, Files and MultiTasking Classic Forth systems traditionally use no Operating System nor File System . Instead of storing code in files, source-code is stored in disk blocks written to physical disk addresses. The word BLOCK is employed to translate the number of a 1K-sized block of disk space into the address of a buffer containing the data, which managed automatically by the Forth system. Some implement contiguous disk files using the system's disk access, where the files are located at fixed disk block ranges. Usually these are implemented as fixed-length binary records, with an integer number of records per disk block. Quick searching is achieved by hashed access on key data.Multitasking , most commonly Cooperative Round-robin Scheduling is normally available (although multitasking words and support are not covered by the ANSI Forth Standard). The word PAUSE is used to save the current task's execution context, to locate the next task, and restore its execution context. Each task has its own stacks, private copies of some control variables and a scratch area. Swapping tasks is simple and efficient; as a result, Forth multitaskers are available even on very simple microcontrollers such as the 8051, AVR, and MSP430.By contrast, some Forth systems run under a host operating system such as Microsoft Windows , Linux or a version of Unix and use the host operating system's file system for source and data files; the ANSI Forth Standard describes the words used for I/O. Other non-standard facilities include a mechanism for issuing Call s to the host OS or windowing systems, and many provide extensions that employ the scheduling provided by the operating system. Typically they have a larger and different set of words from the stand-alone Forth's PAUSE word for task creation, suspension, destruction and modification of priority.Self (meta) and Cross Compilation A full-featured Forth system with all source code will compile itself, a technique commonly called meta-compilation by Forth programmers (although the term doesn't exactly match Meta-compilation as it is normally defined). The usual method is to redefine the handful of words that place compiled bits into memory. The compiler's words therefore use specially-named versions of fetch and store that can be redirected to fetch and store to a buffer area in memory. The buffer area simulates or accesses a memory area beginning at a different address than the code buffer. Such compilers define words to access both the target computer's memory, and the host (compiling) computer's memory. After the fetch and store operations are redefined for the code space, the compiler, assembler, etc. are recompiled using the new definitions of fetch and store. This effectively reuses all the code of the compiler and interpreter. Then, the Forth system's code is compiled, but this version is stored in the buffer. The buffer in memory is written to disk, and ways are provided to load it temporarily into memory for testing. When the new version appears to work, it is written over the previous version. There are numerous variations of such compilers for different environments. For Embedded System s, the code may instead be written to another computer over a serial port or even a single TTL bit, while keeping the word names and other non-executing parts of the dictionary in the original compiling computer. The minimum definitions to "remote" a forth compiler are the words that fetch and store a byte, and the word that commands a forth word to be executed. Often the most time-consuming part of a remote port is to construct the initial program to implement fetch, store and execute. Many modern microprocessors have integrated debugging features (such as the Motorola CPU32 ) that eliminate even this task. STRUCTURE OF THE LANGUAGE The basic data structure of Forth is the "dictionary" which maps "words" to executable code or named data structures. The dictionary is laid out in memory as a Linked List with the links proceeding from the latest (most recently) defined word to oldest, until a sentinel, usually a NULL pointer, is found. A defined word generally consists of ''head'' and ''body'' with the head consisting of the ''name field'' (NF) and the ''link field'' (LF) and body consisting of the ''code field'' (CF) and the ''parameter field'' (PF). Head and body of a dictionary entry are treated separately because they may not be contiguous. For example, when a Forth program is recompiled for a new platform, the head may remain on the compiling computer, while the body goes to the new platform. In some environments (such as Embedded System s) the heads occupy memory unnecessarily. However, some cross-compilers may put heads in the target if the target itself is expected to support an interactive Forth. Dictionary Entry The exact format of a dictionary entry is not prescribed, and implementations vary. However, certain components are almost always present though the exact size and order may vary. Described as a C language structure, a dictionary entry might look this way: struct forthword {
}; |
|
|