bartek/smnp-py
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unnecessary old code

Browse Source
This commit is contained in:
Bartłomiej Pluta
2019-07-11 10:34:10 +02:00
parent 3e506354cd
commit b80710798b
14 changed files with 96 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
smnp/ast/node/assignment.py
View File

@@ -1,28 +0,0 @@
# from smnp.ast.node.expression import ExpressionNode
# from smnp.ast.node.none import NoneNode
#
#
# class AssignmentNode(ExpressionNode):
# def __init__(self, pos):
# super().__init__(pos)
# self.children.append(NoneNode())
#
# @property
# def target(self):
# return self[0]
#
# @target.setter
# def target(self, value):
# self[0] = value
#
# @property
# def value(self):
# return self[1]
#
# @value.setter
# def value(self, value):
# self[1] = value
#
# @classmethod
# def _parse(cls, input):
# raise RuntimeError("This class is not supposed to be automatically called")

28
smnp/ast/node/asterisk.py
View File

@@ -1,28 +0,0 @@
from smnp.ast.node.none import NoneNode
from smnp.ast.node.statement import StatementNode
class AsteriskNode(StatementNode):
def __init__(self, pos):
super().__init__(pos)
self.children = [NoneNode(), NoneNode()]
@property
def iterator(self):
return self[0]
@iterator.setter
def iterator(self, value):
self[0] = value
@property
def statement(self):
return self[1]
@statement.setter
def statement(self, value):
self[1] = value
@classmethod
def _parse(cls, input):
raise RuntimeError("This class is not supposed to be automatically called")

17
smnp/ast/node/bool.py
View File

@@ -1,17 +0,0 @@
from smnp.ast.node.literal import LiteralNode
from smnp.ast.node.operator import LeftAssociativeOperatorNode
from smnp.token.type import TokenType
class BoolLiteralNode(LiteralNode, LeftAssociativeOperatorNode):
def __init__(self, pos):
super().__init__(pos)
self.children = [None]
@classmethod
def _getTokenType(cls):
return TokenType.BOOL
@classmethod
def _lhsParser(cls):
return cls.literalParser()

67
smnp/ast/node/expression.py
View File

@@ -60,69 +60,4 @@ def Expression4Parser(input):
)(input)
MaxPrecedenceExpressionParser = Expression4Parser
#
# class ExpressionNode(Node):
# def __init__(self, pos):
# super().__init__(pos, [NoneNode()])
#
# @property
# def value(self):
# return self[0]
#
#
# @value.setter
# def value(self, v):
# self[0] = v
#
#
# @classmethod
# def withValue(cls, val, pos):
# node = cls(pos)
# node.value = val
# return node
#
# @classmethod
# def _parse(cls, input):
# return Parser.oneOf(
# cls._asteriskParser(),
# cls._expressionParser(),
# )(input)
#
# @classmethod
# def _asteriskParser(cls):
# def createNode(iterator, asterisk, statement):
# node = AsteriskNode(asterisk.pos)
# node.iterator = iterator
# node.statement = statement
# return node
#
# return Parser.allOf(
# cls._expressionParser(),
# Parser.terminalParser(TokenType.ASTERISK),
# Parser.doAssert(StatementNode.parse, 'statement'),
# createNode=createNode
# )
#
# @classmethod
# def _expressionParser(cls):
# from smnp.ast.node.integer import IntegerLiteralNode
# from smnp.ast.node.string import StringLiteralNode
# from smnp.ast.node.note import NoteLiteralNode
# from smnp.ast.node.bool import BoolLiteralNode
# from smnp.ast.node.identifier import IdentifierNode
# from smnp.ast.node.list import List
# from smnp.ast.node.map import MapNode
# from smnp.ast.node.type import TypeNode
#
# return Parser.oneOf(
# IntegerLiteralNode.parse,
# StringLiteralNode.parse,
# NoteLiteralNode.parse,
# BoolLiteralNode.parse,
# IdentifierNode.parse,
# MapNode.parse,
# List.parse,
# TypeNode.parse,
# )
MaxPrecedenceExpressionParser = Expression4Parser

