pegarus 0.1.0

data/lib/pegarus/machine/instructions.rb

@@ -0,0 +1,65 @@
+module Pegarus
+  module Machine
+    module Instructions
+      def self.[](opcode)
+        instructions[opcode]
+      end
+
+      def self.instructions
+        @instructions ||= {}
+      end
+
+      def self.instruction(name, &block)
+        instructions[name] = [block.arity, block]
+      end
+
+      instruction :char do |state, char|
+        if state.subject[state.index] == char
+          state.index += 1
+        else
+          state.failure
+        end
+      end
+
+      instruction :jump do |state, label|
+        state.ip = label
+      end
+
+      instruction :choice do |state, label|
+        state.stack << label << state.index << state.captures.dup
+      end
+
+      instruction :call do |state, label|
+        state.stack << state.ip + 2
+        state.ip = label
+      end
+
+      instruction :return do |state|
+        state.ip = state.stack.pop
+      end
+
+      instruction :commit do |state, label|
+        state.stack[-3..-1] = nil
+        state.ip = label
+      end
+
+      instruction :capture do |state, data|
+        state.captures << [state.index, data]
+      end
+
+      instruction :fail do |state|
+        until state.stack.empty?
+          item = state.stack.pop
+          next unless item.kind_of? Array
+
+          state.captures.replace item
+          state.index = state.stack.pop
+          state.ip = state.stack.pop
+
+          state.continue
+          break
+        end
+      end
+    end
+  end
+end

data/lib/pegarus/machine/interpreter.rb

@@ -0,0 +1,31 @@
+module Pegarus
+  module Machine
+    def self.execute(program, subject)
+      state = State.new subject
+      _, fail = Instructions[:fail]
+
+      total = program.size
+      while state.ip < total
+        break if state.fail?
+
+        width, code = Instructions[program[state.ip]]
+        case width
+        when 1
+          code[state]
+        when 2
+          code[state, program[state.ip+1]]
+        when 3
+          code[state, program[state.ip+1], program[state.ip+2]]
+        end
+
+        if state.fail?
+          fail[state]
+        else
+          state.ip += width
+        end
+      end
+
+      return state.failure? ? nil : state.index
+    end
+  end
+end

data/lib/pegarus/machine/state.rb

@@ -0,0 +1,29 @@
+module Pegarus
+  module Machine
+    class State
+      attr_accessor :ip, :index
+      attr_reader :subject, :stack, :captures
+
+      def initialize(subject)
+        @subject  = subject
+        @ip       = 0
+        @index    = 0
+        @stack    = []
+        @captures = []
+        @failure  = false
+      end
+
+      def failure?
+        @failure
+      end
+
+      def failure
+        @failure = true
+      end
+
+      def continue
+        @failure = false
+      end
+    end
+  end
+end

data/lib/pegarus/machine.rb

@@ -0,0 +1,15 @@
+require 'pegarus/machine/instructions'
+require 'pegarus/machine/compiler'
+require 'pegarus/machine/state'
+require 'pegarus/machine/interpreter'
+
+module Pegarus
+  module Machine
+    def self.new_executor(pattern, subject)
+      Compiler.new.compile pattern
+      pattern.match subject
+    end
+  end
+end
+
+Pegarus::Pattern.select_engine Pegarus::Machine

data/lib/pegarus/parser/parse_error.rb

@@ -0,0 +1,3 @@
+module Pegarus
+  class ParseError < Exception; end
+end

data/lib/pegarus/parser.rb

@@ -0,0 +1 @@
+require 'pegarus/parser/parse_error'

data/lib/pegarus/rubinius/compiler.rb

