def and_sides(s,e): if e.all[K_LEFT]: log('moving diagonally:-)') s.move_cursor_h(-1) if e.all[K_RIGHT]: log('moving diagonally:-)') s.move_cursor_h(1)
def and_updown(s,event): if event.all[K_UP]: log('moving diagonally:-)') s.move_cursor_v(-1) if event.all[K_DOWN]: log('moving diagonally:-)') s.move_cursor_v(1)
def start(): colors.cache(args) root.render() try: #if args.lesh: # something = root.root['lesh'].command_line #else: something = root.root['some program'].ch.statements.items[1] root.cursor_c, root.cursor_r = project.find(something, root.lines) #root.cursor_c += 1 except Exception as e: log (e.__repr__(), ", cant set initial cursor position") #import parser_test #parser_test.test(root.root['some program'].ch.statements.items[0]) if args.load: load(args.load) if args.run: load(args.run) root.root['loaded program'].run() if args.replay: do_replay(False)
def alternative_int(s, sym, val, length=1): assert type(sym) == symbol_int assert type(val) == int r = lib.marpa_r_alternative(s.r, sym, val, length) if r != lib.MARPA_ERR_NONE: log(codes.errors[r])
def resize(size): global screen_surface, screen_width, screen_height log("resize to "+str(size)) rpcing_frames.sdl_screen_surface = screen_surface = pygame.display.set_mode(size, flags) screen_width, screen_height = screen_surface.get_size() resize_frames() redraw_all(555)
def do_post_render_move_cursor(s): if isinstance(s.root.post_render_move_caret, int): s.move_cursor_h(s.root.post_render_move_caret) else: #its a node log("moving cursor to " +str(s.root.post_render_move_caret)) s.cursor_c, s.cursor_r = project.find(s.root.post_render_move_caret, s.lines) s.root.post_render_move_caret = 0
def on_keypress(self, event): event.frame = self event.cursor = (self.cursor_c, self.cursor_r) event.atts = self.atts if self.top_keypress(event): if args.log_events: log("handled by root frame") return True element = self.under_cursor #new style handlers #if element != None and element.dispatch_levent(event): # return True #old style while element != None: assert isinstance(element, Element), (assold, element) if element.on_keypress(event): break assold = element element = element.parent #some element handled it if element != None: if args.log_events: log("handled by "+str(element)) return True
def dump_parents(self): element = self.under_cursor while element != None: assert isinstance(element, Element), (assold, element) log(str(element)) assold = element element = element.parent
def handle_keypress(e): ph = potential_handlers(e.trip) log(e) for k, (elem, handler) in ph: #log("matching with %s:%s..", k, handler) if ( (e.mods == k.mods and e.key == k.key) or (k.key == UNICODE and e.uni and len(e.mods) == 0 and e.key not in (keys.K_ESCAPE, keys.K_BACKSPACE, keys.K_DELETE))): e.any = e.trip.middle or e.trip.left or e.trip.right e.left, e.middle, e.right = ( e.trip.left if e.trip.left and e.trip.left.get(Att.elem) == elem else None, e.trip.middle if e.trip.middle and e.trip.middle.get(Att.elem) == elem else None, e.trip.right if e.trip.right and e.trip.right.get(Att.elem) == elem else None) e.atts = e.middle or e.left or e.right #this should be named "my", to reflect that is corresponds to the node thats gonna handle it, # not some of its children (as opposed to "any") log("match:%s.%s", elem, handler.func) return elem, handler.func(elem, e)
def prepare_grammar(s, scope): #s.marpa.t.input.clear() log("prepare grammar..") for i in s.editor.root.flatten(): i.forget_symbols() # todo:start using visitors s.marpa.collect_grammar(scope) assert s.current_parser_node s.marpa.enqueue_precomputation(weakref(s.current_parser_node))
def resize_frame(): rows, cols = scr.getmaxyx() log("H:%s W:%s"%(rows, cols)) window.resize(rows, cols) frame.rows = rows frame.cols = cols
def cls_palette(cls, scope): r = [] for x in scope: x = x.compiled if x.decl == cls.decl: log( x, x.decl, cls.decl) r += [CompilerMenuItem(Ref(x))] return r
def maybe_draw(s): if not s.visible: return must_recollect = s.counterpart.must_recollect() if must_recollect: s.tags.dirty = s.lines.dirty = True if must_recollect or s.lines.dirty or s.tags.dirty or s.must_redraw:# or not args.rpc: log("drawing %s, must_recollect = %s, lines.dirty = %s, must_redraw = %s", s.counterpart, must_recollect, s.lines.dirty, s.must_redraw) s.draw() s.must_redraw = False
def events(s): count = s.check_int(lib.marpa_g_event_count(s.g)) log('%s events'%count) result = ffi.new('Marpa_Event*') for i in xrange(count): event_type = s.check_int(lib.marpa_g_event(s.g, result, i)) event_value = result.t_value r = event_type, event_value log(i,r) yield r
def loop(): draw() inp = scr.getch(root.cursor_r,root.cursor_c) dummy_allkeys = [False]*(keys.K_MAX+1)#curses wont tell us what other keys are pressed at any moment if inp in curses2sdl: lemon.handle(lemon.KeypressEvent(dummy_allkeys, False, curses2sdl[inp], 0)) else: lemon.handle(lemon.KeypressEvent(dummy_allkeys, unichr(inp), 0, 0)) log(inp, c.unctrl(inp))
def add(e): global is_first_input_event, _ignored #log((is_first_input_event, _ignored)) if is_first_input_event and not _ignored: clear_replay() with open(replay_file, "ab") as f: try: log("pickling:%s",e) pickle.dump(e, f) except pickle.PicklingError as error: log("%s, are you profiling? (%s)", error, e) is_first_input_event = _ignored = False
def initially_position_cursor(): root.render() try: #if args.lesh: # something = root.root['lesh'].command_line #else: something = root.root['some program'].ch.statements.items[1] root.cursor_c, root.cursor_r = project.find(something, root.lines) #root.cursor_c += 1 except Exception as e: log (e.__repr__(), ", cant set initial cursor position")
def test0(): symbol("banana") # print syms.banana try: xxx = syms.orange assert False except KeyError: pass rule("banana_is_a_fruit", symbol('fruit'), syms.banana) known('X') known('Y') rule( 'why',syms.X, syms.Y) log("test0:", syms._dict, rules._dict)
def setup(): log("SETUP") symbol('start') symbol('any') g.start_symbol_set(syms.start) symbol('statement') rule('start', syms.start, syms.statement) symbol('expression') rule('expression_is_statement', syms.statement, syms.expression) symbol('digit') symbol('digits') for i in [chr(j) for j in range(ord('0'), ord('9')+1)]: rule(i + "_is_a_digit",syms.digit, known(i)) sequence('digits_is_sequence_of_digit', syms.digits, syms.digit, join) symbol('number') rule('digits_is_number', syms.number, syms.digits, (ident, int)) rule('number_is_expression',syms.expression, syms.number) # #multiplication's syntax 1: ChildTag("A"), '*', ChildTag("B") #register_grammar: # s.symbol = new_symbol() # rhs = [] # for i in syntax: # if i.type == ChildTag: # rhs.append(s.ch[i.name].symbol) # if i.type == str: # rhs.append(known(i)) # ... symbol('string_body') symbol('string') sequence('string_body_is_sequence_of_any', syms.string_body, syms.any) rule('string', syms.string, [known("'"), syms.string_body, known("'")]) rule('string_is_expression', syms.expression, syms.string) symbol('multiplication') rule('multiplication', syms.multiplication, [syms.expression, known('*'), syms.expression], tuple) rule('multiplication_is_expression',syms.expression, syms.multiplication) symbol('do_x_times') rule('do_x_times',syms.do_x_times, [known_string('do'), syms.expression, known_string('times:')], tuple) #rule('do_x_times_is_expression',syms.expression, syms.do_x_times) rule('do_x_times_is_statement',syms.statement, syms.do_x_times)
def resize_frames(): c.logframe.rect = Rect ( 0, screen_height - args.log_height, screen_width, args.log_height * get_font(0).height) # log frame uses default font c.editor.rect = Rect(0,0, screen_width // 3 * 2, screen_height - c.logframe.rect.height) sidebar_rect = Rect(c.editor.rect.w, 0, screen_width - c.editor.rect.width, c.editor.rect.height) for frame in c.sidebars: frame.rect = sidebar_rect log("resized frames")
def do_post_render_move_cursor(s): m = s.counterpart.root.delayed_cursor_move if m.node: log("moving cursor to %s", m.node) pos = s.find_element(m.node) if pos: s._move_cursor_v(s.cursor_r - pos[1] + s.scroll_lines) s.cursor_c = pos[0] if m.chars: log("moving cursor by %s chars", m.chars) s._move_cursor_h(m.chars) if m.node != None or m.chars != 0: m.node = None m.chars = 0 s.update_atts_on_server()
def feed(s, inp): s.g = Grammar() # this calls symbol_new() repeatedly inp.num_syms times, and gathers the # results in a list # this is too smart. also, todo: make symbol_new throw exceptions s.c_syms = list(starmap(s.g.symbol_new, repeat(tuple(), inp.num_syms))) if args.log_parsing: log('s.c_syms:%s',s.c_syms) s.g.start_symbol_set(s.c_syms[inp.start]) s.c_rules = [] for rule in inp.rules: if rule[0]: # its a sequence _, _, lhs, rhs, action, sep, min, prop = rule s.c_rules.append(s.g.sequence_new(lhs, rhs, sep, min, prop)) else: _, _, lhs, rhs, _ = rule s.c_rules.append(s.g.rule_new(lhs, rhs)) s.g.precompute() #check_accessibility() s.send(Dotdict(message = 'precomputed', for_node = inp.for_node))
def collect_grammar(s,scope:list): assert scope == uniq(scope) s.clear() s.scope = scope s.named_symbol('start') #s.set_start_symbol(s.syms.start) s.named_symbol('nonspecial_char') s.named_symbol('known_char') s.named_symbol('maybe_spaces') s.sequence('maybe_spaces', s.syms.maybe_spaces, s.known_char(' '), action=ignore, min=0) for i in scope: #the property is accessed here, forcing the registering of the nodes grammars sym = i.symbol if sym != None: if args.log_parsing: log(sym) rulename = 'start is %s' % s.symbol2debug_name(sym) else: rulename = "" s.rule(rulename , s.syms.start, sym)
def gen_graph(root): try: import pydot except Exception as e: log(str(e)) log("cant generate graph") return nodes = root.flatten() #print nodes #from compiler.ast import flatten #nodes = flatten(nodes) graph = pydot.Dot(graph_type='digraph') for node in nodes: graph.add_node(pydot.Node(str(node), #style="filled", #fillcolor="green", fontcolor="black")) for node in nodes: parent = node.parent if parent in nodes: graph.add_edge(pydot.Edge(str(parent), str(node), color="black")) graph.set_rankdir("LR") graph.write_gif("graph.gif") log("graph.gif written")
def test1(raw): tokens = raw2tokens(raw) g.start_symbol_set(syms.number) g.precompute() for i in syms._dict.items(): if not g.symbol_is_accessible(i[1]): print ("inaccessible: %s (%s)"%i) r = Recce(g) r.start_input() print ("TEST1") print (g) print (r) for i, sym in enumerate(tokens): print (sym, i+1, symbol2name(sym),raw[i]) assert type(sym) == symbol_int r.alternative_int(sym, i+1) r.earleme_complete() log('ok') #token value 0 has special meaning(unvalued), so lets i+1 over there and insert a dummy over here tokens.insert(0,'dummy') latest_earley_set_ID = r.latest_earley_set() print ('latest_earley_set_ID=%s'%latest_earley_set_ID) b = Bocage(r, latest_earley_set_ID) o = Order(b) tree = Tree(o) import gc for dummy in tree.nxt(): do_steps(tree, tokens, raw, rules) gc.collect() #force an unref of the valuator and stuff so we can move on to the next tree
def parse(s, tokens, raw, rules): r = Recce(s.g) r.start_input() for i, sym in enumerate(tokens): #if args.log_parsing: # log ("input:symid:%s name:%s raw:%s"%(sym, m.symbol2name(sym),raw[i])) #assert type(sym) == symbol_int if sym == None: log("grammar not implemented, skipping this node") else: r.alternative(s.c_syms[sym], i+1) r.earleme_complete() #token value 0 has special meaning(unvalued), # so lets i+1 over there and prepend a dummy tokens.insert(0,'dummy') latest_earley_set_ID = r.latest_earley_set() if args.log_parsing: log ('latest_earley_set_ID=%s'%latest_earley_set_ID) if latest_earley_set_ID == 0: return try: b = Bocage(r, latest_earley_set_ID) except: return # no parse o = Order(b) tree = Tree(o) for _ in tree.nxt(): r=s.do_steps(tree, tokens, raw, rules) yield r
def do_replay(invoked_interactively = True): global we_are_replaying, _ignored if invoked_interactively: _ignored = True if we_are_replaying: log("already replaying") return try: with open(replay_file, "rb") as f: log("replaying...") we_are_replaying = True while 1: try: e = pickle.load(f) except EOFError: break log(e) replay_input_event(e) except IOError as e: log("couldnt open replay.p",e) finally: we_are_replaying = False
def cycle_sidebar(s): s.sidebar = s.sidebars[1 + s.sidebars.index(s.sidebar)] s.after_sidebar_changed() log("sidebar:%s", s.sidebar) redraw(666)
def bye(s): log("deading pygame..") import pygame pygame.quit() log("exit") sys.exit()
def scroll_lines(s, x): if s._scroll_lines != x: s._scroll_lines = x s.tags.dirty = s.lines.dirty = True log("scroll_lines:%s", x)