ir

type Add ¶

type Add struct {
	TypeID TypeID // Operands type.
	token.Position
}

Add operation adds the top stack item (b) and the previous one (a) and replaces both operands with a + b.

func (o *Add) Pos() token.Position

func (o *Add) String() string

type AddressValue ¶

type AddressValue struct {
	// A negative value or object index as resolved by the linker.
	Index int
	Label NameID
	Linkage
	NameID NameID
	Offset uintptr
	// contains filtered or unexported fields
}

AddressValue is a declaration initializer constant of type address. Its final value is determined by the linker/loader.

func (v *AddressValue) String() string

type AllocResult ¶

type AllocResult struct {
	TypeID   TypeID
	TypeName NameID
	token.Position
}

AllocResult operation reserves evaluation stack space for a result of type TypeID.

func (o *AllocResult) Pos() token.Position

func (o *AllocResult) String() string

type And ¶

type And struct {
	TypeID TypeID // Operands type.
	token.Position
}

And operation replaces TOS with the bitwise and of the top two stack items.

func (o *And) Pos() token.Position

func (o *And) String() string

type Argument ¶

type Argument struct {
	Address bool
	Index   int
	TypeID  TypeID
	token.Position
}

Argument pushes argument Index, or its address, to the evaluation stack.

func (o *Argument) Pos() token.Position

func (o *Argument) String() string

type Arguments ¶

type Arguments struct {
	token.Position
	FunctionPointer bool // TOS contains a function pointer for a subsequent CallFP. Determined by linker.
}

Arguments operation annotates that function results, if any, are allocated and a function pointer is at TOS. Evaluation of any function arguments follows.

func (o *Arguments) Pos() token.Position

func (o *Arguments) String() string

type ArrayType ¶

type ArrayType struct {
	TypeBase
	Item  Type
	Items int64
}

ArrayType represents a collection of items that can be selected by index.

func (t *ArrayType) Pointer() Type

type BeginScope ¶

type BeginScope struct {
	// Evaluation stack may be non-empty on entering the scope. See
	// https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html
	Value bool
	token.Position
}

BeginScope operation annotates entering a block scope.

func (o *BeginScope) Pos() token.Position

func (o *BeginScope) String() string

type Bool ¶

type Bool struct {
	TypeID TypeID // Operand type.
	token.Position
}

Bool operation converts TOS to a bool (ie. an int32) such that the result reflects if the operand was non zero.

func (o *Bool) Pos() token.Position

func (o *Bool) String() string

type Call ¶

type Call struct {
	Arguments int    // Actual number of arguments passed to function.
	Comma     bool   // The call operation is produced by the C comma operator for a void function.
	Index     int    // A negative value or an function object index as resolved by the linker.
	TypeID    TypeID // Type of the function.
	token.Position
}

Call operation performs a static function call. The evaluation stack contains the space reseved for function results, if any, and any function arguments. On return all arguments are removed from the stack.

func (o *Call) Pos() token.Position

func (o *Call) String() string

type CallFP ¶

type CallFP struct {
	Arguments int    // Actual number of arguments passed to function.
	Comma     bool   // The call FP operation is produced by the C comma operator for a void function.
	TypeID    TypeID // Type of the function pointer.
	token.Position
}

CallFP operation performs a function pointer call. The evaluation stack contains the space reseved for function results, if any, the function pointer and any function arguments. On return all arguments and the function pointer are removed from the stack.

func (o *CallFP) Pos() token.Position

func (o *CallFP) String() string

type Complex128Value ¶

type Complex128Value struct {
	Value complex128
	// contains filtered or unexported fields
}

Complex128Value is a declaration initializer constant of type complex128.

func (v *Complex128Value) String() string

type Complex64Value ¶

type Complex64Value struct {
	Value complex64
	// contains filtered or unexported fields
}

Complex64Value is a declaration initializer constant of type complex64.

