Introduction

Welcome to SLP-FORTH, the Emulator.ca Systems implementation of an ANS Forth-compatible interpreter. This is not merely another programming language---it is a fundamentally different way of thinking about computation.

FORTH is unlike any programming language you have encountered before. Where most languages hide the machine behind layers of abstraction, FORTH invites you to think with the machine. There are no hidden mechanisms, no complex syntax rules, no operator precedence tables to memorize. Just a stack of numbers and a dictionary of words--and the freedom to extend that dictionary however you wish.

Charles H. Moore created FORTH in the late 1960s while working at the National Radio Astronomy Observatory. He needed a language that could control radio telescope equipment in real time, with limited memory and processing power. The result was a language of remarkable elegance: small enough to fit in a few kilobytes, yet extensible enough to tackle any problem. Since then, FORTH has found its way into satellites, industrial controllers, video games, and countless embedded systems where efficiency matters.

SLP-FORTH brings this heritage to your EC-series terminal. Within minutes of connecting, you can be experimenting with stack operations, defining your own words, and building programs from the ground up. The interactive nature of FORTH means you test each piece as you write it--no compile-link-run cycle, just immediate feedback.

This implementation provides:

• 156 Forth words covering the ANS Forth Core and Core Extensions
• Full control flow: IF/ELSE/THEN, BEGIN/UNTIL/WHILE/REPEAT, CASE/OF/ENDOF/ENDCASE
• Counted loops: DO/LOOP/+LOOP with I, J, LEAVE, UNLOOP
• Variables and constants with full memory operations
• Return stack access for temporary storage
• Strings: S", .", TYPE, and character operations
• Values: VALUE/TO for convenient named storage
• Execution tokens: ', EXECUTE, ['], FIND for meta-programming
• Introspection: WORDS, SEE, FORGET for dictionary exploration
• CREATE...DOES> for building custom data structures
• 32-bit signed integer arithmetic
• RS-232 modem flow control participation

Quick Start

Connect to SLP-FORTH and try these examples to get a feel for stack-based programming:

+------------------------------------------------------------------+
|  QUICK START SESSION                                             |
+------------------------------------------------------------------+
|  ATDT555-0400                                                    |
|  CONNECT 1200                                                    |
|                                                                  |
|    SLP-FORTH v2.1                                                |
|    Emulator.ca Systems                                           |
|                                                                  |
|  ok 5 3 + .                      \ Add 5 and 3, print result     |
|  8 ok                                                            |
|                                                                  |
|  ok : SQUARE  DUP * ;            \ Define a new word             |
|  ok 7 SQUARE .                   \ Use your word                 |
|  49 ok                                                           |
|                                                                  |
|  ok 10 0 DO I . LOOP             \ Count from 0 to 9             |
|  0 1 2 3 4 5 6 7 8 9 ok                                          |
|                                                                  |
|  ok VARIABLE COUNTER             \ Create a variable             |
|  ok 0 COUNTER !                  \ Store 0 in it                 |
|  ok COUNTER @ 1+ COUNTER !       \ Increment it                  |
|  ok COUNTER @ .                  \ Print it                      |
|  1 ok                                                            |
|                                                                  |
|  ok : GREET  ." Hello, World!" CR ;                              |
|  ok GREET                                                        |
|  Hello, World!                                                   |
|  ok                                                              |
+------------------------------------------------------------------+

Key concepts to remember:

1. Numbers go on the stack when you type them
2. Operations consume values from the stack and leave results
3. . prints and removes the top number; .S shows all without removing
4. : begins a definition; ; ends it
5. Everything after \ is a comment

Now read on to understand the philosophy and mechanics behind these simple commands.

The FORTH Philosophy

FORTH is built upon a deceptively simple concept: the stack. In most languages, you write expressions like 2 + 3 and the language figures out what to do. In FORTH, you place values on a stack and then invoke operations that consume and produce stack values:

2 3 +

This "Reverse Polish Notation" (RPN) style eliminates the need for parentheses and operator precedence rules. The expression (2 + 3) * 4 becomes simply:

2 3 + 4 *

Read it aloud: "Two. Three. Add them. Four. Multiply." Each word does exactly one thing, and you can see precisely what happens at each step.

Extensibility: The Heart of FORTH

