Grawlix interpreter

# Pythonista 3.5
# Grawlix Programming Language
# Last update: 2017

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
top_max = 0 # highest value of top
tc = 0      # total command count
steps = 0   # number of execution steps
command_set = "><+-,.[];:?(){}@/|=^!#"

prog_mem = ""
nextch = ""
key_press = ""
input_buffer = ""
data_mem =      array('B')
data_mem =      [0] * 100000
stack =         array('I')
stack =         [0] * 100000

bracket_check = ""
bracket_counter = 0
bc_counter = 0   #bracket_check counter
nesting_levels = 0 # for brackets
open_bracket =  array('I')
open_bracket =  [0] * 100000
close_bracket = array('I')
close_bracket = [0] * 100000

paren_check =  ""
paren_counter = 0
paren_check_counter = 0
paren_nesting_levels = 0
open_paren =  array('I')
open_paren =  [0] * 100000
close_paren = array('I')
close_paren = [0] * 100000

brace_check =  ""
brace_counter = 0
brace_check_counter = 0
brace_nesting_levels = 0
function_call_number = 0
number_of_functions = 0
open_brace =  array('I')
open_brace =  [0] * 100000
close_brace = array('I')
close_brace = [0] * 100000
function_return_stack = array('I')
function_return_stack = [0] * 256
function_return_top = 0

# define functions
def printable(n):
   if((n>31 and n<127) or n == 10):
       return(True)
   else:
       return(False)

def find_open_bracket(x):
   return(open_bracket[close_bracket.index(x)])

def find_close_bracket(x):
   return(close_bracket[open_bracket.index(x)])

def find_open_paren(x):
   return(open_paren[close_paren.index(x)])

def find_close_paren(x):
   return(close_paren[open_paren.index(x)])

def find_open_brace(x):# functions
   return(open_brace[close_brace.index(x)])

def find_close_brace(x):
   return(close_brace[open_brace.index(x)])

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("|")
   #                 print out stack
   if(top > 0):
       print()
       for i in range(top):
           print('{:03d}'.format(i), '{:03d}'.format(stack[i]))

def prog_data():
    print("\ntotal commands: ", tc - prog_mem.count("!"))
    print("total steps: ", steps)
    print("bracket nesting levels: ", nesting_levels)
    print("total bracket pairs: ", bracket_counter)
    print("parenthesis nesting levels: ", paren_nesting_levels)
    print("total parenthesis pairs: ", paren_counter)
    print("number of functions: ", number_of_functions)

f = open(input("file name:"), 'r')

while True:
   nextch = f.read(1)
   if(not nextch):
       f.close()
       break

   if(nextch in command_set):
       prog_mem += (nextch)

tc = len(prog_mem)

#Pre-Processing#################################################
#print(prog_mem)
####################Brackets####################################
# check bracket integrity
for i in range(tc):
    if(prog_mem[i] == "["):
        bc_counter += 1
        nesting_levels = max(bc_counter, nesting_levels)
    elif(prog_mem[i] == "]"):
        bc_counter -= 1
    if(bc_counter < 0):
        print("Grawlix Error: Bracket mismatch")
        quit()
if(bc_counter != 0):
   print("Grawlix Error: Bracket mismatch")
   quit()
# calculate bracket locations
for i in range(tc):
   if(prog_mem[i] == '['):
       top += 1
       stack[top] = i
   elif(prog_mem[i] == ']'):
       close_bracket[bracket_counter] = i
       open_bracket[bracket_counter] = stack[top]
       top -= 1
       bracket_counter += 1
# print out arrays of open/close bracket locations (debugging)
'''
for i in range(bracket_counter):
   print(i, ": ", open_bracket[i], close_bracket[i])
'''

###################Parenthesis##################################
# check parenthesis integrity
for i in range(tc):
    if(prog_mem[i] == "("):
        paren_check_counter += 1
        paren_nesting_levels = max(paren_check_counter, paren_nesting_levels)
    elif(prog_mem[i] == ")"):
        paren_check_counter -= 1
    if(paren_check_counter < 0):
        print("Grawlix Error: Parenthesis mismatch")
        quit()
if(paren_check_counter != 0):
   print("Grawlix Error: Parenthesis mismatch")
   quit()
# calculate parenthesis 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 parenthesis locations (debugging)
'''
for i in range(paren_counter):
   print(i, ": ", open_paren[i], close_paren[i])
'''
###################Functions####################################
# check function integrity
for i in range(tc):
    if(prog_mem[i] == "{"):
        number_of_functions += 1
        brace_check_counter += 1
        brace_nesting_levels = max(brace_check_counter, brace_nesting_levels)
    elif(prog_mem[i] == "}"):
        brace_check_counter -= 1
    if(brace_check_counter < 0):
        print("Grawlix Error: Brace mismatch")
        quit()