func (v *Complex64Value) String() string

type CompositeValue ¶

type CompositeValue struct {
	Values []Value
	// contains filtered or unexported fields
}

CompositeValue represents a constant array/struct initializer.

func (v *CompositeValue) String() string

type Const ¶

type Const struct {
	TypeID TypeID
	Value  Value
	token.Position
}

Const operation pushes a constant value on the evaluation stack.

func (o *Const) Pos() token.Position

func (o *Const) String() string

type Const32 ¶

type Const32 struct {
	LOp    bool // This operation is an artifact of || or &&.
	TypeID TypeID
	Value  int32
	token.Position
}

Const32 operation pushes a 32 bit value on the evaluation stack.

func (o *Const32) Pos() token.Position

func (o *Const32) String() string

type Const64 ¶

type Const64 struct {
	TypeID TypeID
	Value  int64
	token.Position
}

Const64 operation pushes a 64 bit value on the evaluation stack.

func (o *Const64) Pos() token.Position

func (o *Const64) String() string

type ConstC128 ¶

type ConstC128 struct {
	TypeID TypeID
	Value  complex128
	token.Position
}

ConstC128 operation pushes a complex128 value on the evaluation stack.

func (o *ConstC128) Pos() token.Position

func (o *ConstC128) String() string

type Convert ¶

type Convert struct {
	Result TypeID // Conversion type.
	TypeID TypeID // Operand type.
	token.Position
}

Convert operation converts TOS to the result type.

func (o *Convert) Pos() token.Position

func (o *Convert) String() string

type Copy ¶

type Copy struct {
	TypeID TypeID // Operand type.
	token.Position
}

Copy assigns source, which address is at TOS, to dest, which address is the previous stack item. The source address is removed from the stack.

func (o *Copy) Pos() token.Position

func (o *Copy) String() string

type Cpl ¶

type Cpl struct {
	TypeID TypeID // Operand type.
	token.Position
}

Cpl operation replaces TOS with ^TOS (bitwise complement).

func (o *Cpl) Pos() token.Position

func (o *Cpl) String() string

type DataDefinition ¶

type DataDefinition struct {
	ObjectBase
	Value
}

DataDefinition represents a variable definition and an optional initializer value.

func NewDataDefinition(p token.Position, name, typeName NameID, typ TypeID, l Linkage, initializer Value) *DataDefinition

func (d *DataDefinition) Verify() error

type DesignatedValue ¶

type DesignatedValue struct {
	Index int // Array index or field index.
	Value
}

DesignatedValue represents the value of a particular array element or a particular struct field.

func (v *DesignatedValue) String() string

type Div ¶

type Div struct {
	TypeID TypeID // Operands type.
	token.Position
}

Div operation subtracts the top stack item (b) and the previous one (a) and replaces both operands with a / b. The operation panics if operands are integers and b == 0.

func (o *Div) Pos() token.Position

func (o *Div) String() string

type Drop ¶

type Drop struct {
	Comma  bool // The drop operation is produced by the C comma operator.
	LOp    bool // This operation is an artifact of || or &&.
	TypeID TypeID
	token.Position
}

Drop operation removes one item from the evaluation stack.

func (o *Drop) Pos() token.Position

func (o *Drop) String() string

type Dup ¶

type Dup struct {
	TypeID TypeID
	token.Position
}

Dup operation duplicates the top stack item.

func (o *Dup) Pos() token.Position

func (o *Dup) String() string

type Element ¶

type Element struct {
	Address   bool
	IndexType TypeID
	Neg       bool   // Negate the index expression.
	TypeID    TypeID // The indexed type.
	token.Position
}

Element replaces a pointer and index with the indexed element or its address.

func (o *Element) Pos() token.Position

func (o *Element) String() string

type EndScope ¶

type EndScope struct {
	// Leaving the scope may leave values on the evaluation stack. See
	// https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html
	Value bool
	token.Position
}

