bytecode

type Chunk struct {
	// The bytecode itself. Includes both OpCodes and immediate arguments needed
	// by the opcodes.
	Code []uint8
}

type CompiledStoryworld struct {
	// Swid is the Storyworld ID. It is a free string that should uniquely
	// identify the Storyworld.
	Swid string

	// Swov is the Storyworld version. A negative value means that this is a
	// development version. A non-negative value means that this is a release
	// version. For example, if the currently released version of a Storyworld
	// is 3, the development version will be -4. When the development version
	// becomes stable, it will be released as version 4.
	//
	// A version equals to zero is invalid.
	Swov int32

	// The constant values used in all Chunks.
	Constants []Value

	// Chunks is a slice with all Chunks of bytecode containing the compiled
	// data. There is one Chunk for each procedure in the Storyworld.
	//
	// TODO: And in the future, one Chunk for every version of every procedure.
	Chunks []*Chunk

	// InitialChunk indexes the element in Chunks from where the Storyworld
	// execution starts. In other words, it points to the latest version of the
	// "/main" chunk.
	InitialChunk int
}

type DebugInfo struct {
	// Swid is the Storyworld ID. It must match the corresponding field in
	// CompiledStoryworld.
	Swid string

	// Swov is the Storyworld version. It must match the corresponding field in
	// CompiledStoryworld.
	Swov int32

	// ChunksNames contains the names of the procedures on a CompiledStoryworld.
	// There is one entry for each entry in the corresponding
	// CompiledStoryworld.Chunks.
	ChunksNames []string

	// ChunksSourceFiles contains the source files every Chunk was compiled
	// from. The indices here match those in CompiledStoryworld.Chunks. The file
	// names here contain the path from the root of the Storyworld.
	ChunksSourceFiles []string

	// ChunksLines contains the source code line that generated each instruction
	// of each Chunk. This must be interpreted like this:
	// ChunksLines[chunkIndex][codeIndex] contains the line that generated the
	// bytecode at CompiledStoryworld.Chunks[chunkIndex].Code[codeIndex].
	//
	// Notice that we have one entry for each entry in Code. Very
	// space-inefficient, but very simple.
	//
	// TODO: Use run-length encoding (RLE) or something like that to spare some
	// memory and storage.
	ChunksLines [][]int
}

type Lecture struct {
	// Text is the text of the Lecture.
	Text string
}

type OpCode uint8

type Procedure struct {
	// ChunkIndex points to the Chunk that contains this function's bytecode.
	// It's an index into the CompiledStoryworld slice of Chunks.
	ChunkIndex int
}

type Value struct {
	Value interface{}
}

type ValueKind int