Working Notes: a commonplace notebook for recording & exploring ideas.
Home. Site Map. Subscribe. More at expLog.
- =INVERT= is the not used after conditionals
- =OR=, =AND=
- =?DUP=
- Duplicates non zero topmost values
- =ABORT"=
- raise error and die
- =PAGE= clear terminal screen
- =ABS= absolute value, =NEGATE=, =MIN=, =MAX=
- *Parameter Stack* -- standard stack used by parameters
- arguments passed from word to word
- *Return Stack* --
- used by forth to hold pointers
- can be used to temporarily hold values
- must be cleared by the time we reach ;
- =>R= moves value from parameter to return stack
- =R>= moves value from return to parameter stack
- =R@= copies top item from return stack to parameter stack
- Processors that support hardware floating point are faster than fixed point
- Scaling operators help with fixed point
- =*/= ( n1 n2 n3 -- n4 ) n1 * n2 / n3 with a double length intermediate result
- =*/MOD= similar
- Can approximate constants by pairs of integers with errors < 10^-8
- Definite loop: =<LIMIT> <INDEX> DO...LOOP=
- index and limit are stored on the loop control stack
- =I= copies loop index onto stack; =J= next outer loop index
- =U.R= unsigned number print, right justified
- =DO ... <INC> +LOOP= uses a custom increment
- INC must be put on the loop each time around
- Adding random words triggers =ABORT=, which also clears all stacks
- Indefinite loop: =BEGIN ... <flag> UNTIL=
- Infinite loop: =BEGIN ... AGAIN=
- Unconditionally branches back
- =BEGIN ... <f> WHILE ... REPEAT=
- test happens in the middle
- =LEAVE= causes loops to immediately end
- =QUIT= removes ok at end of execution
- =NIP= drop first item below stack
- =2*= arithmetic left shift, =2/= arithmetic right shift
- Stack holds unsigned or signed numbers
- you have to remember to handle appropriately
- =.,= prints stack value as signed number
- =U.= prints it as unsigned
- =UM*=, =UM/MOD=, =U<= -- single length unsigned ops
- =HEX=, =OCTAL=, =DECIMAL= change base
- Prefix hexadecimals with a 0
- = n BASE ! ;= Change base
- Number followed by a . is converted to a double cell number
- =D.= print double length number
- =<# #S #> TYPE ;=
- =<#= bracket-number
- =#>= number-bracket
- =#S= "numbers"
- converts value on stack into ascii
- TYPE prints out the characters
- =HOLD= inserts character at current position
- =<# ... #>= converts double length unsigned values to strings
- =<# ... ROT SIGN #>= double length signed value etc. etc.
- =M+= double length + single length
- =SM/REM= d1 / n1, returning n2 and n3
- =FM/MOD=, =M*=, =M*/=
- Defined numbers get compiled into the dictionary, depending on defined base
- =VARIABLE DATE=, creating variables;
- =12 DATE != ! == store
- =DATE @= @ == fetch onto stack
- =DATE ?= == =DATE @ .=
- Variables are useful for values that need to be changed /after/ the definition has been compiled
- =+!= increment stored value
- =<VALUE> CONSTANT <NAME> =
- constants for readability
- =2VARIABLE=, =2CONSTANT=, =2!=, =2@=
- =VARIABLE <name> <x> CELLS ALLOT=
- adds additional cells to the variable
- =<val> <name> <index> CELLS + <ops>=
- =FILL (addr n char -- )= fills n bytes
- =ERASE (addr n -- )= zeroes out n bytes
- =addr count DUMP= to print out arrays
- Can also use byte arrays: =C! ( char addr - )=, =C@ ( addr - )=
- =CREATE name <value1> , <value2> , <value3> ... ,=
- =CREATE= Puts a new name in the dictionary
- =,= takes a number from the stack and puts it into the array
- =C,= for creating byte arrays
- ='= Identifies location in memory from dictionary, returns execution token
- =EXECUTE= executes token on stack
- =DUMP= shows raw contents
- Vectored execution
- Execute indirectly by storing execution token (xt) in a variable
- allows changing the pointer later -- like a lambda!
- Label pointers with a ='= prefix, eg. ='aloha=
- Tick always goes to the next word in the input stream, not the definition
- =[']= goes to the next word in the definition
- Dictionary entries
- name field, link field, code/code pointer field and data field
- name: first byte defines number of characters, then an ascii rep of the name
- precedence bit: if it should be executed during compilation or compiled into the definition
- link: address of previous definition, allows for searching dictionary
- ' starts with the most recent word and walks backwards
- code pointer
- address of instruction executed for this word
- for variables, pushes address of variable onto stack
- for constant, pushes contents onto stack
- etc.
- points to "run-time" code
- can be actual machine code
- data field
- length depends on type variable, constant, array, etc.
- =>BODY= gets beginning of data field
- contains execution tokens of words that comprise the definition
- execution token is code pointer
- =EXIT= returns execution to next higher level definition, return from subroutine
- return stack keeps return addresses
- =QUIT= is the outermost loop, =INTERPRET= s and prints oks.
- Memory map
- forth / system variables / load definitions / user dictionary (stack)
- pad stores ascii, etc. that are being manipulated
- parameter stack grows up
- TIB grows down / terminal input buffer -- stores text from terminal
- return stack grows up
- user variables/buffers at the end
- =CP= points to the next cell in dictionary
- =HERE= puts =CP= on the stack, can be used to estimate size of stack
- =SP= provides address of top stack location
- =S0= contains address of cell below the empty stack
- =TIB=, =#TIB=, =BASE=, =H=, =>IN=
- User variables
- kept in an "user table"
- each task can get a custom variable even if the definition is same
- defined with =USER=
- Vocabularies manage the dictionary
- =EMIT= ASCII re on the stack and prints it
- =TYPE= prints entire string given starting address in memory
*— Kunal