melbourne 1.0.0

data/ext/melbourne/visitor.hpp

@@ -0,0 +1,20 @@
+#ifndef MEL_VISITOR_HPP
+#define MEL_VISITOR_HPP
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace melbourne {
+  rb_parse_state *alloc_parse_state();
+  void *pt_allocate(rb_parse_state *st, int size);
+  void pt_free(rb_parse_state *st);
+  void create_error(rb_parse_state *parse_state, char *msg);
+  NODE *node_newnode(rb_parse_state*, enum node_type, VALUE, VALUE, VALUE);
+};
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+#endif
+
+#endif

data/lib/melbourne/ast/constants.rb

@@ -0,0 +1,128 @@
+module Melbourne
+
+  module AST
+
+    # Access of a constant as in:
+    #
+    #   X::Y # (X is the accessed constant)
+    #
+    class ConstAccess < Node
+
+      # The parent node
+      #
+      attr_accessor :parent
+
+      # The name of the node
+      #
+      attr_accessor :name
+
+      def initialize(line, parent, name) #:nodoc:
+        @line = line
+        @parent = parent
+        @name = name
+      end
+
+    end
+
+    # A constant in the top level as in:
+    #
+    #   ::X
+    #
+    class ConstAtTop < Node
+
+      # The parent node
+      #
+      attr_accessor :parent
+
+      # The name of the node
+      #
+      attr_accessor :name
+
+      def initialize(line, name) #:nodoc:
+        @line = line
+        @name = name
+        @parent = TopLevel.new line
+      end
+
+    end
+
+    # The parent node of something on the lop level as in:
+    #
+    #   ::X # X is at the top level, it's parent is the top level itself
+    #
+    class TopLevel < Node
+
+    end
+
+    # Access of a constant within some other code node (the constant has to be found then) as in
+    #
+    #   def method
+    #     String
+    #   end
+    #
+    class ConstFind < Node
+  
+      # The name of the node
+      #
+      attr_accessor :name
+
+      def initialize(line, name) #:nodoc:
+        @line = line
+        @name = name
+      end
+
+    end
+
+    # Assignment of a value to a constant as in:
+    #
+    #   X = 42
+    #
+    class ConstSet < Node
+
+      # The parent node
+      #
+      attr_accessor :parent
+
+      # The name of the node
+      #
+      attr_accessor :name
+
+      # The value that is set
+      #
+      attr_accessor :name
+
+      def initialize(line, name, value) #:nodoc:
+        @line = line
+        @value = value
+        @parent = nil
+
+        if name.kind_of? Symbol
+          @name = ConstName.new line, name
+        else
+          @parent = name.parent
+          @name = ConstName.new line, name.name
+        end
+      end
+
+    end
+
+    # A constant's name in a constant's definition as in:
+    #
+    #   X = 42
+    #
+    class ConstName < Node
+
+      # The name of the node
+      #
+      attr_accessor :name
+
+      def initialize(line, name) #:nodoc:
+        @line = line
+        @name = name
+      end
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/control_flow.rb

