metal 0.0.1 → 0.0.2

data/bin/metal

@@ -7,6 +7,9 @@ opts = {
 
 op = OptionParser.new
 
+require 'metal/version'
+op.version = Metal::VERSION::STRING
+
 op.on('-o OUTPUT', 'output file name') {|v|
 	opts[:output] = v
 }

data/bin/metal-run

@@ -18,7 +18,7 @@ after = Object.constants
 parsers = (after - before) \
 	.map     {|c| Object.const_get(c) } \
 	.select  {|c| c.is_a?(Class) }      \
-	.select  {|c| c.public_instance_methods.include?('rule_main') } \
+	.select  {|c| c.public_instance_methods.map{|m|m.to_sym}.include?(:rule_main) } \
 	.sort_by {|c| c.ancestors.length }  \
 	.reverse
 

data/lib/metal/boot.metal

@@ -106,6 +106,8 @@ MetalParser {
 			rule_name:r apply_args?:a  {*
 				if r == "super"
 					Super.new(a)
+				elsif r == "self"
+					Self.new(a || [])
 				else
 					Apply.new(r, a || [])
 				end *}

data/lib/metal/boot.rb

@@ -87,7 +87,7 @@ end
 def rule_precode()
 act_token('@{')
 s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('@')})
-rule_anything
+act_any
 },
 lambda{act_token('@')
 act_not(lambda{act_token('}')})
@@ -222,6 +222,8 @@ a = act_may(lambda{apply(:apply_args)})
 
 				if r == "super"
 					Super.new(a)
+				elsif r == "self"
+					Self.new(a || [])
 				else
 					Apply.new(r, a || [])
 				end 
@@ -249,11 +251,11 @@ end
 def rule_action()
 act_token('{*')
 s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('*')})
-rule_anything
+act_any
 },
 lambda{act_token('*')
 act_not(lambda{act_token('}')})
-''
+'*'
 },
 ])
 })
@@ -263,11 +265,11 @@ end
 def rule_where()
 act_token('?{*')
 s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('*')})
-rule_anything
+act_any
 },
 lambda{act_token('*')
 act_not(lambda{act_token('}')})
-''
+'*'
 },
 ])
 })
@@ -275,24 +277,24 @@ act_token('*}')
  Where.new(s.join) 
 end
 def rule_rule_name()
-x = rule_charset(%[a-z_])
-xs = act_many(lambda{rule_charset(%[a-zA-Z_0-9])})
+x = act_charset(%[a-z_])
+xs = act_many(lambda{act_charset(%[a-zA-Z_0-9])})
  ([x] + xs).join 
 end
 def rule_var_name()
-x = rule_charset(%[a-z_])
-xs = act_many(lambda{rule_charset(%[a-zA-Z_0-9])})
+x = act_charset(%[a-z_])
+xs = act_many(lambda{act_charset(%[a-zA-Z_0-9])})
  ([x] + xs).join 
 end
 def rule_grammar_name()
-x = rule_charset(%[A-Z])
-xs = act_many(lambda{rule_charset(%[a-zA-Z_0-9])})
+x = act_charset(%[A-Z])
+xs = act_many(lambda{act_charset(%[a-zA-Z_0-9])})
  ([x] + xs).join 
 end
 def rule_dq_string()
 act_token('"')
 s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('"')})
-rule_anything
+act_any
 },
 lambda{act_token('\"')
 },
@@ -304,7 +306,7 @@ end
 def rule_q_string()
 act_token("'")
 s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token("'")})
-rule_anything
+act_any
 },
 lambda{act_token("\\'")
 },
@@ -316,7 +318,7 @@ end
 def rule_charclass()
 act_token('[')
 s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token(']')})
-rule_anything
+act_any
 },
 lambda{act_token('\]')
 },
