udamonic.com
  • Start
    • What is a Scamp?
    • Getting Started
    • Getting Started (Windows)
  • Learn
    • What is Forth?
    • Arithmetic
    • The Stack
    • Creating Words
    • Compilation Tricks
    • Decompilation
    • Comments
    • Characters and Strings
    • Accessing Memory
    • Constants, Variables and Values
    • Flow Control
    • Loops
    • Data Structures
    • Doubles, Triples and Quads
    • FlashForth Dictionary Reference
    • Scamp Dictionary Reference
  • Extras
    • Interrupts
    • Timers
    • Multitasking
    • Delays and Tick Count
    • Processor Words
    • Starting up with turnkey
    • Changing the Prompt
    • Formatting Text on Screen
  • Interfacing
    • Using the LED Array
    • Temperature Sensor
    • Input/Output
    • Analog Input
    • Serial >
      • Serial Communication
      • Scamp2 UART Pins
    • I2C >
      • I2C Overview
      • I2C Commands
    • SPI
    • PWM
    • Peripheral Pin Select
    • Input Capture
    • Digital Signal Modulator
  • Create
    • Creating PCBs >
      • Designing PCBs
      • Fabricating PCBs
      • Soldering
    • Sensing >
      • Measuring Temperature
    • LEDs >
      • Adding LEDs
      • LED arc-welder effect
    • Displays >
      • Adding a 7 Segment Display
      • Adding a Touch LCD
      • Touch LCD GUI
      • Game of Pong
    • Adding Extra GPIO
    • Adding a Low Side Switch
    • FizzBuzz
    • Adding MRAM
    • Model Train Control
    • Adding a Real Time Clock
    • Scamp Projects on Youtube
  • Resources
  • Store
  • About
  • Contact

FlashForth Glossary
​

So far we've covered the basics of Forth. There's a lot more to FlashForth.  This page lists the words that come standard in FlashForth. For words specific to the Scamp BSP, see the Scamp Dictionary Reference.

Below is the dictionary compiled by Mikael Nordman of the "standard" build of FlashForth (excluding the words that are specific to the Scamp). Use it as a reference in conjunction with the words command on your Scamp.

Dictionary of FlashForth 5.0 20.03.2018

!          ( x addr -- )
           Store x to addr

!p         ( addr -- )
           Store addr to p(ointer) register

!p>r       ( addr -- )   COMPILE_ONLY
           Push contents of p to return stack and stor addr to p

#          ( ud1 -- ud2 )  COMPILE_ONLY
           Convert 1 digit to formatted numeric string

#>         ( ud1 -- c-addr u )  COMPILE_ONLY
           Leave address and count of formatted numeric string

#s         ( ud1 -- ud2 )  COMPILE_ONLY
           Convert remaining digits to formatted numeric output

'          ( -- xt )
           Parse word and find it in dictionary

'emit      ( -- addr )  User Variable
           EMIT vector. TX0, TX1, TX2 or TXU

'key       ( -- addr )  User Variable
           KEY vector.  RX0, RX1, TX2, or RXU

'key?      ( -- addr )  User Variable
           KEY? vector. RX0?, RX1?, TX2?, or RXU?

'source    ( -- a-addr )     User Variable 
           Current input source

(          ( -- )
           Skip input on the same line until ) is encountered

