- •Contents
- •List of Figures
- •List of Tables
- •Welcome!
- •About the Forth Programming Language
- •About This Book
- •How to Use This Book
- •Reference Materials
- •How to Proceed
- •1. Introduction
- •1.1.1 Definitions of Terms
- •1.1.2 Dictionary
- •1.1.3 Data Stack
- •1.1.4 Return Stack
- •1.1.5 Text Interpreter
- •1.1.6 Numeric Input
- •1.1.7 Two-stack Virtual Machine
- •1.2 Forth Operating System Features
- •1.3 The Forth Assembler
- •1.3.1 Notational Differences
- •1.3.1.1 Instruction Mnemonics
- •1.3.1.2 Addressing Modes
- •1.3.1.3 Instruction Format
- •1.3.1.4 Labels, Branches, and Structures
- •1.3.2 Procedural Differences
- •1.3.2.1 Resident Assembler
- •1.3.2.2 Immediately Executable Code
- •1.3.2.3 Relationship to Other Routines
- •1.3.2.4 Register Usage
- •1.4 Documentation and Programmer Aids
- •1.4.1 Comments
- •1.4.2 Locating Command Source
- •1.4.3 Cross-references
- •1.4.4 Decompiler and Disassembler
- •1.5 Interactive Programming—An Example
- •2. Forth Fundamentals
- •2.1 Stack Operations
- •2.1.1 Stack Notation
- •2.1.2 Data Stack Manipulation Operations
- •2.1.3 Memory Stack Operations
- •2.1.4 Return Stack Manipulation Operations
- •2.1.5 Programmer Conveniences
- •2.2 Arithmetic and Logical Operations
- •2.2.1 Arithmetic and Shift Operators
- •Single-Precision Operations
- •Double-precision Operations
- •Mixed-precision Operations
- •2.2.2 Logical and Relational Operations
- •Single-Precision Logical Operations
- •Double-Precision Logical Operations
- •2.2.3 Comparison and Testing Operations
- •2.3 Character and String Operations
- •2.3.1 The PAD—Scratch Storage for Strings
- •2.3.2 Single-Character Reference Words
- •2.3.3 String Management Operations
- •2.3.4 Comparing Character Strings
- •2.4 Numeric Output Words
- •2.4.1 Standard Numeric Output Words
- •2.4.2 Pictured Number Conversion
- •2.4.2.1 Using Pictured Numeric Output Words
- •2.4.2.2 Using Pictured Fill Characters
- •2.4.2.3 Processing Special Characters
- •2.5 Program Structures
- •2.5.1 Indefinite Loops
- •2.5.2 Counting (Finite) Loops
- •2.5.3 Conditionals
- •2.5.4 CASE Statement
- •2.5.5 Un-nesting Definitions
- •2.5.6 Vectored Execution
- •2.6 Exception Handling
- •3. System Functions
- •3.1 Vectored Routines
- •3.2 System Environment
- •3.3 Serial I/O
- •3.3.1 Terminal Input
- •3.3.2 Terminal Output
- •3.3.3 Support of Special Terminal Features
- •3.4 Block-Based Disk Access
- •3.4.1 Overview
- •3.4.2 Block-Management Fundamentals
- •3.4.3 Loading Forth Source Blocks
- •3.4.3.1 The LOAD Operation
- •3.4.3.2 Named Program Blocks
- •3.4.3.3 Block-based Programmer Aids and Utilities
- •3.5 File-Based Disk Access
- •3.5.1 Overview
- •3.5.2 Global File Operations
- •3.5.3 File Reading and Writing
- •3.5.4 File Support Words
- •3.6 Time and Timing Functions
- •3.7 Dynamic Memory Management
- •3.8 Floating Point
- •3.8.1 Floating-Point System Guidelines
- •3.8.2 Input Number Conversion
- •3.8.3 Output Formats
- •3.8.4 Floating-Point Constants, Variables, and Literals
- •3.8.5 Memory Access
- •3.8.6 Floating-Point Stack Operators
- •3.8.7 Floating-Point Arithmetic
- •3.8.8 Floating-Point Conditionals
- •3.8.9 Logarithmic and Trigonometric Functions
- •3.8.10 Address Management
- •3.8.11 Custom I/O
- •4. The Forth Interpreter and Compiler
- •4.1 The Text Interpreter
- •4.1.1 Input Sources
- •4.1.2 Source Selection and Parsing
- •4.1.3 Dictionary Searches
- •4.1.4 Input Number Conversion
- •4.1.5 Character String Processing
- •4.1.5.1 Scanning Characters to a Delimiter
- •4.1.5.2 Compiling and Interpreting Strings
- •4.1.6 Text Interpreter Directives
- •4.2 Defining Words
- •4.2.1 Creating a Dictionary Entry
- •4.2.2 Variables
- •4.2.3 CONSTANTs and VALUEs
- •4.2.4 Colon Definitions
- •4.2.5 Code Definitions
- •4.2.6 Custom Defining Words
- •4.2.6.1 Basic Principles of Defining Words
- •4.2.6.2 High-level Defining Words
- •4.3 Compiling Words and Literals
- •4.3.1 ALLOTing Space in the Dictionary
- •4.3.2 Use of , and C, to Compile Values
- •4.3.3 The Forth Compiler
- •4.3.4 Use of Literals and Constants in : Definitions
- •4.3.5 Explicit Literals
- •4.3.6 Use of ['] to Compile Literal Addresses
- •4.3.7 Compiling Strings
- •4.4 Compiler Directives
- •4.4.1 Making Compiler Directives
- •4.5 Overlays
- •4.6 Word Lists
- •4.6.1 Basic Principles
- •4.6.2 Managing Word Lists
- •4.6.3 Sealed Word Lists
- •5. The Assembler
- •5.1 Code Definitions
- •5.2 Code Endings
- •5.3 Assembler Instructions
- •5.4 Notational Conventions
- •5.5 Use of the Stack in Code
- •5.6 Addressing Modes
- •5.7 Macros
- •5.8 Program Structures
- •5.9 Literals
- •5.10 Device Handlers
- •5.11 Interrupts
- •5.12 Example
- •6.1 Guidelines for BLOCK-based source
- •6.1.1 Stack Effects
- •6.1.2 General Comments
- •6.1.3 Spacing Within Source
- •6.2.1 Typographic Conventions
- •6.2.2 Use of Spaces
- •6.2.3 Conditional Structures
- •6.2.4 do…loop Structures
- •6.2.5 begin…while…repeat Structures
- •6.2.6 begin…until…again Structures
- •6.2.7 Block Comments
- •6.2.8 Stack Comments
- •6.2.9 Return Stack Comments
- •6.2.10 Numbers
- •6.3 Wong’s Rules for Readable Forth
- •6.3.1 Example: Magic Numbers
- •6.3.2 Example: Factoring
- •6.3.3 Example: Simplicity
- •6.3.4 Example: Testing Assumptions
- •6.3.5 Example: IF Avoidance
- •6.3.6 Example: Stack Music
- •6.3.7 Summary
- •6.4 Naming Conventions
- •Appendix A: Bibliography
- •Appendix B: Glossary & Notation
- •B.1 Abbreviations
- •B.2 Glossary
- •B.3 Data Types in Stack Notation
- •B.4 Flags and IOR Codes
- •B.5 Forth Glossary Notation
- •Appendix C: Index to Forth Words
- •General Index
2. FORTH FUNDAMENTALS
This section defines the major elements of the Forth language. These words are grouped into categories. Except where noted as deriving from “common usage,” all words are found in, and comply with, the American National Standard for the Forth language (ANSI X3.215:1994, equivalent to ISO/IEC 15145:1997), commonly referred to here as Standard Forth. Appendix A,“Glossary & Notation” on page 203 provides definitions of many of the terms used in this section, as well as a detailed description of the notation conventions.
2.1 STACK OPERATIONS
Forth is based on an architecture incorporating push-down stacks (last-in, first-out lists). The data stack is used primarily for passing parameters between procedures. The return stack is used primarily for system functions, such as procedure return addresses, loop parameters, etc.
Stack operators work on data that are on one or more of the stacks. The words defined in this section use the stack as the major source and destination for their operands. Many other Forth words also result in modification of the stack, and are described in the sections of this manual that deal with their primary functions. Besides the stack operators discussed in this manual, stack manipulation words that relate to assembly language are covered in Section 5 and in your Forth system’s documentation.
2.1.1 Stack Notation
Stack parameters used as input to and output from a procedure are described using the notation:
Forth Fundamentals 31
Forth Programmer’s Handbook
( stack-id before — after )
Operations that use the stack usually require that a certain number of items be present on the stack, and then leave another number of items on the stack as results. Most operations remove their operands, leaving only the results. To help see an operation’s effect on the number and type of items on the stack, each word has a stack notation.
Individual stack items are depicted using the notation in Table 11, Section B.3. Any other, special notation will be explained when used. Where several arguments are of the same type, and clarity demands that they be distinguished, numeric subscripts are used.
If you type several numbers on a line, the rightmost will end up on top of the stack. As a result, we show multiple stack arguments with the top element to the right. If alternate conditions may exist, they are separated by a vertical bar (|), meaning “or.” For example, the notation ( — n1 | n2 n3 ) indicates a word that may leave either one or two stack items; and ( — addr | 0 ) indicates that the procedure takes no input and returns either a valid address or zero.
Please remember that the items shown in a word’s stack notation are relative to the top of the stack and do not affect any stack items that may be below the lowest stack item referenced by the operation. For example, ( x1 x2 — x3 ) describes an operation that uses the top two stack items and leaves a different, one-item result. Therefore, if the stack initially contained three items, execution would result in a stack of two items, with the bottom item unchanged and the top item derived as a result of the operation.
Some procedures have stack effects both when they are compiled and when they are executed. The stack effects shown in this manual refer to the execu- tion-time behavior unless specifically noted, because this is usually the behavior of most interest to a programmer.
Where an operation is described that uses more than one stack, the data stack stack-id is S: and the return stack stack-id is R:. When no confusion is possible, the data stack stack-id may be omitted.
With the addition of the floating-point stack (see Section 3.8), it becomes necessary to document its contents, as well. Floating-point stack comments follow the data stack comments, and are indicated by F:. If a command does not affect
32 Forth Fundamentals
Forth Programmer’s Handbook
the floating-point stack, only the data stack comments are shown, and vice versa. If neither stack is affected, a null data stack comment is shown.
For example:
: SF@ ( a-addr — ) ( F: — r )
indicates that an address is removed from the data stack, and a floating-point number is pushed on the floating-point stack by the execution of SF@.
: F. ( F: r — )
indicates that there are no data stack arguments, and that a floating-point number is removed from the floating-point stack by the execution of F..
References Data stack, Section 1.1.3
Data types in stack notation, Section B.3
2.1.2 Data Stack Manipulation Operations
This category of stack operations contains words which manipulate the contents of the data stack without performing arithmetic, logical, or memory reference operations.
Glossary |
|
|
|
|
2DROP |
( x1 x2 |
— ) |
Core |
|
|
Remove the top pair of cells from the stack. The cell values may or may not be |
|||
|
related. “two-drop” |
|
|
|
2DUP |
( x1 |
x2 |
— x1 x2 x1 x2 ) |
Core |
|
Duplicate the top cell pair x1 x2. “two-dup” |
|
||
2OVER |
( x1 |
x2 |
x3 x4 — x1 x2 x3 x4 x1 x2 ) |
Core |
|
Copy cell pair x1 x2 to the top of the stack. “two-over” |
|
||
2ROT |
( x1 |
x2 |
x3 x4 x5 x6 — x3 x4 x5 x6 x1 x2 ) |
Double Ext |
Rotate the top three cell pairs on the stack, bringing cell pair x1 x2 to the top of
Forth Fundamentals 33
Forth Programmer’s Handbook
|
the stack. “two-rote” |
|
2SWAP |
( x1 x2 x3 x4 — x3 x4 x1 x2 ) |
Core |
|
Exchange the top two cell pairs. “two-swap” |
|
?DUP |
( x — 0 | x x ) |
Core |
|
Conditionally duplicate the top item on the stack, if its value is non-zero. |
|
|
“question-dup” |
|
|
Logically equivalent to: DUP IF DUP THEN |
|
DEPTH |
( — +n ) |
Core |
|
Return the number of single-cell values that were on the stack before this word |
|
|
executed. DEPTH will return 2 for each double-precision integer on the stack. |
|
DROP |
( x — ) |
Core |
|
Remove the top entry from the stack. |
|
DUP |
( x — x x ) |
Core |
|
Duplicate the top entry on the stack. |
|
NIP |
( x1 x2 — x2 ) |
Core Ext |
|
Drop the second item on the stack, leaving the top unchanged. |
|
OVER |
( x1 x2 — x1 x2 x1 ) |
Core |
|
Place a copy of x1 on top of the stack. |
|
PICK |
( +n — x ) |
Core Ext |
|
Place a copy of the nth stack entry on top of the stack. The zeroth item is the top |
|
|
of the stack; i.e., 0 PICK is equivalent to DUP and 1 PICK is equivalent to OVER. |
|
ROLL |
( +n ) |
Core Ext |
|
Move the nth stack entry to the top of the stack, moving down all the stack |
|
|
entries in between. The zeroth item is the top of the stack; i.e., 0 ROLL does |
|
|
nothing, 1 ROLL is equivalent to SWAP, 2 ROLL is equivalent to ROT. |
|
ROT |
( x1 x2 x3 — x2 x3 x1 ) |
Core |
|
Rotate the top three items on the stack. |
|
SWAP |
( x1 x2 — x2 x1 ) |
Core |
|
Exchange the top two items on the stack. |
|
34 Forth Fundamentals