Class: Yadriggy::EvalAlgebra

Inherits:
Eval
  • Object
show all
Defined in:
lib/yadriggy/algebra.rb

Overview

Evaluator for Algebra

Instance Method Summary collapse

Methods inherited from Eval

#astree, #being_end, #identifier_or_call

Constructor Details

#initialize(algebra) ⇒ EvalAlgebra

Initializes.

Parameters:



275
276
277
 
# File 'lib/yadriggy/algebra.rb', line 275

def initialize(algebra)
  @algebra = algebra
end

Instance Method Details

#array(expr) ⇒ Object 



343
344
345
 
# File 'lib/yadriggy/algebra.rb', line 343

def array(expr)
  @algebra.array(expr.elements.map {|e| evaluate(e)})
end

#array_ref(expr) ⇒ Object 



389
390
391
392
 
# 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) ⇒ Object 



394
395
396
397
 
# 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) ⇒ Object 



375
376
377
378
379
380
381
382
383
384
385
386
387
 
# 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) ⇒ Object 



471
472
473
474
475
476
477
478
 
# 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) ⇒ Object 



367
368
369
 
# File 'lib/yadriggy/algebra.rb', line 367

def binary(expr)
  @algebra.binary(evaluate(expr.left), expr.op, evaluate(expr.right))
end

#block(expr) ⇒ Object 



449
450
451
452
453
454
 
# 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) ⇒ Object 



441
442
443
 
# 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) ⇒ Object 



403
404
405
406
407
408
 
# 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) ⇒ Object 



501
502
503
504
505
506
507
508
509
 
# 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) ⇒ Object 



410
411
412
413
414
415
 
# 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) ⇒ Object 



417
418
419
420
421
422
423
424
425
426
427
428
429
 
# 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) ⇒ Object 



303
304
305
 
# File 'lib/yadriggy/algebra.rb', line 303

def const(expr)
  @algebra.const(expr.name, expr.line_no, expr.column)
end

#const_path_field(expr) ⇒ Object 



359
360
361
 
# 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) ⇒ Object 



355
356
357
 
# File 'lib/yadriggy/algebra.rb', line 355

def const_path_ref(expr)
  @algebra.const_path_ref(expr.scope, expr.name)
end

#define(expr) ⇒ Object 



480
481
482
483
484
485
486
487
488
489
490
 
# 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) ⇒ Object 



371
372
373
 
# File 'lib/yadriggy/algebra.rb', line 371

def dots(expr)
  @algebra.dots(evaluate(expr.left), expr.op, evaluate(expr.right))
end

#evaluate(expr) ⇒ Object 



279
280
281
282
283
284
285
 
# File 'lib/yadriggy/algebra.rb', line 279

def evaluate(expr)
  if expr.nil?
    nil_value(nil)
  else
    expr.accept(self)
  end
end

#exprs(expr) ⇒ Object 



333
334
335
336
337
 
# 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) ⇒ Object 



436
437
438
439
 
# 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) ⇒ Object 



315
316
317
 
# File 'lib/yadriggy/algebra.rb', line 315

def global_variable(expr)
  @algebra.global_variable(expr.name, expr.line_no, expr.column)
end

#hash(expr) ⇒ Object 



399
400
401
 
# File 'lib/yadriggy/algebra.rb', line 399

def hash(expr)
  @algebra.hash(expr.pairs.map {|p| p.map {|e| evaluate(e) }})
end

#identifier(expr) ⇒ Object 



295
296
297
 
# File 'lib/yadriggy/algebra.rb', line 295

def identifier(expr)
  @algebra.identifier(expr.name, expr.line_no, expr.column)
end

#instance_variable(expr) ⇒ Object 



319
320
321
 
# File 'lib/yadriggy/algebra.rb', line 319

def instance_variable(expr)
  @algebra.instance_variable(expr.name, expr.line_no, expr.column)
end

#label(expr) ⇒ Object 



307
308
309
 
# File 'lib/yadriggy/algebra.rb', line 307

def label(expr)
  @algebra.label(expr.name, expr.line_no, expr.column)
end

#lambda_expr(expr) ⇒ Object 



456
457
458
459
460
461
 
# 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) ⇒ Object 



431
432
433
434
 
# 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) ⇒ Object 



492
493
494
495
496
497
498
499
 
# 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) ⇒ Object 



291
292
293
 
# File 'lib/yadriggy/algebra.rb', line 291

def name(expr)
  raise  'should never happen'
end

#nil_value(expr) ⇒ Object 



287
288
289
 
# File 'lib/yadriggy/algebra.rb', line 287

def nil_value(expr)
  @algebra.nil_value
end

#number(expr) ⇒ Object 



329
330
331
 
# File 'lib/yadriggy/algebra.rb', line 329

def number(expr)
  @algebra.number(expr.value, expr.line_no, expr.column)
end

#paren(expr) ⇒ Object 



339
340
341
 
# File 'lib/yadriggy/algebra.rb', line 339

def paren(expr)
  @algebra.paren(evaluate(expr.expression))
end

#program(expr) ⇒ Object 



521
522
523
 
# File 'lib/yadriggy/algebra.rb', line 521

def program(expr)
  @algebra.program(evaluate(expr.elements))
end

#rescue_end(expr) ⇒ Object 



463
464
465
466
467
468
469
 
# 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) ⇒ Object 



299
300
301
 
# File 'lib/yadriggy/algebra.rb', line 299

def reserved(expr)
  @algebra.reserved(expr.name, expr.line_no, expr.column)
end

#return_values(expr) ⇒ Object 



445
446
447
 
# 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) ⇒ Object 



511
512
513
514
515
516
517
518
519
 
# 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) ⇒ Object 



347
348
349
 
# File 'lib/yadriggy/algebra.rb', line 347

def string_interpolation(expr)
  @algebra.string_interpolation(expr.contents.map {|e| evaluate(e) })
end

#string_literal(expr) ⇒ Object 



351
352
353
 
# 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) ⇒ Object 



327
 
# File 'lib/yadriggy/algebra.rb', line 327

def super_method(expr) @algebra.super_method end

#symbol(expr) ⇒ Object 



311
312
313
 
# File 'lib/yadriggy/algebra.rb', line 311

def symbol(expr)
  @algebra.symbol(expr.name, expr.line_no, expr.column)
end

#unary(expr) ⇒ Object 



363
364
365
 
# File 'lib/yadriggy/algebra.rb', line 363

def unary(expr)
  @algebra.unary(expr.op, evaluate(expr.operand))
end

#variable_call(expr) ⇒ Object 



323
324
325
 
# File 'lib/yadriggy/algebra.rb', line 323

def variable_call(expr)
  @algebra.variable_call(expr.name, expr.line_no, expr.column)
end