120 lines
3.3 KiB
Python
120 lines
3.3 KiB
Python
from smnp.ast.node.atom import Atom
|
|
from smnp.ast.node.expression import MaxPrecedenceExpressionParser
|
|
from smnp.ast.node.iterable import abstractIterableParser
|
|
from smnp.ast.node.model import Node
|
|
from smnp.ast.node.none import NoneNode
|
|
from smnp.ast.node.operator import BinaryOperator, Operator
|
|
from smnp.ast.parser import Parser
|
|
from smnp.token.type import TokenType
|
|
|
|
|
|
class Identifier(Atom):
|
|
pass
|
|
|
|
|
|
class FunctionCall(Node):
|
|
def __init__(self, pos):
|
|
super().__init__(pos)
|
|
self.children = [NoneNode(), NoneNode()]
|
|
|
|
@property
|
|
def name(self):
|
|
return self[0]
|
|
|
|
@name.setter
|
|
def name(self, value):
|
|
self[0] = value
|
|
|
|
@property
|
|
def arguments(self):
|
|
return self[1]
|
|
|
|
@arguments.setter
|
|
def arguments(self, value):
|
|
self[1] = value
|
|
|
|
@classmethod
|
|
def withChildren(cls, name, arguments):
|
|
node = cls(name.pos)
|
|
node.name = name
|
|
node.arguments = arguments
|
|
return node
|
|
|
|
|
|
class ArgumentsList(Node):
|
|
pass
|
|
|
|
|
|
class Assignment(BinaryOperator):
|
|
pass
|
|
|
|
|
|
def IdentifierParser(input):
|
|
identifierLiteralParser = Parser.terminalParser(TokenType.IDENTIFIER, createNode=lambda val, pos: Identifier.withValue(val, pos))
|
|
|
|
functionCallParser = Parser.allOf(
|
|
identifierLiteralParser,
|
|
abstractIterableParser(ArgumentsList, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, MaxPrecedenceExpressionParser),
|
|
createNode=lambda name, arguments: FunctionCall.withChildren(name, arguments)
|
|
)
|
|
|
|
assignmentParser = Parser.allOf(
|
|
identifierLiteralParser,
|
|
Parser.terminalParser(TokenType.ASSIGN, lambda val, pos: Operator.withValue(val, pos)),
|
|
MaxPrecedenceExpressionParser,
|
|
createNode=lambda identifier, assign, expr: Assignment.withValues(identifier, assign, expr)
|
|
)
|
|
|
|
return Parser.oneOf(
|
|
assignmentParser,
|
|
functionCallParser,
|
|
identifierLiteralParser
|
|
)(input)
|
|
|
|
|
|
#
|
|
# def __init__(self, pos):
|
|
# super().__init__(pos)
|
|
# self.children = [None]
|
|
#
|
|
# @classmethod
|
|
# def _lhsParser(cls):
|
|
# return Parser.oneOf(
|
|
# IdentifierNode._functionCallParser(),
|
|
# IdentifierNode._assignmentParser(),
|
|
# IdentifierNode.identifierParser()
|
|
# )
|
|
#
|
|
# @staticmethod
|
|
# def _assignmentParser():
|
|
# def createNode(target, assignment, value):
|
|
# node = AssignmentNode(assignment.pos)
|
|
# node.target = target
|
|
# node.value = value
|
|
# return node
|
|
#
|
|
# return Parser.allOf(
|
|
# IdentifierNode.identifierParser(),
|
|
# Parser.terminalParser(TokenType.ASSIGN),
|
|
# Parser.doAssert(ExpressionNode.parse, "expression"),
|
|
# createNode=createNode
|
|
# )
|
|
#
|
|
# @staticmethod
|
|
# def _functionCallParser():
|
|
# def createNode(name, arguments):
|
|
# node = FunctionCallNode(name.pos)
|
|
# node.name = name
|
|
# node.arguments = arguments
|
|
# return node
|
|
#
|
|
# return Parser.allOf(
|
|
# IdentifierNode.identifierParser(),
|
|
# ArgumentsListNode.parse,
|
|
# createNode=createNode
|
|
# )
|
|
#
|
|
# @staticmethod
|
|
# def identifierParser():
|
|
# return Parser.terminalParser(TokenType.IDENTIFIER, lambda val, pos: IdentifierNode.withValue(val, pos))
|