# braintuck

Paradigm(s) imperative Xradiation 2021 Cell-based one-dimensional Turing complete See below. Brainfuck `.bt`

Braintuck or bt for short, is a derivative of brainfuck made by Xradiation (User:Xradiation) on 27-11-2021 with the purpose of learning. Braintuck is very similar to brainfuck, but its operations are decided based on two characters instead of one.

## Workings

The interpreter goes over every character and reads it as well as its neighbor. So the code `ABCD` is read as `AB` `BC` `CD`. The two characters read by the interpreter determines what is executed. We can name these two characters `A` and `B`. Character `A` determines the handling, and `B` the handler for some of the handlings (see table 1)

tabe 1) handeling list
A handling
`+` current cell += `B`
`-` current cell -= `B`
`>` cell pointer += `B`
`<` cell pointer -= `B`
`[` Jump past the matching ] if the referenced cell is 0
`]` Jump back to the matching [ if the referenced cell is nonzero
`.` Output the character signified by `B`
`,` Input a character and store it in the current cell
tabe 2) handeler list
B handler
`+``-` current cell
`>``<` cell pointer
`,` Input
`[``]``.` 0

However when `A` is the same as `B`, `B` becomes one of the default values:

tabe 3) handeler Defauts
B Default
`+``-` 1
`>``<` 1
`,``[``]` Not applicable (ignored)
`.` current cell

## Instruction list

Caption text
Instruction meaning
>+/>- pointer+= current cell
>> pointer += 1
>< pointer += pointer
>[ / >]/ >. nothing
>, pointer += input, inputptr +=1

## Interpreter

### Python

```   import sys

print('input:')
inputStr = input()

R = {
'cell': 0,
'codeptr': 0,
'cellptr': 0,
'input': 0,
'zero': 0
}

T = {
'>': 'cellptr',
'<': 'cellptr',
'+': 'cell',
'-': 'cell',
'[': 'zero',
']': 'zero',
',': 'input',
'.': 'zero'
}

def RT(A, B):
if A == B:
return 1
RTAB = R[T[B]]
if RTAB == 'empty':
RTAB = 0
return RTAB

def execute(filename):
f = open(filename, "r")
f.close()

def evaluate(code):
code = cleanup(list(code))
bracemap = buildbracemap(code)

cells, codeptr, cellptr, inputptr = , 0, 0, 0

while codeptr < len(code)-1:

try:

R['cell'], R['codeptr'], R['cellptr'] = cells[cellptr], codeptr, cellptr

if inputptr<=len(inputStr)-1:
R['input'] = ord(inputStr[inputptr])
else:
R['input'] = 'empty';

command = code[codeptr:codeptr+2]
A = command
B = command
RTAB = RT(A, B)

if A == ">":
cellptr += RTAB
if cellptr >= len(cells):
for i in range(cellptr-len(cells)+1):
cells.append(0)
if A == "<":
cellptr = (cellptr - RTAB) % len(cells)
elif A == "+":
cells[cellptr] = (cells[cellptr] + RTAB) % 255
elif A == "-":
cells[cellptr] = (cells[cellptr] - RTAB) % 255
elif A == "[" and cells[cellptr] == 0:
codeptr = bracemap[codeptr]
elif A == "]" and cells[cellptr] != 0:
codeptr = bracemap[codeptr]
elif A == ".":
if B == A:
#sys.stdout.write(chr(cells[cellptr]))
print(chr(cells[cellptr]), cells[cellptr])
else:
#sys.stdout.write(chr(RTAB))
print(chr(RTAB), RTAB)
elif A == ",":

if R['input'] != 'empty':
cells[cellptr] = R['input']
inputptr += 1
else:
cells[cellptr] = 0

codeptr += 1
except Exception as e:
print(code)
print(' '*codeptr+'^')
print("Error at char "+str(codeptr+1))

print()
print('Interpeter:')
raise e

def cleanup(code):
return .join(filter(lambda x: x in ['.', ',', '[', ']', '<', '>', '+', '-'], code))

def buildbracemap(code):
temp_bracestack, bracemap = [], {}

for position, command in enumerate(code):
if command == "[":
temp_bracestack.append(position)
if command == "]":
start = temp_bracestack.pop()
bracemap[start] = position
bracemap[position] = start
return bracemap

def main():
if len(sys.argv) == 2:
execute(sys.argv)
else:
print("Usage:", sys.argv, "filename")

if __name__ == "__main__":
main()
```

## Examples

### Hello, World!

```++++->>[]<<+++->>[]<<++->>[]<<+++-.    H
++++++++++++++++++++++++++++++.        e
++++++++..                             ll
++++.                                  o
-+++++++++++++++++++++++-.             ,
-------------.                         space
+++++++++++++--.                       W
+++++++++++++++++++++++++.             o
++++.                                  r
-------.                               l
---------.                             d
-++++++++++++++++++--..                !
```

## Truth machine

```,[.+]..
```

## Cat

```,[.+,]+
```