cxgo

package module

Go to main page

Versions in this module

v0

v0.3.7

Oct 16, 2022

Changes in this version

+ func ErrorWithPos(err error, where token.Position) error

+ func ErrorfWithPos(where token.Position, format string, args ...any) error

type BoolOp

+ func (op BoolOp) Negate() BoolOp

type ExpandExpr

+ X Expr

+ type FileError struct

+ Err error

+ Where token.Position

+ func (e *FileError) Error() string

+ func (e *FileError) Unwrap() error

type FloatLit

+ func (l FloatLit) IsNegative() bool

type IntLit

+ func (l IntLit) IsNegative() bool

type MakeExpr

+ Cap Expr

type Number

+ IsNegative func() bool

type SliceExpr

+ High Expr

+ Low Expr

+ Max Expr

+ Slice3 bool

v0.3.6

Sep 4, 2022

Changes in this version

type GoDecl

+ func ImportsFor(e *libs.Env, decls []GoDecl) []GoDecl

v0.3.5

Jul 31, 2022

v0.3.4

Jun 2, 2022

v0.3.3

May 21, 2022

Changes in this version

type Config

+ GoFilePref string

+ UnexportedFields bool

v0.3.2

Jan 7, 2022

v0.3.1

Sep 15, 2021

v0.3.0

Feb 19, 2021

v0.2.1

Feb 7, 2021

v0.2.0

Jan 21, 2021

v0.1.1

Jan 13, 2021

Changes in this version

+ const HintString

type IdentConfig

+ Index int

v0.1.0

Jan 11, 2021

Changes in this version

+ const CLitChar

+ const CLitWChar

+ const HintBool

+ const HintIface

+ const HintSlice

+ func CallFinals() error

+ func IsNil(e Expr) bool

+ func Parse(c *libs.Env, root, fname string, sconf SourceConfig) (*cc.AST, error)

+ func ParseSource(env *libs.Env, c ParseConfig) (*cc.AST, error)

+ func PrintGo(w io.Writer, pkg string, decls []GoDecl) error

+ func RegisterASTHookC(fnc ASTHookCFunc)

+ func RegisterFinal(fnc func() error)

+ func ToFuncExpr(exp types.Type) *types.FuncType

+ func Translate(root, fname, out string, env *libs.Env, conf Config) error

+ type ASTHookCFunc func(c Config, fname string, decls []CDecl) error

+ type BaseBlock struct

+ func (b *BaseBlock) AddPrevBlock(b2 Block)

+ func (b *BaseBlock) PrevBlocks() []Block

+ type BinaryBoolExpr struct

+ Op BoolOp

+ X BoolExpr

+ Y BoolExpr

+ func (e *BinaryBoolExpr) AsExpr() GoExpr

+ func (e *BinaryBoolExpr) CType(types.Type) types.Type

+ func (e *BinaryBoolExpr) HasSideEffects() bool

+ func (e *BinaryBoolExpr) IsConst() bool

+ func (e *BinaryBoolExpr) Negate() BoolExpr

+ func (e *BinaryBoolExpr) Uses() []types.Usage

+ func (e *BinaryBoolExpr) Visit(v Visitor)

+ type BinaryOp string

+ const BinOpAdd

+ const BinOpBitAnd

+ const BinOpBitOr

+ const BinOpBitXor

+ const BinOpDiv

+ const BinOpLsh

+ const BinOpMod

+ const BinOpMult

+ const BinOpRsh

+ const BinOpSub

+ func (op BinaryOp) GoAssignToken() token.Token

+ func (op BinaryOp) GoToken() token.Token

+ func (op BinaryOp) IsArithm() bool

+ func (op BinaryOp) IsCommutative() bool

+ func (op BinaryOp) Precedence() int

+ type Block interface

+ AddPrevBlock func(b2 Block)

+ NextBlocks func() []Block

+ PrevBlocks func() []Block

+ ReplaceNext func(old, rep Block)

+ type BlockSet map[Block]struct

+ func (b BlockSet) Clone() BlockSet

+ func (b BlockSet) Contains(b2 BlockSet) bool

+ func (b BlockSet) Intersect(b2 BlockSet) BlockSet

+ func (b BlockSet) Union(b2 BlockSet) BlockSet

+ type BlockStmt struct

+ Stmts []CStmt

+ func (s *BlockStmt) AsStmt() []GoStmt

+ func (s *BlockStmt) EachStmt(fnc CStmtFunc) bool

+ func (s *BlockStmt) GoBlockStmt() *ast.BlockStmt

+ func (s *BlockStmt) In(ft *types.FuncType) *BlockStmt

+ func (s *BlockStmt) Uses() []types.Usage

+ func (s *BlockStmt) Visit(v Visitor)

+ type Bool bool

+ func (Bool) Visit(v Visitor)

+ func (e Bool) AsExpr() GoExpr

+ func (e Bool) CType(types.Type) types.Type

+ func (e Bool) HasSideEffects() bool

+ func (e Bool) IsConst() bool

+ func (e Bool) Negate() BoolExpr

+ func (e Bool) Uses() []types.Usage

+ type BoolAssert struct

+ X Expr

