Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

ast

package

Go to main page

Versions in this module

v0

v0.6.2

Oct 12, 2017

v0.6.1

Sep 15, 2017

v0.6.0

Aug 29, 2017

v0.5.1

Aug 3, 2017

v0.5.0

Jul 27, 2017

v0.4.0

Jul 14, 2017

Changes in this version

+ var BareTypes []BareType

+ var BoAdd = appendBinaryOperator("+")

+ var BoAddAssign = appendAssignOp("+=")

+ var BoAndAssign = appendAssignOp("&=")

+ var BoAssign = appendAssignOp("=")

+ var BoBand = appendBinaryOperator("&")

+ var BoBor = appendBinaryOperator("|")

+ var BoBxor = appendBinaryOperator("^")

+ var BoComma = appendBinaryOperator(",")

+ var BoDiv = appendBinaryOperator("/")

+ var BoDivAssign = appendAssignOp("/=")

+ var BoEq = appendBinaryOperator("==")

+ var BoLand = appendBinaryOperator("&&")

+ var BoLess = appendBinaryOperator("<")

+ var BoLessEq = appendBinaryOperator("<=")

+ var BoLor = appendBinaryOperator("||")

+ var BoLxor = appendBinaryOperator("^^")

+ var BoMod = appendBinaryOperator("%")

+ var BoModAssign = appendAssignOp("%=")

+ var BoMore = appendBinaryOperator(">")

+ var BoMoreEq = appendBinaryOperator(">=")

+ var BoMul = appendBinaryOperator("*")

+ var BoMulAssign = appendAssignOp("*=")

+ var BoNotEq = appendBinaryOperator("!=")

+ var BoOrAssign = appendAssignOp("|=")

+ var BoShl = appendBinaryOperator("<<")

+ var BoShlAssign = appendAssignOp("<<=")

+ var BoShr = appendBinaryOperator(">>")

+ var BoShrAssign = appendAssignOp(">>=")

+ var BoSub = appendBinaryOperator("-")

+ var BoSubAssign = appendAssignOp("-=")

+ var BoXorAssign = appendAssignOp("^=")

+ var Operators []fmt.Stringer

+ var TBool = appendType("bool")

+ var TBvec2 = appendType("bvec2")

+ var TBvec3 = appendType("bvec3")

+ var TBvec4 = appendType("bvec4")

+ var TFloat = appendType("float")

+ var TInt = appendType("int")

+ var TIsampler2D = appendType("isampler2D")

+ var TIsampler2DArray = appendType("isampler2DArray")

+ var TIsampler2DMS = appendType("isampler2DMS")

+ var TIsampler2DMSArray = appendType("isampler2DMSArray")

+ var TIsampler3D = appendType("isampler3D")

+ var TIsamplerCube = appendType("isamplerCube")

+ var TIvec2 = appendType("ivec2")

+ var TIvec3 = appendType("ivec3")

+ var TIvec4 = appendType("ivec4")

+ var TMat2 = appendType("mat2")

+ var TMat2x2 = appendType("mat2x2")

+ var TMat2x3 = appendType("mat2x3")

+ var TMat2x4 = appendType("mat2x4")

+ var TMat3 = appendType("mat3")

+ var TMat3x2 = appendType("mat3x2")

+ var TMat3x3 = appendType("mat3x3")

+ var TMat3x4 = appendType("mat3x4")

+ var TMat4 = appendType("mat4")

+ var TMat4x2 = appendType("mat4x2")

+ var TMat4x3 = appendType("mat4x3")

+ var TMat4x4 = appendType("mat4x4")

+ var TSampler2D = appendType("sampler2D")

+ var TSampler2DArray = appendType("sampler2DArray")

+ var TSampler2DArrayShadow = appendType("sampler2DArrayShadow")

+ var TSampler2DMS = appendType("sampler2DMS")

+ var TSampler2DMSArray = appendType("sampler2DMSArray")

+ var TSampler2DShadow = appendType("sampler2DShadow")

+ var TSampler3D = appendType("sampler3D")

+ var TSamplerCube = appendType("samplerCube")

