def build_track(self): file = Parse('bach_846.mid') #file = Parse('WTC_Part1/Fugue7.mid') tpm = file.parse() simulate = Simulation(tpm, self) simulate.next_state(simulate.get_init_note(), self.length)
def testUnescape(self): self.assertEquals("a<b", Parse().unescape("a<b")) self.assertEquals("a>b & b>c &&", Parse().unescape("a>b & b>c &&")) self.assertEquals("&&", Parse().unescape("&amp;&amp;")) self.assertEquals("a>b & b>c &&", Parse().unescape("a>b & b>c &&"))
def start_indexing(dirs_list, dirs_dicts, main_path, posting_path, to_stem, start_index, end_index, directory): dirs_dicts[directory] = None reader = ReadFile() parser = Parse(main_path) indexer = Indexer(posting_path + directory) if to_stem: parser.to_stem = True indexer.to_stem = True if not os.path.exists(posting_path + directory): os.makedirs(posting_path + directory) documents = {} i = start_index while i < end_index: docs = reader.separate_docs_in_file(main_path + '\\corpus', dirs_list[i]) j = 0 for doc_id in docs: doc_dict = parser.main_parser(docs[doc_id].text, docs[doc_id]) docs[doc_id].text = None if i == end_index - 1 and j == len(docs) - 1: indexer.finished_parse = True indexer.index_terms(doc_dict, doc_id) documents[doc_id] = docs[doc_id] j += 1 i += 1 dirs_dicts[directory] = [ indexer.post_files_lines, indexer.terms_dict, documents, reader.languages ]
def main(): #Création de l'objet qui parse le site web parse = Parse("https://www.matchendirect.fr/") #On parse tout le site parse.parseAllSite() #Création du fichier de sortie df_data = parse.createInputOutputFile() #Enregistrement en CSV df_data.to_csv('data.csv', index=False, encoding="utf-8-sig") print('tete')
def caseOne(self, path): p = Parse() p.setPath(path) tag = p.getTag() f = open(casesnew_dir + tag + ".robot", 'a+') apiname = p.getAPIName() casename = p.getCaseName() f.write(casename + "\n") # 获取接口返回值 parameters = p.getParams() paramskey = [] summary = p.getSummary() f.write("\t[Documentation] " + summary.encode("utf-8") + "\n") f.write("\t[Tags] Run\n") f.write("\t${resp} " + apiname + " ${token}") if len(parameters) > 0: for i in range(len(parameters)): name = parameters[i]["name"].keys()[0] paramskey.append(name) f.write(" ${" + casename + "_param[\'" + name + "\']}") f.write("\n") resp = globals()[casename + "_resp"] if isinstance(resp, dict) or isinstance(resp, list): self.assertDict(f, casename, resp, "") f.write("\n") else: f.write("\tshould be equal as strings ${resp} ${" + casename + "_resp}\n\n")
def __init__(self, handler): Parse.__init__(self, handler) self.addRule(ListRule()) self.addRule(ListItemRule()) self.addRule(TitleRule()) self.addRule(HeadingRule()) self.addRule(ParagraphRule()) self.addFilter(r'\*(.+?)\*', 'emphasis') self.addFilter(r'(http://[\.a-zA-Z/]+)', 'url') self.addFilter(r'([\.a-zA-Z]+@[\.a-zA-Z]+[a-zA-Z]+)', 'mail')
def __init__(self, corpus_path, posting_path, terms_dict, cities_dict, docs_dict, avg_doc_length, with_stemming, with_semantics): self.terms_dict = terms_dict self.cities_dict = cities_dict self.docs_dict = docs_dict self.parser = Parse(corpus_path) ## corpus path for stop words self.parser.to_stem = with_stemming self.posting_path = posting_path self.ranker = Ranker(avg_doc_length) self.model = None self.with_semantics = with_semantics self.with_stemming = with_stemming
def callRobot(txt, request): parse = Parse() result = [] decision = parse.outputString(str(txt)) if decision[0][0] == 1: fb = FB() temp = fb.searchUser(str(decision[1])) if temp != None and len(temp) > 0: result.append("Result from Facebook, Total results are " + str(len(temp)) + "\n") for i, y in temp.iteritems(): result.append("UserID:" + i + "\tUser Full Name: " + y + "\n") if decision[0][1] == 1: twitter = twitterSearch() temp = twitter.searchName(str(txt)) result.append("Result from twitter Total results are :" + str(len(temp)) + "\n") for i in temp: result.append("UserID:" + i[0] + "\tUser Full Name:" + i[1] + "\tUser location" + i[2] + "\n") if decision[0][2] == 1: fb = FB() temp = fb.searchDetailInfo(str(txt)) if "name" in temp: result.append("Name: " + temp["name"]) if "category" in temp: result.append("\tCategory: " + temp["category"]) if "birthday" in temp: result.append("\tBirthday: " + temp["birthday"]) if "about" in temp: result.append("\tAbout: " + temp["about"]) if "pic" in temp: result.append("\tPicture: " + temp["pic"] + "\n") #result = fb.searchUser(str(txt)) message = "" for i in result: message = message + i #for i in range(1,1000): # print message.decode('unicode-escape') # for i in range(1,300): # print message[1791:1793] #msg = message.decode('unicode-escape') #print result msg = message user = GetRobot(request, msg) return msg
def callRobot(txt,request): parse = Parse() result = [] decision = parse.outputString(str(txt)) if decision[0][0]==1: fb = FB() temp = fb.searchUser(str(decision[1])) if temp!=None and len(temp)>0: result.append("Result from Facebook, Total results are "+str(len(temp))+"\n") for i,y in temp.iteritems(): result.append("UserID:"+i+"\tUser Full Name: "+y+"\n") if decision[0][1]==1: twitter = twitterSearch() temp = twitter.searchName(str(txt)) result.append("Result from twitter Total results are :"+str(len(temp))+"\n") for i in temp: result.append("UserID:"+i[0]+"\tUser Full Name:"+i[1]+"\tUser location"+i[2]+"\n") if decision[0][2]==1: fb = FB() temp = fb.searchDetailInfo(str(txt)) if "name" in temp: result.append("Name: "+temp["name"]) if "category" in temp: result.append("\tCategory: "+temp["category"]) if "birthday" in temp: result.append("\tBirthday: "+temp["birthday"]) if "about" in temp: result.append("\tAbout: "+temp["about"]) if "pic" in temp: result.append("\tPicture: "+temp["pic"]+"\n") #result = fb.searchUser(str(txt)) message="" for i in result: message = message+i #for i in range(1,1000): # print message.decode('unicode-escape') # for i in range(1,300): # print message[1791:1793] #msg = message.decode('unicode-escape') #print result msg = message user = GetRobot(request,msg) return msg
def __init__(self, path): self.path = path.rstrip() logging.getLogger('asa_utils').debug("Searching %s for data files" % self.path) self.files = glob.glob(os.path.join(self.path, "*")) logging.getLogger('asa_utils').debug("File list: %s" % self.files) if len(self.files) == 0: logging.getLogger('asa_utils').error( "Directory does not exist, or is empty: %s" % path) raise EmptyDataFolder self.parsers = [] for file in self.files: try: p = Parse(file) self.parsers.append(p) except ParseError: logging.getLogger('asa_utils').warn( "Failed to parse file: %s" % file) if len(self.parsers) == 0: logging.getLogger('asa_utils').error( "Unable to parse any data files in this folder: %s" % self.path) raise EmptyDataFolder
def testParsing(self): tags = ("table", ) p = Parse("leader<Table foo=2>body</table>trailer", tags) self.assertEquals("leader", p.leader) self.assertEquals("<Table foo=2>", p.tag) self.assertEquals("body", p.body) self.assertEquals("trailer", p.trailer)
def testIterating(self): p = Parse( "leader<table><tr><td>one</td><td>two</td><td>three</td></tr></table>trailer" ) self.assertEquals("one", p.parts.parts.body) self.assertEquals("two", p.parts.parts.more.body) self.assertEquals("three", p.parts.parts.more.more.body)
def __init__(self, corpus_folder_path, stop_words_file_path, to_stem, path_for_posting_and_dictionary): self.stop_words_container = StopWordsContainer(stop_words_file_path) self.stemmer = Stemmer() if to_stem else None self.parser = Parse() self.doc_posting_fd = None self.doc_counter = 0 # Will be used to count the number of iterations self.doc_repr_list = [] self.term_posting_fd = None self.global_term_dict = {} self.number_of_docs_processed = 0 self.corpus_folder = corpus_folder_path self.stop_words_file_path = stop_words_file_path self.path_for_posting_and_dictionary = path_for_posting_and_dictionary self.stem_doc_posting_folder = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["stem_doc_posting_folder"]) self.doc_posting_folder = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["doc_posting_folder"]) self.stem_term_posting_folder = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["stem_term_posting_folder"]) self.term_posting_folder = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["term_posting_folder"]) if self.stemmer is not None: self.doc_posting_file_path = self.stem_doc_posting_folder self.term_posting_file_target = os.path.join( self.stem_term_posting_folder, IR_CONFIG["storage"]["stem_term_posting_file_name"]) self.doc_posting_file_target = os.path.join( self.stem_doc_posting_folder, IR_CONFIG["storage"]["stem_doc_posting_file_name"]) self.cache_file_path = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["cache_file_name_stem"]) self.dictionary_file_path = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["dictionary_file_name_stem"]) else: self.doc_posting_file_path = self.doc_posting_folder self.term_posting_file_target = os.path.join( self.term_posting_folder, IR_CONFIG["storage"]["term_posting_file_name"]) self.doc_posting_file_target = os.path.join( self.doc_posting_folder, IR_CONFIG["storage"]["doc_posting_file_name"]) self.cache_file_path = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["cache_file_name"]) self.dictionary_file_path = os.path.join( path_for_posting_and_dictionary, IR_CONFIG["storage"]["dictionary_file_name"]) self.dictionary = MainDictionary(self.term_posting_file_target)
def run(self, file, right, wrong, ignores, exceptions): input = self.read("Documents/" + file + ".html") fixture = Fixture() if input.find("<wiki>") != -1: tables = Parse(input, ("wiki", "table", "tr", "td")) fixture.doTables(tables.parts) else: tables = Parse(input, ("table", "tr", "td")) fixture.doTables(tables) output = open("Reports/" + file + ".html", "wt") output.write(str(tables)) output.close() self.assertEquals(right, fixture.counts.right, file + " right") self.assertEquals(wrong, fixture.counts.wrong, file + " wrong") self.assertEquals(ignores, fixture.counts.ignores, file + " ignores") self.assertEquals(exceptions, fixture.counts.exceptions, file + " exceptions")
def getAllCellStates(filename): print(f"Parsing file ({filename})...") startTime = time.monotonic() states = Parse.getAllCellStates(filename) endTime = time.monotonic() timeElapsed = endTime - startTime print(f"Time taken: {timeElapsed}s") return [states, timeElapsed]
def find_all_POS_tags(self, text): parses = re.findall(re.escape(" ") + "(.*)" + re.escape("\n"), text) tags = [] for parse in parses: tags.append(Parse.convert_parse_to_tag(parse)) self.tags += tags
def __init__(self, dataStorage): """ 初始化 :return: """ self.driver = webdriver.Chrome() # self.driver.implicitly_wait(1) # self.driver = webdriver.PhantomJS() #########不能使用,个人成就和推荐信信息爬不出来 self.accountName = ACCOUNT.get('name') self.urlName = LINKEDINURL.get('name') self.usersName = LINKEDINUSERS.get('name') self.postName = LINKEDINPOSTSURL.get('name') self.__dataStorage = dataStorage self.parse = Parse() self.webAction = WebAction() # self.linkedin_limit = 0 self.__initLogger()
def __init__(self, dataStorage): """ 初始化 :return: """ self.driver = webdriver.Chrome() # self.driver = webdriver.PhantomJS() # self.driver.maximize_window() # 设置页面超时时间 self.driver.set_page_load_timeout(30) self.accountName = ACCOUNT.get('name') self.urlName = LINKEDINURL.get('name') self.usersName = LINKEDINUSERS.get('name') self.__dataStorage = dataStorage self.parse = Parse() # self.linkedin_limit = 0 self.__initLogger()
def testParseException(self): try: p = Parse( "leader<table><tr><th>one</th><th>two</th><th>three</th></tr><tr><td>four</td></tr></table>trailer" ) except ParseException, e: self.assertEquals(17, e.offset) self.assertEquals("Can't find tag: td", e.message) return
def tranning_network(s, readout, h_fc1, sess, gameState): print("START OF TRAINING NETWORK") a = tf.placeholder("float", [None, ACTIONS]) y = tf.placeholder("float", [None]) readout_action = tf.reduce_sum(tf.mul(readout, a), reduction_indices = 1) cost = tf.reduce_mean(tf.square(y - readout_action)) tf.scalar_summary("cost", cost) #rain_step = tf.train.AdamOptimizer(1e-6).minimize(cost) train_step = tf.train.AdamOptimizer(0.005).minimize(cost) merged_summary_op = tf.merge_all_summaries() summary_writer = tf.train.SummaryWriter('logs',sess.graph) sess.run(tf.initialize_all_variables()) #first state timeStep = 0 s_t = gameState[timeStep] D=[] print("ADD GAME STATE TO DOMAIN") # add all 10k gameState to Domain for i in range(1, len(gameState)): #SET ACTION a_t = np.zeros([ACTIONS]) action_index = 0 gameStateObjectNext = Parse.parse_game_state(gameState[timeStep+1]) action_index = gameStateObjectNext.pacman.lastMoveMade a_t[action_index] = 1 # SET REWARD r_t = gameStateObjectNext.score # SET NEXTSTATE s_t1 = gameState[timeStep+1] # if GAME OVER SET TERMINAL terminal = (gameStateObjectNext.pacman.numberOfLivesRemaining >0) #ADD TO DOMAIN D.append((s_t, a_t, r_t, s_t1, terminal)) # NEXT STATE IN SEQUENCE s_t = s_t1 timeStep += 1 print("START TO TRAINING BATCH") #training 1k times with BATCH size for i in range (0,TRANING_TIME): if (i%SAVING_STEP==0): print ("Training Time %d " %i )
def testText(self): tags =("td",) p = Parse("<td>a<b</td>", tags) self.assertEquals("a<b", p.body) self.assertEquals("a<b", p.text()) p = Parse("<td>\ta>b & b>c && </td>", tags) self.assertEquals("a>b & b>c &&", p.text()) p = Parse("<td>\ta>b & b>c & </td>", tags) self.assertEquals("a>b & b>c &", p.text()) p = Parse("<TD><P><FONT FACE=\"Arial\" SIZE=2>GroupTestFixture</FONT></TD>", tags) self.assertEquals("GroupTestFixture",p.text())
def addParse(self, parseText): parseText = parseText.strip() for parse in self.parses: if parseText == parse.text: parse.frequency += 1 return parse = Parse(parseText) self.parses.append(parse) self.sortParses()
def newFile(self): fi = open(resp_dir + "__init__.py", "w") fi.write("# coding=utf-8\n") fi.close() tags = Parse().getTags() for tag in tags: self.fileOne(tag) fi = open(resp_dir + "__init__.py", "a+") fi.write("from " + resp_pack + tag + " import *\n") fi.close()
def find_all_POS_tags(self, text): parses = re.findall( re.escape(" ") + "(.*)" + re.escape("\n"), text) tags = [] for parse in parses: tags.append(Parse.convert_parse_to_tag(parse)) self.tags += tags
def decoding(): code = Parse.code().lower() number = Parse.number() result = '' letters = string.ascii_lowercase for letter in code: if letter.isalpha(): position = letters.find(letter) if position > number: position = position - number result = result + letters[position] if position <= number: position = position - 27 result = result + letters[position] if not letter.isalpha(): result += letter return result
def __init__(self): self.parse = Parse() # Authorise my request using OAuth self.t = Twitter( auth=OAuth("2999654973-YS9XG2UdzWDNJhapOjAUDHjrv5wgG3az3MZ5JfF", "NlP0PWQPJv1Z0lPsH6xv3bb7jw3Aos5xD18ni3ODuDZME", "p6yoZBcF9NnteTV67YbVRwcis", "nY0Q4ugFlef0AtlRTaXptshXxJNGymxFgn4KzaeF77UXlMkRuq")) self.tweets = [] # Define target account and fetch tweet self.t.statuses.user_timeline(screen_name="premierleague", count=1, exclude_replies=True, include_rts=False) tweets = self.t.statuses.user_timeline(screen_name="premierleague", count=1, exclude_replies=True, include_rts=False) for i in xrange(len(tweets)): self.tweets.append(self.parse.parseOne(tweets[i]))
def testIndexing(self): p = Parse( "leader<table><tr><td>one</td><td>two</td><td>three</td></tr><tr><td>four</td></tr></table>trailer" ) self.assertEquals("one", p.at(0, 0, 0).body) self.assertEquals("two", p.at(0, 0, 1).body) self.assertEquals("three", p.at(0, 0, 2).body) self.assertEquals("three", p.at(0, 0, 3).body) self.assertEquals("three", p.at(0, 0, 4).body) self.assertEquals("four", p.at(0, 1, 0).body) self.assertEquals("four", p.at(0, 1, 1).body) self.assertEquals("four", p.at(0, 2, 0).body) self.assertEquals(1, p.size()) self.assertEquals(2, p.parts.size()) self.assertEquals(3, p.parts.parts.size()) self.assertEquals("one", p.leaf().body) self.assertEquals("four", p.parts.last().leaf().body)
def __init__(self): # creating an object for parser class parser_obj = Parse() # cycle count self.cycle = 0 self.cy_needed = 0 # loop case check self.loop = False # flag for i-cache self.spec_i_flag = False # collecting the parsed data self.inst = parser_obj.inst self.config = parser_obj.conf self.registers = parser_obj.regs self.data = parser_obj.data # hit count self.i_hit_count = 0 self.i_access_count = 0 self.d_miss = 0 self.d_hit_count = 0 self.d_access_count = 0 self.stall = 0 self.fflag = False self.next = 0 self.v = 0 # register set self.register_set = {} # d-cache self.d_block_0 = {d_value_0: [] for d_value_0 in range(2)} self.d_block_1 = {d_value_1: [] for d_value_1 in range(2)} self.least_recently_used = 0 self.least_recently_used2 = 0 # initialize instruction sets self.mem = ['LW', 'SW', 'L.D', 'S.D'] self.add_sub = ['ADD.D', 'SUB.D'] self.int_inst = ['DADD', 'DADDI', 'DSUB', 'DSUBI', 'AND', 'ANDI', 'OR', 'ORI'] self.jump = ['HLT', 'J', 'BEQ', 'BNE'] # tracking if busy or not self.fetch_busy = self.decode_busy = self.mem_busy = self.add_busy = self.mul_busy = self.div_busy \ = self.write_back_busy = self.iu_busy = self.jump_busy = [False, None]
def calculate_value_game_state(input_layer, readout, h_fc1, sess, gameState): gameObject = Parse.parse_game_state(gameState) #print("AT Game Step: %d Score %d" %(gameObject.totalTime, gameObject.score)) s_t = Frame.get_input_network(gameObject) readout_t = readout.eval(feed_dict={input_layer: [s_t]})[0] action_index = np.argmax(readout_t) return action_index
def testIndexing(self): p = Parse("leader<table><tr><td>one</td><td>two</td><td>three</td></tr><tr><td>four</td></tr></table>trailer") self.assertEquals("one", p.at(0,0,0).body) self.assertEquals("two", p.at(0,0,1).body) self.assertEquals("three", p.at(0,0,2).body) self.assertEquals("three", p.at(0,0,3).body) self.assertEquals("three", p.at(0,0,4).body) self.assertEquals("four", p.at(0,1,0).body) self.assertEquals("four", p.at(0,1,1).body) self.assertEquals("four", p.at(0,2,0).body) self.assertEquals(1, p.size()) self.assertEquals(2, p.parts.size()) self.assertEquals(3, p.parts.parts.size()) self.assertEquals("one", p.leaf().body) self.assertEquals("four", p.parts.last().leaf().body)
def report(self): num_count = 0 i = 0 freq = {} for term in self.indexer.terms_dict.keys(): if Parse.isFloat(term): num_count += 1 freq[term] = self.indexer.terms_dict[term][1] freq_list = sorted(freq.items(), key=itemgetter(1)) with open('frequency.txt', 'wb') as f: for n in freq_list: f.write(str(n[0]) + ": " + str(n[1]) + '\n') print "Num of terms which are nums: " + str(num_count) print "Num of countries: " + str(len(self.indexer.countries)) print "Num of capitals: " + str(self.indexer.num_of_capitals)
def test_run_OLCIL1_Oa01_radiance(self): from test_OLCIL1_parse_data import OLCIL1_test_path, OLCIL1_test_attributes from Parse import Parse s3parse = Parse(OLCIL1_test_path) # Test attributes attribute # Assert opened attributes are the same as the true attributes for key in OLCIL1_test_attributes.keys(): if type(OLCIL1_test_attributes[key]) == list: self.assertItemsEqual(s3parse.attributes[key], OLCIL1_test_attributes[key], "Problem with %s" % key) else: self.assertEqual(s3parse.attributes[key], OLCIL1_test_attributes[key], "Problem with %s" % key)
def respOne(self, path): p = Parse() p.setPath(path) tag = p.getTag() f = open(resp_dir + tag + ".py", 'a+') casename = p.getCaseName() resp = p.getResponse() f.write(casename + "_resp = ") if isinstance(resp, dict): self.writeDict(f, resp) elif isinstance(resp, list): self.writeList(f, resp) else: f.write("\'" + resp + "\'") f.write("\n\n")
def __init__(self, arr): parser_obj = Parse() # depending on the number of registers if len(arr) == 1: self.inst = arr[0] self.reg1 = '' self.reg2 = '' self.reg3 = '' if len(arr) == 3: self.inst = arr[0] self.reg1 = arr[1] self.reg2 = arr[2] self.reg3 = '' if len(arr) == 4: self.inst = arr[0] self.reg1 = arr[1] self.reg2 = arr[2] self.reg3 = arr[3] self.address = 0 self.x = '' self.mem_check = False self.sub_cycle = 0 self.int_cycle = 1 self.iu_cycle = 1 self.mem_cycle = int(parser_obj.conf[0]['Main memory']) self.add_sub_cycle = int(parser_obj.conf[0]['FP adder']) self.mul_cycle = int(parser_obj.conf[0]['FP Multiplier']) self.div_cycle = int(parser_obj.conf[0]['FP divider']) # cycle count for each stage self.fetch = self.decode = self.execute = self.write_back = 0 # possible hazards self.raw = self.war = self.waw = self.struct_haz = 'N' self.status = 'IF' # instruction cache flag self.i_flag = [False, 0] self.cache_miss_flag = False self.d_flag = False
if gradebook_choice == "academic": prompt_event = str(raw_input("Event> ")) prompt_event_id = (raw_input("Event ID> ")) prompt_skill = (raw_input("Skill> ")) prompt_due_date = (raw_input("Due Date> ")) f.write(create_event(prompt_event, prompt_event_id, prompt_skill, prompt_due_date)) elif gradebook_choice == "teks": prompt_assignment = (raw_input("Assignment> ")) prompt_assignment_id = (raw_input("Assignment ID> ")) prompt_due_date = (raw_input("Due Date> ")) f.write(create_assignment(prompt_assignment, prompt_assignment_id, prompt_due_date)) else: print "Error" p = Parse(args.csvimport) p.container_bind() p.get_field_names() print """------------------ Listing of Field Names and Indices ----------------------""" for i, v in enumerate(p.field_names): print "( %s ) ( %s )" % (i,v) prompt_id = int(raw_input("Which field contains the ID? ")) prompt_grade = int(raw_input("Which field contains the grade? ")) prompt_full_name = int(raw_input("Which field contains the full name? ")) prompt_cohort = int(raw_input("Which field contains the cohort? "))
def parseLine(self, slots): numSlots = len(slots) initialParse = Parse(self, numSlots) parses = initialParse.extend(slots[0]) parses[0].comparisonNums.add(1) for slotN in range(1, numSlots): newParses = [] for parse in parses: newParses.append(parse.extend(slots[slotN])) for parseSetIndex in range(len(newParses)): parseSet = newParses[parseSetIndex] for parseIndex in range(len(parseSet)): parse = parseSet[parseIndex] parse.comparisonParses = [] if len(parseSet) > 1 and parseIndex == 0: parse.comparisonNums.add(parseSetIndex) for comparisonIndex in parse.comparisonNums: # should be a label break, but not supported in Python # find better solution; redundant checking if parse.isBounded: break try: for comparisonParse in newParses[comparisonIndex]: if parse is comparisonParse: continue if not comparisonParse.isBounded: if parse.canCompare(comparisonParse): boundingRelation = parse.boundingRelation(comparisonParse) if boundingRelation == Bounding.bounds: comparisonParse.isBounded = True elif boundingRelation == Bounding.bounded: parse.isBounded = True break elif boundingRelation == Bounding.equal: parse.comparisonParses.append(comparisonParse) else: parse.comparisonParses.append(comparisonParse) except IndexError: pass parses = [] parseNum = 0 for parseSet in newParses: for parse in parseSet: if not parse.isBounded: #if (parse.score() < 1000): parse.parseNum = parseNum parseNum += 1 parses.append(parse) for parse in parses: parse.comparisonNums = set() for compParse in parse.comparisonParses: if not compParse.isBounded: parse.comparisonNums.add(compParse.parseNum) return parses
#Author: Josh Wretlind #Class: CSCI 410 - Elements of Computing Systems #Project: ECS 10 - Compiler part #1 #Date: 04/07/13 import sys,string,os from JackTokenizer import JackTokenizer from CompilationEngine import CompilationEngine from Parse import Parse infile = sys.argv[1] # Sys.argv is the system argument list object outfile = infile.replace(".jack",".xml") parse = Parse(infile) infileText = "" jtok = JackTokenizer() tokenList = [] while parse.hasMoreCommands(): parse.advance() blah = parse.output() infileText += blah jtok.advance(blah) tokenList.extend(jtok.listOfTokens) ce = CompilationEngine() ce.setListOfTokens(tokenList) ce.run()