jievro-parser 0.4.0

data/lib/parser/grammar/generics/generics.treetop

@@ -0,0 +1,9 @@
+require 'parser/grammar/generics/generic_argument_clause'
+
+module Kauri
+  grammar Generics
+
+    include Kauri::GenericArgumentClause
+
+  end
+end

data/lib/parser/grammar/grammar.treetop

@@ -0,0 +1,76 @@
+require 'parser/grammar/whitespace'
+require 'parser/grammar/literal/literal'
+require 'parser/grammar/identifier'
+require 'parser/grammar/declaration/declaration'
+require 'parser/grammar/statement/statement'
+require 'parser/grammar/expression/expression'
+require 'parser/grammar/generics/generics'
+require 'parser/grammar/type/type'
+require 'parser/grammar/code_block'
+require 'parser/grammar/pattern/pattern'
+require 'parser/grammar/wildcard'
+require 'parser/grammar/operator'
+
+require 'parser/tools/tokens'
+
+module Jievro
+  grammar Swift
+
+    include Kauri::Whitespace
+    include Kauri::Literal
+    include Kauri::Identifier
+    include Kauri::Declaration
+    include Kauri::Statement
+    include Kauri::Expression
+    include Kauri::Generics
+    include Kauri::Type
+    include Kauri::CodeBlock
+    include Kauri::Pattern
+    include Kauri::Wildcard
+    include Kauri::Operator
+
+    rule root
+      (
+        declaration:declaration
+        /
+        statement:statement
+        /
+        expression:expression
+        /
+        identifier:identifier
+        /
+        whitespaces:whitespaces
+      ) {
+        def tokens
+          unless elements.any?
+            tokens = []
+          else
+            tokens = elements[0].tokens
+          end
+
+          tokens
+        end
+
+        def ast
+          body = []
+
+          if elements.length
+            e = elements[0]
+            if e.respond_to?(:ast)
+              body = e.ast
+            end
+
+            {
+              block_type: 'program',
+              body: body
+            }
+          end
+        end
+      }
+    end
+
+    rule sign
+      '+' / '-'
+    end
+  end
+end

data/lib/parser/grammar/identifier.treetop

