def create_structure(self, hash_table, match, list):
hash_t = symboltable.SymbolTable()
hash_t.add_upper_scope(hash_table)
hash_t.concatenate_scopes(hash_table._upper_scopes)
hash_table.insert((match[1]), (match[0], hash_t))
data_type = ''
to_return = None
while list:
match = list.pop(0)
if match[1] == RETURN:
return list.pop(0)
if match[1] == BRACKET:
break
if self._is_data_type(match[1]):
data_type = match[1]
elif self._is_structure(match[1]):
to_return = self.create_structure(hash_t, match, list)
data_type = ''
elif data_type:
self._insert(match[0], match[1], data_type, hash_t)
data_type = ''
elif not self._is_do_not_care(match[1]):
if not self._lookup(match[1], hash_t):
self._error_switch(symboltable.NOT_DEC, match[1], match[0])
return to_return
def evaluate_function(self, name, data_type, list):
function_type = data_type
hash_table = symboltable.SymbolTable()
hash_table.add_upper_scope(self._main_scope)
values = (data_type, hash_table)
self._main_scope.insert(values, name)
while list:
valor = list.pop(0)
variable = valor[1]
if variable == RETURN:
self._check_return_func(hash_table,
list.pop(0)[1], valor[0],
function_type, name)
if variable is not BRACKET:
if self._is_data_type(variable):
data_type = variable
elif data_type and not self._is_data_type(
variable) and not self._is_do_not_care(
variable) and not self._is_structure(variable):
# A usar:
self._insert(valor[0], variable, data_type, hash_table)
data_type = ''
# Álvaro : hash_table.insert(datatype, variable)
elif self._is_structure(variable):
return_ = self.create_structure(hash_table, valor, list)
if return_ is not None:
self._check_return_func(hash_table, return_[1],
return_[0], function_type,
name)
elif not self._is_do_not_care(variable):
if not self._lookup(variable, hash_table):
self._error_switch(symboltable.NOT_DEC, variable,
valor[0])
else:
break
def __init__(self, tokens):
"""'tokens' should be a generator expression."""
self.tokens = tokens
next = self.tokens.next()
self.next_token = next[1]
self.next_type = next[0]
self.symbols = symboltable.SymbolTable()
self.code = []
def __init__(self, tokenizer, out_file_path):
self.tokenizer = tokenizer
self.tokenizer.advance()
#self.out_file = out_file
self.symboltable = symboltable.SymbolTable()
self.vmwriter = VmWriter(out_file_path)
self.class_name = ''
self.fn_info = {}
self.label_count = 0
Type, \
Block, \
AssignStmt, \
IfStmt, \
WhileStmt, \
ReturnStmt, \
LValue, \
IntLiteral, \
FloatLiteral, \
Operator, \
ArithExpr, \
FuncCall, \
CondExpr
from common import Variable, InputError
s = symboltable.SymbolTable()
lib = None
def setLibAST(libAST):
global lib
lib = libAST
def initLib(node):
if isinstance(node, Function):
var = Variable(node.name.name, node.type, node)
try:
s.insertVariable(var)
except InputError as err:
print(format(err) + ": " + node.name.name)
import time
beginning = time.time()
count = 0
""" FIRST PASS: Traverse parse, fill SYMBOL_TABLE with labels """
FILENAME = os.path.dirname(os.path.realpath(__file__))+"/"+str(sys.argv[1])
try:
file = parser.Parser(FILENAME)
except:
print "File \"" + sys.argv[1] + "\" does not exist."
sys.exit()
SYMBOL_TABLE = symboltable.SymbolTable()
rom_counter = 0
RAM_ADDRESS = 15
""" if A or C command advance, if L add to table """
while file.has_more_commands():
file.advance()
command_type = file.command_type()
if command_type is "L_COMMAND":
SYMBOL_TABLE.add_entry(file.symbol(), rom_counter)
else:
rom_counter += 1
def __init__(self, tokenizer, out_file):
self.tokenizer = tokenizer
self.tokenizer.advance()
self.out_file = out_file
self.symboltable = symboltable.SymbolTable()
def __init__(self):
self.scope = symboltable.SymbolTable(None, "Main")
self.return_code = 0
def setUp(self):
self.symboltable = symboltable.SymbolTable()
def __init__(self, file_path):
self._error_string = ''
self._main_scope = symboltable.SymbolTable()
self._open_file(file_path)