@@ -0,0 +1,382 @@
+module Melbourne
+
+  module AST
+
+    # A +case+ statement as in
+    #
+    #   case
+    #     when a == 1 then
+    #       # something
+    #     when a == 2
+    #       # something
+    #   end
+    #
+    class Case < Node
+
+      # The +when+ nodes of the +case+ statement
+      #
+      attr_accessor :whens
+
+      # The +else+ node of the +case+ statement (or +nil+ if there is none)
+      #
+      attr_accessor :else
+
+      def initialize(line, whens, else_body) #:nodoc:
+        @line = line
+        @whens = whens
+        @else = else_body || Nil.new(line)
+      end
+
+    end
+
+    # A +case+ statement with a receiver as in:
+    #
+    #   case a
+    #     when 1 then
+    #       # something
+    #     when 2
+    #       # something
+    #   end
+    #
+    class ReceiverCase < Case
+
+      # The receiver of the +case+ statement
+      #
+      attr_accessor :receiver
+
+      def initialize(line, receiver, whens, else_body) #:nodoc:
+        @line = line
+        @receiver = receiver
+        @whens = whens
+        @else = else_body || Nil.new(line)
+      end
+
+    end
+
+    # A +when+ statement in a +case+ statement as in:
+    #
+    #   case a
+    #     when 1 then
+    #       # something
+    #     when 2
+    #       # something
+    #   end
+    #
+    class When < Node
+
+      # The conditions for which the +when+ statement is true or +nil+ if only a single value is specified
+      #
+      attr_accessor :conditions
+
+      # The body for the +when+ statement
+      #
+      attr_accessor :body
+
+      # The single value for the +when+ statement if only a single value is specified, +nil+ otherwise
+      #
+      attr_accessor :single
+
+      # Any splat (<tt>*something</tt>) that is specified as a condition for the +when+ statement or +nil+ of no splat is specified
+      #
+      attr_accessor :splat
+
+      def initialize(line, conditions, body) #:nodoc:
+        @line = line
+        @body = body || Nil.new(line)
+        @splat = nil
+        @single = nil
+
+        if conditions.kind_of? ArrayLiteral
+          if conditions.body.last.kind_of? When
+            last = conditions.body.pop
+            if last.conditions.kind_of? ArrayLiteral
+              conditions.body.concat last.conditions.body
+            elsif last.single
+              @splat = SplatWhen.new line, last.single
+            else
+              @splat = SplatWhen.new line, last.conditions
+            end
+          end
+
+          if conditions.body.size == 1 and !@splat
+            @single = conditions.body.first
+          else
+            @conditions = conditions
+          end
+        else
+          @conditions = conditions
+        end
+      end
+
+    end
+
+    # A splat (<tt>*something</tt>) inside a condition of a +when+ statement as in:
+    #
+    #   case a
+    #     when *c then
+    #       d
+    #   end
+    #
+    class SplatWhen < Node
+
+      # The actual content of the plat
+      #
+      attr_accessor :condition
+
+      def initialize(line, condition) #:nodoc:
+        @line = line
+        @condition = condition
+      end
+
+    end
+
+    # A flip statement as in:
+    #
+    #   1 if TRUE..FALSE
+    #
+    class Flip2 < Node
+
+      def initialize(line, start, finish) #:nodoc:
+        @line = line
+        @start = start
+        @finish = finish
+      end
+
+    end
+
+    # An end-exclusive flip statement as in:
+    #
+    #   1 if TRUE...FALSE
+    #
+    class Flip3 < Node
+
+      def initialize(line, start, finish) #:nodoc:
+        @line = line
+        @start = start
+        @finish = finish
+      end
+
+    end
+
+    # An +if+ statement as in:
+    #
+    #   a if true
+    #
+    class If < Node
+
+      # The condition of the +if+ statement
+      #
+      attr_accessor :condition
+
+      # The body of the +if+ statement (the code that is executed if the +condition+ evaluates to true)
+      #
+      attr_accessor :body
+
+      # The +else+ block of the +if+ statement (if there is one)
+      #
+      attr_accessor :else
+
+      def initialize(line, condition, body, else_body) #:nodoc:
+        @line = line
+        @condition = condition
+        @body = body || Nil.new(line)
+        @else = else_body || Nil.new(line)
+      end
+
+    end
+
+    # A +while+ statement as in:
+    #
+    #   i += 1 while go_on?
+    #
+    class While < Node
+
+      # The condition of the +while+ statement
+      #
+      attr_accessor :condition
+
+      # The body of the +while+ statement (the code that is executed if the +condition+ evaluates to true)
+      #
+      attr_accessor :body
+
+      # Whether to check the +while+ statement's condition before or after ths code in the +body+ is executed
+      #
+      attr_accessor :check_first
+
+      def initialize(line, condition, body, check_first) #:nodoc:
+        @line = line
+        @condition = condition
+        @body = body || Nil.new(line)
+        @check_first = check_first
+      end
+
+    end
+
+    # An +until+ statement as in:
+    #
+    #   i += 1 until stop?
+    #
+    class Until < While
+
+    end
+
+    # A regular expression match statement as in:
+    #
+    #   x =~ /x/
+    #
+    class Match < Node
+
+      # the regex pattern used for the match
+      #
+      attr_accessor :pattern
+
+      def initialize(line, pattern, flags) #:nodoc:
+        @line = line
+        @pattern = RegexLiteral.new line, pattern, flags
+      end
+
+    end
+
+    # A regular expression match statement with the regular expression pattern as the receiver as in:
+    #
+    #   /x/ =~ x
+    #
+    class Match2 < Node
+
+      # the regex pattern used for the match
+      #
+      attr_accessor :pattern
+
+      # the value that is matched against the +pattern+
+      #
+      attr_accessor :value
+
+      def initialize(line, pattern, value) #:nodoc:
+        @line = line
+        @pattern = pattern
+        @value = value
+      end
+
+    end
+
+    # A regular expression match statement where a String is matched against the pattern as in:
+    #
+    #   'some' =~ /x/
+    #
+    class Match3 < Node
+
+      # the regex pattern used for the match
+      #
+      attr_accessor :pattern
+
+      # the value that is matched against the +pattern+
+      #
+      attr_accessor :value
+
+      def initialize(line, pattern, value) #:nodoc:
+        @line = line
+        @pattern = pattern
+        @value = value
+      end
+
+    end
+
+    # A +break+ statement as in:
+    #
+    #   while true do
+    #     begin
+    #       x
+    #     rescue Exception => x
+    #       break
+    #     end
+    #   end
+    #
+    class Break < Node
+
+      # The value passed to +break+
+      #
+      attr_accessor :value
+
+      def initialize(line, expr) #:nodoc:
+        @line = line
+        @value = expr || Nil.new(line)
+      end
+
+    end
+
+    # A +next+ statement as in:
+    #
+    #   while true do
+    #     next if skip?(i)
+    #     i += 1
+    #   end
+    #
+    class Next < Break
+
+      def initialize(line, value) #:nodoc:
+        @line = line
+        @value = value
+      end
+
+    end
+
+    # A +redo+ statement as in:
+    #
+    #   while true do
+    #     begin
+    #       x
+    #     rescue Exception => x
+    #       redo
+    #     end
+    #   end
+    #
+    class Redo < Break
+
+      def initialize(line) #:nodoc:
+        @line = line
+      end
+
+    end
+
+    # A +redo+ statement as in:
+    #
+    #   while true do
+    #     begin
+    #       x
+    #     rescue Exception => x
+    #       try_to_fix()
+    #       retry
+    #     end
+    #   end
+    #
+    class Retry < Break
+
+      def initialize(line) #:nodoc:
+        @line = line
+      end
+
+    end
+
+    # A +return+ statement as in:
+    #
+    #   def method
+    #     return 3
+    #   end
+    #
+    class Return < Node
+
+      # The value passed to +return+
+      #
+      attr_accessor :value
+
+      def initialize(line, expr) #:nodoc:
+        @line = line
+        @value = expr
+        @splat = nil
+      end
+
+    end
+
+  end
+
+end

data/lib/melbourne/ast/data.rb

@@ -0,0 +1,19 @@
+module Melbourne
+
+  module AST
+
+    # TODO: document!
+    class EndData < Node #:nodoc:
+
+      attr_accessor :data
+
+      def initialize(line, data)
+        @line = line
+        @data = data
+      end
+
+    end
+
+  end
+
+end