gobstones 0.0.1.1

data/lib/gobstones/lang/definitions/return_from_function.rb

@@ -0,0 +1,22 @@
+module Gobstones
+
+  module Lang
+
+    class ReturnFromFunction
+
+      attr_reader :expressions
+
+      def initialize(expressions)
+        @expressions = expressions
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.expressions == other.expressions
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/definitions/return_from_main.rb

@@ -0,0 +1,22 @@
+module Gobstones
+
+  module Lang
+
+    class ReturnFromMain
+
+      attr_reader :var_tuple
+
+      def initialize(var_tuple)
+        @var_tuple = var_tuple
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.var_tuple == other.var_tuple
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/definitions/var_tuple.rb

@@ -0,0 +1,26 @@
+module Gobstones
+
+  module Lang
+
+    class VarTuple
+
+      attr_reader :variables
+
+      def initialize(variables)
+        @variables = variables
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.variables == other.variables
+      end
+
+      def length
+        variables.length
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/all.rb

@@ -0,0 +1,8 @@
+require 'gobstones/lang/expressions/arithmetic_expressions'
+require 'gobstones/lang/expressions/boolean_expressions'
+require 'gobstones/lang/expressions/comparison_expressions'
+require 'gobstones/lang/expressions/function_call'
+require 'gobstones/lang/expressions/parentheses_expression'
+require 'gobstones/lang/expressions/primitive_functions'
+require 'gobstones/lang/expressions/type_bound_functions'
+require 'gobstones/lang/expressions/var_name'

data/lib/gobstones/lang/expressions/arithmetic_expressions.rb

@@ -0,0 +1,52 @@
+require 'gobstones/lang/expressions/two_arg_expression'
+require 'gobstones/runner/errors/gobstones_runtime_error'
+
+module Gobstones
+
+  module Lang
+
+    class Add < TwoArgExpression
+
+      evaluates_with :+
+
+    end
+
+    class Sub < TwoArgExpression
+
+      evaluates_with :-
+
+    end
+
+    class Mul < TwoArgExpression
+
+      evaluates_with :*
+
+    end
+
+    class Div < TwoArgExpression
+
+      def evaluate(context=nil)
+        begin
+          left_expr.evaluate(context) / right_expr.evaluate(context)
+        rescue ZeroDivisionError
+          raise Gobstones::Runner::GobstonesRuntimeError, 'zero division'
+        end
+      end
+
+    end
+
+    class Mod < TwoArgExpression
+
+      evaluates_with :%
+
+    end
+
+    class Pow < TwoArgExpression
+
+      evaluates_with :**
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/boolean_expressions.rb

@@ -0,0 +1,29 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+
+module Gobstones
+
+  module Lang
+
+    class Not < OneArgExpression
+
+      def evaluate
+        arg.evaluate.not
+      end
+
+    end
+
+    class And < TwoArgExpression
+
+      evaluates_with :and
+
+    end
+
+    class Or < TwoArgExpression
+
+      evaluates_with :or
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/comparison_expressions.rb

@@ -0,0 +1,45 @@
+require 'gobstones/lang/expressions/two_arg_expression'
+
+module Gobstones
+
+  module Lang
+
+    class Equal < TwoArgExpression
+
+      evaluates_with :equal
+
+    end
+
+    class NotEqual < TwoArgExpression
+
+      evaluates_with :not_equal
+
+    end
+
+    class LessThan < TwoArgExpression
+
+      evaluates_with :less_than
+
+    end
+
+    class LessEqual < TwoArgExpression
+
+      evaluates_with :less_equal
+
+    end
+
+    class GreaterEqual < TwoArgExpression
+
+      evaluates_with :greater_equal
+
+    end
+
+    class GreaterThan < TwoArgExpression
+
+      evaluates_with :greater_than
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/function_call.rb

@@ -0,0 +1,15 @@
+require 'gobstones/lang/definitions/definition_call'
+
+module Gobstones
+
+  module Lang
+
+    class FunctionCall
+
+      include DefinitionCall
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/one_arg_expression.rb

