ANS WORDS

! ( x a-addr -- )

# ( ud1 -- ud2 )

#> ( xd -- c-addr u )

#S ( ud1 -- ud2 )

#TIB ( -- addr )

' ( "name" -- addr )

(

(LOCAL) paren-local-paren LOCAL

* ( n1|u1 n2|u2 -- u3|u3 )

*/ ( n1 n2 n3 -- n4 )

*/MOD ( n1 n2 n3 --n4)

+ ( n1|u1 n2|u2 -- n3|u3 )

+! ( n|u a-addr -- )

+LOOP ( n|u a-addr -- )

, ( x -- )

- ( u1|n1 u2|n2 -- u3|n3 -- )

-TRAILING ( c-addr1 u1 -- c-addr2 u2 )

. ( n -- )

." ( "string" -- )

.( ( "string" -- )

.R ( n width -- )

.S ( -- )

/ ( n1 n2 -- n3 )

/MOD ( n1 n2 -- n3 n4 )

/STRING ( c-addr u1 n -- c-addr2 u2 )

0< ( x -- flag )

0= ( x -- flag )

0<> ( x -- flag )

0> ( x -- flag )

1+ ( n1|u1 -- n2|u2 )

1- ( n1|u1 -- n2|u2 )

2! ( x1 x2 addr -- )

2* ( x1 -- x2 )

2/ ( x1 -- x2 )

2>R ( x1 x2 -- )

2@ ( addr -- x1 x2)

2CONSTANT child ( -- x1 x2)

Defining word

parent (x1 x2 --)

child ( --x1 x2)

2DROP ( x1 x2 -- )

2DUP ( x1 x2 -- x1 x2 x1 x2 )

2LITERAL runtime ( -- x1 x2 )

compiling word

compile time ( x1 x2 --)

runtime ( --x1 x2)

2OVER ( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 )

2R> ( -- x1 x2)

2R@ ( -- x1 x2)

2ROT ( x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2 )

2SWAP ( x1 x2 x3 x4 -- x3 x4 x1 x2 )

2VARIABLE ( -- addr )

: child ( i*x-- j*x )

compile time ( "name" -- colon_sys )

child ( i*x -- j*x)

:NONAME child ( i*x-- j*x )

compile time ( "name" -- colon_sys )

runtime ( i*x -- j*x)

; runtime ( -- )

compile time ( colon_sys -- )

runtime ( -- )

;CODE runtime ( -- )

compile time ( colon_sys -- )

runtime ( -- )

< ( n1 n2 -- flag )

<# ( -- )

<> ( x1 x2 -- flag )

= ( x1 x2 -- flag )

> ( n1 n2 -- flag )

>BODY ( xt -- pfa )

>FLOAT to-float FLOATING

>IN ( xt -- pfa )

>NUMBER ( ulow uhigh c-addr1 u1 -- ulow uhigh c-addr2 u2 )

>R ( x -- )

? ( a-addr -- )

?DO ( a-addr -- )

?DUP ( x -- 0 | x x )

@ ( c-addr -- x )

ABORT ( ???-- )

ABORT" ( ???-- )

ABS ( n -- u )

ACCEPT ( addr +n -- +n )

AGAIN runtime ( -- )

AHEAD runtime ( -- )

ALIGN ( -- )

ALLIGNED ( addr -- a-addr )

ALLOCATE ( u -- a-addr ior)

ALLOT ( n -- )

ALSO ( -- )

AND ( x1 x2 -- x3 )

ASSEMBLER( -- )

AT-XY at-x-y FACILITY

BASE( -- addr)

BEGIN compile_time( -- addr)

BIN ( fam1 -- fam2 )

BL ( -- char )

BLANK ( c-addr u -- )

BLK b-l-k BLOCK

BLOCK BLOCK

BUFFER BLOCK

BYE TOOLS EXT

C! ( char c-addr -- )

C" ( -- )

C, ( char -- )

C@ ( c-addr -- char )

CASE CORE EXT

CATCH ( i*x xt -- j*x 0 | i*x n )

CELL+ ( a-addr1 -- a-addr2 )

CELLS ( n1 -- n2 )

CHAR ( -- ascii )

CHAR+ ( c-addr1 -- c-addr2 )

CHARS ( n1 -- n2 )

CLOSE-FILE ( fileid -- ior)

CMOVE ( addr1 addr2 count -- )

CMOVE> ( addr1 addr2 count -- )

CODE ( "name" --)

COMPARE ( c-addr1 u1 c-addr2 u2 -- )

COMPILE, Execution: ( xt -- )

CONSTANT ( x "name" -- )

CONVERT ( ud1 c-addr1 -- ud2 c-addr2 )

COUNT ( c-addr1 -- c-addr2 u )

CR ( --)

CREATE ( "name" -- )

CREATE-FILE ( fileid -- ior)

CS-PICK Execution: ( C: destu ... orig0|dest0 -- destu ... orig0|dest0 destu )( S: u -- )

CS-ROLL ( C: origu|destu origu-1|destu-1 ... orig0|dest0 -- origu-1|destu-1 ... orig0|dest0 origu|destu )( S: u -- )

D+ ( d1|du1 d2|du2 -- d3|du3 )

D- ( d1|du1 d2|du2 -- d3|du3 )

D. ( d -- )

D.R ( d width -- )

D0< ( d -- flag )

D0= ( d -- flag )

D2* ( xd1 -- xd2 )

D2/ ( xd1 -- xd2 )

D< ( d1 d2 -- flag )

D= ( d1 d2 -- flag )

D>F d-to-f FLOATING

D>S ( d -- n)

DABS ( d -- ud )

DECIMAL ( -- )

DEFINITIONS ( -- )

DELETE-FILE ( fileid -- ior)

DEPTH ( -- n)

DF! d-f-store FLOATING EXT

DF@ d-f-fetch FLOATING EXT

DFALIGN d-f-align FLOATING EXT

DFALIGNED d-f-aligned FLOATING EXT

DFLOAT+ d-float-plus FLOATING EXT

DFLOATS d-floats FLOATING EXT

DMAX ( d1 d2 -- d3 )

DMIN ( d1 d2 -- d3 )

DNEGATE ( d1 -- d2 )

DO ( limit start -- )

DOES> runtime ( -- )

DROP ( x -- )

DU< ( ud1 ud2 -- flag)

DU< ( ud1 ud2 -- flag)

DUMP ( addr n --)

EDITOR ( --)

EKEY e-key FACILITY EXT

EKEY>CHAR e-key-to-char FACILITY EXT

EKEY? e-key-question FACILITY EXT

ELSE runtime ( -- )

EMIT ( char --)

EMIT? emit-question FACILITY EXT

EMPTY-BUFFERS BLOCK EXT

ENDCASE end-case CORE EXT

ENDOF end-of CORE EXT

ENVIRONMENT?( c-addr u -- false | i*x true )

ERASE ( addr u -- )

EVALUATE ( i*x c-addr u -- j*x )

EXECUTE ( xt -- )

EXIT execution( -- )

EXPECT ( add n -- )

F! f-store FLOATING

F* f-star FLOATING

F** f-star-star FLOATING EXT

F+ f-plus FLOATING

F- f-minus FLOATING

F. f-dot FLOATING EXT

F/ f-slash FLOATING

F0< f-zero-less-than FLOATING

F0= f-zero-equals FLOATING

F< f-less-than FLOATING

F>D f-to-d FLOATING

F@ f-fetch FLOATING

FABS f-abs FLOATING EXT

FACOS f-a-cos FLOATING EXT

FACOSH f-a-cosh FLOATING EXT

FALIGN f-align FLOATING

FALIGNED f-aligned FLOATING

FALOG f-a-log FLOATING EXT

FALSE ( -- 0)

FASIN f-a-sine FLOATING EXT

FASINH f-a-cinch FLOATING EXT

FATAN f-a-tan FLOATING EXT

FATAN2 f-a-tan-two FLOATING EXT

FATANH f-a-tan-h FLOATING EXT

FCONSTANT f-constant FLOATING

FCOS f-cos FLOATING EXT

FCOSH f-cosh FLOATING EXT

FDEPTH f-depth FLOATING

FDROP f-drop FLOATING

FDUP f-dupe FLOATING

FE. f-e-dot FLOATING EXT

FEXP f-e-x-p FLOATING EXT

FEXPM1 f-e-x-p-m-one FLOATING EXT

FILE-POSITION ( fileid -- ud ior)

FILE-SIZE ( fileid -- ud ior)

FILE-STATUS ( fileid -- code ior)

FILL (c-addr u char -- )

FIND ( c-addr -- c-addr 0 | xt 1 | xt -1 )

FLITERAL f-literal FLOATING

FLN f-l-n FLOATING EXT

FLNP1 f-l-n-p-one FLOATING EXT

FLOAT+ float-plus FLOATING

FLOATS FLOATING

FLOG f-log FLOATING EXT

FLOOR FLOATING

FLUSH BLOCK

FLUSH-FILE ( fileid -- ior)

FM/MOD ( d1 n1 -- n2 n3 )

FMAX f-max FLOATING

FMIN f-min FLOATING

FNEGATE f-negate FLOATING

FORGET TOOLS EXT

FORTH ( -- )

FORTH-WORDLIST ( -- wid )

FOVER f-over FLOATING

FREE ( a-addr -- ior )

FROT f-rote FLOATING

FROUND f-round FLOATING

FS. f-s-dot FLOATING EXT

FSIN f-sine FLOATING EXT

FSINCOS f-sine-cos FLOATING EXT

FSINH f-cinch FLOATING EXT

FSQRT f-square-root FLOATING EXT

FSWAP f-swap FLOATING

FTAN f-tan FLOATING EXT

FTANH f-tan-h FLOATING EXT

FVARIABLE f-variable FLOATING

F~ f-proximate FLOATING EXT

GET-CURRENT ( -- wid )

GET-ORDER ( -- wid-n ...wid-1 n )

HERE( -- addr )

HEX( -- )

HOLD ( char -- )

I ( --x1)

IF ( flag--)

IMMEDIATE ( --)

INCLUDE-FILE ( i*x fileid -- j*x)

INCLUDED ( i*x c-addr u -- j*x)

INVERT ( x1 -- x2 )

J ( -- x1 )

KEY( -- char)

KEY?( -- flag)

LEAVE ( -- )

LIST BLOCK EXT

LITERAL runtime ( --32b )

LOAD BLOCK

LOCALS| locals-bar LOCAL EXT

LOOP runtime ( -- )

LSHIFT ( x1 u -- x2 )

M* ( n1 n2-- l1 hi )

M*/ ( d1 n1 +n2-- d2 )

M+ ( d1|ud1 n -- d2|ud2 )

MARKER ( "name" -- )

MAX ( n1 n2-- n3 )

MIN ( n1 n2 -- n3 )

MOD ( n1 n2 -- n3 )

MOVE ( addr1 addr2 u--)

MS FACILITY EXT

NEGATE ( n1-- n2 )

NIP ( x1 x2 -- x2 )

OF CORE EXT

ONLY ( -- )

OPEN-FILE ( addr num mode -- fileid ior)

OR ( x1 x2-- x3 )

ORDER SEARCH EXT

OVER ( x1 x2-- x1 x2 x1 )

PAD ( -- a-addr )

PAGE ( -- )

PARSE ( char "ccc{char}" -- c-addr u )

PICK ( xu ...x2 x1 u -- xu ...x2 x1 xu)

POSTPONE Compilation: ( " name" -- )

PRECISION FLOATING EXT

PREVIOUS ( -- )

QUERY ( -- )

QUIT ( -- )

R/O ( -- fam)

R/W ( -- fam)

R> ( -- x1 )

R@ ( -- x1 )

READ-FILE ( c-addr u1 fileid-- u2 ior)

READ-LINE ( c-addr u1 fileid-- u2 ior)

RECURSE ( -- )

REFILL ( -- flag )

RENAME-FILE ( c-addr1 u1 c-addr2 u2 -- ior)

REPEAT Run-time: ( -- )

REPOSITION-FILE ( fileid-- u2 ior)

REPRESENT FLOATING

RESIZE ( a-addr1 u -- a-addr2 ior )

RESIZE-FILE ( ud fileid -- ior)

RESTORE-INPUT ( x1 x2 x3 x4 x5 x6 6-- flag)

ROLL ( xu xu-1 ... x0 u -- xu-1 ... x0 xu )

ROT ( x1 x2 x3-- x2 x3 x1 )

RSHIFT ( x1 u-- x2 )

S" ( -- )

S>D ( n-- lo1 hi1 )

SAVE-BUFFERS BLOCK

SAVE-INPUT ( -- x1 x2 x3 x4 x5 x6 6)

SCR s-c-r BLOCK EXT

SEARCH ( c-addr1 u1 c-addr2 u2 -- c-addr3 u3 flag )

SEARCH-WORDLIST ( c-addr u wid -- 0 | xt 1 | xt -1 )

SEE TOOLS

SET-CURRENT ( wid-n -- )

SET-ORDER ( wid-n wid-1 n -- )

SET-PRECISION FLOATING EXT

SF! s-f-store FLOATING EXT

SF@ s-f-fetch FLOATING EXT

SFALIGN s-f-align FLOATING EXT

SFALIGNED s-f-aligned FLOATING EXT

SFLOAT+ s-float-plus FLOATING EXT

SFLOATS s-floats FLOATING EXT

SIGN ( n -- )

SLITERAL runtime( -- c-addr2 u )

SM/REM ( lo hi n1-- n2 n3)

SOURCE ( -- c-addr u )

SOURCE-ID ( -- addr)

SPACE ( -- )

SPACES ( n -- )

SPAN ( -- addr )

STATE ( -- addr )

SWAP ( x1 x2 -- x2 x1 )

THEN runtime ( -- )

THROW ( k*x n -- k*x | i*x n )

THRU BLOCK EXT

TIB ( -- addr)

TIME&DATE time-and-date FACILITY EXT

TO runtime ( x -- )

TRUE ( -- -1 )

TYPE ( addr count -- )

U. ( u -- )

U.R ( u width -- )

U< ( u1 u2 -- flag )

U> ( u1 u2 -- flag )

UM* ( u1 u2 -- lo1 hi1 )

UM/MOD ( lo1 hi1 u1-- u1 u2 )

UNLOOP ( -- )

UNTIL runtime( flag-- )

UNUSED ( --value )

UPDATE BLOCK

VALUE ( x "name" -- )

VARIABLE ( -- addr)

W/O ( -- fam)

WHILE ( flag-- )

WITHIN ( n1|u1 n2|u2 n3|u3 -- flag)

WORD ( char "{chars}ccc{char}" -- c-addr )

WORDLIST ( -- wid )

WORDS ( "name" --)

WRITE-FILE ( c-addr1 fileid -- ior)

WRITE-LINE ( c-addr1 fileid -- ior)

XOR ( x1 x2-- x3 )

[ execution( -- )

['] runtime( -- xt )

[CHAR] runtime( -- char )

[COMPILE] compile( "name" --)

[ELSE] ( -- )

[IF] ( -- )

[THEN] ( -- )

\ ( --)

] ( --)

META EXTENSIONS

vocabularies

COLDFORTH WORDS

#$buffer ( -- n )

#] ( d -- c-addr u )

#clock_high ( -- value )

#clock_medium ( -- value )

#task_level_clock_low ( -- value )

#picture_min ( -- u )

#vocs ( -- n )

$" ( -- )

$buffer ( -- )

$date ( year month day addr n -- $ )

$hold ( $ -- )

$months ( -- addr )

$move ( from to max -- )

$sec ( ticks addr n -- $ )

$ticks ( n addr n --$)

$time ( ticks addr n-- $ )

(d.) ( d addr n -- c-addr len )

(dr.) ( d base n-frac addr n -- )

-rot ( x1 x2 x3 -- x3 x1 x2 )

," ( -- )

,string ( addr n -- )

.buffers ( -- )

.buffers_used ( -- )

.context ( -- )

.d ( n -- )

.date ( yyy mmm ddd -- )

.h ( u -- )

.l ( n -- )

.sec ( ticks -- )

.ticks ( ticks -- )

.ticks ( ticks -- )

.time ( ticks -- )

16* ( n1|u1 -- n2|u2 )

16/ ( n1|u1 -- n2|u2 )

2** ( n -- x1 )

2+ ( n1|u1 -- n2|u2 )

2- ( n1|u1 -- n2|u2 )

2r>drop ( -- )

3* ( n1|u1 -- n2|u2 )

3+ ( n1|u1 -- n2|u2 )

3drop ( x1 x2 x3 -- )

3dup ( x1 x2 x3 -- x1 x2 x3 x1 x2 x3 )

4* ( n1|u1 -- n2|u2 )

4+ ( n1|u1 -- n2|u2 )

4- ( n1|u1 -- n2|u2 )

4/ ( n1|u1 -- n2|u2 )

4drop ( x1 x2 x3 x4 -- )

4dup ( x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2 x3 x4 )

4r>drop ( -- )

8* ( n1|u1 -- n2|u2 )

8+ ( n1|u1 -- n2|u2 )

8- ( n1|u1 -- n2|u2 )

8/ ( n1|u1 -- n2|u2 )

>< ( x1 -- x2)

>asl ( value -- asl-value )

>w< ( x1 -- x2)

@execute ( a-addr -- )

binary ( -- )

buffer ( -- addr )

buffer_size ( addr -- u )

buffer_save_ip ( addr -- )

buffer_too_big? ( -- flag )

cell ( -- n )

cell/ ( x1 -- x2 )

char! ( addr -- char )

char@ ( addr -- char )

current ( -- char )

d.l ( d len -- )

d> ( d1 d2 -- flag )

digit ( u -- ascii_u )

dup@( a-addr -- a-addr x1 )

dup>r ( -- )

eight ( -- 8 )

extend_wordlist ( wid1 -- wid2 )

four ( -- 4 )

get ( addr -- )

get_buffer ( -- )

grab ( addr -- )

jump ( x1 x2 x3 -- x1 x2 x3 x1)

kill_buffer ( -- )

link_double ( link_addr head -- )

mt* ( d1 n1 +n2 -- d2 )

mu/mod ( d1 u -- rem d2 )

n>buffer_size ( n1 -- n2 )

name_wordlist ( wid -- )

not ( n1|u1 -- n2|u2 )

octal ( -- )

one ( -- 1)

previous_definitions ( -- )

r. ( n base n-frac -- )

r.1 ( n base n-frac width -- )

r.r ( n base n-frac width -- )

r>drop ( -- )

release ( addr -- )

search_thread ( c-addr u thread -- c-addr 0 | xt 1 | xt -1)

sleep ( -- value )

sqrt ( u1 -- u2 )

threads_number ( -- addr )

three ( -- 3 )

tnegate ( tri1 -- tri2 )

two ( -- 2 )

u/mod ( u1 u2 -- rem quot )

u>d ( u -- d )

ut* ( d u -- tri )

ut/ ( tri n -- d )

ubuffer

Defining word

parent (u --)

child ( --addr)

unlink_double ( link_addr-- )

visible ( -- value )

vocabulary ( wid -- )

#vocs ( -- n )

wake ( -- value )

xcycle ( u -- )

xgrab ( addr -- )

xnext ( -- )

xoff ( -- )

xpause ( -- )

xsleep ( -- )

xtest ( -- )

xtimeout? ( --flag)

xwake ( --)

zero ( -- 0 )

[# ( addr-top -- )

Symbol standard

The aim is to follow the following standard, to date all the work has not been done

ANS words are in capitals, ANS words that don't follow the standard are left that way. For instance WORD should really be $WORD as it returns a counted string. The system is case sensative. This is a system that forces you to learn the ANS standard, that might be a good thing.

Thankyou

• The ANS word descriptions are taken from the on line version of the ANS draft. This resource is available because of ???
• The work done by Andrew McKewan and Tom Zimmer has been well read (win32FORTH).
• Colour Vision Systems Pty Ltd for supplying the resources needed to get this job done.
• The ANS forth standard committee. It definitly advances the language, but why oh why change the definition of truth. Both 1 and -1 are boring, I think next time go for something interesting like 42, the meaning of life the universe and everything.

ANSI standard, known deviations

• KEY Standard requires characters not to be echoed. COLDFORTH echos as set previously by echo_on and echo_off.
• ACCEPT Standard requires character echo. COLDFORTH echos is set previously by echo_on and echo_off.
• QUIT Standard reguires QUIT to take input and type prompt on completion. COLDFORTH types prompt and accepts input.
• QUIT Emptying the return stack is aborts problem not the problem of QUIT. COLDFORTH's QUIT does not empty the return stack.
• ABORT" Throws the address of a counted string, not -2.
• The ANSI standard local variables are a joke.
• CONVERT takes a counted string