treetop 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c3093c759c685e5241eea8e6ca42dd46d2719bc
-  data.tar.gz: 35c028a9353519e0865b5c1a82cbae4a307abb45
+  metadata.gz: 18fbc0b36ef1e609af0a671196218e5357161e54
+  data.tar.gz: adafd739d5027568cea7ed3baf9ffd8bcb6f5b59
 SHA512:
-  metadata.gz: 698c86025e1979b76b0279d7f28b2897a04832e32fe40d5e4b7708fb573141cb9a1b0f8e159c3db2c74afb44932ae8deea4331838e60d32b5f58ba054d7bfcef
-  data.tar.gz: 921b6d4b7a5debb9fa9ed662f359f31ae511d5f4c83426ab07cff120d8b634660684a9fe43f6a0c13fd7362f95c5a0e59f50763edd073c73728ba8f5060fb343
+  metadata.gz: c11d7d971c0c563025bacef00d8ad62aaae7c4d4400515ee7d173e6509c7afb2c6679036da29b8cb802749343ebf02d6ead9b6b6c8e659bd78f41751671b66a5
+  data.tar.gz: 965406473b8c53171bdb9c0a4c8e49ec2ab552cb1dc10c847d415a5c7d1b214b7bebf42d11a11988a52cd6b7cc3d96fc31b692efacc48a8bf8ef416439803d2a

data/Rakefile

@@ -15,6 +15,7 @@ Jeweler::Tasks.new do |gem|
   gem.homepage = "https://github.com/cjheath/treetop"
   gem.platform = Gem::Platform::RUBY
   gem.summary = "A Ruby-based text parsing and interpretation DSL"
