def __init__(self, input_filename, output_file=None):
self.input_filename = input_filename
self.output_file = output_file
self.symbol_table = SymbolTable.SymbolTable()
self.subtoutine_name = ''
self.subroutine_type = ''
self.class_name = ''
self.if_index = 0
self.while_index = 0
self.var_number = 0
self.in_xml = xml.dom.minidom.parse(self.input_filename)
self.input_child_node_idx = 1
self.vm_writer = VMWriter.VMWriter(input_filename[:-5])
self.current_token = self.in_xml.documentElement.childNodes[
self.input_child_node_idx]
self.doc = xml.dom.minidom.Document()
while self.current_token.nodeName == 'keyword' and self.current_token.childNodes[
0].nodeValue == 'class':
self.compile_class()
self.__save_xml()
pass
def __init__(self, tokenizer):
"""
Ctor
_writer: a VM writer object
_cur_class: the current class
_cur_func: the current function
_cur_func_type: the current function type
_subroutine_table: a symbol table of the subroutine
_class_table: a list of the symbols in the class
_tokenizer: the tokenizer object
_result: a list that is written in the output file
counters: the kind counters
label_counters: the label counters
"""
self._writer = VMWriter()
self._cur_class = None
self._cur_func = None
self._cur_func_type = None
self._subroutine_table = None
self._class_table = []
self._tokenizer = tokenizer
self._result = []
self.counters = {'static': 0, 'field': 0, 'argument': 0, 'local': 0}
self.label_counters = {"if": 0, "while": 0}
self.compileClass()
def __init__(self, inFile, outFile):
""" Creates a new CompilationEngine with given
input and output. The next routine called must
be compileClass() """
# Create an object of JackTokenizer with the input file
self.tokenizer = JackTokenizer.JackTokenizer(inFile)
# Create an object of SymbolTable
self.symbolTable = SymbolTable.SymbolTable()
# Create an object of VMWriter
self.vmWriter = VMWriter.VMWriter(outFile[:-3] + 'vm')
# Open a output file to write to
self.out = open(outFile, 'w')
self.currentToken = ''
self.currentTokenType = ''
self.tabs = 0
self.i = 0 # for creating unique labels
self.nfield = 0
self.nstatic = 0
self.__advance()
def __init__(self, jackTokenizerOutput, outfileName, outVMName):
'''
In: jackTokenizerOutput which is the array of tokens output by JackTokenizer.py
Function: Creates a new compilation engine with the given input and output.
The next routine called must be compileClass().
'''
self.tokenArray = jackTokenizerOutput
self.tokenIndex = 0
self.line = self.tokenArray[0] # first item of array is class
self.curToken = self.line.split()[
1] # the second item in a line is the token
self.curTokenType = self.line.split()[
0] # gets the first tag of the token
# set buffersize to 0
self.f1 = open(outfileName, 'a', 0)
# project 11 part: add Symbol table and VMWriter output
self.sTable = st.SymbolTable()
self.vm = vmw.VMWriter(outVMName)
# project 11 class variables
self.curClass = '' # name of the current class
self.whileCount = 0
self.ifCount = 0
def __init__(self, tokenizer, ostream, file_name_no_ext):
'''Initialize the compilation engine
@tokenizer the tokenizer from the input code file
@ostream the output stream to write the code to'''
self.tokenizer = tokenizer
self.vm_writer = VMWriter.VMWriter(ostream)
self.className = file_name_no_ext
def openXMLFile(self, xml_file):
self.xml_tree = ET.parse(xml_file)
self.tokens = list(self.xml_tree.getroot())
self.tokens.reverse()
self.st = SymbolTable()
self.current_class = xml_file[:-5]
self.vm = VMWriter(self.current_class + '.vm')
def __init__(self, jack_lines):
self._jack_lines = jack_lines
self._token = tk.JackTokenizer(jack_lines)
self._writer = vmw.VMWriter()
self._table = st.SymbolTable()
self._class = None
self._cur_subroutine_ret_type = None
def __init__(self, file):
self.lex = Lex(file)
self.symbols = SymbolTable()
self.vm = VMWriter()
self.openout(file)
self.compile_class()
self.closeout()
def __init__(self, tokens, file_path):
self.tokens = tokens
self.class_symboltable = SymbolTable()
self.subroutine_symboltable = SymbolTable()
self.cur_class = None
self.cur_subroutine_type = None # for the compile return function
self.vmwriter = VMWriter(file_path)
self.labelcounter = 0
def __init__(self, inputPath, outputPath):
self._jackTokenizer = JackTokenizer.JackTokenizer(inputPath)
if self._jackTokenizer.hasMoreTokens():
self._jackTokenizer.advance()
self._vmWriter = VMWriter.VMWriter(outputPath)
self._symbolTable = SymbolTable.SymbolTable()
self._currentClassName = ''
self._whileCount = self._ifCount = 0
def compile_file(jack_file_name, vm_file_name):
jack_file = open(jack_file_name, 'r')
tokenizer = Tokenizer.Tokenizer(jack_file)
symbol_table = SymbolTable.SymbolTable()
vm_file = open(vm_file_name, 'w')
vm_writer = VMWriter.VMWriter(vm_file)
compilation_engine = CompilationEngine(tokenizer, vm_writer, symbol_table)
compilation_engine.compile_class()
def main(self, to_parse):
# Files to parse consists of file path to parse and file name to write
files_to_parse = []
# print("to_parse", to_parse, to_parse[-4:])
# If file
if to_parse[-4:] == "jack":
for_parsing = self.get_files(to_parse)
files_to_parse.append(for_parsing)
# If directory
else:
get_path = self.get_file_path(to_parse)[1]
to_check = os.listdir(get_path)
for f in to_check:
if f[-4:] == "jack":
new_p = to_parse + "/" + f
for_parsing = self.get_files(new_p)
files_to_parse.append(for_parsing)
for f in files_to_parse:
# reset server for unit tests
self.reset(f[1], f[2], f[3])
# print("current f", f)
#
try:
t = T.Tokenizer()
# Read
with open(f[0]) as f1:
with open(f[2], 'a') as fw:
# Write Tokens file
T.Tokenizer.file_to_write = fw
for line in f1:
ln = t.remove_comments(line)
if ln:
t.make_tokens(ln)
# END
def end():
return "</tokens>"
fw.write(end())
vm = VMWriter.VMWriter()
vm.file_to_write = f[3]
c = C.Compiler()
c.vm = vm
# Write compiled code
with open(f[1], 'a') as fw:
c.tag_generator = XML_H.XMLHelper.read_xml_tags(f[2])
xml = c.compile_class()
xml_str = ET.tostring(xml,
encoding='unicode',
short_empty_elements=False)
fw.write(xml_str)
except IOError:
print("File or directory is missing")
def __init__(self, tokenizer):
self.tokenizer = tokenizer
self.output_file = open('temp', 'w')
self.CLASSES = []
self.classTable = symbolTable.SymbolTable()
self.subRoutineTable = symbolTable.SymbolTable()
self.vm_writer = VMWriter.VMWriter()
self.if_label_counter = 0
self.while_label_counter = 0
def __init__(self, inputFile, outputFile):
# self.outFile = outputFile
self.tokenizer = JackTokenizer(inputFile)
self.vmwriter = VMWriter(outputFile)
self.outFile = outputFile
self.currToken = ""
self.tabber = ""
self.argumentsCounter = 0
def translate_token(tokenized, root):
global index, output_file
vars_table.restart_table()
output_file = vm.VMWriter(root, tokenized[1])
index += 1
# class_name = tokenized[index] # name
index += 1
index += 1
inside_class(tokenized)
def __init__(self, input_file, xml_file, vm_file):
''' Initialize the xml file, the symbol table adn the VMwriter '''
super().__init__(input_file)
self.xml_file = xml_file
self.symbol_tab = SymbolTable()
self.vm_writer = VMWriter(vm_file)
self.subroutine_type = None
self.if_label, self.while_label = 0, 0
self.isarray = None
def __init__(self, file_in, file_out):
'''
Creates a new compilation engine with the given input and output.
Input: file_in (string), file_out (string)
'''
self.tokenizer = JackTokenizer.JackTokenizer(file_in)
self.symbol_table = SymbolTable.SymbolTable()
self.vm_writer = VMWriter.VMWriter(file_out)
self.class_name = ''
self.idx = 0
def __init__(self, tokenizer, outputFile):
self.XMLCode = []
self.CodeIndent = 0
self.tokenizer = tokenizer
self.symbolTable = SymbolTable()
self.vmWriter = VMWriter(outputFile)
self.class_name = None
self.segment_local_dict = segment_dict
self.while_count = 0
self.if_count = 0
def __init__(self, input, output):
"""
creates a new compilation engine with
the given input and output.
"""
self.tokenizer = JackTokenizer.JackTokenizer(input)
self.writer = VMWriter.VMWriter(output)
self.symbolTable = SymbolTable.SymbolTable()
self.className = ''
self.name = ''
def __init__(self, tokenizer, output):
"""Creates a new compilation engine with the given input and output.
The next routine called must be compileClass(). """
self.tokenizer = tokenizer
self.tags = []
self.scope = 0
self.writer = VMWriter(output)
self.class_table = SymbolTable()
self.method_table = SymbolTable()
self.class_name = ''
self.method_or_constructor = False
def __init__(self, input, output):
"""
:param input: input file name
:param output: output file name whhere the text will be written
"""
self.tokenizer = Tokenizer.Tokenizer(input)
self.writer = VMWriter.VMWriter(output)
self.symbolTable = SymbolTable.SymbolTable()
self.classname = ""
self.name = ""
def __init__(self, tokenizedArray):
self.tokenizedArray = tokenizedArray
self.tokenizedArraySize = len(tokenizedArray)
self.curIndex = 0
self.indentLevel = 0
self.compiledArray = []
self.INDENT_SIZE = 2
self.className = ''
self.labelsCounter = 0
self.symbolsTable = SymbolTable.SymbolsTable()
self.VMWriter = VMWriter.VMWriter()
def __init__(self, input_file, output_file):
"""
与えられた入力と出力に対して新しいコンパイルエンジンを生成する
次に呼ぶルーチンは compileClass() でなければならない
str, str -> void
"""
self.j = JT.JackTokenizer(input_file)
self.s = ST.SymbolTable()
self.v = VMW.VMWriter(output_file)
self.class_name = ''
def __init__(self, input_path, output_path):
"""
creates a new compilation engine with the given input and output. the next routine called must be compileClass()
:param input_path: input stream/file
:param output_path: output stream/file
"""
self.labels = 0
self.jack_class = None
self.class_subroutine = None
self.tokenizer = JackTokenizer(input_path)
self._writer = VMWriter(output_path)
self.CompileClass()
def __init__(self, file):
""" """
self.label_num = 0
self.tokenizer = JackTokenizer(file)
self.advance()
self.symbols = SymbolTable()
self.vm = VMWriter()
self.open_outfile(file)
self.compile_class()
self.close_outfile()
def __init__(self, infile, outfile):
self.className = ""
self.symbolTable = SymbolTable.SymbolTable()
self.tokenizer = jackTokenizer(infile)
self.writer = VMWriter.VMWriter(outfile)
self.indent = ""
## self.mStack =[] #a stack to store all non terminal blocks opened which have to be closed
self.keywordConsts = {'true', 'false', 'null', 'this'}
self.binaryOp = {'+', '-', '*', '|', '<', '>', '=', '/', '&'}
self.unaryOp = {'-', '~'}
self.function_type = ""
self.is_unary = False
def __init__(self, filename):
"""
constructor, creates a new compilation engine with the given input
:param filename: the input file name
"""
self._tokenizer = JackTokenizer.JackTokenizer(filename)
self._className = filename.split('/')[-1].split('.')[0]
self._filenameVM = filename.split('.')[0] + '.' + co.NEW_SUFFIX
self._vmWriter = vm.VMWriter(self._filenameVM)
self._simba = st.SymbolTable()
self._ifCount = 0
self._whileCount = 0
def __init__(self, input_file, tokenizer):
self.indent_level = 0
self.tokenizer = tokenizer
self.symbol_table = SymbolTable.SymbolTable()
self.label_count = 0
self.vm_output_path = input_file.replace('.jack', '.vm')
self.writer = VMWriter.VMWriter(self.vm_output_path, 'w')
self.xml_output = open(input_file.replace(
'.jack', '.xml'), 'w')
self.compileClass()
self.xml_output.close()
def compileJack(jackFile):
outputFilename = os.path.splitext(jackFile)[0] + ".vm"
t = Tokenizer.Tokenizer(jackFile)
vmw = VMWriter.VMWriter(outputFilename)
ce = CompilationEngine.CompilationEngine(t, vmw)
t.advance()
if t.keyword() != "class":
print("jack file does not have a class!")
exit(1)
ce.CompileClass()
vmw.close()
def __init__(self, in_file, out_file):
"""
A compilation engine constructor
:param in_file: the file we are currently compiling
:param out_file: the file where we save the output
"""
self._tokenizer = JackTokenizer(in_file)
self._class_table = SymbolTable()
self._method_table = SymbolTable()
self._cur_class_name = ""
self._vm_writer = VMWriter(out_file)
self._label_count_while = 0
self._label_count_if = 0
