metal 0.0.2 → 0.0.3

data/lib/metal/generator.rb

@@ -19,296 +19,406 @@
 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
+		def self.escape_quoated_string(str)
+			str = str.gsub("\\", "\\\\\\\\")
+			str.gsub!("\"", "\\\\\"")
+			str_len = string_length(str)
+			str.gsub!("\n", "\\\\n\"\n\"")
+			return str, str_len
 		end
-
-		class Generator
-			def generate(lang, out = '')
-				ctx = Context.new(out)
-				__send__("gen_#{lang}", ctx)
-				ctx.out
-			end
+	
+		def self.string_length(str)
+			#@str.bytesize  # FIXME Ruby 1.9
+			str.size - str.scan(/\\/).length + str.scan(/\\\\/).length;
 		end
-
-		class Meta < Generator
-			def initialize(grammars)
-				@grammars = grammars
+	
+		class Meta
+			def initialize(codes)
+				@grammars, @precodes = codes.partition {|i| i.is_a?(Grammar) }
+				@vars = []
+				@grammar = nil
+				@rule = nil
 			end
-			def gen_ruby(ctx)
-				@grammars.each {|r|
-					r.gen_ruby(ctx)
+			def generate(fname, source = '', header = '', rbcode = '')
+				@grammars.each {|grammar|
+					grammar.preprocess(self)
 				}
-			end
-
-			def [](name)
-				name = name.to_sym
-				@grammars.find {|g| g.is_a?(Grammar) && g.name == name }
+	
+				header << "#import \"metal/runtime.h\"\n"
+				source << "#import \"#{fname}.h\"\n"
+				source << "using namespace Metal;\n"
+	
+				@vars.sort!
+				@vars.uniq!
+				@vars.each {|var|
+					source << "static param_t const PARAM_#{var} = param_lookup(\"#{var}\");\n"
+				}
+	
+				rbcode << <<END
+#import "ruby.h"
+#import "metal/rbcode.h"
+#import "#{fname}.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void Init_#{fname}() {
+VALUE mMetal = rb_define_module("Metal");
+VALUE cBase = rb_define_class_under(mMetal, "ParserBase", rb_cObject);
+VALUE code;
+END
+
+			@precodes.each {|precode|
+				code, code_len = Generator.escape_quoated_string(precode.code)
+				rbcode << "rb_eval_string(\"#{code}\");\n"
+			}
+
+			@grammars.each {|grammar|
+				grammar.generate(self, source, header, rbcode)
+			}
+
+			rbcode << <<END
+}
+#ifdef __cplusplus
+}
+#endif
+END
+	
+				return [source, header, rbcode]
+			end
+	
+			attr_accessor :meta, :grammar, :rule
+	
+			def register_var(name)
+				@vars.push name
 			end
 		end
-
-		class Grammar < Generator
-			def initialize(name, rules, base, interface = false)
-				@name = name.to_sym
-				@rules = rules
+	
+	
+		class Grammar
+			def initialize(name, body, base = nil, category = nil)
+				@name = name
+				@rules = []; @tokens = [], @precodes = []
+				body.each {|b|
+					if b.is_a?(Rule)
+						@rules.push(b)
+					elsif b.is_a?(Token)
+						@tokens.push(b)
+					else
+						@precodes.push(b)
+					end
+				}
 				@base = base