EndScope operation annotates leaving a block scope.

func (o *EndScope) Pos() token.Position

func (o *EndScope) String() string

type Eq ¶

type Eq struct {
	TypeID TypeID // Operands type.
	token.Position
}

Eq operation compares the top stack item (b) and the previous one (a) and replaces both operands with a non zero int32 value if a == b or zero otherwise.

func (o *Eq) Pos() token.Position

func (o *Eq) String() string

type Field ¶

type Field struct {
	Address bool
	Index   int
	TypeID  TypeID // Pointer to a struct/union.
	token.Position
}

Field replaces a struct/union pointer at TOS with its field by index, or its address.

func (o *Field) Pos() token.Position

func (o *Field) String() string

type FieldProperties ¶

type FieldProperties struct {
	Offset  int64 // Relative to start of the struct/union.
	Size    int64 // Field size for copying.
	Padding int   // Adjustment to enforce proper alignment.
}

FieldProperties describe a struct/union field.

func (f *FieldProperties) Sizeof() int64

type FieldValue ¶

type FieldValue struct {
	Index  int
	TypeID TypeID // Struct/union type.
	token.Position
}

FieldValue replaces a struct/union at TOS with its field by index.

func (o *FieldValue) Pos() token.Position

func (o *FieldValue) String() string

type Float32Value ¶

type Float32Value struct {
	Value float32
	// contains filtered or unexported fields
}

Float32Value is a declaration initializer constant of type float32.

func (v *Float32Value) String() string

type Float64Value ¶

type Float64Value struct {
	Value float64
	// contains filtered or unexported fields
}

Float64Value is a declaration initializer constant of type float64.

func (v *Float64Value) String() string

type FunctionDefinition ¶

type FunctionDefinition struct {
	Arguments []NameID // May be nil.
	Body      []Operation
	ObjectBase
	Results []NameID // May be nil.
}

FunctionDefinition represents a function definition.

func NewFunctionDefinition(p token.Position, name, typeName NameID, typ TypeID, l Linkage, argumnents, results []NameID) *FunctionDefinition

func (f *FunctionDefinition) Verify() (err error)

type FunctionType ¶

type FunctionType struct {
	TypeBase
	Arguments []Type
	Results   []Type
	Variadic  bool // C-variadic.
}

FunctionType represents a function, its possibly variadic, optional arguments and results.

func (t *FunctionType) Pointer() Type

type Geq ¶

type Geq struct {
	TypeID TypeID // Operands type.
	token.Position
}

Geq operation compares the top stack item (b) and the previous one (a) and replaces both operands with a non zero int32 value if a >= b or zero otherwise.

func (o *Geq) Pos() token.Position

func (o *Geq) String() string

type Global ¶

type Global struct {
	Address bool
	Index   int // A negative value or an object index as resolved by the linker.
	Linkage
	NameID   NameID
	TypeID   TypeID
	TypeName NameID
	token.Position
}

Global operation pushes a global variable, or its address, to the evaluation stack.

func (o *Global) Pos() token.Position

func (o *Global) String() string

type Gt ¶

type Gt struct {
	TypeID TypeID // Operands type.
	token.Position
}

Gt operation compares the top stack item (b) and the previous one (a) and replaces both operands with a non zero int32 value if a > b or zero otherwise.

func (o *Gt) Pos() token.Position

func (o *Gt) String() string

type Int32Value ¶

type Int32Value struct {
	Value int32
	// contains filtered or unexported fields
}

Int32Value is a declaration initializer constant of type int32.

func (v *Int32Value) String() string

type Int64Value ¶

type Int64Value struct {
	Value int64
	// contains filtered or unexported fields
}

Int64Value is a declaration initializer constant of type int64.

func (v *Int64Value) String() string

type Jmp ¶

type Jmp struct {
	Cond   bool // This operation is an artifact of the conditional operator.
	NameID NameID
	Number int
	token.Position
}