In FORTH, you don't just write programs--you extend the language itself. Every word you define becomes indistinguishable from the built-in words. You build up a vocabulary specific to your problem domain, layer by layer, until solving the problem becomes a single word.

The Two Stacks

SLP-FORTH maintains two stacks:

• Data Stack -- The primary stack for passing parameters between words
• Return Stack -- Used internally for return addresses, but accessible for temporary storage

Most of your interaction will be with the data stack. The return stack is powerful but must be used carefully--it holds return addresses during word execution.

Getting Connected

To access the SLP-FORTH interpreter, configure your modem for dial-out and issue the following command:

ATDT555-0400

Upon successful connection, you will see the FORTH banner and the ok prompt:

The ok prompt indicates FORTH is ready to accept input. Unlike other languages that use "READY" or ">", FORTH's laconic ok reflects its minimalist philosophy.

Modem Signals

The FORTH interpreter participates fully in RS-232 signal protocol:

The Stack Concept

The data stack is FORTH's central mechanism for passing data between words. Think of it as a stack of cafeteria trays: you can only add to the top (push) or remove from the top (pop). The last item placed on the stack is the first one removed--this is called LIFO (Last In, First Out).

    STACK VISUALIZATION
    

    After: 5 3 7

         
          7   <- Top of Stack (TOS)
         
          3   <- Next on Stack (NOS)  
         
          5 
         
           ^
        Bottom

Basic Stack Operations

Enter numbers separated by spaces. Each number is pushed onto the stack:

The word .S (pronounced "dot-S") displays the stack contents without disturbing them. The <3> indicates there are 3 items on the stack.

Stack Notation Convention

FORTH uses a standard notation to document the stack effect of each word:

( before -- after )

The items before the -- are consumed from the stack; items after are left on the stack. For example:

+    ( n1 n2 -- sum )     \ Add n1 and n2, leave sum
DUP  ( n -- n n )         \ Duplicate top of stack
DROP ( n -- )             \ Discard top of stack
SWAP ( n1 n2 -- n2 n1 )   \ Exchange top two items

The backslash \ begins a comment that extends to end of line.

Stack Manipulation Words

These words rearrange values on the data stack without performing arithmetic. Mastering them is essential to writing elegant FORTH.

Arithmetic Operations

FORTH arithmetic words take their operands from the stack and leave results on the stack. All operations work with signed 32-bit integers.

Comparison and Logic

Comparison words test relationships between values and leave a flag on the stack. In ANS FORTH, 0 represents FALSE and -1 (all bits set) represents TRUE. Any non-zero value is treated as true in conditionals.

Logical Operations

These perform bitwise operations, useful for both logic and bit manipulation:

Input and Output

FORTH provides simple but powerful I/O words for terminal interaction.

Number Base

FORTH can work in different number bases:

Defining New Words

The true power of FORTH lies in extending the language with your own words. A word definition begins with : (colon) and ends with ; (semicolon):

: word-name  definition... ;

Compilation vs. Interpretation

When FORTH sees :, it enters compilation mode. Words entered are not executed immediately--they're compiled into the new definition. The ; returns to interpretation mode.

Immediate Words

Some words execute even during compilation. These are marked with IMMEDIATE after their definition. Control structure words like IF and DO are immediate--they compile branch instructions into your definition.

Control Structures

FORTH provides several control structures that can only be used inside colon definitions. They compile into efficient branch instructions.

IF...ELSE...THEN

Conditional execution based on a flag:

: word  ... flag IF true-part THEN ... ;
: word  ... flag IF true-part ELSE false-part THEN ... ;

The IF consumes a flag from the stack. If true (non-zero), the true-part executes; otherwise execution jumps to ELSE (if present) or THEN.

BEGIN...UNTIL

Loop that tests at the end (do-while style):

: word  ... BEGIN body flag UNTIL ... ;

The body executes, then UNTIL consumes a flag. If false, loop continues; if true, loop exits.

BEGIN...WHILE...REPEAT

Loop that tests at the beginning (while style):

: word  ... BEGIN condition WHILE body REPEAT ... ;

BEGIN...AGAIN

Infinite loop (use EXIT to break out):

: word  ... BEGIN body AGAIN ... ;

