metal 0.0.1

data/License.txt

@@ -0,0 +1,13 @@
+Copyright 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.

data/Manifest.txt

@@ -0,0 +1,20 @@
+License.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/metal
+bin/metal-run
+config/hoe.rb
+config/requirements.rb
+lib/metal.rb
+lib/metal/boot.metal
+lib/metal/boot.rb
+lib/metal/generator.rb
+lib/metal/runtime.rb
+lib/metal/version.rb
+script/console
+script/destroy
+script/generate
+setup.rb
+tasks/deployment.rake
+tasks/environment.rake

data/README.txt

@@ -0,0 +1,29 @@
+Metal
+-----
+Object-oriented parser generator based on Parser Expression Grammar (PEG)
+
+*Usage:
+
+  TODO
+
+
+*INSTALL:
+
+  $ gem install metal
+
+
+== LICENSE:
+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.
+

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/bin/metal

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+opts = {
+	:output => '-',
+}
+
+op = OptionParser.new
+
+op.on('-o OUTPUT', 'output file name') {|v|
+	opts[:output] = v
+}
+op.banner = "#{op.banner} <source.metal>"
+op.parse!(ARGV)
+
+if ARGV.length != 1
+	puts op.to_s
+	exit 1
+end
+src = ARGV[0]
+
+require 'metal'
+unless defined? MetalParser
+	require 'metal/boot'
+end
+
+parser = MetalParser.new
+result = parser.parse File.read(src)
+code = result.generate(:ruby)
+
+if opts[:output] == '-'
+	$stdout.write code
+else
+	File.open(opts[:output], 'wb') {|f|
+		f.write code
+	}
+end
+

data/bin/metal-run

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+if ARGV.length != 2
+	puts "Usage: #{File.basename($0)} <source.rb> <target>"
+	exit 1
+end
+src = ARGV[0]
+target = ARGV[1]
+
+require 'rubygems'
+require 'metal'
+
+before = Object.constants
+load src
+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') } \
+	.sort_by {|c| c.ancestors.length }  \
+	.reverse
+
+if parsers.empty?
+	puts "Can't find parser in #{src}."
+	exit 1
+end
+
+first = parsers.first
+$stderr.puts "Using #{first}"
+
+if target == '-'
+	$stderr.puts "Using standard input as input."
+	input = $stdin
+elsif File.file?(target)
+	$stderr.puts "Using #{target} file as input."
+	input = File.open(target)
+else
+	$stderr.puts "Using '#{target}' as input."
+	input = target
+end
+
+result = first.new.parse(input)
+
+if result.is_a?(String)
+	puts result
+else
+	require 'pp'
+	pp result
+end
+

data/config/hoe.rb

@@ -0,0 +1,73 @@
+require 'metal/version'
+
+AUTHOR = 'FURUHASHI Sadayuki'  # can also be an array of Authors
+EMAIL = "fr _at_ syuki.skr.jp"
+DESCRIPTION = "An object-oriented parser generator based on Parser Expression Grammar"
+GEM_NAME = 'metal' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'metal' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+#  ['activesupport', '>= 1.3.1']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Metal::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'metal documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/metal.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Metal
+end
+
+require 'metal/runtime'

data/lib/metal/boot.metal

