def climb_down_from_chair(self): "Should set has_user to False" self.room.objects.append(self.chair) self.chair.has_user = True action = "climb down from chair" parse(action, self.room, self.inv) self.assertFalse(self.chair.has_user)
def turn_on_plaid_lamp(self): "Should set is_lit to True" action = "turn on plaid lamp" self.room.objects.append(self.chair) self.chair.has_user = True parse(action, self.room, self.inv) self.assertTrue(self.ulamp.has_user)
def get_chair_from_dresser(self): "Should add chair to inventory" self.dresser.objects.append(self.chair) self.dresser.is_open = True action = "get chair from dresser" parse(action, self.room, self.inv) self.assertEquals(self.inv, [self.chair])
def test_direction(self): "Direction should return a Room object if the direction is valid, or an error string if it is not valid" action = "south" self.assertEquals(parse(action, self.room, self.inv), self.southern_room) action = "n" self.assertEquals(parse(action, self.room, self.inv), "You cannot go that way.")
def test_invalid_action_with_valid_object(self): "An invalid action will return an action-related error message" action = "stand on lamp" self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.") action = "spit on bed" self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
def test_name_differentiation_when_one_is_in_container(self): """If there are two lamps but one is inside a container, it should recognise two lamps when the container is open and one lamp when when the container is closed""" # dresser is closed self.dresser.objects.append(self.lamp) action = "get lamp" self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.") # dresser is open self.dresser.is_open = True self.assertEquals(parse(action, self.room, self.inv), "More than one object fits that name.")
def read_file(self, fname): """ Simple generator to parse log files """ # Here we try to memory map the file and just use the findall with open(fname, 'r') as logfile: #contents = mmap.mmap(logfile.fileno(), os.stat(fname).st_size) contents = logfile.read() for match in self.rex.finditer(contents, re.MULTILINE | re.DOTALL): thread_id = match.group(1) syscall_number = match.group(2) syscall_name = match.group(3) eip = match.group(4) caller = match.group(5) caller_offset = match.group(6) hexargs = match.group(7) args = match.group(8) #ret = match.group(12) ret = '' hexargs = map(lambda x: x.strip(), hexargs.strip().split(',')) args = parse(args) yield (thread_id, syscall_number, syscall_name, eip, hexargs, args, ret, caller_offset)
def compile(src, out): insts = [] declrs = [] global_env = Scope() for stmt in map(desugar, parse(builtin_declrs + src)): typ = type(stmt) # there are two types of declaration: # delcaration or struct definition if typ == ast.Declaration or typ == ast.DeclrAssign: code = compile_declr(stmt, global_env, declrs) if type(code) == list: insts.extend(code) else: # data declrs.append(code) elif typ == ast.Struct: global_env.add(stmt.name.val, stmt) out.write('.data\n') for declr in declrs: out.write(repr_data(declr) + '\n') out.write('.text\n') for inst in insts: out.write(repr_ir(inst) + '\n') basedir = os.path.dirname(__file__) with open(os.path.join(basedir, 'builtin.s')) as builtin_src: out.write(builtin_src.read())
def test_action_with_adj_when_two_objects_have_same_name(self): """When two objects have the same name but a distinguishing adjective is provided, should perform the action on the correct object""" brass_lamp = Lamp() brass_lamp.description = "A brass lamp with a tarnished base." brass_lamp.on_description = "The light turns on." brass_lamp.off_description = "The light turns off." self.room.objects.append(brass_lamp) # adjective is in object.name action = "light brass lamp" self.assertEquals(parse(action, self.room, self.inv), brass_lamp.on_description) self.assertTrue(brass_lamp.is_lit) # adjective is in object.description action = "snuff tarnished lamp" parse(action, self.room, self.inv) self.assertFalse(brass_lamp.is_lit)
def compile(src, out): insts = [] declrs = [] global_env = Scope() for stmt in map(desugar, parse(builtin_declrs+src)): typ = type(stmt) # there are two types of declaration: # delcaration or struct definition if typ == ast.Declaration or typ == ast.DeclrAssign: code = compile_declr(stmt, global_env, declrs) if type(code) == list: insts.extend(code) else: # data declrs.append(code) elif typ == ast.Struct: global_env.add(stmt.name.val, stmt) out.write('.data\n') for declr in declrs: out.write(repr_data(declr)+'\n') out.write('.text\n') for inst in insts: out.write(repr_ir(inst)+'\n') basedir = os.path.dirname(__file__) with open(os.path.join(basedir, 'builtin.s')) as builtin_src: out.write(builtin_src.read())
def go(program): program = tokenizer.tokenize(program) program = grammar.parse(program) program = syntax.AST(program) #print(program) program = typeChecker.check(program) return program
def index(request, user, language): logger.debug ('entry point') # XXX set language on-the-fly # or pull from db based on users selection on phone # language = LanguageFactory.create_language('eng') if request.method == "GET": logger.debug ('get request') return request_update (user,language) raw_text = request.raw_post_data.decode('UTF8') logger.info ('user: %s text: %s' % (user, raw_text)) # empty request if not raw_text: return request_update (user,language) msg_list = [] tokens = raw_text.split() parsed_text = grammar.parse(tokens, language) command = parsed_text['command'] extras = parsed_text['extras'] member = parsed_text['member'] group_name = parsed_text['group'] if command == language.CREATE: logger.debug('request create group %s' % group_name) # request, user, language, group_name, slot return request_create_group(request, user, language, group_name, '')[1] elif command == language.JOIN: logger.debug('request join group %s' % group_name) # request, user, language, group_name, slot return join_group(request, user, language, group_name)[1] elif command == language.INVITE: # (request, user, language, group_name_or_slot, invite_user_phone, smsc = 'mosms') logger.debug('request invite user %s to group %s' % (user, group_name)) invited_users = ' '.join([member, extras]) return invite_user_to_group(request, user, language, group_name, invited_users)[1] elif command == language.LEAVE: logger.debug('request leave group %s' % group_name) # leave_group (request, user, language, group_or_slot) return leave_group (request, user, language, group_name)[1] elif command == language.DELETE: logger.debug('request delete group %s' % group_name) # delete_group (request, admin, language, group_name_or_slot) return delete_group (request, user, language, group_name)[1] elif command == language.REMOVE: logger.debug('request remove user %s' % user) # delete_user_from_group (request, admin, language, group_name_or_slot, del_user_phone) return delete_user_from_group (request, user, language, group_name, member)[1] elif command == language.SETNAME: logger.debug('request set name user %s, username %s' % (user, username)) return set_username(request, user, language, username)[1] else: return request_update (user,language)[1]
def make_python( fargish_code, file=None, # If None, print to stdout predefs=predefs, preamble=preamble, postamble='', debug=False # If True, print the raw parsed items to stdout ): if file is None: file = sys.stdout file = Indenting(file) items = parse(fargish_code, predefs=predefs) if (debug): print('\n') pp(items) print() env = Env(items) print(preamble, file=file) fixup = Indenting(StringIO()) for item in items: if hasattr(item, 'gen'): try: item.gen(file, fixup, env) except FARGishCompilerException as exc: print('FARGish compiler exception when compiling: ', item) print(exc) raise #TODO This really should become a special item in Env, so that .gen code #can derive things from it. # 'port_mates' is a global variable. You must pass it explicitly to # PortGraph's ctor. print('port_mates = PortMates()', file=file) for link_defn in (i for i in items if isinstance(i, LinkDefn)): fl = repr(link_defn.from_label.name) tl = repr(link_defn.to_label.name) print(f"port_mates.add({fl}, {tl})", file=file) #print('port_hierarchy = Hierarchy()', file=file) for chpa in (i for i in items if isinstance(i, PortLabelParent)): ch = repr(chpa.child) pa = repr(chpa.parent) #print(f'port_hierarchy.declare_parent({pa}, {ch})', file=file) print(f'port_mates.declare_parent({pa}, {ch})', file=file) print('\nnodeclasses = {', file=file) for nodedefn in (i for i in items if isinstance(i, NodeDefn)): name = nodedefn.name print(f' {repr(name)}: {name},', file=file) print('}', file=file) fixup.seek(0) for line in fixup: print(line, file=file, end='') for pa in (i for i in items if isinstance(i, Postamble)): pa.print(file) print(postamble, file=file, end='')
def execute_debug(self, event = None): self.__sym_table_3d = None self.c = 0 # create debug player window = Toplevel() window['bg'] = 'black' label_count = Label(window, text="Execute Now:", borderwidth=0, width=10, bg = "black", fg = "white") label_count.grid(row=0, column=0, sticky="nsew", padx=1, pady=1) label_last = Label(window, text="Executed Before:", borderwidth=0, width=10, bg = "black", fg = "white") label_last.grid(row=0, column=2, sticky="nsew", padx=1, pady=1) self.label_last_line = Label(window, text="Line: 1", borderwidth=0, width=10, bg = "black", fg = "white") self.label_last_line.grid(row=1, column=0, sticky="nsew", padx=1, pady=1) execute = Button(window, text='>', command=self.update_line_debugg) execute.grid(row=1, column=1, sticky="nsew", padx=1, pady=1) self.count = Label(window, text="Line: 0", borderwidth=0, width=10, bg = "black", fg = "white") self.count.grid(row=1, column=2, sticky="nsew", padx=1, pady=1) window.grid_columnconfigure(0, weight=1) window.grid_columnconfigure(1, weight=1) window.grid_columnconfigure(2, weight=1) window.resizable(width=True, height=False) # get all txt from current tab selectedTab = self.tabs.index("current") currentTextArea = self.tabs.winfo_children()[selectedTab+1].textarea input = currentTextArea.get('1.0','end-1c') # new singleton symbol table self.__sym_table = table() # define mode for syntax-tree know how to autoexecute self.__sym_table.setMode(0) # start lex and sintactic analysis ply_left = tenorC.parse() self.__ast = ply_left(tenorC, input, self.__sym_table) # TODO sintax error recover if self.__ast != None: self.__ast.execute(self.__sym_table) self.codeGenerated = self.__ast.get3D()
def parse_re(pattern): """Parses a regular expression pattern and returns a string in a format readable by a custom regex compiler. Parameters: pattern : a string regex pattern Returns: string : a string containing regex pattern converted into string of functions readable by regex compiler """ return convert(parse('RE', pattern, REGRAMMAR)[0])
def play(self, action): """Takes an action and attempts to call it on the game instance. Returns any message that might have been generated.""" location = self.game['location'] inventory = self.game['inv'] message = None update = parse(action, location, inventory) if isinstance(update, Room): self.game['location'] = update return None return update
def initialize(data_matrix, root, old_structure, new_structure, num_iter=200): root = root.copy() if old_structure == new_structure: return root node, old_dist, rule = recursive.find_changed_node(root, old_structure, new_structure) old = root.value() # if we're replacing the root, pass on the observation model; otherwise, treat # the node we're factorizing as exact real-valued observations if node is root: inner_data_matrix = data_matrix else: row_ids = recursive.row_ids_for(data_matrix, node) col_ids = recursive.col_ids_for(data_matrix, node) m_orig, n_orig = recursive.orig_shape_for(data_matrix, node) frv = observations.DataMatrix.from_real_values inner_data_matrix = frv(node.value(), row_ids=row_ids, col_ids=col_ids, m_orig=m_orig, n_orig=n_orig) print 'Initializing %s from %s...' % (grammar.pretty_print(new_structure), grammar.pretty_print(old_structure)) if rule == grammar.parse("gg+g"): new_node = init_low_rank(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("mg+g"): isotropic = (node is root) new_node = init_row_clustering(inner_data_matrix, isotropic, num_iter=num_iter) elif rule == grammar.parse("gM+g"): isotropic = (node is root) new_node = init_col_clustering(inner_data_matrix, isotropic, num_iter=num_iter) elif rule == grammar.parse("bg+g"): new_node = init_row_binary(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("gB+g"): new_node = init_col_binary(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("cg+g"): new_node = init_row_chain(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("gC+g"): new_node = init_col_chain(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("s(g)"): new_node = init_sparsity(inner_data_matrix, node.variance_type, num_iter=num_iter) else: raise RuntimeError('Unknown production rule: %s ==> %s' % (grammar.pretty_print(old_dist), grammar.pretty_print(rule))) root = recursive.splice(root, node, new_node) if isinstance(data_matrix.observations, observations.RealObservations): assert np.allclose(root.value()[data_matrix.observations.mask], old[data_matrix.observations.mask]) return root
def initialize(data_matrix, root, old_structure, new_structure, num_iter=200): root = root.copy() if old_structure == new_structure: return root node, old_dist, rule = recursive.find_changed_node(root, old_structure, new_structure) old = root.value() # if we're replacing the root, pass on the observation model; otherwise, treat # the node we're factorizing as exact real-valued observations if node is root: inner_data_matrix = data_matrix else: row_ids = recursive.row_ids_for(data_matrix, node) col_ids = recursive.col_ids_for(data_matrix, node) m_orig, n_orig = recursive.orig_shape_for(data_matrix, node) frv = observations.DataMatrix.from_real_values inner_data_matrix = frv(node.value(), row_ids=row_ids, col_ids=col_ids, m_orig=m_orig, n_orig=n_orig) print('Initializing %s from %s...' % (grammar.pretty_print(new_structure), grammar.pretty_print(old_structure))) if rule == grammar.parse("gg+g"): new_node = init_low_rank(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("mg+g"): isotropic = (node is root) new_node = init_row_clustering(inner_data_matrix, isotropic, num_iter=num_iter) elif rule == grammar.parse("gM+g"): isotropic = (node is root) new_node = init_col_clustering(inner_data_matrix, isotropic, num_iter=num_iter) elif rule == grammar.parse("bg+g"): new_node = init_row_binary(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("gB+g"): new_node = init_col_binary(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("cg+g"): new_node = init_row_chain(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("gC+g"): new_node = init_col_chain(inner_data_matrix, num_iter=num_iter) elif rule == grammar.parse("s(g)"): new_node = init_sparsity(inner_data_matrix, node.variance_type, num_iter=num_iter) else: raise RuntimeError('Unknown production rule: %s ==> %s' % (grammar.pretty_print(old_dist), grammar.pretty_print(rule))) root = recursive.splice(root, node, new_node) if isinstance(data_matrix.observations, observations.RealObservations): assert np.allclose(root.value()[data_matrix.observations.mask], old[data_matrix.observations.mask]) return root
def repl_line(): line = input('FORMAT> ') if line == 'RELOAD': reload(grammar) global parse parse = grammar.parse elif line == 'EXIT': sys.exit() elif line == 'PYTHON': code.interact(local={**globals(), **locals()}) elif line: result = parse(line) print(result) code.interact(local=locals())
def handle_message(self, message, extra): try: int_tree = grammar.parse(message) tree = grammar.transform(int_tree) # result = "```%s\n\n%s```" % (int_tree.pretty(), tree) return self.handle_command(tree[0], tree[1], extra) except grammar.exceptions.LarkError as error: print(error) return { "error": "```%s```" % error.args[0], "usage": self.usage("general"), "edits": extra.get("edits", None) }
def labelize(rule): if rule == grammar.parse("gg+g"): return 0 elif rule == grammar.parse("mg+g"): return 1 elif rule == grammar.parse("gM+g"): return 4 elif rule == grammar.parse("bg+g"): return 2 elif rule == grammar.parse("gB+g"): return 5 elif rule == grammar.parse("cg+g"): return 3 elif rule == grammar.parse("gC+g"): return 6 elif rule == grammar.parse("s(g)"): return 7 else: raise Exception("Never should reached here.")
def Parser(stringToParse, doLog): result = None if doLog: print(">>> Parsing") print(stringToParse) try: result = grammar.parse(stringToParse, actions=CanopyActions()) if doLog: print(">>> Result") #print (result) print(json.dumps(result, indent=4, separators=(',', ': '))) except Exception as e: print(">>> PARSE ERROR") print(str(e)) return result
def evalQuery(self): from grammar import parse p = parse(self.queryText.toPlainText()) if p: results = [] for jobId, job in self.miner.data.items(): if p(job): results.append(job) #print( job["id"] ) for i, job in enumerate(results): item = JobEntry(None, job) self.queryResultsLayout.addWidget(item) item.show() if i > 4: break else: print("Invalid query!")
def evalQuery( self ): from grammar import parse p = parse( self.queryText.toPlainText() ) if p: results = [] for jobId, job in self.miner.data.items(): if p( job ): results.append( job ) #print( job["id"] ) for i, job in enumerate( results ): item = JobEntry( None, job ) self.queryResultsLayout.addWidget( item ) item.show() if i > 4: break else: print("Invalid query!")
def read_asm_file(filename): """ Reads the assembly file at the given filename. If there is invalid syntax in the file, it will throw an error. This will return a list of parsed instructions in the following format: [List of Instruction] Where Instruction is: [InstructionName [ListOf Argument]] Where Argument is either Register, Offset, or Immediate Where Register is: ['$', RegisterNumber] Where Offset is: [Number, Register or Immediate] Where Immediate is: [Number] or ['-', Number] or ['0x', HexNumber] """ with open(filename, "rb") as f: data = f.read() print len(data.split("\n")) parsed_instructions = grammar.parse(data) if parsed_instructions is None: action, rest = grammar.raw_parse(data) error_char = len(data) - len(rest) data_up_to_error = data[:error_char] line_num = data_up_to_error.count("\n") prev_newline = data_up_to_error.rfind("\n") next_newline = rest.find("\n") if prev_newline < 0: prev_newline = 0 if next_newline < 0: next_newline = len(rest) relative_error_char = error_char - prev_newline print "Syntax error at line %d, character %d" % (line_num + 1, relative_error_char) print data[prev_newline:error_char] + rest[:next_newline] print " " * relative_error_char + "^" return None return parsed_instructions
def read_asm_file(filename): """ Reads the assembly file at the given filename. If there is invalid syntax in the file, it will throw an error. This will return a list of parsed instructions in the following format: [List of Instruction] Where Instruction is: [InstructionName [ListOf Argument]] Where Argument is either Register, Offset, or Immediate Where Register is: ['$', RegisterNumber] Where Offset is: [Number, Register or Immediate] Where Immediate is: [Number] or ['-', Number] or ['0x', HexNumber] """ with open(filename, 'rb') as f: data = f.read() print len(data.split('\n')) parsed_instructions = grammar.parse(data) if parsed_instructions is None: action, rest = grammar.raw_parse(data) error_char = len(data) - len(rest) data_up_to_error = data[:error_char] line_num = data_up_to_error.count('\n') prev_newline = data_up_to_error.rfind('\n') next_newline = rest.find('\n') if prev_newline < 0: prev_newline = 0 if next_newline < 0: next_newline = len(rest) relative_error_char = error_char - prev_newline print "Syntax error at line %d, character %d" % (line_num + 1, relative_error_char) print data[prev_newline:error_char] + rest[:next_newline] print ' ' * relative_error_char + '^' return None return parsed_instructions
from grammar import parse from math import * if __name__ == "__main__": UDPSock = socket(AF_INET, SOCK_DGRAM) UDPSock.bind(('', 1964)) f = open("examples.txt", "a") normalizer = NumeralsNormalizer("numerals.txt") transformer = NumeralsTransformer(normalizer) while True: data, addr = UDPSock.recvfrom(1969) if not data: print("Program has exited!") break else: x = data.decode('utf-8') f.write(x) f.write("\n") print(x.ljust(50), addr[0]) try: result = parse(transformer.replace_with_numbers(x.lower())) print("result: " + str(eval(result)) + "\n") except: pass UDPSock.close()
self.program.append(Instruction('PLUS', None)) else: raise ValueError(node.type) def CALL(self, node): for arg in node.args[::-1]: self.eval(arg) self.eval(node.name) self.program.append(Instruction('CALL', len(node.args))) text = 'x:=0; while x < 5 { print(x); x := x+1; }' from grammar import parse from interpreter import Intepreter, run from pprint import pprint # i = Intepreter() ast = parse(text) # pprint(ast) bcc = ByteCodeCompiler() bcc.compile(ast) i = run(bcc.program) # print i.namespace
def index(request, user, language): logger.debug('entry point') # XXX set language on-the-fly # or pull from db based on users selection on phone # language = LanguageFactory.create_language('eng') if request.method == "GET": logger.debug('get request') return request_update(user, language) raw_text = request.raw_post_data.decode('UTF8') logger.info('user: %s text: %s' % (user, raw_text)) # empty request if not raw_text: return request_update(user, language) msg_list = [] tokens = raw_text.split() parsed_text = grammar.parse(tokens, language) command = parsed_text['command'] extras = parsed_text['extras'] member = parsed_text['member'] group_name = parsed_text['group'] if command == language.CREATE: logger.debug('request create group %s' % group_name) # request, user, language, group_name, slot return request_create_group(request, user, language, group_name, '')[1] elif command == language.JOIN: logger.debug('request join group %s' % group_name) # request, user, language, group_name, slot return join_group(request, user, language, group_name)[1] elif command == language.INVITE: # (request, user, language, group_name_or_slot, invite_user_phone, smsc = 'mosms') logger.debug('request invite user %s to group %s' % (user, group_name)) invited_users = ' '.join([member, extras]) return invite_user_to_group(request, user, language, group_name, invited_users)[1] elif command == language.LEAVE: logger.debug('request leave group %s' % group_name) # leave_group (request, user, language, group_or_slot) return leave_group(request, user, language, group_name)[1] elif command == language.DELETE: logger.debug('request delete group %s' % group_name) # delete_group (request, admin, language, group_name_or_slot) return delete_group(request, user, language, group_name)[1] elif command == language.REMOVE: logger.debug('request remove user %s' % user) # delete_user_from_group (request, admin, language, group_name_or_slot, del_user_phone) return delete_user_from_group(request, user, language, group_name, member)[1] elif command == language.SETNAME: logger.debug('request set name user %s, username %s' % (user, username)) return set_username(request, user, language, username)[1] elif command == language.TEXT: logger.debug('sending sms to group %s' % group_name) return send_group_sms(request, user, language, group_name, extras) else: return request_update(user, language)[1]
def test_two_word_moving(self): "Using a direction in two words (e.g. 'go west') should return a new Room object" action = "go south" self.assertEquals(parse(action, self.room, self.inv), self.southern_room)
def run(string): return parse(filter_ascii(string).strip(), actions=Actions())
def test_invalid_verb(self): "An invalid verb should return an error message" action = "jump" self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
def test_action_on_item_in_room(self): "<action, valid_noun> should perform the appropriate action" action = "open dresser" self.assertEquals(parse(action, self.room, self.inv), self.dresser.open_description)
search => xalphas + search | xalphas login => userpassword hostport | hostport userpassword => user : password @ | user @ user => alphanum2 user | alphanum2 password => alphanum2 password | password path => void | segment / path | segment void => () digits => digit digits | digit digit => [0-9] alpha => [a-zA-Z] safe => [-$_@.&+] extra => [()!*''""] escape => % hex hex hex => [0-9a-fA-F] alphanum => alpha | digit alphanums => alphanum alphanums | alphanum alphanum2 => alpha | digit | [-_.+] ialpha => alpha xalphas | alpha xalphas => xalpha xalphas | xalpha xalpha => alpha | digit | safe | extra | escape """, whitespace = '()') print "--URL grammar:\n",(URL) print verify(URL) print print "--parsed http://www.w3.org/Addressing/URL/5_BNF.html:\n",(parse('url', 'http://www.w3.org/Addressing/URL/5_BNF.html', URL)) print "--print_grammar: URL" print_grammar(URL)
def stand_on_dark_chair(self): "Should set has_User to True" self.room.objects.append(self.chair) action = "stand on dark chair" parse(action, self.room, self.inv) self.assertTrue(self.chair.has_user)
def test_valid_action_with_invalid_object(self): "An action performed on an object that doesn't exist will return an error" action = "look in chest" self.assertEquals(parse(action, self.room, self.inv), "That object does not exist.")
def test_action_with_unhelpful_adj(self): "If adjective is unhelpful but noun does not encounter any conflicts, should call verb on obj" self.room.objects.append(self.chair) action = "climb sturdy chair" self.assertEquals(parse(action, self.room, self.inv), "You clamber onto the object.")
def test_stand_on_object(self): "'stand on' is called as obj.stand()" self.room.objects.append(self.chair) action = "stand on chair" self.assertEquals(parse(action, self.room, self.inv), "You clamber onto the object.")
import grammar import pprint pp = pprint.PrettyPrinter() #pp.pprint(grammar.parse('goal', 'wtf = 7 + 5 + 4 / (7+2) * 3; RAND(4, 7);')) #pp.pprint(grammar.parse('goal', 'Q = INBOX[47];')) #pp.pprint(grammar.parse('goal', 'Q = AREA[47,42];')) x = grammar.parse('goal', 'x = AREA[-2,-3] * (7/4) + y * 8 + INBOX[5] + RAND % 47; MOVE(-1,0);') for st in x: print st.output(2)
parser.add_argument('level', type=int) add_scheduler_args(parser) args = parser.parse_args() init_level(args.name, args.level) if args.level > 1: run_jobs(initial_samples_jobs(args.name, args.level), args, initial_samples_key(args.name, args.level)) elif command == 'init_job': parser.add_argument('name', type=str) parser.add_argument('level', type=int) parser.add_argument('structure', type=str) parser.add_argument('split_id', type=int) parser.add_argument('sample_id', type=int) args = parser.parse_args() compute_init_samples(args.name, args.level, grammar.parse(args.structure), args.split_id, args.sample_id) elif command == 'eval': parser.add_argument('name', type=str) parser.add_argument('level', type=int) add_scheduler_args(parser) args = parser.parse_args() run_jobs(evaluation_jobs(args.name, args.level), args, evaluation_key(args.name, args.level)) collect_scores_for_level(args.name, args.level) elif command == 'eval_job': parser.add_argument('name', type=str) parser.add_argument('level', type=int) parser.add_argument('init_structure', type=str) parser.add_argument('structure', type=str)
def test_look(self): "Verb should return current room's description" action = "look" self.assertEquals(parse(action, self.room, self.inv), self.room.description)
def json_parse(text): return parse("value", text, JSON)
import grammar as g if __name__ == '__main__': f = open("./entrada.txt", "r") input = f.read() print(input) root = g.parse(input) print(root)
import grammar as g if __name__ == '__main__': f = open("./entrada.txt", "r") input = f.read() print(input) g.parse(input) print('> Analisis Finalizado')
def analizar(txt): print("analizando...") print(txt) salida_table() parse(txt)
import grammar import sys prefix = """ #include "map.h" #include <cstdlib> class Player%s : public Unit { public: virtual void RealStep() {""" suffix = """ } }; """ fp = open(sys.argv[1]) data = fp.read() x = grammar.parse('goal', data) print prefix % sys.argv[2] for st in x: print st.output(4) print suffix
def test_action_when_two_objects_have_same_name(self): "When two objects have the same name, return an error message" self.room.objects.append(self.lamp) action = "snuff lamp" self.assertEquals(parse(action, self.room, self.inv), "More than one object fits that name.")
def analizar_select(e): global selected if my_text.selection_get(): selected = my_text.selection_get() print(selected) parse(selected)
def test_action_on_invalid_item(self): "Calling an action on an item that does not exist should return an error message" action = "get boot" self.assertEquals(parse(action, self.room, self.inv), "That object does not exist.")
def execute_current_tab_lef(self): # get all txt from current tab selectedTab = self.tabs.index("current") currentTextArea = self.tabs.winfo_children()[selectedTab+1].textarea input = currentTextArea.get('1.0','end-1c') # new singleton symbol table self.__sym_table = table() # define mode for syntax-tree know how to autoexecute self.__sym_table.setMode(0) # start lex and sintactic analysis ply_left = tenorC.parse() self.__ast = ply_left(tenorC, input, self.__sym_table) # TODO sintax error recover if self.__ast != None: self.__ast.execute(self.__sym_table) self.codeGenerated = self.__ast.get3D() ## start executing ply_left_3d = titus.parse() result = ply_left_3d(titus, self.codeGenerated) if result: ast_3D = result[0] ast_3D.setType("LABEL") ast_3D.setValue("S") ast_3D.root = True self.__sym_table_3d = result[1] # define mode for syntax-tree know how to autoexecute self.__sym_table_3d.setMode(1) goto_called = True start_from = "MAIN" compute = [None, None] while goto_called: goto_called = False self.__sym_table_3d.terminal = self.terminal compute = ast_3D.start_execute(self.__sym_table_3d, start_from) # lookup the last line index = self.terminal.search(r'\n', "insert", backwards=True, regexp=True) txt = self.terminal.get(str(index),'end-1c') if txt == "": index ="1.0" else: index = self.terminal.index("%s+1c" % index) if compute[0]: self.terminal.insert(str(float(index)+1), compute[0]) self.__sym_table_3d.cleanLog() if compute[1]: goto_called = True start_from = compute[1] elif self.__sym_table.error != '': # lookup the last line index = self.terminal.search(r'\n', "insert", backwards=True, regexp=True) txt = self.terminal.get(str(index),'end-1c') if txt == "": index ="1.0" else: index = self.terminal.index("%s+1c" % index) self.terminal.insert(str(float(index)+1), "\nTenorC>> Error Report Generated\n")
def test_invalid_action_on_item(self): "Calling an invalid action on an existing item should return an error message" action = "kick bed" self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")