vm

type ArrayObject ¶

type ArrayObject struct {
	Elements []Object
	// contains filtered or unexported fields
}

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 (b ArrayObject) Class() *RClass

type BooleanObject ¶

type BooleanObject struct {
	Value bool
	// contains filtered or unexported fields
}

BooleanObject represents boolean object in goby. It includes `true` and `FALSE` which represents logically true and false value. - `Boolean.new` is not supported.

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

func (b BooleanObject) Class() *RClass

type BuiltInMethodObject ¶ added in v0.0.5

type BuiltInMethodObject struct {
	Name string
	Fn   func(receiver Object) builtinMethodBody
	// contains filtered or unexported fields
}

BuiltInMethodObject represents methods defined in go.

func (b BuiltInMethodObject) Class() *RClass

type ChannelObject ¶ added in v0.0.8

type ChannelObject struct {
	Chan chan int
	// contains filtered or unexported fields
}

ChannelObject represents a goby channel, which carries a golang channel

func (b ChannelObject) Class() *RClass

type Error ¶

type Error struct {
	Message string
	// contains filtered or unexported fields
}

Error class is actually a special struct to hold internal error types with messages. Goby developers need not to take care of the struct. Goby maintainers should consider using the appropriate error type. Cannot create instances of Error class, or inherit Error class.

The type of internal errors:

* `InternalError`: default error type * `ArgumentError`: an argument-related error * `NameError`: a constant-related error * `TypeError`: a type-related error * `UndefinedMethodError`: undefined-method error * `UnsupportedMethodError`: intentionally unsupported-method error

func (b Error) Class() *RClass

type FileObject ¶ added in v0.0.6

type FileObject struct {
	File *os.File
	// contains filtered or unexported fields
}

FileObject is a special type that contains file pointer so we can keep track on target file.

func (b FileObject) Class() *RClass

type HashObject ¶

type HashObject struct {
	Pairs map[string]Object
	// contains filtered or unexported fields
}

HashObject represents hash instances Hash is a collection of key-value pair, which works like a dictionary. Hash literal is represented with curly brackets `{ }` like `{ key: value }`. Each key of the hash is unique and cannot be duplicate within the hash. Adding a leading space and a trailing space within curly brackets are preferable.

- **Key:** an alphanumeric word that starts with alphabet, without containing space and punctuations. Underscore `_` can also be used within the key. String literal like "mickey mouse" cannot be used as a hash key. The internal key is actually a String and **not a Symbol** for now (TBD). Thus only a String object or a string literal should be used when referencing with `[ ]`.

```ruby a = { balthazar1: 100 } # valid b = { 2melchior: 200 } # invalid x = 'balthazar1'

a["balthazar1"] # => 100 a[x] # => 100 a[balthazar1] # => error ```

- **Value:** String literal and objects (Integer, String, Array, Hash, nil, etc) can be used.

**Note:** - The order of key-value pairs are **not** preserved. - Operator `=>` is not supported. - `Hash.new` is not supported.

func (b HashObject) Class() *RClass

type IntegerObject ¶

type IntegerObject struct {
	Value int
	// contains filtered or unexported fields
}

IntegerObject represents number objects which can bring into mathematical calculations.

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

- `Integer.new` is not supported.

func (b IntegerObject) Class() *RClass

type MethodObject ¶ added in v0.0.5

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

MethodObject represents methods defined using goby.

func (b MethodObject) Class() *RClass

type NullObject ¶ added in v0.0.5

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

NullObject (`nil`) represents the null value in Goby. `nil` is convert into `null` when exported to JSON format. - `Null.new` is not supported.

var (
	// NULL represents Goby's null objects.
	NULL *NullObject
)

func (b NullObject) Class() *RClass

type Object ¶

type Object interface {
	Class() *RClass
	// contains filtered or unexported methods
}

Object represents all objects in Goby, including Array, Integer or even Method and Error.

type Pointer ¶

type Pointer struct {
	Target Object
}

Pointer is used to point to an object. Variables should hold pointer instead of holding a object directly.

type RClass ¶

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

	// Singleton is a flag marks if this class a singleton class
	Singleton bool
	// contains filtered or unexported fields
}

RClass represents normal (not built in) class object

var (
	// InternalErrorClass ...
	InternalErrorClass *RClass
	// ArgumentErrorClass ...
	ArgumentErrorClass *RClass
	// NameErrorClass ...
	NameErrorClass *RClass
	// TypeErrorClass ...
	TypeErrorClass *RClass
	// UndefinedMethodErrorClass ...
	UndefinedMethodErrorClass *RClass
	// UnsupportedMethodClass ...
	UnsupportedMethodClass *RClass
)

func (b RClass) Class() *RClass

func (c *RClass) ReturnName() string

type RObject ¶

type RObject struct {
	InitializeMethod *MethodObject
	// contains filtered or unexported fields
}

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

func (b RObject) Class() *RClass

type RangeObject ¶ added in v0.0.9

type RangeObject struct {
	Start int
	End   int
	// contains filtered or unexported fields
}

RangeObject is the built in range class Range represents an interval: a set of values from the beginning to the end specified. Currently, only Integer objects or integer literal are supported.

```ruby r = 0 (1..(1+4)).each do |i|

puts(r = r + i)

end ```

```ruby r = 0 a = 1 b = 5 (a..b).each do |i|

r = r + i

end ```

func (b RangeObject) Class() *RClass

type StringObject ¶

type StringObject struct {
	Value string
	// contains filtered or unexported fields
}

StringObject represents string instances String object holds and manipulates a sequence of characters. String objects may be created using as string literals. Double or single quotations can be used for representation.

```ruby a = "Three" b = 'zero' c = '漢' d = 'Tiếng Việt' e = "😏️️" ```

**Note:**

- Currently, manipulations are based upon Golang's Unicode manipulations. - Currently, UTF-8 encoding is assumed based upon Golang's string manipulation, but the encoding is not actually specified(TBD). - `String.new` is not supported.

func (b StringObject) Class() *RClass

type VM ¶

type VM struct {
	sync.Mutex
	// contains filtered or unexported fields
}

VM represents a stack based virtual machine.

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

func (vm *VM) ExecInstructions(sets []*bytecode.InstructionSet, fn string)

func (vm *VM) GetExecResult() Object

func (vm *VM) GetREPLResult() string

func (vm *VM) InitForREPL()

func (vm *VM) REPLExec(sets []*bytecode.InstructionSet)

func (vm *VM) SetClassISIndexTable(fn filename)

func (vm *VM) SetMethodISIndexTable(fn filename)