gobstones 0.0.1.1

data/lib/gobstones/lang/program.rb

@@ -0,0 +1,32 @@
+require 'gobstones/runner/execution_context'
+
+module Gobstones
+
+  module Lang
+
+    class Program
+
+      attr_reader :definitions, :main_definition
+
+      def initialize(definitions, main_definition)
+        @definitions = definitions
+        @main_definition = main_definition
+      end
+
+      def ==(other)
+        self.class == other.class &&
+        self.definitions == other.definitions &&
+        self.main_definition == other.main_definition
+      end
+
+      def evaluate
+        context = Gobstones::Runner::ProgramExecutionContext.for self
+        main_definition.evaluate context
+        context
+      end
+
+    end
+
+  end
+
+end

data/lib/gobstones/modules/equal_by_class.rb

@@ -0,0 +1,13 @@
+module Gobstones
+
+  module EqualByClass
+
+    def ==(other)
+      self.class == other.class
+    end
+
+    alias_method :eql?, :==
+
+  end
+
+end

data/lib/gobstones/parser/ast/ast.rb

@@ -0,0 +1,210 @@
+require 'gobstones/lang/all'
+
+module Gobstones
+
+  # TODO divide into smaller modules
+  module Parser
+
+    include Gobstones::Lang
+
+    RESERVED_IDS = %w(
+      if else not True False case of while Skip repeatWith in procedure function
+      return Mover Sacar Poner BOOM IrAlOrigen VaciarTablero div mod hayBolitas
+      nroBolitas puedeMover Norte Sur Este Oeste minBool maxBool minDir maxDir
+      minColor maxColor siguiente previo opuesto Verde Rojo Azul Negro Main
+    )
+
+    def self.ast_node(name, &value_block)
+      # TODO check if it is better to have classes
+      mod = Module.new do
+        define_method :value do
+          instance_eval(&value_block)
+        end
+      end
+      const_set name, mod
+    end
+
+    ast_node(:IntegerLiteral) { Number.new text_value.to_i }
+    ast_node(:BooleanLiteral) { Kernel.const_get(text_value).new }
+    ast_node(:ColorLiteral) { Kernel.const_get(text_value).new }
+    ast_node(:DirectionLiteral) { Kernel.const_get(text_value).new }
+
+    ast_node(:MinBoolFuncNode) { MinBool.new }
+    ast_node(:MaxBoolFuncNode) { MaxBool.new }
+    ast_node(:MinColorFuncNode) { MinColor.new }
+    ast_node(:MaxColorFuncNode) { MaxColor.new }
+    ast_node(:MinDirFuncNode) { MinDir.new }
+    ast_node(:MaxDirFuncNode) { MaxDir.new }
+
+    ast_node(:VarNameNode) { VarName.new text_value }
+
+    ast_node(:NroBolitasFuncNode) { NroBolitas.new gexp.value }
+    ast_node(:HayBolitasFuncNode) { HayBolitas.new gexp.value }
+    ast_node(:PuedeMoverFuncNode) { PuedeMover.new gexp.value }
+    ast_node(:SiguienteFuncNode) { Siguiente.new gexp.value }
+    ast_node(:PrevioFuncNode) { Previo.new gexp.value }
+    ast_node(:OpuestoFuncNode) { Opuesto.new gexp.value }
+
+    ast_node :NopExprNode do
+      if sub_exps.empty?
+        left.value
+      else
+        # it is a nested exp
+        sub_exps.elements.inject(left.value) do |memo, node|
+          case node.op.text_value
+          when '+'
+            memo = Add.new memo, node.right.value
+          when '-'
+            memo = Sub.new memo, node.right.value
+          end
+        end
+      end
+    end
+
+    ast_node :MulExprNode do
+      if sub_exps.empty?
+        left.value
+      else
+        # it is a nested exp
+        sub_exps.elements.inject(left.value) do |memo, node|
+          memo = Mul.new memo, node.right.value
+        end
+      end
+    end
+
+    ast_node :DivModExprNode do
+      case op.text_value
+      when 'div'
+        Div.new left.value, right.value
+      when 'mod'
+        Mod.new left.value, right.value
+      end
+    end
+
+    ast_node :PowExprNode do
+      if sub_exps.empty?
+        left.value
+      else
+        # it is a nested exp
+        sub_exps.elements.inject(left.value) do |memo, node|
+          memo = Pow.new memo, node.right.value
+        end
+      end
+    end
+
+    ast_node :RopExprNode do
+      classes = {
+        '==' => Equal,     '/=' => NotEqual,
+        '<'  => LessThan,  '>'  => GreaterThan,
+        '<=' => LessEqual, '>=' => GreaterEqual
+      }
+      classes[rop.text_value].new left.value, right.value
+    end
+
+    ast_node(:NotExprNode) { Not.new exp.value }
+    ast_node(:AndExprNode) { And.new left.value, right.value }
+    ast_node(:OrExprNode) { Or.new left.value, right.value }
+
+    ast_node(:ParenthesesExprNode) { ParenthesesExpr.new gexp.value }
+    ast_node(:FuncCallNode) do
+      FunctionCall.new func_name.text_value, gexp_tuple.value
+    end
+    ast_node(:TupleExprNode) { exps.empty? ? [] : exps.value }
+
+    ast_node :GexpsNode do
+      if elements.length == 2
+        [elements[0].value]
+      else
+        [exp.value] + exps.value
+      end
+    end
+
+    ast_node(:SkipCmdNode) { Skip.new }
+    ast_node(:BoomCmdNode) { Boom.new string.text_value[1..-2] }
+
+    ast_node(:PonerCmdNode) { Poner.new gexp.value }
+    ast_node(:SacarCmdNode) { Sacar.new gexp.value }
+    ast_node(:MoverCmdNode) { Mover.new gexp.value }
+
+    ast_node(:IrAlOrigenCmdNode) { IrAlOrigen.new }
+    ast_node(:VaciarTableroCmdNode) { VaciarTablero.new }
+
+    ast_node :ProcCallNode do
+      ProcedureCall.new proc_name.text_value, gexp_tuple.value
+    end
+
+    ast_node :SingleAssignmentNode do
+      SingleAssignment.new var_name.value, gexp.value
+    end
+
+    ast_node :CmdBlockNode do
+      CmdBlock.new create_commands(commands)
+    end
+
+    ast_node :IfCmdNode do
+      if else_clause.empty?
+        IfCmd.new gexp.value, then_block.value
+      else
+        IfElseCmd.new gexp.value, then_block.value, else_clause.else_block.value
+      end
+    end
+
+    ast_node(:WhileCmdNode) { WhileCmd.new gexp.value, cmd_block.value }
+
+    ast_node :RepeatWithCmdNode do
+      RepeatWithCmd.new var_name.value, range_min.value,
+        range_max.value, cmd_block.value
+    end
+
+    # TODO abstract duplication, very similar to GexpsNode
+    ast_node(:VarNamesNode) do
+      if elements.length == 2
+        # TODO check why it is needed to create a VarName
+        # instead of having already a VarName in elements[0]
+        [VarName.new(elements[0].text_value)]
+      else
+        [vn.value] + vns.value
+      end
+    end
+
+    ast_node(:VarTupleNode) do
+      variables = vns.empty? ? [] : vns.value
+      VarTuple.new variables
+    end
+
+    ast_node(:ProcedureNode) do
+      Procedure.new proc_name.text_value, var_tuple.value, cmd_block.value
+    end
+
+    ast_node(:FunctionNode) do
+      cmd_block = CmdBlock.new create_commands(commands)
+      Function.new func_name.text_value, var_tuple.value,
+        cmd_block, func_return.value
+    end
+
+    ast_node(:FuncReturnNode) do
+      ReturnFromFunction.new gexp_tuple_1.value
+    end
+
+    ast_node(:MainReturnNode) do
+      ReturnFromMain.new var_tuple.value
+    end
+
+    ast_node(:MainDefNode) do
+      cmd_block = CmdBlock.new create_commands(commands)
+      return_st = ret.empty? ? NoReturnStatement.new : ret.value
+      Main.new cmd_block, return_st
+    end
+
+    ast_node(:ProgramNode) do
+      defs = definitions.elements.map { |node| node.definition.value }
+      Program.new defs, main_def.value
+    end
+
+    def create_commands(commands)
+      commands.elements.map { |node| node.command.value }
+    end
+
+  end
+
+end

