v.table #

fn new_table() &Table

fn new_type(idx int) Type

return new type with TypeSymbol idx set to idx

fn new_type_ptr(idx int, nr_muls int) Type

return new type with TypeSymbol idx set to idx & nr_muls set to nr_muls

fn sharetype_from_flags(is_shared bool, is_atomic bool) ShareType

fn (attrs []Attr) contains(str string) bool

fn (kinds []Kind) str() string

type FExpr = byteptr | voidptr

NB: FExpr here is a actually an ast.Expr . It should always be used by casting to ast.Expr, using ast.fe2ex()/ast.ex2fe() That hack is needed to break an import cycle between v.ast and v.table .

type Type = int

fn (t Type) atomic_typename() string

<atomic.h> defines special typenames

fn (t Type) share() ShareType

fn (t Type) idx() int

return TypeSymbol idx for t

fn (t Type) is_void() bool

fn (t Type) is_full() bool

fn (t Type) nr_muls() int

return nr_muls for t

fn (t Type) is_ptr() bool

return true if t is a pointer (nr_muls>0)

fn (t Type) set_nr_muls(nr_muls int) Type

set nr_muls on t and return it

fn (t Type) to_ptr() Type

increments nr_nuls on t and return it

fn (t Type) deref() Type

decrement nr_muls on t and return it

fn (t Type) set_flag(flag TypeFlag) Type

set flag on t and return t

fn (t Type) clear_flag(flag TypeFlag) Type

clear flag on t and return t

fn (t Type) clear_flags() Type

clear all flags

fn (t Type) has_flag(flag TypeFlag) bool

return true if flag is set on t

fn (t Type) debug() []string

fn (t Type) derive(t_from Type) Type

copy flags & nr_muls from t_from to t and return t

fn (typ Type) is_pointer() bool

built in pointers (voidptr, byteptr, charptr)

fn (typ Type) is_float() bool

fn (typ Type) is_int() bool

fn (typ Type) is_signed() bool

fn (typ Type) is_unsigned() bool

fn (typ Type) is_int_literal() bool

fn (typ Type) is_number() bool

fn (typ Type) is_string() bool

type TypeInfo = Aggregate | Alias | Array | ArrayFixed | Chan | Enum | FnType | GenericStructInst |
	GoHandle | Interface | Map | MultiReturn | Struct | SumType

enum Kind {
	placeholder
	void
	voidptr
	byteptr
	charptr
	i8
	i16
	int
	i64
	byte
	u16
	u32
	u64
	f32
	f64
	char
	size_t
	rune
	bool
	none_
	string
	ustring
	array
	array_fixed
	map
	chan
	any
	struct_
	generic_struct_inst
	multi_return
	sum_type
	alias
	enum_
	function
	interface_
	float_literal
	int_literal
	aggregate
	gohandle
}

fn (k Kind) str() string

for debugging/errors only, perf is not an issue

enum Language {
	v
	c
	js
}

enum ShareType {
	mut_t
	shared_t
	atomic_t
}

fn (t ShareType) str() string

enum TypeFlag {
	optional
	variadic
	generic
	shared_f
	atomic_f
}

max of 8

struct Aggregate {
mut:
	fields []Field
pub:
	types []Type
}

struct Alias {
pub:
	parent_type Type
	language    Language
	is_import   bool
}

struct Array {
pub:
	nr_dims int
pub mut:
	elem_type Type
}

struct ArrayFixed {
pub:
	size int
pub mut:
	elem_type Type
}

struct Attr {
pub:
	name          string
	is_string     bool
	is_ctdefine   bool
	arg           string
	is_string_arg bool
	pos           token.Position
}

e.g. [unsafe]

fn (attr Attr) str() string

no square brackets

struct Chan {
pub mut:
	elem_type Type
	is_mut    bool
}

struct Enum {
pub:
	vals             []string
	is_flag          bool
	is_multi_allowed bool
}

struct Field {
pub:
	name string
pub mut:
	typ              Type
	default_expr     FExpr
	has_default_expr bool
	default_val      string
	attrs            []Attr
	is_pub           bool
	is_mut           bool
	is_global        bool
}

