#! /usr/bin/env python3

import sys

def hilfe():
    print('\nBenutzung: bon2bma [-opt] [*.bon], opt = d,b,h\n')
    
argn = len(sys.argv)
if argn == 1:
    opt = '-d'
    inhalt = sys.stdin.read()
elif argn == 2:
    if sys.argv[1][0] == '-':
        opt = sys.argv[1]
        inhalt = sys.stdin.read()
    else:
        try:
            opt = '-d'
            datei = open(sys.argv[1],'r')
            inhalt = datei.read()
            datei.close()
        except:
            hilfe()
            raise
elif argn == 3:
    if sys.argv[2][0] == '-':
            sys.argv[1],sys.argv[2] = sys.argv[2],sys.argv[1] 
    opt = sys.argv[1]
    if not opt in ['-d','-b','-h']:
        hilfe()
        raise
    else:
        try:
            datei = open(sys.argv[2],'r')
            inhalt = datei.read()
            datei.close()
        except:
            hilfe()
            raise
        
import ply.lex as lex

reserved = {'inc'   : 'INC',
            'dec'   : 'DEC',                 
            'jmp'   : 'JMP',
            'tst'   : 'TST',
            'hlt'   : 'HLT'}

tokens = ['VAR','NUMBER'] + list(reserved.values())

literals = '=()#'                         

def t_VAR(t):
    r'[a-zA-Z_][a-zA-Z_0-9]*'
    t.type = reserved.get(t.value,'VAR')  # get gibt Wert aus Dictionary zurueck, 
    return t                              # wenn nicht gefunden 'VAR'

def t_NUMBER(t):
    r'[+\-]?\d+'
    t.value = int(t.value)    
    return t

def t_newline(t):
    r'\n+'
    t.lexer.lineno = t.lexer.lineno + len(t.value)

t_ignore  = ' \t'

def t_error(t):
    print('Unerwartetes Zeichen:',t.value[0],',Zeile:',s.lineno)
    t.lexer.skip(1)

s = lex.lex()

import ply.yacc as yacc

dat = {}    # Datenspeicher
mem = []    # Programmspeicher
reg = []    # Registernummer --> Variablenname

def p_0(p):
    'bon : befehl bon'

def p_1(p):
    'bon :'

def p_2(p):
    'befehl : inc'

def p_3(p):
    'befehl : dec'

def p_4(p):
    'befehl : jmp'

def p_5(p):
    'befehl : tst'

def p_6(p):
    'befehl : zuw'

def p_7(p):
    'befehl : reg'

def p_8(p):
    'befehl : HLT'

def p_9(p):
    'inc : INC VAR'
    global mem
    mem = mem + [(p[1],p[2])]

def p_10(p):
    'inc : INC NUMBER'
    global mem
    mem = mem + [(p[1],p[2])]

def p_11(p):
    'dec : DEC VAR'
    global mem
    mem = mem + [(p[1],p[2])]

def p_12(p):
    'dec : DEC NUMBER'
    global mem
    mem = mem + [(p[1],p[2])]
    
def p_13(p):
    'jmp :  JMP NUMBER'
    global mem
    mem = mem + [('jmpabs',p[2])]

def p_14(p):
    "jmp :  JMP '(' NUMBER ')'"
    global mem
    mem = mem + [('jmprel',p[3])]

def p_15(p):
    'tst : TST VAR'
    global mem
    mem = mem + [(p[1],p[2])]

def p_16(p):
    'tst : TST NUMBER'
    global mem
    mem = mem + [(p[1],p[2])]

def p_17(p):
    "zuw : VAR '=' NUMBER"
    global dat
    dat.update({p[1]:p[3]})
    global reg
    reg.append(p[1])

def p_18(p):
    "reg : '#' NUMBER VAR"
    global dat
    dat.update({p[3]:p[2]})
    global reg
    reg.append(p[3])

def p_error(p):
    print('Syntaxfehler in Zeile:',s.lineno)

p = yacc.yacc(debug=0)

p.parse(inhalt)
mem = mem + [('hlt',None)]

d = []
b = []
h = []
n = len(mem)
# Befehle
for i in range(n):
    op = mem[i][0]
    ad = mem[i][1]
    if op == 'inc':
        r = n+ad
        opd = '1'
        opb = '00'
    elif op == 'dec':
        r = n+ad
        opd = '2'
        opb = '01'
    elif op == 'jmpabs':
        r = ad - 1
        opd = '3'
        opb = '10'
    elif op == 'tst':
        r = n+ad
        opd = '4'
        opb = '11'
    elif op == 'hlt':
        r = i
        opd = '5'
        opb = '10'
    else:
        print('Fehler')
        raise(Exception)
    d.append(opd+str(r).zfill(4))
    binbef = opb+bin(r)[2:].zfill(6) 
    b.append(bin(i)[2:].zfill(8)+'   '+binbef)
    h.append(hex(i)[2:].zfill(4)+':'+hex(int(binbef,2))[2:].zfill(2))
# Luecke
i = i + 1
d.append('    0')
b.append(bin(i)[2:].zfill(8)+'   '+'       0')
h.append(hex(i)[2:].zfill(4)+':'+'xx')
# Daten
for j in range(len(reg)):
    reginhalt = dat[reg[j]]
    d.append(str(reginhalt).rjust(5))
    b.append(bin(i+1+j)[2:].zfill(8)+'   '+bin(reginhalt)[2:].zfill(8))
    h.append(hex(i+1+j)[2:].zfill(4)+':'+hex(reginhalt)[2:].zfill(2))
# Ausgabe
if opt == '-d':
    feld = d
elif opt == '-b':
    feld = b
elif opt == '-h':
    feld = h
for item in feld:
    print(item)