def __processFile__(self, filePath):
''' processes a single file, first feeding the file to JackTokenizer to generate a list of tokens
(output as T.xml files for debugging use) and that token list is fed through
CompilationEngine to generate a final result list of XML tokens which is output into an .xml file. '''
#TODO make it work
# create opening token tag for tokenizing lines of .jack
tokens = ["<tokens>"]
tokenizer = JackTokenizer(filePath)
line = tokenizer.advance()
# tokenize each line of .jack
while line:
tokens += [self.__wrapTokenInXML__(line)]
line = tokenizer.advance()
tokens += ["</tokens>"]
# 2. create a list for compiled tokens to go into, create compEngine instance
# compile the tokens
compiledTokens = []
compEngine = CompilationEngine(tokens)
compiledTokens += compEngine.compileTokens()
# create the filepath names for writing the tokens and full blown xml
xml_T_FilePath = Path(filePath.parent / (filePath.stem + 'T.xml'))
finalTokenPath = Path(filePath.parent / (filePath.stem + '.xml'))
# write out the raw tokens
self.__output__(xml_T_FilePath, tokens)
self.__output__(finalTokenPath, compiledTokens)
def __processFile__(self, filePath):
''' processes a single file, first feeding the file to JackTokenizer to generate a list of tokens
(output as T.xml files for debugging use) and that token list is fed through
CompilationEngine to generate a final result list of XML tokens which is output into an .xml file. '''
#Phase 1 Tokenize/Analyze
tokenizer = JackTokenizer(filePath)
print(filePath)
xmlTokenList = ["<tokens>"]
taggedTokenList = [("listStart", "tokens", xmlTokenList[0])]
token = tokenizer.advance()
while token:
taggedToken = self.__wrapTokenInXML__(token)
taggedTokenList += [taggedToken]
xmlTokenList += [taggedToken[TT_XML]]
token = tokenizer.advance()
xmlTokenList += ["</tokens>"]
length = len(xmlTokenList)
taggedTokenList += [("listEnd", "tokens", xmlTokenList[length - 1])]
Tfilename = str(filePath.parent) + '/' + filePath.stem + "T.xml"
self.__output__(Tfilename, xmlTokenList)
#Phase 2 Compile/Translate
compiler = CompilationEngine(taggedTokenList)
compiledXMLList = compiler.compileTokens()
Cfilename = str(filePath.parent) + '/' + filePath.stem + ".xml"
self.__output__(Cfilename, compiledXMLList)
def main():
global fn
userInput = sys.argv[1]
if ".jack" in userInput:
filename = userInput
if "/" not in filename:
pos = filename.find(".jack")
fn = filename[:pos]
#newpath = fn
#if not os.path.isdir(newpath):
# os.makedirs(newpath)
outfilenameT = filename[:filename.index(".")] + "T.xml"
outfilename = filename[:filename.index(".")] + ".vm"
else:
last_pos = filename.rfind("/")
pos = filename.find(".jack")
fn = filename[last_pos + 1:pos]
savepath = filename[:last_pos]
#newpath = savepath + "/" + fn
#if not os.path.isdir(newpath):
# os.makedirs(newpath)
outfilenameT = filename[last_pos + 1:filename.rfind(".")] + "T.xml"
outfilename = filename[last_pos + 1:filename.rfind(".")] + ".vm"
ofT = open(outfilenameT, "w")
xmlOp = Tokenizer.tokenizer(filename)
ofT.write(xmlOp)
ofT.close()
of = open(outfilename, "w")
xmlOp = CompilationEngine.compilationEngine(outfilenameT)
of.write(xmlOp)
of.close()
else:
os.chdir(userInput)
if userInput.endswith("/"):
last_pos = userInput.rfind("/")
second_last_pos = userInput[:last_pos].rfind("/")
#newpath = userInput[second_last_pos + 1: last_pos]
else:
if "/" in userInput:
last_pos = userInput.rfind("/")
else:
last_pos = 0
#newpath = userInput[last_pos :]
#if not os.path.isdir(newpath):
# os.makedirs(newpath)
for filename in os.listdir(os.getcwd()):
if filename.endswith(".jack"):
pos = filename.find(".jack")
fn = filename[:pos]
outfilenameT = fn + "T.xml"
outfilename = fn + ".vm"
ofT = open(outfilenameT, "w")
xmlOp = Tokenizer.tokenizer(filename)
ofT.write(xmlOp)
ofT.close()
of = open(outfilename, "w")
xmlOp = CompilationEngine.compilationEngine(outfilenameT)
print(outfilenameT)
of.write(xmlOp)
of.close()
def analyze(filename):
"""
Given file/directory, analyze it
:param filename:
"""
tokenizer = JackTokenizer(filename)
tokenizer.tokenize()
engine = CompilationEngine(tokenizer)
engine.write(filename.replace('.jack', '.vm'))
def _generate_code_file(self, src):
tree = ET.ElementTree(file=src)
engine = CompilationEngine.CompilationEngine(tree)
engine.CompileClass(engine.desRoot)
des = src.split(CompilationEngine.TOKEN_FILE)[0] + CompilationEngine.GEN_CODE_FILE
engine.desTree._setroot(engine.desTree.getroot()[0])#skip first empty token
engine.desTree.write(os.path.join(path, des), short_empty_elements=False)
CompilationEngine.pretty_format_xml(os.path.join(path, des), engine.desTree)
def create_out(self):
"""
creates the output files - first we get the output file name and
then we create a compilation engine with our in file and out file
and the engine compiles the infile and saves the output in
the output file
"""
for file in self._inputs:
out_name = str(os.path.basename(file).split('.')[0]) + ".vm"
comp = CompilationEngine(file, self._out_path + "/" + out_name)
comp.compile_class()
def evaluate():
data = request.json["expression"]
print(data)
res = str()
try:
engine = CompilationEngine(data)
res = engine.run()
print("res " + str(res))
except CompilationError:
res = "Invalid Expression"
finally:
return jsonify(result=res)
def translate_jack_file(file):
"""
translate only one vm file to asm file
:param file: name of file
:return: None
"""
input_file = open(file, "r")
# remove comments from file
clean_file = first_pass(input_file)
# file to list of tokens
tokenized = jt.file_to_tokens(clean_file)
ce.translate_token(tokenized, file[:FILE_NAME_LAST_INDEX])
input_file.close()
def generateFile(foldername, filename): # (Square/mine/, Main.jack)
jack_filename = foldername.rsplit(
"/", 2)[0] + "/" + filename # "Square" + "/" + "Main.jack"
tokens = JackTokenizer.tokenize(
jack_filename) # returns tokens generated from .jack file
vm_filename = foldername + filename.split(
".")[0] + ".vm" # let VMWriter know what file to write to
VMWriter.initializeFile(
vm_filename) # open .vm file to begin writing to it
# pass tokens from Tokenizer to CompilationEngine
class_name = filename.split(".")[0]
CompilationEngine.compileTokens(tokens, class_name)
def test_CompileWhile(self):
ipt = StringIO.StringIO("""while(foo){return bar;};""")
opt = StringIO.StringIO("")
target_string = """<whileStatement>
<keyword> while </keyword>
<symbol> ( </symbol>
<expression>
<term>
<identifier> foo </identifier>
</term>
</expression>
<symbol> ) </symbol>
<symbol> { </symbol>
<statements>
<returnStatement>
<keyword> return </keyword>
<expression>
<term>
<identifier> bar </identifier>
</term>
</expression>
<symbol> ; </symbol>
</returnStatement>
</statements>
<symbol> } </symbol>
</whileStatement>
"""
comp = CompilationEngine.CompilationEngine(ipt, opt, True)
comp.CompileWhile()
opt.seek(0)
res = opt.read()
self.assertEquals(res, target_string)
def _analyzeFile(self, inputPath):
outputPath = inputPath.replace('.jack', '.xml')
outputFile = open(outputPath, 'w')
compilationEngine = CompilationEngine.CompilationEngine(
inputPath, outputFile)
compilationEngine.CompileClass()
outputFile.close()
def tokenizeAndCompile(filename):
'''
In: .jack file
Out: xxx.xml file, xxx.vm file
Function: handles parsing the names of all the files
calls JackTokenizer object to create T.xml file
then calls CompilationEngine to create .xml file
'''
# get outfileName ('T.xml')
ToutfileName = os.path.abspath(filename).split('.')[0] + "T.xml"
if os.path.isfile(ToutfileName): os.remove(ToutfileName)
tokObj = JT.JackTokenizer(os.path.abspath(filename), ToutfileName)
tokObj.tokenize()
tokArray = tokObj.getTokenizedList()
# remove xxxT.xml file - we needed it for Project 10, but not anymore
outfileTName = os.path.abspath(filename).split('.')[0] + "T.xml"
if os.path.isfile(outfileTName): os.remove(outfileTName)
# get outfileName (name of the final .xml file)
outfileName = os.path.abspath(filename).split('.')[0] + ".xml"
if os.path.isfile(outfileName): os.remove(outfileName)
# get outfileName (name of the final .vm file)
outVMName = os.path.abspath(filename).split('.')[0] + ".vm"
if os.path.isfile(outVMName): os.remove(outVMName)
# inputs to CompilationEngine are JackTokenizerOutput array and outfileName
c = CE.CompilationEngine(tokArray, outfileName, outVMName)
c.compileClass()
def run(self):
for input_filename in self.input_filenames:
self.tokenizer_output_filename = input_filename.split(
'.')[0] + 'T.xml'
self.final_output_filename = input_filename.split('.')[0] + '.xml'
with open(input_filename) as in_f:
print('Compiling ' + input_filename)
with open(self.tokenizer_output_filename, 'w') as out_f:
jt = JackTokenizer.JackTokenizer(in_f, out_f)
while jt.has_more_tokens():
token_type = jt.token_type()
if token_type == 'KEYWORD':
jt.keyword()
elif token_type == 'SYMBOL':
jt.symbol()
elif token_type == 'IDENTIFIER':
jt.identifier()
elif token_type == 'INT_CONST':
jt.int_val()
elif token_type == 'STRING_CONST':
jt.string_val()
jt.advance()
jt.save_xml()
with open(self.final_output_filename, 'w') as out_f:
ce = CompilationEngine.CompilationEngine(
self.tokenizer_output_filename, out_f)
print('Compiling finished.')
def main():
if len(sys.argv) != 2:
print("Usage: JackAnalyzer.py fileName.jack/directoryName")
sys.exit(1)
in_put = sys.argv[1]
# Creates a list with all the jack files and
# saves the path where xml files are going to be created
if os.path.isfile(in_put):
jack_files = [in_put]
in_path = os.path.abspath(in_put)
in_path = in_path[:in_path.rfind('/')]
elif os.path.isdir(in_put):
jack_files = [file for file in os.listdir(in_put) if '.jack' in file]
in_path = os.path.abspath(in_put)
# Creates a directory for the xml files
xml_path = os.path.join(in_path, 'xml')
try:
os.mkdir(xml_path)
except FileExistsError:
pass
# Runs the Jack Analyzer for every jack file, and create each corresponding xml and vm file
for jack_file in jack_files:
xml_filepath = os.path.join(xml_path, jack_file.split('.')[0] + '.xml')
vm_path = os.path.join(in_path, jack_file.split('.')[0] + '.vm')
# Opens each out file and writes xml and vm code
with open(os.path.join(in_path, jack_file), 'r') as in_file:
xml_file = open(xml_filepath, 'w')
CompilationEngine(in_file, xml_file, vm_path).run()
xml_file.close()
def test_CompileLet(self):
ipt = StringIO.StringIO("""let blob[foo]=foo;;""")
opt = StringIO.StringIO("")
target_string = """<letStatement>
<keyword> let </keyword>
<identifier> blob </identifier>
<symbol> [ </symbol>
<expression>
<term>
<identifier> foo </identifier>
</term>
</expression>
<symbol> ] </symbol>
<symbol> = </symbol>
<expression>
<term>
<identifier> foo </identifier>
</term>
</expression>
<symbol> ; </symbol>
</letStatement>
"""
comp = CompilationEngine.CompilationEngine(ipt, opt, True)
comp.CompileLet()
opt.seek(0)
res = opt.read()
self.assertEquals(res, target_string)
def main():
# ファイル名処理
path = sys.argv[1]
if os.path.isfile(path):
input_file_list = [sys.argv[1]]
else:
if path[-1] != '/':
path = path + '/'
input_file_list = glob.glob(path + '*.jack')
# パース・コンパイル
for input_file in input_file_list:
output_file = input_file.replace('.jack', '.vm')
c = CE.CompilationEngine(input_file, output_file)
# トークンリストの作成
c.j.make_token_list()
if c.j.hasMoreTokens():
c.j.advance()
if c.j.token == 'class':
c.compileClass()
c.j.f.close()
c.v.close()
def analyze(self):
for jack_file in self.jackFiles:
tokenizer = T.Tokenizer(jack_file)
xml_file = jack_file.replace('.jack', '.xml')
comp_engine = CE.Parsing(tokenizer, xml_file)
comp_engine.outFile.close()
tokenizer.close()
def main():
script, fileName = sys.argv
fileName = fileName
isDirectory = False
if fileName.endswith('.jack'):
c = CE.CompilationEngine(fileName)
else:
try:
os.chdir(fileName)
isDirectory = True
except:
err = 'Please enter a jack file or directory' \
' containing jack files'
print err
sys.exit()
if isDirectory:
files = glob.glob('*.jack')
if files == []:
err = 'Please enter a jack file or directory' \
' containing jack files'
print err
sys.exit()
for f in files:
try:
c = CE.CompilationEngine(f)
c.compile_class()
except:
print 'An error occurred'
for f in glob.glob('*.vm'):
os.remove(f)
# raise
else:
try:
c = CE.CompilationEngine(fileName)
c.compile_class()
except:
print 'An error occurred'
for f in glob.glob('*.vm'):
os.remove(f)
# raise
return
def main():
fin = open('Main.jack', 'r')
xout = open('test_out.xml', 'w')
j = JackTokenizer(fin)
tokens = j.getTokens()
CompilationEngine(tokens, xout)
fin.close()
def doAll(name):
"""
runs the compiler for a specific ".jack" file, or, if given a directory
name, runs the translator for all ".jack" files in directory
:param name: file/directory name
"""
if Consts.OLD_SUFFIX == name.split('.')[-1]:
engine = CompilationEngine.CompilationEngine(name)
engine.compileClass()
engine.closeWriter()
else:
for fileName in os.listdir(name):
if Consts.OLD_SUFFIX == fileName.split('.')[-1]:
engine = CompilationEngine.CompilationEngine(name + "//" +
fileName)
engine.compileClass()
engine.closeWriter()
def compileFile(filename):
engine = CompilationEngine.CompilationEngine(filename)
engine.compileClass()
xml_string = et.tostring(engine.root, encoding='UTF-8', method='html')
xml_string = xml_string.decode().replace("><", ">\n<")
xml_file = open(filename.replace('.jack', '.xml'), 'w')
xml_file.write(xml_string)
xml_file.close()
def main():
root = Tk()
root.withdraw()
inputFilepath = filedialog.askdirectory(initialdir = "/", title = "Select a folder")
for fileName in os.listdir(inputFilepath):
if fileName.lower().endswith(".jack"):
compilationEngine = CompilationEngine.CompilationEngine(os.path.basename(inputFilepath) + "\\" + fileName, os.path.basename(inputFilepath) + "\\" + fileName[:-5] + ".xml")
def test_CompileSubroutine(self):
ipt = StringIO.StringIO(
"""function void test(int blob,foo bar){var int test; return (3+"foo");};"""
)
opt = StringIO.StringIO("")
target_string = """<subroutineDec>
<keyword> function </keyword>
<keyword> void </keyword>
<identifier> test </identifier>
<symbol> ( </symbol>
<parameterList>
<keyword> int </keyword>
<identifier> blob </identifier>
<symbol> , </symbol>
<identifier> foo </identifier>
<identifier> bar </identifier>
</parameterList>
<symbol> ) </symbol>
<subroutineBody>
<symbol> { </symbol>
<varDec>
<keyword> var </keyword>
<keyword> int </keyword>
<identifier> test </identifier>
<symbol> ; </symbol>
</varDec>
<statements>
<returnStatement>
<keyword> return </keyword>
<expression>
<term>
<symbol> ( </symbol>
<expression>
<term>
<integerConstant> 3 </integerConstant>
</term>
<symbol> + </symbol>
<term>
<stringConstant> foo </stringConstant>
</term>
</expression>
<symbol> ) </symbol>
</term>
</expression>
<symbol> ; </symbol>
</returnStatement>
</statements>
<symbol> } </symbol>
</subroutineBody>
</subroutineDec>
"""
comp = CompilationEngine.CompilationEngine(ipt, opt, True)
comp.CompileSubroutine()
opt.seek(0)
res = opt.read()
self.assertEquals(res, target_string)
def main():
# Parameter Configuration
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("-f",dest="file")
args=parser.parse_args()
#Object Initialization
print "Starting Compilation"
comp=CompilationEngine.CompilationEngine(open(args.file),open(args.file.split(".")[0]+".vm","w"),False)
def analyze_file(given_file):
"""
creates a tokenizer for the given file, extracts all tokens
and...
:param given_file: a jack file
:return: None
"""
cur_tokenizer = tokenizer.Tokenizer(given_file)
engine = CompilationEngine.CompilationEngine(cur_tokenizer)
engine.compile()
def test_compiler():
inputFileList = makeInputFileList(getUserInput())
#tokens = ""
for file in inputFileList:
jkt = JackTokenizer.JackTokenizer()
tokens = jkt.tokenize(file) # return token list
comp = CompilationEngine.CompilationEngine(tokens, file)
compiledTokens = comp.compile()
print(compiledTokens)
def main():
inputFileList = makeInputFileList(getUserInput())
#tokens = ""
for file in inputFileList:
jkt= JackTokenizer.JackTokenizer()
tokens = jkt.tokenize(file) # return token list
#outputFile = open(outputFileName, 'a')
#outputFile.write(tokens)
comp = CompilationEngine.CompilationEngine(tokens, file)
compiledTokens = comp.compile()
def main():
userInput = sys.argv[1]
if os.path.isdir(userInput):
if not userInput.endswith("/"):
userInput += "/"
files = os.listdir(userInput)
for file in files:
if file.endswith('.jack'):
fileName = file.split(".")[0]
comp = CompilationEngine.CompilationEngine(userInput + file, userInput + fileName + ".vm")
comp.compileClass()
#Case input is file, just parse it
elif os.path.isfile(userInput):
userInput = userInput.split(".")[0]
comp = CompilationEngine.CompilationEngine(userInput + ".jack", userInput + ".vm")
comp.compileClass()
#Raise an exception
else:
raise Exception("The input is not valid, please try again")
def analyze(jackFile):
outputFilename = os.path.splitext(jackFile)[0] + ".xml.cmp"
t = Tokenizer.Tokenizer(jackFile)
ce = CompilationEngine.CompilationEngine(t, outputFilename)
t.advance()
if t.keyword() != "class":
print("jack file does not have a class!")
exit(1)
ce.CompileClass()
def main():
if len(sys.argv) != 2:
print(' Usage error - please insert file or directory.')
return
input_path = os.path.abspath(sys.argv[1])
if input_path.endswith('.jack'):
input_path = [input_path]
else:
input_path = glob.glob(input_path + '/*.jack')
for _ in input_path:
out_xml = _.replace('.jack', '.xml')
CompilationEngine(_, out_xml)
import sys
from JackTokenizer import *
from CompilationEngine import *
if(__name__=="__main__"):
jackTokenizer = JackTokenizer(sys.argv[1])
compilationEngine = CompilationEngine(jackTokenizer)
compilationEngine.write(sys.argv[2])
import JackTokenizer import CompilationEngine import os import VMWriter import SymbolTable rfile = r"C:\Users\Liu_100\Desktop\nand2tetris\nand2tetris\projects\11\Pong\Ball.jack" xml = os.path.splitext(rfile)[0] + 'MyVersion.xml' vm = os.path.splitext(rfile)[0] + 'MyVersion.vm' xml = open(xml,'w') vm = open(vm,'w') jackTokenizer = JackTokenizer.jacktokenizer(rfile, xml) vmWriter = VMWriter.VMWriter(vm) symbolTable = SymbolTable.SymbolTable() compiler = CompilationEngine.compilationengine(xml,symbolTable,vmWriter) compiler.compileClass(jackTokenizer) xml.close() vmWriter.close()
import JackTokenizer import CompilationEngine import os rfile = r"C:\Users\Liu_100\Desktop\nand2tetris\nand2tetris\projects\10\Square\Square.jack" wfile = os.path.splitext(rfile)[0] + 'FinalVersion.xml' wfile = open(wfile,'w') jackTokenizer = JackTokenizer.jacktokenizer(rfile, wfile) compiler = CompilationEngine.compilationengine(wfile) compiler.compileClass(jackTokenizer) wfile.close()