EXIT

Exit the current word immediately:

: FIND-ZERO  ( addr n -- addr | 0 )
   0 DO
      DUP I + C@
      0= IF DUP I + UNLOOP EXIT THEN
   LOOP
   DROP 0 ;

RECURSE

Call the word being defined from within itself. This enables recursive algorithms:

\ Recursive factorial using RECURSE
: FACTORIAL  ( n -- n! )
   DUP 1 > IF
      DUP 1- RECURSE *
   THEN ;

5 FACTORIAL . 120 ok

RECURSE compiles a call to the word currently being defined. Without RECURSE, you cannot call a word by name until its definition is complete (the ; is reached). This is the standard way to write recursive definitions in Forth.

Counted Loops (DO/LOOP)

FORTH provides powerful counted loops using the return stack:

The loop runs while index < limit. DO pushes the loop parameters onto the return stack; LOOP or +LOOP pops them when done.

Return Stack

The return stack is primarily used by FORTH for return addresses, but you can temporarily store values there:

Variables and Constants

FORTH provides named storage locations:

VALUES

VALUES are like constants but can be changed with TO:

Memory Operations

FORTH provides direct memory access:

CREATE and Arrays

CREATE makes a word that returns an address:

CREATE...DOES>

The DOES> word lets you create "defining words" that build custom data structures:

Strings

FORTH provides basic string handling:

Case Statements

For multi-way branching, use CASE:

: word  ... value
   CASE
      test1 OF action1 ENDOF
      test2 OF action2 ENDOF
      default-action
   ENDCASE ... ;

The selector value stays on the stack through the CASEs. When an OF matches, it drops the selector and executes the clause. ENDCASE drops the selector if no OF matched.

Execution Tokens

FORTH allows treating words as data through execution tokens:

Introspection

FORTH lets you examine and modify the dictionary:

Advanced Compilation

These words give you control over the compilation process:

Input Parsing

For advanced input processing:

Error Handling

Common Patterns and Idioms

Stack Manipulation Patterns

\ Square a number
: SQUARE  ( n -- n^2 )  DUP * ;

\ Double (two methods)
: DOUBLE  ( n -- n*2 )  DUP + ;
: DOUBLE  ( n -- n*2 )  2* ;

\ Absolute difference
: ABSDIFF  ( n1 n2 -- |n1-n2| )  - ABS ;

Conditional Patterns

\ Convert any non-zero to canonical TRUE
: BOOL  ( n -- flag )  0<> ;

\ Check if even/odd
: EVEN?  ( n -- flag )  1 AND 0= ;
: ODD?   ( n -- flag )  1 AND 0<> ;

