gobstones 0.0.1.1

data/lib/gobstones/lang/commands/ir_al_origen_cmd.rb

@@ -0,0 +1,19 @@
+require 'gobstones/modules/equal_by_class'
+
+module Gobstones
+
+  module Lang
+
+    class IrAlOrigen
+
+      include Gobstones::EqualByClass
+
+      def evaluate(context)
+        context.head.go_to_origin
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/mover_cmd.rb

@@ -0,0 +1,25 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+
+module Gobstones
+
+  module Lang
+
+    class Mover < OneArgExpression
+
+      def evaluate(context)
+        context.head.move arg.evaluate(context)
+      end
+
+      def undo(context)
+        opposite.evaluate context
+      end
+
+      def opposite
+        Mover.new arg.opposite
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/poner_cmd.rb

@@ -0,0 +1,31 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+require 'gobstones/lang/commands/sacar_cmd'
+require 'gobstones/runner/errors/gobstones_type_error'
+
+module Gobstones
+
+  module Lang
+
+    class Poner < OneArgExpression
+
+      def evaluate(context)
+        context.head.put arg.evaluate(context)
+      rescue RuntimeError => e
+        raise Gobstones::Runner::GobstonesTypeError, e.message
+      end
+
+      def undo(context)
+        # TODO maybe the command should use the original context
+        # instead of this one (when it was executed)
+        context.head.take_out arg.evaluate(context)
+      end
+
+      def opposite
+        Sacar.new arg
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/procedure_call.rb

@@ -0,0 +1,23 @@
+require 'gobstones/lang/definitions/definition_call'
+require 'gobstones/runner/errors/definition_not_found_error'
+
+module Gobstones
+
+  module Lang
+
+    class ProcedureCall
+
+      include DefinitionCall
+
+      def evaluate(context)
+        evaluated_args = args.map { |arg| arg.evaluate context }
+        context.program_context.definition_named(name, ->(definition) {
+          definition.evaluate context, evaluated_args
+        }, -> { raise Gobstones::Runner::DefinitionNotFound.new name } )
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/repeat_with_cmd.rb

@@ -0,0 +1,73 @@
+require 'gobstones/lang/commands/assignments'
+require 'gobstones/lang/commands/command_block'
+require 'gobstones/lang/commands/while_cmd'
+require 'gobstones/lang/expressions/comparison_expressions'
+require 'gobstones/lang/expressions/primitive_functions'
+require 'gobstones/runner/errors/gobstones_runtime_error'
+require 'gobstones/runner/errors/gobstones_type_error'
+
+module Gobstones
+
+  module Lang
+
+    class RepeatWithCmd
+
+      attr_reader :var_name, :range_min, :range_max, :cmd_block
+
+      def initialize(var_name, range_min, range_max, cmd_block)
+        @var_name = var_name
+        @range_min = range_min
+        @range_max = range_max
+        @cmd_block = cmd_block
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.var_name == other.var_name &&
+        self.range_min == other.range_min &&
+        self.range_max == other.range_max &&
+        self.cmd_block == other.cmd_block
+      end
+
+      def evaluate(context)
+        validate_range_values context
+        validate_index_variable_not_defined context
+        while_based_equivalent_cmd.evaluate context
+        clear_index_variable_from context
+      end
+
+      private
+
+      def clear_index_variable_from(context)
+        context.clear var_name
+      end
+
+      def validate_range_values(context)
+        raise Gobstones::Runner::GobstonesTypeError, "types don't match in range values" \
+          unless range_min.evaluate(context).same_type_as(range_max.evaluate(context))
+      end
+
+      def validate_index_variable_not_defined(context)
+        raise Gobstones::Runner::GobstonesRuntimeError, "index variable can't be used because it's already defined" \
+          if context.has_variable_named?(var_name.name)
+      end
+
+      def while_based_equivalent_cmd
+        #
+        # repeatWith var in min..max block
+        #        is equivalent to
+        # { var := min; while (var < max) { block; var := siguiente(var) }; block }
+        #
+        assign_cmd = SingleAssignment.new var_name, range_min
+        while_cond = LessThan.new var_name, range_max
+        increment = SingleAssignment.new var_name, Siguiente.new(var_name)
+        while_block = CmdBlock.new [cmd_block, increment]
+        while_cmd = WhileCmd.new while_cond, while_block
+        CmdBlock.new [assign_cmd, while_cmd, cmd_block]
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/sacar_cmd.rb