data/lib/gobstones/parser/grammar/gobstones.treetop

@@ -0,0 +1,316 @@
+# TODO modularize when possible
+grammar Gobstones
+
+  # TOP RULE: program
+
+  rule program
+    definitions main_def space* <ProgramNode>
+  end
+
+  # DEFINITIONS: main, procedures, functions
+
+  rule definitions
+    (space* definition space*)*
+  end
+
+  rule definition
+    procedure_def / function_def
+  end
+
+  rule main_def
+    'procedure' space+ 'Main' space* '(' space* ')' space*
+    '{' space* commands ret:main_return? space* '}' <MainDefNode>
+  end
+
+  rule main_return
+    'return' space* var_tuple space* ';'? <MainReturnNode>
+  end
+
+  rule procedure_def
+    'procedure' space+ proc_name space*
+    var_tuple space* cmd_block <ProcedureNode>
+  end
+
+  rule function_def
+    'function' space+ func_name space* var_tuple space*
+    '{' space* commands func_return space* '}' <FunctionNode>
+  end
+
+  rule func_return
+    'return' space* gexp_tuple_1 space* ';'? <FuncReturnNode>
+  end
+
+  # COMMANDS
+
+  rule commands
+    (command space* ';'? space*)*
+  end
+
+  rule command
+    simple_cmd / complex_cmd
+  end
+
+  rule simple_cmd
+    skip_cmd / boom_cmd / poner_cmd / sacar_cmd / mover_cmd /
+    ir_al_origen_cmd / vaciar_tablero_cmd / proc_call /
+    cmd_block / single_assignment # / multiple_assignment
+  end
+
+  rule skip_cmd
+    'Skip' <SkipCmdNode>
+  end
+
+  rule boom_cmd
+    'BOOM' space* '(' space* string space* ')' <BoomCmdNode>
+  end
+
+  rule poner_cmd
+    'Poner' space* '(' space* gexp space* ')' <PonerCmdNode>
+  end
+
+  rule sacar_cmd
+    'Sacar' space* '(' space* gexp space* ')' <SacarCmdNode>
+  end
+
+  rule mover_cmd
+    'Mover' space* '(' space* gexp space* ')' <MoverCmdNode>
+  end
+
+  rule ir_al_origen_cmd
+    'IrAlOrigen' space* '(' space* ')' <IrAlOrigenCmdNode>
+  end
+
+  rule vaciar_tablero_cmd
+    'VaciarTablero' space* '(' space* ')' <VaciarTableroCmdNode>
+  end
+
+  rule proc_call
+    proc_name space* gexp_tuple <ProcCallNode>
+  end
+
+  rule cmd_block
+    '{' space* commands space* '}' <CmdBlockNode>
+  end
+
+  rule single_assignment
+    var_name space* ':=' space* gexp <SingleAssignmentNode>
+  end
+
+  # TODO implement
+  # rule multiple_assignment
+  # end
+
+  rule complex_cmd
+    if_cmd / while_cmd / repeat_with_cmd # / case_cmd
+  end
+
+  rule if_cmd
+    'if' space* '(' space* gexp space* ')'
+    space* then_block:cmd_block
+    else_clause:(space* 'else' space* else_block:cmd_block)?
+    <IfCmdNode>
+  end
+
+  rule while_cmd
+    'while' space* '(' space* gexp space* ')' space* cmd_block <WhileCmdNode>
+  end
+
+  rule repeat_with_cmd
+    'repeatWith' space+ var_name space+ 'in' space+
+    range_min:gexp space* '..' space* range_max:gexp space*
+    cmd_block <RepeatWithCmdNode>
+  end
+
+  # TODO implement
+  # rule case_cmd
+  # end
+
+  # EXPRESSIONS
+
+  rule gexp
+    bexp
+  end
+
+  rule bexp
+    left:bterm space* '||' space* right:bexp <OrExprNode> / bterm
+  end
+
+  rule bterm
+    left:bfact space* '&&' space* right:bterm <AndExprNode> / bfact
+  end
+
+  rule bfact
+    'not' space+ exp:batom <NotExprNode> / batom
+  end
+
+  rule batom
+    left:nexp space* rop space* right:nexp <RopExprNode> / nexp
+  end
+
+  rule rop
+    '==' / '/=' / '<=' / '>=' / '<' / '>'
+  end
+
+  rule nexp
+    left:nterm sub_exps:(space* op:[+-] space* right:nterm)* <NopExprNode>
+  end
+
+  rule nterm
+    left:nfactH sub_exps:(space* '*' space* right:nfactH)* <MulExprNode>
+  end
+
+  rule nfactH
+    left:nfactL space+ op:mop space+ right:nfactL <DivModExprNode> / nfactL
+  end
+
+  rule mop
+    'div' / 'mod'
+  end
+
+  rule nfactL
+    left:natom sub_exps:(space* '^' space* right:natom)* <PowExprNode>
+  end
+
+  rule natom
+    literal / type_bound_func / primitive_func /
+    paren_expr / func_call / var_name
+  end
+
+  rule type_bound_func
+    bool_type_bound_func / color_type_bound_func / direction_type_bound_func
+  end
+
+  rule bool_type_bound_func
+    'minBool()' <MinBoolFuncNode> / 'maxBool()' <MaxBoolFuncNode>
+  end
+
+  rule color_type_bound_func
+    'minColor()' <MinColorFuncNode> / 'maxColor()' <MaxColorFuncNode>
+  end
+
+  rule direction_type_bound_func
+    'minDir()' <MinDirFuncNode> / 'maxDir()' <MaxDirFuncNode>
+  end
+
+  rule primitive_func
+    nro_bolitas_func / hay_bolitas_func / puede_mover_func /
+    siguiente_func / previo_func / opuesto_func
+  end
+
+  rule nro_bolitas_func
+    'nroBolitas' space* '(' space* gexp space* ')' <NroBolitasFuncNode>
+  end
+
+  rule hay_bolitas_func
+    'hayBolitas' space* '(' space* gexp space* ')' <HayBolitasFuncNode>
+  end
+
+  rule puede_mover_func
+    'puedeMover' space* '(' space* gexp space* ')' <PuedeMoverFuncNode>
+  end
+
+  rule siguiente_func
+    'siguiente' space* '(' space* gexp space* ')' <SiguienteFuncNode>
+  end
+
+  rule previo_func
+    'previo' space* '(' space* gexp space* ')' <PrevioFuncNode>
+  end
+
+  rule opuesto_func
+    'opuesto' space* '(' space* gexp space* ')' <OpuestoFuncNode>
+  end
+
+  rule paren_expr
+    '(' space* gexp space* ')' <ParenthesesExprNode>
+  end
+
+  rule func_call
+    func_name space* gexp_tuple <FuncCallNode>
+  end
+
+  rule var_name
+    lower_id &{ |id| id[0].is_not_reserved } <VarNameNode>
+  end
+
+  # LITERALS
+
+  rule literal
+    number / boolean / color / direction
+  end
+
+  rule number
+    '-'? [0-9] [0-9]* <IntegerLiteral>
+  end
+
+  rule boolean
+    ('True' / 'False') <BooleanLiteral>
+  end
+
+  rule color
+    ('Azul' / 'Negro' / 'Rojo' / 'Verde') <ColorLiteral>
+  end
+
+  rule direction
+    ('Norte' / 'Este' / 'Sur' / 'Oeste') <DirectionLiteral>
+  end
+
+  # AUX DEFINITIONS: identifiers, tuples
+
+  rule proc_name
+    upper_id &{ |id| id[0].is_not_reserved }
+  end
+
+  rule func_name
+    lower_id &{ |id| id[0].is_not_reserved }
+  end
+
+  rule var_tuple
+    '(' space* vns:var_names? space* ')' <VarTupleNode>
+  end
+
+  rule var_names
+    ((vn:var_name space* ',' space* vns:var_names) / var_name) <VarNamesNode>
+  end
+
+  rule gexp_tuple
+    '(' space* exps:gexps? space* ')' <TupleExprNode>
+  end
+
+  rule gexp_tuple_1
+    '(' space* exps:gexps space* ')' <TupleExprNode>
+  end
+
+  rule gexps
+    ((exp:gexp space* ',' space* exps:gexps) / gexp) <GexpsNode>
+  end
+
+  rule lower_id
+    [a-z] char* {
+      def is_not_reserved
+        !Gobstones::Parser::RESERVED_IDS.include? text_value
+      end
+    }
+  end
+
+  rule upper_id
+    [A-Z] char* {
+      def is_not_reserved
+        !Gobstones::Parser::RESERVED_IDS.include? text_value
+      end
+    }
+  end
+
+  rule char
+    [a-zA-Z0-9'_]
+  end
+
+  rule string
+    '"' ('\"' / !'"' .)* '"'
+  end
+
+  rule space
+    [\s]
+  end
+
+end