treetop 1.4.1 → 1.4.2

data/bin/tt

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require 'optparse'
 require 'rubygems'
-gem 'treetop'
+require 'treetop'
 
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
 require 'treetop'

data/doc/using_in_ruby.markdown

@@ -19,129 +19,3 @@ If a grammar by the name of `Foo` is defined, the compiled Ruby source will defi
     else
       puts 'failure'
     end
-
-##Defining Grammars Directly in Ruby
-It is possible to define parser directly in Ruby source file.
-
-###Grammars
-Defining parsers in Ruby code is as much similar to original definition as it is possible. To create a grammar just write:
-
-    include Treetop::Syntax
-    grammar :Foo do
-    end
-    parser = FooParser.new
-
-Treetop will automatically compile and load it into memory, thus an instance of `FooParser` can be created.
-
-###Syntactic Recognition
-To create a rule inside of a grammar simply write:
-
-    include Treetop::Syntax
-    grammar :Foo do
-      rule :bar do
-        ...
-      end
-    end
-
-Inside the rule any of Treetop syntactic elements can be used. Each element of a rule is created with standard Ruby classes: Strings act as Terminals, Symbols stand for Nonterminals, Arrays are sequences, Regexps are character classes.
-
-_Note: it is better not to use Numbers, as terminal symbols; use Strings instead._
-
-Sequences can be defined as follows:
-
-    rule :sequence do
-      [ "foo", "bar", "baz" ]
-    end
-
-Ordered choices use `/` operator:
-
-    rule :choice do
-      "foo" / "bar"
-    end
-
-Sequences have higher precedence than choices, so choices must be parenthesized to be used as the elements of a sequence. For example:
-
-    rule :nested do
-      ["foo", "bar", "baz" / "bop" ]    # -> "foo" "bar" ( "baz" / "bop" )
-    end
-
-Special operators like `!`, `&`, `?`, `+` and `*` are available through methods (all of the methods return element itself so calls can be chained) of elements in a rule:
-
-    Op. | Method
-    -----------
-     !  | bang
-     &  | amper
-     ?  | mark
-     +  | plus
-     *  | kleene
-
-For example grammar:
-
-    grammar :Foo do
-      rule :bar do
-       [ "baz" / "bop" ].kleene
-      end
-    end
-
-can generate any word that contain words "bar" and "bop".
-
-###Semantic Interpretation
-
-Syntax node declaration can be added by `node` method (which may be called the same as operators above):
-
-    grammar :Parens do
-      rule :parenthesized_letter do
-        ([ '(', :parenthesized_letter, ')'] / /[a-z]/ ).node(:ParenNode)
-      end
-    end
-    
-It is also possible to add inline blocks of code. They are in fact strings strictly inserted into generated grammar:
-
-    grammar :Parens do
-      rule :parenthesized_letter do
-        (['(', :parenthesized_letter, ')'] / /[a-z]/ ).block(%{
-          def depth
-            if nonterminal?
-              parenthesized_letter.depth + 1
-            else
-              0
-            end
-          end
-        })
-      end
-    end
-
-Labels in rule definitions can be written as follow (example taken from documentation):
-
-  rule :labels do
-    [/[a-z]/.label(:first_letter), [', ', /[a-z]/.kleene.label(:letter)].label(:rest_letters)].block(%{
-      ...
-    })
-  end
-
-###Composition
-
-Inclusion of a grammar works thanks to `include` function call inside the grammar definition:
-
-    grammar :One do
-      rule :a do
-        foo"
-      end
-    
-      rule :b do        
-        "baz"
-      end      
-    end
-
-    grammar :Two do
-      include :One
-      rule :a do      
-        :super / "bar" / :c
-      end
-      
-      rule :c do
-       :b      
-      end
-    end
-
-Grammar Two can generate `"foo"`, `"bar"` and `"baz"` words.

data/lib/treetop/compiler/node_classes/anything_symbol.rb

@@ -4,10 +4,9 @@ module Treetop
       def compile(address, builder, parent_expression = nil)
         super
         builder.if__ "index < input_length" do
-          builder << 'next_character = index + input[index..-1].match(/\A(.)/um).end(1)'
-          assign_result "instantiate_node(#{node_class_name},input, index...next_character)"
+          assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
           extend_result_with_inline_module
