ghostwheel 0.0.1

data/Rakefile

@@ -0,0 +1,46 @@
+require "rake/testtask"
+require "rake/gempackagetask"
+
+DIR     = File.dirname(__FILE__)
+LIB     = File.join(DIR, "lib", "ghost_wheel.rb")
+VERSION = File.read(LIB)[/^\s*VERSION\s*=\s*(['"])(\d\.\d\.\d)\1/, 2]
+
+task :default => [:test]
+
+Rake::TestTask.new do |test|
+	test.libs       << "test"
+	test.test_files =  %w[test/ts_all.rb]
+	test.verbose    =  true
+end
+
+GEM_SPEC = Gem::Specification.new do |spec|
+  spec.name              =  "ghostwheel"
+  spec.version           =  VERSION
+  spec.platform          =  Gem::Platform::RUBY
+  spec.summary           =  "Ghost Wheel is a pure Ruby parser generator."
+  spec.files             =  Dir.glob("{lib,test}/**/*.rb").
+                                delete_if { |item| item.include?(".svn") } +
+                                ["Rakefile", "setup.rb"]
+
+  spec.test_suite_file   =  "test/ts_all.rb"
+  # spec.has_rdoc          =  true
+  # spec.extra_rdoc_files  =  %w{README INSTALL TODO CHANGELOG LICENSE}
+  # spec.rdoc_options      << '--title' << 'Ghost Wheel Documentation' <<
+  #                           '--main'  << 'README'
+
+  spec.require_path      =  'lib'
+
+  spec.author            =  "James Edward Gray II"
+  spec.email             =  "james@grayproductions.net"
+  spec.rubyforge_project =  "ghostwheel"
+  spec.homepage          =  "http://ghostwheel.rubyforge.org"
+  spec.description       =  <<END_DESC
+Ghost Wheel is a packrat parser generator handling scanning and parsing of
+context-free grammars. Parsers can be built using an EBNF-like syntax or a with
+a Ruby DSL.
+END_DESC
+end
+Rake::GemPackageTask.new(GEM_SPEC) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/lib/ghost_wheel.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby -w
+
+require "ghost_wheel/errors"
+require "ghost_wheel/parse_results"
+
+require "ghost_wheel/scanner"
+require "ghost_wheel/parser"
+
+require "ghost_wheel/expression"
+require "ghost_wheel/expression/literal"
+require "ghost_wheel/expression/sequence"
+require "ghost_wheel/expression/alternation"
+require "ghost_wheel/expression/empty"
+require "ghost_wheel/expression/optional"
+require "ghost_wheel/expression/repetition"
+require "ghost_wheel/expression/look_ahead"
+require "ghost_wheel/expression/end_of_file"
+require "ghost_wheel/expression/query"
+require "ghost_wheel/expression/transform"
+require "ghost_wheel/expression/rule"
+
+require "ghost_wheel/build_parser"
+require "ghost_wheel/parser_builder/ruby"
+require "ghost_wheel/parser_builder/ghost_wheel"
+
+module GhostWheel
+  VERSION = "0.0.1"
+end

data/lib/ghost_wheel/build_parser.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  def self.build_parser(grammar = nil, &parser_init)
+    if grammar
+      ParserBuilder::GhostWheel.new(grammar).to_parser
+    else
+      ParserBuilder::Ruby.new(&parser_init).to_parser
+    end
+  end
+end

data/lib/ghost_wheel/errors.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class StackUnderflowError < RuntimeError; end
+  class EmptyRuleError      < RuntimeError; end
+  class ParseError          < RuntimeError; end
+  class EmptyParseError     < ParseError;   end
+  class FailedParseError    < ParseError;   end
+end

data/lib/ghost_wheel/expression.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    def parse(scanner, cache = Hash.new)
+      cache_key = "#{object_id}:#{scanner.pos}"
+      cache_hit = cache[cache_key]
+      if cache_hit.nil?
+        result           = uncached_parse(scanner, cache)
+        cache[cache_key] = [result, scanner.pos]
+        result
+      else
+        scanner.pos = cache_hit.last
+        cache_hit.first
+      end
+    end
+    
+    def ==(other)
+      self.class == other.class
+    end
+  end
+end

data/lib/ghost_wheel/expression/alternation.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Alternation < Expression
+      def initialize(*expressions)
+        @expressions = expressions
+      end
+      
+      attr_reader :expressions
+    
+      def uncached_parse(scanner, cache)
+        @expressions.each do |expression|
+          result = expression.parse(scanner, cache)
+          return result unless result.is_a? FailedParseResult
+        end
+        FailedParseResult.instance
+      end
+
+      def ==(other)
+        super and @expressions == other.expressions
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/empty.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby -w
+
+require "singleton"
+
+module GhostWheel
+  class Expression
+    class Empty < Expression
+      include Singleton
+      
+      def uncached_parse(not_used, cache)
+        EmptyParseResult.instance
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/end_of_file.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby -w
+
+require "singleton"
+
+module GhostWheel
+  class Expression
+    class EndOfFile < Expression
+      include Singleton
+      
+      def uncached_parse(scanner, cache)
+        if scanner.eos?
+          EmptyParseResult.instance
+        else
+          FailedParseResult.instance
+        end
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/literal.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Literal < Expression
+      def initialize(literal, skip = false)
+        @literal = case literal
+                   when Regexp then literal
+                   when Fixnum then /#{Regexp.escape(literal.chr)}/
+                   else             /#{Regexp.escape(literal.to_s)}/
+                   end
+        @skip = skip
+      end
+      
+      attr_reader  :literal, :skip
+      alias_method :skip?,   :skip
+
+      def uncached_parse(scanner, cache)
+        if scanner.scan(@literal)
+          @skip ? EmptyParseResult.instance : ParseResult.new(scanner.matched)
+        else
+          FailedParseResult.instance
+        end
+      end
+      
+      def ==(other)
+        super and @literal.to_s == other.literal.to_s and @skip == other.skip
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/look_ahead.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class LookAhead < Expression
+      def initialize(expression, negate = false)
+        @expression = expression
+        @negate     = negate
+      end
+      
+      attr_reader  :expression, :negate
+      alias_method :negate?,    :negate
+    
+      def uncached_parse(scanner, cache)
+        matched = nil
+        scanner.transaction do
+          matched = @expression.parse(scanner, cache)
+          scanner.abort
+        end
+      
+        if matched.is_a? FailedParseResult
+          @negate ? EmptyParseResult.instance : matched
+        else
+          @negate ? FailedParseResult.instance : EmptyParseResult.instance
+        end
+      end
+      
+      def ==(other)
+        super and @expression == other.expression and @negate == other.negate
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/optional.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Optional < Expression
+      def initialize(expression)
+        @expression = expression
+      end
+      
+      attr_reader :expression
+    
+      def uncached_parse(scanner, cache)
+        result = @expression.parse(scanner, cache)
+        if result.is_a? FailedParseResult
+          EmptyParseResult.instance
+        else
+          result
+        end
+      end
+
+      def ==(other)
+        super and @expression == other.expression
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/query.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Query < Expression
+      def initialize(expression, &query)
+        @expression = expression
+        @query      = query
+      end
+      
+      attr_reader :expression, :query
+      
+      def uncached_parse(scanner, cache)
+        result = @expression.parse(scanner, cache)
+        if result.is_a? FailedParseResult
+          result
+        else
+          value = result.is_a?(ParseResult) ? result.value : result
+          if @query[value]
+            result
+          else
+            FailedParseResult.instance
+          end
+        end
+      end
+      
+      def ==(other)
+        super and @expression == other.expression and @query == other.query
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/repetition.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Repetition < Expression
+      def initialize(expression, minimum_count = 0, maximum_count = 1.0 / 0.0)
+        @expression    = expression
+        @minimum_count = minimum_count
+        @maximum_count = maximum_count
+      end
+      
+      attr_reader :expression, :minimum_count, :maximum_count
+    
+      def uncached_parse(scanner, cache)
+        scanner.transaction do
+          parsed = ParseResult.new(Array.new)
+          while parsed.value.size < @maximum_count
+            case result = @expression.parse(scanner, cache)
+            when FailedParseResult then break
+            when ParseResult       then parsed.value << result.value
+            end
+          end
+        
+          if parsed.value.size >= @minimum_count
+            if parsed.value.empty?
+              EmptyParseResult.instance
+            else
+              parsed
+            end
+          else
+            scanner.abort(FailedParseResult.instance)
+          end
+        end
+      end
+
+      def ==(other)
+        super                                 and
+        @expression    == other.expression    and
+        @minimum_count == other.minimum_count and
+        @maximum_count == other.maximum_count
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/rule.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Rule < Expression
+      def initialize(expression = nil)
+        @expression = expression
+      end
+    
+      attr_accessor :expression
+    
+      def uncached_parse(scanner, cache)
+        if @expression.nil?
+          raise EmptyRuleError, "You failed to set an expression for this rule."
+        end
+        @expression.parse(scanner, cache)
+      end
+
+      def ==(other)
+        super and @expression == other.expression
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/sequence.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Sequence < Expression
+      def initialize(*expressions)
+        @expressions = expressions
+      end
+      
+      attr_reader :expressions
+    
+      def uncached_parse(scanner, cache)
+        scanner.transaction do
+          parsed = ParseResult.new(Array.new)
+          @expressions.each do |expression|
+            case result = expression.parse(scanner, cache)
+            when FailedParseResult then scanner.abort(result)
+            when ParseResult       then parsed.value << result.value
+            end
+          end
+          parsed
+        end
+      end
+
+      def ==(other)
+        super and @expressions == other.expressions
+      end
+    end
+  end
+end

data/lib/ghost_wheel/expression/transform.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -w
+
+module GhostWheel
+  class Expression
+    class Transform < Expression
+      def initialize(expression, &transformer)
+        @expression  = expression
+        @transformer = transformer
+      end
+      
+      attr_reader :expression, :transformer
+    
+      def uncached_parse(scanner, cache)
+        result = @expression.parse(scanner, cache)
+        if result.is_a? FailedParseResult
+          result
+        else
+          value = result.is_a?(ParseResult) ? result.value : result
+          ParseResult.new(@transformer[value])
+        end
+      end
+      
+      def ==(other)
+        super                            and
+        @expression  == other.expression and
+        @transformer == other.transformer
+      end
+    end
+  end
+end