kaiseki 0.0.3 → 1.0.1

data/lib/parser_repeat.rb

@@ -0,0 +1,68 @@
+module Kaiseki
+	class RepeatParser
+		include Parseable
+		attr_reader :expected, :min, :max
+		
+		def initialize expected, min, max = nil
+			@expected = expected.to_parseable
+			@min = min
+			@max = max
+		end
+		
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				result = []
+				count = 0
+				while max.nil? or count < max
+					begin
+						catch :SkipSuccess do
+							result << @expected.parse(stream, options)
+						end
+						count += 1
+					rescue ParseError
+						if options[:skipping]
+							begin
+								catch :SkipSuccess do
+									options[:skipping].parse stream, options.merge(:skipping => nil)
+								end
+								redo
+							rescue ParseError
+								break
+							end
+						else
+							break
+						end
+					end
+				end
+				if result.length < @min
+					raise ParseError.new "expected #{@min} match#{'es' unless @min == 1} but obtained #{result.length} when parsing #{self}", options
+				else
+					if options[:simplify]
+						if @min == 0 and @max == 1
+							result.length == 0 ? nil : result[0]
+						else
+							result
+						end
+					else
+						result
+					end
+				end
+			end
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.expected == @expected and other.min == @min and other.max == @max
+		end
+		
+		alias :== :eql?
+		
+		def to_s
+			if @max
+				@expected.to_s + " [#{@min}..#{@max}]"
+			else
+				@expected.to_s + " [#{@min}+]"
+			end
+		end
+	end
+end

data/lib/parser_sequence.rb

@@ -0,0 +1,41 @@
+module Kaiseki
+	class SequenceParser < MultiParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				result = []
+				@expected.each do |n|
+					begin
+						catch :SkipSuccess do
+							result << n.parse(stream, options)
+						end
+					rescue ParseError => e
+						if options[:skipping]
+							begin
+								catch :SkipSuccess do
+									options[:skipping].parse stream, options.merge(:skipping => nil)
+								end
+								redo
+							rescue ParseError
+								raise e
+							end
+						else
+							raise e
+						end
+					end
+				end
+				if options[:simplify]
+					result.length == 1 ? result[0] : result
+				else
+					result
+				end
+			end
+		end
+		
+		alias :& :append
+		
+		def delimiter
+			'&'
+		end
+	end
+end

data/lib/parser_string.rb

@@ -0,0 +1,18 @@
+module Kaiseki
+	class StringParser < BasicParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				@expected.each_char do |char|
+					actual = stream.getc
+					if actual.nil?
+						raise ParseError.new "unexpected end-of-string (expected \"#{char}\") when parsing #{self}", options
+					elsif actual != char
+						raise ParseError.new "unexpected character \"#{actual}\" (expected \"#{char}\") when parsing #{self}", options
+					end
+				end
+				@expected.dup
+			end
+		end
+	end
+end

data/lib/parser_symbol.rb

@@ -0,0 +1,16 @@
+module Kaiseki
+	class SymbolParser < BasicParser
+		def parse! stream, options = {}
+			if options[:grammar]
+				if options[:grammar].rules[@expected]
+					options[:grammar].rules[@expected].parse stream, options.merge(:rule => @expected)
+				else
+					STDERR.puts "skipping #{self}: not implemented"
+					throw :SkipSuccess
+				end
+			else
+				raise "can't use #{self} without a grammar"
+			end
+		end
+	end
+end

data/lib/predicate_and.rb

@@ -0,0 +1,19 @@
+module Kaiseki
+	class AndPredicate < PackageParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				begin
+					@expected.parse stream, options
+				rescue ParseError => e
+					raise ParseError.new "predicate not satisfied when parsing #{self}: #{e.to_s}", options
+				end
+				throw :PredicateSuccess
+			end
+		end
+		
+		def to_s
+			"#{@expected}.and?"
+		end
+	end
+end

data/lib/predicate_not.rb

@@ -0,0 +1,19 @@
+module Kaiseki
+	class NotPredicate < PackageParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				begin
+					result = @expected.parse stream, options
+				rescue ParseError
+					throw :PredicateSuccess
+				end
+				raise ParseError.new "predicate not satisfied when parsing #{self}: matched #{result}", options
+			end
+		end
+		
+		def to_s
+			"#{@expected}.not!"
+		end
+	end
+end

data/lib/predicate_skip.rb