-          builder << "@index = next_character"
+          builder << "@index += 1"
         end
         builder.else_ do
           builder << 'terminal_parse_failure("any character")'

data/lib/treetop/compiler/node_classes/character_class.rb

@@ -5,14 +5,13 @@ module Treetop
         super
         
         builder.if__ "has_terminal?(#{grounded_regexp(text_value)}, true, index)" do
-          builder << 'next_character = index + input[index..-1].match(/\A(.)/um).end(1)'
           if address == 0 || decorated?
-            assign_result "instantiate_node(#{node_class_name}, input, index...next_character)"
+            assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
             extend_result_with_inline_module
           else
             assign_lazily_instantiated_node
           end
-          builder << "@index = next_character"
+          builder << "@index += 1"
         end
         builder.else_ do
           # "terminal_parse_failure(#{single_quote(characters)})"

data/lib/treetop/compiler/node_classes/sequence.rb

@@ -53,10 +53,10 @@ module Treetop
       def compile(index, builder, rule)
         super
         builder.module_declaration(module_name) do
-          elements_by_name = sequence_elements.inject({}){|h,e| (h[e.label_name] ||= []) << e; h}
+          elements_by_name = sequence_elements.inject({}){|h,e| (h[e.label_name.to_s] ||= []) << e; h}
           sequence_elements.each_with_index do |element, index|
             if element.label_name
-              repetitions = elements_by_name[element.label_name]
+              repetitions = elements_by_name[element.label_name.to_s]
               label_name = element.label_name + (repetitions.size > 1 ? (repetitions.index(element)+1).to_s : "")
               builder.method_declaration(label_name) do
                 builder << "elements[#{index}]"

data/lib/treetop/ruby_extensions/string.rb

@@ -8,7 +8,7 @@ class String
       index + 1
     end
   end
-
+  
   def line_of(index)
     self[0...index].count("\n") + 1
   end
@@ -36,33 +36,7 @@ class String
     end
   end
 
-	def indent_paragraph(n)
-		out = ""
-		self.each_line {|line| out += line.indent(n) }
-		out
-	end
-
-	# Removes indentation uniformly.
-	def justify
-		min = self.length
-		self.each_line {|line|
-			next if line.strip == ""
-			if line =~ /^(  *)\S/
-				min = $1.length if min > $1.length
-			else
-				min = 0
-			end
-		}
-		out = ""
-		self.each_line {|line| out += line.slice(min...line.length) || "\n" }
-		out.strip
-	end
-
   def treetop_camelize
     to_s.gsub(/\/(.?)/){ "::" + $1.upcase }.gsub(/(^|_)(.)/){ $2.upcase }
   end
-
-	def to_tt
-		"'#{self}'"
-	end
-end
+end

data/lib/treetop/ruby_extensions.rb

@@ -1,4 +1,2 @@
 dir = File.dirname(__FILE__)
-Dir.glob("#{dir}/ruby_extensions/*.rb").each do |file|
-	require file
-end
+require "#{dir}/ruby_extensions/string"

data/lib/treetop/runtime/compiled_parser.rb

@@ -88,7 +88,7 @@ module Treetop
     
       def has_terminal?(terminal, regex, index)
         if regex
-          rx = @regexps[terminal] ||= Regexp.new(terminal, nil, 'u')
+          rx = @regexps[terminal] ||= Regexp.new(terminal)
           input.index(rx, index) == index
         else
           input[index, terminal.size] == terminal

data/lib/treetop/version.rb

@@ -2,7 +2,7 @@ module Treetop #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 4
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/treetop.rb

@@ -11,7 +11,6 @@ TREETOP_ROOT = File.join(dir, 'treetop')
 require File.join(TREETOP_ROOT, "ruby_extensions")
 require File.join(TREETOP_ROOT, "runtime")
 require File.join(TREETOP_ROOT, "compiler")
-require File.join(TREETOP_ROOT, "syntax")
 
 require 'polyglot'
 Polyglot.register(Treetop::VALID_GRAMMAR_EXT, Treetop)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: treetop
 version: !ruby/object:Gem::Version 
-  version: 1.4.1
+  version: 1.4.2
 platform: ruby
 authors: 
 - Nathan Sobo
