def p_move(self, player): # pierwsza wyswietlanie ma byc wolne sec = 0.005 while True: os.system('cls') Load.room.introduce(self.id_room - 1, sec) if self.id_room < 8: print("-" * 20 + "\n\nGdzie się ruszasz? (1/2/3)\n") print("1. " + Load.room.rooms_doors[self.id_room * 2 + -1]) print("2. " + Load.room.rooms_doors[self.id_room * 2]) if self.id_room > 1: print("3. Zawróć") print("\nLub...\n4. Wykonaj akcje\n") move = input(">>>") if move == "1": self.id_room *= 2 break if move == "2": self.id_room = self.id_room * 2 + 1 break if self.id_room > 1: if move == "3": self.id_room = int(self.id_room / 2) break if move == "4": Load.action[self.id_room - 2].do_action( player, Load.room, self.id_room - 1) break else: print("-" * 20 + "\nGdzie się ruszasz? (1/2)\n") print("1. Wejdź do portalu") print("2. Zawróć") print("\nLub...\n3. Wykonaj akcje\n") move = input(">>>") if move == "1": Code.guess(player) exit(0) break if move == "2": self.id_room = int(self.id_room / 2) break if move == "3": Load.action[self.id_room - 2].do_action( player, Load.room, self.id_room - 1) break # kolejne wyswitlanie ma byc szybkie sec = 0
def read_mic_engines(): configuration = Code.configuration file = Code.path_resource("IntFiles", "mic_tourney.eval") with open(file) as f: li = [] for linea in f: dic = eval(linea.strip()) alias = dic["ALIAS"] nom_base_engine = dic["ENGINE"] id_info = dic["IDINFO"] elo = dic["ELO"] li_uci = [(d["name"], d["valor"]) for d in dic["LIUCI"]] engine = configuration.dic_engines.get(nom_base_engine) if engine: eng = engine.clona() eng.name = alias eng.id_info = id_info eng.alias = alias eng.elo = elo eng.liUCI = li_uci if alias.isupper(): eng.name = Util.primera_mayuscula(alias) eng.alias = eng.name eng.book = Code.path_resource("Openings", "Players", "%s.bin" % alias.lower()) else: eng.book = None li.append(eng) return li
def generate_h_code(self, env, result): public_vars_and_funcs = [] public_extension_types = [] for entry in env.var_entries: if entry.visibility == 'public': public_vars_and_funcs.append(entry) for entry in env.cfunc_entries: if entry.visibility == 'public': public_vars_and_funcs.append(entry) for entry in env.c_class_entries: if entry.visibility == 'public': public_extension_types.append(entry) if public_vars_and_funcs or public_extension_types: result.h_file = replace_suffix(result.c_file, ".h") result.i_file = replace_suffix(result.c_file, ".pxi") h_code = Code.CCodeWriter(open_new_file(result.h_file)) i_code = Code.PyrexCodeWriter(result.i_file) self.generate_extern_c_macro_definition(h_code) for entry in public_vars_and_funcs: h_code.putln("%s %s;" % (Naming.extern_c_macro, entry.type.declaration_code( entry.cname, dll_linkage="DL_IMPORT"))) i_code.putln("cdef extern %s" % entry.type.declaration_code(entry.cname, pyrex=1)) for entry in public_extension_types: self.generate_cclass_header_code(entry.type, h_code) self.generate_cclass_include_code(entry.type, i_code) h_code.putln("PyMODINIT_FUNC init%s(void);" % env.module_name)
def selecciona(self, type_play): self.game_type = type_play if type_play == GT_FICS: self._db = Code.path_resource("IntFiles", "FicsElo.db") self._activo = self.configuration.ficsActivo self._ponActivo = self.configuration.ponFicsActivo self.nombreObj = _( "Fics-player" ) # self.cabs[ "White" if self.human_side else "Black" ] self._fichEstad = self.configuration.fichEstadFicsElo self._titulo = _("Fics-Elo") self._newTitulo = _("New Fics-Elo") self._TIPO = "FICS" elif type_play == GT_FIDE: self._db = Code.path_resource("IntFiles", "FideElo.db") self._activo = self.configuration.fideActivo self._ponActivo = self.configuration.ponFideActivo self.nombreObj = _( "Fide-player" ) # self.cabs[ "White" if self.human_side else "Black" ] self._fichEstad = self.configuration.fichEstadFideElo self._titulo = _("Fide-Elo") self._newTitulo = _("New Fide-Elo") self._TIPO = "FIDE" elif type_play == GT_LICHESS: self._db = Code.path_resource("IntFiles", "LichessElo.db") self._activo = self.configuration.lichessActivo self._ponActivo = self.configuration.ponLichessActivo self.nombreObj = _("Lichess-player") self._fichEstad = self.configuration.fichEstadLichessElo self._titulo = _("Lichess-Elo") self._newTitulo = _("New Lichess-Elo") self._TIPO = "LICHESS"
def __init__(self, lexer, parser, parent): Token.__init__(self, 'If-condition', lexer, parser, parent) # Expect an expression. lexer.expect(self, 'keyword', 'if') lexer.expect(self, 'whitespace') self.expression = Expression(lexer, parser, parent) self.mark_end() # Body of the if block. self.if_block = Code.Code(lexer, parser, parent) self.elif_blocks = [] self.else_block = None # If there is no "else" statement, just return. lexer.skip(['whitespace', 'newline']) if not lexer.next_if('keyword', 'else'): return # If the "else" statement is followed by an "if" (=elif), # read the next if condition recursively and return. lexer.skip(['whitespace', 'newline']) if lexer.current_is('keyword', 'if'): self.else_block = IfCondition(lexer, parser, parent) return # There was no "elif", so we handle a normal "else" condition here. self.else_block = Code.Code(lexer, parser, parent)
def generate_c_code(self, env, result): modules = [] self.find_referenced_modules(env, modules, {}) #code = Code.CCodeWriter(result.c_file) code = Code.CCodeWriter(StringIO()) code.h = Code.CCodeWriter(StringIO()) code.init_labels() self.generate_module_preamble(env, modules, code.h) code.putln("") code.putln("/* Implementation of %s */" % env.qualified_name) self.generate_const_definitions(env, code) self.generate_interned_name_decls(env, code) self.generate_py_string_decls(env, code) self.body.generate_function_definitions(env, code) self.generate_interned_name_table(env, code) self.generate_py_string_table(env, code) self.generate_typeobj_definitions(env, code) self.generate_method_table(env, code) self.generate_filename_init_prototype(code) self.generate_module_init_func(modules[:-1], env, code) self.generate_filename_table(code) self.generate_utility_functions(env, code) for module in modules: self.generate_declarations_for_module(module, code.h, definition=module is env) f = open_new_file(result.c_file) f.write(code.h.f.getvalue()) f.write("\n") f.write(code.f.getvalue()) f.close() result.c_file_generated = 1
def createGuess(self): newGuess = Code([]) # for as long as the game is in one of the first three phases, use makePhaseGuess to create the next guess if self.phaseRound: newGuess = self.makePhaseGuess() else: self.guessList = self.environment.getGuessList() self.clueList = self.environment.getClueList() # first, check to see if the game has been won with the latest guess if self.clueList[self.guessCount - 1].getBlackPegs() == 4: # if the game has been won, end the program self.won = True print("Correct guess has been made!") if self.testCompleted: self.analyzeTest = True else: # if the game just finished testing out two pins, check the result if self.analyzeTest: print("Just finished testing two pins.") self.analyzeTest = False self.testCompleted = False # a temporary list used to narrow down color choices for a single guess clist = self.viableColors.copy() # TODO: Define createGuess past this point newGuess = Code([]) # update the guess list self.guess = newGuess
def main_menu(): "This function contains the main menu of the game" print("1. PLAY THE GAME\n2. EXIT THE GAME\n") ##Displaying error if user enters values that aren't integers try: menu = int(input("Choose 1 or 2 from above menu:")) except ValueError: print("\nPLEASE ENTER 1 OR 2 AS YOUR CHOICE!\n") print("-------------------------------------\n") ##Calling 'main_menu' inside 'Menu' module main_menu() ##Exiting game if user enters 2 if menu == 2: exit() else: ##Starting game if user enters 1 if menu == 1: ##Calling 'desc_user_interface' inside 'Game_Details' module details.desc1() ##Calling 'desc_txtfile' inside 'Game_Details' module details_txt.desc2() ##Calling 'main_code' inside 'Code' module Code.main_code() else: ##If user enters number other than 1 or 2 if menu != 1 or menu != 2: print("\nPLEASE ENTER 1 OR 2 AS YOUR CHOICE!\n") print("-------------------------------------\n") ##Calling 'main_menu' inside 'Menu' module main_menu() return
def translators(self): txt = self.table_ini(center=False, border="0") txt += "<tr><td>" txt += self.dl_ini() li = os.listdir(Code.path_resource("Locale")) salto = len(li) // 2 for n, lng in enumerate(li): d = Util.ini_base2dic( Code.path_resource("Locale", "%s/lang.ini" % lng)) if n >= salto: salto = 99 txt += self.dl_end() txt += "</td><td>" txt += self.dl_ini() txt += self.dl_tit(d["NAME"]) txt += self.dl_elem(d["AUTHOR"]) if "PREVIOUS" in d: txt += self.dl_elem("%s: %s" % (_("Previous"), d["PREVIOUS"])) txt += self.dl_end() txt += "</td></tr>" txt += self.table_end() txt += '<br><big><bold><center>%s: <a href="https://poeditor.com">https://poeditor.com</a></center></bold></big>' % _( "Web") return txt
def comp(line): if line.find('=') > 0: complist1 = line.split('=') return Code.comp(complist1[1].strip('\n')) elif line.find(';') >= 0: complist2 = line.split(';') return Code.comp(complist2[0].strip(' '))
def removeBadCodes(self, blackPegs, whitePegs, currGuess): newCandidateCodes = [] for i in self.candidateCodes: response = Code(i).getClue(currGuess) if response.getWhitePegs() == whitePegs and response.getBlackPegs( ) == blackPegs: newCandidateCodes.append(i) self.candidateCodes = newCandidateCodes.copy()
def train(trainingdocs, classes): import Code print "Beginning training" vocab = set() docs = [] bigdoc = [] logprior = {} loglikelihood ={} for item in trainingdocs: docname = item[0] doctext = Code.get_text(docname) email = Code.ProcessedEmail(doctext) #get vocab #V <- set of words in docs vocab = vocab | (Code.get_vocab(email)) print "VOCAB CREATED" #Nd =number of docs Nd = len(trainingdocs) for c in classes: bigdoc = Code.get_docs_in_class(c, trainingdocs) #Nc = number of docs from D in c Nc = len(bigdoc) #calc prior logprior[c] = math.log(Nc / float(Nd)) #print(logprior[c]) total=total_words_in_docs(bigdoc) #bigdoc[c] <- append d for d EE D with class c #bigdoc = Code.getdocsinclass(str(c), docs) #print "BIG" #print bigdoc i=0 for word in vocab: i = i+1 percent = float(float(i) / len(vocab)) * 100 #print "class: " + str(c) #print "word " + str(i) + "/" + str(len(vocab)) # print str(float(int(percent*10))/10)+"%" countwc = count_words_in_docs(word, bigdoc) x = float(countwc + 1) y = float((total + len(vocab))) loglikelihood[word, c] = math.log(x/y) #ENABLE THIS TO GET GOOD IDEA OF ASSOCIATION OF WORDS AND CLASSES #print "likelihoods:" #for word in loglikelihood: # print str(word) + ": " + str(loglikelihood[word]) return (logprior, loglikelihood, vocab)
def __call__(self, *args): if type(self.code) == Code.FunctionType: self.code() else: Code.execute(self.code, verbose=False) Code.LiveObject.__call__(self) return
def buildCode(line): binaryString = '' if '@' in line: binaryString += '0' + symbolToBinary(''.join(line[1:])) else: binaryString += '111' + c.comp(comp(line)) + c.dest( dest(line)) + c.jump(jump(line)) binaryString += "\n" return binaryString
def put_line_debug(self, line: str): if self.working: Code.xpr(self.name, "put>>> %s\n" % line) self.stdin_lock.acquire() line = line.encode() if self.log: self.log_write(">>> %s\n" % line) self.stdin.write(line + b"\n") self.stdin.flush() self.stdin_lock.release()
def total_words_in_docs(docs): import Code total=0 #print "docs; " + str(docs) for doc in docs: email = Code.ProcessedEmail(Code.get_text(doc)) total += len(Code.get_vocab(email)) #print "sum" + str(total) return total
def main(): if len(sys.argv) < 2: print(u"使い方: %s FILENAME" % sys.argv[0]) sys.exit(1) asm_file = sys.argv[1] hack_file = os.path.splitext(asm_file)[0] + ".hack" st = SymbolTable() # SymbolTable作成 with Parser(asm_file) as hp: # ROM アドレス op_address = 0 # 1行ごとに読みながら, ROMアドレス番号を保持 while hp.advance() != None: cmd_type = hp.commandType() if cmd_type == A_COMMAND or cmd_type == C_COMMAND: op_address += 1 elif cmd_type == L_COMMAND: st.addEntry(hp.symbol(), op_address) # シンボルをアドレスに置き換え, 機械語コードの生成 with Parser(asm_file) as hp: with open(hack_file, 'w') as wf: # 1行ごとに構文解析 while hp.advance() != None: cmd_type = hp.commandType() # print(cmd_type) # A_COMMAND の変数を処理 if cmd_type == A_COMMAND: symbol = hp.symbol() m = SYMBOL_PATTERN.match(symbol) if m.group(1): # @100など bincode = '0' + int_to_bin(int(m.group(1))) # SymbolTableに書き込み elif m.group(2): # @SYMBOL など # symbol = m.group(2) if st.contains(symbol): address = st.getAddress(symbol) bincode = '0' + int_to_bin(address, 15) else: st.addVariable(symbol) address = st.getAddress(symbol) bincode = '0' + int_to_bin(address, 15) elif cmd_type == C_COMMAND: bincode = "111" + Code.comp(hp.comp()) + Code.dest( hp.dest()) + Code.jump(hp.jump()) if cmd_type != L_COMMAND: wf.write(bincode + '\n')
def _c_has_jump(dest_comp_jump): if "=" in dest_comp_jump[0]: dest_comp = dest_comp_jump[0].split("=") dest = Code.c_dest_binary(dest_mnemonic(dest_comp[0])) comp = Code.c_comp_binary(comp_mnemonic(dest_comp[1])) else: #no dest in jump scenario dest = Code.c_dest_binary("null") comp = Code.c_comp_binary(dest_comp_jump[0]) jump = Code.c_jump_binary(dest_comp_jump[1]) return comp + dest + jump
def jump(self): """ gets where to jump to afterwards :return: """ if self.command_type() == CONTROL_COMMAND: if ";" in self.current_command: return Code.jump(self.current_command.split(';')[1]) else: return Code.jump("")
def code_setup(): ''' Set up code_solution and code_effect dictionaries and send code_solution to Dawn ''' global code_solution global code_effect code_solution = Code.assign_code_solution() code_effect = Code.assign_code_effect() msg = {"codes_solutions": code_solution} lcm_send(LCM_TARGETS.DAWN, DAWN_HEADER.CODES, msg)
def dest(self): """ gets the destination in string form :return: the destination """ if self.command_type() == CONTROL_COMMAND: if '=' in self.current_command: return Code.dest(self.current_command.split('=')[0]) else: return Code.dest("")
def __init__(self, target): index = target.find('.asm') if (index < 1): raise RuntimeError("error, cannot use the filename: " + target) self.inputFileName = target self.outputFileName = self.inputFileName[:index] + '.hack' self.parser = Parser(self.inputFileName) self.code = Code() self.st = SymbolTable()
def saveAllPNG(self, name, px): for pieza in "pnbrqk": for color in "wb": fich = Code.path_resource("Pieces", name, "%s%s.svg" % (color, pieza)) with open(fich, "rb") as f: qb = QtCore.QByteArray(f.read()) pm = QtGui.QPixmap(px, px) pm.fill(QtCore.Qt.transparent) render = QtSvg.QSvgRenderer(qb) painter = QtGui.QPainter() painter.begin(pm) render.render(painter) painter.end() pm.save(Code.path_resource("IntFiles", "Figs", "%s%s.png" % (color, pieza)), "PNG")
def test_get_multiple_episodes(self): ep_list = Code.get_episodes([8, 10, 15, 16]) self.assertEqual(len(ep_list), 4) self.assertEqual(ep_list[0][0], '8') self.assertEqual(ep_list[1][0], '10') self.assertEqual(ep_list[2][0], '15') self.assertEqual(ep_list[3][0], '16') self.assertEqual(Code.get_episodes([]), 'error') self.assertRaises(TypeError, Code.get_episodes(), ['b']) mocked_parameter = Mock() ret_val = Code.get_episodes(mocked_parameter) self.assertFalse(mocked_parameter.called) self.assertEqual(ret_val, 'error')
def test_get_multiple_character(self): char_list = Code.get_characters([1, 2, 4, 6]) self.assertEqual(len(char_list), 4) self.assertEqual(char_list[0][0], '1') self.assertEqual(char_list[1][0], '2') self.assertEqual(char_list[2][0], '4') self.assertEqual(char_list[3][0], '6') self.assertEqual(Code.get_characters([]), 'error') self.assertRaises(TypeError, Code.get_characters(), ['a']) mocked_parameter = Mock() ret_val = Code.get_characters(mocked_parameter) self.assertFalse(mocked_parameter.called) self.assertEqual(ret_val, 'error')
def __init__(self, filename): self.Symbol_Table = Symbol_table_module.Symbol_table() self.code = Code.code_module() self.rom = 0 self.Ram_address = 16 self.file = filename self.out_file = open(self.file.replace(".asm", ".hack"), 'w')
def vm(filename): '''implementing virtual machine''' pyc_lst=functions.pyc_list(filename) # print pyc_lst code_obj=Code.code(pyc_lst) execute(code_obj) return
def main(): input_file_path = parse_arguments() output_file_path = input_file_path[: input_file_path.find('.')] + '.hack' symbolTable = SymbolTable() parser = Parser(input_file_path, symbolTable) parser.add_labels_to_symbol_table() with open(output_file_path, "w") as f: while parser.has_more_instructions(): parser.advance() code = Code(parser.instruction_type(), parser.get_instruction_fields()) try: machine_instruction = code.convert_instruction_to_machine_code() f.write(machine_instruction) f.write('\n') except InstructionError as e: print(str(e) + ' ' + parser.get_instruction())
def __init__(self, code=Code([])): # the hidden code self.code = code # the list of all codes guessed over the course of the game self.guessList = [] # the list of all clues returned over the course of the game self.clueList = []
def create_new(self): with open(Code.path_resource("IntFiles", "mate.15"), "rt", encoding="utf-8") as f: li = [linea.strip() for linea in f if linea.strip()] with self.db_config() as dbc: siguiente = dbc["NEXT"] if siguiente is None: siguiente = 0 if siguiente >= len(li): siguiente = 0 linea = li[siguiente] dbc["NEXT"] = siguiente + 1 # 8/4K1P1/4B3/4k3/4r3/4R3/8/6Q1 w - - 0 1|Shahmat besteciliyi,2006,ABDULLAYEV Elmar|g1e1|{'e5f4': 'e1g3', 'e4e3': 'e1e3', 'e5d4': 'e1c3'} fen, info, move1, cdic = linea.split("|") m15 = Mate15() m15.fen = fen m15.pos = siguiente m15.info = info m15.move = move1 m15.resp = eval(cdic) with self.db() as db: db[str(m15.date)] = m15.save() self.li_data.insert(0, m15) return m15
def parse_asm_file(file_name): """ Gets the commands list using the parser and scans it twice first time searching for labels, second time uses the code to translate the A and C commands to machine code. Adds the machine code to a new .hack file Input: file_name - the .asm file needed to be translated Output: the translated file_name.hack file """ line = 0 symbols_table = SymbolsTable() hack_lines = [] Parser.parse(file_name) # First pass for command in Parser.get_commands(): if command.type == Command.L_COMMAND: symbols_table.add_label(command.content, line) else: line += 1 # Second pass for command in Parser.get_commands(): if command.type == Command.A_COMMAND: if not str(command.content).isnumeric(): if not symbols_table.contains(command.content): # a new variable symbols_table.add_variable(command.content) command.content = symbols_table.get_address(command.content) elif command.type == Command.L_COMMAND: continue hack_lines.append(Code.code(command)) #writes the hack file with open(file_name[:-ASM_SUFF_LEN] + HACK_SUFF, mode=W_FILE_MODE, encoding=DEF_ENCODING) as hack_file: for line in hack_lines: hack_file.write('%s\n' % line)
def menuFNS(self, menu, label, xopcion): td = TrainingDir(Code.path_resource("Trainings")) td.addOtherFolder(self.configuration.personal_training_folder) td.addOtherFolder(self.configuration.folder_tactics()) bmenu = menu.submenu(label, Iconos.Carpeta()) td.reduce() # Elimina carpetas vacias td.menu(bmenu, xopcion)
def testC(p,exD,exC,exJ): d = p.dest() c = p.comp() j = p.jump() print d,c,j dbin = Code.dest(d) cbin = Code.comp(c) jbin = Code.jump(j) if dbin != exD: print "Dest binary does not match. Expected:",exD,"Got:",dbin if cbin != exC: print "Comp binary does not match. Expected:",exC,"Got:",cbin if jbin != exJ: print "Jump binary does not match. Expected:",exJ,"Got:",jbin return "111" + cbin + dbin + jbin
def get_comp(c_command): """ Returns the 'comp' mnemonic in the current C-command (28 possibilities). Should be called only when command_type() is C_COMMAND :param c_command: String :return: String """ if '=' in c_command: c_command = c_command.split('=')[1] if ';' in c_command: c_command = c_command.split(';')[0] comp = Code.get_comp_bin(c_command) return comp
def get_dest(c_command): """ Returns the 'dest' mnemonic in the current C-command (8 possibilities). Should be called only when command_type() is C_COMMAND :param c_command: String :return: String """ # Get the mnemonic for the destination part of the C-command if '=' in c_command: dest_str = c_command.split('=')[0] else: dest_str = "" dest = Code.get_dest_bin(dest_str) return dest
def get_jump(c_command): """ Returns the 'jump' mnemonic in the current C-command (8 possibilities). Should be called only when command_type() is C_COMMAND :param c_command: String :return: String """ # Get the mnemonic for the jump part of the C-command if ';' in c_command: jump_str = c_command.split(';')[-1] else: jump_str = "" jump = Code.get_jump_bin(jump_str) return jump
def __init__(self, impl, name="__pyxutil", prefix="", requires=None, file=None, from_scope=None, context=None): # 1) We need to delay the parsing/processing, so that all modules can be # imported without import loops # 2) The same utility code object can be used for multiple source files; # while the generated node trees can be altered in the compilation of a # single file. # Hence, delay any processing until later. if context is not None: impl = Code.sub_tempita(impl, context, file, name) self.impl = impl self.name = name self.file = file self.prefix = prefix self.requires = requires or [] self.from_scope = from_scope
def getParsedEqual(self): if '=' in self.currentCommand: parsedCommandArray = self.currentCommand.split('=') dest = Code.dest(parsedCommandArray[0]) cmp = Code.comp(parsedCommandArray[1]) jmp = Code.jump(None) elif ';' in self.currentCommand: parsedCommandArray = self.currentCommand.split(';') dest = Code.dest(None) cmp = Code.comp(parsedCommandArray[0]) jmp = Code.jump(parsedCommandArray[1]) return equalString % (cmp, dest, jmp)
def main(): """Drives the entire translation process.""" """Preprocess the file""" pp = Preprocessor() pp.remove_white_spaces_comments() pp.write_temp_file() """First pass - adds labels to the symbol table.""" parser = Parser(sys.argv[1] + '.tmp') symbol_table = SymbolTable() pc = -1 while parser.has_more_commands(): parser.advance() command_type = parser.command_type() if command_type == 'A_COMMAND' or command_type == 'C_COMMAND': pc += 1 elif command_type == 'L_COMMAND': label = parser.symbol() symbol_table.addEntry(label, pc + 1) """Second pass - handles variables names and writes the *.hack file.""" ram_address = 16 parser = Parser(sys.argv[1] + '.tmp') code = Code() file_name = parser.get_file_name() hack_file = open(file_name + '.hack', 'w') while parser.has_more_commands(): parser.advance() command_type = parser.command_type() if command_type == 'A_COMMAND': a_symbol = parser.symbol() if a_symbol[0] in '0123456789': a_symbol_binary = code.convert_to_binary(a_symbol) hack_file.write('0' + a_symbol_binary + '\n') else: if symbol_table.contains(a_symbol) is False: symbol_table.addEntry(a_symbol, ram_address) ram_address += 1 address = symbol_table.GetAddress(a_symbol) address_binary = code.convert_to_binary(address) hack_file.write('0' + address_binary + '\n') elif command_type == 'C_COMMAND': comp = code.comp(parser.comp()) dest = code.dest(parser.dest()) jump = code.jump(parser.jump()) hack_file.write('111' + comp + dest + jump + '\n') hack_file.close()
def jump(self): if self.commandType() == commandsType.C_COMMAND: return Code.jump(self.currentCommand) raise Exception("The current command: %s is not of a type %s" % (self.currentCommand, commandsType.C_COMMAND))
# Second pass print "second pass" currentLine = 0 asm_file = Parser.initialize(asm_filename) decOfNewSymbol = 16 while Parser.hasMoreCommands(numLines, currentLine): command = Parser.advance(asm_file) commandType = Parser.commandType(command) if commandType == 'C_COMMAND': print command destmnemonic = Parser.dest(command) print destmnemonic destbin = Code.dest(destmnemonic) compmnemonic = Parser.comp(command) print compmnemonic compbin = Code.comp(compmnemonic) jumpmnemonic = Parser.jump(command) jumpbin = Code.jump(jumpmnemonic) output.write("111%s%s%s\n" % (compbin, destbin, jumpbin)) elif commandType == 'A_COMMAND': # print 'A_command, %s' % command # if @number ... output binary of that, else output binary of the corresponding value in the symbolTable symbol = Parser.symbol(command) # print 'Symbol %r' % symbol # print 'R0\r' == symbol if re.match('^([0-9]+)', symbol) != None: # print 'found a number' binStr = format(int(symbol), 'b')
p.advance() print testC(p,"010","1000111","010") print "A=M;JLT" p.advance() print testC(p,"100","1110000","100") print "D;JGE" p.advance() print testC(p,"000","0001100","011") print "0;JMP" p.advance() print testC(p,"000","0101010","111") print "done testing C=====" print "=====Testing decimalConstantToBinaryString" binary = Code.decimalConstantToBinaryString("33") if binary != "000000000100001": print "Bad conversion. Got:",binary,"Expected: 000000000100001" binary = Code.decimalConstantToBinaryString("267") if binary != "000000100001011": print "Bad conversion. Got:",binary,"Expected: 000000100001011" print "done testing decimalConstantToBinaryString====="
symbolTable.addEntry(parser.symbol(), romAddress) else: romAddress += 1 # This opens the file that will be written to. hackFilename = asmFilename[:-3] + "hack" hackFile = open(hackFilename, "w") # This writes the translated code to the hack file. parser.restart() ramAddress = 16 while parser.hasMoreCommands(): parser.advance() commandType = parser.commandType() if commandType == "C_COMMAND": hackFile.write("111" + Code.comp(parser.comp()) + Code.dest(parser.dest()) + Code.jump(parser.jump()) + "\n") elif commandType == "A_COMMAND": symbol = parser.symbol() try: address = int(symbol) except: if symbolTable.contains(symbol): address = symbolTable.getAddress(symbol) else: address = ramAddress # This adds an A command symbol to the symbol table if it's not already in it. symbolTable.addEntry(symbol, address) ramAddress += 1 hackFile.write(bin(address)[2:].zfill(16) + "\n")
def connect_instance_port_names_to_module_port_names( parent_module, gbl, list_of_named_port_connections, mod_inst ) : for (port_i, expr) in list_of_named_port_connections: print port_i,"=>",expr for (port_i, expr) in list_of_named_port_connections: # first, check the named ports exist in the new instance. port_name = port_i[1] # port_i[0] = 'port_identifier' sig = mod_inst.get_named_signal_from_scope(port_name) if not sig: return False # fixme - check port directions are compatible assert sig.is_port if sig.port_dir == 'in': # create code for: assign port = <expr> print "Input Port is same as: assign %s = %s" % (sig.hier_name, str(expr[1:]) ) expr_code, sigs = Code.code_eval_expression(parent_module, gbl, expr[1:]) #print "expr_code=",expr_code," sigs in expr=", #for s in sigs: print s.hier_name, #print # make the port name look like a net_identifier lvalue wire = port_i[:] wire[0] = 'net_identifier' lvalue = [ 'net_lvalue', wire ] # create code to assign the expr to the lvalue (port) code = Code.code_assign_expr_code_to_lvalue( mod_inst, gbl, lvalue, expr_code) print "Code=",code # Add event for initial assignment. simcode = gbl.create_and_add_code_to_events( code, 0, 'active_list' ) # Now we need to add the lvalue to the dependency list of all # signals in the expression (in sigs). In practice we need to recompute # the expression if any of the signals change. But we already have the # simcode to do that - we just need to invoke it when needed. if sigs: add_dependent_simcode_to_signals( simcode, sigs ) else: # sig port is output print "Output Port is same as:assign %s = %s" % (str(expr[1:]), sig.hier_name ) # Create code to evaluate (look up) the value of the child module's signal. # First, make signal look like an expression. sig_expr = [ 'net_identifier', sig.local_name ] expr_code, sigs = Code.code_eval_expression(mod_inst, gbl, sig_expr) # Make the expr[1] look like an lvalue lvalue = [ 'net_lvalue', expr[1:] ] print "lvalue is", str(lvalue), "\ncode to eval sig is",expr_code # create code to assign the expr to the lvalue (port) code = Code.code_assign_expr_code_to_lvalue( parent_module, gbl, lvalue, expr_code) print "Code=",code # Add event for initial assignment. simcode = gbl.create_and_add_code_to_events( code, 0, 'active_list' ) # Now we need to invoke code whenever the child signal value changes. assert sigs # Must be exactly one. add_dependent_simcode_to_signals( simcode, sigs ) return True
ctype = Parser.commandType(line) #compare command type if ctype is 'A_COMMAND': AS = Parser.symbol(line) AS1 = bin(int(AS))[2:] AString = AS1.zfill(15) wfile.write('0'+AString+'\n') # L has no meaning elif ctype is 'L_COMMAND': LString = Parser.symbol(line) wfile.write('0'+LString+'\n') if ctype is 'C_COMMAND': DestString = Code.dest(line) CompString = Code.comp(line) JumpString = Code.jump(line) wfile.write('111'+CompString+DestString+JumpString+'\n') line = Parser.advance(rfile, line) flag = Parser.hasMoreCommands(line) rfile.close() wfile.close()
# Sets whether it's using B in the comp comp = parser.comp() if comp.find('B') == -1: commandStart += '1' else: commandStart += '0' comp = comp.replace('B', 'D') # Sets whether it's using B in the dest dest = parser.dest() if dest == None or dest.find('B') == -1: commandStart += '1' else: commandStart += '0' hackFile.write(commandStart + Code.comp(comp) + Code.dest(dest) + Code.jump(parser.jump()) + '\n') elif commandType == 'A_COMMAND': symbol = parser.symbol() try: address = int(symbol) except: if symbolTable.contains(symbol): address = symbolTable.getAddress(symbol) else: address = ramAddress # This adds an A command symbol to the symbol table if it's not already in it. symbolTable.addEntry(symbol, address) ramAddress += 1 hackFile.write(bin(address)[2:].zfill(16) + '\n')
def run(self): if type(self.code) == Code.func_type: self.code() else: Code.execute(self.code, verbose=False) return
else: i += 1 #pass 1 parser.reset() while parser.hasMoreCommands(): parser.advance() type = parser.commandType() if type == "A": sym = parser.symbol() #sym is a constant if ord(sym[0]) >= ord("0") and ord(sym[0]) <= ord("9"): outFile.write("0" + Code.decimalConstantToBinaryString(sym) + "\n") #sym is in table elif symbolTable.contains(sym): outFile.write("0" + symbolTable.getAddress(sym) + "\n") #sym is a new var else: symbolTable.addVariable(sym) outFile.write("0" + symbolTable.getAddress(sym) + "\n") elif type == "C": d = Code.dest(parser.dest()) c = Code.comp(parser.comp()) j = Code.jump(parser.jump()) outFile.write("111" + c + d + j + "\n") outFile.close()
def dest(self): if self.commandType() == commandsType.C_COMMAND: return Code.dest(self.currentCommand) raise Exception("The current command: %s does not carry a dest" % self.currentCommand)
def create_and_add_code_to_events(self, code, c_time, list_type): ''' Convenient helper function ''' simcode = Code.code_create_uniq_SimCode(self, code) self.add_simcode_to_events(simcode, c_time, list_type) return simcode