+  gem.description = "A Parsing Expression Grammar (PEG) Parser generator DSL for Ruby"
   gem.files = [
       "LICENSE", "README.md", "Rakefile", "treetop.gemspec",
       "{spec,lib,bin,examples}/**/*",
@@ -23,7 +24,6 @@ Jeweler::Tasks.new do |gem|
   gem.bindir = "bin"
   gem.executables = ["tt"]
   gem.require_path = "lib"
-  gem.autorequire = "treetop"
   gem.has_rdoc = false
 end
 Jeweler::RubygemsDotOrgTasks.new
@@ -43,6 +43,13 @@ file 'lib/treetop/compiler/metagrammar.treetop' do |t|
   Treetop::Compiler::GrammarCompiler.new.compile(METAGRAMMAR_PATH)
 end
 
+task :rebuild do
+  $:.unshift "lib"
+  require './lib/treetop'
+  load File.expand_path('../lib/treetop/compiler/metagrammar.rb', __FILE__)
+  Treetop::Compiler::GrammarCompiler.new.compile('lib/treetop/compiler/metagrammar.treetop')
+end
+
 task :version do
   puts RUBY_VERSION
 end

data/doc/syntactic_recognition.markdown

@@ -215,3 +215,6 @@ tried at which locations in the input, and what the result was. This process, ca
 requires that the rule would produce the same result (if run again) as it produced the first time when
 the result was remembered. If you violate this principle in your semantic predicates, be prepared to
 fight Cerberus before you're allowed out of Hades again.
+
+There's an example of how to use semantic predicates to parse a language with white-space indented blocks
+in the examples directory.

data/examples/indented_blocks/indented_blocks.tt

@@ -0,0 +1,73 @@
+grammar IndentedBlocks
+  rule top
+    # Initialise the indent stack with a sentinel:
+    &{|s| @indents = [-1] }
+    foo:('foo'?)
+    nested_blocks
+    {
+      def inspect
+	nested_blocks.inspect
+      end
+    }
+  end
+
+  rule nested_blocks
+    (
+      # Do not try to extract this semantic predicate into a new rule.
+      # It will be memo-ized incorrectly because @indents.last will change.
+      !{|s|
+	# Peek at the following indentation:
+	save = index; i = _nt_indentation; index = save
+	# We're closing if the indentation is less or the same as our enclosing block's:
+	closing = i.text_value.length <= @indents.last
+      }
+      block
+    )*
+    {
+      def inspect
+	elements.map{|e| e.block.inspect}*"\n"
+      end
+    }
+  end
+
+  rule block
+    indented_line       # The block's opening line
+    &{|s|               # Push the indent level to the stack
+      level = s[0].indentation.text_value.length
+      @indents << level
+      true
+    }
+    nested_blocks       # Parse any nested blocks
+    &{|s|               # Pop the indent stack
+      # Note that under no circumstances should "nested_blocks" fail, or the stack will be mis-aligned
+      @indents.pop
+      true
+    }
+    {
+      def inspect
+	indented_line.inspect +
+	  (nested_blocks.elements.size > 0 ? (
+	    "\n{\n" +
+	    nested_blocks.elements.map { |content|
+	      content.block.inspect+"\n"
+	    }*'' +
+	    "}"
+	  )
+	  : "")
+      end
+    }
+  end
+
+  rule indented_line
+    indentation text:((!"\n" .)*) "\n"
+    {
+      def inspect
+	text.text_value
+      end
+    }
+  end
+
+  rule indentation
+    ' '*
+  end
+end

data/examples/indented_blocks/indented_blocks_test.rb

@@ -0,0 +1,24 @@
+require 'polyglot'
+require 'byebug'
+require 'treetop'
+require 'indented_blocks'
+
+parser = IndentedBlocksParser.new
+
+input = <<END
+def foo
+  here is some indented text
+    here it's further indented
+    and here the same
+      but here it's further again
+      and some more like that
+    before going back to here
+      down again
+  back twice
+and start from the beginning again
+  with only a small block this time
+END
+
+parse_tree = parser.parse input
+
+p parse_tree

data/examples/inner_outer.rb

@@ -0,0 +1,51 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module InnerOuter
+  include Treetop::Runtime
+
+  def root
+    @root ||= :inner_outer
+  end
+
+  module InnerOuter0
+	def inner
+	end
+  end
+
+  module InnerOuter1
+    def outer
+    end
+  end
+
+  def _nt_inner_outer
+    start_index = index
+    if node_cache[:inner_outer].has_key?(index)
+      cached = node_cache[:inner_outer][index]
+      if cached
+        node_cache[:inner_outer][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if (match_len = has_terminal?("foo", false, index))
+      r0 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      r0.extend(InnerOuter0)
+      @index += match_len
+    else
+      terminal_parse_failure('"foo"')
+      r0 = nil
+    end
+
+    node_cache[:inner_outer][start_index] = r0
+
+    r0
+  end
+
+end
+
+class InnerOuterParser < Treetop::Runtime::CompiledParser
+  include InnerOuter
+end
+

data/examples/inner_outer.tt

@@ -0,0 +1,14 @@
+grammar InnerOuter
+  rule inner_outer
+    ( "foo"
+      {
+	def inner
+	end
+      }
+    )
+    {
+      def outer
+      end
+    } 
+  end
+end

data/examples/numerals.rb

@@ -0,0 +1,210 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Numerals
+  include Treetop::Runtime
+
+  def root
+    @root ||= :percentage
+  end
+
+  module Percentage0
+    def decimal
+      elements[0]
+    end
+
+  end
+
+  module Percentage1
+    def to_f
+      decimal.to_f / 100
+    end
+  end
+
+  def _nt_percentage
+    start_index = index
+    if node_cache[:percentage].has_key?(index)
+      cached = node_cache[:percentage][index]
+      if cached
+        node_cache[:percentage][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_decimal
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("%", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"%"')
+        r2 = nil
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Percentage0)
+      r0.extend(Percentage1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:percentage][start_index] = r0
+
+    r0
+  end
+
+  module Decimal0
+    def sign
+      elements[0]
+    end
+
+  end
+
+  module Decimal1
+    def to_f
+      text_value.to_f
+    end
+  end
+
+  def _nt_decimal
+    start_index = index
+    if node_cache[:decimal].has_key?(index)
+      cached = node_cache[:decimal][index]
+      if cached
+        node_cache[:decimal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_sign
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[0-9]')
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?('.', false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('\'.\'')
+          r4 = nil
+        end
+        s0 << r4
+        if r4
+          s5, i5 = [], index
+          loop do
+            if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+              r6 = true
+              @index += 1
+            else
+              terminal_parse_failure('[0-9]')
+              r6 = nil
+            end
+            if r6
+              s5 << r6
+            else
+              break
+            end
+          end
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          s0 << r5
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Decimal0)
+      r0.extend(Decimal1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:decimal][start_index] = r0
+
+    r0
+  end
+
+  def _nt_sign
+    start_index = index
+    if node_cache[:sign].has_key?(index)
+      cached = node_cache[:sign][index]
+      if cached
+        node_cache[:sign][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i1 = index
+    if (match_len = has_terminal?('+', false, index))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('\'+\'')
+      r2 = nil
+    end
+    if r2
+      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+      r1 = r2
+    else
+      if (match_len = has_terminal?('-', false, index))
+        r3 = true
+        @index += match_len
+      else
+        terminal_parse_failure('\'-\'')
+        r3 = nil
+      end
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r1 = r3
+      else
+        @index = i1
+        r1 = nil
+      end
+    end
+    if r1
+      r0 = r1
+    else
+      r0 = instantiate_node(SyntaxNode,input, index...index)
+    end
+
+    node_cache[:sign][start_index] = r0
+
+    r0
+  end
+
+end
+
+class NumeralsParser < Treetop::Runtime::CompiledParser
+  include Numerals
+end
+

data/examples/numerals.tt

@@ -0,0 +1,21 @@
+grammar Numerals
+  rule percentage
+    (decimal "%") {
+      def to_f
+        decimal.to_f / 100
+      end
+    }
+  end
+
+  rule decimal
+    sign [0-9]+ '.' [0-9]* {
+      def to_f
+        text_value.to_f
+      end
+    }
+  end
+
+  rule sign
+    ('+'/'-')? 
+  end
+end