47
smnp/ast/node/identifier.py
View File

@@ -70,50 +70,3 @@ def IdentifierParser(input):
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))

68
smnp/ast/node/imports.py
View File

@@ -39,71 +39,3 @@ def ImportParser(input):
createNode=lambda imp, source: Import.withValue(source),
name="import"
)(input)
# class ImportNode(Node):
# def __init__(self, pos):
# super().__init__(pos)
# self.children = [NoneNode(), NoneNode(), NoneNode()]
#
# @property
# def source(self):
# return self[0]
#
# @source.setter
# def source(self, value):
# self[0] = value
#
# @property
# def type(self):
# return self[1]
#
# @type.setter
# def type(self, value):
# self[1] = value
#
# @property
# def variable(self):
# return self[2]
#
# @variable.setter
# def variable(self, value):
# self[2] = value
#
# @classmethod
# def _parse(cls, input):
# return Parser.oneOf(
# cls._literalImportParser(),
# cls._fileImportParser()
# )(input)
#
# @classmethod
# def _literalImportParser(cls):
# def createNode(importKeyword, type, fromKeyword, source, asKeyword, variable):
# node = ImportNode(importKeyword.pos)
# node.source = source
# node.type = type
# node.variable = variable
# return node
#
# return Parser.allOf(
# Parser.terminalParser(TokenType.IMPORT),
# TypeNode.parse,
# Parser.doAssert(Parser.terminalParser(TokenType.FROM), "'from <source> as <variable name>'"),
# Parser.doAssert(StringLiteralNode._literalParser(), "source as a string"),
# Parser.doAssert(Parser.terminalParser(TokenType.AS), "'as <variable name>'"),
# Parser.doAssert(Identifier.identifierParser(), "variable name"),
# createNode=createNode
# )
#
# @classmethod
# def _fileImportParser(cls):
# def createNode(importKeyword, source):
# node = ImportNode(importKeyword.pos)
# node.source = source
# return node
#
# return Parser.allOf(
# Parser.terminalParser(TokenType.IMPORT),
# Parser.doAssert(StringLiteralNode._literalParser(), "source as a string"),
# createNode=createNode
# )

35
smnp/ast/node/integer.py
View File

@@ -1,35 +0,0 @@
from smnp.ast.node.operator import LeftAssociativeOperatorNode
from smnp.ast.parser import Parser
from smnp.token.type import TokenType
class IntegerLiteralNode(LeftAssociativeOperatorNode):
def __init__(self, pos):
super().__init__(pos)
self.children = [None]
@classmethod
def _lhsParser(cls):
return cls.literalParser()
@classmethod
def literalParser(cls):
return Parser.oneOf(
cls._negativeIntegerParser(),
cls._positiveIntegerParser()
)
@classmethod
def _negativeIntegerParser(cls):
def createNode(minus, integer):
return IntegerLiteralNode.withValue(-integer.value, minus.pos)
return Parser.allOf(
Parser.terminalParser(TokenType.MINUS),
Parser.doAssert(cls._positiveIntegerParser(), "integer"),
createNode=createNode
)
@classmethod
def _positiveIntegerParser(cls):
return Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteralNode.withValue(int(val), pos))

42
smnp/ast/node/invocation.py
View File

@@ -1,42 +0,0 @@
# from smnp.ast.node.expression import ExpressionNode
# 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 LeftAssociativeOperatorNode
# from smnp.ast.parser import Parser
# from smnp.token.type import TokenType
#
#
# class ArgumentsListNode(Node):
#
# @classmethod
# def _parse(cls, input):
# return abstractIterableParser(ArgumentsListNode, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN,
# Parser.doAssert(ExpressionNode.parse, "expression"))(input)
#
#
# class FunctionCallNode(LeftAssociativeOperatorNode):
# 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 _parse(cls, input):
# raise RuntimeError("This class is not supposed to be automatically called")
#

53
smnp/ast/node/iterable.py
View File