+ var TSamplerCubeShadow = appendType("samplerCubeShadow")

+ var TSamplerExternalOES = appendType("samplerExternalOES")

+ var TUint = appendType("uint")

+ var TUsampler2D = appendType("usampler2D")

+ var TUsampler2DArray = appendType("usampler2DArray")

+ var TUsampler3D = appendType("usampler3D")

+ var TUsamplerCube = appendType("usamplerCube")

+ var TUssampler2DMS = appendType("ussampler2DMS")

+ var TUssampler2DMSArray = appendType("ussampler2DMSArray")

+ var TUvec2 = appendType("uvec2")

+ var TUvec3 = appendType("uvec3")

+ var TUvec4 = appendType("uvec4")

+ var TVec2 = appendType("vec2")

+ var TVec3 = appendType("vec3")

+ var TVec4 = appendType("vec4")

+ var TVoid = appendType("void")

+ var UoBnot = appendPrefixOp("~")

+ var UoLnot = appendPrefixOp("!")

+ var UoMinus = appendPrefixOp("-")

+ var UoPlus = appendPrefixOp("+")

+ var UoPostdec = appendUnaryOperator("--")

+ var UoPostinc = appendUnaryOperator("++")

+ var UoPredec = appendPrefixOp("--")

+ var UoPreinc = appendPrefixOp("++")

+ func ConcatErrors(e1, e2 []error) []error

+ func HasVectorExpansions(t BareType) bool

+ func IsAssignmentOp(op BinaryOp) bool

+ func IsMatrixType(t BareType) bool

+ func IsVectorType(t BareType) bool

+ func TransformChildren(n interface{}, v ChildTransformer)

+ func TypeDimensions(t BareType) (col uint8, row uint8)

+ func ValueEquals(left, right Value) bool

+ func VisitChildren(n interface{}, v ChildVisitor)

+ type ArrayType struct

+ Base Type

+ ComputedSize UintValue

+ LBracketCst *parse.Leaf

+ RBracketCst *parse.Leaf

+ Size Expression

+ func (at *ArrayType) Copy() *ArrayType

+ func (at *ArrayType) Equal(other Type) bool

+ type ArrayValue []Value

+ func (v ArrayValue) Type() Type

+ type Ast struct

+ Decls []interface{}

+ type BareType struct

+ func GetFundamentalType(t BareType) BareType

+ func GetMatrixType(col, row uint8) BareType

+ func GetPrecisionType(t BareType) (prect BareType, hasPrecision bool)

+ func GetVectorType(fund BareType, size uint8) BareType

+ func (t BareType) Canonicalize() BareType

+ func (t BareType) String() string

+ type BinaryExpr struct

+ ExprType Type

+ Left Expression

+ Op BinaryOp

+ OpCst *parse.Leaf

+ Right Expression

+ func (e *BinaryExpr) Constant() bool

+ func (e *BinaryExpr) LValue() bool

+ func (e *BinaryExpr) Type() Type

+ type BinaryOp struct

+ func (op BinaryOp) String() string

+ type BoolValue bool

+ func (v BoolValue) Type() Type

+ type BreakStmt struct

+ BreakCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ type BuiltinFunction struct

+ Impl func(v []Value) Value

+ Params []*FuncParameterSym

+ RetType Type

+ SymName string

+ func (f *BuiltinFunction) Constant() bool

+ func (f *BuiltinFunction) LValue() bool

+ func (f *BuiltinFunction) Name() string

+ func (f *BuiltinFunction) Parameters() []*FuncParameterSym

+ func (f *BuiltinFunction) ReturnType() Type

+ func (f *BuiltinFunction) Type() Type

+ type BuiltinType struct

+ Precision Precision

+ PrecisionCst *parse.Leaf

+ Type BareType

+ TypeCst *parse.Leaf

+ func (bt *BuiltinType) Equal(other Type) bool

+ type CallExpr struct

+ Args []Expression

+ Callee Expression

+ CommaCst []*parse.Leaf

+ ExprConstant bool

+ ExprType Type

+ LParenCst *parse.Leaf

+ RParenCst *parse.Leaf

