Implemented the interpreter
This commit is contained in:
parent
ba8933937e
commit
cca0eb2117
5 changed files with 403 additions and 2 deletions
|
|
@ -3,7 +3,6 @@
|
|||
This repository contains code for a nim program that can interpret a valid [Funge-98](https://github.com/catseye/Funge-98/blob/master/doc/funge98.markdown) program. It will soon pass the [mycology test suite](https://github.com/Deewiant/Mycology).
|
||||
|
||||
Current limitations are :
|
||||
- it is not finished!
|
||||
- currently does not implement any fingerprints
|
||||
- does not implement concurrent execution with the `t` command
|
||||
- does not implement file I/O with the `i` and `o` commands
|
||||
|
|
@ -70,4 +69,7 @@ To debug these particular tests, use :
|
|||
```
|
||||
nim c --debugger:on --parallelBuild:1 --debuginfo --linedir:on tests/stack.nim
|
||||
gdb tests/stack
|
||||
set args XXXXX-if-necessary
|
||||
b src/truc.nim:123
|
||||
r
|
||||
```
|
||||
|
|
|
|||
|
|
@ -37,4 +37,4 @@ proc defaultCharacterOutput*(v: int) =
|
|||
discard stdout.writeChars(@[v.char()], 0, 1)
|
||||
|
||||
proc defaultDecimalOutput*(v: int) =
|
||||
stdout.write(&"{v}")
|
||||
stdout.write(&"{v} ")
|
||||
|
|
|
|||
33
src/interpreter.nim
Normal file
33
src/interpreter.nim
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
import field
|
||||
import pointer
|
||||
|
||||
type
|
||||
Interpreter = object
|
||||
f: ref Field
|
||||
p: ref Pointer
|
||||
argv: seq[string]
|
||||
|
||||
func NewInterpreter*(f: ref Field, p: ref Pointer): ref Interpreter =
|
||||
new(result)
|
||||
result.f = f
|
||||
result.p = p
|
||||
|
||||
proc Step*(i: var Interpreter): ref int =
|
||||
var prev: ref Pointer
|
||||
var p = i.p
|
||||
while p != nil:
|
||||
let (d, v) = p[].Exec(i.f[])
|
||||
if v != nil:
|
||||
return v
|
||||
if d:
|
||||
if prev == nil:
|
||||
i.p = p.next
|
||||
else:
|
||||
prev.next = p.next
|
||||
p = p.next
|
||||
|
||||
proc Run*(i: var Interpreter): int =
|
||||
while i.p != nil:
|
||||
let v = i.Step()
|
||||
if v != nil:
|
||||
return v[]
|
||||
44
src/nimfunge98.nim
Normal file
44
src/nimfunge98.nim
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
import field
|
||||
import interpreter
|
||||
import pointer
|
||||
|
||||
import os
|
||||
import parseopt
|
||||
import strformat
|
||||
|
||||
proc Usage(i: int = 0) =
|
||||
let filename = getAppFilename().extractFilename()
|
||||
echo fmt"""Usage of {filename}:
|
||||
-f string b98 file to interpret
|
||||
-h display this help message
|
||||
"""
|
||||
if i != 0:
|
||||
quit i
|
||||
|
||||
var filename: string
|
||||
|
||||
for kind, key, value in getOpt():
|
||||
case kind
|
||||
of cmdArgument:
|
||||
if filename != "":
|
||||
echo "Invalid argument: ", key
|
||||
Usage(1)
|
||||
filename = key
|
||||
of cmdLongOption, cmdShortOption:
|
||||
case key
|
||||
of "h":
|
||||
Usage()
|
||||
else:
|
||||
echo "Unknown option: ", key
|
||||
Usage(1)
|
||||
of cmdEnd:
|
||||
discard
|
||||
|
||||
var f = Load(filename)
|
||||
if f == nil:
|
||||
echo "Failed to load ", filename
|
||||
quit 1
|
||||
let argv = @[filename]
|
||||
var p = NewPointer(argv=argv)
|
||||
let v = NewInterpreter(f, p)[].Run()
|
||||
quit v
|
||||
322
src/pointer.nim
Normal file
322
src/pointer.nim
Normal file
|
|
@ -0,0 +1,322 @@
|
|||
import defaultIO
|
||||
import field
|
||||
import stackStack
|
||||
|
||||
import math
|
||||
import os
|
||||
import random
|
||||
import times
|
||||
|
||||
randomize()
|
||||
|
||||
type
|
||||
Pointer* = object
|
||||
x, y: int # The pointer's positiont
|
||||
dx, dy: int # The pointer's traveling delta
|
||||
sox, soy: int # The storage offset
|
||||
stringMode, lastCharWasSpace: bool # The string mode flags
|
||||
ss: ref StackStack
|
||||
next*: ref Pointer # the next element for multi-threaded funge-98
|
||||
characterInput*: proc(): int
|
||||
decimalInput*: proc(): int
|
||||
characterOutput*: proc(v: int)
|
||||
decimalOutput*: proc(v: int)
|
||||
argv: seq[string]
|
||||
|
||||
func NewPointer*(next: ref Pointer = nil, argv: seq[string]): ref Pointer =
|
||||
new(result)
|
||||
result.dx = 1
|
||||
result.ss = NewStackStack()
|
||||
result.next = next
|
||||
result.characterInput = defaultCharacterInput
|
||||
result.decimalInput = defaultDecimalInput
|
||||
result.characterOutput = defaultCharacterOutput
|
||||
result.decimalOutput = defaultDecimalOutput
|
||||
result.argv = argv
|
||||
|
||||
#func Split(p: var Pointer) =
|
||||
# # TODO check the spec, maybe we need to duplicate the stack?
|
||||
# p.next = NewPointer(p.next)
|
||||
|
||||
func Step(p: var Pointer, f: Field) =
|
||||
(p.x, p.y) = f.Step((p.x, p.y), (p.dx, p.dy))
|
||||
|
||||
func StepAndGet(p: var Pointer, f: Field): int =
|
||||
p.Step(f)
|
||||
return f.Get(p.x, p.y)
|
||||
|
||||
func Reverse(p: var Pointer) =
|
||||
p.dx = -p.dx; p.dy = -p.dy
|
||||
|
||||
proc Redirect(p: var Pointer, c: int): bool =
|
||||
## Redirects the pointer according to c's value.
|
||||
## Returns true if a redirect has been performed
|
||||
case c:
|
||||
of int('^'): p.dx = 0; p.dy = -1
|
||||
of int('>'): p.dx = 1; p.dy = 0
|
||||
of int('v'): p.dx = 0; p.dy = 1
|
||||
of int('<'): p.dx = -1; p.dy = 0
|
||||
of int('?'):
|
||||
const directions = [0, -1, 1, 0, 0, 1, -1, 0]
|
||||
let r = 2 * rand(3)
|
||||
p.dx = directions[r]; p.dy = directions[r+1]
|
||||
of int('['): (p.dx, p.dy) = (p.dy, -p.dx)
|
||||
of int(']'): (p.dx, p.dy) = (-p.dy, p.dx)
|
||||
of int('r'): p.Reverse()
|
||||
of int('x'): p.dy = p.ss[].Pop(); p.dx = p.ss[].Pop()
|
||||
else: return false
|
||||
return true
|
||||
|
||||
proc Eval(p: var Pointer, f: var Field, c: int): (bool, ref int) =
|
||||
## Executes the instruction on the field
|
||||
## Returns true if the pointer terminated, and a return code if
|
||||
## the program should terminate completely
|
||||
case c:
|
||||
of int('@'): return (true, nil)
|
||||
of int('z'): discard
|
||||
of int('#'): p.Step(f)
|
||||
of int('j'):
|
||||
let n = p.ss[].Pop()
|
||||
if n > 0:
|
||||
for j in 0..<n:
|
||||
p.Step(f)
|
||||
else:
|
||||
p.Reverse()
|
||||
for j in 0 ..< -n:
|
||||
p.Step(f)
|
||||
p.Reverse()
|
||||
of int('q'):
|
||||
var i: ref int
|
||||
new(i); i[] = p.ss[].Pop()
|
||||
return (true, i)
|
||||
of int('k'):
|
||||
let x = p.x
|
||||
let y = p.y
|
||||
let n = p.ss[].Pop()
|
||||
var v = p.StepAndGet(f)
|
||||
var jumpingMode = false
|
||||
while jumpingMode or v == int(' ') or v == int(';'):
|
||||
if v == int(';'):
|
||||
jumpingMode = not jumpingMode
|
||||
v = p.StepAndGet(f)
|
||||
if n > 0:
|
||||
p.x = x; p.y = y
|
||||
if v != int(' ') and v != int(';'):
|
||||
if v == int('q') or v == int('@'):
|
||||
return p.Eval(f, v)
|
||||
for i in 0..<n:
|
||||
discard p.Eval(f, v)
|
||||
of int('!'):
|
||||
if p.ss[].Pop() == 0:
|
||||
p.ss[].Push(1)
|
||||
else:
|
||||
p.ss[].Push(0)
|
||||
of int('`'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
if a > b:
|
||||
p.ss[].Push(1)
|
||||
else:
|
||||
p.ss[].Push(0)
|
||||
of int('_'):
|
||||
if p.ss[].Pop() == 0:
|
||||
p.dx = 1
|
||||
else:
|
||||
p.dx = -1
|
||||
p.dy = 0
|
||||
of int('|'):
|
||||
p.dx = 0
|
||||
if p.ss[].Pop() == 0:
|
||||
p.dy = 1
|
||||
else:
|
||||
p.dy = -1
|
||||
of int('w'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
if a < b:
|
||||
(p.dx, p.dy) = (p.dy, -p.dx)
|
||||
elif a > b:
|
||||
(p.dx, p.dy) = (-p.dy, p.dx)
|
||||
of int('+'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
p.ss[].Push(a+b)
|
||||
of int('*'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
p.ss[].Push(a*b)
|
||||
of int('-'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
p.ss[].Push(a-b)
|
||||
of int('/'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
if b == 0:
|
||||
p.ss[].Push(0)
|
||||
else:
|
||||
p.ss[].Push(a div b)
|
||||
of int('%'):
|
||||
let (a, b) = p.ss[].PopVector()
|
||||
if b == 0:
|
||||
p.ss[].Push(0)
|
||||
else:
|
||||
p.ss[].Push(a mod b)
|
||||
of int('"'):
|
||||
p.stringMode = true
|
||||
of int('\''):
|
||||
p.ss[].Push(p.StepAndGet(f))
|
||||
of int('s'):
|
||||
p.Step(f)
|
||||
f.Set(p.x, p.y, p.ss[].Pop())
|
||||
of int('$'):
|
||||
discard p.ss[].Pop()
|
||||
of int(':'):
|
||||
p.ss[].Duplicate()
|
||||
of int('\\'):
|
||||
p.ss[].Swap()
|
||||
of int('n'):
|
||||
p.ss[].Clear()
|
||||
of int('{'):
|
||||
p.ss[].Begin((p.sox, p.soy))
|
||||
p.sox = p.x + p.dx
|
||||
p.soy = p.y + p.dy
|
||||
of int('}'):
|
||||
var v: tuple[x, y: int]
|
||||
if p.ss[].End(v):
|
||||
p.Reverse()
|
||||
p.sox = v.x; p.soy = v.y
|
||||
of int('u'):
|
||||
if p.ss[].Under():
|
||||
p.Reverse()
|
||||
of int('g'):
|
||||
let (x, y) = p.ss[].PopVector()
|
||||
p.ss[].Push(f.Get(x+p.sox, y+p.soy))
|
||||
of int('p'):
|
||||
let (x, y) = p.ss[].PopVector()
|
||||
let v = p.ss[].Pop()
|
||||
f.Set(x+p.sox, y+p.soy, v)
|
||||
of int('.'):
|
||||
p.decimalOutput(p.ss[].Pop())
|
||||
of int(','):
|
||||
p.characterOutput(p.ss[].Pop())
|
||||
of int('&'):
|
||||
p.ss[].Push(p.decimalInput())
|
||||
of int('~'):
|
||||
p.ss[].Push(p.characterInput())
|
||||
of int('y'):
|
||||
let n = p.ss[].Pop()
|
||||
let now = now()
|
||||
let (x, y, lx, ly) = f.GetSize()
|
||||
let (height, heights) = p.ss[].GetHeights()
|
||||
# 20
|
||||
for key, value in envPairs():
|
||||
case key
|
||||
of "LC_ALL": discard
|
||||
of "PWD": discard
|
||||
of "PATH": discard
|
||||
of "DISPLAY": discard
|
||||
of "USER": discard
|
||||
of "TERM": discard
|
||||
of "LANG": discard
|
||||
of "HOME": discard
|
||||
of "EDITOR": discard
|
||||
of "SHELL": discard
|
||||
else: continue
|
||||
p.ss[].Push(0)
|
||||
for i in value.len-1..0:
|
||||
p.ss[].Push(int(value[i]))
|
||||
# 19
|
||||
p.ss[].PushVector((0, 0))
|
||||
for i in 0..<p.argv.len:
|
||||
p.ss[].Push(0)
|
||||
for j in p.argv[i].len-1..0:
|
||||
p.ss[].Push(int(p.argv[i][j]))
|
||||
# 18
|
||||
for i in 0..<height:
|
||||
p.ss[].Push(heights[i])
|
||||
# 17
|
||||
p.ss[].Push(height)
|
||||
# 16
|
||||
p.ss[].Push(now.hour * 256 * 256 + now.minute * 256 + now.second)
|
||||
# 15
|
||||
p.ss[].Push(now.year * 256 * 256 + int(now.month) * 256 + int(now.monthday))
|
||||
# 14
|
||||
p.ss[].PushVector((lx-1, ly-1))
|
||||
# 13
|
||||
p.ss[].PushVector((x, y))
|
||||
# 12
|
||||
p.ss[].PushVector((p.sox, p.soy))
|
||||
# 11
|
||||
p.ss[].PushVector((p.dx, p.dy))
|
||||
# 10
|
||||
p.ss[].PushVector((p.x, p.y))
|
||||
# 9
|
||||
p.ss[].Push(0)
|
||||
# 8
|
||||
p.ss[].Push(cast[int](addr p))
|
||||
# 7
|
||||
p.ss[].Push(2)
|
||||
# 6
|
||||
p.ss[].Push(int('/'))
|
||||
# 5
|
||||
p.ss[].Push(0) # TODO update when implementing =
|
||||
# 4
|
||||
p.ss[].Push(1)
|
||||
# 3
|
||||
p.ss[].Push(1048577)
|
||||
# 2
|
||||
p.ss[].Push(sizeof(int))
|
||||
# 1
|
||||
p.ss[].Push(0b00000) # TODO update when implementing t, i, o and =
|
||||
if n > 0:
|
||||
p.ss[].YCommandPick(n, heights[0])
|
||||
of int('('):
|
||||
let n = p.ss[].Pop()
|
||||
var v = 0
|
||||
for i in 0..<n:
|
||||
v = v*256+p.ss[].Pop()
|
||||
p.Reverse() # No fingerprints supported yet
|
||||
of int(')'):
|
||||
let n = p.ss[].Pop()
|
||||
var v = 0
|
||||
for i in 0..<n:
|
||||
v = v*256+p.ss[].Pop()
|
||||
p.Reverse() # No fingerprints supported yet
|
||||
of int('i'):
|
||||
quit("not implemented yet", 1)
|
||||
of int('o'):
|
||||
quit("not implemented yet", 1)
|
||||
of int('='):
|
||||
quit("not implemented yet", 1)
|
||||
of int('t'):
|
||||
quit("not implemented yet", 1)
|
||||
else:
|
||||
if not p.Redirect(c):
|
||||
if c >= int('0') and c <= int('9'):
|
||||
p.ss[].Push(c - int('0'))
|
||||
elif c >= int('a') and c <= int('f'):
|
||||
p.ss[].Push(c - int('a') + 10)
|
||||
else:
|
||||
p.Reverse()
|
||||
return (false, nil)
|
||||
|
||||
proc Exec*(p: var Pointer, f: var Field): (bool, ref int) =
|
||||
## Advances to the next instruction of the field and executes it
|
||||
## Returns true if the pointer terminated, and a return code if
|
||||
## the program should terminate completely
|
||||
var c = f.Get(p.x, p.y)
|
||||
if p.stringMode:
|
||||
if p.lastCharWasSpace:
|
||||
while c == int(' '):
|
||||
c = p.StepAndGet(f)
|
||||
p.lastCharWasSpace = false
|
||||
if c == int('"'):
|
||||
p.stringMode = false
|
||||
else:
|
||||
if c == int(' '):
|
||||
p.lastCharWasSpace = true
|
||||
p.ss[].Push(c)
|
||||
else:
|
||||
var jumpingMode = false
|
||||
while jumpingMode or c == int(' ') or c == int(';'):
|
||||
if c == int(';'):
|
||||
jumpingMode = not jumpingMode
|
||||
c = p.StepAndGet(f)
|
||||
result = p.Eval(f, c)
|
||||
p.Step(f)
|
||||
return result
|
||||
Reference in a new issue