-				@interface = interface
-			end
-			attr_reader :name
-			def gen_ruby(ctx)
-				ctx.grammar = @name
-				if @interface
-					ctx.out << %[module #{@name}\n]
+				@category = category
+			end
+			def preprocess(ctx)
+				ctx.grammar = self
+				@rules.each {|rules| rules.preprocess(ctx) }
+				# FIXME @tokens
+			end
+			def generate(ctx, source, header, rbcode)
+				ctx.grammar = self
+	
+				if @category
+					header << "@interface #{@name} (#{@category})\n"
+				else
+					header << "@interface #{@name} : #{@base || 'MetalParserBase'}\n"
+				end
+				@rules.each {|rule|
+					header << "-(VALUE)rule_#{rule.name}:(Metal::Context*)ctx;\n"
+				}
+				# FIXME token
+				header << "@end\n"
+	
+				if @category
+					source << "@implementation #{@name} (#{@category})\n"
 				else
-					ctx.out << %[class #{@name} < #{@base || "Metal::ParserBase"}\n]
+					source << "@implementation #{@name}\n"
 				end
-				@rules.each {|r|
-					r.gen_ruby(ctx)
+				@rules.each {|rule|
+					source << "-(VALUE)rule_#{rule.name}:(Context*)ctx {\n"
+						source << "return ({\n"
+						rule.generate(ctx, source)
+						source << "});\n"
+					source << "}\n"
 				}
-				ctx.out << %[end\n]
+				# FIXME token
+				source << "@end\n"
+	
+				rbcode << "{\n"
+					if @category
+						rbcode << "VALUE c#{@name} = rb_const_get(rb_cKernel,rb_intern(\"#{@name}\"));\n"
+					else
+						rbcode << "VALUE c#{@name} = rb_define_class(\"#{@name}\", #{@base ? "rb_const_get(rb_cKernel,rb_intern(\"#{@base}\"))" : "cBase"});\n";
+						rbcode << "rb_define_method(cMetalParser, \"parse\", (VALUE (*)(ANYARGS))(VALUE (*)(VALUE,VALUE))&Metal::parse_method_template<#{@name}>, 1);\n"
+					end
+					@precodes.each {|precode|
+						code, code_len = Generator.escape_quoated_string(precode.code)
+						rbcode << "code = rb_str_new(\"#{code}\",#{code_len});\n";
+						rbcode << "rb_mod_module_eval(1,&code,c#{@name});\n"
+					}
+				rbcode << "}\n"
 			end
-
-			def [](name)
-				name = name.to_sym
-				@rules.find {|r| r.is_a?(Rule) && r.name == name }
+			attr_reader :name
+			def category?
+				@category != nil
 			end
 		end
-
-		class Precode < Generator
+	
+	
+		class Precode
 			def initialize(code)
 				@code = code
 			end
-			def gen_ruby(ctx)
-				ctx.out << @code << "\n"
-			end
+			attr_reader :code
 		end
-
-		class Mixin < Generator
-			def initialize(name)
+	
+	
+		class Token
+			# FIXME
+		end
+	
+		class Rule
+			def initialize(name, or_set)
 				@name = name
+				@or_set = or_set
+	
+				@serial = 0
 			end
-			def gen_ruby(ctx)
-				ctx.out << "include #{@name}\n"
+			def preprocess(ctx)
+				ctx.rule = self
+				@or_set.preprocess(ctx)
 			end
-		end
-
-		class Rule < Generator
-			def initialize(name, or_set, args)
-				@name = name.to_sym
-				@or_set = or_set
-				@args = args
+			def generate(ctx, source)
+				ctx.rule = self
+				source << "Env env;\n"
+				@or_set.generate(ctx, source)
 			end
-			def gen_ruby(ctx)
-				ctx.rule = @name
-				ctx.out << %[def rule_#{@name}(#{@args.join(',')})\n]
-				@or_set.gen_ruby(ctx)
-				ctx.out << %[end\n]
+			attr_reader :name
+	
+			def with_lambda(source, &block)
+				obj = "rule_#{@name}_#{@serial+=1}"
+				source << "struct #{obj}_t : Lambda {\n"
+					source << "#{obj}_t(Context* _ctx, Env& _env) : Lambda(_ctx, _env) {}\n"
+					source << "VALUE call() {\n"
+						source << "return ({\n"
+						yield
+						source << "});\n"
+					source << "}\n"
+				source << "} #{obj}(ctx, env);\n"
+				obj
 			end
 		end
-
+	
+	
 		class OrSet
-			def initialize(and_set)
-				@and_set = and_set
-			end
-			def gen_ruby(ctx)
-				if @and_set.length == 1
-					# OPTIMIZE
-					@and_set[0].gen_ruby(ctx)
-				elsif @and_set.length > 1
-					ctx.out << "act_or(["
-					@and_set.each {|r|
-						ctx.out << "lambda{"
-						r.gen_ruby(ctx)
-						ctx.out << "},\n"
+			def initialize(and_sets)
+				@and_sets = and_sets
+			end
+			def preprocess(ctx)
+				@and_sets.each {|and_set| and_set.preprocess(ctx) }
+			end
+			def generate(ctx, source)
+				if @and_sets.length <= 1
+					# optimize
+					@and_sets.each {|and_set|
+						and_set.generate(ctx, source)
+					}
+				else
+					objs = []
+					@and_sets.each {|and_set|
+						obj = ctx.rule.with_lambda(source) {
+							and_set.generate(ctx, source)
+						}
+						objs.push obj
 					}
-					ctx.out << "])\n"
+					set_name = "#{objs.first}_or"
+					source << "Lambda* #{set_name}[] = {\n"
+						objs.each {|obj|
+							source << "&#{obj},\n"
+						}
+						source << "NULL\n"
+					source << "};\n"
+					source << "ctx->act_or(#{set_name});\n"
 				end
 			end
 		end
-
+	
 		class AndSet
 			def initialize(exprs)
 				@exprs = exprs
 			end
-			def gen_ruby(ctx)
-				@exprs.each {|r|
-					r.gen_ruby(ctx)
-					ctx.out << "\n"
+			def preprocess(ctx)
+				@exprs.each {|expr| expr.preprocess(ctx) }
+			end
+			def generate(ctx, source)
+				@exprs.each {|expr|
+					expr.generate(ctx, source)
 				}
 			end
 		end
-
+	
+	
 		class Expression
-			def initialize(pred, var)
+			def initialize(pred, iter, var)
 				@pred = pred
+				@iter = iter
 				@var = var
 			end
-
-			def gen_ruby(ctx)
-				ctx.out << "#{@var} = " if @var
-				@pred.gen_ruby(ctx)
-			end
-		end
-
-		class IterMany
-			def initialize(pred)
-				@pred = pred
-			end
-			def gen_ruby(ctx)
-				ctx.out << "act_many(lambda{"
-				@pred.gen_ruby(ctx)
-				ctx.out << "})"
-			end
-		end
-
-		class IterMany1
-			def initialize(pred)
-				@pred = pred
+			def preprocess(ctx)
+				ctx.register_var(@var) if @var
+				@pred.preprocess(ctx)
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_many1(lambda{"
-				@pred.gen_ruby(ctx)
-				ctx.out << "})"
+			def generate(ctx, source)
+				source << "env[PARAM_#{@var}] = ({\n" if @var
+				if @iter
+					obj = ctx.rule.with_lambda(source) {
+						@pred.generate(ctx, source)
+					}
+					source << "ctx->act_#{@iter}(&#{obj});\n"
+				else
+					@pred.generate(ctx, source)
+				end
+				source << "});\n" if @var
 			end
 		end
-
-		class IterMay
+	
+	
+		class PredNot
 			def initialize(pred)
 				@pred = pred
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_may(lambda{"
-				@pred.gen_ruby(ctx)
-				ctx.out << "})"
-			end
-		end
-
-		class Action
-			def initialize(action)
-				@action = action
+			def preprocess(ctx)
+				@pred.preprocess(ctx)
 			end
-			def gen_ruby(ctx)
-				ctx.out << @action.to_s
+			def generate(ctx, source)
+				obj = ctx.rule.with_lambda(source) {
+					@pred.generate(ctx, source)
+				}
+				source << "ctx->act_not(&#{obj});\n"
 			end
 		end
-
-		class Where
-			def initialize(action)
-				@action = action
-			end
-			def gen_ruby(ctx)
-				ctx.out << "act_where(lambda{#{@action.to_s}})"
+	
+		class PredLookahead
+			def initialize(literal)
+				@literal = literal
 			end
-		end
-
-		class Apply
-			def initialize(name, vars)
-				@name = name
-				@vars = vars
+			def preprocess(ctx)
+				@literal.preprocess(ctx)
 			end
-			def gen_ruby(ctx)
-				ctx.out << "apply(:#{@name}#{@vars.map{|v|",#{v}"}})"
+			def generate(ctx, source)
+				obj = ctx.rule.with_lambda(source) {
+					@literal.generate(ctx, source)
+				}
+				source << "ctx->act_lookahead(&#{obj});\n"
 			end
 		end
-
-		class Super
-			def initialize(vars)
-				@vars = vars
+	
+	
+		class LiteralSuper
+			def initialize(args)
+				@args = args
 			end
-			def gen_ruby(ctx)
-				if @vars == nil
-					ctx.out << "super"
-				else
-					ctx.out << "super(#{@vars.join(',')})"
-				end
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				source << "[super rule_#{ctx.rule.name}:ctx];\n"
 			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}"}})"
+	
+		class LiteralEnd
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				source << "ctx->act_end();\n";
 			end
 		end
-
-		class Other
-			def initialize(grammar, rule, args)
-				@grammar = grammar
-				@rule = rule
+	
+		class LiteralApply
+			def initialize(name, args)
+				@name = name
 				@args = args
 			end
-			def gen_ruby(ctx)
-				ctx.out << "#{@grammar}.new(:#{@rule}).parse(@input#{@args.map{|v|",#{v}"}})"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				source << "ctx->apply(@selector(rule_#{@name}:));\n"
 			end
 		end
-
+	
+	
 		class LiteralQuotedToken
 			def initialize(str)
 				@str = str
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_token('#{@str}')"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				str, str_len = Generator.escape_quoated_string(@str)
+				if str_len == 1
+					# FIXME multibyte character optimize
+					source << "ctx->act_char(\"#{str}\",#{str_len});\n"
+				else
+					source << "ctx->act_token(\"#{str}\",#{str_len});\n"
+				end
 			end
 		end
-
+	
 		class LiteralToken
 			def initialize(str)
 				@str = str
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_token(\"#{@str}\")"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				str = @str
+				str_len = Generator.string_length(str)
+				if str_len == 1
+					# FIXME multibyte character optimize
+					source << "ctx->act_char(\"#{str}\",#{str_len});\n"
+				else
+					source << "ctx->act_token(\"#{str}\",#{str_len});\n"
+				end
 			end
 		end
-
-		class LiteralCharset
+	
+		class LiteralCharclass
 			def initialize(set)
 				@set = set
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_charset(%[#{@set}])"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				set, set_len = Generator.escape_quoated_string(@set)
+				reg = "[" << set << "]"  # FIXME \\A
+				reg_len = set_len + 2
+				# FIXME regexp precompile
+				source << "ctx->act_charclass(\"#{reg}\",#{reg_len});\n"
 			end
 		end
-
+	
 		class LiteralAny
-			def gen_ruby(ctx)
-				ctx.out << "act_any"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				source << "ctx->act_any();\n"
 			end
 		end
-
-		class PredNot
-			def initialize(expr)
-				@expr = expr
+	
+		class Action
+			def initialize(code)
+				@code = code
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_not(lambda{"
-				@expr.gen_ruby(ctx)
-				ctx.out << "})"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				code, code_len = Generator.escape_quoated_string(@code)
+				source << "ctx->act_run(env,\"#{code}\",#{code_len});\n"
 			end
 		end
-
-		class PredLookahead
-			def initialize(expr)
-				@expr = expr
+	
+		class Where
+			def initialize(code)
+				@code = code
 			end
-			def gen_ruby(ctx)
-				ctx.out << "act_lookahead(lambda{"
-				@expr.gen_ruby(ctx)
-				ctx.out << "})"
+			def preprocess(ctx) end
+			def generate(ctx, source)
+				code, code_len = Generator.escape_quoated_string(@code)
+				source << "ctx->act_where(env,\"#{code}\",#{code_len});\n"
 			end
 		end
-
+	
 	end
 end
 
-