Class: Heist::Runtime::Body

Inherits:
Frame
  • Object
show all
Defined in:
lib/runtime/frame.rb

Overview

Body is a subclass of Frame, used for evaluating Function bodies. Instead of providing break points between subexpressions in a single expression, it provides break points between whole expressions inside a Scheme procedure. (A ‘break point’ is a point in code execution during which Stack can inspect the last value returned and decide whether to continue the current Frame or switch to some other action.)

Instance Attribute Summary

Attributes inherited from Frame

#expression, #scope

Instance Method Summary collapse

Methods inherited from Frame

#clone, #replaces, #target

Constructor Details

#initialize(expressions, scope) ⇒ Body

A Body is initialized using a Cons list containing a list of Expressions that make up the body of a Function, and a Scope in which these expressions are to be evaluated.



155
156
157
158
159
 
# File 'lib/runtime/frame.rb', line 155

def initialize(expressions, scope)
  @expression  = expressions
  @scope       = scope
  @values      = []
end

Instance Method Details

#complete? ⇒ Boolean

Returns true iff the Body has evaluated all the expressions.

Returns:

  • (Boolean) 


162
163
164
 
# File 'lib/runtime/frame.rb', line 162

def complete?
  @expression.null?
end

#fill!(*args) ⇒ Object

Do-nothing override of Frame#fill!. Function bodies do not need to remember the return value of each expression.



186
187
 
# File 'lib/runtime/frame.rb', line 186

def fill!(*args)
end

#process! ⇒ Object

Processes the next remaining Expression from the Function body, returning the result for inspection by the Stack.



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/runtime/frame.rb', line 168

def process!
  expression = @expression.car
  
  # Increment before evaluating the expression so that when a
  # continuation is saved we resume from the following statement
  @expression = @expression.cdr
  
  # Return the final expression as a +Frame+ to enable tail calls
  return Frame.new(expression, @scope) if complete?
  
  # For all non-tail calls, evaluate the expression and return the value
  stack = @scope.runtime.stack
  stack << Frame.new(expression, @scope)
  stack.value
end