struct Fn {
pub:
	params         []Param
	return_type    Type
	is_variadic    bool
	language       Language
	generic_names  []string
	is_pub         bool
	is_deprecated  bool
	is_unsafe      bool
	is_placeholder bool
	no_body        bool
	mod            string
	ctdefine       string
	attrs          []Attr
pub mut:
	name      string
	source_fn voidptr
}

struct FnSignatureOpts {
	skip_receiver bool
	type_only     bool
}

struct FnType {
pub:
	is_anon  bool
	has_decl bool
	func     Fn
}

struct GenericStructInst {
pub mut:
	parent_idx    int
	generic_types []Type
}

instantiation of a generic struct

struct GoHandle {
pub mut:
	return_type Type
}

struct Interface {
pub mut:
	types   []Type
	fields  []Field
	methods []Fn
}

fn (i &Interface) find_field(name string) ?Field

fn (i Interface) defines_method(name string) bool

struct Map {
pub mut:
	key_type   Type
	value_type Type
}

struct MultiReturn {
pub mut:
	types []Type
}

struct Param {
pub:
	pos       token.Position
	name      string
	is_mut    bool
	typ       Type
	type_pos  token.Position
	is_hidden bool
}

struct Struct {
pub:
	attrs []Attr
pub mut:
	embeds        []Type
	fields        []Field
	is_typedef    bool
	is_union      bool
	is_ref_only   bool
	generic_types []Type
}

fn (s Struct) find_field(name string) ?Field

fn (s Struct) get_field(name string) Field

struct SumType {
pub:
	variants []Type
}

struct Table {
pub mut:
	types         []TypeSymbol
	type_idxs     map[string]int
	fns           map[string]Fn
	imports       []string
	modules       []string
	cflags        []cflag.CFlag
	redefined_fns []string
	fn_gen_types  map[string][][]Type
	cmod_prefix   string
	is_fmt        bool
}

fn (mut t Table) add_placeholder_type(name string, language Language) int

fn (t &Table) array_cname(elem_type Type) string

fn (t &Table) array_fixed_cname(elem_type Type, size int) string

fn (t &Table) array_fixed_name(elem_type Type, size int) string

array_fixed_source_name generates the original name for the v source. e. g. [16][8]int

fn (t &Table) array_name(elem_type Type) string

array_source_name generates the original name for the v source. e. g. []int

fn (t &Table) chan_cname(elem_type Type, is_mut bool) string

fn (t &Table) chan_name(elem_type Type, is_mut bool) string

fn (t &Table) find_field(s &TypeSymbol, name string) ?Field

search from current type up through each parent looking for field

fn (t &Table) find_fn(name string) ?Fn

fn (mut t Table) find_or_register_array(elem_type Type) int

fn (mut t Table) find_or_register_array_fixed(elem_type Type, size int) int

fn (mut t Table) find_or_register_array_with_dims(elem_type Type, nr_dims int) int

fn (mut t Table) find_or_register_chan(elem_type Type, is_mut bool) int

fn (mut t Table) find_or_register_fn_type(mod string, f Fn, is_anon bool, has_decl bool) int

fn (mut t Table) find_or_register_gohandle(return_type Type) int

fn (mut t Table) find_or_register_map(key_type Type, value_type Type) int

fn (mut t Table) find_or_register_multi_return(mr_typs []Type) int

fn (t &Table) find_type(name string) ?TypeSymbol

fn (t &Table) find_type_idx(name string) int

fn (t &Table) fn_signature(func &Fn, opts FnSignatureOpts) string

fn (t &Table) fn_type_signature(f &Fn) string

used to compare fn's & for naming anon fn's

fn (t &Table) fn_type_source_signature(f &Fn) string

source_signature generates the signature of a function which looks like in the V source

fn (t &Table) get_final_type_symbol(typ Type) &TypeSymbol

get_final_type_symbol follows aliases until it gets to a "real" Type

fn (t &Table) get_type_name(typ Type) string

fn (t &Table) get_type_symbol(typ Type) &TypeSymbol

fn (t &Table) gohandle_cname(return_type Type) string

fn (t &Table) gohandle_name(return_type Type) string

fn (mytable &Table) has_deep_child_no_ref(ts &TypeSymbol, name string) bool