@@ -90,59 +90,6 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
return toFlatDesiredNode(iterableNodeType, abstractIterableParser)
#
# @classmethod
# def _parse(cls, input):
# return Parser.oneOf(
# AbstractIterableTail._parser1(input),
# AbstractIterableTail._parser2(input),
# )(input)
#
# @staticmethod
# def _parser1(input):
# return Parser.terminalParser(closeTokenType)
#
# class AbstractIterableNode(ExpressionNode):
# @classmethod
# def _parse(cls, input):
# return Parser.oneOf(
# AbstractIterableNode._parser1(input),
# AbstractIterableNode._parser2(input)
# )(input)
#
# @staticmethod
# def _parser1(input):
# def emptyIterable(openToken, closeToken):
# node = AbstractIterableNode(openToken.pos)
# node.value = openToken
# node.next = closeToken
# return node
#
# return Parser.allOf(
# Parser.terminalParser(openTokenType),
# Parser.terminalParser(closeTokenType),
# createNode=emptyIterable
# )
#
# @staticmethod
# def _parser2(input):
# def createNode(openParen, expr, iterableTail):
# node = AbstractIterableNode(openParen.pos)
# node.value = expr
# node.next = iterableTail
# return node
#
# return Parser.allOf(
# Parser.terminalParser(openTokenType, lambda val, pos: Node(pos)),
# itemParser,
# AbstractIterableTail.parse,
# createNode=createNode
# )
#return toFlatDesiredNode(iterableNodeType, AbstractIterableNode.parse)
def toFlatDesiredNode(iterableNodeType, parser):
def parse(input):

18
smnp/ast/node/literal.py
View File

@@ -1,18 +0,0 @@
from smnp.ast.node.expression import ExpressionNode
from smnp.ast.parser import Parser
class LiteralNode(ExpressionNode):
@classmethod
def _getTokenType(cls):
pass
@classmethod
def _processValue(cls, value):
return value
@classmethod
def literalParser(cls):
createNode = lambda val, pos: cls.withValue(cls._processValue(val), pos)
return Parser.terminalParser(cls._getTokenType(), createNode)

17
smnp/ast/node/note.py
View File

@@ -1,17 +0,0 @@
from smnp.ast.node.literal import LiteralNode
from smnp.ast.node.operator import LeftAssociativeOperatorNode
from smnp.token.type import TokenType
class NoteLiteralNode(LiteralNode, LeftAssociativeOperatorNode):
def __init__(self, pos):
super().__init__(pos)
self.children = [None]
@classmethod
def _getTokenType(cls):
return TokenType.NOTE
@classmethod
def _lhsParser(cls):
return cls.literalParser()

64
smnp/ast/node/ret.py
View File

@@ -1,32 +1,32 @@
from smnp.ast.node.expression import ExpressionNode
from smnp.ast.node.none import NoneNode
from smnp.ast.node.statement import StatementNode
from smnp.ast.parser import Parser
from smnp.token.type import TokenType
class ReturnNode(StatementNode):
def __init__(self, pos):
super().__init__(pos)
self.children.append(NoneNode())
@property
def value(self):
return self[0]
@value.setter
def value(self, value):
self[0] = value
@classmethod
def _parse(cls, input):
def createNode(ret, value):
node = ReturnNode(ret.pos)
node.value = value
return node
return Parser.allOf(
Parser.terminalParser(TokenType.RETURN),
Parser.doAssert(ExpressionNode.parse, "expression"),
createNode=createNode
)(input)
# from smnp.ast.node.expression import ExpressionNode
# from smnp.ast.node.none import NoneNode
# from smnp.ast.node.statement import StatementNode
# from smnp.ast.parser import Parser
# from smnp.token.type import TokenType
#
#
# class ReturnNode(StatementNode):
# def __init__(self, pos):
# super().__init__(pos)
# self.children.append(NoneNode())
#
# @property
# def value(self):
# return self[0]
#
# @value.setter
# def value(self, value):
# self[0] = value
#
# @classmethod
# def _parse(cls, input):
# def createNode(ret, value):
# node = ReturnNode(ret.pos)
# node.value = value
# return node
#
# return Parser.allOf(
# Parser.terminalParser(TokenType.RETURN),
# Parser.doAssert(ExpressionNode.parse, "expression"),
# createNode=createNode
# )(input)

