ir

Documentation

Index

• func DumpFacts(builder *CFGBuilder, factsInFolder string)
• func GetDot(b *CFGBuilder) string
• func Walk(v Visitor, node Node, prev_node Node)
• type AbsDD
• type AbsTD
• type AbsTT
• type Accept
• type AllDD
• type AllTD
• type AllTT
• type AppDD
• type AppTD
• type AppTT
• type Bind
• type Bnr
• type BnrType
• type Builtin
• type BuiltinADTs
  • func StdLib(builder *CFGBuilder) BuiltinADTs
• type BuiltinVar
• type CFGBuilder
  • func BuildCFG(n ast.AstNode) *CFGBuilder
  • func (builder *CFGBuilder) TypeOf(d Data) Type
  • func (builder *CFGBuilder) Visit(node ast.AstNode) ast.Visitor
• type CallProc
• type Cond
• type Data
• type DataCase
• type DataVar
• type Enum
• type EnumType
• type Event
• type Exc
• type ExcType
• type FactsDumper
  • func (fd *FactsDumper) Visit(node Node, prev Node) Visitor
• type IDNode
  • func (i *IDNode) ID() int64
• type Int
• type IntType
• type Jump
• type Kind
  • func KindOf(t Type) Kind
• type Load
• type Map
• type MapType
• type Msg
• type MsgType
• type Nat
• type NatType
• type Node
• type PickData
• type PickProc
• type Proc
• type ProcCase
• type ProcType
• type Raw
• type RawType
• type Save
• type Send
• type SetKind
• type Str
• type StrType
• type Type
• type TypeVar
• type Unit
• type Visitor

Functions

func DumpFacts

func DumpFacts(builder *CFGBuilder, factsInFolder string)

func GetDot

func GetDot(b *CFGBuilder) string

func Walk

func Walk(v Visitor, node Node, prev_node Node)

Types

type AbsDD

type AbsDD struct {
	IDNode
	Vars []DataVar
	Term Data
}

AbsDD :

type AbsTD

type AbsTD struct {
	IDNode
	Vars []TypeVar
	Term Data
}

AbsTD :

type AbsTT

type AbsTT struct {
	IDNode
	Vars []TypeVar
	Term Type
}

AbsTT :

type Accept

type Accept struct {
	IDNode
}

Accept :

type AllDD

type AllDD struct {
	IDNode
	Vars []DataVar
	Term Type
}

AllDD :

type AllTD

type AllTD struct {
	IDNode
	Vars []TypeVar
	Term Type
}

AllTD :

type AllTT

type AllTT struct {
	IDNode
	Vars []TypeVar
	Term Kind
}

AllTT :

type AppDD

type AppDD struct {
	IDNode
	Args []Data
	To   Data
}

AppDD :

type AppTD

type AppTD struct {
	IDNode
	Args []Type
	To   Data
}

AppTD :

type AppTT

type AppTT struct {
	IDNode
	Args []Type
	To   Type
}

AppTT :

type Bind

type Bind struct {
	IDNode
	BindType Type
	Cond     *Cond
}

Bind :

type Bnr

type Bnr struct {
	IDNode
	BnrType *BnrType
	Data    string
}

Bnr :

type BnrType

type BnrType struct {
	IDNode
}

BnrType :

type Builtin

type Builtin struct {
	IDNode
	BuiltinType Type
	Label       string
}

type BuiltinADTs

type BuiltinADTs struct {
	Boolean Type
	TT      Data
	FF      Data

	List *AbsTT
	Nil  *AbsTD
	Cons *AbsTD

	Option *AbsTT
	None   *AbsTD
	Some   *AbsTD

	Product Type
	Pair    Data
	// contains filtered or unexported fields
}

func StdLib

func StdLib(builder *CFGBuilder) BuiltinADTs

type BuiltinVar

type BuiltinVar struct {
	IDNode
	BuiltinVarType Type
	Label          string
}

type CFGBuilder

type CFGBuilder struct {
	Constructor *Proc
	Transitions map[string]*Proc
	Procedures  map[string]*Proc
	// contains filtered or unexported fields
}

func BuildCFG

func BuildCFG(n ast.AstNode) *CFGBuilder

