From c6319e79200293167a5354a4834c18f815660599 Mon Sep 17 00:00:00 2001 From: Danila Fedorin Date: Tue, 24 Jul 2018 23:57:20 -0700 Subject: [PATCH] Create draft of parser in main code. --- src/chalk.cr | 169 ++++++++++++++++++++++++++++++++++++- src/chalk/builder.cr | 8 ++ src/chalk/parser.cr | 36 +++++++- src/chalk/print_visitor.cr | 2 + src/chalk/tree.cr | 30 ++++++- 5 files changed, 239 insertions(+), 6 deletions(-) diff --git a/src/chalk.cr b/src/chalk.cr index 3c58ef2..6b498ad 100644 --- a/src/chalk.cr +++ b/src/chalk.cr @@ -1,6 +1,171 @@ require "./chalk/*" -# TODO: Write documentation for `Chalk` module Chalk - # TODO: Put your code here + lexer = Lexer.new + tokens = lexer.lex(File.read("test.txt")) + + def self.create_op(atom, op) + pl = PlaceholderParser(Tree).new + recurse = atom.then(op).then(pl).transform do |arr| + arr = arr.flatten + TreeOp.new( + arr[1].as(Token).type, + arr[0].as(Tree), + arr[2].as(Tree)).as(Tree) + end + pl.parser = either(recurse, atom) + return pl + end + + def self.create_ops(source, ops) + ops.reduce(source) do |previous, current| + create_op(previous, current) + end + end + + def self.create_type + either(type(TokenType::KwU0), type(TokenType::KwU8), type(TokenType::KwU12)) + end + + def self.create_lit + dec_parser = type(TokenType::LitDec).transform &.string.to_i64 + hex_parser = type(TokenType::LitHex).transform &.string.lchop("0x").to_i64(16) + bin_parser = type(TokenType::LitBin).transform &.string.lchop("0b").to_i64(2) + lit_parser = either(dec_parser, hex_parser, bin_parser).transform { |it| TreeLit.new(it).as(Tree) } + return lit_parser + end + + def self.create_call(expr) + call = type(TokenType::Id).then(char '(').then(delimited(expr, char ',')).then(char ')').transform do |arr| + arr = arr.flatten + name = arr[0].as(Token).string + params = arr[2..arr.size - 2].map &.as(Tree) + TreeCall.new(name, params).as(Tree) + end + return call + end + + def self.create_block(statement) + block = char('{').then(many(statement)).then(char '}').transform do |arr| + arr = arr.flatten + params = arr[1..arr.size - 2].map &.as(Tree) + TreeBlock.new(params).as(Tree) + end + return block + end + + def self.create_if(expr, block) + iff = type(TokenType::KwIf).then(char '(').then(expr).then(char ')').then(block) + .then(optional(type(TokenType::KwElse).then(block))) + .transform do |arr| + arr = arr.flatten + cond = arr[2].as(Tree) + code = arr[4].as(Tree) + otherwise = arr.size == 7 ? arr[6].as(Tree) : nil + TreeIf.new(cond, code, otherwise).as(Tree) + end + return iff + end + + def self.create_while(expr, block) + whilee = type(TokenType::KwWhile).then(char '(').then(expr).then(char ')').then(block).transform do |arr| + arr = arr.flatten + cond = arr[2].as(Tree) + code = arr[4].as(Tree) + TreeWhile.new(cond, code).as(Tree) + end + return whilee + end + + def self.create_return(expr) + returnn = type(TokenType::KwReturn).then(expr).then(char ';').transform do |arr| + arr = arr.flatten + value = arr[1].as(Tree) + TreeReturn.new(value).as(Tree) + end + return returnn + end + + def self.create_func(block, type) + func = type(TokenType::KwFun).then(type(TokenType::Id)) + .then(char '(').then(delimited(type(TokenType::Id), char ',')).then(char ')') + .then(char ':').then(type) + .then(block).transform do |arr| + arr = arr.flatten + name = arr[1].as(Token).string + params = arr[3..arr.size - 5].map &.as(Token).string + code = arr[arr.size - 1].as(Tree) + type = arr[arr.size - 2].as(Token).type + TreeFunction.new(name, params, code).as(Tree) + end + return func + end + + def self.create_var(expr) + var = type(TokenType::KwVar).then(type(TokenType::Id)).then(char '=').then(expr).then(char ';').transform do |arr| + arr = arr.flatten + name = arr[1].as(Token).string + exp = arr[arr.size - 2].as(Tree) + TreeVar.new(name, exp).as(Tree) + end + return var + end + + def self.create_assign(expr) + assign = type(TokenType::Id).then(char '=').then(expr).then(char ';').transform do |arr| + arr = arr.flatten + name = arr[0].as(Token).string + exp = arr[arr.size - 2].as(Tree) + TreeAssign.new(name, exp).as(Tree) + end + return assign + end + + def self.create_basic(expr) + basic = expr.then(char ';').transform do |arr| + arr.flatten[0].as(Tree) + end + return basic + end + + def self.create_expression + expr_place = PlaceholderParser(Tree).new + literal = create_lit + id = type(TokenType::Id).transform { |it| TreeId.new(it.string).as(Tree) } + call = create_call(expr_place) + atom = either(literal, call, id) + + ops = [ either(type(TokenType::OpMul), type(TokenType::OpDiv)), + either(type(TokenType::OpAdd), type(TokenType::OpSub)), + type(TokenType::OpXor), + type(TokenType::OpAnd), + type(TokenType::OpOr) ] + expr = create_ops(atom, ops) + expr_place.parser = expr + + return expr + end + + def self.create_block + expr = create_expression + + statement_place = PlaceholderParser(Tree).new + block = create_block(statement_place) + iff = create_if(expr, block) + whilee = create_while(expr, block) + returnn = create_return(expr) + var = create_var(expr) + assign = create_assign(expr) + basic = create_basic(expr) + statement = either(basic, var, assign, block, iff, whilee, returnn) + statement_place.parser = statement + + return block + end + + func = create_func(create_block, create_type) + body = many(func) + + final = body + final.parse(tokens, 0)[0].each &.accept(PrintVisitor.new) end diff --git a/src/chalk/builder.cr b/src/chalk/builder.cr index 4f645e5..8bcae2b 100644 --- a/src/chalk/builder.cr +++ b/src/chalk/builder.cr @@ -6,6 +6,10 @@ module Chalk return TypeParser.new(type).as(Parser(Token)) end + def self.char(type): Parser(Token) + return CharParser.new(type).as(Parser(Token)) + end + def self.transform(parser : Parser(T), &transform : T -> R) forall T, R return TransformParser.new(parser, &transform).as(Parser(R)) end @@ -22,6 +26,10 @@ module Chalk return ManyParser.new(parser).as(Parser(Array(T))) end + def self.delimited(parser : Parser(T), delimiter : Parser(R)): Parser(Array(T)) forall T, R + return DelimitedParser.new(parser, delimiter).as(Parser(Array(T))) + end + def self.then(first : Parser(T), second : Parser(R)) forall T, R return NextParser.new(first, second).as(Parser(Array(T | R))) end diff --git a/src/chalk/parser.cr b/src/chalk/parser.cr index 3e9797f..0418817 100644 --- a/src/chalk/parser.cr +++ b/src/chalk/parser.cr @@ -32,6 +32,18 @@ module Chalk end end + class CharParser < Parser(Token) + def initialize(@char : Char) + end + + def parse?(tokens, index) + return nil unless index < tokens.size + return nil unless (tokens[index].type == TokenType::Any) && + tokens[index].string[0] == @char + return { tokens[index], index + 1} + end + end + class TransformParser(T, R) < Parser(R) def initialize(@parser : Parser(T), &@block : T -> R) end @@ -84,6 +96,28 @@ module Chalk end end + class DelimitedParser(T, R) < Parser(Array(T)) + def initialize(@parser : Parser(T), @delimiter : Parser(R)) + end + + def parse?(tokens, index) + array = [] of T + first = @parser.parse?(tokens, index) + return { array, index } unless first + first_value, index = first + array << first_value + while delimiter = @delimiter.parse?(tokens, index) + _, new_index = delimiter + new = @parser.parse?(tokens, new_index) + break unless new + new_value, index = new + array << new_value + end + + return { array, index } + end + end + class NextParser(T, R) < Parser(Array(T | R)) def initialize(@first : Parser(T), @second : Parser(R)) end @@ -111,7 +145,7 @@ module Chalk end def parse?(tokens, index) - @parser.try &.parse(tokens, index) + @parser.try &.parse?(tokens, index) end end end diff --git a/src/chalk/print_visitor.cr b/src/chalk/print_visitor.cr index 91fec2b..bb82050 100644 --- a/src/chalk/print_visitor.cr +++ b/src/chalk/print_visitor.cr @@ -59,8 +59,10 @@ module Chalk end end + forward("[call]", TreeCall) forward("[block]", TreeBlock) forward("[var]", TreeVar) + forward("[assign]", TreeAssign) forward("[if]", TreeIf) forward("[while]", TreeWhile) forward("[return]", TreeReturn) diff --git a/src/chalk/tree.cr b/src/chalk/tree.cr index 919c76f..6ce35d8 100644 --- a/src/chalk/tree.cr +++ b/src/chalk/tree.cr @@ -24,6 +24,18 @@ module Chalk def initialize(@lit : Int64) end end + class TreeCall < Tree + property name : String + property params : Array(Tree) + + def initialize(@name : String, @params : Array(Tree)) end + def accept(v : Visitor) + v.visit(self) + @params.each &.accept(v) + v.finish(self) + end + end + class TreeOp < Tree property op : TokenType property left : Tree @@ -73,17 +85,29 @@ module Chalk end end + class TreeAssign < Tree + property name : String + property expr : Tree + + def initialize(@name : String, @expr : Tree) end + def accept(v : Visitor) + v.visit(self) + @expr.accept(v) + v.finish(self) + end + end + class TreeIf < Tree property condition : Tree property block : Tree - property otherwise : Tree + property otherwise : Tree? - def initialize(@condition : Tree, @block : Tree, @otherwise : Tree) end + def initialize(@condition : Tree, @block : Tree, @otherwise : Tree? = nil) end def accept(v : Visitor) v.visit(self) @condition.accept(v) @block.accept(v) - @otherwise.accept(v) + @otherwise.try &.accept(v) v.finish(self) end end