\ Bounded value
: CLAMP  ( n min max -- n' )
   ROT MIN MAX ;

Loop Patterns

\ Sum 1 to n
: SUM-TO  ( n -- sum )
   0 SWAP  1+ 1 DO  I +  LOOP ;
10 SUM-TO . 55 ok

\ Factorial
: FACTORIAL  ( n -- n! )
   DUP 1 > IF
      DUP 1- FACTORIAL *
   ELSE
      DROP 1
   THEN ;
5 FACTORIAL . 120 ok

\ Iterate with callback (functional style)
: EACH  ( xt limit start -- )
   ?DO  DUP I SWAP EXECUTE  LOOP DROP ;
' . 5 0 EACH 0 1 2 3 4 ok

Quick Reference

Stack (15 words)

Arithmetic (16 words)

Comparison (13 words)

Logic (8 words)

Control Flow (13 words)

Counted Loops (8 words)

Return Stack (6 words)

I/O (17 words)

Variables & Memory (20+ words)

Definitions & Compilation (10 words)

Introspection (4 words)

Number Base (3 words)

Parsing (5 words)

Evaluation (2 words)

Error Handling (2 words)

Appendix A: Quick Reference Card

+================================================================+
|                  SLP-FORTH QUICK REFERENCE                     |
+================================================================+
|                                                                |
|  DIAL: ATDT555-0400                                            |
|                                                                |
|  STACK MANIPULATION                                            |
|  DUP  DROP  SWAP  OVER  ROT  NIP  TUCK  ?DUP                   |
|  2DUP  2DROP  2SWAP  2OVER  PICK  ROLL  DEPTH                  |
|                                                                |
|  ARITHMETIC                                                    |
|  +  -  *  /  MOD  /MOD  */  */MOD                              |
|  NEGATE  ABS  MIN  MAX  1+  1-  2*  2/                         |
|                                                                |
|  COMPARISON (true = -1, false = 0)                             |
|  =  <>  <  >  U<  U>  0=  0<>  0<  0>  WITHIN                  |
|  TRUE  FALSE                                                   |
|                                                                |
|  LOGIC (bitwise)                                               |
|  AND  OR  XOR  INVERT  LSHIFT  RSHIFT                          |
|                                                                |
|  CONTROL FLOW                                                  |
|  IF...ELSE...THEN  BEGIN...UNTIL  BEGIN...WHILE...REPEAT       |
|  BEGIN...AGAIN  CASE...OF...ENDOF...ENDCASE  EXIT              |
|                                                                |
|  COUNTED LOOPS                                                 |
|  DO  ?DO  LOOP  +LOOP  I  J  LEAVE  UNLOOP                     |
|                                                                |
|  RETURN STACK                                                  |
|  >R  R>  R@  2>R  2R>  2R@                                     |
|                                                                |
|  I/O                                                           |
|  .  U.  .R  U.R  CR  EMIT  SPACE  SPACES  .S  ."  .(           |
|  TYPE  COUNT  BL  KEY  KEY?  ACCEPT                            |
|                                                                |
|  VARIABLES & MEMORY                                            |
|  VARIABLE  CONSTANT  VALUE  TO  @  !  +!  C@  C!  2@  2!       |
|  HERE  ALLOT  ,  C,  CREATE  DOES>  CELLS  CHARS               |
|  MOVE  FILL  ERASE  CELL+  CHAR+  ALIGN  ALIGNED               |
|                                                                |
|  DEFINING & COMPILATION                                        |
|  : ... ;  IMMEDIATE  [ ]  LITERAL  POSTPONE  STATE             |
|  '  [']  EXECUTE  FIND  >BODY                                  |
|                                                                |
|  NUMBER BASE                                                   |
|  BASE  DECIMAL  HEX                                            |
|                                                                |
|  INTROSPECTION                                                 |
|  WORDS  SEE  FORGET                                            |
|                                                                |
|  STRINGS & PARSING                                             |
|  S"  CHAR  [CHAR]  SOURCE  >IN  WORD  PARSE  PARSE-NAME        |
|  EVALUATE  QUIT                                                |
|                                                                |
|  ERROR HANDLING                                                |
|  ABORT  ABORT"                                                 |
|                                                                |
+================================================================+

Appendix B: Troubleshooting

Stack Underflow

Symptom: Error message when a word expects more values than are on the stack.

Solution: Use .S frequently to monitor stack contents. Check your stack comments ( before -- after ) to ensure operations have the values they need.

Wrong Values or Order

Symptom: Calculations produce incorrect results.

Solution: Walk through your code step by step with .S after each word. Remember that FORTH operations often consume values in a specific order--5 3 - means 5 - 3, not 3 - 5.

Return Stack Imbalance

Symptom: System crash or strange behavior after using >R and R>.

Solution: Every >R must have a matching R> before the word exits. If you use EXIT inside a DO loop, call UNLOOP first.

Definition Not Working

Symptom: A word you defined does not behave as expected.

Solution: Use SEE to examine what was actually compiled. Test each component word individually before combining them.

Division by Zero

Symptom: Error from /, MOD, or /MOD.

Solution: Validate divisors before dividing:

: SAFE/  ( n1 n2 -- n3 )
   DUP 0= ABORT" Division by zero!" / ;

Loop Doesn't Run

Symptom: DO loop body never executes.

Solution: Remember that DO runs while index < limit. For 10 10 DO, use ?DO instead to skip empty ranges.

Connection Issues

Appendix C: Glossary

Colon Definition -- A user-defined word created with : and terminated with ;.

Compilation Mode -- The state entered after : where words are compiled into the dictionary rather than executed.

Data Stack -- The primary stack for passing parameters between words.

Dictionary -- The collection of all defined words, both built-in and user-created.

Execution Token (XT) -- A value that identifies a word and can be used with EXECUTE.