+ func (e BoolAssert) AsExpr() GoExpr

+ func (e BoolAssert) CType(types.Type) types.Type

+ func (e BoolAssert) HasSideEffects() bool

+ func (e BoolAssert) IsConst() bool

+ func (e BoolAssert) Negate() BoolExpr

+ func (e BoolAssert) Uses() []types.Usage

+ func (e BoolAssert) Visit(v Visitor)

+ type BoolExpr interface

+ Negate func() BoolExpr

+ func And(x, y BoolExpr) BoolExpr

+ func CompareFuncs(x FuncExpr, op ComparisonOp, y FuncExpr) BoolExpr

+ func ComparePtrs(x PtrExpr, op ComparisonOp, y PtrExpr) BoolExpr

+ func Or(x, y BoolExpr) BoolExpr

+ type BoolIdent struct

+ func (BoolIdent) Visit(v Visitor)

+ func (e BoolIdent) AsExpr() GoExpr

+ func (e BoolIdent) HasSideEffects() bool

+ func (e BoolIdent) Identifier() *types.Ident

+ func (e BoolIdent) IsConst() bool

+ func (e BoolIdent) Negate() BoolExpr

+ func (e BoolIdent) Uses() []types.Usage

+ type BoolOp string

+ const BinOpAnd

+ const BinOpOr

+ func (op BoolOp) GoToken() token.Token

+ type BoolToInt struct

+ X BoolExpr

+ func (e *BoolToInt) AsExpr() GoExpr

+ func (e *BoolToInt) CType(types.Type) types.Type

+ func (e *BoolToInt) HasSideEffects() bool

+ func (e *BoolToInt) IsConst() bool

+ func (e *BoolToInt) Uses() []types.Usage

+ func (e *BoolToInt) Visit(v Visitor)

+ type CAlignofExpr struct

+ Type types.Type

+ func (e *CAlignofExpr) AsExpr() GoExpr

+ func (e *CAlignofExpr) CType(types.Type) types.Type

+ func (e *CAlignofExpr) HasSideEffects() bool

+ func (e *CAlignofExpr) IsConst() bool

+ func (e *CAlignofExpr) Uses() []types.Usage

+ func (e *CAlignofExpr) Visit(v Visitor)

+ type CAsmExpr struct

+ func (e *CAsmExpr) AsExpr() GoExpr

+ func (e *CAsmExpr) CType(types.Type) types.Type

+ func (e *CAsmExpr) HasSideEffects() bool

+ func (e *CAsmExpr) IsConst() bool

+ func (e *CAsmExpr) Uses() []types.Usage

+ func (e *CAsmExpr) Visit(_ Visitor)

+ type CAssignExpr struct

+ Stmt *CAssignStmt

+ func (e *CAssignExpr) AsExpr() GoExpr

+ func (e *CAssignExpr) CType(types.Type) types.Type

+ func (e *CAssignExpr) HasSideEffects() bool

+ func (e *CAssignExpr) IsConst() bool

+ func (e *CAssignExpr) ToStmt() []CStmt

+ func (e *CAssignExpr) Uses() []types.Usage

+ func (e *CAssignExpr) Visit(v Visitor)

+ type CAssignStmt struct

+ Left Expr

+ Op BinaryOp

+ Right Expr

+ func (s *CAssignStmt) AsStmt() []GoStmt

+ func (s *CAssignStmt) Uses() []types.Usage

+ func (s *CAssignStmt) Visit(v Visitor)

+ type CBinaryExpr struct

+ Left Expr

+ Op BinaryOp

+ Right Expr

+ func (e *CBinaryExpr) AsExpr() GoExpr

+ func (e *CBinaryExpr) CType(exp types.Type) types.Type

+ func (e *CBinaryExpr) HasSideEffects() bool

+ func (e *CBinaryExpr) IsConst() bool

+ func (e *CBinaryExpr) Uses() []types.Usage

+ func (e *CBinaryExpr) Visit(v Visitor)

+ type CBreakStmt struct

+ func (s *CBreakStmt) AsStmt() []GoStmt

+ func (s *CBreakStmt) Uses() []types.Usage

+ func (s *CBreakStmt) Visit(v Visitor)

+ type CCaseStmt struct

+ Expr Expr

+ Stmts []CStmt

+ func (s *CCaseStmt) AsStmt() []GoStmt

+ func (s *CCaseStmt) GoCaseClause() *ast.CaseClause

+ func (s *CCaseStmt) Uses() []types.Usage

+ func (s *CCaseStmt) Visit(v Visitor)

+ type CCastExpr struct

+ Assert bool

+ Expr Expr

+ Type types.Type

+ func (e *CCastExpr) AsExpr() GoExpr

+ func (e *CCastExpr) CType(_ types.Type) types.Type

+ func (e *CCastExpr) HasSideEffects() bool

+ func (e *CCastExpr) IsConst() bool

+ func (e *CCastExpr) Uses() []types.Usage

+ func (e *CCastExpr) Visit(v Visitor)

+ type CCompLitExpr struct

+ Fields []*CompLitField

+ Type types.Type

+ func (e *CCompLitExpr) AsExpr() GoExpr