*          (u1/n1 u2/n2 -- u3/n3
           Signed and unsigned 16*16->16 bit multiplikation

*/         ( n1 n2 n3 -- quotient )
           Multiply n1 and n2 and
           divide with n3. 32 bit intermediate result.

*/mod      ( n1 n2 n3 -- rem quot )
           Multiply n1 with n2 and divide with n3 via 32-bit 
           intermediate result

+          ( n1 n2 -- n3 )
           Add n1 to n2

+!         ( n addr -- )
           Add n to cell at addr.

,          ( x -- )
           Append x to the current data section

,"         ( "string" -- )
           Append a string at HERE.

-          ( n1 n2 -- n3 )
           Subtract n2 from n1

.          ( n -- )
           Display n signed according to base

.s         ( -- )
           Display the stack contents

.st        ( -- )
           Emit status string for base, current data section,
           and display the stack contents.

/          ( n1 n2 -- n3 )
           16/16->16 bit signed division
           
/mod       ( n n  -- rem quot )
           16/16 -> 16-bit signed division.

/string    ( addr u n -- addr+n u-n )
           Trim string

0<         ( n -- flag )
           Leave true flag if n is less than zero

0=         ( x -- flag )
           Leave true flag if x is zero

1          ( -- 1 ) 
           Leave one

1+         ( n -- n1 )
           Add one to n

1-         ( n -- n1 )
           Subtract 1 from n

2*         ( u1 -- u2 )
           Shift u1 left one bit

2+         ( n -- n1 )
           Add two to n

2-         ( n -- n1 )
           Subtract 2 from n

2/         (n1 -- n2 )
           Shift n1 right one bit.

2@         ( a-addr -- x1 x2 )
           Fetch two cells

2!         ( x1 x2 a-addr -- )
           Store two cells

2constant  ( x x "name" -- )
           Define a double constant

2drop      ( x1 x2 -- )
           Drop two cells

2dup       ( x1 x2  -- x1 x2 x1 x2 )
           Duplicate two top cells

2variable ( "name" -- )
          Define a double variable

:          ( "name" -- )
           Begin a colon definition

:noname    ( -- addr )
           Define headerless forth code

;          ( -- )    COMPILE_ONLY
           End a colon definition

;i         ( -- )    COMPILE_ONLY
           End a interrupt word

<          ( n1 n2 -- flag )
           Leave true flag if n1 is less than n2

<#         ( -- )        Compile Only
           Begin numeric conversion

<>         ( x1 x2 -- flag )
           Leave true flag if x1 and x2 are not equal

=          ( x1 x2 -- flag )
           Leave true flag if x1 and x2 are equal

>          ( n1 n2 -- flag )
           Leave true flag if n1 is grater than n2

>a         ( x -- )
           Write to the A register

>body      ( xt -- a-addr )
           Leave the parameter field address of 
           a created word

>in        ( -- a-addr )      User Variable
           Holds offset into tib

>number    ( ud  c-addr1 u1 -- ud c-addr2 u2 )
           Convert string to number

>pr        ( c -- c )
           Convert a character to a graphic ASCII value.
           Non-graphic characters are converted to a dot.

>r         ( x -- ) ( R: -- x )  COMPILE_ONLY
           Push x from the parameter stack to the return stack

>xa        ( a-addr1 -- a-addr2 )
           Convert a flash virtual address to real
           executable address.
           
?abort     ( flag c-addr u -- )
           Print message and abort if flag is false

?abort?    ( flag -- )
           If flag is false output ? and abort

?dnegate   ( d n -- d )
           Negate d if n is negative
           
?negate    ( n1 n2 -- n3 )
           Negate n1 if n2 is negative

@          ( a-addr -- x )
           Fetch x from a-addr

@+         ( a-addr1 -- a-addr2 x )
           Fetch cell from a-addr1 and increment
           a-addr1 by cellsize
           
@p         ( -- addr )
           Fetch the p register to the stack

@ex        ( addr -- )
           Fetch vector from addr and execute.

[          ( -- )
           Enter interpreter state

[']        ( "name" -- )   COMPILE_ONLY
           Compile xt of name as a literal

[char]     ( "char" -- )   COMPILE_ONLY
           Compile inline ascii character

[i         ( -- )   COMPILE_ONLY
           Enter Forth interrupt context

\          ( -- )
           Skip rest of line, used for comments

]          ( -- )
           Enter compilation state

a>         ( -- x )
           Read from the A register

abort      ( -- )
           Reset stack pointer and execute quit

abort"     ( "string" -- )  COMPILE_ONLY
           Compile inline string and postpone ?abort

abs        ( n -- n1 )
           Leave absolute value of n

accept     ( c-addr +n -- +n' )
           Get line from terminal

again      ( a-addr -- )  COMPILE_ONLY
           begin ... again

aivt       ( -- )
           Activate the alternate interrupt vector table

align      ( -- )
           Align the current data section dictionary pointer
           to cell boundary

aligned    ( addr -- a-addr )
           Align addr to a cell boundary.

allot      ( n -- )
           Adjust the current data section dictionary pointer

and        ( x1 x2 -- x3 )
           Bitwise and of x1 and x2

base       ( -- a-addr )     User Variable
           Numeric conversion base

begin      ( -- a-addr )  COMPILE_ONLY
           begin ... again
           begin ... until
           begin ... while ... repeat

binary     ( -- )
           Set base to binary

bl         ( -- c )
           ASCII space (a blank)

busy       ( -- )
           CPU idle mode not allowed
           
c!         ( c c-addr -- )
           Store c to c-addr

c@         ( c-addr -- c )
           Fetch c from addr

c@+        ( c-addr1 -- c-addr2 c )
           Fetch char from addr1 and increment addr1

c,         ( c -- )
           Append c to the current data section

case       ( n -- n ) COMPILE_ONLY
           Start a case construct

cell       ( -- n )
           Leave the size of one cell in characters.

cell+      ( a-addr1 -- a-addr2 )
           Add cell size to addr1

cells      ( n1 -- n2 )
           Convert cells to address units.

char       ( "char" -- n )
           Parse a char and leave ascii value on stack

char+      ( c-addr1 -- c-addr2 )
           Add one to c.addr1

chars      ( n1 -- n2 )
           Convert characters to address units

cf,        ( xt -- )
           Compile xt into the flash dictionary.

c>n        ( addr1 -- addr2 )
           Convert cfa to nfa

cmove      ( addr1 addr2 u -- )
           Move u chars from addr1 to addr2

constant   ( x "name" -- )
           Create a constant in flash as inline literal code

cq>        ( queue-addr -- c )
           Get a character from queue.

cq>?       ( queue-addr -- n )
           Get the amount of characters in the queue.

cq:        ( size "name" -- )
           Create a character queue

cq0        ( queue-addr -- )
           Initalise the queue

cr         ( -- )
           Emit CR LF (carriage return / line feed pair)

create     ( "name" -- )
           Create a word definition and store the current
           data section pointer.

cwd        ( -- )
           Clear the WatchDog counter.
           
d+         ( d d -- d )
           Add double numbers
           
d-         ( d d -- d )
           Subtract double numbers
           
d.         ( d -- )
           Display signed double number.
           
d0=        ( d -- f )
           True if d equals zero
           
d0<        ( d -- f )
           True if d is negative
           
d<         ( d d -- f )
           True if less than
           
d=         ( d d -- f )
           True if equal

d>         ( d d -- f )
           True if greater than
           
d2*        ( d -- d )
           Multiply by 2

d2/        ( d -- d )
           Divide by 2

dabs       ( d - +d )
           Absolute value

decimal    ( -- )
           Set numeric base to decimal 10.

defer      ( "name -- )
           Define a deferred execution vector

di         ( -- )
           Disable interrupts

digit      ( n -- c )
           Convert n to ASCII character value

digit?     ( c -- n flag )
           Convert char to a digit according to base
           
dinvert    ( ud -- ud )
           Invert double number

dnegate    ( d -- -d )
           Negate double number

does>      ( -- )  COMPILE_ONLY
           Define the runtime action of a created word.

dp         ( -- addr )       Eeprom variable mirrored in ram
           Leave the address of the current data section
           dictionary pointer

drop       ( x1 -- )
           Drop top of stack

dump       ( addr u -- )
           Display a memory dump 

dup        ( x -- x x )
           Duplicate top of stack

ei         ( -- )
           Enable interrupts

end        ( task-addr -- )
           Remove a task from the task list.

else       ( addr1 -- addr2 ) COMPILE_ONLY
           if ... else ... then

emit       ( c -- )
           Emit c to the serial port FIFO. FIFO is 46 chars.
           Executes pause.

empty      ( -- )
           Reset all dictionary pointers.

endit      ( -- ) COMPILE_ONLY
           Leave a for/next loop when next is encountered.
           Sets top of return stack to zero

execute    ( addr -- )
           Execute word at addr

exit       ( -- )
           Exit from a word.

false      ( -- 0 )

Fcy        ( -- u )
           CPU & peripheral clock frequency in KHz

fl-        ( -- )
           Disable writes to flash and eeprom.

fl+        ( -- )
           Allow writes to flash and eeprom.

flash      ( -- )
           Set data section context to flash

fill       ( c-addr u c -- )
           Fill u bytes with c staring at c-addr

find       ( c-addr -- c-addr 0/1/-1 )
           Find a word in dictionary
           Leave 1 if immediate, -1 if normal, 0 if not found

fm/mod     (d n -- rem quot )
           Floored 32/16 -> 16-bit division
           
for        ( u -- )   COMPILE_ONLY
           Loop u times. for ... next
           R@ gets the loop counter  u-1 ... 0

forget     ( "name -- )
           Forget name

here       ( -- addr )
           Leave the current data section dictionary pointer

hex        ( -- )
           Set numeric base to hexadecimal

hi         ( -- u )
           High limit of the current data space memory.

hold       ( c -- )  COMPILE_ONLY
           Append char to formatted numeric string

hp         ( -- a-addr )  USER
           Hold pointer for formatted numeric output

i          ( -- n ) COMPILE_ONLY
           The current loop index

i]         ( -- )   COMPILE_ONLY
           Exit Forth interrupt context

idle       ( -- )
           Cpu idle mode is allowed
           
if         ( -- a-addr )  COMPILE_ONLY 
           if ... else ... then

iflush     ( -- )
           Flush the flash write buffer

immed?     ( addr -- n )
           Leave a nonzero value if addr contains a immediate flag

immediate  ( -- )
           Mark latest definition as immediate

in?        ( nfa -- flag )
           Leave a nonzero value if nfa has inline bit set

inline     ( "name" -- )
           Inline the following word.

inlined    ( -- )
           Mark the latest compiled word as for automatic inlining.

int!       ( xt vector-no -- )
           Store an interrupt vector to the interrupt vector table.          
           PIC24F: Alternate interrupt vector table in ram.
           
interpret  ( c-addr u - )
           Interpret the buffer

invert     ( x1 -- x2 )
           Ones complement of x1

is         ( x "name" -- )
           Set the value a deferred word

ivt        ( -- )
           Activate the normal interrupt vector table

key        ( -- c )
           Get a character from the serial port FIFO.
           Execute pause until a character is available

key?       ( -- flag )
           Leave true if character is
           waiting in the serial port FIFO

latest     ( -- a-addr )
           Variable holding the address of the latest defined word

literal    ( x -- )
           Compile a literal into the dictionary

load       ( -- n )
           Get the CPU load in percent.
           The integration interval is 256 milliseconds.

lshift     ( x1 u -- x2
           Shift x1 u bits to the left

m+         ( d1 n -- d2 )
           Add double number d1 to n

m*         ( n n -- d )
           Signed 16*16->32 multiply
           
m*/        ( d1 n1 n2 - d2 )
           Scale d2 = d1*n1/n2 with triple intermediate result

marker     ( "name" -- )
           Mark a dictionary state

max        ( n1 n2 -- n3 )
           Leave max of n1 and n2

mclr       ( byte-mask byte-ram-addr -- )
           AND the contents of caddr with the complement of mask

min        ( n1 n2 -- n3 )
           Leave min of n1 and n2

mod        ( n1 n2 -- remainder )
           Remainder of n1 divided by n2
           
ms         ( +n -- )
           Pause for +n milliseconds

mset       ( byte-mask byte-ram-caddr -- )
           OR the contents of caddr with mask.

mtst       ( byte-mask byte-addr -- x )
           AND the contents of caddr with mask

n=         ( c-addr nfa u -- flag )
           Compare strings in ram(c-addr) and flash(nfa)
           flag is true if strings match. u<16.

negate     ( n -- -n )
           negate n

next       ( bra-addr bc-addr -- )   COMPILE_ONLY
           for ... next

n>c        ( nfa -- cfa )

nip        ( x1 x2 -- x2 )
           Remove x1 from the stack

number?    ( c-addr -- n/d/c-addr flag )
           Convert string to number
           # is decimal prefix
           $ is hexadecimal prefix
           % is binary prefix
           Flag: 0=error, 1=single, 2=double

operator   ( -- addr )
           Leave the address of the operator task

or         ( x1 x2 -- x3 )
           Or bitwise x1 with x2

over       ( x1 x2 -- x1 x2 x1 )
           Copy x1 to top of stack

p+         ( -- )
           Increment P register by one

p2+        ( -- )
           Add 2 to P register

p++        ( n -- )
           Add n to the p register

p!         ( x -- )
           Store x to the location pointed by the p register

pc!        ( c -- )
           Store c to the location pointed by the p register

p@         ( -- x )
           Fetch the cell pointed by the p register

pc@        ( -- c )
           Fetch the char pointed by the p register

pad        ( -- a-addr )
           : pad tib ti# + ;
           Each task has its own pad with initial size of 0.
           If needed the user must allocate space with allot.
           FF core does not use the pad.

parse       ( c -- addr length )
           Parse a word in TIB

pause      ( -- )
           Switch to the next task in the
           round robin task list.
           Idle in the operator task if allowed by all tasks.

place      ( addr1 u addr2 -- )
           Place string from addr1 to addr2 as a counted string

postpone   ( "name" -- )          COMPILE_ONLY
           Postpone action of immediate word

prompt     ( -- a-addr )           Eeprom defer
           Deferred execution vector for the
           info displayed by quit.
           Default is .ST

quit       ( -- )
           Interpret from current input.

r>         ( -- x ) ( R: x -- )   COMPILE_ONLY
           Pop x from the return stack to the parameter stack

r>p        ( -- )                 COMPILE_ONLY
           Pop from return stack to p register

r@         ( -- x ) ( R: x -- x ) COMPILE_ONLY
           Copy x from the return stack to the parameter stack

r0         ( -- a-addr )          USER
           Bottom of return stack

ram        ( -- )
           Set data section context to ram

rdrop      ( -- )              COMPILE_ONLY
           Remove top elemnt from return stack

repeat     ( addr2 addr1 -- )  COMPILE_ONLY
           begin ... while ... repeat

rot        ( x1 x2 x3 -- x2 x3 x1 )
           Rotate three top stack items

rshift     ( x1 u -- x2 )
           Shift x1 u bits to the right

rx1        ( -- c )
           Receive a character from UART1.

rx1?       ( -- f )
           Leave TRUE if UART1 receive buffer is not empty.

rx2        ( -- c )
           Receive a character from UART2.

rx2?       ( -- f )
           Leave TRUE if UART2 receive buffer is not empty.
           PIC24-30-33

rxu        ( -- c )
           Receive a character from USB UART.

rxu?       ( -- f )
           Leave TRUE if USB UART receive buffer is not empty. 

s>d        ( n -- d )
           Sign extend single to double precision number
           
s0         ( -- a-addr )
           Bottom of parameter stack

scan       ( c-addr u c -- c-addr' u'
           Scan string until c is found.
           c-addr must point to ram. u<255

sign       ( n -- )
           Append minus sign to formatted numeric output

sign?      ( addr1 n1 -- addr2 n2 flag )
           Get optional minus sign

skip       ( c-addr u c -- c-addr' u' )
           Skip string until c not encountered.
           c-addr must point to ram. u<255

sm/rem     ( d n -- rem quot )
           Symmetric 32/16 -> 16 bit division
           
sp@        ( -- addr )
           Leave parameter stack pointer

sp!        ( addr -- )
           Set the parameter stack pointer to addr

s"         ( "text" -- )   COMPILE_ONLY
           Compile string into flash

."         ( "text" -- )   COMPILE_ONLY
           Compile string to print into flash

source     ( -- c-addr u )
           Current input buffer address and numbers of chracters

space      ( -- )
           Emit one space character

spaces     ( n -- )
           Emit n space characters

state      ( -- flag )         
           Compilation state. State can only be changed by [ and ] 

swap       ( x1 x2 -- x2 x1 )
           Swap two top stack items

task       ( -- addr )
           Address of the task definition table

then       ( addr -- )   COMPILE_ONLY
           if ... else ... then

tib        ( -- addr )     USER
           Address of the terminal input buffer

tiu        ( -- addr )     USER
           Terminal input buffer pointer

ti#        ( -- n )        Task constant
           Size of terminal input buffer

ticks      ( -- u )
           System ticks. One tick per millisecond.

to         ( x "name" -- )
           Store x into value "name".

true       ( -- -1 )

tuck       ( x1 x2 -- x2 x1 x2 )
           Insert x2 below x1 in the stack

turnkey    ( -- addr )
           Vector for user startup word
           Eeprom value cached in ram

type       ( c-addr u -- )
           Type line to terminal. u < 256

tx1        ( c -- )
           Send a character to UART 1.

tx2        ( c -- )
           Send a character to UART 2.

txu        ( c -- )
           Send a character to USB UART.

u1-        ( -- )
           Disable flow control for UART1 serial interface

u1+        ( -- )
           Enable flow control for UART1 serial interface (Default)

u2-        ( -- )
           Disable flow control for UART2 serial interface

u2+        ( -- )
           Enable flow control for UART2 serial interface (Default)


u*/mod     ( u1 u2 u3 -- u4(remainder) u5(quotient) )
           Unsigned u1*u2/u3 with 32 bit intermediate result

u.         ( u -- )
           Display u unsigned according to numeric base

u.r        ( u +n -- )
           Display u in field of width n. 0<n<256

u/         ( u1 u2 -- u3 )
           Unsigned 16/16->16 bit division

u/mod      ( u1 u2 -- u3(remainder) u4(quotient)
           Unsigned 16/16->16 bit division

u<         ( u1 u2 -- flag )
           Leave true flag if u1 is less than u2

u>         ( u1 u2 -- flag )
           Leave true flag if u1 is greater than u2

ud.        ( ud -- )
           Display unsigned double number
           
ud*        ( ud u -- ud )
           Unsigned 32x16 -> 32 bit multiply

ud/mod     ( ud u -- u(remainder) ud(quotient)
           unsigned 32/16 -> 32 bit division

ulink      ( -- a-addr)
           Link to next task

um*        ( u1 u2 -- ud )
           Unsigned 16x16 -> 32 bit multiply

um/mod     ( ud u1 -- u2(remainder) u3(quotient)
           unsigned 32/16 -> 16 bit division

umax       ( u1 u2 -- u )
           Leave the unsigned larger of u1 and u2.

umin       ( u1 u2 -- u )
           Leave the unsigned smaller of u1 and u2.

until      ( flag -- )   COMPILE_ONLY
           begin..until

up         ( -- a-addr )
           Variable holding the user pointer

user       ( +n "name" -- )
           Define a user variable at offset +n

uq*        ( ud ud -- uq )
           Multiply two double numbers to a quad result
           PIC18 PIC24 PIC30 PIC33

uq/mod     ( qu du -- du-rem du-quot )
           Divide a 64 bit unsigned number with a 32 bit unsigned number
           PIC18 PIC24 PIC30 PIC33

d>q        ( d -- q )
           Extend a double number to a quad number
           PIC18 PIC24 PIC30 PIC33

q+         ( q q -- q )
           Add a quad number to quad number
           PIC24 PIC30 PIC33

qm+        ( q d -- q )
           Add a double number to quad number
           PIC18 PIC24 PIC30 PIC33

ut*        ( ud u -- ut )
           Multiply single number with double number

ut/        ( ut u -- ud )
           Divide triple number with single number

um*/       ( ud1 u1 u2 -- ud2 )
           Scale with triple number intermediate result

value      ( x "name" -- )
           Define a value

variable   ( "name" -- )
           Create a variable in the current data section

warm       ( -- )
           Make a warm start
          
while      (addr1 -- addr2 addr1 )  COMPILE_ONLY
           begin ... while ... repeat

within     ( x xl xh -- flag )
           Leave true if  xl <= x < xh

word       ( c -- c-addr )
           Parse a word in TIB and write the length into TIB
           Leave the address of the length byte on the stack.

wmove      ( addr1 addr2 u -- )
           Move u cells from addr1 to addr2

words xxx  ( "name" -- )
           List words optionally filtered with xxx

x!         ( u addr.d -- )
           Extended store into flash. Real flash address
           PIC18 ATMEGA

x!         ( ud addr.d -- )
           Extended store into flash. Real flash address
           PIC-24-30-33

x@         ( addr.d -- u )
           Extended fetch from flash. Real flash address
           PIC18 ATMEGA

x@         ( addr.d -- ud )
           Extended fetch from flash. Real flash address
           PIC24-30-33

xa>        ( a-addr1 -- a-addr2 )
           Convert a real executable address
           to virtual flash address

xor        ( x1 x2 -- x3 )
           Xor bitwise x1 with x2.


PIC24-30-33 assembler (partial)
===============================
rcall,     ( rel-addr -- )
bra,       ( cc rel-addr -- )
return,    ( -- )
retfie,    ( -- )
bclr,      ( bit ram-addr -- )
bset,      ( bit ram-addr -- )
btst,      ( bit ram-addr -- )
btsc,      ( bit ram-addr -- )
btss,      ( bit ram-addr -- )
z,         ( -- cc )
nz,        ( -- cc )
not,       ( cc -- not-cc )
if,        ( cc -- here )
else,      ( back-addr -- here )
then,      ( back-addr -- )
begin,     ( -- here )
again,     ( back-addr -- )
until,     ( back-addr cc -- )


Site powered by Weebly. Managed by Hostwinds
  • Start
    • What is a Scamp?
    • Getting Started
    • Getting Started (Windows)
  • Learn
    • What is Forth?
    • Arithmetic
    • The Stack
    • Creating Words
    • Compilation Tricks
    • Decompilation
    • Comments
    • Characters and Strings
    • Accessing Memory
    • Constants, Variables and Values
    • Flow Control
    • Loops
    • Data Structures
    • Doubles, Triples and Quads
    • FlashForth Dictionary Reference
    • Scamp Dictionary Reference
  • Extras
    • Interrupts
    • Timers
    • Multitasking
    • Delays and Tick Count
    • Processor Words
    • Starting up with turnkey
    • Changing the Prompt
    • Formatting Text on Screen
  • Interfacing
    • Using the LED Array
    • Temperature Sensor
    • Input/Output
    • Analog Input
    • Serial >
      • Serial Communication
      • Scamp2 UART Pins
    • I2C >
      • I2C Overview
      • I2C Commands
    • SPI
    • PWM
    • Peripheral Pin Select
    • Input Capture
    • Digital Signal Modulator
  • Create
    • Creating PCBs >
      • Designing PCBs
      • Fabricating PCBs
      • Soldering
    • Sensing >
      • Measuring Temperature
    • LEDs >
      • Adding LEDs
      • LED arc-welder effect
    • Displays >
      • Adding a 7 Segment Display
      • Adding a Touch LCD
      • Touch LCD GUI
      • Game of Pong
    • Adding Extra GPIO
    • Adding a Low Side Switch
    • FizzBuzz
    • Adding MRAM
    • Model Train Control
    • Adding a Real Time Clock
    • Scamp Projects on Youtube
  • Resources
  • Store
  • About
  • Contact