@@ -9,7 +9,7 @@ autorequire: treetop
 bindir: bin
 cert_chain: []
 
-date: 2009-09-04 00:00:00 +10:00
+date: 2009-09-11 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,12 +61,7 @@ files:
 - lib/treetop/compiler/node_classes.rb
 - lib/treetop/compiler/ruby_builder.rb
 - lib/treetop/compiler.rb
-- lib/treetop/ruby_extensions/array.rb
-- lib/treetop/ruby_extensions/nil.rb
-- lib/treetop/ruby_extensions/object.rb
-- lib/treetop/ruby_extensions/regexp.rb
 - lib/treetop/ruby_extensions/string.rb
-- lib/treetop/ruby_extensions/symbol.rb
 - lib/treetop/ruby_extensions.rb
 - lib/treetop/runtime/compiled_parser.rb
 - lib/treetop/runtime/interval_skip_list/head_node.rb
@@ -78,7 +73,6 @@ files:
 - lib/treetop/runtime/terminal_parse_failure_debug.rb
 - lib/treetop/runtime/terminal_syntax_node.rb
 - lib/treetop/runtime.rb
-- lib/treetop/syntax.rb
 - lib/treetop/version.rb
 - lib/treetop.rb
 - bin/tt
@@ -101,8 +95,6 @@ files:
 - examples/lambda_calculus/lambda_calculus_node_classes.rb
 - examples/lambda_calculus/lambda_calculus_test.rb
 - examples/lambda_calculus/test_helper.rb
-- examples/ruby_syntax/syntax_test.rb
-- examples/ruby_syntax/test_helper.rb
 has_rdoc: true
 homepage: http://functionalform.blogspot.com
 licenses: []

data/examples/ruby_syntax/syntax_test.rb

@@ -1,105 +0,0 @@
-dir = File.dirname(__FILE__)
-require File.expand_path("#{dir}/test_helper")
-
-class SyntaxTest < Test::Unit::TestCase
-	include Treetop::Syntax
-	include SyntaxTestHelper
-
-	def test_simple
-		assert_grammar {
-			grammar :OnlyGrammar do
-			end
-		}
-	end
-
-	def test_rules
-		assert_grammar {
-			grammar :Simple do
-				rule :foo do
-					["foo", :bar]
-				end
-
-				rule :bar do
-					"bar" / "baz"
-				end
-			end
-		}
-		parse('foobar')
-		parse('foobaz')
-	end
-
-	def test_nested
-		assert_grammar {
-			grammar :Nested do
-				rule :nested do
-					["foo", "bar", "baz" / "bop"]
-				end
-			end
-		}
-		parse('foobarbaz')
-		parse('foobarbop')
-	end
-
-	def test_operators
-		assert_grammar {
-			grammar :Kleene do
-				rule :Kleene do
-					"foo".kleene
-				end
-			end
-		}
-		parse("")
-		parse("foo")
-		parse("foofoo")
-
-		assert_grammar {
-			grammar :Plus do
-				rule :Plus do
-					"foo".plus
-				end
-			end
-		}
-		parse("foo")
-		parse("foofoo")
-
-		assert_grammar {
-			grammar :Optional do
-				rule :Optional do
-					"foo".mark
-				end
-			end
-		}
-		parse("")
-		parse("foo")
-	end
-
-	def test_inclusion
-		assert_grammar {
-			grammar :One do
-				rule :a do
-					"foo"
-				end
-
-				rule :b do
-					"baz"
-				end
-			end
-		}
-
-		assert_grammar {
-			grammar :Two do
-				include :One
-				rule :a do
-					:super / "bar" / :c
-				end
-
-				rule :c do
-					:b
-				end
-			end
-		}
-		parse("foo")
-		parse("bar")
-		parse("baz")
-	end
-end

data/examples/ruby_syntax/test_helper.rb