+ VoidCst *parse.Leaf

+ VoidPresent bool

+ func (e *CallExpr) Constant() bool

+ func (e *CallExpr) LValue() bool

+ func (e *CallExpr) Type() Type

+ type CaseStmt struct

+ CaseCst *parse.Leaf

+ ColonCst *parse.Leaf

+ Expr Expression

+ type ChildTransformer func(child, parent interface{}) interface

+ type ChildVisitor func(interface{})

+ type CompoundStmt struct

+ LBraceCst *parse.Leaf

+ RBraceCst *parse.Leaf

+ Stmts []interface{}

+ type ConditionalExpr struct

+ ColonCst *parse.Leaf

+ Cond Expression

+ FalseExpr Expression

+ QuestionCst *parse.Leaf

+ TrueExpr Expression

+ func (e *ConditionalExpr) Constant() bool

+ func (e *ConditionalExpr) LValue() bool

+ func (e *ConditionalExpr) Type() Type

+ type ConstantExpr struct

+ ValCst *parse.Leaf

+ Value Value

+ func (e *ConstantExpr) Constant() bool

+ func (e *ConstantExpr) LValue() bool

+ func (e *ConstantExpr) Type() Type

+ type ContinueStmt struct

+ ContinueCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ type DeclarationStmt struct

+ Decl interface{}

+ type DefaultStmt struct

+ ColonCst *parse.Leaf

+ DefaultCst *parse.Leaf

+ type DiscardStmt struct

+ DiscardCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ type DoStmt struct

+ DoCst *parse.Leaf

+ Expr Expression

+ LParenCst *parse.Leaf

+ RParenCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ Stmt interface{}

+ WhileCst *parse.Leaf

+ type DotExpr struct

+ DotCst *parse.Leaf

+ Expr Expression

+ ExprConstant bool

+ ExprLValue bool

+ ExprType Type

+ Field string

+ FieldCst *parse.Leaf

+ func (e *DotExpr) Constant() bool

+ func (e *DotExpr) LValue() bool

+ func (e *DotExpr) Type() Type

+ type EmptyStmt struct

+ SemicolonCst *parse.Leaf

+ type ErrorCollector []error

+ func (e *ErrorCollector) Error(err ...error)

+ func (e *ErrorCollector) Errorf(message string, args ...interface{})

+ func (e *ErrorCollector) GetErrors() []error

+ type Expression interface

+ Constant func() bool

+ LValue func() bool

+ Type func() Type

+ type ExpressionCond struct

+ Expr Expression

+ type ExpressionStmt struct

+ Expr Expression

+ SemicolonCst *parse.Leaf

+ type FloatValue float64

+ func (v FloatValue) String() string

+ func (v FloatValue) Type() Type

+ type ForStmt struct

+ Body interface{}

+ Cond interface{}

+ ForCst *parse.Leaf

+ Init interface{}

+ LParenCst *parse.Leaf

+ Loop Expression

+ RParenCst *parse.Leaf

+ Semicolon2Cst *parse.Leaf

+ type FuncParameterSym struct

+ ArrayAfterVar bool

+ Const bool

+ ConstCst *parse.Leaf

+ Direction ParamDirection

+ DirectionCst *parse.Leaf

+ NameCst *parse.Leaf

+ SymName string

+ SymType Type

+ func (v *FuncParameterSym) Constant() bool

+ func (v *FuncParameterSym) LValue() bool

+ func (v *FuncParameterSym) Name() string

+ func (v *FuncParameterSym) Type() Type

+ type Function interface

+ Parameters func() []*FuncParameterSym

+ ReturnType func() Type

+ type FunctionDecl struct

+ CommaCst []*parse.Leaf

+ LParenCst *parse.Leaf

+ NameCst *parse.Leaf

+ Params []*FuncParameterSym

+ RParenCst *parse.Leaf

+ RetType Type

+ SemicolonCst *parse.Leaf

+ Stmts *CompoundStmt

+ SymName string

+ VoidCst *parse.Leaf

+ VoidPresent bool

+ func (f *FunctionDecl) Constant() bool

