Brainfuck Interpreter

[STxAxTIC]

On vacation from women for a month or two. I work, I hustle, I study. Choose two. Ya feel?

[bplus]

@STxAxTIC  Here's something to help keep the women away!

https://www.qb64.org/forum/index.php?topic=2308.msg115346#msg115346

Update: I moved the post under STxAxTIC's start of new thread, it fits better there!
I have also updated the zip with some new stuff.

[romichess]

Well, I've written an interpreter for brainfuck, why? why not? But I've ran into a bug that I can't solve.
I don't understand the reason, but even though I included a line that wraps the data pointer to the upper bound of the data array, the program keeps subtracting 1 to it, this is crucial for loops to work. Here's the code

Code: QB64: [Select]

1. $console
2. _console on
3. dim shared prog(&hffff&) as string
4. dim shared ostream       as _unsigned _byte
5. dim shared arr(&hffff&)  as _unsigned _byte
6. dim shared istream       as _unsigned _byte
7. dim shared ptr           as integer
8.  
9. do
10.     sleep
11.     do
12.         select case inkey$
13.             case ">"     : s$ = s$ + ">": cnt = cnt + 1: prog(cnt) = ">": exit do
14.             case "<"     : s$ = s$ + "<": cnt = cnt + 1: prog(cnt) = "<": exit do
15.             case "+"     : s$ = s$ + "+": cnt = cnt + 1: prog(cnt) = "+": exit do
16.             case "-"     : s$ = s$ + "-": cnt = cnt + 1: prog(cnt) = "-": exit do
17.             case "."     : s$ = s$ + ".": cnt = cnt + 1: prog(cnt) = ".": exit do
18.             case ","     : s$ = s$ + ",": cnt = cnt + 1: prog(cnt) = ",": exit do
19.             case "["     : s$ = s$ + "[": cnt = cnt + 1: prog(cnt) = "[": exit do
20.             case "]"     : s$ = s$ + "]": cnt = cnt + 1: prog(cnt) = "]": exit do
21.             case chr$(8) : if len(s$) then s$ = left$(s$, len(s$) - 1)  : exit do
22.             case chr$(13): exec
23.             case "v"     : for i = 1 to len(_clipboard$): prog(i + cnt) = chr$(asc(_clipboard$, i)): next: s$ = s$ + _clipboard$: exit do
24.             case else    :
25.         end select
26.     loop
27.     print s$;
28.     _display:cls
29.     _keyclear
30. loop
31.  
32. sub exec
33.     for i = 0 to ubound(prog)
34.         select case prog(i)
35.             case ">": ptr = ptr + 1
36.             case "<": if ptr then ptr = ptr - 1 else ptr = ubound(arr) 'What the heck?
37.             case "+": arr(ptr) = arr(ptr) + 1
38.             case "-": arr(ptr) = arr(ptr) - 1
39.             case ".": ostream  = arr(ptr)
40.             case ",": arr(ptr) = istream
41.             case "[":
42.                 if arr(ptr) = 0 then
43.                     for y = i to ubound(prog)
44.                         if prog(x) = "]" then i = x + 1: exit for
45.                     next
46.                 end if
47.             case "]":
48.                 if arr(ptr) then
49.                     for x = i to 0 step -1
50.                         if prog(x) = "[" then i = x: exit for
51.                     next
52.                 end if
53.         end select
54.         updateOutput
55.         updateConsole(i)
56.     next
57. end sub
58.  
59. sub updateOutput     : print chr$(ostream): _display: cls: end sub
60. sub updateInput      : istream = asc(inkey$)             : end sub
61. sub updateConsole(i) : cout "dataptr           =" + str$(ptr)
62.     cout "data    (current) ="  + str$(arr(ptr))
63.     cout "program (current) = " + prog(i)
64.     cout "---------------------"
65. end sub
66. sub cout(s$)      : _dest _console: print s$: _dest 0 : end sub
67.  

And here's the test program (paste with v, execute with [enter]):

Code: QB64: [Select]

1. ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.
2.  

Unless you are planning to equal or top this there is not much point.

https://eli.thegreenplace.net/2017/adventures-in-jit-compilation-part-1-an-interpreter/

[romichess]

A very worthwhile project would be to write a compiler as close to BF as possible but will also use the full power of the processor. Every line would start with one character.

An if else construct:
\
> var1 var2
' code
/
e
\
' code
/

A while loop:
/
w > var1 var2
' code
\

A do while:
/
'code
w > var1 var2
\

Function call:
f name var1 var2 : var3

Function body:
{
n name var1 var2
' code
r var3
}

Something like that. The idea is every single line starts with one character that identifies the action and then a jump table jumps to where that is handled. It would be fast once it is compiled and become like  shorthand for the compiler and the human.