@@ -1,28 +0,0 @@
-require 'test/unit'
-require 'rubygems'
-require 'treetop'
-
-dir = File.dirname(__FILE__)
-require File.expand_path("#{dir}/../../lib/treetop/ruby_extensions")
-require File.expand_path("#{dir}/../../lib/treetop/syntax")
-
-module SyntaxTestHelper
-	def assert_grammar
-		g = yield
-		assert_not_nil g
-		flunk "Badly generated parser" unless g
-		@parser = eval("#{g}.new")
-	end
-
-	def parse(input)
-		result = @parser.parse(input)
-    unless result
-      puts @parser.terminal_failures.join("\n")
-    end
-    assert_not_nil result
-		if result
-			assert_equal input, result.text_value
-		end
-    result
-	end
-end

data/lib/treetop/ruby_extensions/array.rb

@@ -1,22 +0,0 @@
-class Array
-	def join_with(method, pattern = "")
-		return join(pattern) unless method
-		return "" if self.length == 0
-
-		args = []
-		if method.respond_to? :to_hash
-			args = method[:args] || []
-			method = method[:name]
-		end
-
-		output = self[0].send(method, *args)
-		for i in (1...self.length)
-			output += pattern + self[i].send(method, *args)
-		end
-		output
-	end
-
-	def to_tt
-		self.join_with({:name => :seq_to_tt, :args => [true]}, " ")
-	end
-end

data/lib/treetop/ruby_extensions/nil.rb

@@ -1,5 +0,0 @@
-class NilClass
-	def to_tt
-		""
-	end
-end

data/lib/treetop/ruby_extensions/object.rb

@@ -1,57 +0,0 @@
-class Object
-	def sequence
-		@sequence ||= []
-	end
-
-	def /(other)
-		sequence.push(other)
-		self
-	end
-
-	def seq_to_tt(inline = false)
-		separator = inline ? " / " : "\n/\n"
-		tt = if sequence.length == 0
-			self.to_tt
-		else
-			output = self.to_tt + separator + sequence.join_with({:name => :seq_to_tt, :args => [true]}, separator)
-			output = "( #{output} )" if inline
-			output
-		end
-
-		# Operators
-		tt = "&" + tt if @amper
-		tt = "!" + tt if @bang
-		tt += "*" if @kleene
-		tt += "+" if @plus
-		tt += "?" if @mark
-
-		tt += " <#{@node.to_s}>" if @node
-		tt += " {\n#{@block.gsub("\t", "  ").justify.indent_paragraph(2)}\n}" if @block
-		tt = @label.to_s + ':' + tt if @label
-		tt
-	end
-
-	def node(name)
-		@node = name
-		self
-	end
-
-	def block(content)
-		@block = content
-		self
-	end
-
-	def label(name)
-		@label = name
-		self
-	end
-
-	[:mark, :kleene, :plus, :amper, :bang].each do |sym|
-		Object.class_eval(%{
-			def #{sym.to_s}
-				@#{sym.to_s} = true
-				self
-			end
-		})
-	end
-end

data/lib/treetop/ruby_extensions/regexp.rb

@@ -1,5 +0,0 @@
-class Regexp
-	def to_tt
-		self.inspect
-	end
-end

data/lib/treetop/ruby_extensions/symbol.rb

@@ -1,5 +0,0 @@
-class Symbol
-	def to_tt
-		self.to_s
-	end
-end

data/lib/treetop/syntax.rb

@@ -1,39 +0,0 @@
-=begin rdoc
-	Definition of TreeTop syntax in pure Ruby.
-=end
-
-module Treetop
-	# Provides the possibility to write Treetop syntax as a Ruby code.
-	# Symbols act as nonterminals, strings as terminals, arrays as
-	# sequences. Ordered choices are defined similar to original Treetop
-	# syntax.
-	#
-	# (Note: it is better not to use numbers; use Strings instead)
-	#
-	module Syntax
-		class Grammar
-			attr_reader :source
-			def initialize
-				@source = ""
-			end
-
-			def rule(name)
-				@source += "rule #{name.to_s}\n#{yield.seq_to_tt.indent_paragraph(2)}\nend\n"
-			end
-
-			def include(name)
-				@source += "include #{name.to_s}\n"
-			end
-		end
-
-		def grammar(name, &block)
-			Syntax.grammar(name, &block)
-		end
-
-		def self.grammar(name, &block)
-			(g = Grammar.new).instance_eval(&block)
-			source = "grammar #{name.to_s}\n#{g.source.indent_paragraph(2)}end\n"
-			Treetop.load_from_string(source)
-		end
-	end
-end