+ func (e *CCompLitExpr) CType(types.Type) types.Type

+ func (e *CCompLitExpr) HasSideEffects() bool

+ func (e *CCompLitExpr) IsConst() bool

+ func (e *CCompLitExpr) Uses() []types.Usage

+ func (e *CCompLitExpr) Visit(v Visitor)

+ type CCompStmt interface

+ EachStmt func(fnc CStmtFunc) bool

+ type CContinueStmt struct

+ func (s *CContinueStmt) AsStmt() []GoStmt

+ func (s *CContinueStmt) Uses() []types.Usage

+ func (s *CContinueStmt) Visit(v Visitor)

+ type CDecl interface

+ AsDecl func() []GoDecl

+ Uses func() []types.Usage

+ func TranslateCAST(fname string, tu *cc.AST, env *libs.Env, conf Config) ([]CDecl, error)

+ type CDeclStmt struct

+ Decl CDecl

+ func (s *CDeclStmt) AsStmt() []GoStmt

+ func (s *CDeclStmt) Uses() []types.Usage

+ func (s *CDeclStmt) Visit(v Visitor)

+ type CExprStmt struct

+ Expr Expr

+ func (s *CExprStmt) AsExpr() GoExpr

+ func (s *CExprStmt) AsStmt() []GoStmt

+ func (s *CExprStmt) CType() types.Type

+ func (s *CExprStmt) Uses() []types.Usage

+ func (s *CExprStmt) Visit(v Visitor)

+ type CForStmt struct

+ Body BlockStmt

+ Cond Expr

+ Init CStmt

+ Iter CStmt

+ func (s *CForStmt) AsStmt() []GoStmt

+ func (s *CForStmt) EachStmt(fnc CStmtFunc) bool

+ func (s *CForStmt) Uses() []types.Usage

+ func (s *CForStmt) Visit(v Visitor)

+ type CFuncDecl struct

+ Body *BlockStmt

+ Name *types.Ident

+ Range *Range

+ Type *types.FuncType

+ func (d *CFuncDecl) AsDecl() []GoDecl

+ func (d *CFuncDecl) Uses() []types.Usage

+ func (d *CFuncDecl) Visit(v Visitor)

+ type CGotoStmt struct

+ Label string

+ func (s *CGotoStmt) AsStmt() []GoStmt

+ func (s *CGotoStmt) Uses() []types.Usage

+ func (s *CGotoStmt) Visit(v Visitor)

+ type CIfStmt struct

+ Cond BoolExpr

+ Else IfElseStmt

+ Then *BlockStmt

+ func (s *CIfStmt) AsStmt() []GoStmt

+ func (s *CIfStmt) EachStmt(fnc CStmtFunc) bool

+ func (s *CIfStmt) Uses() []types.Usage

+ func (s *CIfStmt) Visit(v Visitor)

+ type CIncrExpr struct

+ Decr bool

+ Expr Expr

+ Prefix bool

+ func (e *CIncrExpr) AsExpr() GoExpr

+ func (e *CIncrExpr) CType(types.Type) types.Type

+ func (e *CIncrExpr) HasSideEffects() bool

+ func (e *CIncrExpr) IsConst() bool

+ func (e *CIncrExpr) ToStmt() []CStmt

+ func (e *CIncrExpr) Uses() []types.Usage

+ func (e *CIncrExpr) Visit(v Visitor)

+ type CIncrStmt struct

+ Decr bool

+ Expr Expr

+ func (s *CIncrStmt) AsStmt() []GoStmt

+ func (s *CIncrStmt) Uses() []types.Usage

+ func (s *CIncrStmt) Visit(v Visitor)

+ type CIndexExpr struct

+ Expr Expr

+ Index Expr

+ func (e *CIndexExpr) AsExpr() GoExpr

+ func (e *CIndexExpr) CType(types.Type) types.Type

+ func (e *CIndexExpr) HasSideEffects() bool

+ func (e *CIndexExpr) IndexZero() bool

+ func (e *CIndexExpr) IsConst() bool

+ func (e *CIndexExpr) Uses() []types.Usage

+ func (e *CIndexExpr) Visit(v Visitor)

+ type CLabelStmt struct

+ Label string

+ func (s *CLabelStmt) AsStmt() []GoStmt

+ func (s *CLabelStmt) Uses() []types.Usage

+ func (s *CLabelStmt) Visit(v Visitor)

+ type CLitKind int

+ type CLiteral struct

+ Kind CLitKind

+ Type types.Type

+ Value string

+ func (*CLiteral) Visit(v Visitor)

+ func (e *CLiteral) AsExpr() GoExpr

+ func (e *CLiteral) CType(types.Type) types.Type

+ func (e *CLiteral) HasSideEffects() bool

+ func (e *CLiteral) IsConst() bool

+ func (e *CLiteral) Uses() []types.Usage

+ type CMultiExpr struct

+ Exprs []Expr

+ func (e *CMultiExpr) AsExpr() GoExpr

+ func (e *CMultiExpr) CType(exp types.Type) types.Type

+ func (e *CMultiExpr) HasSideEffects() bool

