119 lines
3.2 KiB
Python
119 lines
3.2 KiB
Python
from core.builtin_concepts import BuiltinConcepts
|
|
from parsers.BaseParser import BaseParser, Node, ErrorNode
|
|
from dataclasses import dataclass
|
|
import ast
|
|
import copy
|
|
import logging
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
@dataclass()
|
|
class PythonErrorNode(ErrorNode):
|
|
source: str
|
|
exception: Exception
|
|
|
|
# def __post_init__(self):
|
|
# log.debug("-> PythonErrorNode: " + str(self.exception))
|
|
|
|
|
|
@dataclass()
|
|
class PythonNode(Node):
|
|
source: str
|
|
ast_: ast.AST
|
|
|
|
# def __repr__(self):
|
|
# return "PythonNode(source='" + self.source + "', ast=" + self.get_dump(self.ast_) + ")"
|
|
|
|
def __repr__(self):
|
|
ast_type = "expr" if isinstance(self.ast_, ast.Expression) else "module"
|
|
return "PythonNode(" + ast_type + "='" + self.source + "')"
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, PythonNode):
|
|
return False
|
|
|
|
if self.source != other.source:
|
|
return False
|
|
|
|
self_dump = self.get_dump(self.ast_)
|
|
other_dump = self.get_dump(other.ast_)
|
|
|
|
return self_dump == other_dump
|
|
|
|
def __hash__(self):
|
|
return hash((self.source, self.ast_.hash))
|
|
|
|
@staticmethod
|
|
def get_dump(ast_):
|
|
dump = ast.dump(ast_)
|
|
for to_remove in [", ctx=Load()", ", kind=None", ", type_ignores=[]"]:
|
|
dump = dump.replace(to_remove, "")
|
|
return dump
|
|
|
|
|
|
class PythonParser(BaseParser):
|
|
"""
|
|
Parse Python scripts
|
|
"""
|
|
|
|
def __init__(self, source="<undef>"):
|
|
|
|
BaseParser.__init__(self, "PythonParser")
|
|
self.source = source
|
|
|
|
def parse(self, context, text):
|
|
text = text if isinstance(text, str) else self.get_text_from_tokens(text)
|
|
text = text.strip()
|
|
|
|
sheerka = context.sheerka
|
|
|
|
# first, try to parse an expression
|
|
res, tree, error = self.try_parse_expression(text)
|
|
if not res:
|
|
# then try to parse a statement
|
|
res, tree, error = self.try_parse_statement(text)
|
|
if not res:
|
|
self.has_error = True
|
|
error_node = PythonErrorNode(text, error)
|
|
self.error_sink.append(error_node)
|
|
|
|
ret = sheerka.ret(
|
|
self.name,
|
|
not self.has_error,
|
|
sheerka.new(
|
|
BuiltinConcepts.PARSER_RESULT,
|
|
parser=self,
|
|
source=text,
|
|
body=self.error_sink if self.has_error else PythonNode(text, tree),
|
|
try_parsed=None))
|
|
|
|
self.log_result(log, text, ret)
|
|
return ret
|
|
|
|
def try_parse_expression(self, text):
|
|
try:
|
|
return True, ast.parse(text, f"<{self.source}>", 'eval'), None
|
|
except Exception as error:
|
|
return False, None, error
|
|
|
|
def try_parse_statement(self, text):
|
|
try:
|
|
return True, ast.parse(text, f"<{self.source}>", 'exec'), None
|
|
except Exception as error:
|
|
return False, None, error
|
|
|
|
|
|
class PythonGetNamesVisitor(ast.NodeVisitor):
|
|
"""
|
|
This visitor will find all the name declared in the ast
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.names = set()
|
|
log.debug("Searching for names.")
|
|
|
|
def visit_Name(self, node):
|
|
log.debug(f"Found name : {node.id}")
|
|
self.names.add(node.id)
|