Jmp operation performs a branch to a named or numbered label.

func (o *Jmp) Pos() token.Position

func (o *Jmp) String() string

type JmpP ¶

type JmpP struct {
	token.Position
}

JmpP operation performs a branch to pointer at TOS.

func (o *JmpP) Pos() token.Position

func (o *JmpP) String() string

type Jnz ¶

type Jnz struct {
	LOp    bool // This operation is an artifact of || or &&.
	NameID NameID
	Number int
	token.Position
}

Jnz operation performs a branch to a named or numbered label if the top of the stack is non zero. The TOS type must be int32 and the operation removes TOS.

func (o *Jnz) Pos() token.Position

func (o *Jnz) String() string

type Jz ¶

type Jz struct {
	LOp    bool // This operation is an artifact of || or && or the conditional operator.
	NameID NameID
	Number int
	token.Position
}

Jz operation performs a branch to a named or numbered label if the top of the stack is zero. The TOS type must be int32 and the operation removes TOS.

func (o *Jz) Pos() token.Position

func (o *Jz) String() string

type Label ¶

type Label struct {
	Cond   bool // This operation is an artifact of the conditional operator.
	LAnd   bool // This operation is an artifact of &&.
	LOr    bool // This operation is an artifact of ||.
	NameID NameID
	Nop    bool // This operation is an artifact of the conditional operator.
	Number int
	token.Position
}

Label operation declares a named or numbered branch target. A valid Label must have a non zero NameID or non negative Number.

func (o *Label) IsValid() bool

func (o *Label) Pos() token.Position

func (o *Label) String() string

type Leq ¶

type Leq struct {
	TypeID TypeID // Operands type.
	token.Position
}

Leq operation compares the top stack item (b) and the previous one (a) and replaces both operands with a non zero int32 value if a <= b or zero otherwise.

func (o *Leq) Pos() token.Position

func (o *Leq) String() string

type Linkage ¶

type Linkage int

Linkage represents a linkage type.

const (
	ExternalLinkage Linkage
	InternalLinkage
)

func (i Linkage) String() string

type Load ¶

type Load struct {
	TypeID TypeID // Pointer type.
	token.Position
}

Load replaces a pointer at TOS by its pointee.

func (o *Load) Pos() token.Position

func (o *Load) String() string

type Lsh ¶

type Lsh struct {
	TypeID TypeID // Operand (a) type.
	token.Position
}

Lsh operation uses the top stack item (b), which must be an int32, and the previous one (a), which must be an integral type and replaces both operands with a << b.

func (o *Lsh) Pos() token.Position

func (o *Lsh) String() string

type Lt ¶

type Lt struct {
	TypeID TypeID // Operands type.
	token.Position
}

Lt operation compares the top stack item (b) and the previous one (a) and replaces both operands with a non zero int32 value if a < b or zero otherwise.

func (o *Lt) Pos() token.Position

func (o *Lt) String() string

type MemoryModel ¶

type MemoryModel map[TypeKind]MemoryModelItem

MemoryModel defines properties of types. A valid memory model must provide model items for all type kinds except Array, Struct and Union. Methods of invalid models may panic. Memory model instances are not modified by this package and safe for concurrent use by multiple goroutines as long as any of them does not modify them either.

func NewMemoryModel() (MemoryModel, error)

func (m MemoryModel) Alignof(t Type) int

func (m MemoryModel) Layout(t *StructOrUnionType) []FieldProperties

func (m MemoryModel) Sizeof(t Type) int64

func (m MemoryModel) StructAlignof(t Type) int

type MemoryModelItem ¶

type MemoryModelItem struct {
	Size        uint
	Align       uint
	StructAlign uint
}

MemoryModelItem describes memory properties of a particular type kind.

type Mul ¶

type Mul struct {
	TypeID TypeID // Operands type.
	token.Position
}

