1. A Programming Language for the FC16 Forth Core
WHYP
A Programming Language for the
FC16 Forth Core

2. WHYP Pronounced “whip” “Words to Help You Program”
Subroutine-threaded Forth for Embedded Systems
68HC11 (16-bit)
68332 (32-bit)
68HC12 (16-bit)

3. WHYP is developed from scratch in the new book: Design of Embedded Systems Using 68HC12/11 Microcontrollers by Richard E. Haskell Prentice Hall, 2000

4. FORTH is a programming language that ---
was invented by Charles Moore in the early 70’s
is extensible
keeps all definitions in a dictionary
is extremely compact
is recursive
can be programmed in RAM, PROM, or ROM
is structured
uses a stack and postfix notation

5. Chuck Moore
reading Haskell’s
WHYP book

6. FORTH is a programming languages that ---
is extremely modular
is interactive
is easy to debug
allow easy machine access
is fast
is transportable
can be understood in its entirety
is unlike any other language

7. Introducing WHYP (Forth)
Everything in WHYP is a word
WHYP words must be separated by a space
WHYP words are stored in a dictionary
WHYP words may be either interpreted or compiled
When in the interpret mode, a WHYP word is executed
When in the compile mode, a WHYP word is stored in the dictionary

8. Introducing WHYP (Forth)
If you type a WHYP word and press <enter>, the word will be executed (interpret mode)
If you type a number (e.g. 6) and press <enter>, the number will be pushed on the data stack.
WHYP uses the stack to pass parameters from one word to the next.
You can define new words in WHYP by stringing together previously defined words.

9. The Structure of WHYP PC Target 68HC12 C++ Program Kernel: Dictionary:
Serial Line
LOOP BSR INWDY
JSR 0,Y
send address
BRA LOOP
F82C
display F82C
F82C -----
-----
-----
-----
Screen
-----
C:\>whyp
RTS ok
display

10. WHYP Arithmetic Operators
4 7 * .
8 3 / .
8 3 /MOD . .

11. WHYP Colon Definitions
: squared ( n -- n**2)
DUP * ;
: cubed ( n -- n**3)
DUP \ n n
squared \ n n**2
* ; \ n**3

12. WHYP Stack Manipulation Words
DUP ( n -- n n )
SWAP ( a b -- b a )
DROP ( a -- )
OVER ( a b -- a b a )
TUCK ( a b -- b a b )
ROT ( a b c -- b c a )
-ROT ( a b c -- c a b )
NIP ( a b -- b )
2DUP ( a b -- a b a b )
2SWAP ( a b c d -- c d a b )
2DROP ( a b -- )
2OVER ( a b c d -- a b c d a b )

13. WHYP on the FC16

14. Stack Manipulation Words
FC16 Primitives
: DUP ( w -- w w )
DUP (0001);
: DROP ( w -- )
DROP (0003) ;
: SWAP ( a b -- b a)
SWAP (0002)
: NIP ( a b -- b )
NIP (0007);

15. Stack Manipulation Words
FC16 Primitives
: ROT ( a b c -- b c a)
ROT (0005) ;
: -ROT ( a b c -- c a b)
MROT (0006) ;
: OVER ( a b -- a b a)
OVER (0004) ;
: TUCK ( a b -- b a b)
TUCK (0008)

16. Stack Manipulation Words
Colon Definitions
: 2DUP ( a b -- a b a b )
OVER (0004) \ a b a
OVER (0004) ; \ a b a b

17. Memory Access Words Fetch Store \ Fetch word at address T in RAM and
\ load it into T
( a -- w )
fetch (0034) ;
Store
\ Store the word in N at the address T.
\ Pop both T and N.
: ! ( w a -- )
store (010E) ;

18. RAM Module

19. Return Stack Words To-R R-From R-Fetch R-From-Drop
: >R ( w -- ) \ pop T & push to R
TOR (0030) ;
R-From
: R> ( -- w ) \ pop R & push to T
RFROM (0031) ;
R-Fetch
: ( -- w ) \ copy R & push to T
RFETCH (0032) ;
R-From-Drop
: R>DROP ( -- ) \ pop R & drop it
RFROMDROP (0033) ;

20. Arithmetic Words Plus w3 = w1 + w2 minus w3 = w1 - w2

21. Arithmetic Words One-plus w2 = w1 + 1 One-minus w2 = w1 - 1

22. Logical Words Bitwise AND Bitwise OR Bitwise XOR One’s complement
: AND ( w1 w2 -- w3 )
ANDD (0015) ;
Bitwise OR
: OR ( w1 w2 -- w3 )
ORR (0016) ;
Bitwise XOR
: XOR ( w1 w2 -- w3 )
XORR (0017) ;
One’s complement
: INVERT ( w1 -- w2 )
INVERT (0014) ;