@@ -0,0 +1,19 @@
+module Kaiseki
+	class SkipPredicate < PackageParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				begin
+					@expected.parse stream, options
+				rescue ParseError => e
+					raise ParseError.new "predicate not satisfied when parsing #{self}: #{e.to_s}", options
+				end
+				throw :SkipSuccess
+			end
+		end
+		
+		def to_s
+			"#{@expected}.skip"
+		end
+	end
+end

data/lib/result_cast.rb

@@ -0,0 +1,33 @@
+module Kaiseki
+	class CastResult < PackageParser
+		attr_reader :to_class
+		
+		def initialize expected, to_class
+			super expected
+			@to_class = to_class
+		end
+		
+		def parse! stream, options = {}
+			result = @expected.parse stream, options
+			if @to_class == Integer
+				result.is_a?(MatchData) ? result.to_s.to_i : result.to_i
+			elsif @to_class == Float
+				result.is_a?(MatchData) ? result.to_s.to_f : result.to_f
+			elsif @to_class == String
+				result.is_a?(Array) ? result.join : result.to_s
+			elsif @to_class == Symbol
+				result.is_a?(Array) ? result.join.to_sym : result.to_sym
+			elsif @to_class == Array
+				result.is_a?(String) ? result.split(options[:delimiter] || '') : result.to_a
+			else
+				raise "can't cast to #{@to_class}"
+			end
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.expected == @expected and other.to_class == @to_class
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/result_filter.rb

@@ -0,0 +1,36 @@
+module Kaiseki
+	class FilterResult < PackageParser
+		attr_reader :node, :block
+		
+		def initialize expected, node = Node.subclass([:result], :arity => {:result => 0}), &block
+			super expected
+			@node = node
+			@block = block
+		end
+		
+		def parse! stream, options = {}
+			if @node.is_a? Class
+				node_class = @node
+			else
+				if options[:grammar]
+					node_class = options[:grammar].nodes[@node]
+				else
+					raise "can't use named nodes without a grammar"
+				end
+			end
+			result = @expected.parse stream, options
+			if result.is_a? Array
+				node = node_class.new result, options[:global]
+			else
+				node = node_class.new [result]
+			end
+			node.eval options[:global], &@block
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.expected == @expected and other.block == @block
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/result_merge.rb

@@ -0,0 +1,20 @@
+module Kaiseki
+	class MergeResult < PackageParser
+		def parse! stream, options = {}
+			results = @expected.parse stream, options
+			new_results = []
+			if results.respond_to? :each
+				results.each do |result|
+					if result.respond_to? :each
+						result.each {|n| new_results << n }
+					else
+						new_results << result
+					end
+				end
+			else
+				new_results = results
+			end
+			new_results
+		end
+	end
+end

data/lib/result_override.rb

@@ -0,0 +1,20 @@
+module Kaiseki
+	class OverrideResult < PackageParser
+		attr_reader :options
+		
+		def initialize expected, options
+			super expected
+			@options = options
+		end
+		
+		def parse! stream, options = {}
+			@expected.parse stream, options.merge(@options)
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.expected == @expected and other.options == @options
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/rule.rb

@@ -0,0 +1,88 @@
+module Kaiseki
+	class Rule
+		attr_reader :parseable
+		
+		def initialize name, grammar, &block
+			@name = name
+			@grammar = grammar
+			@parseable = nil
+			
+			instance_eval &block if block_given?
+		end
+		
+		def parses parseable
+			if @parseable
+				raise "parseable for rule #{@name.inspect} already defined"
+			else
+				@parseable = parseable.to_parseable
+			end
+		end
+		
+		def override options
+			if @parseable
+				@parseable = @parseable.override options
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+		
+		def skipping parseable
+			if @parseable
+				@parseable = @parseable.override :skipping => parseable.to_parseable
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+		
+		def simplify bool = true
+			if @parseable
+				@parseable = @parseable.override :simplify => bool
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+		
+		def merge
+			if @parseable
+				@parseable = @parseable.merge
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+		
+		def cast to_class
+			if @parseable
+				@parseable = @parseable.cast to_class
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+		
+		def filter node = @name, &block
+			if @parseable
+				@grammar.nodes[@name] ||= Node.subclass([:result], :arity => {:result => 0})
+				@parseable = @parseable.filter node, &block
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+		
+		def node args, options = {}
+			args.must_be Array
+			if @grammar.nodes.key? @name
+				raise "node #{@name.inspect} already defined"
+			else
+				parent = options[:class] || Node
+				@grammar.nodes[@name] = parent.subclass args, options
+			end
+		end
+		
+		def set *vars
+			if @parseable
+				@parseable = @parseable.set *vars
+			else
+				raise "parseable for rule #{@name.inspect} undefined"
+			end
+		end
+	end
+end