Mul operation subtracts the top stack item (b) and the previous one (a) and replaces both operands with a * b.

func (o *Mul) Pos() token.Position

func (o *Mul) String() string

type NameID ¶

type NameID int

NameID is a numeric identifier of an identifier as registered in a global dictionary[0].

[0]: https://godoc.org/modernc.org/xc#pkg-variables

func (t *NameID) GobDecode(b []byte) error

func (t NameID) GobEncode() ([]byte, error)

func (t NameID) String() string

type Neg ¶

type Neg struct {
	TypeID TypeID // Operand type.
	token.Position
}

Neg operation replaces TOS with 0-TOS.

func (o *Neg) Pos() token.Position

func (o *Neg) String() string

type Neq ¶

type Neq struct {
	TypeID TypeID // Operands type.
	token.Position
}

Neq operation compares the top stack item (b) and the previous one (a) and replaces both operands with a non zero int32 value if a != b or zero otherwise.

func (o *Neq) Pos() token.Position

func (o *Neq) String() string

type Nil ¶

type Nil struct {
	TypeID TypeID // Pointer type.
	token.Position
}

Nil pushes a typed nil to TOS.

func (o *Nil) Pos() token.Position

func (o *Nil) String() string

type Not ¶

type Not struct {
	token.Position
}

Not replaces the boolean value at TOS with !value. The TOS type must be int32.

func (o *Not) Pos() token.Position

func (o *Not) String() string

type Object ¶

type Object interface {
	// Verify checks if the object is well-formed. Verify may mutate the
	// object. For example, Verify may remove provably unreachable code of
	// a FunctionDefinition.Body.
	Verify() error
	Base() *ObjectBase
}

Object represents a declarations or definitions of static data and functions.

func LinkLib(translationUnits ...[]Object) (_ []Object, err error)

func LinkMain(translationUnits ...[]Object) (_ []Object, err error)

type ObjectBase ¶

type ObjectBase struct {
	Comment NameID
	Linkage
	NameID   NameID
	Package  NameID
	TypeID   TypeID
	TypeName NameID
	token.Position
}

ObjectBase collects fields common to all objects.

func (o *ObjectBase) Base() *ObjectBase

type Objects ¶

type Objects [][]Object

Objects represent []Object implementing io.ReaderFrom and io.WriterTo.

func (o *Objects) ReadFrom(r io.Reader) (n int64, err error)

func (o Objects) WriteTo(w io.Writer) (n int64, err error)

type Operation ¶

type Operation interface {
	Pos() token.Position
	// contains filtered or unexported methods
}

Operation is a unit of execution.

type Or ¶

type Or struct {
	TypeID TypeID // Operands type.
	token.Position
}

Or operation replaces TOS with the bitwise or of the top two stack items.

func (o *Or) Pos() token.Position

func (o *Or) String() string

type Panic ¶

type Panic struct {
	token.Position
}

Panic operation aborts execution with a stack trace.

func (o *Panic) Pos() token.Position

func (o *Panic) String() string

type PointerType ¶

type PointerType struct {
	TypeBase
	Element Type
}

PointerType represents a pointer to an element, an instance of another type.

func (t *PointerType) Pointer() Type

type PostIncrement ¶

type PostIncrement struct {
	BitFieldType TypeID
	BitOffset    int
	Bits         int
	Delta        int
	TypeID       TypeID // Operand type.
	token.Position
}

PostIncrement operation adds Delta to the value pointed to by address at TOS and replaces TOS by the value pointee had before the increment. If Bits is non zero then the effective operand type is BitFieldType and the bit field starts at bit BitOffset.

func (o *PostIncrement) Pos() token.Position

func (o *PostIncrement) String() string

type PreIncrement ¶

type PreIncrement struct {
	BitFieldType TypeID
	BitOffset    int
	Bits         int
	Delta        int
	TypeID       TypeID // Operand type.
	token.Position
}

