|
| """
forth.cobra
This is a budding FORTH interpreter featuring:
* basic stack item manipulation (dup, over, swap, drop, ...)
* stack manipulation (0SP aka stack.clear)
* math (+ - * / %)
* definitions (; NAME CODE : -OR- def NAME CODE end)
* You can multiply strings as in: foo 3 * -- foofoofoo
...and not much else right now.
Run with no arguments to see some example FORTH get executed.
Run with -i for "interactive mode" to enter your own FORTH.
Enter "quit" or "exit" to do so.
Forth tutorial:
http://www.softsynth.com/pforth/pf_tut.htm
In addition to some extra synonym words which you'll see in the list of words, this particular
interperter also accepts 'def' for ':' and 'end' for ';'. So these are equivalent:
: AVERAGE ( a b -- avg ) + 2 / ;
def AVERAGE ( a b -- avg ) + 2 / end
TODO:
[ ] Text in parens is a comment.
[ ] variables
[ ] Could do the built-in definitions by tagging their methods with attributes
[ ] Support fractional numbers. In other words, decimals.
[ ] Automated tests.
[ ] Consider making Definition abstract with concrete subs: BuiltInDefinition, WordsDefinition with possible DelegateDefinition as well
[ ] Could preserve the comment in a definition that immediatel follows the definition's name and store it with the definition. Then could offer it back later with a help command.
[ ] Shouldn't there be some kind of quoting character so a name can be pushed on the stack without invoking it? Probably have not gotten that far in the tutorial.
[ ] More FORTH:
- In general, cover everything at http://www.softsynth.com/pforth/pf_tut.htm
ROT ( a b c -- b c a , ROTate third item to top )
PICK ( ... v3 v2 v1 v0 N -- ... v3 v2 v1 v0 vN )
0 PICK is equivalent to DUP
1 PICK is equivalent to OVER
DROP ( n -- , remove top of stack )
?DUP ( n -- n n | 0 , duplicate only if non-zero, '|' means OR )
-ROT ( a b c -- c a b , rotate top to third position )
2SWAP ( a b c d -- c d a b , swap pairs )
2OVER ( a b c d -- a b c d a b , leapfrog pair )
2DUP ( a b -- a b a b , duplicate pair )
2DROP ( a b -- , remove pair )
NIP ( a b -- b , remove second item from stack )
TUCK ( a b -- b a b , copy top item to third position )
Fast math operations:
1+ 1- 2+ 2- 2* 2/
Define new words:
: AVERAGE ( a b -- avg ) + 2/ ;
"""
class ForthMachine
var _stack as Stack<of Word>
var _definitions as Dictionary<of Word, Definition>
var _didQuit as bool
var _verbosity = 1
cue init
base.init
_stack = Stack<of Word>()
_definitions = Dictionary<of Word, Definition>()
.define('quit', 'built-in:quit')
.define('exit', 'built-in:quit')
.define('words', 'built-in:printDefinitionNames')
.define('.', 'built-in:printTop')
.define('.S', 'built-in:printStack')
.define('stack.print', 'built-in:printStack')
.define('0SP', 'built-in:clearStack')
.define('stack.clear', 'built-in:clearStack')
.define('drop', 'built-in:drop')
.define('dup', 'built-in:dup')
.define('over', 'built-in:over')
.define('swap', 'built-in:swap')
.define('+', 'built-in:add')
.define('-', 'built-in:sub')
.define('*', 'built-in:mul')
.define('/', 'built-in:div')
.define('%', 'built-in:mod')
get didQuit from var
pro verbosity from var
## Fundamental operations to implement a FORTH machine
def wordFor(text as String) as Word
require text.trim.length
return Word(text)
def wordFor(i as int) as Word
return Word(i)
def push(word as Word)
require word.isString implies word.string.trim.length
_stack.push(word)
def push(word as String)
.push(Word(word))
def peek as Word
if _stack.count
return _stack.peek
else
print 'ERROR: Stack is empty.'
return Word(0)
def pop as Word
if _stack.count
return _stack.pop
else
print 'ERROR: Stack is empty.'
return Word(0)
def define(word as String, definition as String)
words = for rawWord in definition.split where rawWord.trim.length>0 get .wordFor(rawWord.trim) # CC: axe > 0
_definitions[.wordFor(word)] = Definition(words)
def define(word as Word, definition as IEnumerable<of Word>)
_definitions[word] = Definition(definition)
def definitionFor(word as Word) as Definition?
result as Definition?
if _definitions.tryGetValue(word, out result)
return result to !
else
return nil
def invoke(name as Word, definition as Definition)
if definition.count
word = definition[0]
if word.toString.startsWith('built-in:')
methodName = word.toString['built-in:'.length:]
methodName = methodName[0].toString.toUpper + methodName[1:] # because at run-time, method names are capped for compatibility with C# and VB
method = .typeOf.getMethod(methodName)
method.invoke(this, nil)
else
for word in definition
if word.isString
defin = .definitionFor(word)
if defin
.invoke(word, defin)
continue
.push(word)
else
# empty definition is a no-op
pass
def error(message as String)
print 'ERROR:', message
## Conveniences
def processInput(input as String)
mode = 0 # 0 - normal, 1 - define
if _verbosity
print 'input>', input
rawWords = input.trim.split
for rawWord in rawWords
rawWord = rawWord.trim
if not rawWord.length
continue
branch mode
on 0 # normal
if rawWord in [':', 'def']
defWords = List<of Word>()
mode = 1 # into define mode
else
word = .wordFor(rawWord)
if word.isString
defin = .definitionFor(word)
if defin
.invoke(word, defin)
continue
.push(word)
on 1 # definition mode
if rawWord in [';', 'end']
.define(defWords[0], defWords[1:])
defWords.clear
mode = 0 # back to normal
else
defWords.add(.wordFor(rawWord))
if _verbosity
print 'stack> ' stop
.printStack
print
## Built-in definitions
def quit
_didQuit = true
def printDefinitionNames
keys = List<of Word>(_definitions.keys)
keys.sort
for key in keys, print '[key] ' stop
print
def printTop
print .pop
def printStack
for word in Stack<of Word>(_stack) # Stack wrapper reverses the order so right most printed element is the top of the stack
print '[word] | ' stop
print
## Built-ins: whole stack manipulation
def clearStack
_stack.clear
## Built-ins: stack element manipulations
def drop
.pop
def dup
.push(.peek)
def over
"""
a b -- a b a
"""
b = .pop
a = .pop
.push(a)
.push(b)
.push(a)
def swap
"""
a b -- b a
"""
b = .pop
a = .pop
.push(b)
.push(a)
## Built-ins: arithmetic
def add
b = .pop
a = .pop
if a.isInt and b.isInt
.push(.wordFor(a.int + b.int))
else if a.isString and b.isString
.push(.wordFor(a.string + b.string))
else
.error('Cannot add "[a]" and "[b]".')
def sub
b = .pop
a = .pop
if a.isInt and b.isInt
.push(.wordFor(a.int - b.int))
else
.error('Cannot subtract "[a]" and "[b]".')
def mul
b = .pop
a = .pop
if a.isInt and b.isInt
.push(.wordFor(a.int * b.int))
return
else if a.isString and b.isInt
s = a.string
i = b.int
else if a.isInt and b.isString
s = b.string
i = a.int
else
.error('Cannot add "[a]" and "[b]".')
sb = StringBuilder()
for j in i, sb.append(s)
.push(.wordFor(sb.toString))
def div
b = .pop
a = .pop
if a.isInt and b.isInt
.push(.wordFor(a.int // b.int))
else
.error('Cannot divide "[a]" and "[b]".')
def mod
b = .pop
a = .pop
if a.isInt and b.isInt
.push(.wordFor(a.int % b.int))
else
.error('Cannot modulate "[a]" and "[b]".')
class Word implements IComparable<of Word>
enum WordType
String
Int
var _which as WordType
var _i as int
var _s as String?
cue init(text as String)
"""
Creates a new word, interpreting the text as an integer if possible.
"""
.init(text, true)
cue init(text as String, interpret as bool)
"""
When interpretation is false, text is simply taken as is.
Otherwise if the text represents an integer, this word will be one.
"""
test
w = Word('foo')
assert w.isString
w = Word('10')
assert w.isInt
w = Word('10', false)
assert w.isString
body
base.init
if interpret and int.tryParse(text, out _i)
_which = WordType.Int
else
_s = text
_which = WordType.String
cue init(i as int)
base.init
_i = i
_which = WordType.Int
get isInt as bool
return _which == WordType.Int
get int as int
require .isInt
return _i
get isString as bool
return _which == WordType.String
get string as String
require .isString
return _s to !
def equals(other as Object?) as bool is override
if other inherits Word
if _which == other._which
branch _which
on WordType.String, return _s == other._s
on WordType.Int, return _i == other._i
return false
else
return false
def compareTo(other as Word) as int
if .isInt
if other.isInt
return .int.compareTo(other.int)
else
return -1
else if .isString
if other.isString
return .string.compareTo(other.string)
else
return 1
else
throw FallThroughException(other)
def getHashCode as int is override
branch _which
on WordType.String, return _s.getHashCode
on WordType.Int, return _i.getHashCode
throw FallThroughException(_which)
def toString as String is override
branch _which
on WordType.String
if _s == '', return '(EMPTY-STRING)'
if _s.trim == '', return '(BLANK-STRING)'
return _s to !
on WordType.Int
return _i.toString
return ''
def toTechString as String
branch _which
on WordType.String, return '[.typeOf.name](string, "[_s]")'
on WordType.Int, return '[.typeOf.name](int, "[_i]")'
throw FallThroughException(_which)
class Definition inherits List<of Word>
cue init(words as IEnumerable<of Word>?)
base.init(words)
class Program
shared
def main
print 'FORTH interpeter written in Cobra [CobraCore.version]'
args = CobraCore.commandLineArgs
if args.count > 1 and args[1] == '-i'
.interactive
else
.runExamples
print 'Run with -i for interactive mode.'
def runExamples
print 'Examples/tests:'
print
fm = ForthMachine()
fm.printDefinitionNames
fm.processInput('1 .')
fm.processInput('1 2 +')
fm.processInput('stack.clear')
fm.processInput('2 dup + .')
fm.processInput('1 3 swap')
fm.processInput('drop drop')
fm.processInput('3 5 over')
# fm.processInput(': AVERAGE ( a b -- avg ) + 2 / ; words stack.clear 10 20 AVERAGE')
fm.processInput(': AVERAGE + 2 / ; words stack.clear 10 20 AVERAGE .')
fm.processInput('def double 2 * end 2 double dup . double dup . double dup . drop')
def interactive
print 'Enter "quit" or "exit" to do so.'
print
fm = ForthMachine()
fm.verbosity = 0
print 'words:'
fm.printDefinitionNames
print
while true
print 'forth> ' stop
input = Console.readLine
if input
fm.processInput(input)
if fm.didQuit, break
print 'stack> ' stop
fm.printStack
print
else
break
|