+ func (f *FunctionDecl) LValue() bool

+ func (f *FunctionDecl) Name() string

+ func (f *FunctionDecl) Parameters() []*FuncParameterSym

+ func (f *FunctionDecl) ReturnType() Type

+ func (f *FunctionDecl) Type() Type

+ type FunctionType struct

+ ArgTypes []Type

+ RetType Type

+ func (t *FunctionType) Equal(other Type) bool

+ type FunctionValue struct

+ Func func(v []Value) Value

+ ValType *FunctionType

+ func (v FunctionValue) Type() Type

+ type IfStmt struct

+ ElseCst *parse.Leaf

+ ElseStmt interface{}

+ IfCst *parse.Leaf

+ IfExpr Expression

+ LParenCst *parse.Leaf

+ RParenCst *parse.Leaf

+ ThenStmt interface{}

+ type IndexExpr struct

+ Base Expression

+ ExprType Type

+ Index Expression

+ LBracketCst *parse.Leaf

+ RBracketCst *parse.Leaf

+ func (e *IndexExpr) Constant() bool

+ func (e *IndexExpr) LValue() bool

+ func (e *IndexExpr) Type() Type

+ type IntValue int32

+ func (v IntValue) String() string

+ func (v IntValue) Type() Type

+ type InterpolationQualifier uint8

+ const IntFlat

+ const IntNone

+ const IntSmooth

+ func (i InterpolationQualifier) String() string

+ type InvariantDecl struct

+ CommaCst []*parse.Leaf

+ InvariantCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ Vars []*VarRefExpr

+ type Language uint8

+ const LangFragmentShader

+ const LangPreprocessor

+ const LangVertexShader

+ type LayoutDecl struct

+ Layout *LayoutQualifier

+ SemicolonCst *parse.Leaf

+ UniformCst *parse.Leaf

+ type LayoutQualifier struct

+ CommaCst []*parse.Leaf

+ Ids []LayoutQualifierID

+ LParenCst *parse.Leaf

+ LayoutCst *parse.Leaf

+ RParenCst *parse.Leaf

+ type LayoutQualifierID struct

+ EqualCst *parse.Leaf

+ Name string

+ NameCst *parse.Leaf

+ Value Value

+ ValueCst *parse.Leaf

+ type MatrixValue struct

+ Members [][]Value

+ ValType BuiltinType

+ func NewMatrixValue(t BareType, member func(col, row uint8) Value) MatrixValue

+ func NewMatrixValueCR(col, row uint8, member func(col, row uint8) Value) MatrixValue

+ func (v MatrixValue) Type() Type

+ type MultiVarDecl struct

+ CommaCst []*parse.Leaf

+ FunnyComma bool

+ FunnyCommaCst *parse.Leaf

+ Quals *TypeQualifiers

+ SemicolonCst *parse.Leaf

+ Type Type

+ Vars []*VariableSym

+ type ParamDirection uint8

+ const DirIn

+ const DirInout

+ const DirNone

+ const DirOut

+ func (d ParamDirection) String() string

+ type ParenExpr struct

+ Expr Expression

+ LParenCst *parse.Leaf

+ RParenCst *parse.Leaf

+ func (e *ParenExpr) Constant() bool

+ func (e *ParenExpr) LValue() bool

+ func (e *ParenExpr) Type() Type

+ type Precision uint8

+ const HighP

+ const LowP

+ const MediumP

+ const NoneP

+ func (p Precision) String() string

+ type PrecisionDecl struct

+ PrecisionCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ Type *BuiltinType

+ type ReturnStmt struct

+ Expr Expression

+ ReturnCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ type StorageQualifier uint8

+ const StorAttribute

+ const StorCentroidIn

+ const StorCentroidOut

+ const StorConst

+ const StorIn

+ const StorNone

+ const StorOut

+ const StorUniform

+ const StorVarying

+ func (s StorageQualifier) String() string

+ type StructSym struct

+ LBraceCst *parse.Leaf

+ NameCst *parse.Leaf

+ RBraceCst *parse.Leaf

+ StructCst *parse.Leaf

+ SymName string

