sbyc 0.1.0

data/LICENCE.textile

@@ -0,0 +1,12 @@
+h1. The MIT License
+
+Copyright (c) 2009 Bernard Lambeau and the University of Louvain (Universite Catholique de Louvain, Louvain-la-Neuve, Belgium)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.textile

@@ -0,0 +1,44 @@
+h1. SByC - Investigating Specialization by Constraint
+
+h2. SYNOPSIS
+
+SByC is an investigation about Specialization by Constraint as an alternative to common type systems that we found in (object-oriented) programming languages. The library is written as a collection of Ruby tools described below. Those tools are in fact sub-gems of SByC that can often be used in isolation.
+
+h2. CodeTree
+
+This part of SByC provides a safe, reusable, extensible, mashallable, and non-intrusive (no monkey patching of Ruby core classes) implementation of block expressions. Block expressions are parsed using a generic DSL and converted to a parse tree, which may be analyzed, rewrited, compiled, and so on. The example below illustrates typical usage of CodeTree.
+
+<pre>
+code = CodeTree::parse{ x > 10 & y < 20 }   
+# => (& (> x, 10), (< y, 20))
+
+# See the evaluation section for details
+code.eval{:x => 5, :y => 5}                
+# => true
+
+# See the code-generation section for details
+code.object_compile('scope', :[])          
+# => "scope[:x].>(10) & scope[:y].<(20)"
+
+# CodeTree expressions may be marshaled
+Marshal.dump(code)
+</pre>
+
+"Learn more about CodeTree":http://blambeau.github.com/sbyc/codetree.html
+
+h2. INSTALL
+
+bc. gem install sbyc
+
+h2. DOCUMENTATION
+
+* The official documentation can be found on "GitHub pages":http://blambeau.github.com/sbyc/
+* The api documentation can be found on "rdoc.info":http://rdoc.info/projects/blambeau/sbyc
+
+h2. CONTRIBUTE
+
+Fork the project on "github":http://github.com/blambeau/sbyc, make a contrib, and send me a pull request
+
+h2. CREDITS
+
+SByC (c) 2010 by Bernard Lambeau. SByC is distributed under the MIT licence. Please see the LICENCE.md document for details.

data/lib/sbyc.rb

@@ -0,0 +1,14 @@
+module SByC
+
+  # Version
+  VERSION = "0.1.0".freeze
+  
+  # Provides tools around functional source code trees.
+  module CodeTree
+    
+  end # module CodeTree
+  
+end # module SByC
+
+CodeTree = ::SByC::CodeTree
+require 'sbyc/codetree'

data/lib/sbyc/codetree.rb

@@ -0,0 +1,82 @@
+module CodeTree
+  
+  # Operator names
+  OPERATOR_NAMES = {
+    :[]  => :get,
+    :[]= => :set,
+    :**  => :exponentiation,
+    :~   => :complement,
+    :==  => :eq,
+    #:!=  => :neq,
+    :-@  => :unary_minus,
+    :+@  => :unary_plus,
+    :-   => :minus,
+    :+   => :plus,
+    :*   => :times,
+    :/   => :divide,
+    :%   => :modulo,
+    :=~  => :match,
+    :=== => :matches?,
+    :&   => :bool_and,
+    :|   => :bool_or,
+    :>   => :gt,
+    :>=  => :gte,
+    :<=  => :lte,
+    :<   => :lt,
+    :>>  => :right_shift,
+    :<<  => :left_shift,
+    :'^' => :exclusive,
+    :<=> => :compare
+  }
+  REVERSE_OPERATOR_NAMES = Hash[*OPERATOR_NAMES.to_a.collect{|c| c.reverse}.flatten]
+  
+  # Parses some code or block
+  def parse(code = nil, &block)
+    ProcParser::parse(code, &block)
+  end
+  module_function :parse
+  
+  # Alias for _parse_
+  def expr(code = nil, &block)
+    ProcParser::parse(code, &block)
+  end
+  module_function :expr
+  
+  # Factors a CodeTree::Matcher instance
+  def matcher(code = nil, &block)
+    CodeTree::Matcher.new(parse(code, &block))
+  end
+  module_function :matcher
+  
+  # Factors a rewriter instance
+  def rewriter(&definition)
+    CodeTree::Rewriting::Rewriter.new(&definition)
+  end
+  module_function :rewriter
+  
+  # Factors a producer instance
+  def producer(default_rules = true, &definition)
+    CodeTree::Producing::Producer.new(default_rules, &definition)
+  end
+  module_function :producer
+  
+  # Converts an argument to an parse tree (an ASTNode instance)
+  def coerce(arg)
+    case arg
+      when AstNode
+        arg
+      when Proc, String
+        CodeTree::parse(arg)
+      else
+        raise "Unable to coerce #{arg.inspect} to a CodeTree::AstNode"
+    end
+  end
+  module_function :coerce
+  
+end # module CodeTree
+require 'sbyc/codetree/ast_node'
+require 'sbyc/codetree/proc_parser'
+require 'sbyc/codetree/eval'
+require 'sbyc/codetree/producing'
+require 'sbyc/codetree/matching'
+require 'sbyc/codetree/rewriting'