17
smnp/ast/node/string.py
View File

@@ -1,17 +0,0 @@
from smnp.ast.node.literal import LiteralNode
from smnp.ast.node.operator import LeftAssociativeOperatorNode
from smnp.token.type import TokenType
class StringLiteralNode(LiteralNode, LeftAssociativeOperatorNode):
def __init__(self, pos):
super().__init__(pos)
self.children = [None]
@classmethod
def _getTokenType(cls):
return TokenType.STRING
@classmethod
def _lhsParser(cls):
return cls.literalParser()

126
smnp/ast/node/type.py
View File

@@ -1,63 +1,63 @@
from smnp.ast.node.iterable import abstractIterableParser
from smnp.ast.node.model import Node
from smnp.ast.node.operator import LeftAssociativeOperatorNode
from smnp.ast.parser import Parser
from smnp.token.type import TokenType
from smnp.type.model import Type
class TypeSpecifier(Node):
@classmethod
def _parse(cls, input):
return abstractIterableParser(TypeSpecifier, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE,
Parser.doAssert(cls._specifierItem(), "type"))(input)
@classmethod
def _specifierItem(cls):
return Parser.oneOf(
TypeNode.parse,
cls.parse
)
class TypeSpecifiers(Node):
pass
class TypeNode(LeftAssociativeOperatorNode):
def __init__(self, pos):
super().__init__(pos)
@property
def type(self):
return self[0]
@type.setter
def type(self, value):
self[0] = value
@property
def specifiers(self):
return self[1]
@specifiers.setter
def specifiers(self, value):
self[1] = value
@classmethod
def _parse(cls, input):
def createNode(type, specifiers):
node = TypeNode(type.pos)
node.type = Type[type.value.upper()]
node.specifiers = specifiers
return node
return Parser.allOf(
cls._rawTypeParser(),
Parser.many(TypeSpecifier.parse, lambda specifiers, pos: TypeSpecifiers.withChildren(specifiers, pos)),
createNode=createNode
)(input)
@classmethod
def _rawTypeParser(cls):
return Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos))
# from smnp.ast.node.iterable import abstractIterableParser
# from smnp.ast.node.model import Node
# from smnp.ast.node.operator import LeftAssociativeOperatorNode
# from smnp.ast.parser import Parser
# from smnp.token.type import TokenType
# from smnp.type.model import Type
#
#
# class TypeSpecifier(Node):
#
# @classmethod
# def _parse(cls, input):
# return abstractIterableParser(TypeSpecifier, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE,
# Parser.doAssert(cls._specifierItem(), "type"))(input)
#
# @classmethod
# def _specifierItem(cls):
# return Parser.oneOf(
# TypeNode.parse,
# cls.parse
# )
#
# class TypeSpecifiers(Node):
# pass
#
#
# class TypeNode(LeftAssociativeOperatorNode):
# def __init__(self, pos):
# super().__init__(pos)
#
# @property
# def type(self):
# return self[0]
#
# @type.setter
# def type(self, value):
# self[0] = value
#
# @property
# def specifiers(self):
# return self[1]
#
# @specifiers.setter
# def specifiers(self, value):
# self[1] = value
#
# @classmethod
# def _parse(cls, input):
# def createNode(type, specifiers):
# node = TypeNode(type.pos)
# node.type = Type[type.value.upper()]
# node.specifiers = specifiers
# return node
#
# return Parser.allOf(
# cls._rawTypeParser(),
# Parser.many(TypeSpecifier.parse, lambda specifiers, pos: TypeSpecifiers.withChildren(specifiers, pos)),
# createNode=createNode
# )(input)
#
# @classmethod
# def _rawTypeParser(cls):
# return Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos))