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, #evaluate, #identifier_or_call

Constructor Details

#initialize(algebra) ⇒ EvalAlgebra 



265
266
267
 
# File 'lib/yadriggy/algebra.rb', line 265

def initialize(algebra)
  @algebra = algebra
end

Instance Method Details

#array(expr) ⇒ Object 



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

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

#array_ref(expr) ⇒ Object 



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

def array_ref(expr)
  @algebra.array_ref(evaluate(expr.array),
                     expr.indexes.map {|e| evaluate(e) })
end

#array_ref_field(expr) ⇒ Object 



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

def array_ref_field(expr)
  @algebra.array_ref_field(evaluate(expr.array),
                           expr.indexes.map {|e| evaluate(e) })
end

#assign(expr) ⇒ Object 



357
358
359
 
# File 'lib/yadriggy/algebra.rb', line 357

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

#begin_end(expr) ⇒ Object 



443
444
445
446
447
448
449
450
 
# File 'lib/yadriggy/algebra.rb', line 443

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 



349
350
351
 
# File 'lib/yadriggy/algebra.rb', line 349

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

#block(expr) ⇒ Object 



421
422
423
424
425
426
 
# File 'lib/yadriggy/algebra.rb', line 421

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 



413
414
415
 
# File 'lib/yadriggy/algebra.rb', line 413

def break_out(expr)
  @algebra.break_out(expr.op, expr.values.map {|e| evaluate(e) })
end

#call(expr) ⇒ Object 



375
376
377
378
379
380
 
# File 'lib/yadriggy/algebra.rb', line 375

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 



473
474
475
476
477
478
479
480
481
 
# File 'lib/yadriggy/algebra.rb', line 473

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 



382
383
384
385
386
387
 
# File 'lib/yadriggy/algebra.rb', line 382

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 



389
390
391
392
393
394
395
396
397
398
399
400
401
 
# File 'lib/yadriggy/algebra.rb', line 389

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 



285
286
287
 
# File 'lib/yadriggy/algebra.rb', line 285

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

#const_path_field(expr) ⇒ Object 



341
342
343
 
# File 'lib/yadriggy/algebra.rb', line 341

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

#const_path_ref(expr) ⇒ Object 



337
338
339
 
# File 'lib/yadriggy/algebra.rb', line 337

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

#define(expr) ⇒ Object 



452
453
454
455
456
457
458
459
460
461
462
 
# File 'lib/yadriggy/algebra.rb', line 452

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 



353
354
355
 
# File 'lib/yadriggy/algebra.rb', line 353

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

#exprs(expr) ⇒ Object 



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

def exprs(expr)
  expr.expressions.inject(nil) do |result, e|
    @algebra.exprs(result, evaluate(e))
  end
end

#for_loop(expr) ⇒ Object 



408
409
410
411
 
# File 'lib/yadriggy/algebra.rb', line 408

def for_loop(expr)
  @algebra.for_loop(expr.vars, evaluate(expr.set),
                    lambda { evaluate(expr.body) })
end

#global_variable(expr) ⇒ Object 



297
298
299
 
# File 'lib/yadriggy/algebra.rb', line 297

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

#hash(expr) ⇒ Object 



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

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

#identifier(expr) ⇒ Object 



277
278
279
 
# File 'lib/yadriggy/algebra.rb', line 277

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

#instance_variable(expr) ⇒ Object 



301
302
303
 
# File 'lib/yadriggy/algebra.rb', line 301

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

#label(expr) ⇒ Object 



289
290
291
 
# File 'lib/yadriggy/algebra.rb', line 289

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

#lambda_expr(expr) ⇒ Object 



428
429
430
431
432
433
 
# File 'lib/yadriggy/algebra.rb', line 428

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 



403
404
405
406
 
# File 'lib/yadriggy/algebra.rb', line 403

def loop(expr)
  @algebra.loop(expr.op, lambda { evaluate(expr.cond) },
                lambda { evaluate(expr.body) })
end

#module_def(expr) ⇒ Object 



464
465
466
467
468
469
470
471
 
# File 'lib/yadriggy/algebra.rb', line 464

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 



273
274
275
 
# File 'lib/yadriggy/algebra.rb', line 273

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

#nil_value(expr) ⇒ Object 



269
270
271
 
# File 'lib/yadriggy/algebra.rb', line 269

def nil_value(expr)
  @algebra.nil_value
end

#number(expr) ⇒ Object 



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

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

#paren(expr) ⇒ Object 



321
322
323
 
# File 'lib/yadriggy/algebra.rb', line 321

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

#program(expr) ⇒ Object 



493
494
495
 
# File 'lib/yadriggy/algebra.rb', line 493

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

#rescue_end(expr) ⇒ Object 



435
436
437
438
439
440
441
 
# File 'lib/yadriggy/algebra.rb', line 435

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 



281
282
283
 
# File 'lib/yadriggy/algebra.rb', line 281

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

#return_values(expr) ⇒ Object 



417
418
419
 
# File 'lib/yadriggy/algebra.rb', line 417

def return_values(expr)
  @algebra.return_values(expr.values.map {|e| evaluate(e) })
end

#singular_class_def(expr) ⇒ Object 



483
484
485
486
487
488
489
490
491
 
# File 'lib/yadriggy/algebra.rb', line 483

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 



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

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

#string_literal(expr) ⇒ Object 



333
334
335
 
# File 'lib/yadriggy/algebra.rb', line 333

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

#super_method(expr) ⇒ Object 



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

def super_method(expr) @algebra.super_method end

#symbol(expr) ⇒ Object 



293
294
295
 
# File 'lib/yadriggy/algebra.rb', line 293

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

#unary(expr) ⇒ Object 



345
346
347
 
# File 'lib/yadriggy/algebra.rb', line 345

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

#variable_call(expr) ⇒ Object 



305
306
307
 
# File 'lib/yadriggy/algebra.rb', line 305

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