# Pythonista 3.5
# alphabet_stew interpreter
# latest update: 2018
# 

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, where next value goes
high_top = 0  # highest value of t. 
tc = 0        # total command count
steps = 0     # number of execution steps
xch_temp = 0  # xchg command temporary storage
command_set = "abcdefghijklmnopqrstuvwxyz!"
prog_mem =    ""
data_mem =    array('B')
data_mem =    [ 0 for i in range(100000)]
stack =       array('I')
stack =       [ 0 for i in range(2000)]
open_loop =   array('I')
open_loop =   [ 0 for i in range(2000)]
close_loop =  array('I')
close_loop =  [ 0 for i in range(2000)]
loop_check =  ""
loop_counter = 0
bc_counter = 0   #loop_check counter
nesting_levels = 0

##################################################
# define functions
def find_open(x):
   return(open_loop[close_loop.index(x)])

def find_close(x):
   return(close_loop[open_loop.index(x)])

def printable(n):
   if(n>31 and n<127):
       return(True)
   else:
       return(False)

# whole memory output from 0 to highest value of 'p'
def dump(x):   # x should only be current value of p
   format_count = 0
   print()
   for i in range(high_p + 1):
       if(i == x):
           left_cc = "{"
           right_cc = "}"
       else:
           left_cc = " "
           right_cc = " "
       
       if(printable(data_mem[i])):
           print("|" + left_cc + "%05d" % i + chr(data_mem[i]) + "%03d" % data_mem[i], end = right_cc)
           format_count += 1
           if(format_count % 8 == 0): print("|")
       else:
           print("|" + left_cc + "%05d" % i + " " + "%03d" % data_mem[i], end = right_cc)
           format_count += 1
           if(format_count % 8 == 0): print("|")
   print("|")

def prog_data():
    print("\nprogram counter: ", pc)
    print("total commands: ", tc - prog_mem.count("!"))
    print("total steps: ", steps)
    print("nesting levels: ", nesting_levels)
    print("total loops: ", loop_counter)
    print()

def stack_print():
    print("Stack")
    if(high_top < 1):
        print("***Not Used***")
    for i in range(top - 1, -1, -1):
        print(i, stack[i], end = "")
        if(i == top - 1):
            print(" *")
        else:
            print("")
    if((top == 0) & (high_top > 0)):
        print("Stack Empty")

##################################################
# load program into memory
#file = open(input("file: "), 'r')
file = open("a.txt", 'r')

while True:
   nextch = file.read(1)
   if(not nextch):
       file.close()
       break
   if(nextch in command_set):
       prog_mem += (nextch)

tc = len(prog_mem)
print("01234567890123456789")
print(prog_mem)
file.close()


##################################################
# check loop integrity
for i in range(tc):
   if(prog_mem[i] == "t" or prog_mem[i] == "i"):
       loop_check += prog_mem[i]

for i in range(len(loop_check)):
   if(loop_check[i] == "t"):
       bc_counter += 1
       nesting_levels = max(bc_counter, nesting_levels)
   elif(loop_check[i] == "i"):
       bc_counter -= 1
       if(bc_counter < 0):
           print("Loop mismatch")
           quit()

if(bc_counter != 0):
   print("Loop mismatch")
   quit()

##################################################
# calculate loop locations, store in loop stack
for i in range(tc):
   if(prog_mem[i] == 't'):
       top += 1
       stack[top] = i
   elif(prog_mem[i] == 'i'):
       close_loop[loop_counter] = i
       open_loop[loop_counter] = stack[top]
       top -= 1
       loop_counter += 1

##################################################
# run program
while(pc < len(prog_mem)):
   if(prog_mem[pc] == "g"):   #add
       if(top < 2):
           print("Stack Error")
           quit()
       stack[top - 2] = (stack[top - 1] + stack[top -2]) % 256
       top -= 1
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "p"): #and
       if(top < 2):
           print("Stack Error")
           quit()
       stack[top - 2] = (stack[top - 1] & stack[top -2]) % 256
       top -= 1
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "q"): #or
       if(top < 2):
           print("Stack Error")
           quit()
       stack[top - 2] = (stack[top - 1] | stack[top -2]) % 256
       top -= 1
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "y"): #not mem
       data_mem[p] = 255 - data_mem[p]
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "z"): #input ascii (',')
       data_mem[p] = ord(input("input character: "))
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "x"): #sub
       if(top < 2):
           print("Stack Error")
           quit()
       stack[top - 2] = (stack[top - 1] - stack[top -2]) % 256
       top -= 1
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "t"): #[
       steps += 1
       if(data_mem[p] == 0):
           pc = close_loop[open_loop.index(pc)] + 1
       else:
           pc += 1

   elif(prog_mem[pc] == "m"): #shl mem
       data_mem[p] = (data_mem[p] << 1) % 256
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "a"): #shr mem
       data_mem[p] = (data_mem[p] >> 1) % 256
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "f"): #jmp left
       pc -= data_mem[p]
       steps += 1
   
   elif(prog_mem[pc] == "k"): #xor
       if(top < 2):
           print("Stack Error")
           quit()
       stack[top - 2] = (stack[top - 1] ^ stack[top - 2]) % 256
       top -= 1
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "o"): #push mem
       stack[top] = data_mem[p]
       top += 1
       high_top = max(top, high_top)
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "l"): #pop
       if(top < 1):
           print("Stack Error")
           quit()
       top -= 1
       data_mem[p] = stack[top]
       stack[top] = 0
       Z = int(data_mem[p] == 0)
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "h"): #jmp right
       pc += data_mem[p]
       steps += 1
   
   elif(prog_mem[pc] == "n"): #halt
       prog_data()
       stack_print()
       print("\nProgram Halt")
       quit()
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "c"): #peek
       if(top < 1):
           print("Stack Error")
           quit()
       top -= 1
       data_mem[p] = stack[top]
       top += 1
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "u"): #dec mem
       data_mem[p] = (data_mem[p] - 1) % 256
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "e"): #inc mem
       data_mem[p] = (data_mem[p] + 1) % 256
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "r"): #input dec
       data_mem[p] = int(input("Enter Decimal Number: ")) % 256
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "b"): #output ascii
       if(printable(data_mem[p])):
           print(chr(data_mem[p]), end = "")
       else:
           if(data_mem[p] == 10):
               print("\n")
           else:
               print(end = "")
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "w"): #xchg
       if(top < 2):
           print("Stack Error")
           quit()
       xch_temp = stack[top - 1]
       stack[top - 1] = stack[top - 2]
       stack[top - 2] = xch_temp
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "j"): #clear stack
       top = 0
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "s"): #>
       p += 1
       high_p = max(p, high_p)
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "v"): #output dec
       print('{:03d}'.format(data_mem[p]), end = "")
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "i"): #]
       steps += 1
       pc = open_loop[close_loop.index(pc)]

   elif(prog_mem[pc] == "d"): #<
       p -= 1
       if(p < 0):
            print("Data Pointer Underflow")
            quit()
       pc += 1
       steps += 1
   
   elif(prog_mem[pc] == "!"): #dump mem
       dump(p)
       pc += 1

prog_data()
stack_print()