@@ -0,0 +1,21 @@
+module Gobstones
+
+  module Lang
+
+    class OneArgExpression
+
+      attr_reader :arg
+
+      def initialize(arg)
+        @arg = arg
+      end
+
+      def ==(other)
+        self.class == other.class && arg == other.arg
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/parentheses_expression.rb

@@ -0,0 +1,13 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+
+module Gobstones
+
+  module Lang
+
+    class ParenthesesExpr < OneArgExpression
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/primitive_functions.rb

@@ -0,0 +1,68 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+require 'gobstones/extensions/boolean'
+require 'gobstones/extensions/fixnum'
+require 'gobstones/type_check_result'
+
+module Gobstones
+
+  module Lang
+
+    class NroBolitas < OneArgExpression
+
+      def evaluate(context)
+        context.head.number_of_balls(arg.evaluate(context)).to_gbs_num
+      end
+
+    end
+
+    class HayBolitas < OneArgExpression
+
+      def evaluate(context)
+        context.head.are_there_balls?(arg.evaluate(context)).to_gbs_bool
+      end
+
+    end
+
+    class PuedeMover < OneArgExpression
+
+      def evaluate(context)
+        context.head.can_move?(arg.evaluate(context)).to_gbs_bool
+      end
+
+      def arg_type
+        :Direction
+      end
+
+      def type_check
+        Gobstones::TypeCheckResult.new arg_type, arg.return_type
+      end
+
+    end
+
+    class Siguiente < OneArgExpression
+
+      def evaluate(context=nil)
+        arg.evaluate(context).next
+      end
+
+    end
+
+    class Previo < OneArgExpression
+
+      def evaluate(context=nil)
+        arg.evaluate(context).previous
+      end
+
+    end
+
+    class Opuesto < OneArgExpression
+
+      def evaluate(context=nil)
+        arg.evaluate(context).opposite
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/two_arg_expression.rb

@@ -0,0 +1,34 @@
+module Gobstones
+
+  module Lang
+
+    class TwoArgExpression
+
+      attr_reader :left_expr, :right_expr
+
+      def self.evaluates_with(selector)
+        instance_eval do
+          define_method :evaluate do |*args|
+            context = args.first
+            left_expr.evaluate(context)
+              .send(selector, right_expr.evaluate(context))
+          end
+        end
+      end
+
+      def initialize(left, right)
+        @left_expr = left
+        @right_expr = right
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          self.left_expr == other.left_expr &&
+          self.right_expr == other.right_expr
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/type_bound_functions.rb

@@ -0,0 +1,66 @@
+require 'gobstones/lang/literals/booleans'
+require 'gobstones/lang/literals/colors'
+require 'gobstones/lang/literals/directions'
+require 'gobstones/modules/equal_by_class'
+
+module Gobstones
+
+  module Lang
+
+    class TypeBoundFunc
+
+      include Gobstones::EqualByClass
+
+    end
+
+    class MinBool < TypeBoundFunc
+
+      def evaluate(context=nil)
+        False.new
+      end
+
+    end
+
+    class MaxBool < TypeBoundFunc
+
+      def evaluate(context=nil)
+        True.new
+      end
+
+    end
+
+    class MinColor < TypeBoundFunc
+
+      def evaluate(context=nil)
+        Azul.new
+      end
+
+    end
+
+    class MaxColor < TypeBoundFunc
+
+      def evaluate(context=nil)
+        Verde.new
+      end
+
+    end
+
+    class MinDir < TypeBoundFunc
+
+      def evaluate(context=nil)
+        Norte.new
+      end
+
+    end
+
+    class MaxDir < TypeBoundFunc
+
+      def evaluate(context=nil)
+        Oeste.new
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/expressions/var_name.rb

@@ -0,0 +1,31 @@
+module Gobstones
+
+  module Lang
+
+    class VarName
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def ==(var)
+        self.class == var.class && self.name == var.name
+      end
+
+      alias eql? ==
+
+      def hash
+        @name.hash
+      end
+
+      def evaluate(context)
+        context.get self
+      end
+
+    end
+
+  end
+
+end