+ func (e *CMultiExpr) IsConst() bool

+ func (e *CMultiExpr) Uses() []types.Usage

+ func (e *CMultiExpr) Visit(v Visitor)

+ type CParentExpr struct

+ Expr Expr

+ func (e *CParentExpr) AsExpr() GoExpr

+ func (e *CParentExpr) CType(types.Type) types.Type

+ func (e *CParentExpr) HasSideEffects() bool

+ func (e *CParentExpr) IsConst() bool

+ func (e *CParentExpr) Uses() []types.Usage

+ func (e *CParentExpr) Visit(v Visitor)

+ type CReturnStmt struct

+ Expr Expr

+ func (s *CReturnStmt) AsStmt() []GoStmt

+ func (s *CReturnStmt) Uses() []types.Usage

+ func (s *CReturnStmt) Visit(v Visitor)

+ type CSelectExpr struct

+ Expr Expr

+ Sel *types.Ident

+ func (e *CSelectExpr) AsExpr() GoExpr

+ func (e *CSelectExpr) CType(exp types.Type) types.Type

+ func (e *CSelectExpr) HasSideEffects() bool

+ func (e *CSelectExpr) IsConst() bool

+ func (e *CSelectExpr) Uses() []types.Usage

+ func (e *CSelectExpr) Visit(v Visitor)

+ type CSizeofExpr struct

+ Type types.Type

+ func (e *CSizeofExpr) AsExpr() GoExpr

+ func (e *CSizeofExpr) CType(types.Type) types.Type

+ func (e *CSizeofExpr) HasSideEffects() bool

+ func (e *CSizeofExpr) IsConst() bool

+ func (e *CSizeofExpr) Uses() []types.Usage

+ func (e *CSizeofExpr) Visit(v Visitor)

+ type CStmt interface

+ AsStmt func() []GoStmt

+ Uses func() []types.Usage

+ func NewCExprStmt(e Expr) []CStmt

+ func NewCExprStmt1(e Expr) CStmt

+ type CStmtConv interface

+ ToStmt func() []CStmt

+ type CStmtFunc func(s CStmt) ([]CStmt, bool)

+ type CSwitchStmt struct

+ Cases []*CCaseStmt

+ Cond Expr

+ func (s *CSwitchStmt) AsStmt() []GoStmt

+ func (s *CSwitchStmt) EachStmt(fnc CStmtFunc) bool

+ func (s *CSwitchStmt) Uses() []types.Usage

+ func (s *CSwitchStmt) Visit(v Visitor)

+ type CTernaryExpr struct

+ Cond BoolExpr

+ Else Expr

+ Then Expr

+ func (e *CTernaryExpr) AsExpr() GoExpr

+ func (e *CTernaryExpr) CType(types.Type) types.Type

+ func (e *CTernaryExpr) HasSideEffects() bool

+ func (e *CTernaryExpr) IsConst() bool

+ func (e *CTernaryExpr) ToStmt() []CStmt

+ func (e *CTernaryExpr) Uses() []types.Usage

+ func (e *CTernaryExpr) Visit(v Visitor)

+ type CTypeDef struct

+ func (d *CTypeDef) AsDecl() []GoDecl

+ func (d *CTypeDef) Uses() []types.Usage

+ func (d *CTypeDef) Visit(v Visitor)

+ type CUnaryExpr struct

+ Expr Expr

+ Op UnaryOp

+ func (e *CUnaryExpr) AsExpr() GoExpr

+ func (e *CUnaryExpr) CType(exp types.Type) types.Type

+ func (e *CUnaryExpr) HasSideEffects() bool

+ func (e *CUnaryExpr) IsConst() bool

+ func (e *CUnaryExpr) Uses() []types.Usage

+ func (e *CUnaryExpr) Visit(v Visitor)

+ type CVarDecl struct

+ Const bool

+ Single bool

+ func (d *CVarDecl) AsDecl() []GoDecl

+ func (d *CVarDecl) GoField() *GoField

+ func (d *CVarDecl) Visit(v Visitor)

+ type CVarSpec struct

+ Inits []Expr

+ Names []*types.Ident

+ Type types.Type

+ func (d *CVarSpec) GoSpecs(isConst bool) *ast.ValueSpec

+ func (d *CVarSpec) Uses() []types.Usage

+ func (d *CVarSpec) Visit(v Visitor)

+ type CallExpr struct

+ Args []Expr

+ Fun FuncExpr

+ func (e *CallExpr) AsExpr() GoExpr

+ func (e *CallExpr) CType(types.Type) types.Type

+ func (e *CallExpr) HasSideEffects() bool

+ func (e *CallExpr) IsConst() bool

+ func (e *CallExpr) Uses() []types.Usage

+ func (e *CallExpr) Visit(v Visitor)

+ type CodeBlock struct

+ Next Block

+ Stmts []CStmt

+ func (b *CodeBlock) NextBlocks() []Block

+ func (b *CodeBlock) ReplaceNext(old, rep Block)

+ type CompLitField struct

+ Field *types.Ident

+ Index Expr

+ Value Expr

+ func (e *CompLitField) Visit(v Visitor)

+ type Comparison struct

