class Yadriggy::EvalAlgebra

Evaluator for Algebra

Public Class Methods

new(algebra) click to toggle source

Initializes.

@param [Algebra] algebra

# File lib/yadriggy/algebra.rb, line 275
def initialize(algebra)
  @algebra = algebra
end

Public Instance Methods

array(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 343
def array(expr)
  @algebra.array(expr.elements.map {|e| evaluate(e)})
end
array_ref(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 389
def array_ref(expr)
  @algebra.array_ref(evaluate(expr.array),
                     expr.indexes.map {|e| evaluate(e) })
end
array_ref_field(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 394
def array_ref_field(expr)
  @algebra.array_ref_field(evaluate(expr.array),
                           expr.indexes.map {|e| evaluate(e) })
end
assign(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 375
def assign(expr)
  right = if expr.right.is_a?(Array)
            expr.right.map {|e| evaluate(e) }
         else
            evaluate(expr.right)
         end
  left = if expr.left.is_a?(Array)
            expr.left.map {|e| evaluate(e) }
         else
            evaluate(expr.left)
         end
  @algebra.assign(left, expr.op, right)
end
begin_end(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 471
def begin_end(expr)
  @algebra.begin_end(lambda { evaluate(expr.body) },
                  if expr.rescue.nil?
                    nil
                  else
                    lambda { evaluate(expr.rescue) }
                  end)
end
binary(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 367
def binary(expr)
  @algebra.binary(evaluate(expr.left), expr.op, evaluate(expr.right))
end
block(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 449
def block(expr)
  @algebra.block(expr.params, expr.optionals, expr.rest_of_params,
                 expr.params_after_rest, expr.keywords,
                 expr.rest_of_keywords,
                 expr.block_param, lambda { evaluate(expr.body) })
end
break_out(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 441
def break_out(expr)
  @algebra.break_out(expr.op, expr.values.map {|e| evaluate(e) })
end
call(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 403
def call(expr)
  @algebra.call(evaluate(expr.receiver), expr.op, expr.name,
                expr.args.map {|e| evaluate(e) },
                evaluate(expr.block_arg),
                lambda { evaluate(expr.block) })
end
class_def(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 501
def class_def(expr)
  @algebra.class_def(expr.name, expr.superclass,
                     lambda { evaluate(expr.body) },
                      if expr.rescue.nil?
                        nil
                      else
                        lambda { evaluate(expr.rescue) }
                      end)
end
command(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 410
def command(expr)
  @algebra.command(evaluate(expr.receiver), expr.op, expr.name,
                   expr.args.map {|e| evaluate(e) },
                   evaluate(expr.block_arg),
                   lambda { evaluate(expr.block) })
end
conditional(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 417
def conditional(expr)
  @algebra.conditional(expr.op, evaluate(expr.cond),
                       lambda { evaluate(expr.then) },
                       expr.all_elsif.map do |e|
                         [lambda { evaluate(e[0]) },
                          lambda { evaluate(e[1]) }]
                       end,
                       if expr.else.nil?
                         nil
                       else
                         lambda { evaluate(expr.else) }
                       end)
end
const(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 303
def const(expr)
  @algebra.const(expr.name, expr.line_no, expr.column)
end
const_path_field(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 359
def const_path_field(expr)
  @algebra.const_path_field(expr.scope, expr.name)
end
const_path_ref(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 355
def const_path_ref(expr)
  @algebra.const_path_ref(expr.scope, expr.name)
end
define(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 480
def define(expr)
  @algebra.define(expr.name, expr.params, expr.optionals,
                  expr.rest_of_params, expr.params_after_rest,
                  expr.keywords, expr.rest_of_keywords,
                  expr.block_param, lambda { evaluate(expr.body) },
                  if expr.rescue.nil?
                    nil
                  else
                    lambda { evaluate(expr.rescue) }
                  end)
end
dots(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 371
def dots(expr)
  @algebra.dots(evaluate(expr.left), expr.op, evaluate(expr.right))
end
evaluate(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 279
def evaluate(expr)
  if expr.nil?
    nil_value(nil)
  else
    expr.accept(self)
  end
end
exprs(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 333
def exprs(expr)
  expr.expressions.inject(nil) do |result, e|
    @algebra.exprs(result, evaluate(e))
  end
end
for_loop(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 436
def for_loop(expr)
  @algebra.for_loop(expr.vars, evaluate(expr.set),
                    lambda { evaluate(expr.body) })
end
global_variable(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 315
def global_variable(expr)
  @algebra.global_variable(expr.name, expr.line_no, expr.column)
end
hash(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 399
def hash(expr)
  @algebra.hash(expr.pairs.map {|p| p.map {|e| evaluate(e) }})
end
identifier(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 295
def identifier(expr)
  @algebra.identifier(expr.name, expr.line_no, expr.column)
end
instance_variable(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 319
def instance_variable(expr)
  @algebra.instance_variable(expr.name, expr.line_no, expr.column)
end
label(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 307
def label(expr)
  @algebra.label(expr.name, expr.line_no, expr.column)
end
lambda_expr(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 456
def lambda_expr(expr)
  @algebra.lambda_expr(expr.params, expr.optionals, expr.rest_of_params,
                       expr.params_after_rest, expr.keywords,
                       expr.rest_of_keywords,
                       expr.block_param, lambda { evaluate(expr.body) })
end
loop(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 431
def loop(expr)
  @algebra.loop(expr.op, lambda { evaluate(expr.cond) },
                lambda { evaluate(expr.body) })
end
module_def(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 492
def module_def(expr)
  @algebra.module_def(expr.name, lambda { evaluate(expr.body) },
                      if expr.rescue.nil?
                        nil
                      else
                        lambda { evaluate(expr.rescue) }
                      end)
end
name(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 291
def name(expr)
  raise  'should never happen'
end
nil_value(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 287
def nil_value(expr)
  @algebra.nil_value
end
number(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 329
def number(expr)
  @algebra.number(expr.value, expr.line_no, expr.column)
end
paren(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 339
def paren(expr)
  @algebra.paren(evaluate(expr.expression))
end
program(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 521
def program(expr)
  @algebra.program(evaluate(expr.elements))
end
rescue_end(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 463
def rescue_end(expr)
  @algebra.rescue_end(expr.types, expr.parameter,
                      lambda { evaluate(expr.body) },
                      lambda { evaluate(expr.nested_rescue) },
                      lambda { evaluate(expr.else) },
                      lambda { evaluate(expr.ensure) })
end
reserved(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 299
def reserved(expr)
  @algebra.reserved(expr.name, expr.line_no, expr.column)
end
return_values(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 445
def return_values(expr)
  @algebra.return_values(expr.values.map {|e| evaluate(e) })
end
singular_class_def(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 511
def singular_class_def(expr)
  @algebra.singular_class_def(expr.name,
                              lambda { evaluate(expr.body) },
                              if expr.rescue.nil?
                                nil
                              else
                                lambda { evaluate(expr.rescue) }
                              end)
end
string_interpolation(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 347
def string_interpolation(expr)
  @algebra.string_interpolation(expr.contents.map {|e| evaluate(e) })
end
string_literal(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 351
def string_literal(expr)
  @algebra.string_literal(expr.value, expr.line_no, expr.column)
end
super_method(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 327
def super_method(expr) @algebra.super_method end
symbol(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 311
def symbol(expr)
  @algebra.symbol(expr.name, expr.line_no, expr.column)
end
unary(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 363
def unary(expr)
  @algebra.unary(expr.op, evaluate(expr.operand))
end
variable_call(expr) click to toggle source
# File lib/yadriggy/algebra.rb, line 323
def variable_call(expr)
  @algebra.variable_call(expr.name, expr.line_no, expr.column)
end