## ##
'-
Read and discard the next 62 characters. This is used in blocks to provide line width comments.
. Text to ignore
This is intended for use in blocks. If placed as the first word on a line, it will ignore the rest of the line.
As RetroForth does not track line lengths during evaluation, this can not be used to comment out the end of a line, only a full line.
(
##### ## ## ## ## ## ## ## ## ## #### ## ## ## #### ## ## ## #####
'-
Parse to end of line. Insert into text line 0
0 text for the top line
The provided text will replace all text on the line.
This is one of a very few parsing words.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
##
###
####
## ##
##
##
##
##
##
##
'-
Parse to end of line. Insert into text line 1
1 text for the second line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 2 3 4 5 6 7 8 9 10 11 12 13 14 15
#####
## ##
## ##
##
##
##
##
##
## ##
########
'-
Parse to end of line. Insert into text line 2
2 text for the third line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 3 4 5 6 7 8 9 10 11 12 13 14 15
########
## ##
##
##
#####
##
##
## ##
## ##
#####
'-
Parse to end of line. Insert into text line 3
3 text for the fourth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 4 5 6 7 8 9 10 11 12 13 14 15
##
###
####
## ##
## ##
## ###
## ####
#### ##
##
##
'-
Parse to end of line. Insert into text line 4
4 text for the fifth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 5 6 7 8 9 10 11 12 13 14 15
#####
####
##
## ###
#### ##
##
##
## ##
## ##
#####
'-
Parse to end of line. Insert into text line 5
5 text for the sixth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 6 7 8 9 10 11 12 13 14 15
#### ## ## ## ## ## ## ### #### ## ## ## ## ## ## ## ####
'-
Parse to end of line. Insert into text line 6
6 text for the seventh line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 7 8 9 10 11 12 13 14 15
########
## ##
##
##
##
##
##
##
##
##
'-
Parse to end of line. Insert into text line 7
7 text for the eighth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 8 9 10 11 12 13 14 15
#### ## ## ## ## ## ## ##### ## ## ## ## ## ## ## ## #####
'-
Parse to end of line. Insert into text line 8
8 text for the nineth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 9 10 11 12 13 14 15
####
## ##
## ##
## ##
## ####
### ##
##
## ##
## ##
####
'-
Parse to end of line. Insert into text line 9
9 text for the tenth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 10 11 12 13 14 15
## #####
### ## ##
#### ## ##
## ## ## ##
## ## ##
## ## ####
## ## ## ##
## #### ##
## ## ##
## #####
'-
Parse to end of line. Insert into text line 10
10 text for the eleventh line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 9 11 12 13 14 15
## ##
### ###
#### ####
## ## ## ##
## ##
## ##
## ##
## ##
## ##
## ##
'-
Parse to end of line. Insert into text line 11
11 text for the twelveth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 9 10 12 13 14 15
## #####
### ## ##
#### ## ##
## ## ##
## ##
## ##
## ##
## ##
## ## ##
## ########
'-
Parse to end of line. Insert into text line 12
12 text for the thirteenth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 9 10 11 13 14 15
## ########
### ## ##
#### ##
## ## ##
## #####
## ##
## ##
## ## ##
## ## ##
## #####
'-
Parse to end of line. Insert into text line 13
13 text for the fourteenth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 9 10 11 12 14 15
## ##
### ###
#### ####
## ## ## ##
## ## ##
## ## ###
## ## ####
## #### ##
## ##
## ##
'-
Parse to end of line. Insert into text line 14
14 text for the fifteenth line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 15
## #####
### ####
#### ##
## ## ## ###
## #### ##
## ##
## ##
## ## ##
## ## ##
## #####
'-
Parse to end of line. Insert into text line 15
15 text for the last line
The provided text will replace all text on the line.
This is one of a very few parsing words.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
### ###
## ##
## ##
## ##
## ##
### ###
### ###
## ##
## ##
## ##
## ##
### ###
-
Begin a lexical scoped area. Starts the private portion.
{{
'a var
:set &a store ;
:bump @a n:inc !a ;
---reveal---
:foo (n-) set bump @n n:put nl
}}
Scoping is lexical. This works by unlinking the dictionary headers in between the {{ and ---reveal--- from the dictionary.
---reveal--- }}
###
##
##
## ### ##### ## ## ##### ##### ##
## ## ## ## ## ## ## ## ## ## ## ##
###### ###### ###### #### ## ## ### ## ## ## ### ##### ## ###### ###### ######
### ##### ## ## ##### ### ## ##
## ## ## ## ## ## ## ##
## ## ## ### ## ## ## #### ##
## ###### ## ###### #### ## ##
-
Within lexical scoped area, switch to global scope area.
{{
'a var
:set &a store ;
:bump @a n:inc !a ;
---reveal---
:foo (n-) set bump @n n:put nl
}}
Scoping is lexical. This works by unlinking the dictionary headers in between the {{ and ---reveal--- from the dictionary.
{{ }}
### ###
## ##
## ##
## ##
## ##
### ###
### ###
## ##
## ##
## ##
## ##
### ###
-
Close off lexical scoped area. Hides words in the private area.
{{
'a var
:set &a store ;
:bump @a n:inc !a ;
---reveal---
:foo (n-) set bump @n n:put nl
}}
Scoping is lexical. This works by unlinking the dictionary headers in between the {{ and ---reveal--- from the dictionary.
{{ ---reveal---
##
##
##
##
##
##
##
##
##
##
##
##
-
Ending for comments or visual grouping. Provided for readability purposes
( #2 #2 n:add )
This is provided as a readability aid. Since comments (made by the `(` sigil) are ignored, you can use this to help visually group phrases in your code.
sigil:(
#####
## ##
## ##
##### ### ## ##
## ## ## ## ## ##
###### ## ### ## #### ##
##### ## ### ##
## ## ##
## ## ## ## ##
###### ###### ##
##
##
##
nn-f
Compare values for inequality
#100 #45 -eq?
eq? lt? gt? lteq? gteq?
## ####
## ## ##
##
## ##
## ####
###### ## ####
## ##
## ##
## ##
## ##
fp-
Execute p if flag is zero
#6 #100 eq? [ 'condition_not_met! s:put nl ] -if #100 #100 eq? [ 'condition_not_met! s:put nl ] -if
choose if
## ## ## ## ##
-
End a definition
:foo (-) ;
Compiler sigil::
##### ##
## ## ##
## ##
## ## ## ## ### ## ## ###
## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## #### ##
## ## ## ### ## ## ## ### ##
## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ##
## ## ### ## ## ## ######
## ## ##
## ## ##
#### ##
fp-
Internal. If flag is non-zero, branch to p.
(used_internally)
#### ## ###
## ## ## ##
## ##
## ##### ### ## ## ### ## ## ##### ## ###
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ## ### #### ##
## ## ## ## ## ## ### ## ## ## ##### ###
## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ##
##### ##### ## ## ###### ## ## ###### ##
##
##
##
-
Data. Tracks compiler state
:compiling? @Compiler [ 'Compiler_active ] [ 'Interpreting ] choose s:put nl ; #-1 @Dictionary d:flags store compiling? [ compiling? ] drop
The `Compiler` state is changed by `[`, `sigil::`, `]`, and `;`. For checking state, `compiling?` is provided.
compiling? sigil:: ;
###### ## # ##
## ## ## ## ##
## ## ##
## ## ## #### #### ## ##### ## ### ##### ## ### ## ##
## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## #### ## ##### #### ## ## ##
## ## ## ## ## ## ## ## ### ## ### ## ### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ### ## ## ## #### ## ## ## ## ## ## #### ## ## ##
#### ## ###### ## ## ##### ## ## #### ## ## #####
##
## ##
###
-
Data. Pointer to most recent header in dictionary
(Get_address_of_most_recent_word) @Dictionary d:address fetch n:put
d:create sigil:: d:for-each
#### #### ## ## ## ### ##### ##### ## ### ## ## ## ## ## ## ## #### #### ## ## ### ## ### ## ### ##### ##### ## ## ## ## ## ## ## ## ## ## ## ## ###### ######
-
Data. Pointer to next free addr
(Display_next_free_memory_address) @Free n:put
The `Free` variable holds a pointer to the next free memory address. You can check this value by calling `here`. Various words will consume memory. The main ones are `comma` and `allot`. Dictionary headers as well as some array and string words will also consume memory at `here`.
here allot gc
### ### ## ## ## ## ## ## ### ###
-n
Access the loop index for the current loop. (For loops made using indexed-times)
#10 [ I n:put ] indexed-times
J K indexed-times
##
##
##
##
##
##
## ##
## ##
## ##
#####
-n
Access the parent loop index for the current loop. (For loops made using indexed-times)
:inner [ I n:put $, c:put J n:put sp ] ; #10 [ #5 inner indexed-times ] indexed-times
I K indexed-times
## ## ## ## ## ### #### ### #### ## ## ## ## ## ## ## ##
-n
Access the grandparent loop index for the current loop. (For loops made using indexed-times)
:inner [ I n:put $, c:put J n:put $, c:put K n:put sp ] ; :outer #3 inner indexed-times ; #10 [ #5 &outer indexed-times ] indexed-times
I J indexed-times
###### ## ## ###
## ## ## ## ##
## ##
### ## ###### ## ## ######
### ## ## ## ## ## ## ##
## ## ## ## ## ## ###
## ## ## ### ## ## ####
## ## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## ######
##
## ##
######
-
Data. Table of sigil handlers
(get_pointer_to_sigil_table) &Sigils
Sigils is a table holding up to 128 (the lower 7-bit ASCII space) pointers to sigil handlers. Unused sigils have the matching entries here set to zero.
##### ## ## ## ## ## ## ## ## ## ## #####
-p
Begin a quotation
[ #45 n:put ] call
Quotations are anonymous, nestable functions. RetroForth uses `[` to begin one.
]
#####
##
##
##
##
##
##
##
##
##
##
#####
p-p
End a quotation
[ #45 n:put ] call
Quotations are anonymous, nestable functions. RetroForth uses `]` to end one.
[
##
##
## ##
##### ## ##### ## ### ## ### ##### ## ### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ##
##### ##### #### ## #### ## ## ### #### ## ## ##
### ## ### ## ### ## ### ## ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## ## ####
## #### ## ## #### ## ## ## ## ## ## ## ## ## ## ##
#### ## #### ## ###### ###### ###### ## ## ### ##
## ##
## ##
## ##
aa-a
Create a new array with the contents of a1 followed by a2
(displays:_1_2_3_6_5_4) ( #3 #2 #1 ) #3 a:make/temp ( #4 #5 #6 ) #3 a:make/temp a:append [ n:put sp ] a:for-each
An `a:append` operations constructs a new (temporal) array from the contents of two provided arrays.
a:prepend
## ## ##
## ## ##
## ## ## ##
##### ## ## ### ##### ## ### ##### ##### #####
## ## #### ## ## ## ## ## ## ## ## ## ## ### ##
##### ## ## ## ### #### ## ## ### ##### ## ##
### ## ## ## ##### ### ## ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## ####
## #### ## ## ### ## ## ## ## ## ## ## #### ## ## ##
#### ## #### ###### ## ## ###### #### ## ### ##
a-a
Remove first item from an array
(remove_first_item_in_array) ( #100 #200 #300 ) #3 a:make/temp a:behead
a:chop
##
##
## ##
##### ## #### ## ### ##### ## ###
## ## ## ## ## ## ## ## ## ## ## ##
##### ## #### ## ## ## #### ##
### ## ## ### ## ## ## ### ##
## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ## ## ## ##
#### ## ###### ## ## ##### ######
##
##
##
a-a
Remove last item from an array
(remove_last_item_in_array) ( #100 #200 #300 ) #3 a:make/temp a:chop
New array is allocated in the temporary pool.
a:behead
# ## #####
## ## ## ##
## ## ## ##
##### ## #### ##### ## ### #### ##### ## ## ### ###### ##
## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ##
##### ## ## ## #### ## ## ##### ## #### ## ### ##
### ## ## ## ## ### ## ## ### ## ## ### ## #### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ## ## #### ## #### ## ## ## ## ## ##
#### ## ###### ##### ## ## ## #### ## ## ## ## ###### ##
an-f
True if array contains n. False otherwise
( #100 #200 #300 ) #3 a:make \data-set &data-set #300 a:contains? n:put nl &data-set #281 a:contains? n:put nl
##
##### ## #### ##### ## ### ## ##
## ## ## ## ## ## ## ## ## ## ##
##### ## ## ## #### ## ## ##
### ## ## ## ## ### ## ## ##
## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ## ## ## ##
#### ## ###### ##### ###### #####
## ##
## ## ##
## ###
ap-
Copy array a to memory starting at pointer p
( #100 #200 #300 ) #3 a:make \data-set here #4 allot \data-set-copy &data-set &data-set-copy a:copy
##
##
## ##
##### ## ##### ## ## ## ###
## ## ### ## ## ## ## ## ##
##### ## ## ## ## #### ##
### ## ## ### ## ### ### ##
## ## ## ## #### ## #### ## ##
## #### ## ## ## ## ## ## ## ## ##
#### ## ### ## ### ## ######
##
##
##
a-a
Make a copy of an array
( #100 #200 #300 ) #3 a:make \data-set &data-set a:dup [ n:put sp ] a:for-each
#####
## ##
## ## ##
##### ## ##### ### ## ##
## ## ## ## ## ## ## ##
##### ## ### ## #### ##
### ## ##### ## ### ##
## ## ## ## ## ##
## #### ## ## ## ## ## ##
#### ## ###### ###### ##
##
##
##
aa-f
Compare two arrays for equality
( #100 #200 #300 ) #3 a:make \data-set1 ( #100 #200 #300 ) #3 a:make \data-set2 ( #10 #20 #30 ) #3 a:make \data-set3 &data-set1 &data-set2 a:eq? n:put nl &data-set1 &data-set3 a:eq? n:put nl &data-set2 &data-set3 a:eq? n:put nl
#####
## ##
## ## ##
##### ## ##### ### ## ##
## ## ## ## ## ## ## ##
##### ###### ## ### ## #### ##
### ## ##### ## ### ##
## ## ## ## ## ##
## #### ## ## ## ## ## ##
#### ## ###### ###### ##
##
##
##
aa-f
Compare two arrays for inequality
( #100 #200 #300 ) #3 a:make \data-set1 ( #100 #200 #300 ) #3 a:make \data-set2 ( #10 #20 #30 ) #3 a:make \data-set3 &data-set1 &data-set2 a:-eq? n:put nl &data-set1 &data-set3 a:-eq? n:put nl &data-set2 &data-set3 a:-eq? n:put nl
#### # ##
## ## ## ##
## ## ## ##
##### ## ## ##### #### #### ## ###
## ## #### ## ## #### ## ## ## ## ##
##### #### ## ### ## ## #### ##
### ## ## ##### ## ## ### ##
## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## #### ## ## ## ##
#### ## ## ###### ## ###### ## ##
an-v
Fetch value stored at index n in array
( #100 #200 #300 ) #3 a:make \data-set &data-set #2 a:fetch n:put
a:store a:th
#### ## ### #
## ## ## ## ##
## ## ## ##
##### ## ## ## ## #### ##### ## ###
## ## #### ## ## #### ## ## ## ## ##
##### #### ## ## ## ## ### #### ##
### ## ## ## ## ## ##### ###
## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## #### ## ## ##
#### ## ## ## ## ## ###### ##
ap-a
Run p once for each value in a. If it returns true, copy value new array
( #1 #2 #3 #4 ) #4 a:make \data-set &data-set [ #2 n:mod n:zero? ] a:filter [ n:put sp ] a:for-each
#### ## #
## ## ## ##
## ## ##
##### ## ## ## ## ### ###### ####
## ## #### ## ## ## ## ## ## ####
##### #### ## #### ## ### ##
### ## ## ## ### #### ##
## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ## ####
#### ## ## ## ## ###### ##
a-n
Return the first value in an array
( #1 #2 #3 #4 ) #4 a:make/temp a:first n:put nl
#### ##
## ## ##
## ## ##
##### ## ## ##### ## ### ##### ##### #### ## ###
## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ##
##### #### ## ## #### ## ###### ## ### ##### ## #### ##
### ## ## ## ## ### ##### ### ## ## ### ##
## ## ## ## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ## ## ## #### ## ## ## ##
#### ## ## ##### ## ###### #### ## ###### ## ##
ap-
Run p once for each value in the array. Pushes each value prior to calling p
( #1 #2 #3 #4 ) #4 a:make/temp [ n:put tab ] a:for-each nl
## ##
## ##
## ## ##
##### ## ## ### ##### ###### ## ###
## ## ## ## ## ## ## ## ## ## ## ##
##### #### ## ##### ### #### ##
### ## ### ## ### ## #### ### ##
## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## #### ## ## ## ##
#### ## ## ## #### ## ###### ## ##
a-n
Return the hash of an array
( #1 #2 #3 #4 ) #4 a:make/temp a:hash
## ## ##
## ## ##
## ##
##### ## ## ## ### ##### ## #### ##### ######
## ## ## ## ## ## ### ## ## ## ## ## ## ## ##
##### ## #### ## ## ## ## ## ## ### ###
### ## ## ### ## ## ### ## ## ##### ####
## ## ## ## ## ## ## #### ## ## ## ##
## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ### ## ## ###### ###### ######
av-a
Return array of indices for v in source array
'hello_world $o a:indices [ n:put sp ] a:for-each nl
a:index
## ##
## ##
## ##
##### ## ## ## ### ##### ##### ## ##
## ## ## ## ## ## ### ## ## ## ## ##
##### ## #### ## ## ## ## ### ####
### ## ## ### ## ## ### ##### ##
## ## ## ## ## ## ## #### ## ####
## #### ## ## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ### ## ###### ## ##
av-n
Return first index of n in a
'hello_world $e a:index n:put nl
a:indices
### #
## ##
## ## ##
##### ## ## ##### ###### ####
## ## ## ## ## ## ## ####
##### ## ##### ### ##
### ## ## ### ## #### ##
## ## ## ## ## ## ## ## ##
## #### ## ## ## #### ## ## ####
#### ## ## #### ## ###### ##
a-n
Return the last value in an array
'hello a:last c:put
### #### #
## ## ## ##
## ## ## ##
##### ## ## ##### ## ####
## ## ## ## ## #### ####
##### ## ## ### #### ##
### ## ## ##### ## ##
## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ####
#### ## ## ###### ## ##
an-a
Return left n values from array
( #1 #20 #13 #84 #5 ) #5 a:make/temp #3 a:left
New array is allocated in the temporary pool.
a:right a:middle
### # ##
## ## ##
## ## ## ##
##### ## ## ##### ## ### ###### #### ## ###
## ## ## ## ## ## ## ## ## ## #### ## ## ##
##### ## ## ### #### ## ## ## ## #### ##
### ## ## ##### ### ## ## ### ## ### ##
## ## ## ## ## ## ## ## #### ## ## ## ##
## #### ## ## ## ## ## ## ## ## ## #### ## ##
#### ## ## ###### ## ## ### ## ## ## ##
##
## ##
######
a-n
Return the length of an array
(returns_3) ( #100 #200 #300 ) #3 a:make/temp a:length
##
##
## ##
##### ## ### ## ##### ## ## #####
## ## ## ## ## ## ## ## ## ## ##
##### ## ## ## ##### ## ## ## ###
### ## ## ## ## ### ## ##### #####
## ## ## ## ## ## ## ### ## ##
## #### ## ## ## ## #### ## ## ## ##
#### ## ## ## #### ## ## ## ######
...n-a
Create a new permanent array from the provided values
(create_an_array_of_three_characters,_"cba") $a $b $c #3 a:make (display_it_as_a_string) s:put nl
This creates an array in the permanent memory area. For arrays that aren't needed long term, it may be better to use `a:make/temp` instead.
a:make/temp
## ## #
## # ##
## ## ## ##
##### ## ### ## ##### ## ## ##### # #### ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ##
##### ## ## ## ##### ## ## ## ### # ## ## ### ## ## ## #### ##
### ## ## ## ## ### ## ##### ##### ## ## ##### ## ## ## ### ##
## ## ## ## ## ## ## ### ## ## # ## ## ## ## ## ## ##
## #### ## ## ## ## #### ## ## ## ## ## #### ## ## ## ## ## ##
#### ## ## ## #### ## ## ## ###### # ## ###### ## ## ######
## ##
##
##
...n-a
Create a new temporary array from the provided values
(create_an_array_of_three_characters,_"cba") $a $b $c #3 a:make/temp (display_it_as_a_string) s:put nl
This creates an array in the temporary pool. This is preferred for short lived arrays.
a:make
##
##### ## ### ## ##### ## ###
## ## ## ## ## ## ## ## ## ##
##### ## ## ## ##### #### ##
### ## ## ## ## ### ## ### ##
## ## ## ## ## ## ## ## ##
## #### ## ## ## ## #### ## ##
#### ## ## ## #### ## ######
##
##
##
ap-a
Run p once for each value in the array. Takes the returned value and creates a new array
(displays:_30_20_10) ( #1 #2 #3 ) #3 a:make/temp [ #10 n:mul ] a:map [ n:put sp ] a:for-each
## ## ## ###
## ## ## ##
## ## ## ##
##### ## ### ## ## ##### ##### ## #####
## ## ## ## ## ## ### ## ### ## ## ## ##
##### ## ## ## ## ## ## ## ## ## ## ###
### ## ## ## ## ## ## ### ## ### ## #####
## ## ## ## ## ## ## #### ## #### ## ##
## #### ## ## ## ## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ### ## ### ## ## ######
afl-a
Return new array from f to l, inclusive
(__5__4__3__2__1__0_:-_value_offset) ( #6 #5 #4 #3 #2 #1 ) #6 a:make/temp (_______^^__________:_-_start_at_offset_3) #3 (____^^_^^__________:_-_take_two_values) #2 a:middle
a:left a:right
##
##
## ##
##### ## ## ### ## ### ##### ## ### ##### ## ### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ##
##### #### ## #### ## ## ### #### ## ## ### #### ## ## ##
### ## ### ## ### ##### ### ## ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## ## ####
## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
#### ## ###### ## ###### ###### ###### ## ## ### ##
## ##
## ##
## ##
aa-a
Create a new array with the contents of a2 followed by a1
(displays:_6_5_4_1_2_3) ( #3 #2 #1 ) #3 a:make/temp ( #4 #5 #6 ) #3 a:make/temp a:prepend [ n:put sp ] a:for-each
An `a:prepend` operations constructs a new (temporal) array from the contents of two provided arrays. This is identical to `a:append` except for the argument ordering.
a:append
##
##
## ##
##### ## ## ### ##### ##### ## ## #### #####
## ## ## ## ## ## ## ### ## ## ## ## ## ## ##
##### #### ## ## ### ## ## ## ## ## ## ###
### ## ### ##### ## ### ## ### ## #####
## ## ## ## ## ## #### ## #### ## ##
## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ##
#### ## ## ###### ### ## ### ## ###### ######
anp-n
Takes an array, a starting value, and a quote. This will apply the quote to each item in the array; the quote should consume two values and return one
(sum_values_in_array) :a:sum (a-n) #0 [ n:add ] a:reduce ; ( #1 #20 #13 #84 #5 ) #5 a:make/temp a:sum
##
##### ## ## ### ##### ## ## ##### ## ### ###### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
##### #### ## ## ### ## ## ## ### #### ## ### ## ###
### ## ### ##### ## ## ##### ### #### #####
## ## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ### ## ## ## ## ## ## ##
#### ## ## ###### ## ###### ## ###### ######
a-a
Reverse the order of items in an array
( #1 #20 #13 #84 #5 ) #5 a:make/temp a:reverse
New array is allocated in the temporary pool.
## ## #
## ## ##
## ## ##
##### ## ## ### ## ###### ## ### ####
## ## ## ## ## ## ## ## ## ## ## ####
##### #### ## ## ## ## #### ## ##
### ## ### ## ## ### ### ## ##
## ## ## ## ## ## #### ## ## ## ##
## #### ## ## ## ## ## ## ## ## ####
#### ## ## ## ### ## ## ## ##
##
## ##
######
an-a
Return right n values from array
( #1 #20 #13 #84 #5 ) #5 a:make/temp #2 a:right
New array is allocated in the temporary pool.
a:left a:middle
#
##
## ##
##### ## ###### #### ##### ## ### #####
## ## ## ## #### ## ## ## ## ## ## ##
##### ### ## ## ## #### ## ## ###
### ## #### ## ## ## ### #####
## ## ## ## ## ## ## ## ## ##
## #### ## ## ## #### ## ## ## ## ##
#### ## ###### ## ##### ## ######
van-
Store value v into array at index n
( #1 #20 #13 #84 #5 ) #5 a:make \data-set &data-set [ n:put sp ] a:for-each #2000 &data-set #2 a:store &data-set [ n:put sp ] a:for-each
a:fetch a:th
#
##
## ##
##### ## #### ##### ### ## ## ###
## ## #### ## ## ## ## ## ## ## ##
##### ## ## ### ## ## ## #### ##
### ## ## ##### ## ## ## ### ##
## ## ## ## ## ## ## ## ## ##
## #### ## #### ## ## ## ## ## ##
#### ## ## ###### ## ## ######
##
##
##
a-a
Make a copy of the array in the temporary string/array space
(make_an_array) ( #10 #15 #20 ) #3 a:make (put_a_copy_into_the_temporary_buffers) a:temp
The temporary pool is shared with strings.
# ##
## ##
## ## ##
##### ## #### ## ###
## ## #### ## ## ##
##### ## #### ##
### ## ## ### ##
## ## ## ## ## ## ##
## #### ## #### ## ##
#### ## ## ## ##
an-p
Return the address of a specific index into the array
( #10 #15 #20 ) #3 a:make/temp #1 a:th
The calculation for this is:
array-start + offset + 1
`a:th` is provided to aid in readability, and is mainly an internal factor used by `a:fetch` and `a:store`.
a:fetch a:store
### ### #
## ## ##
## ## ##
##### ## ## ##### ####
## ## ## ## ## ## ####
##### ## ## ## ## ##
### ## ## ## ## ## ##
## ## ## ## ## ## ## ##
## #### ## ## ## ## ####
#### ## ## ## ##### ##
n-
Allocate n cells of memory
(allocate_500_cells) #500 allot (free_500_cells) #-500 allot
`allot` both allocates and frees (when passed a negative length) memory at `here`. The allocations are strictly linear, so take care when freeing memory. If you need to temporarily allocate memory, it's recommended to use `allot` in a `gc` quote to handle the cleanup.
Free here gc
##
##
##
##### ## ### #####
## ## ## ## ## ### ##
##### #### ## ## ##
### ## ### ## ## ###
## ## ## ## ## ####
## #### ## ## ## ## ##
#### ## ## ## ### ##
nn-n
Perform a bitwise AND
#0 #-1 and n:put nl (0) #-1 #-1 and n:put nl (-1) #-1 #0 and n:put nl (0) #0 #0 and n:put nl (0)
or xor not
## ## ## ## ## ## ### ## #### ## ## ## ## ## ## ## ## ## ## ## ## ### ## #### ##
xpp-?
Execute p1 against x, then p2 against a copy of x
#10 [ n:inc ] [ n:dec ] bi
bi* bi@ tri tri* tri@
## ## ## ## ## ## #### ## ######## ## ### ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## #### ##
xypp-
Execute p1 against x and p2 against y
#10 #20 [ n:inc ] [ n:dec ] bi*
bi bi@ tri tri* tri@
## ## ####
## ## ## ##
## ## ####
## ### ## ## ## ##
#### ## ## ## ## ##
## ## ## ## ## ##
## ## ## ## ####
## ## ## ## ##
## ### ## ## ##
#### ## ## ###
###
xyp-
Execute p against x, execute p against y
#10 #20 [ #10 n:div ] bi@
bi bi* tri tri* tri@
## ### ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ##### #### ## ## ## ## ##### ##### ##### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ##### ## ## ## ## ## ## ## ## ##### ## ## ## ### ## ## ### ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## #### ## ### ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## #### ## ##### ###### ## ## ## ##### #### ## ### ##
np-
Read 1024 cells in block n to p
(load_contents_of_block_45_into_block_buffer) #45 block:buffer block:load
block:save block:buffer
## ### ## ## ## ## ## ## ## ## ## ### ## ##### #### ## ## ## ###### ##### ## ## ##### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ##### ## ## ## ### ## ## ## ## ## ## ##### #### ### ## ## ## ##### ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## #### ### ## ## #### ## ##### ###### ## ## ###### #### ## ## ######
np-
Save 1024 cells at p to block n
(save_contents_of_block_buffer_to_block_45) #45 block:buffer block:save
block:load block:buffer
## ### ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ##### #### ## ## ## ## ### ## ## ## ## ##### ## ### #### ## ## ## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### #### ## ### #### ## ## ## ## ## ## ## ##### ## ## ## ### ## ## ##### ### ## ## ## ## ## ## ### ## ## ## ## ## #### ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## #### ## ##### ###### ## ## #### ### ## ## ## ###### ##
-p
Return a pointer to the start of the block buffer
block:buffer
block:load block:save
##
##
##
## ### ## ## #####
#### ## ## ## ## ##
## ## ## ## ## ###
## ## ## ## #####
## ## ## ## ##
## ### ## ## ## ##
#### ##### ######
##
## ##
###
-
Exit RetroForth/ilo
(exit_retroforth/ilo) bye
On a hosted system, `bye` will generally exit the system. On a native/embedded system the behaviour is left to the implementation. Consult the documentation for your local system in this case.
#
##
## ##
#### ## ###### ##### ####
## ## ## ## ## ## ####
## ## ## ## ### ##
## ## ### ##### ##
## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ####
###### ### ## ###### ##
##
## ##
######
-c
Read a character from the keyboard
:pause 'Press_a_key... s:put c:get drop ;
This word may return as soon as a key is hit or buffered until a newline is entered. On a BSD or Linux, you can run `stty cbreak` prior to starting RetroForth/ilo to have it return immediately. If you do this, run `stty -cbreak` when done.
If you use a Unix and prefer line buffering, it's worth considering using something like `rlwrap` to get history and line editing support.
`c:get` is a hookable word. It starts with a set of two `........` instruction bundles (NOPs) that can be replaced to jump to a user-chosen word instead. If you are trying to inject data as input, this should be your starting point.
c:put
### #####
## ## ##
## ## ## ##
#### ## ## ##### ## ## ##### ## ### #### ##### ###### ##### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ### #### ## ## ##### ### ## ### ##
## ## ## ## ## ## ## ##### ### ## ### ## #### ##### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ######## ## ## ## ## ## ## #### ## ## ## ## ##
###### ## ##### ## ## ###### ## ###### #### ## ###### ###### ##
c-f
Return true if character is lowercase or false if not
(returns_true) $c c:lowercase? (returns false) $D c:lowercase?
The case determination only works with ASCII (or the subset of UTF8 corresponding to ASCII).
c:uppercase?
#
##
## ##
#### ## ## ### ## ## ####
## ## ## ## ## ## ## ####
## #### ## ## ## ##
## ### ## ## ### ##
## ## ## ## ## #### ## ##
## ## ## ## ## ## ## ## ####
###### ###### ### ## ##
##
##
##
c-
Display a single character
$h c:put $e c:put $l c:put $l c:put $o c:put
`c:put` is a hookable word. It starts with a set of two `........` instruction bundles (NOPs) that can be replaced to jump to a user-chosen word instead. If you are trying to capture all output, this is the best bet.
c:get
# ###
## ##
## ## ##
#### ## #### ##### ## ##### ## ## ##### ## ###
## ## #### ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ###### ## ## ## ## ## ## ### #### ##
## ## ## ## ## ## ## ## ## ## ##### ###
## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ######## ## ## ##
###### ## ##### ## ##### ## ## ###### ##
c-c
Convert character to lowercase
$c c:to-lower c:put
The case conversion only works with ASCII (or the subset of UTF8 corresponding to ASCII).
c:to-upper
#
##
## ##
#### ## #### ##### ######
## ## #### ## ## ## ##
## ## ## ## ###### ###
## ## ## ## ####
## ## ## ## ## ## ##
## ## ## #### ## ## ## ##
###### ## ##### ######
c-s
Convert a character to a string
$c c:to-s
This create a temporary string and sets the first character to the provided one. It's useful if you need to append a character to a string.
s:to-n n:to-s
#
##
## ##
#### ## #### ##### ## ## ## ### ## ### ##### ## ###
## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ###### ## ## #### ## #### ## ## ### #### ##
## ## ## ## ## ### ### ## ### ## ##### ###
## ## ## ## ## ## ## #### ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ##
###### ## ##### ### ## ###### ###### ###### ##
## ##
## ##
## ##
c-c
Convert character to uppercase
$c c:to-upper c:put
The case conversion only works with ASCII (or the subset of UTF8 corresponding to ASCII).
c:to-lower
#####
## ##
## ## ##
#### ## ## ## ## ### ## ### ##### ## ### #### ##### ###### ##### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## #### ## ## ### #### ## ## ##### ### ## ### ##
## ## ### ### ## ### ## ##### ### ## ### ## #### ##### ##
## ## ## #### ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ##
###### ### ## ###### ###### ###### ## ###### #### ## ###### ###### ##
## ##
## ##
## ##
c-f
Return true if character is uppercase or false if not
(returns_true) $C c:uppercase? (returns false) $d c:uppercase?
The case determination only works with ASCII (or the subset of UTF8 corresponding to ASCII).
c:lowercase?
### ###
## ##
## ##
#### ##### ## ##
## ## ## ## ## ##
## ##### ## ##
## ### ## ## ##
## ## ## ## ##
## ## ## #### ## ##
###### #### ## ## ##
p-
Call a function
(call_a_function_[via_pointer]) &bye call (or_call_a_quote) [ bye ] call
jump
##
##
##
#### ## ### ##### ##### ###### #####
## ## ## ## ## ## ## ## ## ## ## ## ##
## #### ## ## ## ## ## ### ## ###
## ### ## ## ## ## ## #### #####
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ##
###### ## ## ##### ##### ###### ######
fpp-
Execute p1 if flag is non-zero or p2 if zero.
:is-one? (n-) [ #1 eq? ] [ #-1 eq? ] bi or [ 'Yes! ] [ 'No! ] choose s:put nl ; #10 is-one? (No!) #1 is-one? (Yes!) #-1 is-one? (Yes!) #-10 is-one? (No!)
if -if
#### ##### ### ## ### ## ##### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##### ## ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ###### ##### ## ## ## ## #### ##
n-
Inline a value to here and increment Free
(let's_make_a_manual_array) here (pointer) #3 comma (length) $a comma (value_0) $b comma (value_1) $c comma (value_2) (display it) [ c:put ] a:for-each nl
#### ##### ### ## ## ### ##### ## ### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ##### #### ## ## ###
## ## ## ## ## ## ### ## ### ## ### #####
## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## #### ## ## ##
###### ##### ## ## ###### #### ## ## ######
##
##
##
sdn-f
Compare n cells of memory startng at s to memory starting at d. Return true if all match or false otherwise
'Hello s:keep \Test-1 'Nevermore s:keep \Test-2 'Hello s:keep \Test-3 &Test-1 &Test-2 over s:length n:inc compare n:put nl (0) &Test-1 &Test-3 over s:length n:inc compare n:put nl (-1) &Test-2 &Test-3 over s:length n:inc compare n:put nl (0)
## ### ## #####
## ## ## ## ##
## ## ##
#### ##### ### ## ## ### ## ## ## ## ### ###### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ## #### ## ## ## ##
## ## ## ## ## ## ### ## ## ## ## ### ## ## ### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ##### ## ## ###### ## ## ## ## ## ### ## ##
## ##
## ## ##
## ######
-f
True if Compiler is set, False otherwise
:c? compiling? [ 'Compiler_active ] [ 'Interpreting ] choose s:put nl ; #-1 @Dictionary d:flags store c? [ c? ] drop
Compiler sigil:: ;
## ### ### ## #
## ## ## ## ##
## ## ## ##
#### ##### ### ## ## ### ## ## ##### ## ## ## ####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
## ## ## ## ## ## #### ## ## ## ## ### ## ## ##
## ## ## ## ## ## ### ## ## ## ##### ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
###### ##### ## ## ###### ## ## ###### ## ## ##
##
##
##
n-
Internal. Compile an ilo li instruction
(used_internally)
## ### ### ###
## ## ## ##
## ## ## ##
#### ##### ### ## ## ### ## ## ##### ## #### ##### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ## ### ## ##### ## ##
## ## ## ## ## ## ### ## ## ## ##### ## ### ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ##
###### ##### ## ## ###### ## ## ###### ###### #### ## ## ##
##
##
##
p-
Internal. Compile an ilo lica instruction
(used_internally)
## ### ##
## ## ##
## ##
#### ##### ### ## ## ### ## ## ##### ## ## ## ## ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ## ### ## ## ## ## ## ## #### ##
## ## ## ## ## ## ### ## ## ## ##### ## ## ### ## ## ## ### ##
## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ##### ## ## ###### ## ## ###### ## ### ## ## ## ######
## ## ## ##
## ## ## ##
## #### ##
p-
Internal. Compile an ilo liju instruction
(used_internally)
#### ##### ## ### ## ##
## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ##
## ## ## ### ## ## ##
## ## ## ## ## ## ##
## ## ## ## ## ## ## ##
###### ##### ###### #####
## ##
## ## ##
## ###
sdc-
Copy c cells starting at s to memory starting at d. Does not support overlapping regions
'Test d:create #45 allot 'Test_data &Test over s:length n:inc copy
#### ## ## ## ### ## ### ## ##
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## #### ## ## ##
## ## ### ### ### ## ##
## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ##
###### ### ## ## ## #####
##
## ##
###
vp-p
Create a new quote pushing the value, then calling p1
#100 &n:put curry \100 100 (displays_100)
## ## ##
## ## ##
## ## ## ##
##### ## ##### ##### ##### ## ### ##### ###### ######
### ## ## ## ### ## ### ## ## ## ## ## ## ## ## ## ##
## ## ##### ## ## ## ## #### ## ## ### ### ###
## ### ### ## ## ### ## ### ### ##### #### ####
## #### ## ## ## ## #### ## #### ## ## ## ##
## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## #### ## ### ## ### ## ## ###### ###### ######
d-p
Given a dictionary header, return a pointer to the address field
(get_address_of_most_recent_word) @Dictionary d:address fetch
d:flags d:hash d:link
## #
## ##
## ## ##
##### ## #### ## ### ##### ##### #### #####
### ## ## ## ## ## ## ## ## ## ## #### ## ##
## ## ## #### ## ## ### ##### ## ## ###
## ### ## ### ##### ### ## ## #####
## #### ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## #### #### ## ##
### ## ###### ## ###### #### ## ## ######
s-
Create a new header
(create_a_new_header_for_"foo") 'foo d:create (the_address_field_is_pointing_to_`here`)
sigil::
## ## # #####
## ## ## ## ##
## ## ## ## ##
##### ## ##### ## ## ## ###### #### ###### ##
### ## ## ## ## ## ## ## ## #### ## ## ##
## ## ## ### #### ## ### ## ### ##
## ### ##### ## ## #### ## #### ##
## #### ## ## #### ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### ## ## ##
### ## ###### ## ## ## ###### ## ###### ##
s-f
Given a dictionary header, return a flag indicating whether or not the word exists
:defined? (s-) d:exists? [ 'yes ] [ 'no ] choose s:put nl ; 'drop defined? 'dfo4j2o41oj defined?
## #### ###
## ## ## ##
## ## ## ##
##### ## ## ## ##### ###### ######
### ## #### ## ## ## ## ## ## ##
## ## #### ## ##### ## ## ###
## ### ## ## ### ## ## ### ####
## #### ## ## ## ## ## ## #### ##
## ## ## ## ## ## ## #### ## ## ## ## ##
### ## ## ## #### ## ### ## ######
##
## ##
######
d-p
Given a dictionary header, return a pointer to the flags field
(get_flags_of_most_recent_word) @Dictionary d:flags fetch
The flags field is currently used to identify immediate words. We can extend this to support up to 32 flags, but there are no plans to do so at this time.
d:address d:hash d:link
## ## ##
## ## ##
## ## ## ##
##### ## ## ### ##### ###### ## ###
### ## ## ## ## ## ## ## ## ## ## ##
## ## #### ## ##### ### #### ##
## ### ### ## ### ## #### ### ##
## #### ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## #### ## ## ## ##
### ## ## ## #### ## ###### ## ##
d-p
Given a dictionary header, return a pointer to the hash field
(get_hash_of_most_recent_word) @Dictionary d:hash fetch
d:address d:flags d:link
## ### ## ##
## ## ## ##
## ## ## ##
##### ## ## ## ## ### ## ##
### ## ## ## ## ## ## ## ##
## ## ## ## #### ## ## ##
## ### ## ## ### ## #####
## #### ## ## ## ## ## ### ##
## ## ## ## ## ## ## ## ## ##
### ## ## ## ## ## ## ##
d-p
Given a dictionary header, return a pointer to the link field
(get_header_of_most_recent_word) @Dictionary (follow_d:link_to_previous_header) d:link fetch
d:address d:flags d:hash
## ### ##
## ## ##
## ## ## ##
##### ## ## ##### ##### ## ## ## ## ## ###
### ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### ##
## ### ## ## ## ## ## ##### ## ### ### ##
## #### ## ## ## ## ## ## ### ## ## #### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ##### ##### ## ## ### ## ######
##
##
##
s-d
Lookup a word in the dictionary. Returns zero if not found or the dictionary header address
:defined? (s-f) d:lookup n:-zero? ; 'sys:info defined? n:put nl (-1) 'dj13j1gm0 defined? n:put nl (0) 'bye d:lookup d:address fetch call
## # ##
## ## ##
## ## ##
##### ##### ## ### #### ## ### ######
### ## ## ## ## ## ## #### ## ## ## ## ##
## ## ## ### #### ## ## #### ## ###
## ### ##### ### ## ## ### ## ####
## #### ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## #### ## ## ## ##
### ## ###### ###### ## ## ## ######
##
##
##
-nm
Return depths of data and address stacks
depths n:put tab n:put nl
The returned depth of the data stack does not include the values being pushed by this.
depth/data depth/address
## # ## ## ## #
## ## ## # ## ##
## ## ## ## ## ##
##### ##### ## ### #### ## ### # ##### ##### #### #####
### ## ## ## ## ## ## #### ## ## ## ## ### ## ## ## #### ## ##
## ## ## ### #### ## ## #### ## # ## ## ##### ## #####
## ### ##### ### ## ## ### ## ## ## ### ### ## ## ### ##
## #### ## ## ## ## ## ## ## # ## #### ## ## ## ## ## ##
## ## ## ## ## ## ## #### ## ## ## ## ## ## ## #### #### ## ####
### ## ###### ###### ## ## ## # ### ## #### ## ## #### ##
## ##
##
##
-n
Return the depth of the data stack
:.stk depth/data n:put '_items_on_the_stack s:put nl ; .stk
The returned depth does not include the value being pushed by this.
depths depth/address
## # ## ## ## ##
## ## ## # ## ##
## ## ## ## ## ##
##### ##### ## ### #### ## ### # ##### ##### ##### ## ### ##### ###### ######
### ## ## ## ## ## ## #### ## ## ## ## ## ## ### ## ### ## ## ## ## ## ## ## ## ## ##
## ## ## ### #### ## ## #### ## # ##### ## ## ## ## #### ## ## ### ### ###
## ### ##### ### ## ## ### ## ## ### ## ## ### ## ### ### ##### #### ####
## #### ## ## ## ## ## ## ## # ## ## ## #### ## #### ## ## ## ##
## ## ## ## ## ## ## #### ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ###### ###### ## ## ## # #### ## ### ## ### ## ## ###### ###### ######
## ##
##
##
-n
Return the depth of the address stack
depth/address n:put nl
depth/data depths
## ##
## ##
##
##### ## ## ###
### ## ## ## ## ##
## ## ## #### ##
## ### ## ### ##
## #### ## ## ##
## ## ## ## ## ##
### ## ## ######
##
##
##
np-n
Push n to address stack, call p. then restore n to data stack
#1 #2 [ n:put nl ] dip n:put nl
This is the same as doing:
push ... pop
sip push pop
##
##
##
##### ## ### ##### ## ###
### ## ## ## ## ## ## ## ## ##
## ## #### ## ## ## #### ##
## ### ### ## ## ### ##
## #### ## ## ## ## ##
## ## ## ## ## ## ## ##
### ## ## ##### ######
##
##
##
n-
Discard top value on stack
#1 #2 #3 #4 #5 #6 drop #5 [ n:put tab ] times nl
drop-pair nip
## ##
## ##
##
##### ## ### ##### ## ### ## ### ##### ## ## ###
### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## #### ## ## ## #### ## ###### #### ## ##### ## #### ##
## ### ### ## ## ### ## ### ## ### ## ## ###
## #### ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### ## ##
### ## ## ##### ###### ###### #### ## ## ##
## ##
## ##
## ##
nn-
Discard top two values on stack
#1 #2 #3 #4 #5 #6 drop-pair n:put tab n:put nl n:put tab n:put nl
This is the same as doing `drop drop`.
drop nip
## #
## ##
## ##
##### #### ####
### ## #### ## ##
## ## ## ##
## ### ## ##
## #### ## ## ##
## ## ## #### ## ##
### ## ## ######
-
Internal. Data following is a direct threaded address list
(used_internally)
##
##
##
##### ## ## ## ###
### ## ## ## ## ## ##
## ## ## ## #### ##
## ### ## ### ### ##
## #### ## #### ## ##
## ## ## ## ## ## ## ##
### ## ### ## ######
##
##
##
n-nn
Duplicate top value on stack
#13 dup n:put tab n:put nl
dup-pair
## ##
## ##
##
##### ## ## ## ### ## ### ##### ## ## ###
### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## #### ## ###### #### ## ##### ## #### ##
## ### ## ### ### ## ### ## ### ## ## ###
## #### ## #### ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### ## ##
### ## ### ## ###### ###### #### ## ## ##
## ##
## ##
## ##
nm-nmnm
Duplicate top two values
#1 #2 dup-pair n:put tab n:put nl n:put tab n:put nl
dup
###### ## ###
## ## ## ##
## ## ## ##
##### ## ## ## ## ###### ## ### ## ##### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ### ## ## ## ### #### ## ## ##### ## ##
##### ## ## ## #### ### ## ## ### ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ### ## ## ## ## ## ## ## #### ## ##
###### #### ## ###### ###### ## #### ## #####
## ##
## ## ##
## ###
-
Data. Holds a pointer to a block display word. Called by edit.
&list# !e:Display @e:Display call
The `e:Display` variable holds a pointer to the word used to display a block when editing starts via `edit`. It defaults to holding a pointer to `list`.
list list* list# sys:info
## ### ##
# ## ##
## ## ##
##### ## ##### ## ### ##### ###### ##### # ## ## ## ### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ### ## ### #### ## ##### ### ## ### # ## ## #### ## ## ###
##### ##### ### ### ## #### ##### ## ## ## ### ## #####
## ## ## ## ## ## ## ## # ## ## ## ## ##
## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ##
###### ###### ## #### ## ###### ###### # ## ## ## ## ######
##
n-
Erase line n in the block buffer
(erase_contents_of_line_10) #10 e:erase/line
## #
## ##
## ##
##### ## ## ## ### ###### ##### ## ### ####
## ## ## ## ## ## ## ## ## ## ## ## ## ####
## ### ## #### ## ### ## ### #### ## ##
##### ## ### ## #### ##### ### ##
## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ####
###### ## ## ## ###### ###### ## ##
n'-
Erase line n, parse to end of line, insert into line n
(replace_line_10_with_text_following_`e:insert`) #10 e:insert hello, world!
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 e:insert-at
## # #
## ## ##
## ## ##
##### ## ## ## ### ###### ##### ## ### #### ##### ####
## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ####
## ### ## #### ## ### ## ### #### ## ## ###### ##### ##
##### ## ### ## #### ##### ### ## ### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### ## #### ####
###### ## ## ## ###### ###### ## ## #### ## ##
lc'-
Parse to end of line. Insert text into line l at column c
(replace_line_10,_starting_at_column_5,_with_text_following_`e:insert`) #10 #5 e:insert hello, world!
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 e:insert
### ##
## ##
## ##
##### ## ## ## ## ### #####
## ## ## ## ## ## ## ## ##
## ### ## ## #### ## ## ###
##### ## ## ### ## #####
## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ##
###### ## ## ## ## ######
n-
Display a single line from the current block
(display_line_10_of_current_block) #10 e:line
###
##
## ##
##### ## ## ### ##### ## ### ## ##### #### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ### #### ## ## ### #### ## ## ##### ## ## ###
##### ### ##### ### ## ## ### ## ## #####
## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## #### ## ## ## ##
###### ## ###### ###### ## #### ## ###### ######
##
##
##
ls-
Insert text s into line l
(Replace_line_10_with_"Hello_World!") #10 'Hello_World! e:replace list
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 e:insert e:insert-at e:replace-at
### #
## ##
## ## ##
##### ## ## ### ##### ## ### ## ##### #### ##### ##### ####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
## ### #### ## ## ### #### ## ## ##### ## ## ### ###### ##### ##
##### ### ##### ### ## ## ### ## ## ##### ### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## #### ####
###### ## ###### ###### ## #### ## ###### ###### #### ## ##
##
##
##
lcs-
Insert text s into line l at column c
(Replace_text_in_line_10_with_"Hello_World!") (Starts_at_column_5) #10 #5 'Hello_World! e:replace list
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 e:insert e:insert-at e:replace-at
# ### ##
## ## ##
## ## ##
##### ## #### ##### ## ## ## ### #####
## ## #### ## ## ## ## ## ## ## ## ##
## ### ## ## ## ###### ## ## #### ## ## ###
##### ## ## ## ## ## ### ## #####
## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## ## ##
###### ## ##### ## ## ## ## ######
n-p
Return pointer to start of line in the block buffer
#10 e:to-line n:put (address_of_line_10)
## ## #
## ## ##
## ##
##### ##### ## ####
## ## ### ## ## ####
## ### ## ## ## ##
##### ## ### ## ##
## ## #### ## ## ##
## ## ## ## ## ## ####
###### ### ## ## ##
n-
Set Block to n. Load and display block
(begin_editing_block_0) #0 edit
list list* list# e:Display sys:info
#####
## ##
## ##
##### ### ## ##
## ## ## ## ## ##
## ### ## #### ##
##### ## ### ##
## ## ##
## ## ## ## ##
###### ###### ##
##
##
##
nn-f
Compare values for equality
#10 #10 eq? n:put nl #9 #10 eq? n:put nl
-eq? lt? gt? lteq? gteq?
#### # ## ## ## ## ## ## ## ## ## ##### #### #### ## ### #### ## ## #### ## ## ## ## ## #### ## ### ## ## #### ## ## ##### ## ## ### ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ###### ## ###### ## ##
p-n
Fetch a value stored at address
#75 'foo var-n &foo fetch n:put nl
fetch-next
#### # ## # ## ## ## ## ## ## ## ## ## ## ##### #### #### ## ### ## ### ##### ## ## #### #### ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## #### #### ## ### ## ## #### ## ###### #### ## ## ### #### ## ## ##### ## ## ### ## ### ## ##### ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## #### ## ###### ## ###### ## ## ## ## ###### ## ## ##
a-an
Fetch a value stored at address Also returns the next address
#75 'foo var-n #80 comma &foo fetch-next n:put tab fetch n:put nl
fetch
#### ## ### ### ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
vpn-
Fill n cells of memory starting at p with value v
'Test d:create #100 comma #100 allot (populate_string_with_100_"f"_characters) $f &Test n:inc #100 fill (display_100_"f"_characters_in_string) &Test s:put
#### ## ## ## ## ##### ## ### ##### ## ## ##### ## ### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## #### ## ## ### ## ## ## ### #### ## ## ## ## ### ##### ## ## ##### ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## ## ##### ## ###### ## ###### ##
p-
Run p repeatedly, in an unending loop
[ 'hello! s:put nl ] forever
I J K indexed-times times while until
###### ####
## ## ## ##
## ## ##
## ### ##
## #### ##
## ## ## ## ##
### ## ######
##
## ##
######
p-
Run function at pointer p. Saves and restores Free to recover any memory allocated during run
[ here n:put nl #1000 allot here n:put nl ] gc
This is a very simple form of garbage collection. Some words will allocate memory at `here`. By wrapping calls to these in a quote and passing to `gc`, this memory will be reclaimed when the quote returns.
You shouldn't use this with code that's actually allocating things you want to keep around.
Free here allot
# #####
## ## ##
## ## ##
###### #### ##
## ## #### ##
## ## ## ##
## ### ## ##
## #### ## ##
## ## ## #### ##
### ## ## ##
##
## ##
######
nn-f
Compare values for n1 greater than n2
#10 #11 gt? n:put nl #10 #10 gt? n:put nl #9 #10 gt? n:put nl
-eq? eq? lt? lteq? gteq?
# #####
## ## ##
## ## ##
###### #### ##### ### ## ##
## ## #### ## ## ## ## ## ##
## ## ## ## ### ## #### ##
## ### ## ##### ## ### ##
## #### ## ## ## ## ##
## ## ## #### ## ## ## ## ##
### ## ## ###### ###### ##
## ##
## ## ##
###### ##
nn-f
Compare two values for greater than or equality
#10 #11 gteq? n:put nl #10 #10 gteq? n:put nl #9 #10 gteq? n:put nl
-eq? eq? lt? gt? lteq?
## ## ## ## ### ##### ## ### ##### ## ## ## ## ## ## ## ## ## ## #### ## ## ### #### ## ## ### ### ## ##### ### ##### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ###### ## ######
-a
Return the next free memory address
(print_"here") here n:put nl (determine_length_of_allocated_data) here ( #1 #2 #3 ) #3 a:make drop here swap n:sub n:put nl
Free allot gc
## ####
## ## ##
##
## ##
## ####
## ####
## ##
## ##
## ##
## ##
fp-
Execute p if flag is non-zero
:check [ 'Value_is_valid_for_true_(non-zero) s:put nl ] if ; #100 check #0 check #-100 check
-if choose
## ## ## # ##
## ## ## ## ##
## ## ##
## ## ### ##### ##### ## ## ##### ##### #### ## ### ## ##### ######
## ## ## ## ### ## ## ## ## ## ## ## ### ## #### ## ## ## ## ## ## ## ##
## #### ## ## ## ## ### #### ## ### ## ## ###### ## ## ## ## ## ## ### ###
## ### ## ## ### ##### ## ##### ## ### ## ## ## ## ## ##### ####
## ## ## ## #### ## #### ## ## #### ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ##
## ## ## ### ## ###### ## ## ###### ### ## ## ## ## ## ###### ######
np-
Run a quote the specified number of times, tracking the loop index in I
#10 [ I n:put sp ] indexed-times nl
With `indexed-times` you can obtain the loop index with `I`. This will always count down towards zero. If you don't need the loop index, use `times` instead as it's more efficient.
I J K forever times until while
## # ### ### ## #
## ## ## ## ## ##
## ## ## ## ##
## ## ### #### ##### ## ### ## ### ##### ## ## ## ## ####
## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ####
## #### ## ## ## ### #### ## #### ## ##### ## ## ## ##
## ### ## ## ##### ### ### ## ### ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## #### ## ## ## ## ####
## ## ## ## ###### ## ## ## #### ## ## ## ## ##
-n
Internal. Push next value in memory to the stack
(used_internally)
## # ### #
## ## ## ##
## ## ## ##
## ## ### #### ##### ## ### ## ### ##### ## ## ### ## ## ## ##### #### #####
## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ##
## #### ## ## ## ### #### ## #### ## ##### ## ## #### ## ## ## ## ## ## ###
## ### ## ## ##### ### ### ## ### ## ## ## ### ## ### ## ## ## #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## #### ## ##
## ## ## ## ###### ## ## ## #### ## ## ###### ### ## ##### ## ######
##
##
##
-p
Internal. Skip over quote. Push address of quote to stack.
(used_internally)
## # #
## ## ##
## ##
## ## ### #### ##### ## ### ## ### ## ### ##### ####
## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ####
## #### ## ## ## ### #### ## #### ## #### ## ## ### ##
## ### ## ## ##### ### ### ## ### ##### ##
## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## ## ## ####
## ## ## ## ###### ## ###### ## ###### ##
##
##
##
s-
Interpret token
'#124 interpret 'n:put interpret
s:evaluate
## ## ## ##### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #####
...n-
Trigger an I/O operation
(used_internally)
##
##
## ## ## ### ## ## ###
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ##
## ## ### ## ## ## ### ##
## ## #### ## ## ## ##
## ## ## ## ## ## ## ##
## ### ## ## ## ######
## ## ##
## ## ##
#### ##
p-
Internal. Jump to an address
&bye jump
call
### ## # ## ## ## ## ## #### ## ## ######## ## ## ###### #### #### ## ## ## ## #### ## ## ## ## ### ## ## ## #### ## ## ## ## ## ## ## ## ## ## #### ## ## ###### ##
-
Display the text in the block
list*
list# list e:Display sys:info
### ## # ## ## ## ## ## ## ## ## ## ######## ## ## ###### #### ## ## ## ## ## ## #### ## ## ## ## ### ## ## ## ## ## #### ## ## ## ## ## ## ## ## ######## ## ## ## ## #### ## ## ## ## ###### ## ## ##
-
Display the block with line numbers
list#
list* list e:Display sys:info
### ## # ## ## ## ## ## ## ## ###### #### ## ## ## ## #### ## ## ### ## ## ## #### ## ## ## ## ## ## ## ## ## ## #### ## ## ###### ##
-
Display the block with line numbers and rules
list
list* list# e:Display sys:info
### ## ## ## ## ## ## ##### ##### ##### ## ## ## ## ## ### ## ## ## ## ##### ## ## ## ## ## ### ## ## ### ## ## ## ## ## ## #### ## ## ## ## #### ## ## ## ## ##### #### ## ### ##
-
(re)Load the current block
load
Loads block (number taken from `Block`) into the `block:buffer`.
set save block:load block:save block:buffer
### # ##### ## ## ## ## ## ## ## ## ## #### ## ## #### ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ##
nn-f
Compare values for n1 less than n2
#10 #11 lt? n:put nl #10 #10 lt? n:put nl #9 #10 lt? n:put nl
-eq? eq? gt? lteq? gteq?
### # #####
## ## ## ##
## ## ## ##
## #### ##### ### ## ##
## #### ## ## ## ## ## ##
## ## ## ### ## #### ##
## ## ##### ## ### ##
## ## ## ## ## ##
## #### ## ## ## ## ##
## ## ###### ###### ##
##
##
##
nn-f
Compare two values for less than or equality
#10 #11 lteq? n:put nl #10 #10 lteq? n:put nl #9 #10 lteq? n:put nl
-eq? eq? lt? gt? gteq?
##
##
## ##
## ### ## ##### ## ### ######
## ## ## ## ## #### ## ## ##
#### ## ##### ## ## ###
### ## ### ## ## ## ####
## ## ## ## ## ## ## ##
## ## ## ## #### ## ### ## ##
## ## #### ## #### ######
n-n
Return the absolute value of n
#-190 n:abs n:put nl #31 n:abs n:put nl
n:negate
## ##
## ##
## ## ##
## ### ## ##### ##### #####
## ## ## ## ## ### ## ### ##
#### ## ##### ## ## ## ##
### ## ### ## ## ### ## ###
## ## ## ## ## ## #### ## ####
## ## ## ## #### ## ## ## ## ## ##
## ## #### ## ### ## ### ##
nn-n
Add n1 to n2, returning n3
(add_5_+_5) #5 #5 n:add
n:sub n:mul n:div n:divmod n:mod
## # #####
## ## ## ##
## ## ## ## ##
## ### ## ## ### ##### #### ## ## ##### ##### ## ### ##
## ## ## #### ## ## ## #### ## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ### ## ## ## ## ### ## ### #### ## ##
### ## ## ## ##### ## ## ## ## ##### ##### ### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ### ## ## #### ######## ## ## ## ## ## ## ##
## ## #### ###### ## ## ## ###### ###### ## ## ##
nlu-f
True if n is between l and u, inclusive
#10 #1 #100 n:between? [ 'yes s:put nl ] if #10 #10 #100 n:between? [ 'yes s:put nl ] if #10 #-1 #10 n:between? [ 'yes s:put nl ] if #10 #50 #93 n:between? [ 'yes s:put nl ] if
##
##
## ##
## ### ## ##### ##### ####
## ## ## ### ## ## ## ## ##
#### ## ## ## ## ### ##
### ## ## ### ##### ##
## ## ## ## #### ## ##
## ## ## ## ## ## ## ## ## ##
## ## ### ## ###### ######
n-n
Decrement n by 1
(decrease_100_by_1) #100 n:dec
n:inc
## ##
## ##
## ##
## ### ## ##### ## ## ##
## ## ## ### ## ## ## ##
#### ## ## ## ## ## ##
### ## ## ### ## ## ##
## ## ## ## #### ## ## ##
## ## ## ## ## ## ## ###
## ## ### ## ## ##
nn-n
Divine n1 by n2; get result
#110 #10 n:div n:put nl (11)
n:add n:sub n:mul n:divmod n:mod
## ## ##
## ## ##
## ## ##
## ### ## ##### ## ## ## ### ## ##### #####
## ## ## ### ## ## ## ## ## ## ## ## ## ### ##
#### ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## ## ## ## ## ## ## ###
## ## ## ## #### ## ## ## ## ## ## ## ## ####
## ## ## ## ## ## ## ### ## ## ## ## ## ## ##
## ## ### ## ## ## ## ## ##### ### ##
nn-nn
Divide n1 by n2 and return the result and remainder
#115 #10 n:divmod n:put sp n:put nl (11,_5)
n:add n:sub n:mul n:div n:mod
##
##
##
## ### ## ## ## ### ####
## ## ## ## ## ## ## ## ##
#### ## ## #### ## ##
### ## ## ### ## ##
## ## ## ## ## ## ##
## ## ## ## ## ## ## ##
## ## ## ## ## ######
n-n
Increment n by 1
(increment_100_by_1) #100 n:inc
n:dec
### ## ## #
## ## ## ##
## ## ##
## ### ## ## ## ### ## ## ####
## ## ## ## ## ## ## ## ## ####
#### ## ## ## ## ## ## ## ##
### ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ####
## ## ## ## ## ## ## ##
nlu-n
Constrain n to between l and u, inclusive
#10 #1 #100 n:limit n:put nl #10 #1 #10 n:limit n:put nl #10 #1 #5 n:limit n:put nl
n:min n:max
##
## ### ## ### ## ##### ## ##
## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ##### ####
### ## ## ## ## ### ## ##
## ## ## ## ## ## ## ####
## ## ## ## ## ## #### ## ##
## ## ## ## #### ## ## ##
nn-n
Return the greater of two values
#33 #45 n:max n:put nl #-1 #21 n:max n:put nl #45 #33 n:max n:put nl
n:limit n:min
##
##
##
## ### ## ### ## ## ## ###
## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ## #### ##
### ## ## ## ## ## ### ##
## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ##
## ## ## ## ## ## ##
nn-n
Return the lower of two values
#33 #45 n:min n:put nl #-1 #21 n:min n:put nl #45 #33 n:min n:put nl
n:limit n:max
##
##
## ##
## ### ## ### ## ##### #####
## ## ## ## ## ## ## ## ### ##
#### ## ## ## ## ## ## ## ##
### ## ## ## ## ## ## ## ###
## ## ## ## ## ## ## ## ####
## ## ## ## ## ## ## ## ## ##
## ## ## ## ##### ### ##
nn-n
Divide n1 by n2; get remainder
#115 #10 n:mod n:put nl (5)
n:add n:sub n:mul n:div n:divmod
###
##
## ##
## ### ## ### ## ## ## ##
## ## ## ## ## ## ## ## ##
#### ## ## ## ## ## ## ##
### ## ## ## ## ## ### ##
## ## ## ## ## ## #### ##
## ## ## ## ## ## ## ## ##
## ## ## ## ### ## ##
nn-n
Multiply n1 by n2, returning n3
#33 #10 n:mul n:put nl
n:add n:sub n:div n:divmod n:mod
#
##
## ##
## ### ## ## ### ##### ###### ##### #### #####
## ## ## ## ## ## ## ## ## ## ## ## #### ## ##
#### ## #### ## ## ### ## ## ##### ## ## ###
### ## ### ## ##### ## ### ### ## ## #####
## ## ## ## ## ## ## #### ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### #### ## ##
## ## ## ## ###### ### ## #### ## ## ######
##
## ##
######
n-n
Invert the sign of n
#21 n:negate n:put nl #-21 n:negate n:put nl
n:abs
#
##
## ##
## ### ## ## ### ## ## ####
## ## ## ## ## ## ## ## ####
#### ## #### ## ## ## ##
### ## ### ## ## ### ##
## ## ## ## ## ## #### ## ##
## ## ## ## ## ## ## ## ####
## ## ###### ### ## ##
##
##
##
n-
Display a number
#12 n:put nl #-312 n:put nl
c:put s:put
##
##
## ##
## ### ## ###### ## ## ## ###
## ## ## ## ## ## ## #### ##
#### ## ### ## ## ## ##
### ## #### ## ### ## ##
## ## ## ## ## #### ## ##
## ## ## ## ## ## ## ## ## ###
## ## ###### ### ## ####
nn-n
Subtract n2 from n1
(subtract_33_from_45) #45 #33 n:sub n:put nl
n:add n:mul n:div n:divmod n:mod
#
##
## ##
## ### ## #### ##### ######
## ## ## #### ## ## ## ##
#### ## ## ## ## ###### ###
### ## ## ## ## ####
## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ##
## ## ## ##### ######
n-s
Convert number to a temp string
(convert_numbers_to_temporary_strings) #124 n:to-s #-13 n:to-s
c:to-s s:to-n
#####
## ##
## ## ##
## ### ## ######## ##### ## ### ##### ##
## ## ## ## ## ## ## ## ## ## ## ##
#### ## ## ## ### #### ## ## ## ##
### ## ## ##### ### ## ## ##
## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ##
## ## ######## ###### ## ##### ##
n-f
Compare n to zero. True if zero, false otherwise
:zero? n:zero? [ 'yes! s:put nl ] if ; #10 zero? #0 zero?
n:-zero?
#####
## ##
## ## ##
## ### ## ######## ##### ## ### ##### ##
## ## ## ## ## ## ## ## ## ## ## ##
#### ## ###### ## ## ### #### ## ## ## ##
### ## ## ##### ### ## ## ##
## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ##
## ## ######## ###### ## ##### ##
n-f
Compare n to zero. True if not zero, false otherwise
:zero? n:-zero? [ 'no! s:put nl ] if ; #10 zero? #0 zero?
n:zero?
##
##
##
## ### ##### ##### ##### ######
## ## ## ## ## ## ## ### ## ## ##
#### ## ## ### ## ### ## ## ###
### ## ##### ##### ## ### ####
## ## ## ## ## #### ##
## ## ## ## ## ## ## ## ## ## ##
## ## ###### ###### ### ## ######
s-
Run any blocks (in order found) with a title starting with s
'(std-library) needs
This is the most common way to load a set of blocks. You pass in an identifier (the first word, separated by whitespace, in the title line). Any matching blocks are then located and loaded.
If you are editing a block, `save` it first. The block buffer (`block:buffer`) is reused when loading blocks, so any changes you have made to your current one will be lost if not first saved.
Blocks can not use this to load other blocks.
use using
## ### ##### ## ## ## ## ## ## ## ## ## #### ## ## ### ## ## ### ## ##### ## ## ## ## ## ## ## ## ## ## ## ## ## ######## ## ## ###### ## ##
-
Erase the contents of the current block
new
#
##
##
## ### ##### ## ## ####
## ## ## ## ## ## ## ####
#### ## ## ### #### ##
### ## ##### ## ##
## ## ## #### ## ##
## ## ## ## ## ## ####
## ## ###### ## ## ##
-
Switch to and load next block
next
prev set load
##
##
## ### ## ## ###
## ## ## ## ## ## ##
#### ## ## #### ##
### ## ## ### ##
## ## ## ## ##
## ## ## ## ##
## ## ## ######
##
##
##
xy-y
Discard second item on stack
(will_display_3_then_1) #1 #2 #3 nip n:put sp n:put
drop drop-pair
###
##
##
## ### ##
## ## ## ##
#### ## ##
### ## ##
## ## ##
## ## ##
## ## ##
-
Display a newline
'hello s:put tab 'world s:put nl
sp tab
#
##
##
## ### ##### ####
## ## ## ## ## ####
#### ## ## ## ##
### ## ## ## ##
## ## ## ## ## ##
## ## ## ## ####
## ## ##### ##
n-n
Perform a logical NOT operation
#1 #2 eq? not [ 'no_match s:put nl ] if
and or xor
##### ## ### ## ## ## ## ## ## ## #### ## ## ## ### ## ## ## ## ## ## ##### ##
nn-n
Perform a bitwise OR
#1 #2 eq? #1 #2 lt? or [ 'a_condition_met s:put nl ] if
and xor not
##### ## ## ##### ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### #### ## ## ## ## ## ##### ### ## ## ## ## ## ## ## ## ### ## ## ## ##### ## ###### ##
nm-nmn
Put a copy of NOS on top of stack
#2 #3 [ over n:put nl ] times nl
This is the same as `&dup dip swap` or `push dup pop swap`.
tuck swap
## ### ##### ## ### ## ## ## ## ## ## ## ## #### ## ## ## #### ## ### ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ###### ##### ###### ## ## ## ## ## ##
-n
Move top value on address stack to data stack
#33 [ push #3 #4 pop ] call #3 [ n:put tab ] times nl
dip sip push
### ##
## ##
## ##
## ### ## ### ##### ## ## ## ##### #####
## ## ## ## ## ## ## ## ## ## ## ### ## ## ##
#### ## #### ## ## ### ## ## ## ## ## ## ###
### ## ### ##### ## ## ### ## ### #####
## ## ## ## ## ## #### ## #### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ## ###### ## ### ## ### ## ######
##
##
##
-
Load & run blocks 1 & 2 if they appear to be code. Called by default `startup`.
prelude
`prelude` checks blocks 1 & 2 to see if they start with a `(` character. If so, it runs the contents of the blocks as code. This is called by the default `startup`.
startup
## ### ## ### ##### ## ## ## ## ## ## ## ## ## ## ## ## #### ## #### ## ## ### ## ## ### ## ### ##### ## ## ## ## ## ## ## ## ## ## ## ## ## ### ###### ## ###### ## ## ## ##
-
Switch to and load previous block
prev list
next set load
## #
## ##
## ##
## ### ## ### ##### #### ##### ###### ###### ##### ##### #### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## #### ## ##
#### ## #### ## ## ## ## ## ### ### ### ###### ## ## ##### ## #####
### ## ### ## ## ## ##### #### #### ## ### ### ## ## ### ##
## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## #### #### ## ####
###### ## ##### ###### ###### ###### ###### ### ## #### ## ## #### ##
##
##
##
n-?
Internal. If compiling, compile value as a literal into the word. If interpreting, leave on the stack
(used_internally)
##
##
##
## ### ## ## ###### ## ###
## ## ## ## ## ## ## ## ## ##
#### ## ## ## ### #### ##
### ## ## ### #### ### ##
## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ##
###### ### ## ###### ## ##
##
##
##
n-
Move TOS to the address stack
#33 [ push #3 #4 pop ] call #3 [ n:put tab ] times nl
Use of `push` must be paired with `pop`. You can not reliably use this to obtain return addresses due to the use of direct threaded code sequences and the address interpreter.
dip sip pop
# #
## ##
## ##
## ### ##### ###### #### ##### ## ### ####
## ## ## ## ## ## ## #### ## ## ## ## ## ####
#### ## ## ### ### ## ##### #### ## ##
### ##### #### ## ### ## ### ##
## ## ## ## ## ## ## ## ## ##
## ## ## ## ## #### ## #### ## ####
## ###### ###### ## #### ## ## ##
-
Reload the image and empty stacks
restart
##
## ### ##### ### ## ## ###### ##### ## ## #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
#### ## ## ## ## ## ## ### ##### ## ## ## ###
### ## ## ## ## ## #### ### ## ## ## #####
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## #### ### ## ##
## ##### ## ## ###### #### ## ## ######
-
Save the current memory to disk (ilo.rom)
rom:save
If your ilo system supports it, this will dump the system memory (but not stacks or registers) to a physical medium for later use. This might be an image file ("ilo.rom"), physical flash media, disk, or whatever the underlying hardware best supports.
#
##
##
## ### ##### ####
## ## ## ## ## ####
#### ## ## ## ##
### ## ## ##
## ## ## ## ##
## ## ## ####
## ##### ##
xyz-yzx
Rotate the top three values
#1 #2 #3 rot n:put tab n:put tab n:put nl
over tuck swap push pop dip sip
## ### ## ## ## ### ## ## ## ## ## ## ## ## #### ## ## ## #### ## ### ## ### ### ## ## ## #### ## ## ## ## ## ## ## ## ## ### ## ## ##
-
Run code in the currently loaded block
run
##
##
## ##
###### ## ##### ## ### ## ### ##### ## ### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ##
### ##### #### ## #### ## ## ### #### ## ## ##
#### ### ## ### ## ### ## ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## ####
## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ##
###### #### ## ###### ###### ###### ## ## ### ##
## ##
## ##
## ##
ss-s
Append s2 to s1, returning new temporary string
'hello_ 'world! s:append s:put nl
s:prepend
## ## ##
## ## ##
## ## ## ##
###### ## ## ### ##### ## ### ##### ##### #####
## ## #### ## ## ## ## ## ## ## ## ## ## ### ##
### ## ## ## ### #### ## ## ### ##### ## ##
#### ## ## ##### ### ## ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ####
## ## ## ## ### ## ## ## ## ## ## ## #### ## ## ##
###### #### ###### ## ## ###### #### ## ### ##
s-s
Remove first item from a string
'hello_world s:behead s:put nl
New string is allocated in the temporary pool.
s:chop
##
##
## ##
###### ## #### ## ### ##### ## ###
## ## ## ## ## ## ## ## ## ## ## ##
### ## #### ## ## ## #### ##
#### ## ### ## ## ## ### ##
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
###### ###### ## ## ##### ######
##
##
##
s-s
Remove last item from a string
'hello_world s:chop s:put nl
New string is allocated in the temporary pool.
s:behead
# ## #####
## ## ## ##
## ## ## ##
###### ## #### ##### ## ### #### ##### ## ## ### ###### ##
## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ##
### ## ## ## #### ## ## ##### ## #### ## ### ##
#### ## ## ## ### ## ## ### ## ## ### ## #### ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## #### ## #### ## ## ## ## ## ##
###### ###### ##### ## ## ## #### ## ## ## ## ###### ##
sc-f
True if string contains c. False otherwise
'help!_I_lost_a_character. $z s:contains? n:put nl (0) 'help!_I_lost_a_character. $a s:contains? n:put nl (-1)
##
###### ## #### ##### ## ### ## ##
## ## ## ## ## ## ## ## ## ## ##
### ## ## ## #### ## ## ##
#### ## ## ## ### ## ## ##
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
###### ###### ##### ###### #####
## ##
## ## ##
## ###
sd-
Copy string s to memory at d
'Target d:create #100 allot 'hello &Target s:copy
##
##
## ##
###### ## ##### ## ## ## ###
## ## ### ## ## ## ## ## ##
### ## ## ## ## #### ##
#### ## ### ## ### ### ##
## ## ## #### ## #### ## ##
## ## ## ## ## ## ## ## ## ## ##
###### ### ## ### ## ######
##
##
##
s-s
Make a copy of string
'Test_string s:dup
s:temp s:keep
#####
## ##
## ## ##
###### ## ##### ### ## ##
## ## ## ## ## ## ## ##
### ## ### ## #### ##
#### ##### ## ### ##
## ## ## ## ##
## ## ## ## ## ## ## ##
###### ###### ###### ##
##
##
##
ss-f
Compare two strings for equality
'hello_world! 'different_string s:eq? n:put nl 'hello_world! 'hello_world s:eq? n:put nl
s:-eq?
#####
## ##
## ## ##
###### ## ##### ### ## ##
## ## ## ## ## ## ## ##
### ###### ## ### ## #### ##
#### ##### ## ### ##
## ## ## ## ##
## ## ## ## ## ## ## ##
###### ###### ###### ##
##
##
##
ss-f
Compare two strings for inequality
'hello_world! 'different_string s:-eq? n:put nl 'hello_world! 'hello_world s:-eq? n:put nl
s:eq?
### #
## ##
## ## ##
###### ## ##### ## ## ##### ## ## ## ##### #### #####
## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ##
### ## ### ## ## ##### ## ## ## ##### ## ## ###
#### ##### ## ## ### ## ## ## ### ### ## ## #####
## ## ## ## ## ## ## ## ## #### ## ## ## ## ##
## ## ## ## ## ### ## #### ## ## ## ## ## #### #### ## ##
###### ###### ## #### ## ## ### ## #### ## ## ######
s-?
Interpret each token in a string
'#100_#200_n:add_n:put_nl s:evaluate
interpret
#### # ##
## ## ## ##
## ## ## ##
###### ## ## ##### #### #### ## ###
## ## #### ## ## #### ## ## ## ## ##
### #### ## ### ## ## #### ##
#### ## ##### ## ## ### ##
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ##
###### ## ###### ## ###### ## ##
sn-c
Return character at index n in the string
'hello_world! #4 s:fetch c:put
s:store s:th
#### ## ### #
## ## ## ## ##
## ## ## ##
###### ## ## ## ## #### ##### ## ###
## ## #### ## ## #### ## ## ## ## ##
### #### ## ## ## ## ### #### ##
#### ## ## ## ## ##### ###
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ##
###### ## ## ## ## ###### ##
sp-s
Run p once for each value in s If it returns true, copy value new string
'HeLlO_WoRlD! [ c:upper? ] s:filter s:put nl
#### ## #
## ## ## ##
## ## ##
###### ## ## ## ## ### ###### ####
## ## #### ## ## ## ## ## ## ####
### #### ## #### ## ### ##
#### ## ## ### #### ##
## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ####
###### ## ## ## ###### ##
s-c
Return the first character in a string
'hello_world! s:first c:put nl
s:last
#### ##
## ## ##
## ## ##
###### ## ## ##### ## ### ##### ##### #### ## ###
## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### #### ## ## #### ## ###### ## ### ##### ## #### ##
#### ## ## ## ### ##### ### ## ## ### ##
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## #### ## ## ## ##
###### ## ##### ## ###### #### ## ###### ## ##
sp-
Run p once for each character in s. Pushes each character to the stack before calling p
:s:put [ c:put ] s:for-each ;
# ## ### ##
## # ## ##
## ## ## ##
###### ## ###### ##### #### # ## ## ## ### #####
## ## ## ## ## ## #### ## ## ## ## ## ## ## ##
### ## ## ## ### ## # ## ## #### ## ## ###
#### ## ### ##### ## ## ## ## ### ## #####
## ## ## #### ## ## ## # ## ## ## ## ##
## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ##
###### ### ## ###### ## # ## ## ## ## ######
## ##
## ##
######
'-s
Read a line of input until enter is encountered. Return input as string
:input (s-s) s:put sp s:get/line s:temp ; 'Enter_your_name: input
s:get/token
# ## # ##
## # ## ##
## ## ## ## ##
###### ## ###### ##### #### # #### ##### ## ## ##### ## ###
## ## ## ## ## ## #### ## #### ## ## ## ## ## ## ## ## ##
### ## ## ## ### ## # ## ## ## ## ## ## ### #### ##
#### ## ### ##### ## ## ## ## ## ##### ##### ### ##
## ## ## #### ## ## ## # ## ## ## ## ### ## ## ## ##
## ## ## ## ## ## ## ## #### ## #### ## ## ## ## ## ## ## ##
###### ### ## ###### ## # ## ##### ## ## ###### ## ##
## ##
## ##
######
-s
Read a string from the keyboard ending when a whitespace is encountered
:input (s-n) s:put sp s:get/token s:to-n ; 'Enter_your_age: input
s:get/line
## ##
## ##
## ## ##
###### ## ## ### ##### ###### ## ###
## ## ## ## ## ## ## ## ## ## ## ##
### #### ## ##### ### #### ##
#### ### ## ### ## #### ### ##
## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ##
###### ## ## #### ## ###### ## ##
s-n
Return the hash of the string
'hello_world s:hash
## ## ##
## ## #
## ## ##
###### ## ## ## ### ##### ##### ## ## # ####
## ## ## ## ## ## ### ## ## ## ## ## ## ## ##
### ## #### ## ## ## ## ### #### # ##
#### ## ### ## ## ### ##### ## ## ##
## ## ## ## ## ## #### ## #### # ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ## ## ## ### ## ###### ## ## # ######
##
sc-f
True if string contains c, false otherwise
'hello_world $e s:index/c n:put nl
##
##
## ##
###### ## ## ## ##### ##### ## ###
## ## ## ## ## ## ## ## ## ## ##
### ## ## ## ### ## ### #### ##
#### ##### ##### ##### ### ##
## ## ### ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
###### ## ## ###### ###### ######
##
##
##
s-s
Move string to here, allocating space and returning a pointer
'banana_bread_is_good s:keep
s:temp
### #
## ##
## ## ##
###### ## ## ##### ###### ####
## ## ## ## ## ## ## ####
### ## ##### ### ##
#### ## ### ## #### ##
## ## ## ## ## ## ## ##
## ## ## ## ## #### ## ## ####
###### ## #### ## ###### ##
s-c
Return the last character in a string
'hello a:last c:put
s:last
### #### #
## ## ## ##
## ## ## ##
###### ## ## ##### ## ####
## ## ## ## ## #### ####
### ## ## ### #### ##
#### ## ##### ## ##
## ## ## ## ## ## ##
## ## ## ## ## ## ## ####
###### ## ###### ## ##
sn-s
Return left n characters of string
'banana_bread_is_good #6 s:left
New string is allocated in the temporary pool.
s:right s:middle
### # ##
## ## ##
## ## ## ##
###### ## ## ##### ## ### ###### #### ## ###
## ## ## ## ## ## ## ## ## ## #### ## ## ##
### ## ## ### #### ## ## ## ## #### ##
#### ## ##### ### ## ## ### ## ### ##
## ## ## ## ## ## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## #### ## ##
###### ## ###### ## ## ### ## ## ## ##
##
## ##
######
s-n
Return the length of a string
'banana_bread_is_good s:length
##
###### ## ### ## ##### ## ###
## ## ## ## ## ## ## ## ## ##
### ## ## ## ##### #### ##
#### ## ## ## ### ## ### ##
## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ##
###### ## ## #### ## ######
##
##
##
sp-s
Run p once for each value in the string. Takes the returned value and creates a new string
:make-uppercase [ c:to-upper ] s:map ; 'banana_bread_is_good make-uppercase s:put nl
## ## ## ###
## ## ## ##
## ## ## ##
###### ## ### ## ## ##### ##### ## #####
## ## ## ## ## ## ### ## ### ## ## ## ##
### ## ## ## ## ## ## ## ## ## ## ###
#### ## ## ## ## ## ### ## ### ## #####
## ## ## ## ## ## #### ## #### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ## ## ## ### ## ### ## ## ######
sfl-s
Return substring from f to l, inclusive
(01234567890123456789)
'banana_bread_is_good
(_______^____________) #7 (starting_point)
(___________^________) #5 (length)
s:middle s:put ("bread")
s:left s:right
##
##
## ##
###### ## ## ### ## ### ##### ## ### ##### ## ### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ##
### #### ## #### ## ## ### #### ## ## ### #### ## ## ##
#### ### ## ### ##### ### ## ##### ### ## ## ###
## ## ## ## ## ## ## ## ## ## ## ## ####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ###### ## ###### ###### ###### ## ## ### ##
## ##
## ##
## ##
ss-s
Create a new string with the contents of s2 followed by s1
'world! 'hello_ s:prepend s:put nl
s:append
#
##
## ##
###### ## ## ### ## ## ####
## ## ## ## ## ## ## ####
### #### ## ## ## ##
#### ### ## ## ### ##
## ## ## ## ## #### ## ##
## ## ## ## ## ## ## ## ####
###### ###### ### ## ##
##
##
##
s-
Display a string
'banana_bread_is_good s:put nl
##
###### ## ## ### ##### ## ## ##### ## ### ###### #####
## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### #### ## ## ### ## ## ## ### #### ## ### ## ###
#### ### ##### ## ## ##### ### #### #####
## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ### ## ## ## ## ## ## ##
###### ## ###### ## ###### ## ###### ######
s-s
Reverse the order of values in the string. Returns a pointer to the new string
'banana_bread_is_good s:reverse
## #
## ##
## ##
###### ## ## ### ##### ## ## ## ### ## #### #####
## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ##
### #### ## ## ### ## ## #### ## ## ## ## ###
#### ### ##### ## ## ## ### ## ## #####
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ######## ## ## #### ## ##
###### ## ###### ## ## ## ## ## ######
s-s
Replace underscores in string with spaces
'abcdef s:rewrite
## ## #
## ## ##
## ## ##
###### ## ## ### ## ###### ## ### ####
## ## ## ## ## ## ## ## ## ## ## ####
### #### ## ## ## ## #### ## ##
#### ### ## ## ### ### ## ##
## ## ## ## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ## ## ####
###### ## ## ### ## ## ## ##
##
## ##
######
sn-s
Return right n characters of string
'banana_bread_is_good #4 s:right
New string is allocated in the temporary pool.
s:left s:middle
#
##
## ##
###### ## ###### #### ##### ## ### #####
## ## ## ## #### ## ## ## ## ## ## ##
### ### ## ## ## #### ## ## ###
#### #### ## ## ## ### #####
## ## ## ## ## ## ## ## ##
## ## ## ## ## #### ## ## ## ## ##
###### ###### ## ##### ## ######
csn-
Store character into string at index n
$H 'hello_world [ #0 s:store ] sip s:put nl
s:fetch s:th
#
##
## ##
###### ## #### ##### ### ## ## ###
## ## #### ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## #### ##
#### ## ##### ## ## ## ### ##
## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ##
###### ## ###### ## ## ######
##
##
##
s-s
Put a copy of a string in the temporary buffers. Return a pointer to it
'hello_world s:temp
s:keep
# ##
## ##
## ## ##
###### ## #### ## ###
## ## #### ## ## ##
### ## #### ##
#### ## ### ##
## ## ## ## ## ##
## ## ## #### ## ##
###### ## ## ##
sn-a
Given a string and index, return the address
'hello_reader! #6 s:th (______^________return_address_of_character_at_offset_6) (0123456789...) (and_display_it: fetch c:put
s:fetch s:store
# ###
## ##
## ## ##
###### ## #### ##### ## ##### ## ## ##### ## ###
## ## #### ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ## ###### ## ## ## ## ## ## ### #### ##
#### ## ## ## ## ## ## ## ## ## ##### ###
## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ######## ## ## ##
###### ## ##### ## ##### ## ## ###### ##
s-s
Make all characters in string lowercase
'Mixed_CASE_To_LowerCase s:to-lower
s:to-upper
#
##
## ##
###### ## #### ##### ## ###
## ## #### ## ## ## ## ##
### ## ## ## ###### #### ##
#### ## ## ## ### ##
## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ##
###### ## ##### ## ##
s-n
Convert a string to a number
'341 s:to-n n:inc n:put nl '-33 s:to-n n:put nl
Conversion to numbers only supports decimal (base 10) numbers. If negative, the negative sign (-) should be the first character in the string.
n:to-s
#
##
## ##
###### ## #### ##### ## ## ## ### ## ### ##### ## ###
## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ## ###### ## ## #### ## #### ## ## ### #### ##
#### ## ## ## ## ### ### ## ### ## ##### ###
## ## ## ## ## ## ## #### ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ##
###### ## ##### ### ## ###### ###### ###### ##
## ##
## ##
## ##
s-s
Make all characters in a string uppercase
'Mixed_CASE_To_uPPerCase s:to-upper
s:to-lower
# ##
## ##
## ##
###### ## #### ## ### ## ### ##
## ## #### ## ## ## ## ## ## ##
### ## #### ## ## ## ## ##
#### ## ### ## ## ## ##
## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ##
###### ## ## ## ## ##
s-s
Trim both leading and trailing whitespace from a string
'___hello_world_!___ s:trim s:put '| s:put nl
s:trim-right s:trim-left
# ## ## ## #
## ## ## ## ##
## ## ## ##
###### ## #### ## ### ## ### ## ## ### ## ###### ## ### ####
## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
### ## #### ## ## ## ## ## ###### #### ## ## ## ## #### ## ##
#### ## ### ## ## ## ## ### ## ## ### ### ## ##
## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ##
## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ####
###### ## ## ## ## ## ## ## ### ## ## ## ##
##
## ##
######
s-s
Trim trailing whitespace from a string
'___hello_world_!___ s:trim-right s:put '| s:put nl
s:trim s:trim-left
# ## ### #### #
## ## ## ## ## ##
## ## ## ## ##
###### ## #### ## ### ## ### ## ## ##### ## ####
## ## #### ## ## ## ## ## ## ## ## ## ## #### ####
### ## #### ## ## ## ## ## ###### ## ## ### #### ##
#### ## ### ## ## ## ## ## ##### ## ##
## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## #### ## ## ## ## ## ## ## ## ####
###### ## ## ## ## ## ## ###### ## ##
s-s
Trim leading whitespace from a string
'___hello_world_!___ s:trim-left s:put '| s:put nl
s:trim s:trim-right
## ## #### # ### #### #
## ## ## ## ## ## ## ## ##
## ## ## ## ## ##
###### ## ### ## ## #### ## ##### ## ####
## ## ## ## ## ## #### #### ## ## ## #### ####
### #### ## ## #### ## ###### ## ## ### #### ##
#### ### ## ## ## ## ## ##### ## ##
## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## #### ## ## ## ## ####
###### ## ## ## ## ## ## ###### ## ##
nn-n
Shift n1 left by n2 bits
#1793 #8 shift-left n:put
## ## #### # ## ## #
## ## ## ## ## ## ## ##
## ## ## ## ##
###### ## ### ## ## #### ## ### ## ###### ## ### ####
## ## ## ## ## ## #### #### ## ## ## ## ## ## ## ## ## ####
### #### ## ## #### ## ###### #### ## ## ## ## #### ## ##
#### ### ## ## ## ## ### ## ## ### ### ## ##
## ## ## ## ## ## ## ## ## ## #### ## ## ## ##
## ## ## ## ## ## #### ## ## ## ## ## ## ## ####
###### ## ## ## ## ## ## ## ### ## ## ## ##
##
## ##
######
nn-n
Shift n1 right by n2 bits
#1793 #8 shift-right n:put
##
## ## ### ##
## ## ## ##
## ## ##
###### ## ###### ## ## ## ##
## ## ## ## ## ## ## ##
### ## ## ## ## ## ##
#### ## ## ### ## ## ##
## ## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## ##
## ##
## ##
######
-
Sigil. Token is a comment
(comments_are_ignored)
## ## ### ## ##
## ## ## ## ##
## ## ########
###### ## ###### ## ## ## ## ##
## ## ## ## ## ## ## ## ##
### ## ## ## ## ## ## ##
#### ## ## ### ## ## ## ##
## ## ## #### ## ## ## ########
## ## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## ## ##
##
## ##
######
s-n
Sigil. Token is a number
#-190 n:put #100 #200 n:add n:put
## ## ### ###
## ## ## ## ##
## ## ## ##
###### ## ###### ## ## ## ####
## ## ## ## ## ## ## ###
### ## ## ## ## ## ## ##
#### ## ## ### ## ## ## ###
## ## ## #### ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ###
###### ## ### ## ## ## ### ##
##
## ##
######
s-a
Sigil. Token is a named pointer
&bye call
## ## ### ##
## ## ## ##
## ## ##
###### ## ###### ## ## ##
## ## ## ## ## ## ##
### ## ## ## ## ##
#### ## ## ### ## ##
## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ##
###### ## ### ## ## ##
##
## ##
######
s-s
Sigil. Token is a string.
'hello! 'underscores_are_replaced_with_spaces!
## ## ###
## ## ##
## ## ##
###### ## ###### ## ## ## ##
## ## ## ## ## ## ##
### ## ## ## ## ##
#### ## ## ### ## ##
## ## ## #### ## ## ## ##
## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ##
##
## ##
######
s-
Sigil. Token is name of a new word to define
:test (s-) s:put nl ;
Compiler compiling? d:create ;
##
## ## ### ######
## ## ## ## ## ##
## ## ## ##
###### ## ###### ## ## ## ####
## ## ## ## ## ## ## ###
### ## ## ## ## ## ####
#### ## ## ### ## ## ## ##
## ## ## #### ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## ######
## ##
## ##
######
s-c
Sigil. Return first character of token
$9 c:put
## ## ### #
## ## ## ##
## ## ##
###### ## ###### ## ## ## ###### ##### ####
## ## ## ## ## ## ## ## ## ## ## ####
### ## ## ## ## ## ## ## ## ### ##
#### ## ## ### ## ## ## ### ##### ##
## ## ## #### ## ## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
###### ## ### ## ## ## ### ## ###### ##
## ##
## ## ## ##
###### ######
c-p
Return the address of a sigil handler for character c
$@ sigil:get n:put (address_of_sigil:@)
## ## ### #
## ## ## ##
## ## ##
###### ## ###### ## ## ## ###### ##### ####
## ## ## ## ## ## ## ## ## ## ## ####
### ## ## ## ## ## ### ## ### ##
#### ## ## ### ## ## #### ##### ##
## ## ## #### ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ####
###### ## ### ## ## ## ###### ###### ##
##
## ##
######
pc-
Assign word at address to the sigil handler for character c
:sigil:. s:rewrite compiling? [ s:keep &s:put compile:call ] [ s:put ] choose ; &sigil:. $. sigil:set .Hello_World!
## ## ### ####
## ## ## ## ##
## ## ## ####
###### ## ###### ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ##
### ## ## ## ## ## ## ## ##
#### ## ## ### ## ## ## ####
## ## ## #### ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## ## ###
## ###
## ##
######
s-n
Sigil. Use to fetch value from a named variable
@Free n:put
## ## ### ##
## ## ## ##
## ## ##
###### ## ###### ## ## ## ##
## ## ## ## ## ## ## ##
### ## ## ## ## ## ##
#### ## ## ### ## ## ##
## ## ## #### ## ## ##
## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## ##
##
## ##
######
ns-
Sigil. Use to store value into a named variable
'Data var #456 !Data
## ## ### ##
## ## ## #
## ## ##
###### ## ###### ## ## ## #
## ## ## ## ## ## ## ##
### ## ## ## ## ## #
#### ## ## ### ## ## ##
## ## ## #### ## ## ## #
## ## ## ## ## ## ## ## ## ##
###### ## ### ## ## ## #
## ##
## ##
######
as-
Sigil. Bind name s to function a
[ 'hello! s:put nl ] \hello
If making an alias to another word this is preferable to wrapping the word in a colon definition. Use of the `\` sigil will result in only a header being created, with no additional wrapper code.
##
##
###### ## ## ###
## ## ## ## ## ##
### ## #### ##
#### ## ### ##
## ## ## ##
## ## ## ## ##
###### ## ######
##
##
##
np-n
Push a copy of n to address then call p. Afterwards, restore to the data stack
#100 [ n:put nl ] sip n:put nl
This is the same as doing:
dup push ... pop
In general use of `sip` is preferable as it ensures the stack stays balanced. You may wish to use the above form if the logic leading up to the duplicated value would be clearer, or if you need to save some space (the dup/push/pop form saves three cells over using a quotation and sip).
dip dup push pop
###### ##### ## ## #####
## ## ## ## ## ## ## ##
### ##### ## ## ## ###
#### ### ## ## ## #####
## ## ## ## ## ##
## ## ## #### ### ## ##
###### #### ## ## ######
-
Save the current block
save
Writes `block:buffer` to block (number taken from `Block`)
set load block:load block:save block:buffer
#
##
##
###### ##### ####
## ## ## ## ####
### ## ### ##
#### ##### ##
## ## ## ##
## ## ## ## ####
###### ###### ##
n-
Set Block to n. Does not load or save the block
#45 set load list
Assigns `Block` to the provided number.
###### ## ###
## ## ## ## ##
### #### ##
#### ### ##
## ## ##
## ## ## ##
###### ######
##
##
##
-
Display a space
'hello s:put sp 'world s:put nl :spaces (n-) &sp times ;
nl tab
# #
## ##
## ##
###### #### ##### ## ### #### ## ## ## ###
## ## #### ## ## ## ## ## #### ## ## ## ## ##
### ## ##### #### ## ## ## ## #### ##
#### ## ### ## ### ## ## ### ### ##
## ## ## ## ## ## ## ## ## #### ## ##
## ## #### ## #### ## #### ## ## ## ## ##
###### ## #### ## ## ## ### ## ######
##
##
##
-
Called on startup to prepare the system. You can replace this to have ilo start your application
startup
RetroForth/ilo searches for this word when starting. If found, it is then run. If redefined, only the most recently created `startup` word will be run.
prelude
#
##
##
###### #### ##### ## ### #####
## ## #### ## ## ## ## ## ## ##
### ## ## ## #### ## ## ###
#### ## ## ## ### #####
## ## ## ## ## ## ##
## ## #### ## ## ## ## ##
###### ## ##### ## ######
na-
Store n into address a
'data var #102 &data store
store-next
# #
## ##
## ##
###### #### ##### ## ### ##### ## ### ##### ## ## ####
## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
### ## ## ## #### ## ## ### ###### #### ## ## ### #### ##
#### ## ## ## ### ##### ### ## ##### ## ##
## ## ## ## ## ## ## ## ## ## #### ## ##
## ## #### ## ## ## ## ## ## ## ## ## ## ## ####
###### ## ##### ## ###### ## ## ###### ## ## ##
na-a
Store n int address a, return address a + 1
'data d:create #4 allot #102 #103 #104 #3 &data n:inc store-next store-next store &data [ n:put sp ] a:for-each nl
store
###### ## ## ##### ## ###
## ## ## ## ## ## ## ## ##
### ## ## ##### #### ##
#### ## ## ## ### ## ### ##
## ## ## ## ## ## ## ##
## ## ######## ## #### ## ##
###### ## ## #### ## ######
##
##
##
xy-yx
Exchange the top two stack items
#1 #2 n:put tab n:put nl #1 #2 swap n:put tab n:put nl
over tuck rot push pop dip sip
## #### #### ## ## ### ##
## ## ## ## ## # ## ## ##
## ## ## ## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ## ### ## ##### #### ## ##
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # ## ## ## ## ## ## ## ##
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## ## ## ## ## ## ## #####
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## ## ### ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # #### ## ##### ###### ## ##
## ##
## ##
###
-
Data. Points to the start of the block buffer.
## #### #### ## ###
## ## ## ## ## # ##
## ## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ## ##### ##### ## ### ######
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # ## ## ## ## ## #### ## ###
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## ## ## ## ## ## ### ## ####
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # ## ##### ##### ###### ######
## ## ##
## ## ##
### ##
-
Data. Holds loop indices.
## #### #### ## ## ##
## ## ## ## ## # ## ##
## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ## ### ## ## ### ## ##### ## ### ## #### #### ##### ## ### ## ## ##### ## ### ###### ## ##### ## ###
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # #### ## ## ## ## ## ## ## ### #### ## ## ## ###### ## ## ## #### ## ## ## ## ### #### ## ### ## ## ## #### ##
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## ### ## ## ### ## ## ## ##### ### ## ## ## ## ## ### ## ## ## ##### ### #### ## ## ## ### ##
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # ## ## ### ## ## ## ###### ## ## ###### ###### ##### ## ## ## ###### ## ###### ## ##### ## ##
## ##
## ##
###
-
Data. Used by s:to-n.
## #### #### ##
## ## ## ## ## #
## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ###### #### ##### ## ### #####
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # ### ## ## ## #### ## ## ###
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## #### ## ## ## ### ## #####
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # ###### ###### ##### ###### ######
## ## ##
## ## ##
### ##
-
Data. Holds dictionary pointers for {{ ---reveal--- }}
## #### #### ## ##
## ## ## ## ## # ##
## ## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ## ### ##### ##### ##### ######
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # #### ## ## ### ## ### ## ## ###
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## ### ## ##### ##### ## ### ####
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## #### ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # ## ## ###### ###### ### ## ######
## ##
## ##
###
-
Data. Used by needs
## #### #### ## ##
## ## ## ## ## # ##
## ## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ## ### ##### ###### ##### ## ### ## ## ##### #####
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # #### ## ## ### ### ## ### #### ## ## ## ## ### ## ##
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## ### ##### #### ##### ### ## ## ##### ## ###
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## ## ## ## ## ####
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # ## ###### ###### ###### ## ## ###### ### ##
## ##
## ##
###
-
Data. Reserved for future use.
## #### #### ## # ##
## ## ## ## ## # ## ##
## ## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ###### #### ## ### ## ## ### ###### ###### ## ##### ## ### ## ### ##### ## ## ######
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ##
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # ### ## #### ## ## #### ## ## ## ### ###### ##### #### ## #### ## ##### ## ## ###
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## #### ## ### ## ### ## ## ### #### ## ### ## ### ### ### ## ## ## ####
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## #### ## ## ## #### ## ## ## ##
###### ##### ###### #### ### ## ## ## ###### ## ###### # ###### ## ## ## ## ## ### ## ###### #### ## ## ## #### ## ##### ######
## ## ## ##
## ## ## ## ## ##
### ###### ###
-
Data. Start of the temporary string & array pool.
## #### #### ## ## #
## ## ## ## ## # ## ##
## ## ## ## ## ##
###### ## ## ###### ## ## ### ## ## ## ## ##### ## ### ###### # ## ## ### ## ### ## ## ####
## ## ## ## ## ## #### ## ## ## #### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
### ## ## ### ## ## ## ## #### #### ## ### #### ## ### # ## #### ## #### ## ## ## ##
#### ## ## #### ## ## ## ### ## ## ##### ### #### ## ## ### ## ### ## ## ### ##
## ## ## ## ## ## ## ## #### ## ## ## ## ## # ## ## ## ## ## ## #### ## ##
## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ####
###### ##### ###### #### ### ## ## ## ###### ## ###### # ## ## ## ###### ### ## ##
## ## ##
## ## ##
### ##
-
Data. Holds the current input token.
## ####
## ## ##
## ##
###### ## ## ###### ## ## ## ### ## #####
## ## ## ## ## ## ## ## ## ## #### ## ##
### ## ## ### ## #### ## #### ## ##
#### ## ## #### ## ### ## ## ## ##
## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ##
###### ##### ###### ## ## ## ## #####
##
## ##
###
-
Display system information
sys:info
The default `list` word for displaying the blocks looks up and runs this word to display the status line below the block. You can define a new status display word with the same name to override the default.
list list* list# e:Display
# ## ## ## ## ## #### ##### ## ### #### ## ## #### ## ## ##### ## ## ## ### ## ## ## ## ## ## ## ## ## #### ## #### ## ### ## #### ## ####
-
Display a tab
'hello s:put tab 'world s:put nl
sp nl
# ## ## ## ## #### ## ### ## ##### ###### #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ### ## ## ## ## ## ##### #### ## ## ## ## ## ## ## #### ## ## ## ## ## ## ## ## ## ## ## ###### ######
np-
For n iterations, execute p
#10 [ $. c:put ] times nl
I J K forever indexed-times while until
# ## # ### ## ## ## ## ## ## ## #### ## #### ## ##### ###### #### ## #### ## ## ## ## ## ## ## ## ## ## ### ### ## ## ## ## ##### #### ## ## ## ## ## ## ## ## #### ## #### ## ## ## ## ## ## ## ## ## ###### ######
-
Display the block title lines. The output is paginated every 16 lines
titles
The titles listing adds a break after each 16 titles. Blocks must have a non-space character as the first character in the title line (the first line) to be included in the listing.
# ## ## ## ## #### ## ### ## #### ## ## ## ## ## #### ## ## ## ### ## ## ## ## ## #### ## ## ## ## ##
xppp-?
Apply p1 against x, then p2 against a copy of x, and finally p3 against another copy of x
#1 [ #10 n:mul ] [ #20 n:mul ] [ #30 n:mul ] tri
The naming of this originally derives from the Factor programming language.
bi bi* bi@ tri* tri@
# ## ## ## ## ## #### ## ######## #### ## ### ## #### #### ## ## ## ## ## ## ## #### ## ## ## ### ## ## ## ## ## #### ## ## ## ## ##
xyzppp-?
Apply p1 against x, p2 against y, and p3 against z
#1 #2 #3 [ #10 n:mul ] [ #20 n:mul ] [ #30 n:mul ] tri*
The naming of this originally derives from the Factor programming language.
bi bi* bi@ tri tri@
# ## ####
## ## ## ##
## ## ####
#### ## ### ## ## ## ##
#### ## ## ## ## ## ## ##
## #### ## ## ## ## ##
## ### ## ## ####
## ## ## ## ## ##
#### ## ## ## ##
## ## ## ## ###
###
xyzp-?
Apply p against x, then against y, and finally against z
#1 #2 #3 [ #10 n:mul ] tri@
The naming of this originally derives from the Factor programming language.
bi bi* bi@ tri tri*
# ## ## ## ## ## #### ## ## #### ## ## #### ## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ##### ## ## ## #### ## ### ## #### ## ## ## ## ## ## ## ## ### ## ###### ## ##
xy-yxy
Put a copy of TOS under NOS
#10 #20 tuck #3 [ n:put sp ] times
`tuck` is the same as `swap over`
over swap rot push pop dip sip
# ## ###
## ## ##
## ##
## ## ## ### #### ## ##
## ## ## ## ## #### ## ##
## ## #### ## ## ## ##
## ### ### ## ## ## ##
## #### ## ## ## ## ## ##
## ## ## ## ## #### ## ##
### ## ## ## ## ## ##
p-
Run a quote in a loop repeatedly The loop must return a flag. End loop when flag is not zero
#100 [ dup n:put sp n:dec dup n:zero? ] until
I J K forever indexed-times times while
## ## ###### ##### ## ## ## ## ## ## ## ## ### ## ### ## ### #### ##### ## #### ## ## ## ## ## ## ## ## ## ### ## ###### ######
n-
Load and run a specific block numbered n
#33 use
If you are editing a block, `save` it first. The block buffer (`block:buffer`) is reused when loading blocks, so any changes you have made to your current one will be lost if not first saved.
Blocks can not use this to load other blocks.
needs using
##
##
## ## ###### ## ## ### ######
## ## ## ## ## ## ## ## ## ##
## ## ### ## #### ## ## ##
## ### #### ## ### ## ## ###
## #### ## ## ## ## ## ####
## ## ## ## ## ## ## ## ## ## ##
### ## ###### ## ## ## ### ##
##
## ##
######
nn-
Load and run blocks n1 thru n2
#33 #45 using
If you are editing a block, `save` it first. The block buffer (`block:buffer`) is reused when loading blocks, so any changes you have made to your current one will be lost if not first saved.
Blocks can not use this to load other blocks.
needs use
##
##
## ##
## ## ## ##### ##### ####
## ## ### ## ## ## ## ##
## ## ## ## ## ### ##
## ## ## ### ##### ##
## ## ## ## #### ## ##
### ## ## ## ## ## ## ## ##
## ### ## ###### ######
a-
Decrement the value stored at address
'Count var &Count v:inc
v:inc
##
##
##
## ## ## ## ## ### ####
## ## ## ## ## ## ## ##
## ## ## #### ## ##
## ## ## ### ## ##
## ## ## ## ## ## ##
### ## ## ## ## ## ##
## ## ## ## ######
a-
Increment the value stored at address
'Count var &Count v:dec
v:dec
## ## ##### ## ### ## ## ## ## ## ## ## ## ## ##### #### ## ## ## ### ## ### ## ## ## ## ## ### ## #### ## ## #### ## ##
s-
Create a variable with a value of zero
'Count var
The initial value is set to zero.
var-n
## ## ##### ## ### ## ### ## ## ## ## ## ## ## ## ## ## ## ## ##### #### ## ###### #### ## ## ## ### ## ### ### ## ## ## ## ## ## ## ## ### ## #### ## ## ## ## #### ## ## ## ##
ns-
Create a variable with a value of n
#500 'Count var-n
This is like `var`, but sets the initial value. This is cleaner to read than doing something like:
'foo var #5 !foo
var
## ## ###
## ## ##
## ##
## ## ## ### ## ## #####
## ## ## ## ## ## ## ## ##
## ## #### ## ## ## ## ###
## ## ## ### ## ## ## #####
## ## ## ## ## ## ## ##
######## ## ## ## ## ## ##
## ## ## ## ## ## ######
p-
Run a quote in a loop repeatedly The loop must return a flag. End loop when flag is zero
(display_100_to_1) #100 [ dup n:put sp n:dec dup n:-zero? ] while drop
I J K forever indexed-times times until
## ## ##### ## ### ## ## ## ## ## ## ## #### ## ## #### ## ## ## ## ### #### ## ## ## ## ## ## ## ## ## ## ##### ##
nn-n
Perform a bitwise XOR
#1 #2 eq? #1 #2 lt? xor [ 'a_condition_met s:put nl ] if
and or not