+ Op ComparisonOp

+ X Expr

+ Y Expr

+ func (e *Comparison) AsExpr() GoExpr

+ func (e *Comparison) CType(types.Type) types.Type

+ func (e *Comparison) HasSideEffects() bool

+ func (e *Comparison) IsConst() bool

+ func (e *Comparison) Negate() BoolExpr

+ func (e *Comparison) Uses() []types.Usage

+ func (e *Comparison) Visit(v Visitor)

+ type ComparisonOp string

+ const BinOpEq

+ const BinOpGt

+ const BinOpGte

+ const BinOpLt

+ const BinOpLte

+ const BinOpNeq

+ func (op ComparisonOp) GoToken() token.Token

+ func (op ComparisonOp) IsEquality() bool

+ func (op ComparisonOp) IsRelational() bool

+ func (op ComparisonOp) Negate() ComparisonOp

+ type CondBlock struct

+ Else Block

+ Expr Expr

+ Then Block

+ func NewCondBlock(expr Expr, then, els Block) *CondBlock

+ func (b *CondBlock) NextBlocks() []Block

+ func (b *CondBlock) ReplaceNext(old, rep Block)

+ type Config struct

+ Define []Define

+ FixImplicitReturns bool

+ FlattenAll bool

+ ForwardDecl bool

+ GoFile string

+ Hooks bool

+ Idents []IdentConfig

+ IgnoreIncludeDir bool

+ Include []string

+ MaxDecls int

+ Package string

+ Predef string

+ Replace []Replacer

+ Root string

+ SkipDecl map[string]bool

+ SysInclude []string

+ type ControlFlow struct

+ Start Block

+ func (cf *ControlFlow) Dom(a, b Block) bool

+ func (cf *ControlFlow) Flatten() []CStmt

+ func (cf *ControlFlow) IDom(a Block) Block

+ func (cf *ControlFlow) SDom(a, b Block) bool

+ type Define struct

+ Name string

+ Value string

+ type Deref struct

+ X PtrExpr

+ func (e *Deref) AsExpr() GoExpr

+ func (e *Deref) CType(types.Type) types.Type

+ func (e *Deref) HasSideEffects() bool

+ func (e *Deref) IsConst() bool

+ func (e *Deref) Uses() []types.Usage

+ func (e *Deref) Visit(v Visitor)

+ type ExpandExpr struct

+ func (e *ExpandExpr) AsExpr() GoExpr

+ func (e *ExpandExpr) CType(_ types.Type) types.Type

+ func (e *ExpandExpr) HasSideEffects() bool

+ func (e *ExpandExpr) IsConst() bool

+ func (e *ExpandExpr) Uses() []types.Usage

+ func (e *ExpandExpr) Visit(v Visitor)

+ type Expr interface

+ AsExpr func() GoExpr

+ CType func(exp types.Type) types.Type

+ HasSideEffects func() bool

+ IsConst func() bool

+ Uses func() []types.Usage

+ func NewCSelectExpr(x Expr, f *types.Ident) Expr

+ type FloatLit struct

+ func (FloatLit) Visit(v Visitor)

+ func (l FloatLit) AsExpr() GoExpr

+ func (l FloatLit) CType(exp types.Type) types.Type

+ func (l FloatLit) HasSideEffects() bool

+ func (l FloatLit) IsConst() bool

+ func (l FloatLit) IsOne() bool

+ func (l FloatLit) IsZero() bool

+ func (l FloatLit) Negate() Number

+ func (l FloatLit) Uses() []types.Usage

+ type FuncAssert struct

+ X Expr

+ func (e FuncAssert) AsExpr() GoExpr

+ func (e FuncAssert) CType(types.Type) types.Type

+ func (e FuncAssert) FuncType(*types.FuncType) *types.FuncType

+ func (e FuncAssert) HasSideEffects() bool

+ func (e FuncAssert) IsConst() bool

+ func (e FuncAssert) Uses() []types.Usage

+ func (e FuncAssert) Visit(v Visitor)

+ type FuncComparison struct

+ Op ComparisonOp

+ X FuncExpr

+ Y FuncExpr

+ func (e *FuncComparison) AsExpr() GoExpr

+ func (e *FuncComparison) CType(types.Type) types.Type

+ func (e *FuncComparison) HasSideEffects() bool

+ func (e *FuncComparison) IsConst() bool

+ func (e *FuncComparison) Negate() BoolExpr

+ func (e *FuncComparison) Uses() []types.Usage

+ func (e *FuncComparison) Visit(v Visitor)

+ type FuncExpr interface

+ FuncType func(exp *types.FuncType) *types.FuncType

+ type FuncIdent struct

+ func (FuncIdent) Visit(v Visitor)

+ func (e FuncIdent) AsExpr() GoExpr

+ func (e FuncIdent) FuncType(exp *types.FuncType) *types.FuncType

+ func (e FuncIdent) HasSideEffects() bool

+ func (e FuncIdent) Identifier() *types.Ident

+ func (e FuncIdent) IsConst() bool

+ func (e FuncIdent) Uses() []types.Usage

+ type FuncLit struct

+ Body *BlockStmt