@@ -0,0 +1,220 @@
+module Pegarus
+  module Rubinius
+    def self.new_executor(pattern, subject)
+      Compiler.new.compile pattern
+      pattern.match subject
+    end
+
+    class Compiler
+      attr_reader :g
+
+      def initialize
+        @g = Generator.new
+      end
+
+      def compile(pattern)
+        g.name = :match
+        g.file = :"(pegarus)"
+        g.set_line 1
+
+        g.required_args = 1
+        g.total_args = 1
+        g.splat_index = nil
+
+        g.local_count = 2
+        g.local_names = [:subject, :index]
+
+        g.push 0
+        g.set_index
+
+        pattern.visit self
+        g.finish
+
+        g.encode
+        cm = g.package ::Rubinius::CompiledMethod
+        puts cm.decode if $DEBUG
+
+        ss = ::Rubinius::StaticScope.new Object
+        ::Rubinius.attach_method :match, cm, ss, pattern
+      end
+
+      def failure
+        g.push :nil
+        g.goto g.fail
+      end
+
+      def always(pattern)
+        failure
+      end
+
+      def any(pattern)
+        failure
+      end
+
+      def any_range(pattern)
+        failure
+      end
+
+      def character(pattern)
+        failure
+      end
+
+      def character_range(pattern)
+        failure
+      end
+
+      def choice(pattern)
+        failure
+      end
+
+      def concatenation(pattern)
+        failure
+      end
+
+      def difference(pattern)
+        failure
+      end
+
+      def if(pattern)
+        failure
+      end
+
+      def never(pattern)
+        failure
+      end
+
+      def set(pattern)
+        failure
+      end
+
+      def unless(pattern)
+        failure
+      end
+    end
+
+    def any(g, count)
+      g.push_index
+      g.push count
+      g.send :+, 1, false
+
+      g.push_subject
+      g.send :size, 0, false
+      g.send :<=, 1, false
+      g.gif g.fail
+
+      g.push count
+      g.inc_index
+    end
+
+    def char(g, string)
+      fail = g.new_label
+      done = g.new_label
+
+      g.push_literal string
+      g.dup
+      g.send :size, 0, false
+      g.dup
+      g.move_down 2
+
+      g.push_subject
+      g.swap
+      g.push_index
+      g.swap
+      g.send :substring, 2, false
+      g.send :==, 1, false
+      g.gif fail
+
+      g.inc_index
+      g.goto done
+
+      fail.set!
+      g.pop
+      g.goto g.fail
+
+      done.set!
+    end
+  end
+
+  class Any
+    def bytecode(g)
+      any g, @count
+    end
+  end
+
+  class Character
+    def bytecode(g)
+      char g, @string
+    end
+  end
+
+  class Choice
+    def bytecode(g)
+      g.push_index # store index, so that we can restart
+      old_fail = g.fail
+      done = g.new_label
+
+      choice_fail = g.new_label
+      g.fail = choice_fail
+      @first.bytecode(g)
+      g.pop # success, pop index
+      g.fail = old_fail # reset fail
+      g.goto done
+
+      choice_fail.set!
+      g.fail = old_fail
+      g.set_index # reset index to the stored index, this pops the value
+      @second.bytecode(g)
+
+      done.set!
+    end
+  end
+
+  class Concatenation
+    def bytecode(g)
+      @first.bytecode(g)
+      @second.bytecode(g)
+    end
+  end
+
+  class If
+    def bytecode(g)
+      g.push_index # store index, so that we can restart
+      old_fail = g.fail
+      done = g.new_label
+
+      pattern_fail = g.new_label
+      g.fail = pattern_fail
+      @pattern.bytecode(g)
+      # success
+      g.set_index #  reset index to the stored index, this pops the value
+      g.fail = old_fail # reset fail
+      g.goto done
+      # failure
+      pattern_fail.set!
+      g.set_index # reset index to the stored index, this pops the value
+      g.fail = old_fail
+      g.goto g.fail
+
+      done.set!
+    end
+  end
+
+  class Unless
+    def bytecode(g)
+      g.push_index # store index, so that we can restart
+      old_fail = g.fail
+
+      pattern_fail = g.new_label
+      g.fail = pattern_fail
+      @pattern.bytecode(g)
+      # success => failure
+      g.set_index #  reset index to the stored index, this pops the value
+      g.fail = old_fail # reset fail
+      g.goto g.fail
+      # failure => success
+      pattern_fail.set!
+      g.set_index # reset index to the stored index, this pops the value
+      g.fail = old_fail
+    end
+  end
+end

data/lib/pegarus/rubinius/generator.rb

@@ -0,0 +1,48 @@
+module Pegarus
+  module Rubinius
+    class Generator < ::Rubinius::Generator
+      attr_reader :done
+      attr_accessor :fail
+
+      def initialize
+        super
+        @fail = new_label
+        @done = new_label
+      end
+
+      def push_subject
+        push_local 0
+      end
+
+      def push_index
+        push_local 1
+      end
+
+      def set_index
+        set_local 1
+        pop
+      end
+
+      def inc_index
+        push_local 1
+        send :+, 1, false
+        set_local 1
+        pop
+      end
+
+      def finish
+        # end
+        push_index
+        goto done
+
+        # fail
+        fail.set!
+        push :nil
+
+        done.set!
+        ret
+        close
+      end
+    end
+  end
+end

data/lib/pegarus/rubinius.rb

@@ -0,0 +1,4 @@
+require 'pegarus/rubinius/generator'
+require 'pegarus/rubinius/compiler'
+
+Pegarus::Pattern.select_engine Pegarus::Rubinius

data/lib/pegarus/version.rb

@@ -0,0 +1,3 @@
+module Pegarus
+  VERSION = "0.1.0"
+end

data/lib/pegarus.rb

@@ -0,0 +1,3 @@
+require 'pegarus/ast'
+require 'pegarus/parser'
+require 'pegarus/compatibility'

