Braintuck

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")
 evaluate(f.read())
 f.close()
 
 
 def evaluate(code):
 code = cleanup(list(code))
 bracemap = buildbracemap(code)
 
 cells, codeptr, cellptr, inputptr = [0], 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[0]
 B = command[1]
 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[1])
 else:
 print("Usage:", sys.argv[0], "filename")
 
 
 if __name__ == "__main__":
 main()
== Examples ==
=== Hello, World! ===
 ++++->>[]<<+++->>[]<<++->>[]<<+++-. H
 ++++++++++++++++++++++++++++++. e
 ++++++++.. ll
 ++++. o
 -+++++++++++++++++++++++-. ,
 -------------. space
 +++++++++++++--. W
 +++++++++++++++++++++++++. o
 ++++. r
 -------. l
 ---------. d
 -++++++++++++++++++--.. !
== Truth machine ==
 ,[.+]..
== Cat ==
 ,[.+,]+
Category:Languages
Category:Brainfuck derivatives
Category:Implemented
Category:2021
Category:Cell-based
Category:Turing complete