@@ -0,0 +1,31 @@
+require 'gobstones/lang/expressions/one_arg_expression'
+require 'gobstones/lang/commands/poner_cmd'
+require 'gobstones/runner/errors/gobstones_type_error'
+
+module Gobstones
+
+  module Lang
+
+    class Sacar < OneArgExpression
+
+      def evaluate(context)
+        begin
+          context.head.take_out arg.evaluate(context)
+        rescue RuntimeError => e
+          raise Gobstones::Runner::GobstonesTypeError, e.message
+        end
+      end
+
+      def undo(context)
+        context.head.put arg.evaluate(context)
+      end
+
+      def opposite
+        Poner.new arg
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/skip_cmd.rb

@@ -0,0 +1,19 @@
+require 'gobstones/modules/equal_by_class'
+
+module Gobstones
+
+  module Lang
+
+    class Skip
+
+      include Gobstones::EqualByClass
+
+      def evaluate(context=nil)
+        # do nothing, that's my job :-)
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/vaciar_tablero_cmd.rb

@@ -0,0 +1,19 @@
+require 'gobstones/modules/equal_by_class'
+
+module Gobstones
+
+  module Lang
+
+    class VaciarTablero
+
+      include Gobstones::EqualByClass
+
+      def evaluate(context)
+        context.board.empty!
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/lang/commands/while_cmd.rb

@@ -0,0 +1,25 @@
+require 'gobstones/lang/commands/conditional_cmd'
+require 'gobstones/runner/errors/gobstones_runtime_error'
+
+module Gobstones
+
+  module Lang
+
+    class WhileCmd < ConditionalCmd
+
+      STACK_LIMIT = 10000
+
+      def evaluate(context)
+        stack_acc = 0
+        while evaluate_condition(context).is_true?
+          raise Gobstones::Runner::GobstonesRuntimeError, 'stack overflow' if stack_acc == STACK_LIMIT
+          then_block.evaluate context
+          stack_acc += 1
+        end
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,4 @@
+require 'gobstones/lang/definitions/function'
+require 'gobstones/lang/definitions/main'
+require 'gobstones/lang/definitions/procedure'
+require 'gobstones/lang/definitions/var_tuple'

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

@@ -0,0 +1,32 @@
+module Gobstones
+
+  module Lang
+
+    class Definition
+
+      attr_reader :name, :args, :body, :return_statement
+
+      def initialize(name, args, body, return_statement)
+        @name = name
+        @args = args
+        @body = body
+        @return_statement = return_statement
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.name == other.name &&
+        self.args == other.args &&
+        self.body == other.body &&
+        self.return_statement == other.return_statement
+      end
+
+      def named?(a_name)
+        name == a_name
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,24 @@
+module Gobstones
+
+  module Lang
+
+    module DefinitionCall
+
+      attr_reader :name, :args
+
+      def initialize(name, args=[])
+        @name = name
+        @args = args
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.name == other.name &&
+        self.args == other.args
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,14 @@
+require 'gobstones/lang/definitions/definition'
+require 'gobstones/lang/definitions/return_from_function'
+
+module Gobstones
+
+  module Lang
+
+    class Function < Definition
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,26 @@
+require 'gobstones/lang/definitions/definition'
+require 'gobstones/lang/definitions/var_tuple'
+require 'gobstones/lang/definitions/no_return_statement'
+require 'gobstones/lang/definitions/return_from_main'
+
+module Gobstones
+
+  module Lang
+
+    class Main < Definition
+
+      def initialize(body, return_statement)
+        super('Main', VarTuple.new([]), body, return_statement)
+      end
+
+      def evaluate(context)
+        # evaluate body
+        body.evaluate context
+        # evaluate return
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,15 @@
+module Gobstones
+
+  module Lang
+
+    class NoReturnStatement
+
+      def ==(other)
+        self.class == other.class
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,44 @@
+require 'gobstones/lang/definitions/definition'
+require 'gobstones/lang/definitions/no_return_statement'
+require 'gobstones/runner/execution_context'
+require 'gobstones/runner/errors/wrong_arguments_error'
+
+module Gobstones
+
+  module Lang
+
+    class Procedure < Definition
+
+      # TODO rename args to a better name, args_tuple?
+
+      def initialize(name, args, body)
+        super(name, args, body, NoReturnStatement.new)
+      end
+
+      def evaluate(context, arguments=[])
+        check_number_of_arguments arguments
+        procedure_context = Gobstones::Runner::ProcedureExecutionContext.based_on context
+        set_arguments arguments, procedure_context
+        body.evaluate procedure_context
+      end
+
+      private
+
+      def check_number_of_arguments(arguments)
+        if args.length != arguments.length
+          message = "Wrong number of arguments in procedure '#{name}': expected #{args.length}, got #{arguments.length}"
+          raise Gobstones::Runner::WrongArgumentsError, message
+        end
+      end
+
+      def set_arguments(arguments, procedure_context)
+        args.length.times do |index|
+          procedure_context.set args.variables[index], arguments[index]
+        end
+      end
+
+    end
+
+  end
+
+end