def __init__(self, filepath, vm_writer):
self.wf = open(filepath[:-5] + ".myImpl.xml", 'w')
self.tokenizer = JackTokenizer(filepath)
self.symbol_table = SymbolTable()
self.vmw = vm_writer
self.compiled_class_name = None
self.label_num = 0
def __init__(self, jack_file):
self.vm_writer = VMWriter(jack_file)
self.tokenizer = JackTokenizer(jack_file)
self.symbol_table = SymbolTable()
self.if_index = -1
self.while_index = -1
def __init__(self, jack_file, vm_file):
self._jack_tokenizer = JackTokenizer(jack_file)
self._vm_file = vm_file
self._vm_text = ''
self._xml_text = ''
self._symbol_table = SymbolTable()
self._vm_writer = VmWriter(self._vm_file)
self._class_name = None
self._label_count = 0
self._compiled_class_name = ''
def __init__(self, input_file, output_file):
self.tokenizer = JackTokenizer(input_file)
self.out = open(output_file, 'w')
self.token = None
self.class_name = None
#######################
### PROJECT 11 CODE ###
#######################
self.symbol_table = SymbolTable()
self.vm_writer = VMWriter(output_file)
def compile(self, input_file, output_file):
self._tokenizer = JackTokenizer(input_file)
self._output_file = output_file
self._offset = 0
while self._tokenizer.has_more_tokens:
if self._tokenizer.advance() == VALID_TOKEN:
if self._tokenizer.current_token == 'class':
tag = 'class'
self._open_tag(tag)
self._compile_class()
self._close_tag(tag)
else:
line_n = self._tokenizer.line_number
raise Exception(
f"Class declaration expected. Line {line_n}")
def main():
if len(sys.argv) != 2:
print(
"Expected 1 argument (either the .jack file or a directory containing .jack files). Exiting!"
)
return
is_file_arg = sys.argv[1].endswith(".jack")
if is_file_arg:
jack_files = [sys.argv[1]]
else:
jack_files = [
join(sys.argv[1], f) for f in listdir(sys.argv[1])
if f.endswith(".jack")
]
for jack_file in jack_files:
ce = CompilationEngine(JackTokenizer(jack_file),
jack_file.split(".jack")[0] + "Nisarg.xml")
ce.compile()
def build_tokenizer(self):
self.tokenizer = JackTokenizer(self.jack_input)
from sys import argv
# For handling file/dir paths
from pathlib import Path
# Import Analyzer components
from compilation_engine import CompilationEngine
from jack_tokenizer import JackTokenizer
# Get input path
in_path = Path(argv[1])
if in_path.is_file():
# Path points to a file
# Initialize tokenizer
tokenizer = JackTokenizer(in_path)
# Initialize compilation engine
compilationEngine = CompilationEngine(tokenizer,
in_path.with_suffix(".xml"))
# Start compilation
compilationEngine.start_compilation()
elif in_path.is_dir():
# Path points to a directory
for item in in_path.iterdir():
if item.is_file():
# Compile every jack file
if item.suffix == ".jack":
tokenizer = JackTokenizer(item)
ci = CompilationEngine(tokenizer, item.with_suffix(".xml"))
def __init__(self, source_filepath):
self.source_path = source_filepath
self.tokenizer = JackTokenizer(self.source_path)
self.class_name = None
self.syntax_tree_root = self.compile_class()
def tokenize(self, code, outfile):
tokenizer = JackTokenizer(code)
CompilationEngine(tokenizer, outfile).compile()
def __init__(self, input_file_path, vm_writer: VMWriter):
self.jack_tokenizer = JackTokenizer(input_file_path)
self.symbol_table = SymbolTable()
self.vm_writer = vm_writer
if self.jack_tokenizer.has_more_tokens():
self.compile_class()
def __init__(self, filepath):
self.wf = open(filepath[:-5] + ".my.xml", 'w')
self.tokenizer = JackTokenizer(filepath)
import glob
import sys
from pathlib import Path, PurePath
from os.path import isfile, isdir, join
from jack_tokenizer import JackTokenizer
from compilation_engine import CompilationEngine
if __name__ == '__main__':
if len(sys.argv) > 1:
program_path = sys.argv[1]
if isfile(program_path):
files = [program_path]
output_path = Path(program_path).parent
elif isdir(program_path):
files = glob.glob(join(program_path, '*.jack'))
output_path = program_path
else:
raise FileNotFoundError("[Errno 2] No such file or directory: ", program_path)
for file in files:
output_file_name = PurePath(file).name.split('.')[0] + '.vm'
output_file = Path(output_path, output_file_name)
file_tokenizer = JackTokenizer(file)
CompilationEngine(file_tokenizer, output_file)
else:
raise TypeError("1 argument is required: program path, 0 arguments entered")
def __init__(self, input_file_path, output_file_path):
self.output_file = open(output_file_path, 'w')
self.jack_tokenizer = JackTokenizer(input_file_path)
if self.jack_tokenizer.has_more_tokens():
self.compile_class()
def __init__(self, jack_file, xml_file):
self._jack_tokenizer = JackTokenizer(jack_file)
self._xml_file = xml_file
self._xml_text = ''
def analyze(self):
for filename in self.files_to_translate:
tokenizer = JackTokenizer(filename)
compiler = CompilationEngine(tokenizer.tokens)
self.__write_out(filename, compiler.xml_output)