@@ -0,0 +1,56 @@
+require 'parser/grammar/implicit_parameter_name'
+
+module Kauri
+  grammar Identifier
+
+    include Kauri::ImplicitParameterName
+
+    rule identifier
+      implicit_parameter_name / backticked_identifier / regular_identifier
+    end
+
+    rule regular_identifier
+      '_' [A-Za-z0-9_]+ / [A-Za-z] [A-Za-z0-9_]* {
+        def tokens
+          [
+            {
+              type: 'T_IDENTIFIER',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'identifier',
+              value: text_value
+            }
+          ]
+        end
+      }
+    end
+
+    rule backticked_identifier
+      '`' regular_identifier:regular_identifier '`' {
+        def tokens
+          [
+            {
+              type: 'T_BACKTICKED_IDENTIFIER',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'identifier',
+              value: regular_identifier.text_value
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/implicit_parameter_name.treetop

@@ -0,0 +1,26 @@
+module Kauri
+  grammar ImplicitParameterName
+
+    rule implicit_parameter_name
+      '$' literal_integer_decimal:literal_integer_decimal {
+        def tokens
+          [
+            {
+              type: 'T_IMPLICIT_PARAMETER_NAME',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'implicit-parameter-name',
+              value: literal_integer_decimal.text_value,
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/literal/literal.treetop

@@ -0,0 +1,45 @@
+require 'parser/grammar/literal/literal_nil'
+require 'parser/grammar/literal/literal_boolean'
+require 'parser/grammar/literal/literal_numeric'
+require 'parser/grammar/literal/literal_string'
+require 'parser/grammar/literal/literal_array'
+require 'parser/grammar/literal/literal_dictionary'
+
+module Kauri
+  grammar Literal
+
+    include Kauri::LiteralNil
+    include Kauri::LiteralBoolean
+    include Kauri::LiteralNumeric
+    include Kauri::LiteralString
+    include Kauri::LiteralArray
+    include Kauri::LiteralDictionary
+
+    rule literal
+      (literal_nil / literal_boolean / literal_numeric / literal_string / literal_array / literal_dictionary) {
+        def ast
+
+          if defined?(super)
+            return super
+          end
+
+          if elements.nil?
+            return []
+          end
+
+          unless elements.any?
+            return []
+          end
+
+          first_element = elements.first
+
+          if first_element.respond_to?(:ast)
+            return first_element.ast
+          end
+
+          []
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_array.treetop

@@ -0,0 +1,98 @@
+module Kauri
+  grammar LiteralArray
+
+    rule literal_array
+      '[' ws1:_ items:literal_array_items? ws2:_ ']' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_SQUARE_BRACKET',
+            value: '['
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          unless items.text_value.empty?
+            tokens.concat(items.tokens)
+          end
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_SQUARE_BRACKET',
+            value: ']'
+          })
+
+          tokens
+        end
+
+        def ast
+
+          values = []
+
+          unless items.text_value.empty?
+            values = items.ast
+          end
+
+          [
+            {
+              block_type: 'literal-array',
+              values: values
+            }
+          ]
+        end
+      }
+    end
+
+    rule literal_array_items
+      head:(expression:expression ws1:_ ',' ws2:_)* tail:expression {
+        def tokens
+          tokens = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+
+              tokens.concat(e.expression.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.concat(e.expression.ast)
+            }
+          end
+
+          ast.concat(tail.ast)
+
+          ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_boolean.treetop

@@ -0,0 +1,50 @@
+module Kauri
+  grammar LiteralBoolean
+
+    rule literal_boolean
+      literal_true / literal_false
+    end
+
+    rule literal_true
+      'true' {
+        def tokens
+          [
+            {
+              type: 'T_TRUE',
+              value: text_value
+            }
+          ]
+        end
+        def ast
+          [
+            {
+              block_type: 'literal-boolean',
+              value: true
+            }
+          ]
+        end
+      }
+    end
+
+    rule literal_false
+      'false' {
+        def tokens
+          [
+            {
+              type: 'T_FALSE',
+              value: text_value
+            }
+          ]
+        end
+        def ast
+          [
+            {
+              block_type: 'literal-boolean',
+              value: false
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_decimal_floating_point.treetop

@@ -0,0 +1,49 @@
+require 'parser/tools/converter/converter'
+
+module Kauri
+  grammar LiteralDecimalFloatingPoint
+
+    rule literal_decimal_floating_point
+      (
+        (literal_integer_decimal decimal_fraction decimal_exponent)
+        /
+        (literal_integer_decimal decimal_fraction)
+        /
+        (literal_integer_decimal decimal_exponent)
+      ) {
+        def tokens
+          [
+            {
+              type: 'T_LITERAL_FLOATING_POINT_DECIMAL',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+
+          converter = Kauri::Tools::Converter::DecimalFloatStringToFloatConverter.new
+
+          [
+            {
+              block_type: 'literal-double',
+              value: converter.convert(text_value)
+            }
+          ]
+        end
+      }
+    end
+
+    rule decimal_fraction
+      '.' literal_integer_decimal
+    end
+
+    rule decimal_exponent
+      floating_point_e sign? literal_integer_decimal
+    end
+
+    rule floating_point_e
+      'e' / 'E'
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_dictionary.treetop

@@ -0,0 +1,157 @@
+module Kauri
+  grammar LiteralDictionary
+
+    rule literal_dictionary
+      '[' ws1:_ content:literal_dictionary_content ws2:_ ']' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPEN_SQUARE_BRACKET',
+            value: '['
+          })
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(content.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.push({
+            type: 'T_CLOSE_SQUARE_BRACKET',
+            value: ']'
+          })
+
+          tokens
+        end
+
+        def ast
+          content.ast
+        end
+      }
+    end
+
+    rule literal_dictionary_content
+      (items:literal_dictionary_items / ':') {
+        def tokens
+
+          if defined? items
+            tokens = items.tokens
+          else
+            tokens = [{
+              type: 'T_COLON',
+              value: ':'
+            }]
+          end
+
+          tokens
+        end
+
+        def ast
+
+          if defined? items
+            ast = items.ast
+          else
+            ast = [{
+              block_type: 'literal-dictionary',
+              pairs: []
+            }]
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule literal_dictionary_item
+      key:expression ws1:_ ':' ws2:_ value:expression {
+        def tokens
+          tokens = []
+
+          tokens.concat(key.tokens)
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.push({
+            type: 'T_COLON',
+            value: ':'
+          })
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          tokens.concat(value.tokens)
+
+          tokens
+        end
+
+        def ast
+          [
+            {
+              key: key.ast.first,
+              value: value.ast.first
+            }
+          ]
+        end
+      }
+    end
+
+    rule literal_dictionary_items
+      head:(item:literal_dictionary_item ws1:_ ',' ws2:_)* tail:literal_dictionary_item {
+        def tokens
+          tokens = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+
+              tokens.concat(e.item.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
+          pairs = []
+
+          unless head.text_value.empty?
+            head.elements.each { |e|
+              pairs.concat(e.item.ast)
+            }
+          end
+
+          pairs.concat(tail.ast)
+
+          [
+            {
+              block_type: 'literal-dictionary',
+              pairs: pairs
+            }
+          ]
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_hexadecimal_floating_point.treetop

@@ -0,0 +1,47 @@
+require 'parser/tools/converter/converter'
+
+module Kauri
+  grammar LiteralHexadecimalFloatingPoint
+
+    rule literal_hexadecimal_floating_point
+      (
+        (literal_integer_hexadecimal hexadecimal_fraction hexadecimal_exponent)
+        /
+        (literal_integer_hexadecimal hexadecimal_exponent)
+      ) {
+        def tokens
+          [
+            {
+              type: 'T_LITERAL_FLOATING_POINT_HEXADECIMAL',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+
+          converter = Kauri::Tools::Converter::HexadecimalFloatStringToFloatConverter.new
+
+          [
+            {
+              block_type: 'literal-double',
+              value: converter.convert(text_value)
+            }
+          ]
+        end
+      }
+    end
+
+    rule hexadecimal_fraction
+      '.' hexadecimal_digit hexadecimal_literal_characters?
+    end
+
+    rule hexadecimal_exponent
+      floating_point_p sign? literal_integer_decimal
+    end
+
+    rule floating_point_p
+      'p' / 'P'
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_integer_binary.treetop

@@ -0,0 +1,47 @@
+require 'parser/tools/converter/converter'
+
+module Kauri
+  grammar LiteralIntegerBinary
+
+    rule literal_integer_binary
+      '0b' binary_digit binary_literal_characters? {
+        def tokens
+          [
+            {
+              type: 'T_LITERAL_INTEGER_BINARY',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+
+          converter = Kauri::Tools::Converter::BinaryStringToIntConverter.new
+
+          [
+            {
+              block_type: 'literal-integer',
+              value: converter.convert(text_value)
+            }
+          ]
+        end
+      }
+    end
+
+    rule binary_literal_characters
+      binary_literal_character+
+    end
+
+    rule binary_literal_character
+      binary_digit / '_'
+    end
+
+    rule binary_digits
+      binary_digit+
+    end
+
+    rule binary_digit
+      [0-1]+
+    end
+  end
+end

data/lib/parser/grammar/literal/literal_integer_decimal.treetop

@@ -0,0 +1,47 @@
+require 'parser/tools/converter/converter'
+
+module Kauri
+  grammar LiteralIntegerDecimal
+
+    rule literal_integer_decimal
+      decimal_digit decimal_literal_characters? {
+        def tokens
+          [
+            {
+              type: 'T_LITERAL_INTEGER_DECIMAL',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+
+          converter = Kauri::Tools::Converter::DecimalStringToIntConverter.new
+
+          [
+            {
+              block_type: 'literal-integer',
+              value: converter.convert(text_value)
+            }
+          ]
+        end
+      }
+    end
+
+    rule decimal_literal_characters
+      decimal_literal_character+
+    end
+
+    rule decimal_literal_character
+      decimal_digit / '_'
+    end
+
+    rule decimal_digits
+      decimal_digit+
+    end
+
+    rule decimal_digit
+      [0-9]+
+    end
+  end
+end