jievro-parser 0.4.0

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

@@ -0,0 +1,47 @@
+require 'parser/tools/converter/converter'
+
+module Kauri
+  grammar LiteralIntegerHexadecimal
+
+    rule literal_integer_hexadecimal
+      '0x' hexadecimal_digit hexadecimal_literal_characters? {
+        def tokens
+          [
+            {
+              type: 'T_LITERAL_INTEGER_HEXADECIMAL',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+
+          converter = Kauri::Tools::Converter::HexadecimalStringToIntConverter.new
+
+          [
+            {
+              block_type: 'literal-integer',
+              value: converter.convert(text_value)
+            }
+          ]
+        end
+      }
+    end
+
+    rule hexadecimal_literal_characters
+      hexadecimal_literal_character+
+    end
+
+    rule hexadecimal_literal_character
+      hexadecimal_digit / '_'
+    end
+
+    rule hexadecimal_digits
+      hexadecimal_digit+
+    end
+
+    rule hexadecimal_digit
+      [0-9A-Fa-f]
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'parser/tools/converter/converter'
+
+module Kauri
+  grammar LiteralIntegerOctal
+
+    rule literal_integer_octal
+      '0o' octal_digit octal_literal_characters? {
+        def tokens
+          [
+            {
+              type: 'T_LITERAL_INTEGER_OCTAL',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+
+          converter = Kauri::Tools::Converter::OctalStringToIntConverter.new
+
+          [
+            {
+              block_type: 'literal-integer',
+              value: converter.convert(text_value)
+            }
+          ]
+        end
+      }
+    end
+
+    rule octal_literal_characters
+      octal_literal_character+
+    end
+
+    rule octal_literal_character
+      octal_digit / '_'
+    end
+
+    rule octal_digits
+      octal_digit+
+    end
+
+    rule octal_digit
+      [0-7]+
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Kauri
+  grammar LiteralNil
+
+    rule literal_nil
+      'nil' {
+        def tokens
+          [
+            {
+              type: 'T_NIL',
+              value: text_value
+            }
+          ]
+        end
+
+        def ast
+          [
+            {
+              block_type: 'literal-nil'
+            }
+          ]
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'parser/grammar/literal/literal_integer_binary'
+require 'parser/grammar/literal/literal_integer_octal'
+require 'parser/grammar/literal/literal_integer_decimal'
+require 'parser/grammar/literal/literal_integer_hexadecimal'
+require 'parser/grammar/literal/literal_decimal_floating_point'
+require 'parser/grammar/literal/literal_hexadecimal_floating_point'
+
+module Kauri
+  grammar LiteralNumeric
+
+    include Kauri::LiteralIntegerBinary
+    include Kauri::LiteralIntegerOctal
+    include Kauri::LiteralIntegerDecimal
+    include Kauri::LiteralIntegerHexadecimal
+    include Kauri::LiteralDecimalFloatingPoint
+    include Kauri::LiteralHexadecimalFloatingPoint
+
+    rule literal_numeric
+      minus:minus? numeric:(literal_floating_point / literal_integer) {
+        def tokens
+          tokens = []
+
+          unless minus.text_value.empty?
+            tokens.push(minus.tokens)
+          end
+
+          tokens.concat(numeric.tokens)
+
+          tokens
+        end
+
+        def ast
+          ast = numeric.ast.first
+
+          unless minus.text_value.empty?
+            ast[:value] = -ast[:value]
+          end
+
+          [ast]
+        end
+      }
+    end
+
+    rule literal_integer
+      literal_integer_hexadecimal
+      /
+      literal_integer_octal
+      /
+      literal_integer_binary
+      /
+      literal_integer_decimal
+    end
+
+    rule literal_floating_point
+      literal_hexadecimal_floating_point / literal_decimal_floating_point
+    end
+
+    rule minus
+      '-' {
+        def tokens
+          {
+            type: 'T_MINUS',
+            value: '-'
+          }
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+module Kauri
+  grammar LiteralString
+
+    rule literal_string
+      '"' quoted_text:quoted_text? '"' {
+        def tokens
+
+          tokens = [
+            {
+              type: 'T_DOUBLE_QUOTE',
+              value: '"'
+            }
+          ]
+
+          unless quoted_text.text_value.empty?
+            tokens.concat(quoted_text.tokens)
+          end
+
+          tokens.push({
+            type: 'T_DOUBLE_QUOTE',
+            value: '"'
+          })
+
+          tokens
+        end
+
+        def ast
+
+          if quoted_text.text_value.empty?
+            ast = [
+              {
+                block_type: 'literal-string',
+                value: ''
+              }
+            ]
+          else
+            ast = quoted_text.ast
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule quoted_text
+      quoted_text_item+ {
+        def tokens
+          tokens = []
+          elements.each { |e|
+            tokens.concat(e.tokens)
+          }
+          tokens
+        end
+
+        def ast
+          ast = []
+          is_interpolated_string = false
+          last_node_is_literal_string = false
+          stripper = Kauri::Tools::QuoteStripper.new
+
+          elements.each { |e|
+            if e.is_expression
+              is_interpolated_string = true
+              last_node_is_literal_string = false
+              ast.push(e.ast)
+            else
+
+              if e.is_quoted_unicode_char
+                value = e.raw_value
+              else
+                value = stripper.strip(e.text_value)
+              end
+
+              if last_node_is_literal_string
+                ast[-1][:value] += value
+              else
+                ast.push({
+                  block_type: 'literal-string',
+                  value: value
+                })
+              end
+              last_node_is_literal_string = true
+            end
+          }
+
+          if is_interpolated_string
+            ast = [
+              {
+                block_type: 'interpolated-string',
+                value: ast
+              }
+            ]
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule quoted_text_item
+      quoted_unicode_char / quoted_expression / sequence_of_chars
+    end
+
+    rule sequence_of_chars
+      (escaped_character / standard_character)+ {
+        def tokens
+          stripper = Kauri::Tools::QuoteStripper.new
+          [
+            {
+              type: 'T_LITERAL_STRING',
+              value: stripper.strip(text_value)
+            }
+          ]
+        end
+
+        def is_expression
+          false
+        end
+
+        def is_quoted_unicode_char
+          false
+        end
+      }
+    end
+
+    rule quoted_expression
+      '\(' expression:literal ')' {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_QUOTED_EXPRESSION_OPEN',
+            value: '\('
+          })
+
+          tokens.concat(expression.tokens)
+
+          tokens.push({
+            type: 'T_QUOTED_EXPRESSION_CLOSE',
+            value: ')'
+          })
+
+          tokens
+        end
+
+        def ast
+          expression.ast.first
+        end
+
+        def is_expression
+          true
+        end
+
+        def is_quoted_unicode_char
+          false
+        end
+      }
+    end
+
+    rule quoted_unicode_char
+      '\u{' unicode_scalar_digits:unicode_scalar_digits 1..8 '}' {
+        def tokens
+          [
+            {
+              type: 'T_QUOTED_UNICODE_CHAR_OPEN',
+              value: '\\u' + 123.chr
+            },
+            {
+              type: 'T_UNICODE_CHAR',
+              value: unicode_scalar_digits.text_value
+            },
+            {
+              type: 'T_QUOTED_UNICODE_CHAR_CLOSE',
+              value: 125.chr
+            }
+          ]
+        end
+
+        def is_expression
+          false
+        end
+
+        def is_quoted_unicode_char
+          true
+        end
+
+        def raw_value
+          unicode_string_value = unicode_scalar_digits.text_value
+          unicode_value = unicode_string_value.to_i(base=16)
+          [unicode_value].pack('U*')
+        end
+      }
+    end
+
+    rule unicode_scalar_digits
+      hexadecimal_digit
+    end
+
+    rule standard_character
+      [a-zA-Z0-9: ]
+    end
+
+    rule escaped_character
+      '\0' / '\"' / '\\\'' / '\n' / '\\\\' / '\t' / '\n' / '\r'
+    end
+  end
+end

data/lib/parser/grammar/operator.treetop

@@ -0,0 +1,35 @@
+module Kauri
+  grammar Operator
+
+    rule operator
+      operator_head operator_characters? {
+        def tokens
+          [
+            {
+              type: 'T_OPERATOR',
+              value: text_value
+            }
+          ]
+        end
+        def ast
+          []
+        end
+        def operator
+          text_value
+        end
+      }
+    end
+
+    rule operator_head
+      operator_basic_char
+    end
+
+    rule operator_characters
+      operator_basic_char+
+    end
+
+    rule operator_basic_char
+      '/' / '=' / '-' / '+' / '!' / '*' / '%' / '<' / '>' / '&' / '|' / '^' / '~' / '?'
+    end
+  end
+end

data/lib/parser/grammar/pattern/pattern.treetop

@@ -0,0 +1,16 @@
+require 'parser/grammar/pattern/pattern_wildcard'
+require 'parser/grammar/pattern/pattern_identifier'
+require 'parser/grammar/pattern/pattern_initializer'
+
+module Kauri
+  grammar Pattern
+
+    include Kauri::PatternWildcard
+    include Kauri::PatternIdentifier
+    include Kauri::PatternInitializer
+
+    rule pattern
+      pattern_wildcard / pattern_identifier
+    end
+  end
+end

data/lib/parser/grammar/pattern/pattern_identifier.treetop

@@ -0,0 +1,8 @@
+module Kauri
+  grammar PatternIdentifier
+
+    rule pattern_identifier
+      identifier
+    end
+  end
+end

data/lib/parser/grammar/pattern/pattern_initializer.treetop

@@ -0,0 +1,189 @@
+module Kauri
+  grammar PatternInitializer
+
+    rule untyped_pattern_initializer
+      pattern:pattern ws:_ initializer:initializer? {
+        def tokens
+          tokens = []
+
+          tokens.concat(pattern.tokens)
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          unless initializer.text_value.empty?
+            tokens.concat(initializer.tokens)
+          end
+
+          tokens
+        end
+
+        def ast
+
+          ast = {
+            pattern: pattern.ast.first
+          }
+
+          ast[:pattern] = pattern.ast.first
+
+          unless initializer.text_value.empty?
+            ast[:initializer] = initializer.ast.first
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule typed_pattern_initializer
+      pattern:pattern ws1:_ type_annotation:type_annotation ws2:_ initializer:initializer? {
+        def tokens
+          tokens = []
+
+          tokens.concat(pattern.tokens)
+
+          unless ws1.text_value.empty?
+            tokens.concat(ws1.tokens)
+          end
+
+          tokens.concat(type_annotation.tokens)
+
+          unless ws2.text_value.empty?
+            tokens.concat(ws2.tokens)
+          end
+
+          unless initializer.text_value.empty?
+            tokens.concat(initializer.tokens)
+          end
+
+          tokens
+        end
+
+        def ast
+          ast = {}
+
+          ast[:pattern] = pattern.ast.first
+          ast[:pattern][:type] = type_annotation.ast.first
+
+          unless initializer.text_value.empty?
+            ast[:initializer] = initializer.ast.first
+          end
+
+          ast
+        end
+      }
+    end
+
+    rule pattern_initializer
+      (pattern:typed_pattern_initializer / pattern:untyped_pattern_initializer) {
+        def tokens
+          pattern.tokens
+        end
+
+        def ast
+          pattern.ast
+        end
+      }
+    end
+
+    rule pattern_initializer_list
+      head:pattern_initializer_list_head? ws:_ tail:pattern_initializer {
+        def tokens
+
+          tokens = []
+
+          unless head.text_value.empty?
+            tokens.concat(head.tokens)
+          end
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.concat(tail.tokens)
+
+          tokens
+        end
+
+        def ast
+
+          ast = []
+
+          unless head.text_value.empty?
+            ast.concat(head.ast)
+          end
+
+          ast.push(tail.ast)
+
+          ast
+        end
+      }
+    end
+
+    rule pattern_initializer_list_head
+      (pattern_initializer:pattern_initializer ws1:_ ',' ws2:_)+ {
+        def tokens
+
+          tokens = []
+
+          elements.each { |e|
+
+            tokens.concat(e.pattern_initializer.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
+          }
+
+          tokens
+        end
+
+        def ast
+
+          ast = []
+
+          elements.each { |e|
+            ast.push(e.pattern_initializer.ast)
+          }
+
+          ast
+        end
+      }
+    end
+
+    rule initializer
+      '=' ws:_ expression:expression {
+        def tokens
+          tokens = []
+
+          tokens.push({
+            type: 'T_OPERATOR',
+            value: '='
+          })
+
+          unless ws.text_value.empty?
+            tokens.concat(ws.tokens)
+          end
+
+          tokens.concat(expression.tokens)
+
+          tokens
+        end
+
+        def ast
+          expression.ast
+        end
+      }
+    end
+  end
+end

data/lib/parser/grammar/pattern/pattern_wildcard.treetop

@@ -0,0 +1,8 @@
+module Kauri
+  grammar PatternWildcard
+
+    rule pattern_wildcard
+      wildcard
+    end
+  end
+end

data/lib/parser/grammar/statement/branch/branch.treetop

@@ -0,0 +1,16 @@
+require 'parser/grammar/statement/branch/if'
+
+module Kauri
+  module Grammar
+    module Statement
+      grammar Branch
+
+        include Kauri::StatementIf
+
+        rule statement_branch
+          statement_if
+        end
+      end
+    end
+  end
+end