tenderlove-rkelly 0.0.0.20080909095845

data/lib/rkelly/visitors/function_visitor.rb

@@ -0,0 +1,46 @@
+module RKelly
+  module Visitors
+    class FunctionVisitor < Visitor
+      attr_reader :scope_chain
+      def initialize(scope)
+        super()
+        @scope_chain = scope
+      end
+
+      def visit_SourceElementsNode(o)
+        o.value.each { |x| x.accept(self) }
+      end
+
+      def visit_FunctionDeclNode(o)
+        if o.value
+          scope_chain[o.value].value = RKelly::JS::Function.new(o.function_body, o.arguments)
+        end
+      end
+
+      %w{
+        AddNode ArgumentsNode ArrayNode AssignExprNode BitAndNode BitOrNode
+        BitXOrNode BitwiseNotNode BlockNode BracketAccessorNode BreakNode
+        CaseBlockNode CaseClauseNode CommaNode ConditionalNode
+        ConstStatementNode ContinueNode DeleteNode DivideNode
+        DoWhileNode DotAccessorNode ElementNode EmptyStatementNode EqualNode
+        ExpressionStatementNode FalseNode ForInNode ForNode FunctionBodyNode
+        FunctionExprNode GetterPropertyNode GreaterNode GreaterOrEqualNode
+        IfNode InNode InstanceOfNode LabelNode LeftShiftNode LessNode
+        LessOrEqualNode LogicalAndNode LogicalNotNode LogicalOrNode ModulusNode
+        MultiplyNode NewExprNode NotEqualNode NotStrictEqualNode NullNode
+        NumberNode ObjectLiteralNode OpAndEqualNode OpDivideEqualNode
+        OpEqualNode OpLShiftEqualNode OpMinusEqualNode OpModEqualNode
+        OpMultiplyEqualNode OpOrEqualNode OpPlusEqualNode OpRShiftEqualNode
+        OpURShiftEqualNode OpXOrEqualNode ParameterNode PostfixNode PrefixNode
+        PropertyNode RegexpNode ResolveNode ReturnNode RightShiftNode
+        SetterPropertyNode StrictEqualNode StringNode
+        SubtractNode SwitchNode ThisNode ThrowNode TrueNode TryNode TypeOfNode
+        UnaryMinusNode UnaryPlusNode UnsignedRightShiftNode VarDeclNode
+        VarStatementNode VoidNode WhileNode WithNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+        end
+      end
+    end
+  end
+end

data/lib/rkelly/visitors/pointcut_visitor.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module Visitors
+    class PointcutVisitor < Visitor
+      attr_reader :matches
+      def initialize(pattern)
+        @pattern  = pattern
+        @matches  = []
+      end
+
+      ALL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          @matches << o if @pattern === o
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rkelly/visitors/sexp_visitor.rb

@@ -0,0 +1,374 @@
+module RKelly
+  module Visitors
+    class SexpVisitor < Visitor
+      def visit_NumberNode(o)
+        [:lit, o.value]
+      end
+
+      def visit_RegexpNode(o)
+        [:lit, o.value]
+      end
+
+      def visit_AssignExprNode(o)
+        [:assign, super]
+      end
+
+      def visit_VarDeclNode(o)
+        [ o.constant? ? :const_decl : :var_decl,
+          o.name.to_sym, o.value ? super(o) : nil]
+      end
+
+      def visit_VarStatementNode(o)
+        [:var, super]
+      end
+
+      def visit_PostfixNode(o)
+        [:postfix, super, o.value]
+      end
+
+      def visit_PrefixNode(o)
+        [:prefix, super, o.value]
+      end
+
+      def visit_DeleteNode(o)
+        [:delete, super]
+      end
+
+      def visit_VoidNode(o)
+        [:void, super]
+      end
+
+      def visit_TypeOfNode(o)
+        [:typeof, super]
+      end
+
+      def visit_UnaryPlusNode(o)
+        [:u_plus, super]
+      end
+
+      def visit_UnaryMinusNode(o)
+        [:u_minus, super]
+      end
+
+      def visit_BitwiseNotNode(o)
+        [:bitwise_not, super]
+      end
+
+      def visit_LogicalNotNode(o)
+        [:not, super]
+      end
+
+      def visit_ConstStatementNode(o)
+        [:const, super]
+      end
+
+      def visit_MultiplyNode(o)
+        [:multiply, *super]
+      end
+
+      def visit_DivideNode(o)
+        [:divide, *super]
+      end
+
+      def visit_ModulusNode(o)
+        [:modulus, *super]
+      end
+
+      def visit_AddNode(o)
+        [:add, *super]
+      end
+
+      def visit_LeftShiftNode(o)
+        [:lshift, *super]
+      end
+
+      def visit_RightShiftNode(o)
+        [:rshift, *super]
+      end
+
+      def visit_UnsignedRightShiftNode(o)
+        [:urshift, *super]
+      end
+
+      def visit_SubtractNode(o)
+        [:subtract, *super]
+      end
+
+      def visit_LessNode(o)
+        [:less, *super]
+      end
+
+      def visit_GreaterNode(o)
+        [:greater, *super]
+      end
+
+      def visit_LessOrEqualNode(o)
+        [:less_or_equal, *super]
+      end
+
+      def visit_GreaterOrEqualNode(o)
+        [:greater_or_equal, *super]
+      end
+
+      def visit_InstanceOfNode(o)
+        [:instance_of, *super]
+      end
+
+      def visit_EqualNode(o)
+        [:equal, *super]
+      end
+
+      def visit_NotEqualNode(o)
+        [:not_equal, *super]
+      end
+
+      def visit_StrictEqualNode(o)
+        [:strict_equal, *super]
+      end
+
+      def visit_NotStrictEqualNode(o)
+        [:not_strict_equal, *super]
+      end
+
+      def visit_BitAndNode(o)
+        [:bit_and, *super]
+      end
+
+      def visit_BitOrNode(o)
+        [:bit_or, *super]
+      end
+
+      def visit_BitXOrNode(o)
+        [:bit_xor, *super]
+      end
+
+      def visit_LogicalAndNode(o)
+        [:and, *super]
+      end
+
+      def visit_LogicalOrNode(o)
+        [:or, *super]
+      end
+
+      def visit_InNode(o)
+        [:in, *super]
+      end
+
+      def visit_DoWhileNode(o)
+        [:do_while, *super]
+      end
+
+      def visit_WhileNode(o)
+        [:while, *super]
+      end
+
+      def visit_WithNode(o)
+        [:with, *super]
+      end
+
+      def visit_CaseClauseNode(o)
+        [:case, *super]
+      end
+
+      def visit_CaseBlockNode(o)
+        [:case_block, super]
+      end
+
+      def visit_SwitchNode(o)
+        [:switch, *super]
+      end
+
+      def visit_ForNode(o)
+        [ :for, *super]
+      end
+
+      def visit_BlockNode(o)
+        [:block, super]
+      end
+
+      def visit_IfNode(o)
+        [:if, *super].compact
+      end
+
+      def visit_ConditionalNode(o)
+        [:conditional, *super]
+      end
+
+      def visit_ForInNode(o)
+        [ :for_in, *super]
+      end
+
+      def visit_TryNode(o)
+        [ :try, *super]
+      end
+
+      def visit_EmptyStatementNode(o)
+        [:empty]
+      end
+
+      def visit_FunctionBodyNode(o)
+        [:func_body, super]
+      end
+
+      def visit_ResolveNode(o)
+        [:resolve, o.value]
+      end
+
+      def visit_BracketAccessorNode(o)
+        [:bracket_access, *super]
+      end
+
+      def visit_NewExprNode(o)
+        [:new_expr, *super]
+      end
+
+      def visit_ParameterNode(o)
+        [:param, o.value]
+      end
+
+      def visit_BreakNode(o)
+        [:break, o.value].compact
+      end
+
+      def visit_ContinueNode(o)
+        [:continue, o.value].compact
+      end
+
+      def visit_LabelNode(o)
+        [:label, o.name, super]
+      end
+
+      def visit_ThrowNode(o)
+        [:throw, super]
+      end
+
+      def visit_ObjectLiteralNode(o)
+        [:object, super]
+      end
+
+      def visit_PropertyNode(o)
+        [ :property, o.name, super ]
+      end
+
+      def visit_GetterPropertyNode(o)
+        [ :getter, o.name, super ]
+      end
+
+      def visit_SetterPropertyNode(o)
+        [ :setter, o.name, super ]
+      end
+
+      def visit_ElementNode(o)
+        [:element, super ]
+      end
+
+      def visit_ExpressionStatementNode(o)
+        [:expression, super ]
+      end
+
+      def visit_OpEqualNode(o)
+        [:op_equal, *super ]
+      end
+
+      def visit_OpPlusEqualNode(o)
+        [:op_plus_equal, *super ]
+      end
+
+      def visit_OpMinusEqualNode(o)
+        [:op_minus_equal, *super ]
+      end
+
+      def visit_OpMultiplyEqualNode(o)
+        [:op_multiply_equal, *super ]
+      end
+
+      def visit_OpDivideEqualNode(o)
+        [:op_divide_equal, *super]
+      end
+
+      def visit_OpLShiftEqualNode(o)
+        [:op_lshift_equal, *super ]
+      end
+
+      def visit_OpRShiftEqualNode(o)
+        [:op_rshift_equal, *super ]
+      end
+
+      def visit_OpURShiftEqualNode(o)
+        [:op_urshift_equal, *super ]
+      end
+
+      def visit_OpAndEqualNode(o)
+        [:op_and_equal, *super ]
+      end
+
+      def visit_OpXOrEqualNode(o)
+        [:op_xor_equal, *super ]
+      end
+
+      def visit_OpOrEqualNode(o)
+        [:op_or_equal, *super ]
+      end
+
+      def visit_OpModEqualNode(o)
+        [:op_mod_equal, *super]
+      end
+
+      def visit_CommaNode(o)
+        [:comma, *super]
+      end
+
+      def visit_FunctionCallNode(o)
+        [:function_call, *super]
+      end
+
+      def visit_ArrayNode(o)
+        [:array, super]
+      end
+
+      def visit_ThisNode(o)
+        [:this]
+      end
+
+      def visit_ReturnNode(o)
+        o.value ? [:return, super] : [:return]
+      end
+
+      def visit_FunctionExprNode(o)
+        [ :func_expr, *super]
+      end
+
+      def visit_FunctionDeclNode(o)
+        [ :func_decl, *super]
+      end
+
+      def visit_ArgumentsNode(o)
+        [:args, super]
+      end
+
+      def visit_DotAccessorNode(o)
+        [:dot_access,
+          super,
+          o.accessor
+        ]
+      end
+
+      def visit_NullNode(o)
+        [:nil]
+      end
+      
+      def visit_StringNode(o)
+        [:str, o.value]
+      end
+
+      def visit_FalseNode(o)
+        [:false]
+      end
+
+      def visit_TrueNode(o)
+        [:true]
+      end
+
+    end
+  end
+end

data/lib/rkelly/visitors/visitor.rb

@@ -0,0 +1,136 @@
+module RKelly
+  module Visitors
+    class Visitor
+      TERMINAL_NODES = %w{
+        Break Continue EmptyStatement False Null Number Parameter Regexp Resolve
+        String This True
+      }
+      SINGLE_VALUE_NODES = %w{
+        AssignExpr BitwiseNot Block Delete Element ExpressionStatement
+        FunctionBody LogicalNot Return Throw TypeOf UnaryMinus UnaryPlus Void
+      }
+      BINARY_NODES = %w{
+        Add BitAnd BitOr BitXOr CaseClause Comma Divide DoWhile Equal Greater
+        GreaterOrEqual In InstanceOf LeftShift Less LessOrEqual LogicalAnd
+        LogicalOr Modulus Multiply NotEqual NotStrictEqual OpAndEqual
+        OpDivideEqual OpEqual OpLShiftEqual OpMinusEqual OpModEqual
+        OpMultiplyEqual OpOrEqual OpPlusEqual OpRShiftEqual OpURShiftEqual
+        OpXOrEqual RightShift StrictEqual Subtract Switch UnsignedRightShift
+        While With
+      }
+      ARRAY_VALUE_NODES = %w{
+        Arguments Array CaseBlock ConstStatement ObjectLiteral SourceElements
+        VarStatement
+      }
+      NAME_VALUE_NODES = %w{
+        Label Property GetterProperty SetterProperty VarDecl
+      }
+      PREFIX_POSTFIX_NODES  = %w{ Postfix Prefix }
+      CONDITIONAL_NODES     = %w{ If Conditional }
+      FUNC_CALL_NODES       = %w{ NewExpr FunctionCall }
+      FUNC_DECL_NODES       = %w{ FunctionExpr FunctionDecl }
+      ALL_NODES = %w{ For ForIn Try BracketAccessor DotAcessor } +
+        TERMINAL_NODES + SINGLE_VALUE_NODES + BINARY_NODES + ARRAY_VALUE_NODES +
+        NAME_VALUE_NODES + PREFIX_POSTFIX_NODES + CONDITIONAL_NODES +
+        FUNC_CALL_NODES + FUNC_DECL_NODES
+
+      def accept(target)
+        target.accept(self)
+      end
+
+      TERMINAL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") { |o| }
+      end
+
+      BINARY_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.left && o.left.accept(self), o.value && o.value.accept(self)]
+        end
+      end
+
+      ARRAY_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.value && o.value.map { |v| v ? v.accept(self) : nil }
+        end
+      end
+
+      NAME_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          return o.value ? o.value.accept(self) : nil
+        end
+      end
+
+      SINGLE_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.value.accept(self) if o.value
+        end
+      end
+
+      PREFIX_POSTFIX_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.operand.accept(self)
+        end
+      end
+
+      CONDITIONAL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [ o.conditions.accept(self),
+            o.value.accept(self),
+            o.else ? o.else.accept(self) : nil
+          ]
+        end
+      end
+      FUNC_CALL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.value.accept(self), o.arguments.accept(self)]
+        end
+      end
+      FUNC_DECL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [
+            o.value ? o.value : nil,
+            o.arguments.map { |x| x.accept(self) },
+            o.function_body.accept(self)
+          ]
+        end
+      end
+
+      def visit_ForNode(o)
+        [
+          o.init ? o.init.accept(self) : nil,
+          o.test ? o.test.accept(self) : nil,
+          o.counter ? o.counter.accept(self) : nil,
+          o.value.accept(self)
+        ]
+      end
+
+      def visit_ForInNode(o)
+        [
+          o.left.accept(self),
+          o.right.accept(self),
+          o.value.accept(self)
+        ]
+      end
+
+      def visit_TryNode(o)
+        [
+          o.value.accept(self),
+          o.catch_var ? o.catch_var : nil,
+          o.catch_block ? o.catch_block.accept(self) : nil,
+          o.finally_block ? o.finally_block.accept(self) : nil
+        ]
+      end
+
+      def visit_BracketAccessorNode(o)
+        [
+          o.value.accept(self),
+          o.accessor.accept(self)
+        ]
+      end
+
+      def visit_DotAccessorNode(o)
+        o.value.accept(self)
+      end
+    end
+  end
+end