data/lib/sbyc/codetree/ast_node.rb

@@ -0,0 +1,101 @@
+module CodeTree
+  class AstNode
+    include Enumerable
+    
+    # Name of the method call
+    attr_reader :name
+    alias :function :name
+
+    # Children nodes
+    attr_reader :children
+    alias :args :children
+
+    # Operator found by type checking
+    attr_reader :operator
+    
+    # Creates an ASTNode instance
+    def initialize(name, children)
+      @name, @children = name, children
+    end
+    
+    # Delegated to the children array
+    def [](*args, &block)
+      children.[](*args, &block)
+    end
+    
+    # Recursively finds the first literal.
+    def literal
+      leaf? ? children[0] : children[0].literal
+    end
+  
+    # Returns false
+    def leaf?
+      (name == :_)
+    end
+  
+    # Negation of leaf?
+    def branch?
+      not(leaf?)
+    end
+  
+    # Yields block with each child in turn  
+    def each(&block)
+      children.each(&block)
+    end
+    
+    # Makes a depth-first-search visit of the AST
+    def visit(&block)
+      yield(self, leaf? ? children : children.collect{|c| c.visit(&block)})
+    end
+    alias :produce :visit
+    
+    # Inspection
+    def inspect
+      "(#{name} #{children.collect{|c| c.inspect}.join(', ')})"
+    end
+    
+    # Returns a short string representation
+    def to_s
+      case function
+        when :'_'
+          literal.inspect
+        when :'?'
+          literal.to_s
+        else
+          "(#{name} #{children.collect{|c| c.to_s}.join(', ')})"
+      end
+    end
+    
+    # Returns an array version of this ast
+    def to_a
+      visit{|node, collected| [node.name, collected]}
+    end
+    
+    # Checks tree equality with another node 
+    def ==(other)
+      return false unless other.kind_of?(AstNode)
+      return false unless (function == other.function)
+      return false unless args.size == other.args.size
+      return false unless args.zip(other.args).all?{|v1, v2| v1 == v2}
+      true
+    end
+    
+    # Coercion
+    def self.coerce(arg)
+      case arg
+        when AstNode
+          arg
+        when Array
+          name, children = arg
+          if name == :_ and children.size == 1
+            AstNode.new(:_, children)
+          else
+            AstNode.new(name, children.collect{|c| AstNode.coerce(c)})
+          end
+        else
+          AstNode.new(:_, [ arg ])
+      end
+    end
+    
+  end # module AstNode
+end # module CodeTree

data/lib/sbyc/codetree/eval.rb

@@ -0,0 +1,3 @@
+require 'sbyc/codetree/eval/object_eval'
+require 'sbyc/codetree/eval/functional_eval'
+require 'sbyc/codetree/eval/ast_node_ext'

data/lib/sbyc/codetree/eval/ast_node_ext.rb