+ Type *types.FuncType

+ func (e *FuncLit) AsExpr() GoExpr

+ func (e *FuncLit) CType(types.Type) types.Type

+ func (e *FuncLit) FuncType(*types.FuncType) *types.FuncType

+ func (e *FuncLit) HasSideEffects() bool

+ func (e *FuncLit) IsConst() bool

+ func (e *FuncLit) Uses() []types.Usage

+ func (e *FuncLit) Visit(v Visitor)

+ type FuncToInt struct

+ To types.IntType

+ X FuncExpr

+ func (e *FuncToInt) AsExpr() GoExpr

+ func (e *FuncToInt) CType(types.Type) types.Type

+ func (e *FuncToInt) HasSideEffects() bool

+ func (e *FuncToInt) IsConst() bool

+ func (e *FuncToInt) Uses() []types.Usage

+ func (e *FuncToInt) Visit(v Visitor)

+ type FuncToPtr struct

+ X FuncExpr

+ func (e *FuncToPtr) AsExpr() GoExpr

+ func (e *FuncToPtr) CType(types.Type) types.Type

+ func (e *FuncToPtr) HasSideEffects() bool

+ func (e *FuncToPtr) IsConst() bool

+ func (e *FuncToPtr) PtrType(types.PtrType) types.PtrType

+ func (e *FuncToPtr) Uses() []types.Usage

+ func (e *FuncToPtr) Visit(v Visitor)

+ type GoDecl = ast.Decl

+ func TranslateAST(fname string, tu *cc.AST, env *libs.Env, conf Config) ([]GoDecl, error)

+ type GoExpr = ast.Expr

+ type GoField = ast.Field

+ type GoStmt = ast.Stmt

+ type GoType = ast.Expr

+ type Ident interface

+ Identifier func() *types.Ident

+ type IdentConfig struct

+ Alias bool

+ Fields []IdentConfig

+ Flatten *bool

+ Name string

+ Rename string

+ Type TypeHint

+ type IdentExpr struct

+ func (e IdentExpr) AsExpr() GoExpr

+ func (e IdentExpr) HasSideEffects() bool

+ func (e IdentExpr) Identifier() *types.Ident

+ func (e IdentExpr) IsConst() bool

+ func (e IdentExpr) Uses() []types.Usage

+ func (e IdentExpr) Visit(v Visitor)

+ type IfElseStmt interface

+ type IntLit struct

+ func (IntLit) HasSideEffects() bool

+ func (IntLit) IsConst() bool

+ func (IntLit) Visit(v Visitor)

+ func (l IntLit) AsExpr() GoExpr

+ func (l IntLit) CType(exp types.Type) types.Type

+ func (l IntLit) Int() int64

+ func (l IntLit) IsNeg() bool

+ func (l IntLit) IsOne() bool

+ func (l IntLit) IsUint() bool

+ func (l IntLit) IsZero() bool

+ func (l IntLit) MulLit(v int64) IntLit

+ func (l IntLit) Negate() Number

+ func (l IntLit) NegateLit() IntLit

+ func (l IntLit) OverflowInt(sz int) IntLit

+ func (l IntLit) OverflowUint(sz int) IntLit

+ func (l IntLit) String() string

+ func (l IntLit) Uint() uint64

+ func (l IntLit) Uses() []types.Usage

+ type IntToFunc struct

+ To *types.FuncType

+ X Expr

+ func (e *IntToFunc) AsExpr() GoExpr

+ func (e *IntToFunc) CType(types.Type) types.Type

+ func (e *IntToFunc) FuncType(*types.FuncType) *types.FuncType

+ func (e *IntToFunc) HasSideEffects() bool

+ func (e *IntToFunc) IsConst() bool

+ func (e *IntToFunc) Uses() []types.Usage

+ func (e *IntToFunc) Visit(v Visitor)

+ type IntToPtr struct

+ To types.PtrType

+ X Expr

+ func (e *IntToPtr) AsExpr() GoExpr

+ func (e *IntToPtr) CType(types.Type) types.Type

+ func (e *IntToPtr) HasSideEffects() bool

+ func (e *IntToPtr) IsConst() bool

+ func (e *IntToPtr) PtrType(types.PtrType) types.PtrType

+ func (e *IntToPtr) Uses() []types.Usage

+ func (e *IntToPtr) Visit(v Visitor)

+ type MakeExpr struct

+ Elem types.Type

+ Size Expr

+ func (e *MakeExpr) AsExpr() GoExpr

+ func (e *MakeExpr) CType(_ types.Type) types.Type

+ func (e *MakeExpr) HasSideEffects() bool

+ func (e *MakeExpr) IsConst() bool

+ func (e *MakeExpr) Uses() []types.Usage

+ func (e *MakeExpr) Visit(v Visitor)

+ type NewExpr struct

+ Elem types.Type

+ func (e *NewExpr) AsExpr() GoExpr

+ func (e *NewExpr) CType(_ types.Type) types.Type

+ func (e *NewExpr) HasSideEffects() bool

+ func (e *NewExpr) IsConst() bool

+ func (e *NewExpr) PtrType(_ types.PtrType) types.PtrType