PreIncrement operation adds Delta to the value pointed to by address at TOS and replaces TOS by the new value of the pointee. If Bits is non zero then the effective operand type is BitFieldType and the bit field starts at bit BitOffset.

func (o *PreIncrement) Pos() token.Position

func (o *PreIncrement) String() string

type PtrDiff ¶

type PtrDiff struct {
	PtrType TypeID
	TypeID  TypeID // Operands type.
	token.Position
}

PtrDiff operation subtracts the top stack item (b) and the previous one (a) and replaces both operands with a - b of type TypeID.

func (o *PtrDiff) Pos() token.Position

func (o *PtrDiff) String() string

type Rem ¶

type Rem struct {
	TypeID TypeID // Operands type.
	token.Position
}

Rem operation divides the top stack item (b) and the previous one (a) and replaces both operands with a % b. The operation panics if b == 0.

func (o *Rem) Pos() token.Position

func (o *Rem) String() string

type Result ¶

type Result struct {
	Address bool
	Index   int
	TypeID  TypeID
	token.Position
}

Result pushes a function result by index, or its address, to the evaluation stack.

func (o *Result) Pos() token.Position

func (o *Result) String() string

type Return ¶

type Return struct {
	token.Position
}

Return operation removes all function call arguments from the evaluation stack as well as the function pointer used in the call, if any.

func (o *Return) Pos() token.Position

func (o *Return) String() string

type Rsh ¶

type Rsh struct {
	TypeID TypeID // Operand (a) type.
	token.Position
}

Rsh operation uses the top stack item (b), which must be an int32, and the previous one (a), which must be an integral type and replaces both operands with a >> b.

func (o *Rsh) Pos() token.Position

func (o *Rsh) String() string

type Store ¶

type Store struct {
	BitOffset int
	Bits      int
	TypeID    TypeID // Type of the value.
	token.Position
}

Store operation stores a TOS value at address in the preceding stack position. The address is removed from the evaluation stack. If Bits is non zero then the destination is a bit field starting at bit BitOffset.

func (o *Store) Pos() token.Position

func (o *Store) String() string

type StringConst ¶

type StringConst struct {
	Value  StringID
	TypeID TypeID // Type of the pointer to the string value.
	token.Position
}

StringConst operation pushes a string value on the evaluation stack.

func (o *StringConst) Pos() token.Position

func (o *StringConst) String() string

type StringID ¶

type StringID int

StringID is a numeric identifier of a string literal as registered in a global dictionary[0].

[0]: https://godoc.org/modernc.org/xc#pkg-variables

func (t *StringID) GobDecode(b []byte) error

func (t StringID) GobEncode() ([]byte, error)

func (t StringID) String() string

type StringValue ¶

type StringValue struct {
	Offset   uintptr
	StringID StringID
	// contains filtered or unexported fields
}

StringValue is a declaration initializer constant of type string.

func (v *StringValue) String() string

type StructOrUnionType ¶

type StructOrUnionType struct {
	Fields []Type
	Names  []NameID
	TypeBase
}

StructOrUnionType represents a collection of fields that can be selected by name.

func (t *StructOrUnionType) Pointer() Type

type Sub ¶

type Sub struct {
	TypeID TypeID // Operands type.
	token.Position
}

Sub operation subtracts the top stack item (b) and the previous one (a) and replaces both operands with a - b.

func (o *Sub) Pos() token.Position

func (o *Sub) String() string

type Switch ¶

type Switch struct {
	Default Label
	Labels  []Label
	TypeID  TypeID // Operand type.
	Values  []Value
	token.Position
}

Switch jumps to a label according to a value at TOS or to a default label. The value at TOS is removed from the evaluation stack.

func (o *Switch) Pos() token.Position

func (o *Switch) String() string

type Type ¶