data/lib/stream.rb

@@ -0,0 +1,98 @@
+module Kaiseki
+	class Stream
+		attr_reader :pos
+		
+		def initialize string
+			if string.is_a? File
+				@string = ''
+				string.each_char {|n| @string << n }
+			else
+				@string = string.to_s
+			end
+			@pos = 0
+			#index_lines
+		end
+		
+		def getc
+			if @pos < @string.length
+				@pos += 1
+				@string[@pos - 1]
+			else
+				nil
+			end
+		end
+		
+		def match regexp
+			match = @string[@pos..-1].match /\A#{regexp}/
+			if match
+				@pos += match.to_s.length
+				match
+			else
+				nil
+			end
+		end
+		
+		def look len = 10
+			if @string.length - @pos > len
+				"\"#{@string[@pos, len - 3] + '...'}\""
+			else
+				"\"#{@string[@pos..-1]}\""
+			end
+		end
+		
+		def goto pos
+			if pos < 0
+				@pos = 0
+			elsif pos > @string.length
+				@pos = @string.length
+			end
+		end
+		
+		def lock &block
+			safe_pos = @pos
+			begin
+				catch :PredicateSuccess do
+					return block.call
+				end
+				@pos = safe_pos
+				throw :SkipSuccess
+			rescue ParseError => e
+				@pos = safe_pos
+				#e.line ||= self.line
+				#e.column ||= self.column
+				raise e
+			end
+		end
+		
+		def to_s
+			@string.dup
+		end
+		
+		def to_stream
+			self
+		end
+		
+		def length
+			@string.length
+		end
+		
+		alias :size :length
+		
+		def line
+			
+		end
+		
+		def column
+			
+		end
+		
+		private
+		def index_lines
+			
+		end
+		
+		def bsearch
+			
+		end
+	end
+end

data/lib/var_get.rb

@@ -0,0 +1,40 @@
+module Kaiseki
+	class GetVar < BasicParser
+		attr_reader :parser
+		
+		def initialize expected, parser
+			super expected
+			@parser = parser.to_parseable
+		end
+		
+		def parse! stream, options = {}
+			if @expected.is_a? Symbol
+				if options[:global] and options[:global].key?(@expected)
+					source = options[:global][@expected]
+				else
+					raise "$#{@expected} undefined"
+				end
+			else
+				source = @expected
+			end
+			result = @parser.parse stream, options
+			if source.is_a?(MatchData) and result.is_a?(MatchData) and source.to_s == result.to_s and source.regexp == result.regexp
+				result
+			elsif source == result
+				result
+			else
+				raise ParseError.new "unexpected result #{result.inspect} (expected #{source.inspect}) when parsing #{@parser}", options
+			end
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.expected == @expected and other.parser == @parser
+		end
+		
+		alias :== :eql?
+		
+		def to_s
+			"#{@expected.is_a?(Symbol) ? "$#{@expected}" : @expected.inspect} (match)"
+		end
+	end
+end

data/lib/var_insert.rb

@@ -0,0 +1,19 @@
+module Kaiseki
+	class InsertVar < BasicParser
+		def parse! stream, options = {}
+			if @expected.is_a? Symbol
+				if options[:global] and options[:global].key?(@expected)
+					options[:global][@expected]
+				else
+					raise "$#{@expected} undefined"
+				end
+			else
+				@expected
+			end
+		end
+		
+		def to_s
+			"#{@expected.is_a?(Symbol) ? "$#{@expected}" : @expected.inspect} (ins)"
+		end
+	end
+end

data/lib/var_set.rb

@@ -0,0 +1,24 @@
+module Kaiseki
+	class SetVar < PackageParser
+		attr_reader :vars
+		
+		def initialize expected, *vars
+			super expected
+			@vars = []
+			vars.each {|n| @vars << n }
+		end
+		
+		def parse! stream, options = {}
+			result = @expected.parse stream, options
+			options[:global] ||= {}
+			@vars.each {|n| options[:global][n] = result }
+			result
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.expected == @expected and other.vars == @vars
+		end
+		
+		alias :== :eql?
+	end
+end