def do_call(self, parser: BasicParser) -> bool:
parser._stream.save_context()
parser.push_rule_nodes()
while self.pt(parser):
pass
parser.pop_rule_nodes()
return parser._stream.validate_context()
def do_call(self, parser: BasicParser) -> bool:
parser._stream.save_context()
while not parser.read_eof():
res = self.pt(parser)
if res:
return parser._stream.validate_context()
parser._stream.incpos()
parser._stream.restore_context()
parser.undo_last_ignore()
return False
def do_call(self, parser: BasicParser) -> Node:
# save result of current rule
parser.push_rule_nodes()
for pt in self.ptlist:
parser._stream.save_context()
parser.push_rule_nodes()
res = pt(parser)
if res:
parser.pop_rule_nodes()
parser.pop_rule_nodes()
parser._stream.validate_context()
return res
parser.pop_rule_nodes()
parser._stream.restore_context()
parser.pop_rule_nodes()
return False
def do_call(self, parser: BasicParser) -> bool:
if parser.read_eof():
return False
parser._stream.save_context()
res = self.pt(parser)
if not res:
parser._stream.incpos()
return parser._stream.validate_context()
parser._stream.restore_context()
return False
def do_call(self, parser: BasicParser) -> Node:
if parser.begin_tag(self.tagname):
# subcontext
parser.push_rule_nodes()
res = self.pt(parser)
parser.pop_rule_nodes()
if res and parser.end_tag(self.tagname):
tag = parser.get_tag(self.tagname)
# no bindings, wrap it in a Node instance
if type(res) is bool:
res = Node()
# update node cache
parser.tag_node(self.tagname, res)
parser.rule_nodes[self.tagname] = res
# forward nodes
return res
return False
def do_call(self, parser: BasicParser) -> bool:
valueparam = []
for v, t in self.param:
if t is Node:
if v not in parser.rule_nodes:
parser.diagnostic.notify(
error.Severity.ERROR,
"Unknown capture variable : %s" % v,
error.LocationInfo.from_stream(parser._stream, is_error=True),
)
raise parser.diagnostic
valueparam.append(parser.rule_nodes[v])
elif type(v) is t:
valueparam.append(v)
else:
raise TypeError("Type mismatch expected {} got {}".format(t, type(v)))
return parser.eval_hook(self.name, valueparam)
def do_call(self, parser: BasicParser) -> bool:
valueparam = []
for v, t in self.param:
if t is Node:
if v not in parser.rule_nodes:
parser.diagnostic.notify(
error.Severity.ERROR,
"Unknown capture variable : %s" % v,
error.LocationInfo.from_stream(parser._stream,
is_error=True))
raise parser.diagnostic
valueparam.append(parser.rule_nodes[v])
elif type(v) is t:
valueparam.append(v)
else:
raise TypeError("Type mismatch expected {} got {}".format(
t, type(v)))
return parser.eval_hook(self.name, valueparam)
def do_call(self, parser: BasicParser) -> bool:
return parser.peek_text(self.char)
def do_call(self, parser: BasicParser) -> bool:
#if len(parser._ignores) > 0:
# parser._ignores[-1](parser)
parser.skip_ignore()
return True
def do_call(self, parser: BasicParser) -> Node:
parser.push_rule_nodes()
res = parser.eval_rule(self.name)
parser.pop_rule_nodes()
return res
def do_call(self, parser: BasicParser) -> Node:
res = self.pt(parser)
if res:
parser.bind(self.tagname, res)
return res
return False
def do_call(self, parser: BasicParser) -> bool:
return parser.read_until(self.char)
def do_call(self, parser: BasicParser) -> bool:
return parser.read_range(self.begin, self.end)
def do_call(self, parser: BasicParser) -> bool:
return parser.read_text(self.text)
def do_call(self, parser: BasicParser) -> bool:
parser.push_rule_nodes()
while self.pt(parser):
pass
parser.pop_rule_nodes()
return True
def do_call(self, parser: BasicParser) -> bool:
parser.push_rule_nodes()
while self.pt(parser):
pass
parser.pop_rule_nodes()
return True