data/spec/ast/choice_spec.rb

@@ -0,0 +1,9 @@
+require 'spec/spec_helper'
+
+describe "Choice.new" do
+  it "converts both inputs to patterns" do
+    pattern = Pegarus::Choice.new 1, "a"
+    pattern.first.should be_an_instance_of(Pegarus::Any)
+    pattern.second.should be_an_instance_of(Pegarus::Character)
+  end
+end

data/spec/ast/concatenation_spec.rb

@@ -0,0 +1,9 @@
+require 'spec/spec_helper'
+
+describe "Concatenation.new" do
+  it "converts both inputs to patterns" do
+    pattern = Pegarus::Concatenation.new 1, "a"
+    pattern.first.should be_an_instance_of(Pegarus::Any)
+    pattern.second.should be_an_instance_of(Pegarus::Character)
+  end
+end

data/spec/ast/difference_spec.rb

@@ -0,0 +1,9 @@
+require 'spec/spec_helper'
+
+describe "Difference.new" do
+  it "converts the input to a pattern" do
+    pattern = Pegarus::Difference.new 1, "a"
+    pattern.first.should be_an_instance_of(Pegarus::Any)
+    pattern.second.should be_an_instance_of(Pegarus::Character)
+  end
+end

data/spec/ast/grammar_spec.rb

@@ -0,0 +1,54 @@
+require 'spec/spec_helper'
+
+describe "Pegarus.grammar" do
+  it "returns a Grammar with empty start rule when passed no arguments" do
+    grammar = Pegarus.grammar
+
+    grammar.should be_an_instance_of(Pegarus::Grammar)
+    grammar.start.should be_nil
+  end
+
+  it "returns a Grammar with start rule :S corresponding to the Pattern passed" do
+    pattern = Pegarus.pattern 1
+    grammar = Pegarus.grammar pattern
+
+    grammar.should be_an_instance_of(Pegarus::Grammar)
+    grammar.start.should == :S
+    grammar.S.pattern.should equal(pattern)
+  end
+
+  it "returns a Grammar with start symbol corresponding to the Symbol passed" do
+    grammar = Pegarus.grammar :token
+
+    grammar.should be_an_instance_of(Pegarus::Grammar)
+    grammar.start.should == :token
+    grammar.token.pattern.should be_nil
+  end
+
+  it "returns a Grammar with start rule corresponding to the Symbol and Pattern passed" do
+    pattern = Pegarus.pattern 1
+    grammar = Pegarus.grammar :token, pattern
+
+    grammar.should be_an_instance_of(Pegarus::Grammar)
+    grammar.start.should == :token
+    grammar.token.pattern.should equal(pattern)
+  end
+
+  it "returns a Grammar with start rule corresponding to the Variable passed" do
+    variable = Pegarus.variable :token, "abc"
+    grammar = Pegarus.grammar variable
+
+    grammar.should be_an_instance_of(Pegarus::Grammar)
+    grammar.start.should == :token
+    grammar.token.pattern.should equal(variable.pattern)
+  end
+end
+
+describe "Pegarus::Grammar" do
+  it "returns a Variable instance with the name of the method invoked" do
+    grammar = Pegarus.grammar
+    variable = grammar.pattern
+    variable.name.should == :pattern
+    variable.pattern.should be_nil
+  end
+end

data/spec/ast/if_spec.rb

@@ -0,0 +1,8 @@
+require 'spec/spec_helper'
+
+describe "If.new" do
+  it "converts the input to a pattern" do
+    pattern = Pegarus::If.new "a"
+    pattern.pattern.should be_an_instance_of(Pegarus::Character)
+  end
+end

data/spec/ast/pattern_spec.rb

