jievro-parser 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14e2978148043c35f1cc7228b7586fe4383bceda
+  data.tar.gz: 64604bffdc949996288c78a90a8a04507011c03c
+SHA512:
+  metadata.gz: 01489d03f902d929fe888fc49ab402fb156d9ea916197b6239527262bed880e29119774003030e0557c0331b67de375a80e3fcfcc5bc4cb783a52c2749f4f942
+  data.tar.gz: f3a20355d13406bf740a7604f469639d747ec38d093ce25ac277eefc36047a38663e3c13dcf5898e15584da7e1a78510aa6e270fa8fd551418f8d6b6014f3d5f

data/.gitignore

@@ -0,0 +1 @@
+/vendor/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+
+script: bundle exec rake test

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'treetop'
+gem 'polyglot'
+gem 'rspec', :require => 'spec'

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    polyglot (0.3.5)
+    rake (10.3.2)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    treetop (1.5.3)
+      polyglot (~> 0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  polyglot
+  rake
+  rspec
+  treetop

data/README.md

@@ -0,0 +1 @@
+# jievro ~ parser [![Build Status](https://travis-ci.org/jievro/parser.svg?branch=develop)](https://travis-ci.org/jievro/parser)

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.ruby_opts = %w(-I lib  -I spec)
+  t.rspec_opts = '--color --format progress'
+end

data/lib/parser/binary_operator.rb

@@ -0,0 +1,64 @@
+module Kauri
+  class BinaryOperator
+
+    def initialize(sign, associativity, precedence)
+      @sign = sign
+      @associativity = associativity
+      @precedence = precedence
+    end
+
+    def sign
+      @sign
+    end
+
+    def associativity
+      @associativity
+    end
+
+    def precedence
+      @precedence
+    end
+
+    def self.get(sign)
+      case sign
+        when '<<', '>>'
+          operator = BinaryOperator.new(sign, :none, 160)
+        when '*', '/', '%', '&*', '&/', '&%', '&'
+          operator = BinaryOperator.new(sign, :left, 150)
+        when '+', '-', '&+', '&-', '|', '^'
+          operator = BinaryOperator.new(sign, :left, 140)
+        when '..<', '...'
+          operator = BinaryOperator.new(sign, :none, 135)
+        when 'is', 'as'
+          operator = BinaryOperator.new(sign, :none, 132)
+        when '<', '<=', '>', '>=', '==', '!=', '===', '!==', '~='
+          operator = BinaryOperator.new(sign, :left, 130)
+        when '&&'
+          operator = BinaryOperator.new(sign, :left, 120)
+        when '||'
+          operator = BinaryOperator.new(sign, :left, 110)
+        when '??'
+          operator = BinaryOperator.new(sign, :right, 110)
+        when '?:'
+          operator = BinaryOperator.new(sign, :right, 100)
+        when '=', '*=', '/=', '%=', '+=', '-=', '<<=', '>>=', '&=', '^=', '|=', '&&=', '||='
+          operator = BinaryOperator.new(sign, :right, 90)
+        else
+          raise Exception, 'sign not managed'
+      end
+
+      operator
+    end
+
+    def self.is_operator(sign)
+      begin
+        self.get(sign)
+        is_operator = true
+      rescue Exception
+        is_operator = false
+      end
+
+      is_operator
+    end
+  end
+end

data/lib/parser/grammar/code_block.treetop

@@ -0,0 +1,46 @@
+module Kauri
+  grammar CodeBlock
+
+    rule code_block
+      '{' ws1:_ statement_list:statement_list? ws2:_ '}' {
+        def tokens
+          tokens = []
+
+            tokens.push({
+              type: 'T_OPEN_CURLY_BRACKET',
+              value: '{'
+            })
+
+            unless ws1.text_value.empty?
+              tokens.concat(ws1.tokens)
+            end
+
+            unless statement_list.text_value.empty?
+              tokens.concat(statement_list.tokens)
+            end
+
+            unless ws2.text_value.empty?
+              tokens.concat(ws2.tokens)
+            end
+
+            tokens.push({
+              type: 'T_CLOSE_CURLY_BRACKET',
+              value: '}'
+            })
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          unless statement_list.text_value.empty?
+            ast = statement_list.ast
+          end
+
+          ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/declaration/constant_declaration.treetop

@@ -0,0 +1,38 @@
+module Kauri
+  grammar ConstantDeclaration
+
+    rule constant_declaration
+      'let' whitespaces:whitespaces pattern_initializer_list:pattern_initializer_list {
+        def tokens
+
+          tokens = []
+
+          tokens.push({
+            type: 'T_LET',
+            value: 'let'
+          })
+
+          tokens.concat(whitespaces.tokens)
+          tokens.concat(pattern_initializer_list.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          ast = []
+
+          pattern_initializer_list.ast.each { |e|
+            ast.push({
+              block_type: 'constant-declaration',
+              pattern: e[:pattern],
+              initializer: e[:initializer]
+            })
+          }
+
+          ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/declaration/declaration.treetop

@@ -0,0 +1,16 @@
+require 'parser/grammar/declaration/constant_declaration'
+require 'parser/grammar/declaration/variable_declaration'
+require 'parser/grammar/declaration/function_declaration'
+
+module Kauri
+  grammar Declaration
+
+    include Kauri::ConstantDeclaration
+    include Kauri::VariableDeclaration
+    include Kauri::FunctionDeclaration
+
+    rule declaration
+      constant_declaration / variable_declaration / function_declaration
+    end
+  end
+end

data/lib/parser/grammar/declaration/function_declaration.treetop

@@ -0,0 +1,302 @@
+module Kauri
+  grammar FunctionDeclaration
+
+    rule function_declaration
+      function_head ws1:_ function_name ws2:_ function_signature ws3:_ function_body {
+        def tokens
+          tokens = []
+
+          tokens.concat(function_head.tokens)
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(function_name.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(function_signature.tokens)
+
+          unless ws3.text_value.empty?
+            tokens.concat(ws3.tokens)
+          end
+
+          tokens.concat(function_body.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          signature = function_signature.ast
+
+          name = function_name.ast.first
+          parameters = signature[:parameters]
+          return_type = signature[:return_type]
+          body = function_body.ast
+
+          [
+            {
+              block_type: 'function-declaration',
+              name: name,
+              parameters: parameters,
+              return_type: return_type,
+              body: body
+            }
+          ]
+        end
+      }
+    end
+
+    rule function_head
+      'func' {
+        def tokens
+          [
+            {
+              type: 'T_FUNCTION',
+              value: 'func'
+            }
+          ]
+        end
+      }
+    end
+
+    rule function_name
+      identifier
+    end
+
+    rule function_signature
+      parameter_clause:parameter_clause ws:_ return_type:return_type? {
+        def tokens
+          tokens = []
+
+          tokens.concat(parameter_clause.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          unless return_type.text_value.empty?
+            tokens.concat(return_type.tokens)
+          end
+
+          tokens
+        end
+        
+        def ast
+
+          parameters = parameter_clause.ast
+
+          unless return_type.text_value.empty?
+            type = return_type.ast
+          end
+
+          {
+            parameters: parameters,
+            return_type: type
+          }
+        end
+      }
+    end
+
+    rule parameter_clause
+      empty_parameter_clause / parameter_clause_with_arguments
+    end
+
+    rule empty_parameter_clause
+      '(' ws:_ ')' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_ROUND_BRACKET',
+            value: '('
+          })
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_ROUND_BRACKET',
+            value: ')'
+          })
+
+          tokens
+        end
+
+        def ast
+          []
+        end
+      }
+    end
+
+    rule parameter_clause_with_arguments
+      '(' ws1:_ parameter_list ws2:_ ')' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_ROUND_BRACKET',
+            value: '('
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(parameter_list.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_ROUND_BRACKET',
+            value: ')'
+          })
+
+          tokens
+        end
+
+        def ast
+          parameter_list.ast
+        end
+      }
+    end
+
+    rule parameter_list
+      head:(parameter ws1:_ ',' ws2:_)* tail:parameter {
+        def tokens
+          tokens = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              tokens.concat(e.parameter.tokens)
+
+              unless e.ws1.text_value.empty?
+                tokens.concat(e.ws1.tokens)
+              end
+
+              tokens.push({
+                type: 'T_COMMA',
+                value: ','
+              })
+
+              unless e.ws2.text_value.empty?
+                tokens.concat(e.ws2.tokens)
+              end
+            }
+          end
+
+          tokens.concat(tail.tokens)
+
+          tokens
+        end
+
+        def ast
+          ast = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              ast.push(e.parameter.ast)
+            }
+          end
+
+          ast.push(tail.ast)
+
+          ast
+        end
+      }
+    end
+
+    rule parameter
+      (
+        (external_parameter_name ws1:_ local_parameter_name ws2:_ type_annotation)
+        /
+        (local_parameter_name ws2:_ type_annotation)
+      ) {
+        def tokens
+          tokens = []
+
+          if defined? external_parameter_name
+            tokens.concat(external_parameter_name.tokens)
+          end
+
+          if defined? ws1
+            unless ws1.text_value.empty?
+              tokens.concat(ws1.tokens)
+            end
+          end
+
+          tokens.concat(local_parameter_name.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(type_annotation.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          type = type_annotation.ast.first
+          local = local_parameter_name.ast.first
+
+          if defined? external_parameter_name
+            external = external_parameter_name.ast.first
+          end
+
+          {
+            type: type,
+            local: local,
+            external: external,
+            default: nil
+          }
+        end
+      }
+    end
+
+    rule local_parameter_name
+      identifier / wildcard
+    end
+
+    rule external_parameter_name
+      identifier / wildcard
+    end
+
+    rule return_type
+      '->' ws:_ type:type {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_RETURN_TYPE_ARROW',
+            value: '->'
+          })
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.concat(type.tokens)
+
+          tokens
+        end
+
+        def ast
+          type.ast.first
+        end
+      }
+    end
+
+    rule function_body
+      code_block
+    end
+  end
+end

