COLDFORTH Version 0.8

license
history

Source

source

Source tar

To extract save in desired directory and issue command tar xzf tr.tar.gz

tar ball

Articles

Heap management
Multitasking
tcp/ip

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 "name" --)
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 child( -- addr )
Defining word
parent ( "name" --)
child ( --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 ( c-addr n -- float true|false )
>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 child( -- x)
Defining word
parent ( x "name" --)
child ( -- x )
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! ( float float_addr -- )
F* ( float float -- float )
F** f-star-star FLOATING EXT
F+ ( float float -- float)
F- ( float float -- float )
F. ( float -- )
F/ ( float float -- float)
F0< ( float -- flag)
F0= ( float -- flag)
F< ( float float -- flag)
F<D ( float -- double)
F@ ( float_addr -- float)
FABS f-abs FLOATING EXT
FACOS f-a-cos FLOATING EXT
FACOSH f-a-cosh FLOATING EXT
FALIGN ( -- )
FALIGNED ( addr -- float_addr )
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 child ( -- float )
Defining word
parent (m1 e2 "name" --)
child ( --m1 e2)
FCOS f-cos FLOATING EXT
FCOSH f-cosh FLOATING EXT
FDEPTH ( -- n )
FDROP ( float float-- float)
FDUP ( float -- float float)
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 runtime( -- float )
compiling word
compile time ( m1 e2 --)
runtime ( --m1 e2)
FLN f-l-n FLOATING EXT
FLNP1 f-l-n-p-one FLOATING EXT
FLOAT+ ( float_addr1 -- float_addr2)
FLOATS ( n -- bytes )
FLOG f-log FLOATING EXT
FLOOR ( float1 -- float2 )
FLUSH BLOCK
FLUSH-FILE ( fileid -- ior)
FM/MOD ( d1 n1 -- n2 n3 )
FMAX ( float float -- float )
FMIN ( float flaot -- float )
FNEGATE ( float -- float )
FORGET TOOLS EXT
FORTH ( -- )
FORTH-WORDLIST ( -- wid )
FOVER ( floata floatb -- floata floatb floata)
FREE ( a-addr -- ior )
FROT ( floata floatb floatc -- floatb floatc floata)
F. ( floata -- floatb)
FS. ( float -- )
FSIN f-sine FLOATING EXT
FSINCOS f-sine-cos FLOATING EXT
FSINH f-cinch FLOATING EXT
FSQRT f-square-root FLOATING EXT
FSWAP ( floata floatb -- floatb floata)
FTAN f-tan FLOATING EXT
FTANH f-tan-h FLOATING EXT
FVARIABLE child( -- f-addr)
Defining word
parent ( "name" --)
child ( --f-addr)
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 )
compile time ( 32b --)
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 ( float -- )
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 child( -- addr)
Defining word
parent ( "name" --)
child ( --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 )
fm. ( vector_source1 row column -- )
fm>fv ( vector_source1 rows columns vector_dest slected_column -- )
fv. ( vector_source1 n -- )
fv*f ( vector_source1 float vector_dest n -- )
fv*fv ( vector_source1 vector_source2 vector_dest n -- )
fv+f ( vector_source1 float vector_dest n -- )
fv+fv ( vector_source1 vector_source2 vector_dest n -- )
fv-fv ( vector_source1 vector_source2 vector_dest n -- )
fvsum ( vector_source n -- float )
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 )
sv>fv ( vector_source vector_dest n -- )
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

Constants start with #
Variables start with %
Counted string words starts with a $
Words that return a flag end with ?
We use _ to seperate words _
Print words start with a .
Words to be used with TO end with a @
Hex numbers &
Words that deal with a string described on stack "
Zero terminated strings ( we try not to use them) z"
Words that belong to the kernel and will never be documented and should not be used in applications start with a _
In the kernel immediate words runtime code starts with_do_

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

ANSI standard, known deviations