@@ -0,0 +1,38 @@
+module CodeTree
+  class AstNode
+    
+    # Generates the code of an object evaluation
+    def object_compile(scope_object = "scope", scope_method = :[])
+      CodeTree::ObjectEval.object_compile(self, scope_object, scope_method)
+    end
+    
+    # Generates a lambda function for object evaluation
+    def object_proc(scope_method = :[])
+      CodeTree::ObjectEval.object_proc(self, scope_method)
+    end
+    
+    # Executes object evaluation of this ast
+    def object_eval(scope = {}, scope_method = :[])
+      CodeTree::ObjectEval.object_eval(self, scope)
+    end
+    alias :call :object_eval
+    alias :eval :object_eval
+    
+    # Generates the code of an functional evaluation
+    def functional_compile(receiver_object = "receiver", scope_object = "scope", scope_method = :[])
+      CodeTree::FunctionalEval.functional_compile(self, receiver_object, scope_object, scope_method)
+    end
+    
+    # Generates a lambda function for functional evaluation
+    def functional_proc(scope_method = :[])
+      CodeTree::FunctionalEval.functional_proc(self, scope_method)
+    end
+    
+    # Executes functional evaluation of this ast
+    def functional_eval(master_object, scope = {}, scope_method = :[]) 
+      CodeTree::FunctionalEval.functional_eval(self, master_object, scope)
+    end
+    alias :apply :functional_eval
+    
+  end # class AstNode
+end # module CodeTree

data/lib/sbyc/codetree/eval/functional_eval.rb

@@ -0,0 +1,36 @@
+module CodeTree
+  module FunctionalEval
+    
+    # Generates code for a functional evaluation
+    def functional_compile(ast, receiver_object = "receiver", scope_object = "scope", scope_method = :[])
+      ast.produce{|node, collected|
+        case func = node.function
+          when :_
+            collected.first.inspect
+          when :'?'
+            if scope_method == :[]
+              "#{scope_object}[#{collected.join(', ')}]"
+            else
+              "#{scope_object}.#{scope_method}(#{collected.join(', ')})"
+            end
+          else
+            "#{receiver_object}.#{func}(#{collected.join(', ')})"
+        end
+      }
+    end
+    module_function :functional_compile
+    
+    # Generates a lambda function for functional evaluation
+    def functional_proc(ast, scope_method = :[])
+      ::Kernel.eval("::Kernel.lambda{|receiver, scope| #{functional_compile(ast, 'receiver', 'scope', scope_method)}}")
+    end
+    module_function :functional_proc
+    
+    # Evaluates this AST with an object style.
+    def functional_eval(ast, receiver, scope = {}, scope_method = :[]) 
+      functional_proc(ast, scope_method).call(receiver, scope)
+    end
+    module_function :functional_eval
+  
+  end # module FunctionalEval
+end # module CodeTree

data/lib/sbyc/codetree/eval/object_eval.rb

@@ -0,0 +1,36 @@
+module CodeTree
+  module ObjectEval
+    
+    # Generates code for an object evaluation
+    def object_compile(ast, scope_object = "scope", scope_method = :[])
+      ast.produce{|node, collected|
+        case func = node.function
+          when :'_'
+            collected.first.inspect
+          when :'?'
+            if scope_method == :[]
+              "#{scope_object}[#{collected.join(', ')}]"
+            else
+              "#{scope_object}.#{scope_method}(#{collected.join(', ')})"
+            end
+          else
+            "#{collected[0]}.#{func}(#{collected[1..-1].join(', ')})"
+        end
+      }
+    end
+    module_function :object_compile
+    
+    # Generates a lambda function for object evaluation
+    def object_proc(ast, scope_method = :[])
+      ::Kernel.eval "::Kernel.lambda{|scope| #{object_compile(ast, 'scope', scope_method)}}"
+    end
+    module_function :object_proc
+    
+    # Evaluates this AST with an object style.
+    def object_eval(ast, scope = {}, scope_method = :[]) 
+      object_proc(ast, scope_method).call(scope)
+    end
+    module_function :object_eval
+  
+  end # module ObjectEval
+end # module CodeTree

data/lib/sbyc/codetree/matching.rb