data/lib/parser/grammar/declaration/variable_declaration.treetop

@@ -0,0 +1,38 @@
+module Kauri
+  grammar VariableDeclaration
+
+    rule variable_declaration
+      'var' whitespaces:whitespaces pattern_initializer_list:pattern_initializer_list {
+        def tokens
+
+          tokens = []
+
+          tokens.push({
+            type: 'T_VAR',
+            value: 'var'
+          })
+
+          tokens.concat(whitespaces.tokens)
+          tokens.concat(pattern_initializer_list.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          ast = []
+
+          pattern_initializer_list.ast.each { |e|
+            ast.push({
+              block_type: 'variable-declaration',
+              pattern: e[:pattern],
+              initializer: e[:initializer]
+            })
+          }
+
+          ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/expression/binary_expression.treetop

@@ -0,0 +1,75 @@
+require 'parser/tools/shunting_yard'
+
+module Kauri
+  grammar BinaryExpression
+
+    rule binary_expression
+      left:infix_operation_chain ws:_ right:primary_expression {
+        def tokens
+
+          tokens = []
+
+          tokens.concat(left.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.concat(right.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          sy = Kauri::Tools::ShuntingYard.new
+
+          flatten_ast = []
+
+          flatten_ast.concat(left.flatten_ast)
+          flatten_ast.push(right.ast.first)
+
+          ast = sy.generate_ast(flatten_ast)
+
+          ast
+        end
+      }
+    end
+
+    rule infix_operation_chain
+      (primary:primary_expression ws1:_ operator:operator ws2:_)+ {
+        def tokens
+          tokens = []
+
+          elements.each { |e|
+
+            tokens.concat(e.primary.tokens)
+
+            unless e.ws1.text_value.empty?
+              tokens.concat(e.ws1.tokens)
+            end
+
+            tokens.concat(e.operator.tokens)
+
+            unless e.ws2.text_value.empty?
+              tokens.concat(e.ws2.tokens)
+            end
+          }
+
+          tokens
+        end
+
+        def flatten_ast
+          nodes = []
+
+          elements.each { |e|
+            nodes.push(e.primary.ast.first)
+            nodes.push(e.operator.text_value)
+          }
+
+          nodes
+        end
+      }
+    end
+  end
+end