metal 0.0.1

data/lib/metal/generator.rb

@@ -0,0 +1,289 @@
+#
+# Metal Generator
+#
+# Copyright (C) 2008 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Metal
+	module Generator
+
+		class Generator
+			def generate(lang, buf = '')
+				__send__("gen_#{lang}", buf)
+				buf
+			end
+		end
+
+		class Meta < Generator
+			def initialize(grammars)
+				@grammars = grammars
+			end
+			def gen_ruby(buf)
+				@grammars.each {|r|
+					r.gen_ruby(buf)
+				}
+			end
+
+			def [](name)
+				name = name.to_sym
+				@grammars.find {|g| g.is_a?(Grammar) && g.name == name }
+			end
+		end
+
+		class Grammar < Generator
+			def initialize(name, rules, base, interface = false)
+				@name = name.to_sym
+				@rules = rules
+				@base = base
+				@interface = interface
+			end
+			attr_reader :name
+			def gen_ruby(buf)
+				if @interface
+					buf << %[module #{@name}\n]
+				else
+					buf << %[class #{@name} < #{@base || "Metal::ParserBase"}\n]
+				end
+				@rules.each {|r|
+					r.gen_ruby(buf)
+				}
+				buf << %[end\n]
+			end
+
+			def [](name)
+				name = name.to_sym
+				@rules.find {|r| r.is_a?(Rule) && r.name == name }
+			end
+		end
+
+		class Precode < Generator
+			def initialize(code)
+				@code = code
+			end
+			def gen_ruby(buf)
+				buf << @code << "\n"
+			end
+		end
+
+		class Mixin < Generator
+			def initialize(name)
+				@name = name
+			end
+			def gen_ruby(buf)
+				buf << "include #{@name}\n"
+			end
+		end
+
+		class Rule < Generator
+			def initialize(name, or_set, args)
+				@name = name.to_sym
+				@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]
+			end
+		end
+
+		class OrSet
+			def initialize(and_set)
+				@and_set = and_set
+			end
+			def gen_ruby(buf)
+				if @and_set.length == 1
+					# OPTIMIZE
+					@and_set[0].gen_ruby(buf)
+				elsif @and_set.length > 1
+					buf << "act_or(["
+					@and_set.each {|r|
+						buf << "lambda{"
+						r.gen_ruby(buf)
+						buf << "},\n"
+					}
+					buf << "])\n"
+				end
+			end
+		end
+
+		class AndSet
+			def initialize(exprs)
+				@exprs = exprs
+			end
+			def gen_ruby(buf)
+				@exprs.each {|r|
+					r.gen_ruby(buf)
+					buf << "\n"
+				}
+			end
+		end
+
+		class Expression
+			def initialize(pred, var)
+				@pred = pred
+				@var = var
+			end
+
+			def gen_ruby(buf)
+				buf << "#{@var} = " if @var
+				@pred.gen_ruby(buf)
+			end
+		end
+
+		class IterMany
+			def initialize(pred)
+				@pred = pred
+			end
+			def gen_ruby(buf)
+				buf << "act_many(lambda{"
+				@pred.gen_ruby(buf)
+				buf << "})"
+			end
+		end
+
+		class IterMany1
+			def initialize(pred)
+				@pred = pred
+			end
+			def gen_ruby(buf)
+				buf << "act_many1(lambda{"
+				@pred.gen_ruby(buf)
+				buf << "})"
+			end
+		end
+
+		class IterMay
+			def initialize(pred)
+				@pred = pred
+			end
+			def gen_ruby(buf)
+				buf << "act_may(lambda{"
+				@pred.gen_ruby(buf)
+				buf << "})"
+			end
+		end
+
+		class Action
+			def initialize(action)
+				@action = action
+			end
+			def gen_ruby(buf)
+				buf << @action.to_s
+			end
+		end
+
+		class Where
+			def initialize(action)
+				@action = action
+			end
+			def gen_ruby(buf)
+				buf << "act_where(lambda{#{@action.to_s}})"
+			end
+		end
+
+		class Apply
+			def initialize(name, vars)
+				@name = name
+				@vars = vars
+			end
+			def gen_ruby(buf)
+				buf << "apply(:#{@name}#{@vars.map{|v|",#{v}"}})"
+			end
+		end
+
+		class Super
+			def initialize(vars)
+				@vars = vars
+			end
+			def gen_ruby(buf)
+				if @vars == nil
+					buf << "super"
+				else
+					buf << "super(#{@vars.join(',')})"
+				end
+			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}"}})"
+			end
+		end
+
+		class LiteralQuotedToken
+			def initialize(str)
+				@str = str
+			end
+			def gen_ruby(buf)
+				buf << "act_token('#{@str}')"
+			end
+		end
+
+		class LiteralToken
+			def initialize(str)
+				@str = str
+			end
+			def gen_ruby(buf)
+				buf << "act_token(\"#{@str}\")"
+			end
+		end
+
+		class LiteralCharset
+			def initialize(set)
+				@set = set
+			end
+			def gen_ruby(buf)
+				buf << "rule_charset(%[#{@set}])"
+			end
+		end
+
+		class LiteralAny
+			def gen_ruby(buf)
+				buf << "rule_anything"
+			end
+		end
+
+		class PredNot
+			def initialize(expr)
+				@expr = expr
+			end
+			def gen_ruby(buf)
+				buf << "act_not(lambda{"
+				@expr.gen_ruby(buf)
+				buf << "})"
+			end
+		end
+
+		class PredLookahead
+			def initialize(expr)
+				@expr = expr
+			end
+			def gen_ruby(buf)
+				buf << "act_lookahead(lambda{"
+				@expr.gen_ruby(buf)
+				buf << "})"
+			end
+		end
+
+	end
+end
+
+