type Type interface {
	Equal(Type) bool
	ID() TypeID
	Kind() TypeKind
	Pointer() Type
	Signed() bool
}

Type represents an IR type.

The type specifier syntax is defined using Extended Backus-Naur Form (EBNF[0]):

Type		= ArrayType | FunctionType | PointerType | StructType | TypeName | UnionType .
ArrayType	= "[" "0"..."9" { "0"..."9" } "]" Type .
FunctionType	= "func" "(" [ TypeList ] [ "..." ] ")" [ Type | "(" TypeList ")" ] .
PointerType	= "*" Type .
StructType	= "struct" "{" [ FieldList ] "}" .
Fieldist	= name " " Type { "," name " " Type } .
TypeList	= Type { "," Type } .
TypeName	= "uint8" | "uint16" | "uint32" | "uint64"
		| "int8" | "int16" | "int32" | "int64"
		| "float32" | "float64" | "float128"
		| "complex64" | "complex128" | complex256
		| "uint0" | "uint8" | "uint16" | "uint32" | "uint64" .
UnionType	= "union" "{" [ FieldList ] "}" .

No whitespace is allowed in type specifiers except as the name Type separator.

[0]: https://golang.org/ref/spec#Notation

Type identity ¶

Two types are identical if their type specifiers are equivalent.

type TypeBase ¶

type TypeBase struct {
	TypeKind
	TypeID
}

TypeBase collects fields common to all types.

func (t *TypeBase) Pointer() Type

func (t *TypeBase) String() string

type TypeCache ¶

type TypeCache map[TypeID]Type

TypeCache maps TypeIDs to Types. Use TypeCache{} to create a ready to use TypeCache value.

func (c TypeCache) MustType(id TypeID) Type

func (c TypeCache) Type(id TypeID) (Type, error)

type TypeID ¶

type TypeID int

TypeID is a numeric identifier of a type specifier as registered in a global dictionary[0].

[0]: https://godoc.org/modernc.org/xc#pkg-variables

func (t TypeID) Equal(u Type) bool

func (t *TypeID) GobDecode(b []byte) error

func (t TypeID) GobEncode() ([]byte, error)

func (t TypeID) ID() TypeID

func (t TypeID) Signed() bool

func (t TypeID) String() string

type TypeKind ¶

type TypeKind int

TypeKind represents a particular type kind.

const (
	Int8 TypeKind
	Int16
	Int32
	Int64

	Uint8
	Uint16
	Uint32
	Uint64

	Float32
	Float64
	Float128

	Complex64
	Complex128
	Complex256

	Array
	Union
	Struct
	Pointer
	Function
)

func (k TypeKind) Kind() TypeKind

func (i TypeKind) String() string

type Value ¶

type Value interface {
	// contains filtered or unexported methods
}

Value represents a constant expression used for initializing static data or function variables.

type Variable ¶

type Variable struct {
	Address bool
	Index   int
	TypeID  TypeID
	token.Position
}

Variable pushes a function local variable by index, or its address, to the evaluation stack.

func (o *Variable) Pos() token.Position

func (o *Variable) String() string

type VariableDeclaration ¶

type VariableDeclaration struct {
	Index    int // 0-based index within a function.
	NameID   NameID
	TypeID   TypeID
	TypeName NameID
	Value
	token.Position
}

VariableDeclaration operation declares a function local variable. NameID, TypeName and Value are all optional.

func (o *VariableDeclaration) Pos() token.Position

func (o *VariableDeclaration) String() string

type WideStringValue ¶

type WideStringValue struct {
	Value []rune
	// contains filtered or unexported fields
}

WideStringValue is a declaration initializer constant of type wide string.

func (v *WideStringValue) String() string

type Xor ¶

type Xor struct {
	TypeID TypeID // Operands type.
	token.Position
}

Xor operation replaces TOS with the bitwise xor of the top two stack items.

func (o *Xor) Pos() token.Position

func (o *Xor) String() string