if(brace_check_counter != 0):
   print("Grawlix Error: Parenthesis mismatch")
   quit()
# calculate function locations
for i in range(tc):
   if(prog_mem[i] == '{'):
       top += 1
       stack[top] = i
   elif(prog_mem[i] == '}'):
       close_brace[brace_counter] = i
       open_brace[brace_counter] = stack[top]
       top -= 1
       brace_counter += 1
# print out open/close brace arrays (debugging)

for i in range(brace_counter):
   print(i, ": ", open_brace[i], close_brace[i])

# run program  #################################################
while(pc < len(prog_mem)):
    if(prog_mem[pc] == "+"):
        data_mem[p] = (data_mem[p] + 1) % 256
        pc += 1
        steps += 1

    elif(prog_mem[pc] == "-"):
        data_mem[p] = (data_mem[p] - 1) % 256
        pc    += 1
        steps += 1

    elif(prog_mem[pc] == ">"):
        p     += 1
        high_p = max(p, high_p)
        pc    += 1
        steps += 1

    elif(prog_mem[pc] == "<"):
        p     -= 1
        if(p < 0):
            print("Grawlix Error: Data Pointer Underflow")
            quit()
        pc    += 1
        steps += 1

    elif(prog_mem[pc] == "."):
        if(printable(data_mem[p])):
            print(chr(data_mem[p]), end = "")
        pc    += 1
        steps += 1

# enter one char at a time, or several
# they will be used as needed
# use one more prompt to enter (cr) for EOF
    elif(prog_mem[pc] == ","):
        if(input_buffer == ""):
            input_buffer = input(": ")
        if(input_buffer == ""):# still empty - (cr) entered
            data_mem[p] = 0
        else:
            key_press = input_buffer[0]
            input_buffer = input_buffer[1:]
            data_mem[p] = ord(key_press)
        pc    += 1
        steps += 1

    elif(prog_mem[pc] == "["):
        steps += 1
        if(data_mem[p] == 0):
            pc = close_bracket[open_bracket.index(pc)] + 1
        else:
            pc += 1

    elif(prog_mem[pc] == "]"):
        steps += 1
        pc = open_bracket[close_bracket.index(pc)]

# Grawlix commands #############################################
    elif(prog_mem[pc] == "|"):# left shift
        data_mem[p] = (data_mem[p] << 1) % 256
        pc += 1
        steps += 1

    elif(prog_mem[pc] == "/"):# right shift
        data_mem[p] = data_mem[p] >> 1
        pc += 1
        steps += 1

    elif(prog_mem[pc] == ":"):# push
        stack[top] = data_mem[p]
        top += 1
        top_max = max(top, top_max)
        pc += 1
        steps += 1

    elif(prog_mem[pc] == ";"):# pop
        top -= 1
        if(top < 0):
            print("Grawlix Error: Stack Underflow")
            quit()
        data_mem[p] = stack[top]
        pc += 1
        steps += 1

    elif(prog_mem[pc] == "?"):# input decimal number
        data_mem[p] = int(input("Enter Decimal Number: ")) % 256
        pc += 1
        steps += 1

    elif(prog_mem[pc] == "="):# output decimal number
        print('{:03d}'.format(data_mem[p]), end = "")
        pc += 1
        steps += 1

    elif(prog_mem[pc] == "^"):# stop
        print("\nGrawlix Command Stop")
        pc += 1
        steps += 1
        dump(p)
        prog_data()
        quit()

    elif(prog_mem[pc] == "("):
        steps += 1
        if(data_mem[p] == 0):
            pc += 1
        else:
            pc = close_paren[open_paren.index(pc)] + 1

    elif(prog_mem[pc] == ")"):
        steps += 1
        pc = open_paren[close_paren.index(pc)]

    elif(prog_mem[pc] == "{"):# skip function code
        pc = close_brace[open_brace.index(pc)] + 1
        steps += 1

    elif(prog_mem[pc] == "}"):
        function_return_top -= 1
        pc = function_return_stack[function_return_top]
        steps += 1

    elif(prog_mem[pc] == "@"):
        steps += 1
        function_return_stack[function_return_top] = pc + 1
        function_return_top += 1
        top -= 1
        function_call_number = stack[top]
        if(function_call_number > (number_of_functions - 1)):
            print("Grawlix Error: No Function", function_call_number)
            quit()
        else:
            pc = open_brace[function_call_number] + 1

    elif(prog_mem[pc] == "!"):
        pc += 1
        dump(p)

    elif(prog_mem[pc] == "#"):
        pc += 1
        dump(p)
        temp = input("Pause")

# print out program data
prog_data()