@@ -0,0 +1,3 @@
+require 'sbyc/codetree/matching/matcher'
+require 'sbyc/codetree/matching/match_data'
+require 'sbyc/codetree/matching/ast_node_ext'

data/lib/sbyc/codetree/matching/ast_node_ext.rb

@@ -0,0 +1,14 @@
+module CodeTree
+  class AstNode
+    
+    # Applies ast node matching
+    def ===(other)
+      if other.kind_of?(CodeTree::AstNode)
+        CodeTree::Matcher.new(self) === other
+      else
+        super
+      end
+    end
+    
+  end # class AstNode
+end # module CodeTree

data/lib/sbyc/codetree/matching/match_data.rb

@@ -0,0 +1,30 @@
+module CodeTree
+  class MatchData
+    
+    # Source AstNode of the matching
+    attr_reader :source
+    
+    # Matched node
+    attr_reader :matched_node
+    
+    # Captured variables
+    attr_reader :captures
+    
+    # Creates a MatchData instance
+    def initialize(source, matched_node, captures)
+      @source, @matched_node, @captures = source, matched_node, captures
+    end
+    
+    # Returns node matched under a given variable name
+    def [](varname)
+      captures[varname]
+    end
+    
+    # Inspects this MatchData
+    def inspect
+      "MatchData#{captures.inspect}"
+    end
+    alias :to_s :inspect
+    
+  end # class MatchData
+end # module CodeTree

data/lib/sbyc/codetree/matching/matcher.rb

@@ -0,0 +1,83 @@
+module CodeTree
+  class Matcher
+    
+    # Match Abstract Syntax Tree
+    attr_reader :match_ast
+    
+    # Creates an IMatch instance
+    def initialize(match_ast)
+      @match_ast = match_ast
+    end
+    
+    # Looks for a match against some ast node
+    def =~(ast_node)
+      if captures = do_match(match_ast, ast_node)
+        CodeTree::MatchData.new(ast_node, ast_node, captures)
+      else
+        nil
+      end
+    end
+    alias :match :=~
+    alias :call :=~
+    
+    # Returns true if _ast_node_ is matched by this matcher,
+    # false otherwise
+    def ===(ast_node)
+      not((self =~ ast_node).nil?)
+    end
+    
+    # Lookups for a match between _matcher_ and _matched_.
+    def do_match(matcher, matched, match_data = {})
+      return nil unless matched.kind_of?(CodeTree::AstNode)
+      return nil unless function_match(matcher, matched, match_data)
+      return nil unless args_match(matcher.args[1..-1], matched.args.dup, match_data)
+      return match_data
+    end
+    
+    #
+    # Applies function name matching, returning true if _ast_node_'s function name
+    # is matched by first argument of _match_ast_.
+    #
+    # Cases that may arise:
+    #   (match (_ :fname), ...)   # true iif ast_node.function == fname
+    #   (match (? (_ :x)), ...)   # true and match_data[x] = ast_node.function
+    #   false otherwise
+    #
+    def function_match(match_ast, ast_node, match_data = {})
+      case fname = match_ast[0].function
+        when :'_'
+          return (match_ast[0].literal == ast_node.function ? true : false)
+        when :'?'
+          match_data[match_ast[0].literal] = ast_node.function
+          return true
+      end
+      false
+    end
+    
+    # 
+    # Applies arguments matching, return true if there is a match,
+    # false otherwise.
+    #
+    def args_match(matchers, candidates, match_data = {})
+      matchers.each do |m|
+        case m.function
+          when :'?'
+            return false if candidates.empty?
+            match_data[m.literal] = candidates.shift
+          when :'_'
+            return false if candidates.empty?
+            return false unless candidates.shift.literal == m.literal
+          when :'[]'
+            return false if candidates.empty?
+            match_data[m.literal] = candidates
+            candidates = []
+          else
+            return false if candidates.empty?
+            return false unless do_match(m, candidates.shift, match_data)
+        end
+      end
+      candidates.empty?
+    end
+
+  end # class Matcher
+end # module CodeTree