@@ -0,0 +1,153 @@
+@{#
+# Metal Bootstrap Parser
+#
+# 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.
+#
+require 'metal/generator'
+@}
+
+
+MetalParser {
+	@include Metal::Generator
+
+	-main
+		meta:m end  {* m *}
+
+	-meta
+		(grammar / meta_command)*:xs s  {* Meta.new(xs) *}
+
+	-meta_command
+			s precode
+	
+	-grammar
+			s interface_attr:i grammar_name:n s extend_attr?:e s '{' grammar_body:b '}'
+				{* Grammar.new(n, b, e, i) *}
+
+	-interface_attr
+			'module' fs  {* true  *}
+		/ 'class' fs   {* false *}
+		/ {* false *}
+	
+	-extend_attr
+			'<' s grammar_name
+
+	-grammar_body
+		s (rule / grammar_command)*
+
+	-grammar_command
+			precode
+		/ mixin
+
+	-precode
+			'@{' (!'@' . / '@' !'}' {*'@'*})+:s '@}' s  {* Precode.new(s.join) *}
+
+	-mixin
+			'@include' fs scoped_grammar_name:n s  {* Mixin.new(n) *}
+
+	-scoped_grammar_name
+		('::'?:s grammar_name:n  {*"#{s}#{n}"*})+:xs  {* xs.join *}
+
+	-rule
+			'-' s rule_name:n rule_args:a fs or_set:r s
+				{* Rule.new(n, r, a) *}
+	
+	-rule_args
+			(s ':' var_name)*
+	
+	-or_set
+			and_set:x s (s '/' and_set)*:xs
+				{* OrSet.new([x] + xs) *}
+	
+	-and_set
+			s (expr:x (fs expr)*:xs {*[x]+xs*})?:xs
+				{* AndSet.new(xs || []) *}
+	
+	-expr
+			pred:p iter(p)?:p var?:v {* Expression.new(p, v) *}
+	
+	-pred
+			'!' pred:p     {* PredNot.new(p) *}
+		/ '&' literal:f  {* PredLookahead.new(f) *}
+		/ literal
+	
+	-iter :x
+			'*'  {* IterMany.new(x)  *}
+		/ '+'  {* IterMany1.new(x) *}
+		/ '?'  {* IterMay.new(x) *}
+		/      {* x *}
+	
+	-literal
+			apply_rule
+		/ action
+		/ where
+		/ q_string:s   {* LiteralQuotedToken.new(s) *}
+		/ dq_string:s  {* LiteralToken.new(s) *}
+		/ charclass:s  {* LiteralCharset.new(s) *}
+		/ '.'          {* LiteralAny.new *}
+		/ other_call
+		/ '(' s or_set:r s ')'  {* r *}
+	
+	-var
+			':' var_name:n  {* n *}
+
+	-apply_rule
+			rule_name:r apply_args?:a  {*
+				if r == "super"
+					Super.new(a)
+				else
+					Apply.new(r, a || [])
+				end *}
+	
+	-other_call
+			grammar_name:g '.' rule_name:r apply_args?:a  {* Other.new(g, r, a || []) *}
+	
+	-apply_args
+			'(' (s var_name:x (',' s var_name)*:xs {*[x] + xs*})?:a ')'  {* a || [] *}
+	
+	-action
+			'{*' (!'*' . / '*' !'}' {*'*'*})+:s '*}'  {* Action.new(s.join) *}
+
+	-where
+			'?{*' (!'*' . / '*' !'}' {*'*'*})+:s '*}' {* Where.new(s.join) *}
+	
+	-rule_name
+			[a-z_]:x [a-zA-Z_0-9]*:xs  {* ([x] + xs).join *}
+	
+	-var_name
+			[a-z_]:x [a-zA-Z_0-9]*:xs  {* ([x] + xs).join *}
+	
+	-grammar_name
+			[A-Z]:x [a-zA-Z_0-9]*:xs  {* ([x] + xs).join *}
+	
+	-dq_string
+			'"' (!'"' . / '\"')+:s '"'   {* s.join *}
+	
+	-q_string
+			"'" (!"'" . / "\\'")+:s "'"  {* s.join *}
+	
+	-charclass
+			'[' (!']' . / '\]')+:s ']'   {* s.join *}
+	
+	-s
+			(comment / [ \t\r\n])*
+	
+	-fs
+			(comment / [ \t\r\n])+
+
+	-comment
+			'#' (!"\n" .)* "\n"
+}
+
+

data/lib/metal/boot.rb

