iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-23 09:41:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

More refactoring, get lines below 80 chars.

Browse Source
This commit is contained in:
HorseMD 2014-11-13 16:26:38 +00:00
parent c0774dc821
commit ade01b4ad8
1 changed files with 31 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
forth.html.markdown
View File

@ -7,28 +7,29 @@ filename: learnforth.fs
Forth was created by Charles H. Moore in the 70s. Forth was created by Charles H. Moore in the 70s.
Note: This article focuses predominantly on the Gforth implementation of Forth, but most Note: This article focuses predominantly on the Gforth implementation of
of what is written here should work elsewhere. Forth, but most of what is written here should work elsewhere.
> If Lisp is the ultimate high level language, Forth is the ultimate low level language. > If Lisp is the ultimate high level lang, Forth is the ultimate low level lang.
```forth ```forth
\ Forth is an interactive programming language which is comprised of *words*. These are \ Forth is an interactive programming language which is comprised of
\ Forth subroutines which are executed once you press <Cr>, from left to right. \ *words*. These are Forth subroutines which are executed once you press
<Cr>, from left to right.
\ ------------------------------ Precursor ------------------------------ \ ------------------------------ Precursor ------------------------------
\ It's important to know how forth processes instructions. All programming in Forth is \ It's important to know how forth processes instructions. All
\ done by manipulating what's known as the parameter stack (more commonly just referred \ programming in Forth is done by manipulating what's known as the parameter
\ to as "the stack"). Typing: \ stack (more commonly just referred to as "the stack"). Typing:
5 2 3 56 76 23 65 5 2 3 56 76 23 65
\ Makes those numbers get added to the stack, from left to right. \ Makes those numbers get added to the stack, from left to right.
.s \ <7> 5 2 3 56 76 23 65 ok .s \ <7> 5 2 3 56 76 23 65 ok
\ Forth's interpreter interprets what you type in one of two ways: as *words* (i.e. the \ Forth's interpreter interprets what you type in one of two ways: as *words*
\ name of subroutines) or as *numbers*. Words are essentially "symbols that do things". \ (i.e. the name of subroutines) or as *numbers*.
\ ------------------------------ Basic Arithmetic ------------------------------ \ ------------------------------ Basic Arithmetic ------------------------------
@ -47,16 +48,16 @@ of what is written here should work elsewhere.
\ And so on. \ And so on.
\ ------------------------------ Stack Manipulation ------------------------------ \ ----------------------------- Stack Manipulation -----------------------------
\ Naturally, as we do so much work with the stack, we'll want some useful methods. \ Naturally, as we work with the stack, we'll want some useful methods:
3 dup - \ duplicate the top item (1st now equals 2nd): 3 - 3 3 dup - \ duplicate the top item (1st now equals 2nd): 3 - 3
2 5 swap / \ swap the top with the second element: 5 / 2 2 5 swap / \ swap the top with the second element: 5 / 2
6 4 5 rot .s \ rotate the top 3 elements: 4 5 6 ok 6 4 5 rot .s \ rotate the top 3 elements: 4 5 6 ok
4 0 drop 2 / \ remove the top item (dont print to screen): 4 / 2 4 0 drop 2 / \ remove the top item (dont print to screen): 4 / 2
\ ------------------------------ More Advanced Stack Manipulation ------------------------------ \ ---------------------- More Advanced Stack Manipulation ----------------------
1 2 3 4 tuck \ duplicate the top item into the second slot: 1 2 4 3 4 ok 1 2 3 4 tuck \ duplicate the top item into the second slot: 1 2 4 3 4 ok
1 2 3 4 over \ duplicate the second item to the top: 1 2 3 4 3 ok 1 2 3 4 over \ duplicate the second item to the top: 1 2 3 4 3 ok
@ -65,7 +66,7 @@ of what is written here should work elsewhere.
\ When referring to stack indexes, they are zero-based. \ When referring to stack indexes, they are zero-based.
\ ------------------------------ Creating Words ------------------------------ \ ------------------------------ Creating Words --------------------------------
\ Quite often one will want to write their own words. \ Quite often one will want to write their own words.
: square ( n -- n ) dup * ; \ ok : square ( n -- n ) dup * ; \ ok
@ -77,7 +78,7 @@ of what is written here should work elsewhere.
\ We can check the definition of a word with the `see` word: \ We can check the definition of a word with the `see` word:
see square \ dup * ; ok see square \ dup * ; ok
\ ------------------------------ Conditionals ------------------------------ \ -------------------------------- Conditionals --------------------------------
\ In forth, -1 is used to represent truth, and 0 is used to represent false. \ In forth, -1 is used to represent truth, and 0 is used to represent false.
\ The idea is that -1 is 11111111 in binary, whereas 0 is obviously 0 in binary. \ The idea is that -1 is 11111111 in binary, whereas 0 is obviously 0 in binary.
@ -86,22 +87,22 @@ see square \ dup * ; ok
42 42 = / -1 ok 42 42 = / -1 ok
12 53 = / 0 ok 12 53 = / 0 ok
\ `if` is a *compile-only word*. This means that it can only be used when we're compiling a word. \ `if` is a *compile-only word*. This means that it can only be used when we're
\ when creating conditionals, the format is `if` <stuff to do> `then` <rest of program>. \ compiling a word. The format is `if` <stuff to do> `then` <rest of program>.
: ?>64 ( n -- n ) DUP 64 > if ." Greater than 64!" then ; \ ok : ?>64 ( n -- n ) DUP 64 > if ." Greater than 64!" then ; \ ok
100 ?>64 \ Greater than 64! ok 100 ?>64 \ Greater than 64! ok
\ Else: \ Else:
: ?>64 ( n -- n ) DUP 64 > if ." Greater than 64!" else ." Less than 64!" then ; \ ok : ?>64 ( n -- n ) DUP 64 > if ." Greater than 64!" else ." Less than 64!" then ;
100 ?>64 \ Greater than 64! ok 100 ?>64 \ Greater than 64! ok
20 ?>64 \ Less than 64! ok 20 ?>64 \ Less than 64! ok
\ ------------------------------ Loops ------------------------------ \ ------------------------------------ Loops -----------------------------------
\ `do` is like `if` in that it is also a compile-only word, though it uses `loop` as its \ `do` is like `if` in that it is also a compile-only word, though it uses
\ terminator: \ `loop` as its terminator:
: myloop ( -- ) 5 0 do cr ." Hello!" loop ; \ ok : myloop ( -- ) 5 0 do cr ." Hello!" loop ; \ ok
test test
\ Hello! \ Hello!
@ -110,11 +111,11 @@ test
\ Hello! \ Hello!
\ Hello! ok \ Hello! ok
\ `do` expects two numbers on the stack: the end number and the index number, respectively. \ `do` expects two numbers on the stack: the end number and the index number:
\ Get the value of the index as we loop with `i`: \ Get the value of the index as we loop with `i`:
: one-to-15 ( -- ) 15 0 do i . loop ; \ ok : one-to-12 ( -- ) 12 0 do i . loop ; \ ok
one-to-15 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ok one-to-12 \ 0 1 2 3 4 5 6 7 8 9 10 11 12 ok
: squares ( -- ) 10 0 do i DUP * . loop ; \ ok : squares ( -- ) 10 0 do i DUP * . loop ; \ ok
squares \ 0 1 4 9 16 25 36 49 64 81 ok squares \ 0 1 4 9 16 25 36 49 64 81 ok
@ -125,7 +126,7 @@ threes \ 0 3 6 9 12 ok
\ Finally, while loops with `begin` <stuff to do> <flag> `unil`: \ Finally, while loops with `begin` <stuff to do> <flag> `unil`:
: death ( -- ) begin ." Are we there yet?" 0 until ; : death ( -- ) begin ." Are we there yet?" 0 until ;
\ ------------------------------ Variables and Memory ------------------------------ \ ---------------------------- Variables and Memory ----------------------------
\ Sometimes we'll be in a situation where we want more permanent variables: \ Sometimes we'll be in a situation where we want more permanent variables:
\ First, we use `variable` to declare `age` to be a variable. \ First, we use `variable` to declare `age` to be a variable.
@ -134,8 +135,8 @@ variable age
\ Then we write 21 to age with the word `!`. \ Then we write 21 to age with the word `!`.
21 age ! 21 age !
\ Finally we can print our variable using the "read" word '@', which adds the value \ Finally we can print our variable using the "read" word '@', which adds the
\ to the stack, or use a handy word called `?` that reads and prints it in one go. \ value to the stack, or use `?` that reads and prints it in one go.
age @ . \ 12 ok age @ . \ 12 ok
age ? \ 12 ok age ? \ 12 ok
@ -180,7 +181,7 @@ create mynumbers 64 , 9001 , 1337 , \ the last `,` is important!
\ TODO \ TODO
\ ------------------------------ Final Notes ------------------------------ \ --------------------------------- Final Notes --------------------------------
\ Floats \ Floats
\ Commenting (types) \ Commenting (types)