kodjo/Sheerka-Old
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Working on #48 : Added BaseExprParser and BaseNodeParser.py

Browse Source
This commit is contained in:
Kodjo Sossouvi
2021-03-10 21:09:09 +01:00
parent 998ea160be
commit 9c4991923e
18 changed files with 317 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/parsers/ExpressionParser.py
+77 -28
View File
@@ -2,7 +2,7 @@ from core.builtin_concepts_ids import BuiltinConcepts
from core.sheerka.services.SheerkaExecute import ParserInput
from core.tokenizer import TokenKind
from core.utils import get_text_from_tokens
from parsers.BaseParser import BaseExprParser
from parsers.BaseParser import BaseExprParser, ErrorSink
from parsers.FunctionParser import FunctionParser
from parsers.LogicalOperatorParser import LogicalOperatorParser
from parsers.RelationalOperatorParser import RelationalOperatorParser
@@ -18,9 +18,10 @@ class ExpressionParser(BaseExprParser):
def __init__(self, **kwargs):
super().__init__(ExpressionParser.NAME, 60, False, yield_eof=False)
self.logical_parser = LogicalOperatorParser()
self.relational_parser = RelationalOperatorParser()
self.variable_parser = VariableOrNamesParser()
self.function_parser = FunctionParser()
self.relational_parser = RelationalOperatorParser()
self.logical_parser = LogicalOperatorParser(expr_parser=self.variable_parser)
def parse(self, context, parser_input: ParserInput):
"""
@@ -40,61 +41,109 @@ class ExpressionParser(BaseExprParser):
False,
sheerka.new(BuiltinConcepts.IS_EMPTY))
if not self.reset_parser(context, parser_input):
return self.sheerka.ret(
error_sink = ErrorSink()
if not self.reset_parser_input(parser_input, error_sink):
return context.sheerka.ret(
self.name,
False,
context.sheerka.new(BuiltinConcepts.ERROR, body=self.error_sink))
context.sheerka.new(BuiltinConcepts.ERROR, body=error_sink.sink))
self.parser_input.next_token()
node = self.parse_input()
node = self.parse_input(context, parser_input, error_sink)
if isinstance(node, ParenthesisNode):
node = node.node
value = self.get_return_value_body(context.sheerka, self.parser_input.as_text(), node, node)
value = self.get_return_value_body(context.sheerka, parser_input.as_text(), node, node, error_sink.sink)
ret = self.sheerka.ret(
ret = context.sheerka.ret(
self.name,
not self.has_error,
not error_sink.has_error,
value)
return ret
def parse_input(self):
pos = self.parser_input.pos
for parser in []: # [self.logical_parser, self.relational_parser, self.function_parser]:
self.parser_input.seek(pos) # reset position
if parser.reset_parser(self.context, self.parser_input):
res = parser.parse_input()
if res and not parser.has_error:
return res
def parse_input(self, context, parser_input, error_sink):
pos = parser_input.pos
for parser in [self.logical_parser,
self.variable_parser]: # [self.logical_parser, self.relational_parser, self.function_parser]:
parser_input.seek(pos) # reset position
res = parser.parse_input(context, parser_input, error_sink)
if res and not error_sink.has_error:
return res
return None
class VariableOrNamesParser(BaseExprParser):
NAME = "VariableOrNames"
def __init__(self, **kwargs):
super().__init__(VariableOrNamesParser.NAME, 60, False, yield_eof=False)
def parse(self, context, parser_input: ParserInput):
"""
:param context:
:param parser_input:
:return:
"""
if not isinstance(parser_input, ParserInput):
return None
context.log(f"Parsing '{parser_input}' with {self.NAME}Parser", self.name)
sheerka = context.sheerka
if parser_input.is_empty():
return context.sheerka.ret(self.name,
False,
sheerka.new(BuiltinConcepts.IS_EMPTY))
error_sink = ErrorSink()
if not self.reset_parser_input(parser_input, error_sink):
return context.sheerka.ret(
self.name,
False,
context.sheerka.new(BuiltinConcepts.ERROR, body=error_sink.sink))
node = self.parse_input(context, parser_input, error_sink)
if isinstance(node, ParenthesisNode):
node = node.node
value = self.get_return_value_body(context.sheerka, parser_input.as_text(), node, node, error_sink.sink)
ret = context.sheerka.ret(
self.name,
not error_sink.has_error,
value)
return ret
def parse_input(self, context, parser_input, error_sink):
# try to recognize a VariableNode
dots_found = []
for i, token in enumerate(self.parser_input.as_tokens()):
pos = parser_input.pos
for i, token in enumerate(parser_input.as_tokens()):
if token.type == TokenKind.DOT:
dots_found.append(i)
continue
if not (token.type == TokenKind.WHITESPACE or
token.type == TokenKind.IDENTIFIER and token.value.isidentifier()):
return NameExprNode(self.parser_input.start, self.parser_input.end, self.parser_input.as_tokens())
return NameExprNode(parser_input.start, parser_input.end, parser_input.as_tokens())
if len(dots_found) == 0:
return VariableNode(pos, self.parser_input.end, self.parser_input.as_tokens(), self.parser_input.as_text())
return VariableNode(pos, parser_input.end, parser_input.as_tokens(), parser_input.as_text())
parts = []
current_dot_pos = pos
for dot_found in dots_found:
parts.append(get_text_from_tokens(self.parser_input.tokens[current_dot_pos: dot_found]))
parts.append(get_text_from_tokens(parser_input.tokens[current_dot_pos: dot_found]))
current_dot_pos = dot_found + 1
# do not forget the trailing part
parts.append(get_text_from_tokens(self.parser_input.tokens[current_dot_pos: self.parser_input.end + 1]))
parts.append(get_text_from_tokens(parser_input.tokens[current_dot_pos: parser_input.end + 1]))
return VariableNode(self.parser_input.start,
self.parser_input.end,
self.parser_input.as_tokens(),
return VariableNode(parser_input.start,
parser_input.end,
parser_input.as_tokens(),
parts[0],
*parts[1:])