func (*CFGBuilder) TypeOf

func (builder *CFGBuilder) TypeOf(d Data) Type

func (*CFGBuilder) Visit

func (builder *CFGBuilder) Visit(node ast.AstNode) ast.Visitor

type CallProc

type CallProc struct {
	IDNode
	Args []Data
	To   Data
}

CallProc :

type Cond

type Cond struct {
	IDNode
	Case string
	Data []Bind
}

Cond :

type Data

type Data interface {
	Node
	// contains filtered or unexported methods
}

Data :

type DataCase

type DataCase struct {
	IDNode
	Bind Bind
	Body Data
}

DataCase :

type DataVar

type DataVar struct {
	IDNode
	DataType Type
}

DataVar :

type Enum

type Enum struct {
	IDNode
	EnumType Type
	Case     string
	Data     []Data
}

Enum :

type EnumType

type EnumType struct {
	IDNode
	Constructors map[string][]Type
}

EnumType :

type Event

type Event struct {
	IDNode
	Data Data
}

Event :

type Exc

type Exc struct {
	IDNode
	ExcType *ExcType
	Data    string
}

Exc :

type ExcType

type ExcType struct {
	IDNode
}

ExcType :

type FactsDumper

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

func (*FactsDumper) Visit

func (fd *FactsDumper) Visit(node Node, prev Node) Visitor

type IDNode

type IDNode struct {
	Id int64
}

func (*IDNode) ID

func (i *IDNode) ID() int64

type Int

type Int struct {
	IDNode
	IntType *IntType
	Data    string
}

Int :

type IntType

type IntType struct {
	IDNode
	Size int
}

Int

type Jump

type Jump interface {
	Node
	// contains filtered or unexported methods
}

Jump :

type Kind

type Kind interface {
	Node
	// contains filtered or unexported methods
}

Kind :

func KindOf

func KindOf(t Type) Kind

type Load

type Load struct {
	IDNode
	Slot string
	Path []Data
}

Load :

type Map

type Map struct {
	IDNode
	MapType *MapType
	Data    map[string]string
}

Map :

type MapType

type MapType struct {
	IDNode
	KeyType Type
	ValType Type
}

MapType :

type Msg

type Msg struct {
	IDNode
	MsgType *MsgType
	Data    map[string]Data
}

Msg :

type MsgType

type MsgType struct {
	IDNode
}

MsgType :

type Nat

type Nat struct {
	IDNode
	NatType *NatType
	Data    string
}

Nat :

type NatType

type NatType struct {
	IDNode
	Size int
}

Uint

type Node

type Node interface {
	ID() int64
}

type PickData

type PickData struct {
	IDNode
	From Data
	With []DataCase
}

PickData :

type PickProc

type PickProc struct {
	IDNode
	From Data
	With []ProcCase
}

PickProc :

type Proc

type Proc struct {
	IDNode
	ProcName string
	Vars     []DataVar
	Plan     []Unit
	Jump     Jump
}

Proc :

type ProcCase

type ProcCase struct {
	IDNode
	Bind Bind
	Body Proc
}

ProcCase :

type ProcType

type ProcType struct {
	IDNode
	Vars []DataVar
}

ProcType :

type Raw

type Raw struct {
	IDNode
	RawType *RawType
	Data    string
}

Raw :

type RawType

type RawType struct {
	IDNode
	Size int
}

ByStr

type Save

type Save struct {
	IDNode
	Slot string
	Path []Data
	Data Data
}

Save :

type Send

type Send struct {
	IDNode
	Data Data
}

Send :

type SetKind

type SetKind struct {
	IDNode
}

SetKind :

type Str

type Str struct {
	IDNode
	StrType *StrType
	Data    string
}

Str :

type StrType

type StrType struct {
	IDNode
}

StrType :

type Type

type Type interface {
	Node
	// contains filtered or unexported methods
}

Type :

type TypeVar

type TypeVar struct {
	IDNode
	Kind Kind
}

TypeVar :

type Unit

type Unit interface {
	Node
	// contains filtered or unexported methods
}

Unit :

type Visitor

type Visitor interface {
	Visit(x Node, prevX Node) (w Visitor)
}