@@ -0,0 +1,123 @@
+require 'spec/spec_helper'
+
+describe "Pegarus.pattern" do
+  it "returns an Any pattern when passed an Integer" do
+    Pegarus.pattern(5).should be_an_instance_of(Pegarus::Any)
+  end
+
+  it "returns a Set pattern when passed an Array" do
+    Pegarus.pattern(["abc"]).should be_an_instance_of(Pegarus::Set)
+  end
+
+  it "retuns an Always pattern when passed true" do
+    Pegarus.pattern(true).should be_an_instance_of(Pegarus::Always)
+  end
+
+  it "returns a Never pattern when passed false" do
+    Pegarus.pattern(false).should be_an_instance_of(Pegarus::Never)
+  end
+
+  it "returns an Exact pattern when passed a String" do
+    Pegarus.pattern("abc").should be_an_instance_of(Pegarus::Character)
+  end
+
+  it "returns a AnyRange pattern when passed a Range of Integers" do
+    Pegarus.pattern(1..2).should be_an_instance_of(Pegarus::AnyRange)
+    Pegarus.pattern(1...2).should be_an_instance_of(Pegarus::AnyRange)
+  end
+
+  it "returns a CharRange pattern when passed a Range of Strings" do
+    Pegarus.pattern("a".."z").should be_an_instance_of(Pegarus::CharacterRange)
+    Pegarus.pattern("a"..."z").should be_an_instance_of(Pegarus::CharacterRange)
+  end
+
+  it "returns the instance unmodified when passed a Pattern" do
+    pattern = Pegarus::Pattern.new
+    Pegarus.pattern(pattern).should equal(pattern)
+  end
+
+  it "returns a Variable when passed a Symbol" do
+    Pegarus.pattern(:S).should be_an_instance_of(Pegarus::Variable)
+  end
+
+  it "returns nil when passed nil" do
+    Pegarus.pattern(nil).should be_nil
+  end
+
+  it "raises a Pegarus::ParseError when passed a Object" do
+    lambda { Pegarus.pattern(Object.new) }.should raise_error(Pegarus::ParseError)
+  end
+
+  it "raises a Pegarus::ParseError when passed a Hash" do
+    lambda { Pegarus.pattern({}) }.should raise_error(Pegarus::ParseError)
+  end
+
+  it "raises a Pegarus::ParseError when passed a Float" do
+    lambda { Pegarus.pattern(4.2) }.should raise_error(Pegarus::ParseError)
+  end
+end
+
+describe "Pattern#+@" do
+  it "returns an If pattern" do
+    p1 = Pegarus.pattern(1)
+    pattern = +p1
+
+    pattern.should be_an_instance_of(Pegarus::If)
+  end
+end
+
+describe "Pattern#-@" do
+  it "returns an Unless pattern" do
+    p1 = Pegarus.pattern(1)
+    pattern = -p1
+
+    pattern.should be_an_instance_of(Pegarus::Unless)
+  end
+end
+
+describe "Pattern#/" do
+  it "returns a Choice of two patterns" do
+    p1 = Pegarus.pattern(1)
+    p2 = Pegarus.pattern("a")
+    pattern = p1 / p2
+
+    pattern.should be_an_instance_of(Pegarus::Choice)
+    pattern.first.should equal(p1)
+    pattern.second.should equal(p2)
+  end
+end
+
+describe "Pattern#+" do
+  it "returns a Concatenation of two patterns" do
+    p1 = Pegarus.pattern(1)
+    p2 = Pegarus.pattern("a")
+    pattern = p1 + p2
+
+    pattern.should be_an_instance_of(Pegarus::Concatenation)
+    pattern.first.should equal(p1)
+    pattern.second.should equal(p2)
+  end
+end
+
+describe "Pegarus#-" do
+  it "returns a Difference of two patterns" do
+    p1 = Pegarus.pattern(1)
+    p2 = Pegarus.pattern("a")
+    pattern = p1 - p2
+
+    pattern.should be_an_instance_of(Pegarus::Difference)
+    pattern.first.should equal(p1)
+    pattern.second.should equal(p2)
+  end
+end
+
+describe "Pegarus#*" do
+  it "returns a Product of two patterns" do
+    p1 = Pegarus.pattern("a")
+    pattern = p1 * 2
+
+    pattern.should be_an_instance_of(Pegarus::Product)
+    pattern.first.should equal(p1)
+    pattern.second.should == 2
+  end
+end

data/spec/ast/product_spec.rb

@@ -0,0 +1,28 @@
+require 'spec/spec_helper'
+
+describe "Product.new" do
+  it "converts the first input to a pattern" do
+    pattern = Pegarus::Product.new "a", 1
+    pattern.first.should be_an_instance_of(Pegarus::Character)
+  end
+
+  it "calls #to_int to convert the second input" do
+    obj = mock("multiplier")
+    obj.should_receive(:to_int).and_return(2)
+
+    pattern = Pegarus::Product.new "a", obj
+    pattern.second.should == 2
+  end
+
+  it "raises a TypeError if the second input is nil" do
+    lambda { Pegarus::Product.new "a", nil }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError if the second input is a String" do
+    lambda { Pegarus::Product.new "a", "b" }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError if the second input is an Object" do
+    lambda { Pegarus::Product.new "a", Object.new }.should raise_error(TypeError)
+  end
+end

data/spec/ast/unless_spec.rb

@@ -0,0 +1,8 @@
+require 'spec/spec_helper'
+
+describe "Unless.new" do
+  it "converts the input to a pattern" do
+    pattern = Pegarus::Unless.new "a"
+    pattern.pattern.should be_an_instance_of(Pegarus::Character)
+  end
+end

data/spec/ast/variable_spec.rb

@@ -0,0 +1,4 @@
+require 'spec/spec_helper'
+
+describe "Pegarus.variable" do
+end