+ Vars []*MultiVarDecl

+ func (s *StructSym) Name() string

+ type StructType struct

+ NameCst *parse.Leaf

+ StructDef bool

+ Sym *StructSym

+ func (s *StructType) Equal(other Type) bool

+ type StructValue struct

+ Members map[string]Value

+ ValType *StructType

+ func NewStructValue(t *StructType, member func(name string) Value) StructValue

+ func (v StructValue) Type() Type

+ type SwitchStmt struct

+ Expr Expression

+ LParenCst *parse.Leaf

+ RParenCst *parse.Leaf

+ Stmts *CompoundStmt

+ SwitchCst *parse.Leaf

+ type Symbol interface

+ Name func() string

+ type Type interface

+ Equal func(other Type) bool

+ type TypeConversionExpr struct

+ ArgTypes []Type

+ RetType Type

+ func (e *TypeConversionExpr) Constant() bool

+ func (e *TypeConversionExpr) LValue() bool

+ func (e *TypeConversionExpr) Type() Type

+ type TypeQualifiers struct

+ CentroidStorageCst *parse.Leaf

+ Interpolation InterpolationQualifier

+ InterpolationCst *parse.Leaf

+ Invariant bool

+ InvariantCst *parse.Leaf

+ Layout *LayoutQualifier

+ Storage StorageQualifier

+ StorageCst *parse.Leaf

+ type UintValue uint32

+ func (v UintValue) String() string

+ func (v UintValue) Type() Type

+ type UnaryExpr struct

+ Expr Expression

+ Op UnaryOp

+ OpCst *parse.Leaf

+ func (e *UnaryExpr) Constant() bool

+ func (e *UnaryExpr) LValue() bool

+ func (e *UnaryExpr) Type() Type

+ type UnaryOp BinaryOp

+ func GetPrefixOp(opname string) (op UnaryOp, present bool)

+ func (o UnaryOp) String() string

+ type UniformBlock struct

+ LBraceCst *parse.Leaf

+ Layout *LayoutQualifier

+ NameCst *parse.Leaf

+ RBraceCst *parse.Leaf

+ SymName string

+ UniformCst *parse.Leaf

+ Vars []*MultiVarDecl

+ func (u *UniformBlock) Name() string

+ type UniformDecl struct

+ Block *UniformBlock

+ LBracketCst *parse.Leaf

+ NameCst *parse.Leaf

+ RBracketCst *parse.Leaf

+ SemicolonCst *parse.Leaf

+ Size Expression

+ SymName string

+ func (u *UniformDecl) Name() string

+ type Value interface

+ Type func() Type

+ type ValueSymbol interface

+ Constant func() bool

+ LValue func() bool

+ Type func() Type

+ type VarDeclCond struct

+ Sym *VariableSym

+ type VarRefExpr struct

+ Sym ValueSymbol

+ SymCst *parse.Leaf

+ func (e *VarRefExpr) Constant() bool

+ func (e *VarRefExpr) LValue() bool

+ func (e *VarRefExpr) Type() Type

+ type VariableSym struct

+ EqualCst *parse.Leaf

+ Init Expression

+ NameCst *parse.Leaf

+ Quals *TypeQualifiers

+ SymLValue bool

+ SymName string

+ SymType Type

+ func (v *VariableSym) Constant() bool

+ func (v *VariableSym) LValue() bool

+ func (v *VariableSym) Name() string

+ func (v *VariableSym) Type() Type

+ type VectorComponentKind uint8

+ const ComponentKindNone

+ const ComponentKindRGBA

+ const ComponentKindSTPQ

+ const ComponentKindXYZW

+ func GetVectorComponentInfo(r rune) (position uint8, kind VectorComponentKind)

+ type VectorValue struct

+ Members []Value

+ ValType BuiltinType

+ func NewVectorValue(t BareType, member func(i uint8) Value) VectorValue

+ func (v VectorValue) Type() Type

+ type WhileStmt struct

+ Cond interface{}

+ LParenCst *parse.Leaf

+ RParenCst *parse.Leaf

+ Stmt interface{}

+ WhileCst *parse.Leaf