23. Logical Words TRUE = X“FFFF” FALSE = X“0000” : TRUE (-- w )
ONES (0020) ;
FALSE = X“0000”
: FALSE (-- w )
ZEROS (0021) ;

24. Branching and Looping in WHYP
IF…ELSE…THEN
FOR…NEXT
BEGIN…AGAIN
BEGIN…UNTIL
BEGIN…WHILE…REPEAT

25. IF…ELSE…THEN <cond> IF <true statements> ELSE
<false statements>
THEN
<cond> is either TRUE (-1) or FALSE (0)

26. WHYP Conditional Words
< ( n1 n2 -- f ) (“less-than”)
> ( n1 n2 -- f ) (“greater-than”)
= ( n1 n2 -- f ) (“equals”)
<> ( n1 n2 -- f ) (“not-equals”)
<= ( n1 n2 -- f ) (“less-than or equal”)
>= ( n1 n2 -- f ) (“greater-than or equal”)
0< ( n -- f) (“zero-less”)
0> ( n -- f) (“zero-greater”)
0= ( n -- f) (“zero-equal”)
U< ( u1 u2 -- f ) (“U-less-than”)
U> ( u1 u2 -- f ) (“U-greater-than”)
U<= ( u1 u2 -- f ) (“U-less-than or equal”)
U>= ( u1 u2 -- f ) (“U-greater-than or equal”)

28. FOR…NEXT Loop n FOR <WHYP statements> NEXT >R
drjne <WHYP statements>
Decrement top of return stack and branch back
to <WHYP statements> if not equal to zero.
Therefore, <WHYP statements> are executed
n times.

29. BEGIN…AGAIN
BEGIN <WHYP statements> AGAIN

30. BEGIN…UNTIL BEGIN <WHYP statements> <flag> UNTIL
<flag> is either TRUE or FALSE
usually from some WHYP conditional word

31. BEGIN…WHILE…REPEAT BEGIN <words> <flag> WHILE

32. x = 1; i = 2;
WHILE (i <= n) {
x = x * i
i = i + 1 }
factorial = x

33. FC16 Relational Operator Words
Zero-equals -- true if T = 0 (NOT)
: 0= ( n -- f )
zeroequal (0022) ;
Zero-less-than -- true if T < 0
: 0< ( n -- f )
zeroless (0023) ;
Zero-greater-than -- true if T > 0
: 0> ( n -- f )
DUP 0= \ n f1
SWAP 0< \ f1 f2
OR NOT ;

34. Relational Operator Words
U-greater-than -- true if u1 > u2
: U> ( u1 u2 -- f )
ugt (0024);
when ugt
if N > T then
ones;
else
zeros;
endif;
U-less-than -- true if u1 < u2
: U< ( n1 n2 -- f )
ult (0025);
equal-to -- true if n1 = n2
: = ( n1 n2 -- f )
eq (0026) ;
Implement these
instructions directly
In Funit

35. Relational Operator Words
U-greater-than-or equal -- true if u1 >= u2
: U>= ( u1 u2 -- f )
ugte (0027) ;
U-less-than-or equal -- true if u1 <= u2
: U<= ( u1 u2 -- f )
ulte (0028) ;
not-equal-to -- true if n1 /= n2
: <> ( n1 n2 -- f )
neq (0029) ;

36. Relational Operator Words
greater-than -- true if n1 > n2
: > ( n1 n2 -- f )
gt (002A) ;
less-than -- true if n1 < n2
: < ( n1 n2 -- f )
lt (002B) ;
use IEEE.std_logic_arith.all;
variable avs, bvs: signed (width-1 downto 0);
In Funit16

37. use IEEE.std_logic_arith.all;
variable avs, bvs: signed (width-1 downto 0);
variable y_tmp: STD_LOGIC_VECTOR
(width-1 downto 0);
for i in 0 to width-1 loop
true(i) := '1';
false(i) := '0';
av(i) := a(i);
bv(i) := b(i);
avs(i) := a(i);
bvs(i) := b(i);
end loop;

38. In Funit16 when “101010" => if (avs > bvs) then y <= true;
else
y <= false;
end if;
when “101011" =>
if (avs < bvs) then y <= true;

39. Relational Operator Words
greater-than-or-equal -- true if n1 >= n2
: >= ( n1 n2 -- f )
gte (002C) ;
less-than-or-equal -- true if n1 <= n2
: <= ( n1 n2 -- f )
lte (002D) ;

40. Branching Words
if ( f -- ) JZ (0102) --
else JMP (0101)
then

41. Branching Words
begin --
while ( f -- ) JZ (0102)
repeat JMP (0101)

42. Branching Words
begin --
until ( f -- ) JZ (0102)

43. Branching Words
begin --
again JMP (0101)

44. Looping Words
for (cnt -- ) >R
---
next DRJNE