data/lib/metal/runtime.rb

@@ -0,0 +1,413 @@
+#
+# Metal Runtime
+#
+# Copyright (C) 2008 FURUHASHI Sadayuki
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+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}"
+		end
+	end
+
+
+	class ParseError < RuntimeError
+		def initialize(msg, input)
+			super(msg)
+			@pos = input.pos
+			@error = input.error
+			@input = input
+		end
+		attr_reader :pos
+		attr_reader :error
+
+		def message
+			msg = super
+			@error.each {|e|
+				msg << "\n\t\t" << e.to_s
+			}
+			msg << "\n"
+		end
+		def to_s
+			stdmsg(super)
+		end
+
+		private
+		def stdmsg(msg)
+			msg << " " << @input.inspect_at(@pos)
+		end
+	end
+
+	class LeftRecursion
+		def initialize
+			@detected = false
+		end
+		attr_accessor :detected
+	end
+
+	class Memo
+		def initialize(ret, pos)
+			@ret = ret
+			@pos = 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
+
+		attr_accessor :me  # FIXME
+
+		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
+
+		def apply(rule, *args)
+			rule_method = "rule_#{rule}"
+			unless args.empty?
+				return __send__(rule_method, *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)
+				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 $!
+			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
+
+			else
+				@input.unmark(m)
+			end
+
+			ret
+		end
+
+		def act_many(block, *rets)
+			@input.error.clear
+			while true
+				m = @input.mark
+				begin
+					rets.push block.call
+				rescue ParseError
+					@input.error.push $!
+					@input.rewind(m)
+					break
+				ensure
+					@input.unmark(m)
+				end
+			end
+			rets
+		end
+
+		def act_many1(block, *rets)
+			rets.push block.call
+			act_many(block, *rets)
+		end
+
+		def act_may(block)
+			m = @input.mark
+			rets = nil
+			@input.error.clear
+			begin
+				rets = block.call
+			rescue ParseError
+				@input.error.push $!
+				@input.rewind(m)
+			ensure
+				@input.unmark(m)
+			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)
+			end
+		end
+
+		def act_lookahead(block)
+			m = @input.mark
+			begin
+				block.call   # FIXME
+			ensure
+				@input.rewind(m)
+				@input.unmark(m)
+			end
+		end
+
+		def act_where(block)
+			unless block.call
+				raise ParseError.new("where block failed", @input)
+			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)
+			end
+		end
+
+		def act_token(str)
+			return act_exactly(str) if str.length == 1
+			m = @input.mark
+			begin
+				str.scan(/./m) {|c|  # FIXME Ruby 1.9
+					act_exactly(c)
+				}
+				str
+			rescue ParseError
+				@input.rewind(m)
+				raise ParseError.new("#{str.inspect} is expected", @input)
+			ensure
+				@input.unmark(m)
+			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)
+			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")
+		end
+
+		def rule_spaces
+			while @input.next.count(" \t\r\n") != 0
+				true
+			end
+		end
+=end
+
+		protected
+		def error(msg)
+			raise ParseError.new(msg, @input)
+		end
+
+	end
+end
+
+EXTEND_GRAMMER = <<EOF
+MetaUtility {
+	-letter
+		<charset "a-zA-Z">
+}
+EOF
+
+
+
+
+