diff --git a/src/main/kotlin/dsl/ast/parser/AbstractIterableParser.kt b/src/main/kotlin/dsl/ast/parser/AbstractIterableParser.kt index 47dd51a..bf86651 100644 --- a/src/main/kotlin/dsl/ast/parser/AbstractIterableParser.kt +++ b/src/main/kotlin/dsl/ast/parser/AbstractIterableParser.kt @@ -13,29 +13,28 @@ abstract class AbstractIterableParser( private val createNode: (List, TokenPosition) -> Node ) : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - val emptyIterableParser = allOf(listOf(terminal(beginTokenType), terminal(endTokenType))) { createNode(listOf(), it[0].position) } + val emptyIterableParser = allOf( + terminal(beginTokenType), + terminal(endTokenType) + ) { createNode(listOf(), it[0].position) } val nonEmptyIterableParser = allOf( - listOf(terminal(beginTokenType), - allOf(listOf( - itemParser, - optional(repeat(allOf( - listOf( - terminal(TokenType.COMMA), - itemParser - ) - ) { it[1] }) { list, position -> object : Node(list, position) {} } - ))) { list -> - object : Node(listOf(list[0]) + list[1].children, TokenPosition.NONE) {} }, - terminal(endTokenType) - ) + terminal(beginTokenType), + allOf( + itemParser, + optional(repeat(allOf( + terminal(TokenType.COMMA), + itemParser + ) { it[1] }) { list, position -> object : Node(list, position) {} } + )) { list -> + object : Node(listOf(list[0]) + list[1].children, TokenPosition.NONE) {} + }, + terminal(endTokenType) ) { createNode(it[1].children.toList(), it[0].position) } return oneOf( - listOf( - emptyIterableParser, - nonEmptyIterableParser - ) + emptyIterableParser, + nonEmptyIterableParser ).parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/AssignmentOperatorParser.kt b/src/main/kotlin/dsl/ast/parser/AssignmentOperatorParser.kt index c18c8fa..2c7347b 100644 --- a/src/main/kotlin/dsl/ast/parser/AssignmentOperatorParser.kt +++ b/src/main/kotlin/dsl/ast/parser/AssignmentOperatorParser.kt @@ -7,11 +7,11 @@ import dsl.token.model.enumeration.TokenType class AssignmentOperatorParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( SimpleIdentifierParser(), terminal(TokenType.ASSIGN), assert(ExpressionParser(), "expression") - )) { + ) { AssignmentOperatorNode(it[0], it[1], it[2]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/AtomParser.kt b/src/main/kotlin/dsl/ast/parser/AtomParser.kt index 5ef61ba..81a896f 100644 --- a/src/main/kotlin/dsl/ast/parser/AtomParser.kt +++ b/src/main/kotlin/dsl/ast/parser/AtomParser.kt @@ -7,23 +7,19 @@ import dsl.token.model.enumeration.TokenType class AtomParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { val parenthesesParser = allOf( - listOf( - terminal(TokenType.OPEN_PAREN), - ExpressionParser(), - terminal(TokenType.CLOSE_PAREN) - ) + terminal(TokenType.OPEN_PAREN), + ExpressionParser(), + terminal(TokenType.CLOSE_PAREN) ) { it[1] } val literalParser = oneOf( - listOf( - parenthesesParser, - ComplexIdentifierParser(), - ListParser(), - LiteralParser(), - MapParser() - ) + parenthesesParser, + ComplexIdentifierParser(), + ListParser(), + LiteralParser(), + MapParser() ) return literalParser.parse(input) diff --git a/src/main/kotlin/dsl/ast/parser/ComplexIdentifierParser.kt b/src/main/kotlin/dsl/ast/parser/ComplexIdentifierParser.kt index a013b67..3ef238d 100644 --- a/src/main/kotlin/dsl/ast/parser/ComplexIdentifierParser.kt +++ b/src/main/kotlin/dsl/ast/parser/ComplexIdentifierParser.kt @@ -5,10 +5,10 @@ import dsl.token.model.entity.TokenList class ComplexIdentifierParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return oneOf(listOf( + return oneOf( AssignmentOperatorParser(), FunctionCallParser(), SimpleIdentifierParser() - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/ConditionParser.kt b/src/main/kotlin/dsl/ast/parser/ConditionParser.kt index 6904c8c..f62a55a 100644 --- a/src/main/kotlin/dsl/ast/parser/ConditionParser.kt +++ b/src/main/kotlin/dsl/ast/parser/ConditionParser.kt @@ -8,17 +8,17 @@ import dsl.token.model.enumeration.TokenType class ConditionParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - val ifStatementParser = allOf(listOf( + val ifStatementParser = allOf( terminal(TokenType.IF), terminal(TokenType.OPEN_PAREN), SubexpressionParser(), terminal(TokenType.CLOSE_PAREN), StatementParser() - )) { + ) { ConditionNode(it[0], it[2], it[4], Node.NONE, Node.NONE) } - val ifElseStatementParser = allOf(listOf( + val ifElseStatementParser = allOf( terminal(TokenType.IF), terminal(TokenType.OPEN_PAREN), SubexpressionParser(), @@ -26,13 +26,13 @@ class ConditionParser : Parser() { StatementParser(), terminal(TokenType.ELSE), StatementParser() - )) { + ) { ConditionNode(it[0], it[2], it[4], it[5], it[6]) } - return oneOf(listOf( + return oneOf( ifElseStatementParser, ifStatementParser - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/ExpressionParser.kt b/src/main/kotlin/dsl/ast/parser/ExpressionParser.kt index f80882d..f035c14 100644 --- a/src/main/kotlin/dsl/ast/parser/ExpressionParser.kt +++ b/src/main/kotlin/dsl/ast/parser/ExpressionParser.kt @@ -5,9 +5,9 @@ import dsl.token.model.entity.TokenList class ExpressionParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return oneOf(listOf( + return oneOf( LoopParser(), SubexpressionParser() - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/FactorParser.kt b/src/main/kotlin/dsl/ast/parser/FactorParser.kt index b7198b7..3e388ec 100644 --- a/src/main/kotlin/dsl/ast/parser/FactorParser.kt +++ b/src/main/kotlin/dsl/ast/parser/FactorParser.kt @@ -16,16 +16,16 @@ class FactorParser : Parser() { PowerOperatorNode(lhs, operator, rhs) } - val notOperatorParser = allOf(listOf( + val notOperatorParser = allOf( terminal(TokenType.NOT), factorParser - )) { + ) { NotOperatorNode(it[0], it[1]) } - return oneOf(listOf( + return oneOf( notOperatorParser, factorParser - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/FunctionCallArgumentsParser.kt b/src/main/kotlin/dsl/ast/parser/FunctionCallArgumentsParser.kt index 24a736a..0815fec 100644 --- a/src/main/kotlin/dsl/ast/parser/FunctionCallArgumentsParser.kt +++ b/src/main/kotlin/dsl/ast/parser/FunctionCallArgumentsParser.kt @@ -3,6 +3,7 @@ package dsl.ast.parser import dsl.ast.model.node.FunctionCallArgumentsNode import dsl.token.model.enumeration.TokenType -class FunctionCallArgumentsParser : AbstractIterableParser(TokenType.OPEN_PAREN, ExpressionParser(), TokenType.CLOSE_PAREN, { - list, tokenPosition -> FunctionCallArgumentsNode(list, tokenPosition) -}) \ No newline at end of file +class FunctionCallArgumentsParser : + AbstractIterableParser(TokenType.OPEN_PAREN, ExpressionParser(), TokenType.CLOSE_PAREN, { list, tokenPosition -> + FunctionCallArgumentsNode(list, tokenPosition) + }) \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/FunctionCallParser.kt b/src/main/kotlin/dsl/ast/parser/FunctionCallParser.kt index e14a16d..77ae6ed 100644 --- a/src/main/kotlin/dsl/ast/parser/FunctionCallParser.kt +++ b/src/main/kotlin/dsl/ast/parser/FunctionCallParser.kt @@ -6,10 +6,10 @@ import dsl.token.model.entity.TokenList class FunctionCallParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( SimpleIdentifierParser(), FunctionCallArgumentsParser() - )) { + ) { FunctionCallNode(it[0], it[1]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentParser.kt b/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentParser.kt index 2a8f8d0..55c20e8 100644 --- a/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentParser.kt +++ b/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentParser.kt @@ -5,9 +5,9 @@ import dsl.token.model.entity.TokenList class FunctionDefinitionArgumentParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return oneOf(listOf( + return oneOf( OptionalFunctionDefinitionArgumentParser(), RegularFunctionDefinitionArgumentParser() - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentsParser.kt b/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentsParser.kt index 8266520..bf9fdbe 100644 --- a/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentsParser.kt +++ b/src/main/kotlin/dsl/ast/parser/FunctionDefinitionArgumentsParser.kt @@ -3,6 +3,10 @@ package dsl.ast.parser import dsl.ast.model.node.FunctionDefinitionArgumentsNode import dsl.token.model.enumeration.TokenType -class FunctionDefinitionArgumentsParser : AbstractIterableParser(TokenType.OPEN_PAREN, FunctionDefinitionArgumentParser(), TokenType.CLOSE_PAREN, { - list, tokenPosition -> FunctionDefinitionArgumentsNode(list, tokenPosition) -}) \ No newline at end of file +class FunctionDefinitionArgumentsParser : AbstractIterableParser( + TokenType.OPEN_PAREN, + FunctionDefinitionArgumentParser(), + TokenType.CLOSE_PAREN, + { list, tokenPosition -> + FunctionDefinitionArgumentsNode(list, tokenPosition) + }) \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/FunctionDefinitionParser.kt b/src/main/kotlin/dsl/ast/parser/FunctionDefinitionParser.kt index 76e8437..4e5eb2b 100644 --- a/src/main/kotlin/dsl/ast/parser/FunctionDefinitionParser.kt +++ b/src/main/kotlin/dsl/ast/parser/FunctionDefinitionParser.kt @@ -7,12 +7,12 @@ import dsl.token.model.enumeration.TokenType class FunctionDefinitionParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( terminal(TokenType.FUNCTION), assert(SimpleIdentifierParser(), "function/method name"), assert(FunctionDefinitionArgumentsParser(), "function/method arguments list"), assert(BlockParser(), "function/method body") - )) { + ) { FunctionDefinitionNode(it[1], it[2], it[3], it[0].position) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/ListParser.kt b/src/main/kotlin/dsl/ast/parser/ListParser.kt index c53a8c8..d3a30c3 100644 --- a/src/main/kotlin/dsl/ast/parser/ListParser.kt +++ b/src/main/kotlin/dsl/ast/parser/ListParser.kt @@ -3,6 +3,10 @@ package dsl.ast.parser import dsl.ast.model.node.ListNode import dsl.token.model.enumeration.TokenType -class ListParser : AbstractIterableParser(TokenType.OPEN_SQUARE, SubexpressionParser(), TokenType.CLOSE_SQUARE, { - list, tokenPosition -> ListNode(list, tokenPosition) -}) \ No newline at end of file +class ListParser : AbstractIterableParser( + TokenType.OPEN_SQUARE, + SubexpressionParser(), + TokenType.CLOSE_SQUARE, + { list, tokenPosition -> + ListNode(list, tokenPosition) + }) \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/LiteralParser.kt b/src/main/kotlin/dsl/ast/parser/LiteralParser.kt index ede847d..15f2864 100644 --- a/src/main/kotlin/dsl/ast/parser/LiteralParser.kt +++ b/src/main/kotlin/dsl/ast/parser/LiteralParser.kt @@ -5,12 +5,12 @@ import dsl.token.model.entity.TokenList class LiteralParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return oneOf(listOf( + return oneOf( BoolLiteralParser(), FloatLiteralParser(), IntegerLiteralParser(), NoteLiteralParser(), StringLiteralParser() - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/LoopParametersParser.kt b/src/main/kotlin/dsl/ast/parser/LoopParametersParser.kt index b853b00..221ab7b 100644 --- a/src/main/kotlin/dsl/ast/parser/LoopParametersParser.kt +++ b/src/main/kotlin/dsl/ast/parser/LoopParametersParser.kt @@ -3,6 +3,10 @@ package dsl.ast.parser import dsl.ast.model.node.LoopParametersNode import dsl.token.model.enumeration.TokenType -class LoopParametersParser : AbstractIterableParser(TokenType.OPEN_PAREN, SimpleIdentifierParser(), TokenType.CLOSE_PAREN, { - list, tokenPosition -> LoopParametersNode(list, tokenPosition) -}) \ No newline at end of file +class LoopParametersParser : AbstractIterableParser( + TokenType.OPEN_PAREN, + SimpleIdentifierParser(), + TokenType.CLOSE_PAREN, + { list, tokenPosition -> + LoopParametersNode(list, tokenPosition) + }) \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/LoopParser.kt b/src/main/kotlin/dsl/ast/parser/LoopParser.kt index 3aefd7d..574054e 100644 --- a/src/main/kotlin/dsl/ast/parser/LoopParser.kt +++ b/src/main/kotlin/dsl/ast/parser/LoopParser.kt @@ -8,26 +8,26 @@ import dsl.token.model.enumeration.TokenType class LoopParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - val loopParametersParser = allOf(listOf( + val loopParametersParser = allOf( terminal(TokenType.AS), - oneOf(listOf( + oneOf( mapNode(SimpleIdentifierParser()) { LoopParametersNode(listOf(it), it.position) }, LoopParametersParser() - )) - )) { it[1] } + ) + ) { it[1] } - val loopFilterParser = allOf(listOf( + val loopFilterParser = allOf( terminal(TokenType.PERCENT), assert(SubexpressionParser(), "filter as bool expression") - )) { it[1] } + ) { it[1] } - return allOf(listOf( + return allOf( SubexpressionParser(), optional(loopParametersParser), terminal(TokenType.CARET), StatementParser(), optional(loopFilterParser) - )) { + ) { LoopNode(it[0], it[1], it[2], it[3], it[4]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/MapEntryParser.kt b/src/main/kotlin/dsl/ast/parser/MapEntryParser.kt index 0ec1bce..20450bc 100644 --- a/src/main/kotlin/dsl/ast/parser/MapEntryParser.kt +++ b/src/main/kotlin/dsl/ast/parser/MapEntryParser.kt @@ -7,16 +7,16 @@ import dsl.token.model.enumeration.TokenType class MapEntryParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - val keyParser = oneOf(listOf( + val keyParser = oneOf( LiteralParser(), SimpleIdentifierParser() - )) + ) - return allOf(listOf( + return allOf( keyParser, terminal(TokenType.ARROW), assert(SubexpressionParser(), "expression") - )) { + ) { MapEntryNode(it[0], it[1], it[2]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/MapParser.kt b/src/main/kotlin/dsl/ast/parser/MapParser.kt index feeca54..ea4cc55 100644 --- a/src/main/kotlin/dsl/ast/parser/MapParser.kt +++ b/src/main/kotlin/dsl/ast/parser/MapParser.kt @@ -3,6 +3,7 @@ package dsl.ast.parser import dsl.ast.model.node.MapNode import dsl.token.model.enumeration.TokenType -class MapParser : AbstractIterableParser(TokenType.OPEN_CURLY, MapEntryParser(), TokenType.CLOSE_CURLY, { - list, tokenPosition -> MapNode(list, tokenPosition) -}) \ No newline at end of file +class MapParser : + AbstractIterableParser(TokenType.OPEN_CURLY, MapEntryParser(), TokenType.CLOSE_CURLY, { list, tokenPosition -> + MapNode(list, tokenPosition) + }) \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt b/src/main/kotlin/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt index 5400caf..ac2cae7 100644 --- a/src/main/kotlin/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt +++ b/src/main/kotlin/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt @@ -7,15 +7,15 @@ import dsl.token.model.enumeration.TokenType class OptionalFunctionDefinitionArgumentParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( SimpleIdentifierParser(), - optional(allOf(listOf( + optional(allOf( terminal(TokenType.COLON), TypeParser() - )){ it[1] }), + ) { it[1] }), terminal(TokenType.ASSIGN), assert(ExpressionParser(), "expression") - )) { + ) { OptionalFunctionDefinitionArgumentNode(it[0], it[1], it[3]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/Parser.kt b/src/main/kotlin/dsl/ast/parser/Parser.kt index 5078e44..218dd0b 100644 --- a/src/main/kotlin/dsl/ast/parser/Parser.kt +++ b/src/main/kotlin/dsl/ast/parser/Parser.kt @@ -13,7 +13,7 @@ abstract class Parser { fun parse(input: TokenList): ParserOutput { val snapshot = input.snapshot() val output = tryToParse(input) - if(output.result == ParsingResult.FAILED) { + if (output.result == ParsingResult.FAILED) { input.restore(snapshot) } @@ -28,7 +28,7 @@ abstract class Parser { fun terminal(terminal: TokenType, createNode: (Token) -> Node = { TokenNode(it) }): Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - if(input.hasCurrent() && input.current.type == terminal) { + if (input.hasCurrent() && input.current.type == terminal) { val token = input.current input.ahead() return ParserOutput.ok(createNode(token)) @@ -40,16 +40,16 @@ abstract class Parser { } // oneOf -> a | b | c | ... - fun oneOf(parsers: List): Parser { + fun oneOf(vararg parsers: Parser): Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - if(parsers.isEmpty()) { + if (parsers.isEmpty()) { throw RuntimeException("Provide one parser at least") } for (parser in parsers) { val output = parser.parse(input) - if(output.result == ParsingResult.OK) { + if (output.result == ParsingResult.OK) { return output } } @@ -60,15 +60,15 @@ abstract class Parser { } // a -> A | B | C | ... - fun terminals(terminals: List, createNode: (Token) -> Node = { TokenNode(it) }): Parser { - return oneOf(terminals.map { terminal(it, createNode) }) + fun terminals(vararg terminals: TokenType, createNode: (Token) -> Node = { TokenNode(it) }): Parser { + return oneOf(*terminals.map { terminal(it, createNode) }.toTypedArray()) } // allOf -> a b c ... - fun allOf(parsers: List, createNode: (List) -> Node): Parser { + fun allOf(vararg parsers: Parser, createNode: (List) -> Node): Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - if(parsers.isEmpty()) { + if (parsers.isEmpty()) { throw RuntimeException("Provide one parser at least") } @@ -91,16 +91,21 @@ abstract class Parser { } // leftAssociative -> left | left OP right - fun leftAssociativeOperator(lhsParser: Parser, allowedOperators: List, rhsParser: Parser, createNode: (lhs: Node, operator: Node, rhs: Node) -> Node): Parser { + fun leftAssociativeOperator( + lhsParser: Parser, + allowedOperators: List, + rhsParser: Parser, + createNode: (lhs: Node, operator: Node, rhs: Node) -> Node + ): Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - val opParser = terminals(allowedOperators) + val opParser = terminals(*allowedOperators.toTypedArray()) var lhs = lhsParser.parse(input) - if(lhs.result == ParsingResult.OK) { + if (lhs.result == ParsingResult.OK) { var op = opParser.parse(input) while (op.result == ParsingResult.OK) { val rhs = rhsParser.parse(input) - if(rhs.result == ParsingResult.FAILED) { // Todo: Not sure if it should be here + if (rhs.result == ParsingResult.FAILED) { // Todo: Not sure if it should be here return ParserOutput.fail() } lhs = ParserOutput.ok(createNode(lhs.node, op.node, rhs.node)) @@ -120,11 +125,11 @@ abstract class Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { val items = mutableListOf() - while(true) { + while (true) { val output = itemParser.parse(input) - if(output.result == ParsingResult.OK) { + if (output.result == ParsingResult.OK) { items += output.node - } else if(items.isEmpty()) { + } else if (items.isEmpty()) { return ParserOutput.fail() } else { return ParserOutput.ok(createNode(items, items.first().position)) @@ -136,19 +141,24 @@ abstract class Parser { } // loop -> begin item* end - fun loop(beginParser: Parser, itemParser: Parser, endParser: Parser, createNode: (Node, List, Node) -> Node): Parser { + fun loop( + beginParser: Parser, + itemParser: Parser, + endParser: Parser, + createNode: (Node, List, Node) -> Node + ): Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { val items = mutableListOf() val begin = beginParser.parse(input) - if(begin.result == ParsingResult.OK) { - while(true) { + if (begin.result == ParsingResult.OK) { + while (true) { val end = endParser.parse(input) - if(end.result == ParsingResult.OK) { + if (end.result == ParsingResult.OK) { return ParserOutput.ok(createNode(begin.node, items, end.node)) } val item = itemParser.parse(input) - if(item.result == ParsingResult.FAILED) { + if (item.result == ParsingResult.FAILED) { return ParserOutput.fail() } items += item.node @@ -180,12 +190,12 @@ abstract class Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { val output = parser.parse(input) - return if(output.result == ParsingResult.OK) output else ParserOutput.ok(Node.NONE) + return if (output.result == ParsingResult.OK) output else ParserOutput.ok(Node.NONE) } } } - fun mapNode(parser: Parser, mapper: (Node) -> Node) : Parser { + fun mapNode(parser: Parser, mapper: (Node) -> Node): Parser { return object : Parser() { override fun tryToParse(input: TokenList): ParserOutput { return parser.parse(input).map(mapper) diff --git a/src/main/kotlin/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt b/src/main/kotlin/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt index 1f31abc..6e49d87 100644 --- a/src/main/kotlin/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt +++ b/src/main/kotlin/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt @@ -7,14 +7,14 @@ import dsl.token.model.enumeration.TokenType class RegularFunctionDefinitionArgumentParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( optional(terminal(TokenType.DOTS)), SimpleIdentifierParser(), - optional(allOf(listOf( + optional(allOf( terminal(TokenType.COLON), TypeParser() - )){ it[1] }) - )) { + ) { it[1] }) + ) { RegularFunctionDefinitionArgumentNode(it[1], it[2], it[0]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/ReturnParser.kt b/src/main/kotlin/dsl/ast/parser/ReturnParser.kt index 92c30e6..12e7b80 100644 --- a/src/main/kotlin/dsl/ast/parser/ReturnParser.kt +++ b/src/main/kotlin/dsl/ast/parser/ReturnParser.kt @@ -7,10 +7,10 @@ import dsl.token.model.enumeration.TokenType class ReturnParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( terminal(TokenType.RETURN), optional(SubexpressionParser()) - )) { + ) { ReturnNode(it[1]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/SimpleIdentifierParser.kt b/src/main/kotlin/dsl/ast/parser/SimpleIdentifierParser.kt index c5edb2a..1da610f 100644 --- a/src/main/kotlin/dsl/ast/parser/SimpleIdentifierParser.kt +++ b/src/main/kotlin/dsl/ast/parser/SimpleIdentifierParser.kt @@ -9,8 +9,8 @@ class SimpleIdentifierParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { val identifierParser = terminal(TokenType.IDENTIFIER) { IdentifierNode(it) } - return oneOf(listOf( + return oneOf( identifierParser - )).parse(input) + ).parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/StatementParser.kt b/src/main/kotlin/dsl/ast/parser/StatementParser.kt index 0db02eb..ba390ba 100644 --- a/src/main/kotlin/dsl/ast/parser/StatementParser.kt +++ b/src/main/kotlin/dsl/ast/parser/StatementParser.kt @@ -7,18 +7,14 @@ import dsl.token.model.enumeration.TokenType class StatementParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { return allOf( - listOf( - oneOf( - listOf( - ConditionParser(), - ExpressionParser(), - BlockParser(), - ReturnParser(), - ThrowParser() - ) - ), - optional(terminal(TokenType.SEMICOLON)) - ) + oneOf( + ConditionParser(), + ExpressionParser(), + BlockParser(), + ReturnParser(), + ThrowParser() + ), + optional(terminal(TokenType.SEMICOLON)) ) { it[0] }.parse(input) diff --git a/src/main/kotlin/dsl/ast/parser/SubexpressionParser.kt b/src/main/kotlin/dsl/ast/parser/SubexpressionParser.kt index 8171fbb..4f27e14 100644 --- a/src/main/kotlin/dsl/ast/parser/SubexpressionParser.kt +++ b/src/main/kotlin/dsl/ast/parser/SubexpressionParser.kt @@ -13,32 +13,32 @@ class SubexpressionParser : Parser() { TermParser(), listOf(TokenType.PLUS, TokenType.MINUS), TermParser() - ) { - lhs, operator, rhs -> SumOperatorNode(lhs, operator, rhs) + ) { lhs, operator, rhs -> + SumOperatorNode(lhs, operator, rhs) } val expr2Parser = leftAssociativeOperator( expr1Parser, listOf(TokenType.RELATION, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE), expr1Parser - ) { - lhs, operator, rhs -> RelationOperatorNode(lhs, operator, rhs) + ) { lhs, operator, rhs -> + RelationOperatorNode(lhs, operator, rhs) } val expr3Parser = leftAssociativeOperator( expr2Parser, listOf(TokenType.AND), expr2Parser - ) { - lhs, operator, rhs -> LogicOperatorNode(lhs, operator, rhs) + ) { lhs, operator, rhs -> + LogicOperatorNode(lhs, operator, rhs) } val expr4Parser = leftAssociativeOperator( expr3Parser, listOf(TokenType.OR), expr3Parser - ) { - lhs, operator, rhs -> LogicOperatorNode(lhs, operator, rhs) + ) { lhs, operator, rhs -> + LogicOperatorNode(lhs, operator, rhs) } return expr4Parser.parse(input) diff --git a/src/main/kotlin/dsl/ast/parser/TermParser.kt b/src/main/kotlin/dsl/ast/parser/TermParser.kt index afc8f77..2c4e6f8 100644 --- a/src/main/kotlin/dsl/ast/parser/TermParser.kt +++ b/src/main/kotlin/dsl/ast/parser/TermParser.kt @@ -11,8 +11,8 @@ class TermParser : Parser() { FactorParser(), listOf(TokenType.ASTERISK, TokenType.SLASH), FactorParser() - ) { - lhs, operator, rhs -> ProductOperatorNode(lhs, operator, rhs) + ) { lhs, operator, rhs -> + ProductOperatorNode(lhs, operator, rhs) }.parse(input) } } \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/ThrowParser.kt b/src/main/kotlin/dsl/ast/parser/ThrowParser.kt index 170e6a6..e8188f3 100644 --- a/src/main/kotlin/dsl/ast/parser/ThrowParser.kt +++ b/src/main/kotlin/dsl/ast/parser/ThrowParser.kt @@ -7,10 +7,10 @@ import dsl.token.model.enumeration.TokenType class ThrowParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( terminal(TokenType.THROW), optional(SubexpressionParser()) - )) { + ) { ThrowNode(it[1]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/TypeParser.kt b/src/main/kotlin/dsl/ast/parser/TypeParser.kt index e34a908..fd5c9aa 100644 --- a/src/main/kotlin/dsl/ast/parser/TypeParser.kt +++ b/src/main/kotlin/dsl/ast/parser/TypeParser.kt @@ -7,10 +7,10 @@ import dsl.token.model.entity.TokenList class TypeParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { - return allOf(listOf( + return allOf( SimpleIdentifierParser(), - optional(repeat(TypeSpecifierParser()) { list, tokenPosition -> TypeSpecifiersNode(list, tokenPosition) }) - )) { + optional(repeat(TypeSpecifierParser()) { list, tokenPosition -> TypeSpecifiersNode(list, tokenPosition) }) + ) { TypeNode(it[0], it[1]) }.parse(input) } diff --git a/src/main/kotlin/dsl/ast/parser/TypeSpecifierParser.kt b/src/main/kotlin/dsl/ast/parser/TypeSpecifierParser.kt index e460e53..d739baa 100644 --- a/src/main/kotlin/dsl/ast/parser/TypeSpecifierParser.kt +++ b/src/main/kotlin/dsl/ast/parser/TypeSpecifierParser.kt @@ -3,6 +3,7 @@ package dsl.ast.parser import dsl.ast.model.node.TypeSpecifierNode import dsl.token.model.enumeration.TokenType -class TypeSpecifierParser : AbstractIterableParser(TokenType.OPEN_ANGLE, TypeParser(), TokenType.CLOSE_ANGLE, { - list, tokenPosition -> TypeSpecifierNode(list, tokenPosition) -}) \ No newline at end of file +class TypeSpecifierParser : + AbstractIterableParser(TokenType.OPEN_ANGLE, TypeParser(), TokenType.CLOSE_ANGLE, { list, tokenPosition -> + TypeSpecifierNode(list, tokenPosition) + }) \ No newline at end of file diff --git a/src/main/kotlin/dsl/ast/parser/UnitParser.kt b/src/main/kotlin/dsl/ast/parser/UnitParser.kt index 554eaea..58153c0 100644 --- a/src/main/kotlin/dsl/ast/parser/UnitParser.kt +++ b/src/main/kotlin/dsl/ast/parser/UnitParser.kt @@ -9,21 +9,19 @@ import dsl.token.model.enumeration.TokenType class UnitParser : Parser() { override fun tryToParse(input: TokenList): ParserOutput { val minusOperatorParser = allOf( - listOf( - terminal(TokenType.MINUS), - assert(AtomParser(), "atom") - ) + terminal(TokenType.MINUS), + assert(AtomParser(), "atom") ) { MinusOperatorNode(it[0], it[1]) } - val atom2 = oneOf(listOf( + val atom2 = oneOf( minusOperatorParser, AtomParser() - )) + ) - return leftAssociativeOperator(atom2, listOf(TokenType.DOT), assert(atom2, "atom")) { - lhs, operator, rhs -> AccessOperatorNode(lhs, operator, rhs) + return leftAssociativeOperator(atom2, listOf(TokenType.DOT), assert(atom2, "atom")) { lhs, operator, rhs -> + AccessOperatorNode(lhs, operator, rhs) }.parse(input) } } \ No newline at end of file