+ func (e *NewExpr) Uses() []types.Usage

+ func (e *NewExpr) Visit(_ Visitor)

+ type Nil struct

+ func NewNil(size int) Nil

+ func (Nil) AsExpr() GoExpr

+ func (Nil) HasSideEffects() bool

+ func (Nil) IsConst() bool

+ func (Nil) Visit(v Visitor)

+ func (e Nil) CType(exp types.Type) types.Type

+ func (e Nil) FuncType(exp *types.FuncType) *types.FuncType

+ func (e Nil) PtrType(exp types.PtrType) types.PtrType

+ func (e Nil) Uses() []types.Usage

+ type Node interface

+ Visit func(v Visitor)

+ type Not struct

+ X BoolExpr

+ func (e *Not) AsExpr() GoExpr

+ func (e *Not) CType(types.Type) types.Type

+ func (e *Not) HasSideEffects() bool

+ func (e *Not) IsConst() bool

+ func (e *Not) Negate() BoolExpr

+ func (e *Not) Uses() []types.Usage

+ func (e *Not) Visit(v Visitor)

+ type Number interface

+ IsOne func() bool

+ IsZero func() bool

+ Negate func() Number

+ type ParseConfig struct

+ Define []Define

+ Includes []string

+ Predefines bool

+ Sources []cc.Source

+ SysIncludes []string

+ WorkDir string

+ type PtrAssert struct

+ X Expr

+ func (e PtrAssert) AsExpr() GoExpr

+ func (e PtrAssert) CType(types.Type) types.Type

+ func (e PtrAssert) HasSideEffects() bool

+ func (e PtrAssert) IsConst() bool

+ func (e PtrAssert) PtrType(types.PtrType) types.PtrType

+ func (e PtrAssert) Uses() []types.Usage

+ func (e PtrAssert) Visit(v Visitor)

+ type PtrComparison struct

+ Op ComparisonOp

+ X PtrExpr

+ Y PtrExpr

+ func (e *PtrComparison) AsExpr() GoExpr

+ func (e *PtrComparison) CType(types.Type) types.Type

+ func (e *PtrComparison) HasSideEffects() bool

+ func (e *PtrComparison) IsConst() bool

+ func (e *PtrComparison) Negate() BoolExpr

+ func (e *PtrComparison) Uses() []types.Usage

+ func (e *PtrComparison) Visit(v Visitor)

+ type PtrDiff struct

+ X PtrExpr

+ Y PtrExpr

+ func (e *PtrDiff) AsExpr() GoExpr

+ func (e *PtrDiff) CType(exp types.Type) types.Type

+ func (e *PtrDiff) HasSideEffects() bool

+ func (e *PtrDiff) IsConst() bool

+ func (e *PtrDiff) Uses() []types.Usage

+ func (e *PtrDiff) Visit(v Visitor)

+ type PtrElemOffset struct

+ Conv *types.PtrType

+ Ind Expr

+ X PtrExpr

+ func (e *PtrElemOffset) AsExpr() GoExpr

+ func (e *PtrElemOffset) CType(exp types.Type) types.Type

+ func (e *PtrElemOffset) HasSideEffects() bool

+ func (e *PtrElemOffset) IsConst() bool

+ func (e *PtrElemOffset) PtrType(exp types.PtrType) types.PtrType

+ func (e *PtrElemOffset) Uses() []types.Usage

+ func (e *PtrElemOffset) Visit(v Visitor)

+ type PtrExpr interface

+ PtrType func(exp types.PtrType) types.PtrType

+ type PtrIdent struct

+ func (PtrIdent) Visit(v Visitor)

+ func (e PtrIdent) AsExpr() GoExpr

+ func (e PtrIdent) HasSideEffects() bool

+ func (e PtrIdent) Identifier() *types.Ident

+ func (e PtrIdent) IsConst() bool

+ func (e PtrIdent) PtrType(exp types.PtrType) types.PtrType

+ func (e PtrIdent) Uses() []types.Usage

+ type PtrOffset struct

+ Conv *types.PtrType

+ Ind int64

+ X PtrExpr

+ func (e *PtrOffset) AsExpr() GoExpr

+ func (e *PtrOffset) CType(exp types.Type) types.Type

+ func (e *PtrOffset) HasSideEffects() bool

+ func (e *PtrOffset) IsConst() bool

+ func (e *PtrOffset) PtrType(exp types.PtrType) types.PtrType

+ func (e *PtrOffset) Uses() []types.Usage

+ func (e *PtrOffset) Visit(v Visitor)

+ type PtrToFunc struct

+ To *types.FuncType

+ X PtrExpr

+ func (e *PtrToFunc) AsExpr() GoExpr

+ func (e *PtrToFunc) CType(types.Type) types.Type

+ func (e *PtrToFunc) FuncType(*types.FuncType) *types.FuncType

+ func (e *PtrToFunc) HasSideEffects() bool

+ func (e *PtrToFunc) IsConst() bool

+ func (e *PtrToFunc) Uses() []types.Usage

+ func (e *PtrToFunc) Visit(v Visitor)

+ type PtrToInt struct

+ To types.Type

