def __init__(self):
# initialize the symbol table (for ids -> values)
self.sym_table = sym_tbl.SymbolTable()
# holds the type of last expression type
self.current_value = None
# the heap {oid:struct_obj}
self.heap = {}
def __init__(self):
# initialize the symbol table (for ids -> types)
self.sym_table = symbol_table.SymbolTable()
# current_type holds the type of the last expression type
self.current_type = None
# global env (for return)
self.sym_table.push_environment()
# set global return type to int
self.sym_table.add_id('return')
self.sym_table.set_info('return', token.INTTYPE)
# load in built-in function types
self.sym_table.add_id('print')
self.sym_table.set_info('print', [[token.STRINGTYPE], token.NIL])
self.sym_table.add_id('length')
self.sym_table.set_info('length', [[token.STRINGTYPE], token.INTTYPE])
self.sym_table.add_id('get')
self.sym_table.set_info('get', [[token.INTTYPE, token.STRINGTYPE], token.STRINGTYPE])
self.sym_table.add_id('reads')
self.sym_table.set_info('reads', [[token.NIL], token.STRINGTYPE])
self.sym_table.add_id('readi')
self.sym_table.set_info('readi', [[token.NIL], token.INTTYPE])
self.sym_table.add_id('readf')
self.sym_table.set_info('readf', [[token.NIL], token.FLOATTYPE])
self.sym_table.add_id('itos')
self.sym_table.set_info('itos', [[token.INTTYPE], token.STRINGTYPE])
self.sym_table.add_id('itof')
self.sym_table.set_info('itof', [[token.INTTYPE], token.FLOATTYPE])
self.sym_table.add_id('ftos')
self.sym_table.set_info('ftos', [[token.FLOATTYPE], token.STRINGTYPE])
def action_11(self, prev_token):
self.is_global = True
# Delete local symbol table
self.local_table = symbol_table.SymbolTable(50)
self.current_function = None
self.backpatch(self.local_store, self.local_memory)
self.generate("free", self.local_memory)
self.generate("PROCEND")
def assemble(self, asms):
self.tokenizer = tokenizer.Tokenizer()
token_lines = [self.tokenizer.tokenize(asm) for asm in asms]
self.parser = parser.Parser()
parsed_lines = self.parser.parse(token_lines)
self.symbol_table = symbol_table.SymbolTable()
self.symbol_table.generate(parsed_lines)
self.generator = generator.Generator()
codes = self.generator.generate(parsed_lines, self.symbol_table)
return codes
def __init__(self, jack_tokenizer, output):
"""
constructor for compilation engine
"""
self.tokenizer = jack_tokenizer
self.writer = vm_writer.VMWriter(output)
self.symbol_table = symbol_table.SymbolTable()
self.class_name = ""
self.function_name = ""
def main(args):
try:
inFilename = parseArgs(args)
with open(inFilename) as file:
symbolTable = st.SymbolTable()
text = file.read()
tokens, tokenTypes = lexer.genTokenStream(text)
try:
wp = parser.WibblyParser()
wp.parse(tokens, symbolTable)
except parser.SyntaxValidException as e:
print('Syntax Valid')
except parser.SyntaxInvalidException as e:
print('Syntax Error')
except IOError as err:
print(err)
def main():
#Get the filename supplied by command line argument
#Rework to allow for multiple asm files to be processed at the same time
file_name = sys.argv[1]
#Check that the file provided is a .asm file. Raise exception if not
extension = file_name.split('.')[-1]
if extension != 'asm':
raise ValueError("Wrong filetype. Supply a .asm file")
sym_table = symbol_table.SymbolTable()
pass1(file_name, sym_table)
#Create a list of commands to be later exported to a .hack file
command_list = pass2(file_name)
write_to_hack_file(command_list, file_name)
def main(filename):
outputFilename = os.path.splitext(filename)[0]+".hack"
st = symbol_table.SymbolTable()
# First pass store all LABELS
p = parser.Parser(filename)
p.advance()
instructionCount = 0
while p.hasMoreCommands():
commandType = p.commandType()
if p.commandType() == command_types.L_COMMAND:
symbol = p.symbol()
st.addEntry(symbol, instructionCount)
else:
instructionCount += 1
p.advance()
# Second pass
n = 16
p = parser.Parser(filename)
p.advance()
while p.hasMoreCommands():
command = ""
if p.commandType() == command_types.A_COMMAND:
symbol = p.symbol()
address = ""
if st.contains(symbol):
address = st.getAddress(symbol)
elif symbol.isdigit():
address = symbol
else:
st.addEntry(symbol, n)
address = n
n += 1
command = format(int(address), '#018b')[2:]
elif p.commandType() == command_types.C_COMMAND:
command = "111" + code.comp(p.comp()) + code.dest(p.dest()) + code.jump(p.jump())
if bool(command):
with open(outputFilename, 'a') as outFile:
outFile.write(command+"\n")
p.advance()
def _parse_symbol_table():
"""Read symbol table from video player debug file."""
opcode_data = {}
for name, data in symbol_table.SymbolTable(
"player/iivision.dbg").parse().items():
if name.startswith("\"op_"):
op_name = name[4:-1]
start_addr = int(data["val"], 16)
opcode_data.setdefault(op_name, {})["start"] = start_addr
opcode_addrs = []
for op_name, addrs in opcode_data.items():
for op in OpcodeCommand:
if op.name.lower() != op_name:
continue
opcode_addrs.append((op, addrs["start"]))
return sorted(opcode_addrs, key=lambda x: x[1])
def CompileSubroutineDec(self, subroutine, env):
new_env = symbol_table.SymbolTable(env)
sub_type = subroutine.subroutine_type.keyword
return getattr(self,
"Compile" + sub_type.capitalize() + "Dec")(subroutine,
new_env)
def CompileVMCode(self, jack_program):
env = symbol_table.SymbolTable(None)
return os.linesep.join(self.CompileClass(jack_program, env))
def __init__(self):
self.symtab = symbol_table.SymbolTable()
def delayEval(curAddr):
symtab = symbol_table.SymbolTable()
symtab.insert(".", curAddr)
self[1].replace_idents(symtab)
return self[1].eval()
def __init__(self):
self.semantic_stack = []
# True if in insertion mode in symbol table. False if in search mode in symbol table
self.is_insert = True
# True if in global environment. False if in local environment
self.is_global = True
# True if next variable should be treated as array. False if next variable is a simple variable (not array)
self.is_array = False
# Keeps track of number of global variable declarations
self.global_memory = 0
# Keeps track of number of local variable declarations
self.local_memory = 0
# self.local_table =
self.temp_var_num = 0
self.local_table = symbol_table.SymbolTable(50)
self.global_table = symbol_table.SymbolTable(50)
# Keeps track of alloc statement
self.global_store = 0
self.local_store = 0
self.quadruples = quadruple.Quadruples()
self.create_num = 0
# Initialize current function as None
self.current_function = None
# Initialization of constant table
self.constant_table = symbol_table.SymbolTable(50)
# Parameter count stack, where each element is the number of
# parameters of a function or procedures
self.param_count = []
# Parameter info stack, where each element is a list of symbol
# table entries representing the parameter info for a function
# or procedure
self.param_stack = []
# Keep track of the current index into the list on the
# top of param_stack
self.next_param = 0
self.valid_semantic_actions = [
1,
2,
6,
4,
7,
13,
9,
3,
55,
56,
# 30, 40, 42, 44, 31, 41, 46, 48
# 31, 41, 46, 48
30,
40,
42,
44,
31,
41,
46,
43,
45,
48,
32,
33,
34,
53,
54,
38,
39,
47,
22,
24,
25,
26,
27,
28,
29,
5,
11,
15,
16,
17,
19,
20,
21,
35,
51,
54,
36,
37,
49,
50,
52,
"51READ",
"51WRITE"
]
self.actions_tested = []
def test_parse(self):
dbg = io.StringIO(DEBUG_FILE)
s = symbol_table.SymbolTable()
self.assertEqual(
{"\"op_ack\"", "\"op_tick\"", "\"rle1\""}, s.parse(dbg).keys())
import analyzer
import symbol_table
table = symbol_table.SymbolTable()
rodata = "SECTION .rodata" + '\n'
data = "SECTION .data" + '\n'
bss = "SECTION .bss" + '\n'
text = dict()
text['functions'] = '\n' + "SECTION .text" + '\n'
text['functions'] += "EXTERN print_number, print_text, print_boolean" + '\n'
text['code'] = "global _start" + '\n'
text['code'] += "_start:" + '\n'
rodata_index = 0
data_index = 0
label_index = 0
loop_index = 0
builtin_functions = ['print']
def generate(node):
initialize_code()
generate_text(node, 'code')
terminate_code()
return rodata + data + bss + text['functions'] + text['code']
def __init__(self, tokens, writer, module_name):
self.tokens = tokens
self.symbols = symbol_table.SymbolTable()
self.writer = writer
self.module_name = module_name
class TypeChecker(NodeVisitor):
table = symbol_table.SymbolTable(None, 'program')
result_types = defaultdict(lambda :{
(types_.Int, types_.Int): types_.Int,
(types_.Int, types_.Float): types_.Float,
(types_.Float, types_.Int): types_.Float,
(types_.Float, types_.Float): types_.Float
})
result_types['.+'] = {(types_.Matrix, types_.Matrix): types_.Matrix}
result_types['.-'] = {(types_.Matrix, types_.Matrix): types_.Matrix}
result_types['./'] = {(types_.Matrix, types_.Matrix): types_.Matrix}
result_types['.*'] = {(types_.Matrix, types_.Matrix): types_.Matrix}
def __init__(self):
self.errors = False
def visit_ID(self, node):
symbol = self.table.get(node.id)
if not symbol:
return types_.Id()
return symbol.symbol_type
def visit_Number(self, node):
if node.type == 'integer':
return types_.Int()
return types_.Float()
def visit_Matrix(self, node):
if node.type == None:
return self.visit(node.content)
elif node.type == 'zeros':
node.matrix = [0 for i in range(node.dim)] * node.dim
elif node.type == 'ones':
node.matrix = [1 for i in range(node.dim)] * node.dim
elif node.type == 'eye':
node.matrix = [[1 if i == j else 0 for i in range(node.dim)] for j in range(node.dim)]
return types_.Matrix(node.dim, node.dim, types_.Int())
def visit_IDAt(self, node):
type_index1 = self.visit(node.index1)
type_index2 = self.visit(node.index2)
index1 = None
index2 = None
if not type_index1.is_integer:
print(f"Error in line {node.line}: first index is not an integer!")
else:
index1 = node.index1.value
if not type_index2.is_integer:
print(f"Error in line {node.line}: second index is not an integer!")
else:
index2 = node.index2.value
id = self.visit_ID(node)
if id.is_id():
print(f"Error in line {node.line}: variable {node.id} not known!")
elif not id.is_matrix():
print(f"Error in line {node.line}: variable {node.id} not a matrix!")
else:
if index1 < id.x and index2 < id.y:
return id.element_type()
else:
print(f"Error in line {node.line}: index out of bounds!")
return types_.Int()
def visit_Condition(self, node):
bool = self.visit(node.bool_expression)
if not bool.is_boolean():
print(f"Error in line {node.line}: Condition is not of boolean type!")
self.table.pushScope('condition')
self.visit(node.statement1)
self.table.popScope()
self.table.pushScope('condition')
self.visit(node.statement2)
self.table.popScope()
def visit_BinaryOperation(self, node):
right = self.visit(node.right)
left = self.visit(node.left)
if node.operator in ['.+', '.-', '.*', './']:
if left.is_matrix() and right.is_matrix() \
and (left.x != right.x or left.y != right.y):
print(f"Error in line {node.line}: Matrix binary operation require equal dimensions!")
return right
elif node.operator in ['+', '-', '*', '/']:
if not right.is_numeric():
print(f"Error in line {node.line}: {node.operator} require number arguments!")
return types_.Int()
if not left.is_numeric():
print(f"Error in line {node.line}: {node.operator} require number arguments!")
return types_.Int()
return TypeChecker.result_types[node.operator][(left.__class__,right.__class__)]()
def visit_UnaryOperation(self, node):
arg = self.visit(node.arg)
if node.operator == '\'':
if not arg.is_matrix():
print(f"Error in line {node.line}: Wrong transpose argument (of matrix type required)!")
else:
return types_.Matrix(-1,-1,None)
if node.operator == '.-':
if not arg.is_matrix():
print(f"Error in line {node.line}: Wrong .- argument (of matrix type required)!")
else:
return types_.Matrix(-1, -1, None)
if node.operator == '-':
if not arg.is_numeric():
print(f"Error in line {node.line}: Wrong - argument (of number type required)!")
return types_.Int()
else:
return arg
def visit_Assignment(self, node):
if not isinstance(node.left, entities.ID):
print(f"Error in line {node.line}: Left operand is not a variable!")
return
right = self.visit(node.right)
if node.operator == '=':
self.table.put(node.left.id, symbol_table.VariableSymbol(right, node.right))
return
if node.operator != '=':
id = self.table.get(node.left.id)
if not id:
print(f"Error in line {node.line}: Unknown variable!")
if not id.symbol_type.is_numeric():
print(f"Error in line {node.line}: Such assignment requires right arg of number type!")
return
def visit_Relation(self, node):
left = self.visit(node.left)
if not left.is_numeric():
print(f"Error in line {node.line}: left operand of relation is not numeric!")
right = self.visit(node.right)
if not right.is_numeric():
print(f"Error in line {node.line}: right operand of relation is not numeric!")
return types_.Boolean()
def visit_WhileLoop(self, node):
expr = self.visit(node.expr)
if not expr.is_boolean():
print(f"Error in line {node.line}: while condition has to be of boolean type!")
self.table.pushScope('loop')
prog = self.visit(node.prog)
self.table.popScope()
def visit_ForLoop(self, node):
self.table.pushScope('loop')
beg = self.visit(node.beg)
end = self.visit(node.end)
if not beg.is_integer():
print(f"Error in line {node.line}: Beginning value of iterator has to be an integer!")
if not end.is_integer():
print(f"Error in line {node.line}: End value of iterator has to be a number!")
self.visit(node.prog)
self.table.popScope()
def visit_Print(self, node):
self.visit(node.list)
def visit_Program(self, node):
self.visit(node.statement)
self.visit(node.program)
def visit_List(self, node):
length = len(node.get_value())
types = []
for n in node.get_value():
types.append(self.visit(n))
diff = False
for i in range(length - 1):
if type(types[i]) != type(types[i + 1]):
diff = True
if diff:
return types_.List(length, None)
return types_.List(length, types[0])
def visit_List2D(self, node):
list_of_vectors = node.get_value()
list_of_length = []
list_of_type = []
for vector in list_of_vectors:
l_type = self.visit(vector)
list_of_length.append(l_type.length)
list_of_type.append(l_type.element_type)
ok = True
diff = False
for i in range(len(list_of_length) - 1):
if list_of_length[i] != list_of_length[i + 1]:
ok = False
if type(list_of_type[i]) != type(list_of_type[i + 1]):
diff = True
if None in list_of_type:
diff = True
if not ok:
print(f"Error in line {node.line}: Vectors of different lengths!")
if diff:
print(f"Error in line {node.line}: All variables in a matrix has to be of one type!")
return types_.Matrix(len(list_of_length), list_of_length[0], types_.Int())
return types_.Matrix(len(list_of_length), list_of_length[0], list_of_type[0])
def visit_Empty(self, node):
return 'empty'
def visit_Break(self, node):
if not self.table.is_inside_loop():
print(f"Error in line {node.line}: Break outside a loop")
return 'break'
def visit_Contnue(self, node):
if not self.table.is_inside_loop():
print(f"Error in line {node.line}: Continue outside a loop")
return 'continue'
def visit_Return(self, node):
if node.variable:
n_type = self.visit(node.variable)
if n_type not in ['integer', 'float', 'boolean'] and not 'matrix' in n_type:
print(f"Error in line {node.line}: Wrong returned type!")
return 'return'
