v3.eval

fn create() Eval

create returns a capturing evaluator convenient for tests.

fn new(prefs_ &pref.Preferences) Eval

new returns a new evaluator configured for direct execution.

fn FlowKind.from[W](input W) !FlowKind

type Value = ArrayValue
	| EnumValue
	| FnValue
	| MapValue
	| ModuleValue
	| RangeValue
	| StructValue
	| SumValue
	| TupleValue
	| TypeValue
	| VoidValue
	| bool
	| f64
	| i64
	| string

struct ArrayValue {
pub mut:
	elem_type_name string
	values         []Value
}

struct EnumValue {
pub:
	type_name string
	value     i64
}

struct Eval {
pub mut:
	capture_output bool
	prefs          pref.Preferences
mut:
	a                 &flat.FlatAst = unsafe { nil }
	stdout_data       string
	stderr_data       string
	functions         map[string]map[string]FunctionDef
	consts            map[string]map[string]ConstEntry
	globals           map[string]map[string]Value
	global_types      map[string]map[string]string
	global_inits      []GlobalEntry
	enum_inits        []EnumInitEntry
	implicit_main     []TopLevelStmt
	structs           map[string]StructInfo
	enum_fields       map[string][]string
	sum_types         map[string][]string
	type_aliases      map[string]TypeAliasInfo
	type_names        map[string]map[string]bool
	module_imports    map[string][]string
	module_order      []string
	file_import_alias map[string]map[string]string
	modules           map[string]bool
	scopes            []ScopeFrame
	call_stack        []CallFrame
}

Eval interprets v3 flat AST nodes directly for a practical subset of V.

fn (e &Eval) stdout() string

stdout returns the captured stdout stream.

fn (e &Eval) stderr() string

stderr returns the captured stderr stream.

fn (mut e Eval) run_text(code string) ![]Value

run_text parses and executes a single V source string.

fn (mut e Eval) run_files(a &flat.FlatAst) ![]Value

run_files executes parsed flat AST files and invokes main.main.

struct FnValue {
	node          flat.NodeId
	module_name   string
	file_name     string
	captures      map[string]Value
	capture_types map[string]string
}

struct MapEntry {
pub:
	key Value
pub mut:
	value Value
}

struct MapValue {
pub mut:
	key_type_name   string
	value_type_name string
	default_value   Value
	entries         []MapEntry
}

struct ModuleValue {
pub:
	name string
}

struct RangeValue {
pub:
	start     i64
	end       i64
	inclusive bool
}

struct StructValue {
pub:
	type_name string
pub mut:
	fields map[string]Value
}

struct SumValue {
pub:
	type_name    string
	variant_name string
pub mut:
	payload Value
}

struct TupleValue {
pub:
	values []Value
}

struct TypeValue {
pub:
	name string
}

struct VoidValue {}