vm

type ArrayObject ¶

type ArrayObject struct {
	Class    *RArray
	Elements []Object
}

ArrayObject represents instance from Array class. An array is a collection of different objects that are ordered and indexed. Elements in an array can belong to any class.

func (a *ArrayObject) Inspect() string

type BaseClass ¶

type BaseClass struct {
	// Name is the class's name
	Name string
	// Methods contains its instances' methods
	Methods *environment
	// ClassMethods contains this class's methods
	ClassMethods *environment

	// Class points to this class's class, which should be ClassClass
	Class *RClass
	// Singleton is a flag marks if this class a singleton class
	Singleton bool
	// contains filtered or unexported fields
}

BaseClass is a embedded struct that contains all the essential fields for a class

func (c *BaseClass) Inspect() string

func (c *BaseClass) ReturnName() string

type BaseObject ¶

type BaseObject interface {
	Object
	// contains filtered or unexported methods
}

BaseObject is an interface that implements basic functions any object requires.

type BooleanObject ¶

type BooleanObject struct {
	Class *RBool
	Value bool
}

BooleanObject represents boolean object in goby. It includes `true` and `FALSE` which represents logically true and false value.

var (

	// TRUE is shared boolean object that represents true
	TRUE *BooleanObject
	// FALSE is shared boolean object that represents false
	FALSE *BooleanObject
)

func (b *BooleanObject) Inspect() string

type BuiltInMethod ¶

type BuiltInMethod struct {
	Name string
	Fn   func(receiver Object) builtinMethodBody
}

BuiltInMethod represents methods defined in go.

func (bim *BuiltInMethod) Inspect() string

type Class ¶

type Class interface {
	ReturnName() string

	BaseObject
	// contains filtered or unexported methods
}

Class is an interface that implements a class's basic functions. - lookupClassMethod: search for current class's class method with given name. - lookupInstanceMethod: search for current class's instance method with given name. - ReturnName returns class's name

type Error ¶

type Error struct {
	Class   *ErrorClass
	Message string
}

func (e *Error) Inspect() string

type ErrorClass ¶

type ErrorClass struct {
	*BaseClass
}

type HashObject ¶

type HashObject struct {
	Class *RHash
	Pairs map[string]Object
}

HashObject represents hash instances

func (h *HashObject) Inspect() string

func (h *HashObject) Length() int

type IntegerObject ¶

type IntegerObject struct {
	Class *RInteger
	Value int
}

IntegerObject represents number objects which can bring into mathematical calculations.

```ruby 1 + 1 # => 2 2 * 2 # => 4 ```

func (i *IntegerObject) Inspect() string

type Method ¶

type Method struct {
	Name string
	// contains filtered or unexported fields
}

Method represents methods defined using goby.

func (m *Method) Inspect() string

type Null ¶

type Null struct {
	Class *RNull
}

var (
	NULL *Null
)

func (n *Null) Inspect() string

type Object ¶

type Object interface {
	Inspect() string
	// contains filtered or unexported methods
}

type Pointer ¶

type Pointer struct {
	Target Object
}

type RArray ¶

type RArray struct {
	*BaseClass
}

RArray is the built in array class

type RBool ¶

type RBool struct {
	*BaseClass
}

RBool is the built in class of goby's boolean objects.

type RClass ¶

type RClass struct {
	*BaseClass
}

RClass represents normal (not built in) class object

type RHash ¶

type RHash struct {
	*BaseClass
}

RHash is the class of hash objects

type RInteger ¶

type RInteger struct {
	*BaseClass
}

RInteger is integer class

type RNull ¶

type RNull struct {
	*BaseClass
}

type RObject ¶

type RObject struct {
	Class             *RClass
	InstanceVariables *environment
	InitializeMethod  *Method
}

RObject represents any non built-in class's instance.

func (ro *RObject) Inspect() string

type RString ¶

type RString struct {
	*BaseClass
}

RString is the built in string class

type StringObject ¶

type StringObject struct {
	Class *RString
	Value string
}

StringObject represents string instances

func (s *StringObject) Inspect() string

type VM ¶

type VM struct {
	// contains filtered or unexported fields
}

VM represents a stack based virtual machine.

func New(fileDir string, args []string) *VM

func (vm *VM) ExecBytecodes(bytecodes, fn string)

func (vm *VM) GetExecResult() Object