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)