+ X PtrExpr

+ func (e *PtrToInt) AsExpr() GoExpr

+ func (e *PtrToInt) CType(types.Type) types.Type

+ func (e *PtrToInt) HasSideEffects() bool

+ func (e *PtrToInt) IsConst() bool

+ func (e *PtrToInt) Uses() []types.Usage

+ func (e *PtrToInt) Visit(v Visitor)

+ type PtrToPtr struct

+ To types.PtrType

+ X PtrExpr

+ func (e *PtrToPtr) AsExpr() GoExpr

+ func (e *PtrToPtr) CType(types.Type) types.Type

+ func (e *PtrToPtr) HasSideEffects() bool

+ func (e *PtrToPtr) IsConst() bool

+ func (e *PtrToPtr) PtrType(types.PtrType) types.PtrType

+ func (e *PtrToPtr) Uses() []types.Usage

+ func (e *PtrToPtr) Visit(v Visitor)

+ type PtrVarOffset struct

+ Conv *types.PtrType

+ Ind Expr

+ Mul int

+ X PtrExpr

+ func (e *PtrVarOffset) AsExpr() GoExpr

+ func (e *PtrVarOffset) CType(exp types.Type) types.Type

+ func (e *PtrVarOffset) HasSideEffects() bool

+ func (e *PtrVarOffset) IsConst() bool

+ func (e *PtrVarOffset) PtrType(exp types.PtrType) types.PtrType

+ func (e *PtrVarOffset) Uses() []types.Usage

+ func (e *PtrVarOffset) Visit(v Visitor)

+ type Range struct

+ End int

+ Start int

+ StartLine int

+ type Replacer struct

+ New string

+ Old string

+ Re *regexp.Regexp

+ type ReturnBlock struct

+ func (b *ReturnBlock) NextBlocks() []Block

+ func (b *ReturnBlock) ReplaceNext(old, rep Block)

+ type SliceExpr struct

+ Expr Expr

+ func (e *SliceExpr) AsExpr() GoExpr

+ func (e *SliceExpr) CType(types.Type) types.Type

+ func (e *SliceExpr) HasSideEffects() bool

+ func (e *SliceExpr) IsConst() bool

+ func (e *SliceExpr) Uses() []types.Usage

+ func (e *SliceExpr) Visit(v Visitor)

+ type SourceConfig struct

+ Define []Define

+ IgnoreIncludeDir bool

+ Include []string

+ Predef string

+ SysInclude []string

+ type SrcFunc struct

+ File string

+ Func string

+ Line int

+ OffsetEnd int

+ OffsetStart int

+ Proto string

+ Src string

+ func SourceFunc(fname string, src []byte, fd *CFuncDecl) SrcFunc

+ type StringLit struct

+ func (StringLit) Visit(v Visitor)

+ func (l StringLit) AsExpr() GoExpr

+ func (l StringLit) CType(types.Type) types.Type

+ func (l StringLit) HasSideEffects() bool

+ func (l StringLit) IsConst() bool

+ func (l StringLit) IsWide() bool

+ func (l StringLit) String() string

+ func (l StringLit) Uses() []types.Usage

+ func (l StringLit) Value() string

+ type StringToPtr struct

+ X StringLit

+ func (e *StringToPtr) AsExpr() GoExpr

+ func (e *StringToPtr) CType(exp types.Type) types.Type

+ func (e *StringToPtr) HasSideEffects() bool

+ func (e *StringToPtr) IsConst() bool

+ func (e *StringToPtr) PtrType(types.PtrType) types.PtrType

+ func (e *StringToPtr) Uses() []types.Usage

+ func (e *StringToPtr) Visit(v Visitor)

+ type SwitchBlock struct

+ Blocks []Block

+ Cases []Expr

+ Expr Expr

+ func (b *SwitchBlock) NextBlocks() []Block

+ func (b *SwitchBlock) ReplaceNext(old, rep Block)

+ type TakeAddr struct

+ X Expr

+ func (e *TakeAddr) AsExpr() GoExpr

+ func (e *TakeAddr) CType(exp types.Type) types.Type

+ func (e *TakeAddr) HasSideEffects() bool

+ func (e *TakeAddr) IsConst() bool

+ func (e *TakeAddr) PtrType(types.PtrType) types.PtrType

+ func (e *TakeAddr) Uses() []types.Usage

+ func (e *TakeAddr) Visit(v Visitor)

+ type TypeAssert struct

+ Expr Expr

+ Type types.Type

+ func (e *TypeAssert) AsExpr() GoExpr

+ func (e *TypeAssert) CType(types.Type) types.Type

+ func (e *TypeAssert) HasSideEffects() bool

+ func (e *TypeAssert) IsConst() bool

+ type TypeHint string

+ type UnaryOp string

+ const UnaryMinus

+ const UnaryPlus

+ const UnarySizeof

+ const UnaryXor

+ type UnusedVar struct

+ Name *types.Ident

+ func (s *UnusedVar) AsStmt() []GoStmt

+ func (s *UnusedVar) Uses() []types.Usage

+ func (s *UnusedVar) Visit(v Visitor)

+ type Visitor func(n Node)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL