Pasted

#python 3
# bitter - like brainfuck, only much, much, worse
# mathematically equivalent to Smallfuck
# Lineage:
#   Brainfuck > Boolfuck > Smallfuck > Bitter
 
#set up variables, arrays
from array import array
 
p = 0       # data pointer
high_p = 0  # highest value of p
pc = 0      # program counter
top = 0     # top of the stack
tc = 0      # total command count
steps = 0   # number of execution steps
command_set = "+-()!"
 
prog_mem = ""
data_mem =       array('B')
data_mem =       [ 0 for i in range(10000)]
stack =          array('I')
stack =          [ 0 for i in range(5000)]
open_paren =     array('I')
open_paren =     [ 0 for i in range(5000)]
close_paren =    array('I')
close_paren =    [ 0 for i in range(5000)]
paren_check =    ""
paren_counter =  0
pch_counter =    0   #paren check counter
nesting_levels = 0
 
# load bitter program into memory
file = open(input("bitter file "), 'r')
while True:
    nextch = file.read(1)
    if(not nextch): break
    
    if(nextch in command_set):
        prog_mem += nextch
 
file.close()
 
tc = len(prog_mem)
 
# define functions
def find_open(x):
    return(open_paren[close_paren.index(x)])
 
def find_close(x):
    return(close_paren[open_paren.index(x)])
 
def flip(x):              # x = data_mem[i]
    return(abs(~x) % 2)   # = not x
 
def dump(x):
    format_count = 0
    for i in range(high_p + 1):
        if(i == x): cc = "#"  # marks position of data pointer
        else: cc = "-"  # char in between address and bit
        format_count += 1
        print("%04d" % i + cc + str(data_mem[i]), end = "|")
        if(format_count % 16 == 0): print(" ")
    print()
 
# check parentheses integrity
for i in range(tc):
    if(prog_mem[i] == "(" or prog_mem[i] == ")"):
        paren_check += prog_mem[i]
 
for i in range(len(paren_check)):
    if(paren_check[i] == "("):
        pch_counter += 1
        nesting_levels = max(pch_counter, nesting_levels)
 
    elif(paren_check[i] == ")"):
        pch_counter -= 1
        if(pch_counter < 0):
            print("mismatch")
            quit()
 
if(pch_counter != 0):
    print("mismatch")
    quit()
    
# calculate parentheses locations
for i in range(tc):
    if(prog_mem[i] == '('):
        top += 1
        stack[top] = i
    elif(prog_mem[i] == ')'):
        close_paren[paren_counter] = i
        open_paren[paren_counter] = stack[top]
        top -= 1
        paren_counter += 1
 
# print out arrays of open/close parentheses (debugging)
'''
for i in range(paren_counter):
    print("\n", i, ": ", open_paren[i], close_paren[i])
'''
# run program
while(pc < len(prog_mem)):
    if(prog_mem[pc] == "+"):
        pc += 1
        steps += 1
        p += 1
        high_p = max(p, high_p)
        data_mem[p] = flip(data_mem[p])
    
    elif(prog_mem[pc] == "-"):
        pc += 1
        steps += 1
        p -= 1
        if(p < 0):
            print("data pointer moved below zero")
            dump(p)
            quit()
        else:
            data_mem[p] = flip(data_mem[p])
 
    elif(prog_mem[pc] == "("):
        steps += 1
        if(data_mem[p] == 0):
            pc = close_paren[open_paren.index(pc)] + 1
        else:
            pc += 1
 
    elif(prog_mem[pc] == ")"):
        steps += 1
        pc = open_paren[close_paren.index(pc)]
    
    elif(prog_mem[pc] == "!"):
        pc += 1
        dump(p)
 
# print out program data
print()
print("\ntotal commands: ", tc - prog_mem.count("!"))
print("total steps: ", steps)
print("nesting levels: ", nesting_levels)
print("total paren pairs: ", paren_counter)
print()