Flag -- A boolean value on the stack; 0 represents false, -1 (all bits set) represents true.

Immediate Word -- A word that executes during compilation rather than being compiled.

Interpretation Mode -- The normal state where words are executed immediately as entered.

LIFO -- Last In, First Out. The stack discipline where the most recently added item is the first removed.

NOS -- Next on Stack. The second item from the top.

Return Stack -- Secondary stack used for return addresses and temporary storage.

RPN -- Reverse Polish Notation. The postfix notation where operators follow their operands.

Stack Effect -- The change a word makes to the stack, documented as ( before -- after ).

TOS -- Top of Stack. The most recently pushed item.

Word -- The FORTH term for a named operation, whether built-in or user-defined.

Appendix D: Word Standards Reference

This appendix shows which standard each word first appeared in. Words marked ANS were standardized in 1994; those marked F2012 are from the 2012 standard. Words marked Forth-83 were available in the 1983 standard.

Words from Forth-83 (1983)

These words have been standard since 1983 or earlier:

Stack: DUP, DROP, SWAP, OVER, ROT, 2DUP, 2DROP, 2SWAP, ?DUP, DEPTH, PICK, ROLL

Arithmetic: +, -, , /, MOD, /MOD, NEGATE, ABS, MIN, MAX, 1+, 1-, 2, 2/

Comparison: =, <, >, 0=, 0<, U<

Logic: AND, OR, XOR, INVERT (was NOT in Forth-83)

I/O: ., CR, EMIT, SPACE, SPACES, TYPE, COUNT

Memory: @, !, C@, C!, HERE, ALLOT, ,, C,, CELLS, CHARS

Definitions: :, ;, CONSTANT, VARIABLE, CREATE, DOES>

Control: IF, ELSE, THEN, BEGIN, UNTIL, WHILE, REPEAT, DO, LOOP, +LOOP, I, J, LEAVE

Return Stack: >R, R>, R@

Compilation: ', EXECUTE, IMMEDIATE, [, ], LITERAL, STATE

Other: WORD, BASE, DECIMAL, HEX

Words from ANS Forth (1994)

These words were standardized in ANS Forth 1994:

Stack: NIP, TUCK, 2OVER

Arithmetic: */, */MOD

Comparison: <>, 0<>, 0>, U>, WITHIN, TRUE, FALSE

Logic: LSHIFT, RSHIFT

I/O: U., .R, U.R, BL, .S, .", .(, ACCEPT

Memory: +!, 2@, 2!, CELL+, CHAR+, MOVE, FILL, ERASE, ALIGN, ALIGNED

Definitions: VALUE, TO

Control: ?DO, UNLOOP, AGAIN, EXIT, CASE, OF, ENDOF, ENDCASE

Return Stack: 2>R, 2R>, 2R@

Compilation: ['], POSTPONE, FIND, >BODY, CHAR, [CHAR]

Parsing: SOURCE, >IN, PARSE

Evaluation: EVALUATE, QUIT

Error: ABORT, ABORT"

Introspection: WORDS, SEE, FORGET

Words from Forth 2012

Parsing: PARSE-NAME

Notes on Historical Accuracy

SLP-FORTH implements a blend of Forth-83 and ANS Forth words, chosen for practical utility rather than strict historical accuracy. If you require a period-accurate 1983 experience, avoid using words marked ANS or F2012 above.

Key differences from a pure Forth-83 system:

1. TRUE/FALSE values: Forth-83 used 1 for true; ANS Forth uses -1
2. POSTPONE: Replaces Forth-83's [COMPILE] and COMPILE
3. VALUE/TO: Did not exist until late 1980s
4. CASE statements: Common vendor extension but not standard until ANS
5. ?DO: ANS addition for skipping empty loops

See Also

• ANS Forth Standard -- The 1994 language specification (dpans94)
• Starting FORTH by Leo Brodie -- An excellent tutorial for beginners
• Thinking FORTH by Leo Brodie -- Advanced FORTH programming philosophy
• SLP-BASIC (555-0300) -- If you prefer a more traditional BASIC environment
• SLP-LOGO (555-0310) -- A visual approach to learning programming concepts
• SLP-Scheme (555-0330) -- Another minimal, elegant language worth exploring