sbyc 0.1.3 → 0.1.4

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

@@ -1,36 +1,38 @@
-module CodeTree
-  module FunctionalEval
+module SByC
+  module CodeTree
+    module FunctionalEval
     
-    # Generates code for a functional evaluation
-    def functional_compile(ast, receiver_object = "receiver", scope_object = "scope", scope_method = :[])
-      ast.visit{|node, collected|
-        case func = node.function
-          when :_
-            collected.first.inspect
-          when :'?'
-            if scope_method == :[]
-              "#{scope_object}[#{collected.join(', ')}]"
+      # Generates code for a functional evaluation
+      def functional_compile(ast, receiver_object = "receiver", scope_object = "scope", scope_method = :[])
+        ast.visit{|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
-              "#{scope_object}.#{scope_method}(#{collected.join(', ')})"
-            end
-          else
-            "#{receiver_object}.#{func}(#{collected.join(', ')})"
-        end
-      }
-    end
-    module_function :functional_compile
+              "#{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
+      # 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
+      # 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
+    end # module FunctionalEval
+  end # module CodeTree
+end # module SByC

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

@@ -1,36 +1,38 @@
-module CodeTree
-  module ObjectEval
+module SByC
+  module CodeTree
+    module ObjectEval
     
-    # Generates code for an object evaluation
-    def object_compile(ast, scope_object = "scope", scope_method = :[])
-      ast.visit{|node, collected|
-        case func = node.function
-          when :'_'
-            collected.first.inspect
-          when :'?'
-            if scope_method == :[]
-              "#{scope_object}[#{collected.join(', ')}]"
+      # Generates code for an object evaluation
+      def object_compile(ast, scope_object = "scope", scope_method = :[])
+        ast.visit{|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
-              "#{scope_object}.#{scope_method}(#{collected.join(', ')})"
-            end
-          else
-            "#{collected[0]}.#{func}(#{collected[1..-1].join(', ')})"
-        end
-      }
-    end
-    module_function :object_compile
+              "#{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
+      # 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
+      # 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
+    end # module ObjectEval
+  end # module CodeTree
+end # module SByC

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

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

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

@@ -1,30 +1,32 @@
-module CodeTree
-  class MatchData
+module SByC
+  module CodeTree
+    class MatchData
     
-    # Source AstNode of the matching
-    attr_reader :source
+      # Source AstNode of the matching
+      attr_reader :source
     
-    # Matched node
-    attr_reader :matched_node
+      # Matched node
+      attr_reader :matched_node
     
-    # Captured variables
-    attr_reader :captures
+      # Captured variables
+      attr_reader :captures
     
-    # Creates a MatchData instance
-    def initialize(source, matched_node, captures)
-      @source, @matched_node, @captures = source, matched_node, captures
-    end
+      # 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
+      # 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
+      # Inspects this MatchData
+      def inspect
+        "MatchData#{captures.inspect}"
+      end
+      alias :to_s :inspect
     
-  end # class MatchData
-end # module CodeTree
+    end # class MatchData
+  end # module CodeTree
+end # module SByC

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

@@ -1,83 +1,85 @@
-module CodeTree
-  class Matcher
+module SByC
+  module CodeTree
+    class Matcher
     
-    # Match Abstract Syntax Tree
-    attr_reader :match_ast
+      # 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
+      # Creates an IMatch instance
+      def initialize(match_ast)
+        @match_ast = match_ast
       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
+      # 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 :=~
     
-    # 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
+      # Returns true if _ast_node_ is matched by this matcher,
+      # false otherwise
+      def ===(ast_node)
+        not((self =~ ast_node).nil?)
+      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
+      # 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
-      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
+      #
+      # 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 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)
+            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
-      candidates.empty?
-    end
 
-  end # class Matcher
-end # module CodeTree
+    end # class Matcher
+  end # module CodeTree
+end # module SByC

data/lib/sbyc/codetree/name2x/delegate.rb

@@ -1,57 +1,59 @@
-module CodeTree
-  module Name2X
-    class Delegate
-      
-      # Hash delegate
-      attr_reader :delegate
-      
-      # Creates FromHash instance
-      def initialize(delegate)
-        @delegate = delegate
-      end
-      
-      # Converts an argument to a sub-class of this
-      # delegate implementation
-      def self.coerce(arg)
-        case arg
-          when Delegate
-            arg
-          when Hash, Proc
-            Delegate.new(arg)
-          when Module
-            ModuleDelegate.new(arg)
-          else
-            if arg.respond_to?(:[])
+module SByC
+  module CodeTree
+    module Name2X
+      class Delegate
+      
+        # Hash delegate
+        attr_reader :delegate
+      
+        # Creates FromHash instance
+        def initialize(delegate)
+          @delegate = delegate
+        end
+      
+        # Converts an argument to a sub-class of this
+        # delegate implementation
+        def self.coerce(arg)
+          case arg
+            when Delegate
+              arg
+            when Hash, Proc
               Delegate.new(arg)
+            when Module
+              ModuleDelegate.new(arg)
             else
-              raise ArgumentError, "Unable to convert #{arg} to a Name2X::Delegate", caller
-            end
+              if arg.respond_to?(:[])
+                Delegate.new(arg)
+              else
+                raise ArgumentError, "Unable to convert #{arg} to a Name2X::Delegate", caller
+              end
+          end
         end
-      end
-      
-      # Make a fetch on from_hash
-      def fetch(name)
-        delegate[name]
-      end
-      
-      # Convert a name to a module
-      def name2module(name)
-        result = fetch(name)
-        result.kind_of?(Module) ? result : nil
-      end
-      
-      # Convert a name to a class
-      def name2class(name)
-        result = fetch(name)
-        result.kind_of?(Class) ? result : nil
-      end
-      
-      # Convert a name to another name
-      def name2name(name)
-        result = fetch(name)
-        result.kind_of?(Symbol) ? result : nil
-      end
-      
-    end # class FromHash
-  end # module Name2X
-end # module CodeTree
+      
+        # Make a fetch on from_hash
+        def fetch(name)
+          delegate[name]
+        end
+      
+        # Convert a name to a module
+        def name2module(name)
+          result = fetch(name)
+          result.kind_of?(Module) ? result : nil
+        end
+      
+        # Convert a name to a class
+        def name2class(name)
+          result = fetch(name)
+          result.kind_of?(Class) ? result : nil
+        end
+      
+        # Convert a name to another name
+        def name2name(name)
+          result = fetch(name)
+          result.kind_of?(Symbol) ? result : nil
+        end
+      
+      end # class FromHash
+    end # module Name2X
+  end # module CodeTree
+end # module SByC