Torsten Rüger
dd810cfc49
First baby baby step on the way to passes Create all parfait objects in first pass, so methods exist to be resolved in second path
103 lines
3.3 KiB
Ruby
103 lines
3.3 KiB
Ruby
# Virtual
|
|
# Object Oriented
|
|
# Language
|
|
#
|
|
# VOOL is the abstraction of ruby: ruby minus the fluff
|
|
# fluff is generally what makes ruby nice to use, like 3 ways to achieve the same thing
|
|
# if/unless/ternary , reverse ifs (ie statement if condition), reverse whiles,
|
|
# implicit blocks, splats and multiple assigns etc
|
|
#
|
|
# Vool has expression and statements, revealing that age old dichotomy of code and
|
|
# data. Statements represent code whereas Expressions resolve to data.
|
|
# (in ruby there are no pure statements, everthing resolves to data)
|
|
#
|
|
# Vool resolves to Mom in the next step down. But it also the place where we create
|
|
# Parfait representations for the main oo players, ie classes and methods.
|
|
# The protocol is thus two stage:
|
|
# - first to_parfait with implicit side-effects of creating parfait objects that
|
|
# are added to the Parfait object_space
|
|
# - second to_mom , which will return a mom version of the statement. This may be code
|
|
# or a compiler (for methods), or compiler collection (for classes)
|
|
#
|
|
module Vool
|
|
|
|
# Base class for all statements in the tree. Derived classes correspond to known language
|
|
# constructs
|
|
#
|
|
# Basically Statements represent code, generally speaking code "does things".
|
|
# But Vool distinguishes Expressions (see below), that represent data, and as such
|
|
# don't do things themselves, rather passively participate in being pushed around
|
|
class Statement
|
|
|
|
# Create any neccessary parfait object and add them to the parfait object_space
|
|
# return the object for testing
|
|
#
|
|
# Default implementation (ie this one) riases to show errors
|
|
# argument is general and depends on caller
|
|
def to_parfait(arg)
|
|
raise "Called when it shouldn't #{self.class}"
|
|
end
|
|
|
|
# create mom version of the statement, this is often code, that is added to the
|
|
# compiler, but for methods it is a compiler and for classes a collection of those.
|
|
#
|
|
# The argument given most often is a compiler
|
|
# The default implementation (this) is to raise an error
|
|
def to_mom( _ )
|
|
raise "Not implemented for #{self}"
|
|
end
|
|
|
|
def at_depth(depth , lines)
|
|
prefix = " " * 2 * depth
|
|
strings = lines.split("\n")
|
|
strings.collect{|str| prefix + str}.join("\n")
|
|
end
|
|
|
|
end
|
|
|
|
# An Expression is a Statement that represents data. ie variables constants
|
|
# (see basic_values) , but alos classes, methods and lambdas
|
|
class Expression < Statement
|
|
|
|
def each(&block)
|
|
block.call(self)
|
|
end
|
|
|
|
def ct_type
|
|
nil
|
|
end
|
|
|
|
def normalize
|
|
raise "should not be normalized #{self}"
|
|
end
|
|
|
|
# for loading into a slot, return the "slot_definition" that can be passed to
|
|
# SlotLoad.
|
|
def to_slot(compiler)
|
|
raise "not iplemented in #{self}"
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
require_relative "assignment"
|
|
require_relative "basic_values"
|
|
require_relative "call_statement"
|
|
require_relative "class_expression"
|
|
require_relative "if_statement"
|
|
require_relative "ivar_assignment"
|
|
require_relative "lambda_expression"
|
|
require_relative "local_assignment"
|
|
require_relative "macro_expression"
|
|
require_relative "method_expression"
|
|
require_relative "class_method_expression"
|
|
require_relative "return_statement"
|
|
require_relative "statements"
|
|
require_relative "send_statement"
|
|
require_relative "super_statement"
|
|
require_relative "variables"
|
|
require_relative "while_statement"
|
|
require_relative "yield_statement"
|