@@ -328,7 +330,7 @@ end
 def rule_s()
 act_many(lambda{act_or([lambda{apply(:comment)
 },
-lambda{rule_charset(%[ \t\r\n])
+lambda{act_charset(%[ \t\r\n])
 },
 ])
 })
@@ -336,7 +338,7 @@ end
 def rule_fs()
 act_many1(lambda{act_or([lambda{apply(:comment)
 },
-lambda{rule_charset(%[ \t\r\n])
+lambda{act_charset(%[ \t\r\n])
 },
 ])
 })
@@ -344,7 +346,7 @@ end
 def rule_comment()
 act_token('#')
 act_many(lambda{act_not(lambda{act_token("\n")})
-rule_anything
+act_any
 })
 act_token("\n")
 end

data/lib/metal/generator.rb

@@ -19,10 +19,22 @@
 module Metal
 	module Generator
 
+		class Context
+			def initialize(out)
+				@out = out
+				@rule = nil
+				@grammar = nil
+			end
+			attr_reader :out
+			attr_accessor :rule
+			attr_accessor :grammar
+		end
+
 		class Generator
-			def generate(lang, buf = '')
-				__send__("gen_#{lang}", buf)
-				buf
+			def generate(lang, out = '')
+				ctx = Context.new(out)
+				__send__("gen_#{lang}", ctx)
+				ctx.out
 			end
 		end
 
@@ -30,9 +42,9 @@ module Metal
 			def initialize(grammars)
 				@grammars = grammars
 			end
-			def gen_ruby(buf)
+			def gen_ruby(ctx)
 				@grammars.each {|r|
-					r.gen_ruby(buf)
+					r.gen_ruby(ctx)
 				}
 			end
 
@@ -50,16 +62,17 @@ module Metal
 				@interface = interface
 			end
 			attr_reader :name
-			def gen_ruby(buf)
+			def gen_ruby(ctx)
+				ctx.grammar = @name
 				if @interface
-					buf << %[module #{@name}\n]
+					ctx.out << %[module #{@name}\n]
 				else
-					buf << %[class #{@name} < #{@base || "Metal::ParserBase"}\n]
+					ctx.out << %[class #{@name} < #{@base || "Metal::ParserBase"}\n]
 				end
 				@rules.each {|r|
-					r.gen_ruby(buf)
+					r.gen_ruby(ctx)
 				}
-				buf << %[end\n]
+				ctx.out << %[end\n]
 			end
 
 			def [](name)
@@ -72,8 +85,8 @@ module Metal
 			def initialize(code)
 				@code = code
 			end
-			def gen_ruby(buf)
-				buf << @code << "\n"
+			def gen_ruby(ctx)
+				ctx.out << @code << "\n"
 			end
 		end
 
@@ -81,8 +94,8 @@ module Metal
 			def initialize(name)
 				@name = name
 			end
-			def gen_ruby(buf)
-				buf << "include #{@name}\n"
+			def gen_ruby(ctx)
+				ctx.out << "include #{@name}\n"
 			end
 		end
 
@@ -92,10 +105,11 @@ module Metal
 				@or_set = or_set
 				@args = args
 			end
-			def gen_ruby(buf)
-				buf << %[def rule_#{@name}(#{@args.join(',')})\n]
-				@or_set.gen_ruby(buf)
-				buf << %[end\n]
+			def gen_ruby(ctx)
+				ctx.rule = @name
+				ctx.out << %[def rule_#{@name}(#{@args.join(',')})\n]
+				@or_set.gen_ruby(ctx)
+				ctx.out << %[end\n]
 			end
 		end
 
@@ -103,18 +117,18 @@ module Metal
 			def initialize(and_set)
 				@and_set = and_set
 			end
-			def gen_ruby(buf)
+			def gen_ruby(ctx)
 				if @and_set.length == 1
 					# OPTIMIZE
-					@and_set[0].gen_ruby(buf)
+					@and_set[0].gen_ruby(ctx)
 				elsif @and_set.length > 1
-					buf << "act_or(["
+					ctx.out << "act_or(["
 					@and_set.each {|r|
-						buf << "lambda{"
-						r.gen_ruby(buf)
-						buf << "},\n"
+						ctx.out << "lambda{"
+						r.gen_ruby(ctx)
+						ctx.out << "},\n"
 					}
-					buf << "])\n"
+					ctx.out << "])\n"
 				end
 			end
 		end
@@ -123,10 +137,10 @@ module Metal
 			def initialize(exprs)
 				@exprs = exprs
 			end
-			def gen_ruby(buf)
+			def gen_ruby(ctx)
 				@exprs.each {|r|
-					r.gen_ruby(buf)
-					buf << "\n"
+					r.gen_ruby(ctx)
+					ctx.out << "\n"
 				}
 			end
 		end
@@ -137,9 +151,9 @@ module Metal
 				@var = var
 			end
 
-			def gen_ruby(buf)
-				buf << "#{@var} = " if @var
-				@pred.gen_ruby(buf)
+			def gen_ruby(ctx)
+				ctx.out << "#{@var} = " if @var
+				@pred.gen_ruby(ctx)
 			end
 		end
 
@@ -147,10 +161,10 @@ module Metal
 			def initialize(pred)
 				@pred = pred
 			end
-			def gen_ruby(buf)
-				buf << "act_many(lambda{"
-				@pred.gen_ruby(buf)
-				buf << "})"
+			def gen_ruby(ctx)
+				ctx.out << "act_many(lambda{"
+				@pred.gen_ruby(ctx)
+				ctx.out << "})"
 			end
 		end
 
@@ -158,10 +172,10 @@ module Metal
 			def initialize(pred)
 				@pred = pred
 			end
-			def gen_ruby(buf)
-				buf << "act_many1(lambda{"
-				@pred.gen_ruby(buf)
-				buf << "})"
+			def gen_ruby(ctx)
+				ctx.out << "act_many1(lambda{"
+				@pred.gen_ruby(ctx)
+				ctx.out << "})"
 			end
 		end
 
@@ -169,10 +183,10 @@ module Metal
 			def initialize(pred)
 				@pred = pred
 			end
-			def gen_ruby(buf)
-				buf << "act_may(lambda{"
-				@pred.gen_ruby(buf)
-				buf << "})"
+			def gen_ruby(ctx)
+				ctx.out << "act_may(lambda{"
+				@pred.gen_ruby(ctx)
+				ctx.out << "})"
 			end
 		end
 
@@ -180,8 +194,8 @@ module Metal
 			def initialize(action)
 				@action = action
 			end
-			def gen_ruby(buf)
-				buf << @action.to_s
+			def gen_ruby(ctx)
+				ctx.out << @action.to_s
 			end
 		end
 
@@ -189,8 +203,8 @@ module Metal
 			def initialize(action)
 				@action = action
 			end
-			def gen_ruby(buf)
-				buf << "act_where(lambda{#{@action.to_s}})"
+			def gen_ruby(ctx)
+				ctx.out << "act_where(lambda{#{@action.to_s}})"
 			end
 		end
 
@@ -199,8 +213,8 @@ module Metal
 				@name = name
 				@vars = vars
 			end
-			def gen_ruby(buf)
-				buf << "apply(:#{@name}#{@vars.map{|v|",#{v}"}})"
+			def gen_ruby(ctx)
+				ctx.out << "apply(:#{@name}#{@vars.map{|v|",#{v}"}})"
 			end
 		end
 
@@ -208,23 +222,34 @@ module Metal
 			def initialize(vars)
 				@vars = vars
 			end
-			def gen_ruby(buf)
+			def gen_ruby(ctx)
 				if @vars == nil
-					buf << "super"
+					ctx.out << "super"
 				else
-					buf << "super(#{@vars.join(',')})"
+					ctx.out << "super(#{@vars.join(',')})"
 				end
 			end
 		end
 
+		class Self
+			def initialize(vars)
+				@vars = vars
+			end
+			def gen_ruby(ctx)
+				#name = "caller.find{|c|n = c.to_s.scan(/`rule_(.*)'/).flatten.first; break n if n}.to_sym"
+				name = ctx.rule
+				ctx.out << "apply(:#{name}#{@vars.map{|v|",#{v}"}})"
+			end
+		end
+
 		class Other
 			def initialize(grammar, rule, args)
 				@grammar = grammar
 				@rule = rule
 				@args = args
 			end
-			def gen_ruby(buf)
-				buf << "#{@grammar}.new(:#{@rule}).parse(@input#{@args.map{|v|",#{v}"}})"
+			def gen_ruby(ctx)
+				ctx.out << "#{@grammar}.new(:#{@rule}).parse(@input#{@args.map{|v|",#{v}"}})"
 			end
 		end
 
@@ -232,8 +257,8 @@ module Metal
 			def initialize(str)
 				@str = str
 			end
-			def gen_ruby(buf)
-				buf << "act_token('#{@str}')"
+			def gen_ruby(ctx)
+				ctx.out << "act_token('#{@str}')"
 			end
 		end
 
@@ -241,8 +266,8 @@ module Metal
 			def initialize(str)
 				@str = str
 			end
-			def gen_ruby(buf)
-				buf << "act_token(\"#{@str}\")"
+			def gen_ruby(ctx)
+				ctx.out << "act_token(\"#{@str}\")"
 			end
 		end
 
@@ -250,14 +275,14 @@ module Metal
 			def initialize(set)
 				@set = set
 			end
-			def gen_ruby(buf)
-				buf << "rule_charset(%[#{@set}])"
+			def gen_ruby(ctx)
+				ctx.out << "act_charset(%[#{@set}])"
 			end
 		end
 
 		class LiteralAny
-			def gen_ruby(buf)
-				buf << "rule_anything"
+			def gen_ruby(ctx)
+				ctx.out << "act_any"
 			end
 		end
 
@@ -265,10 +290,10 @@ module Metal
 			def initialize(expr)
 				@expr = expr
 			end
-			def gen_ruby(buf)
-				buf << "act_not(lambda{"
-				@expr.gen_ruby(buf)
-				buf << "})"
+			def gen_ruby(ctx)
+				ctx.out << "act_not(lambda{"
+				@expr.gen_ruby(ctx)
+				ctx.out << "})"
 			end
 		end
 
@@ -276,10 +301,10 @@ module Metal
 			def initialize(expr)
 				@expr = expr
 			end
-			def gen_ruby(buf)
-				buf << "act_lookahead(lambda{"
-				@expr.gen_ruby(buf)
-				buf << "})"
+			def gen_ruby(ctx)
+				ctx.out << "act_lookahead(lambda{"
+				@expr.gen_ruby(ctx)
+				ctx.out << "})"
 			end
 		end
 

data/lib/metal/runtime.rb

@@ -17,397 +17,370 @@
 #
 
 module Metal
-
-	class Input
-		def initialize
-			@marks = []
-			@pos = 0
-			@memo = {}
-			@error = []
-		end
-		attr_reader :pos
-		attr_reader :error
-
-		def get_memo(name)
-			@memo["#{@pos} #{name}"]
-		end
-
-		def set_memo(pos, name, rec)
-			@memo["#{pos} #{name}"] = rec
-		end
-
-		def next
-			val = self[@pos]
-			raise EOFError, "unexpected EOF." unless val
-			@pos += 1
-			val
-		end
-
-		def prev
-			@pos -= 1
-		end
-
-		def mark
-			@marks.push @pos
-			@marks.length-1
-		end
-
-		def unmark(mark)
-			@marks[mark] = nil
-		end
-
-		def rewind(mark)
-			@pos = @marks[mark]
-		end
-
-		def seek(pos)
-			@pos = pos
-		end
-
-		def leaked_marks  # FIXME
-			@marks.compact.length
-		end
-
-		def inspect_at(index)
-			"at #{index}"
-		end
-	end
-
-
-	class StringInput < Input
-		def initialize(source)
-			@source = source.scan(/./m)  # FIXME Ruby 1.9
-			super()
-		end
-		def [](index)
-			@source[index]
-		end
-		def inspect_at(pos)
-			parsed = @source[0, pos].join.split("\n")
-			line = parsed.length
-			column = (line == 0 ? 0 : parsed.last.length)
-			"at line #{line}, col #{column}"
+	class ParserBase
+		def initialize(root = :main)
+			@root = root
 		end
-	end
-
 
-	class ParseError < RuntimeError
-		def initialize(msg, input)
-			super(msg)
-			@pos = input.pos
-			@error = input.error
-			@input = input
+		def parse(source, *args)
+			parser = self.dup
+			parser.initialize_parser(source, *args)
+			parser.apply(@root)
 		end
-		attr_reader :pos
-		attr_reader :error
 
-		def message
-			msg = super
-			@error.each {|e|
-				msg << "\n\t\t" << e.to_s
+		def initialize_parser(source, *args)
+			@input = case source
+				when IO
+					source.read.scan(/./m)
+				when String
+					source.scan(/./m)
+				when Array
+					source
+				else
+					source
+				end
+			@cache = Hash.new {|hash, key| hash[key] = {} }
+			@index = 0
+			@error_history = []
+			@call_stack  = []
+			@label_stack = []
+			@current_rule = nil
+			input = @input
+			error_history = @error_history
+			@error_class = Class.new(ParseError) {
+				const_set(:INPUT, input)
+				const_set(:ERROR_HISTORY, error_history)
 			}
-			msg << "\n"
-		end
-		def to_s
-			stdmsg(super)
 		end
 
-		private
-		def stdmsg(msg)
-			msg << " " << @input.inspect_at(@pos)
+		class ParseError < RuntimeError
+			def initialize(msg, index, call_stack)
+				super(msg)
+				@index = index
+				@call_stack = call_stack
+			end
+			attr_reader :index
+			def to_s
+				super.gsub("\n", "\n    ")
+			end
+			def message(rec = false)
+				if rec
+					input = self.class::INPUT
+					parsed = input[0, @index].to_s.split("\n")
+					line = parsed.length
+					column = (line == 0 ? 0 : parsed.last.length)
+					help = input[@index, 10]
+					help = help.join if help.is_a?(Array)
+					help << '...' if help.length == 10
+					help.gsub!("\r", '\r')
+					help.gsub!("\n", '\n')
+					help.gsub!("\t", '\t')
+					help = "'#{help}'"
+					msg = "  #{@call_stack.join('> ')}\n      at line #{line}, column #{column}  #{help.ljust(18)} #{super()}"
+				else
+					msg = "parse error:\n"
+					s = 0
+					self.class::ERROR_HISTORY.dup.push(self).sort_by{|e| [-e.index, s+=1] }.each_with_index {|(err,s), i|
+					#self.class::ERROR_HISTORY.dup.push(self).reverse.each_with_index {|err, i|
+						msg << "\n" << err.message(true)
+						if i > 5
+							msg << "\n  ...\n"
+							break
+						end
+					}
+				end
+				msg
+			end
 		end
-	end
 
-	class LeftRecursion
-		def initialize
-			@detected = false
+		class LeftRecursion
+			def initialize
+				@call_stack = nil
+			end
+			attr_accessor :call_stack
 		end
-		attr_accessor :detected
-	end
 
-	class Memo
-		def initialize(ret, pos)
-			@ret = ret
-			@pos = pos
+		class Memo
+			def initialize(ret, pos)
+				@ret = ret
+				@pos = pos
+			end
+			attr_accessor :ret, :pos
 		end
-		attr_reader :ret
-		attr_reader :pos
-	end
 
-	class ParserBase
-		DEFAULT_ROOT = :main
-
-		def initialize(root = nil)
-			@root = root
-			@me = 0  # FIXME
-		end
-		attr_accessor :root
+		def apply(rule, *args)
+			@current_rule = rule
+			@call_stack.push rule
 
-		attr_accessor :me  # FIXME
+			#p @label_stack.map {|l| l.join(':')  }.join(',')
+			#cache_name = "#{rule}@#{@label_stack.map{|l|l.join(':')}.join(',')}"
+			cache_name = "#{rule}"  # FIXME left recursion
+		#	cache_name = "#{rule}@#{@label_stack.inspect}"
 
-		def parse(source, *args)
-			@input = case source
-					when Input
-						source
-					when IO
-						StringInput.new(source.read) #FIXME
-					when String
-						StringInput.new(source)
-					else
-						StringInput.new(source)
-					end
-			apply(@root || self.class::DEFAULT_ROOT, *args)
-		end
-		attr_reader :input
+			method_name = "rule_#{rule}"
 
-		def apply(rule, *args)
-			rule_method = "rule_#{rule}"
 			unless args.empty?
-				return __send__(rule_method, *args)
+				return __send__(method_name, *args)
 			end
 
-			memo_name = "#{self.class}.#{rule}"
-			if memorized = @input.get_memo(memo_name)
-				@me += 1  # FIXME
-				# memorized rule
-				if memorized.class == LeftRecursion
-					memorized.detected = true
-					raise ParseError.new("Left recursion detected", @input)
+			#labeled = nil
+			#if @label_stack.last
+			#	labeled = true
+			#end
+		#	if @label_stack.last && !@label_stack.last.shift
+		#		@label_stack.pop
+		#		#labeled = false
+		#	end
+
+			#puts "#{rule}@#{@label_stack.inspect}:  cache: #{@cache["#{rule}@#{@label_stack.inspect}"].inspect}"
+
+			if memo = @cache[cache_name][@index]
+				if memo.ret.class == LeftRecursion
+					memo.ret.call_stack = @call_stack[0..-1]
+					parse_error "left recursion"
 				end
-				@input.seek(memorized.pos)
-				return memorized.ret
-			end
-
-			# non-memorized rule
-			m = @input.mark
-			begin
-				save_pos = @input.pos
-				lr = LeftRecursion.new
-				@input.set_memo(save_pos, memo_name, lr)
-				ret = __send__(rule_method)
-				@input.set_memo(save_pos, memo_name, Memo.new(ret, @input.pos))
-			rescue
-				@input.unmark(m)
-				raise $!
+				#puts "#{cache_name}: cached #{@index} to #{memo.pos}  (#{memo.ret.inspect})"
+				@index = memo.pos
+				return memo.ret
+			else
+				#begin  XXX
+					start_pos = @index
+					lr = LeftRecursion.new
+					memo = @cache[cache_name][start_pos] = Memo.new(lr, start_pos)
+					memo.ret = __send__(method_name)
+					memo.pos = @index
+					#puts "#{cache_name}: uncached #{start_pos} to #{@index}  (#{memo.ret.inspect})"
+					#if labeled != nil
+					#	cache_name = "#{rule}@#{@label_stack.inspect}"
+					#	puts "ncn: #{cache_name} #{start_pos} -> #{memo.inspect}"
+					#	memo = @cache[cache_name][start_pos] = Memo.new(memo.ret, memo.pos)
+					#end
+					if lr.call_stack
+						$stderr.puts "#{@call_stack.inspect}: left recursion" # FIXME left recursion
+						parse_error "left recursion"  # FIXME left recursion
+		#				#puts "#{cache_name}: lr start"
+		#				finish_pos = @index
+		#				#puts "#{cache_name}: detected on #{@index} from #{memo.pos}"
+		#				#puts "#{cache_name}: rewind stack: #{lr.call_stack[@call_stack.length..-1].inspect}"
+		#				@label_stack.push(lr.call_stack[@call_stack.length..-1])
+		#				while true
+		#					@index = start_pos
+		#					memo.ret = __send__(method_name)
+		#					#puts "#{cache_name}: recalled, moved to #{@index}"
+		#					memo.pos = @index
+		#					break if finish_pos <= @index
+		#					#if finish_pos <= @index
+		#					#	p "lr growed #{cache_name} #{start_pos} to #{@index}  #{memo.ret.inspect}"
+		#					#	#p memo
+		#					#	#p @cache[cache_name][start_pos]
+		#					#	#nmemo = @cache[cache_name][start_pos]
+		#					#	#if nmemo && memo.pos <= nmemo.pos
+		#					#	#	@index = nmemo.pos
+		#					#	#	memo = nmemo
+		#					#	#end
+		#					#	#break
+		#					#	nmemo = @cache[cache_name][start_pos]
+		#					#	if nmemo && memo.pos <= nmemo.pos
+		#					#		memo = nmemo
+		#					#		@index = memo.pos
+		#					#	end
+		#					#	#begin
+		#					#	#	@index = start_pos
+		#					#	#	p "JKJK"
+		#					#	#	ret = __send__(method_name)
+		#					#	#	if memo.pos <= @index
+		#					#	#		memo.ret = ret
+		#					#	#		memo.pos = @index
+		#					#	#	end
+		#					#	#rescue
+		#					#	#	break
+		#					#	#	p $!
+		#					#	#end
+		#					#	break
+		#					#end
+		#				end
+		#				#puts "#{cache_name}: lr end #{start_pos} -> #{@index}"
+					end
+					memo.ret
+				#rescue ParseError  # XXX
+				#	@cache[cache_name][@index] = nil
+				#	raise
+				#end
 			end
 
-			if lr.detected
-				sentinel = @input.pos
-				@input.rewind(m)
-				while true
-					n = @input.mark
-					begin
-						ret = __send__(rule_method)
-						break if @input.pos == sentinel
-						memorized = @input.set_memo(save_pos, memo_name, Memo.new(ret, @input.pos))
-						@input.rewind(n)
-					rescue ParseError
-						@input.unmark(n)
-						break
-					end
-				end
+		#rescue
+		#	if $!.to_s == '"k" is expected'
+		#		require 'pp'
+		#		pp caller
+		#	end
+		#	raise
+		ensure
+			@call_stack.pop
+		end
 
-			else
-				@input.unmark(m)
-			end
+		def act_or_message(err)
+			msg = "One of following expressions expected:"
+			err.each {|e| msg << "\n          " << e.to_s }
+			msg
+		end
+		private :act_or_message
 
-			ret
+		def act_or(blocks)
+			err = []
+			pos = @index
+			blocks.each {|block|
+				begin
+					ret = block.call
+					@error_history.concat err
+					return ret
+				rescue ParseError
+					@index = pos
+					err.push $!
+				end
+			}
+			parse_error act_or_message(err)
 		end
 
-		def act_many(block, *rets)
-			@input.error.clear
+		def act_many(block)
+			ret = []
 			while true
-				m = @input.mark
+				pos = @index
 				begin
-					rets.push block.call
+					ret.push block.call
+					return ret if pos == @index   # XXX many in many avoidance
 				rescue ParseError
-					@input.error.push $!
-					@input.rewind(m)
-					break
-				ensure
-					@input.unmark(m)
+					@index = pos
+					@error_history.push $!
+					return ret
 				end
 			end
-			rets
 		end
 
-		def act_many1(block, *rets)
-			rets.push block.call
-			act_many(block, *rets)
+		def act_many1(block)
+			ret = []
+			while true
+				pos = @index
+				begin
+					ret.push block.call
+					return ret if pos == @index   # XXX many in many avoidance
+				rescue ParseError
+					@index = pos
+					raise if ret.empty?
+					@error_history.push $!
+					return ret
+				end
+			end
 		end
 
 		def act_may(block)
-			m = @input.mark
-			rets = nil
-			@input.error.clear
+			pos = @index
 			begin
-				rets = block.call
+				block.call
 			rescue ParseError
-				@input.error.push $!
-				@input.rewind(m)
-			ensure
-				@input.unmark(m)
+				@index = pos
+				@error_history.push $!
+				nil
 			end
-			rets
 		end
 
-		def act_or(blocks)
-			ex = []
-			blocks.each {|block|
-				m = @input.mark
-				begin
-					ret = block.call
-					return ret
-				rescue ParseError
-					ex.push $!
-					@input.rewind(m)
-				ensure
-					@input.unmark(m)
-				end
-			}
-			msg = "All expression failed:"
-			ex.each {|e| msg << "\n\t\t\t" << e.to_s }
-			raise ParseError.new(msg, @input)
-		end
 
 		def act_not(block)
-			m = @input.mark
-			unless	begin
-								block.call
-								nil
-							rescue ParseError
-								true
-							ensure
-								@input.rewind(m)
-								@input.unmark(m)
-							end
-				raise ParseError.new("unexpectedly succeeded", @input)
+			pos = @index
+			unless begin
+						block.call
+						nil
+					rescue ParseError
+						true
+					ensure
+						@index = pos
+					end
+				parse_error "not prediction failed"
 			end
 		end
 
 		def act_lookahead(block)
-			m = @input.mark
+			pos = @index
 			begin
-				block.call   # FIXME
+				block.call
 			ensure
-				@input.rewind(m)
-				@input.unmark(m)
+				@index = pos
 			end
 		end
 
 		def act_where(block)
 			unless block.call
-				raise ParseError.new("where block failed", @input)
+				parse_error "where prediction failed"
 			end
 		end
 
-		def act_exactly(wanted)
-			m = @input.mark
-			begin
-				val = @input.next
-				unless val == wanted
-					@input.rewind(m)
-					raise ParseError.new("#{wanted.inspect} is expected", @input)
-				end
-				val
-			rescue EOFError
-				@input.rewind(m)
-				raise ParseError.new("#{wanted.inspect} is expected but EOF comes", @input)
-			ensure
-				@input.unmark(m)
+		def act_any
+			next_char
+		end
+
+		def act_char(c)
+			pos = @index
+			n = next_char
+			unless c == n
+				@index = pos
+				parse_error "#{c.inspect} is expected"
+			end
+			n
+		end
+
+		def act_charset(set)
+			pos = @index
+			n = next_char
+			if n.count(set) == 0
+				@index = pos
+				parse_error "character set [#{set.inspect[1..-2]}] is expected"
 			end
+			n
 		end
 
 		def act_token(str)
-			return act_exactly(str) if str.length == 1
-			m = @input.mark
+			pos = @index
 			begin
-				str.scan(/./m) {|c|  # FIXME Ruby 1.9
-					act_exactly(c)
+				str.scan(/./m) {|c|
+					act_char(c)
 				}
 				str
 			rescue ParseError
-				@input.rewind(m)
-				raise ParseError.new("#{str.inspect} is expected", @input)
-			ensure
-				@input.unmark(m)
+				@index = pos
+				parse_error "#{str.inspect} is expected"
 			end
 		end
 
-		def rule_anything
-			@input.next
-		rescue EOFError
-			raise ParseError.new($!.to_s, @input)
-		end
-
 		def rule_end
-			m = @input.mark
-			begin
-				@input.next
-				raise ParseError.new("EOF expected", @input)
-			rescue EOFError
-				nil
-			ensure
-				@input.rewind(m)
-				@input.unmark(m)
-			end
-		end
-
-		def rule_charset(set)
-			x = @input.next
-			if x.count(set) == 0
-				@input.prev
-				raise ParseError.new("one of character in #{set.inspect} expected", @input)
+			if begin
+						c = next_char
+						@index -= 1
+						true
+					rescue
+						nil
+					end
+				parse_error "unexpected character '#{c}', EOF expected"
 			end
-			x
-		rescue EOFError
-			raise ParseError.new($!.to_s, @input)
-		end
-
-		def rule_empty
-			nil
-		end
-
-=begin
-		def rule_letter
-			rule_charset("a-zA-Z")
-		end
-
-		def rule_digit
-			rule_charset("0-9")
-		end
-
-		def rule_letter_or_digit
-			rule_charset("a-zA-Z0-9")
 		end
 
-		def rule_space
-			rule_charset(" \t\r\n")
+		protected
+		def error(msg)
+			parse_error(msg)
 		end
 
-		def rule_spaces
-			while @input.next.count(" \t\r\n") != 0
-				true
+		private
+		def next_char
+			unless c = @input[@index]
+				parse_error "Unexpected end of input"
 			end
+			@index += 1
+			c
 		end
-=end
 
-		protected
-		def error(msg)
-			raise ParseError.new(msg, @input)
+		def parse_error(msg)
+			raise @error_class.new(msg, @index, @call_stack.dup)
 		end
 
 	end
 end
 
-EXTEND_GRAMMER = <<EOF
-MetaUtility {
-	-letter
-		<charset "a-zA-Z">
-}
-EOF
-
-
-
-
 

data/lib/metal/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: metal
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - FURUHASHI Sadayuki
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-30 00:00:00 +09:00
+date: 2008-07-24 00:00:00 +09:00
 default_executable: 
 dependencies: []