has_deep_child_no_ref returns true if type is struct and has any child or nested child with the type of the given name the given name consists of module and name (mod.Name) it doesn't care about childs that are references

fn (t &Table) is_same_method(f &Fn, func &Fn) string

fn (t &Table) known_fn(name string) bool

fn (t &Table) known_type(name string) bool

fn (mytable &Table) known_type_names() []string

fn (t &Table) map_cname(key_type Type, value_type Type) string

fn (t &Table) map_name(key_type Type, value_type Type) string

map_source_name generates the original name for the v source. e. g. map[string]int

fn (t &Table) mktyp(typ Type) Type

fn (mut mytable Table) parse_cflag(cflg string, mod string, ctimedefines []string) ?bool

parse the flags to (table.cflags) []CFlag Note: clean up big time (joe-c)

fn (t &Table) register_aggregate_method(mut sym TypeSymbol, name string) ?Fn

fn (mut t Table) register_builtin_type_symbols()

fn (mut t Table) register_fn(new_fn Fn)

fn (mut mytable Table) register_fn_gen_type(fn_name string, types []Type)

fn (mut t Table) register_type_symbol(typ TypeSymbol) int

fn (t &Table) struct_has_field(s &TypeSymbol, name string) bool

fn (mytable &Table) sumtype_has_variant(parent Type, variant Type) bool

TODO: there is a bug when casting sumtype the other way if its pointer so until fixed at least show v (not C) error x(variant) = y(SumType*)

fn (t &Table) type_find_method(s &TypeSymbol, name string) ?Fn

search from current type up through each parent looking for method

fn (t &Table) type_has_method(s &TypeSymbol, name string) bool

fn (table &Table) type_kind(typ Type) Kind

returns TypeSymbol kind only if there are no type modifiers

fn (mytable &Table) type_to_code(t Type) string

type name in code (for builtin)

fn (table &Table) type_to_str(t Type) string

human readable type name

fn (mytable &Table) type_to_str_using_aliases(t Type, import_aliases map[string]string) string

import_aliases is a map of imported symbol aliases 'module.Type' => 'Type'

fn (t &Table) unalias_num_type(typ Type) Type

fn (t &Table) value_type(typ Type) Type

struct TypeSymbol {
pub:
	parent_idx int
pub mut:
	info      TypeInfo
	kind      Kind
	name      string
	cname     string
	methods   []Fn
	mod       string
	is_public bool
	language  Language
}

Represents a type that only needs an identifier, e.g. int, array_int. A pointer type &T would have a TypeSymbol T. Note: For a Type, use: * Table.type_to_str(typ) not TypeSymbol.name. * Table.type_kind(typ) not TypeSymbol.kind. Each TypeSymbol is entered into Table.types. See also: Table.get_type_symbol.

fn (t &TypeSymbol) array_fixed_info() ArrayFixed

fn (t &TypeSymbol) array_info() Array

fn (t &TypeSymbol) chan_info() Chan

fn (ts TypeSymbol) debug() []string

fn (t &TypeSymbol) embed_name() string

fn (t &TypeSymbol) enum_info() Enum

fn (t &TypeSymbol) find_field(name string) ?Field

fn (t &TypeSymbol) find_method(name string) ?Fn

fn (t &TypeSymbol) gohandle_info() GoHandle

fn (t &TypeSymbol) has_method(name string) bool

fn (t &TypeSymbol) is_builtin() bool

fn (t &TypeSymbol) is_float() bool

fn (t &TypeSymbol) is_int() bool

fn (t &TypeSymbol) is_number() bool

fn (t &TypeSymbol) is_pointer() bool

fn (t &TypeSymbol) is_primitive() bool

fn (t &TypeSymbol) is_string() bool

fn (t &TypeSymbol) map_info() Map

fn (t &TypeSymbol) mr_info() MultiReturn

fn (mut t TypeSymbol) register_method(new_fn Fn) int

fn (t &TypeSymbol) str() string

fn (t &TypeSymbol) str_method_info() (bool, bool, int)

fn (t &TypeSymbol) struct_info() Struct

struct Var {
pub:
	name   string
	is_mut bool
mut:
	typ Type
}