@@ -0,0 +1,351 @@
+#
+# Metal Bootstrap Parser
+#
+# 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.
+#
+require 'metal/generator'
+
+class MetalParser < Metal::ParserBase
+include Metal::Generator
+def rule_main()
+m = apply(:meta)
+apply(:end)
+ m 
+end
+def rule_meta()
+xs = act_many(lambda{act_or([lambda{apply(:grammar)
+},
+lambda{apply(:meta_command)
+},
+])
+})
+apply(:s)
+ Meta.new(xs) 
+end
+def rule_meta_command()
+apply(:s)
+apply(:precode)
+end
+def rule_grammar()
+apply(:s)
+i = apply(:interface_attr)
+n = apply(:grammar_name)
+apply(:s)
+e = act_may(lambda{apply(:extend_attr)})
+apply(:s)
+act_token('{')
+b = apply(:grammar_body)
+act_token('}')
+ Grammar.new(n, b, e, i) 
+end
+def rule_interface_attr()
+act_or([lambda{act_token('module')
+apply(:fs)
+ true  
+},
+lambda{act_token('class')
+apply(:fs)
+ false 
+},
+lambda{ false 
+},
+])
+end
+def rule_extend_attr()
+act_token('<')
+apply(:s)
+apply(:grammar_name)
+end
+def rule_grammar_body()
+apply(:s)
+act_many(lambda{act_or([lambda{apply(:rule)
+},
+lambda{apply(:grammar_command)
+},
+])
+})
+end
+def rule_grammar_command()
+act_or([lambda{apply(:precode)
+},
+lambda{apply(:mixin)
+},
+])
+end
+def rule_precode()
+act_token('@{')
+s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('@')})
+rule_anything
+},
+lambda{act_token('@')
+act_not(lambda{act_token('}')})
+'@'
+},
+])
+})
+act_token('@}')
+apply(:s)
+ Precode.new(s.join) 
+end
+def rule_mixin()
+act_token('@include')
+apply(:fs)
+n = apply(:scoped_grammar_name)
+apply(:s)
+ Mixin.new(n) 
+end
+def rule_scoped_grammar_name()
+xs = act_many1(lambda{s = act_may(lambda{act_token('::')})
+n = apply(:grammar_name)
+"#{s}#{n}"
+})
+ xs.join 
+end
+def rule_rule()
+act_token('-')
+apply(:s)
+n = apply(:rule_name)
+a = apply(:rule_args)
+apply(:fs)
+r = apply(:or_set)
+apply(:s)
+ Rule.new(n, r, a) 
+end
+def rule_rule_args()
+act_many(lambda{apply(:s)
+act_token(':')
+apply(:var_name)
+})
+end
+def rule_or_set()
+x = apply(:and_set)
+apply(:s)
+xs = act_many(lambda{apply(:s)
+act_token('/')
+apply(:and_set)
+})
+ OrSet.new([x] + xs) 
+end
+def rule_and_set()
+apply(:s)
+xs = act_may(lambda{x = apply(:expr)
+xs = act_many(lambda{apply(:fs)
+apply(:expr)
+})
+[x]+xs
+})
+ AndSet.new(xs || []) 
+end
+def rule_expr()
+p = apply(:pred)
+p = act_may(lambda{apply(:iter,p)})
+v = act_may(lambda{apply(:var)})
+ Expression.new(p, v) 
+end
+def rule_pred()
+act_or([lambda{act_token('!')
+p = apply(:pred)
+ PredNot.new(p) 
+},
+lambda{act_token('&')
+f = apply(:literal)
+ PredLookahead.new(f) 
+},
+lambda{apply(:literal)
+},
+])
+end
+def rule_iter(x)
+act_or([lambda{act_token('*')
+ IterMany.new(x)  
+},
+lambda{act_token('+')
+ IterMany1.new(x) 
+},
+lambda{act_token('?')
+ IterMay.new(x) 
+},
+lambda{ x 
+},
+])
+end
+def rule_literal()
+act_or([lambda{apply(:apply_rule)
+},
+lambda{apply(:action)
+},
+lambda{apply(:where)
+},
+lambda{s = apply(:q_string)
+ LiteralQuotedToken.new(s) 
+},
+lambda{s = apply(:dq_string)
+ LiteralToken.new(s) 
+},
+lambda{s = apply(:charclass)
+ LiteralCharset.new(s) 
+},
+lambda{act_token('.')
+ LiteralAny.new 
+},
+lambda{apply(:other_call)
+},
+lambda{act_token('(')
+apply(:s)
+r = apply(:or_set)
+apply(:s)
+act_token(')')
+ r 
+},
+])
+end
+def rule_var()
+act_token(':')
+n = apply(:var_name)
+ n 
+end
+def rule_apply_rule()
+r = apply(:rule_name)
+a = act_may(lambda{apply(:apply_args)})
+
+				if r == "super"
+					Super.new(a)
+				else
+					Apply.new(r, a || [])
+				end 
+end
+def rule_other_call()
+g = apply(:grammar_name)
+act_token('.')
+r = apply(:rule_name)
+a = act_may(lambda{apply(:apply_args)})
+ Other.new(g, r, a || []) 
+end
+def rule_apply_args()
+act_token('(')
+a = act_may(lambda{apply(:s)
+x = apply(:var_name)
+xs = act_many(lambda{act_token(',')
+apply(:s)
+apply(:var_name)
+})
+[x] + xs
+})
+act_token(')')
+ a || [] 
+end
+def rule_action()
+act_token('{*')
+s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('*')})
+rule_anything
+},
+lambda{act_token('*')
+act_not(lambda{act_token('}')})
+''
+},
+])
+})
+act_token('*}')
+ Action.new(s.join) 
+end
+def rule_where()
+act_token('?{*')
+s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('*')})
+rule_anything
+},
+lambda{act_token('*')
+act_not(lambda{act_token('}')})
+''
+},
+])
+})
+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] + xs).join 
+end
+def rule_var_name()
+x = rule_charset(%[a-z_])
+xs = act_many(lambda{rule_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] + xs).join 
+end
+def rule_dq_string()
+act_token('"')
+s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token('"')})
+rule_anything
+},
+lambda{act_token('\"')
+},
+])
+})
+act_token('"')
+ s.join 
+end
+def rule_q_string()
+act_token("'")
+s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token("'")})
+rule_anything
+},
+lambda{act_token("\\'")
+},
+])
+})
+act_token("'")
+ s.join 
+end
+def rule_charclass()
+act_token('[')
+s = act_many1(lambda{act_or([lambda{act_not(lambda{act_token(']')})
+rule_anything
+},
+lambda{act_token('\]')
+},
+])
+})
+act_token(']')
+ s.join 
+end
+def rule_s()
+act_many(lambda{act_or([lambda{apply(:comment)
+},
+lambda{rule_charset(%[ \t\r\n])
+},
+])
+})
+end
+def rule_fs()
+act_many1(lambda{act_or([lambda{apply(:comment)
+},
+lambda{rule_charset(%[ \t\r\n])
+},
+])
+})
+end
+def rule_comment()
+act_token('#')
+act_many(lambda{act_not(lambda{act_token("\n")})
+rule_anything
+})
+act_token("\n")
+end
+end