syntax

package
v0.0.0-...-c5860aa Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 29, 2017 License: BSD-3-Clause Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// for AliasDecl
	Const = _Const
	Type  = _Type
	Var   = _Var
	Func  = _Func

	// for BranchStmt
	Break       = _Break
	Continue    = _Continue
	Fallthrough = _Fallthrough
	Goto        = _Goto

	// for CallStmt
	Go    = _Go
	Defer = _Defer
)

Variables

View Source 
var ImplicitOne = &BasicLit{Value: "1"}

We represent x++, x-- as assignments x += ImplicitOne, x -= ImplicitOne. ImplicitOne should not be used elsewhere.

Functions

func Fdump 

func Fdump(w io.Writer, n Node) (err error)

Fdump dumps the structure of the syntax tree rooted at n to w. It is intended for debugging purposes; no specific output format is guaranteed.

func Fprint 

func Fprint(w io.Writer, x Node, linebreaks bool) (n int, err error)

func String 

func String(n Node) string

func Write 

func Write(w io.Writer, n *File) error

Types

type AliasDecl 

type AliasDecl struct {
	Tok   token // Const, Type, Var, or Func
	Name  *Name
	Orig  Expr
	Group *Group // nil means not part of a group
	// contains filtered or unexported fields
}

Name => Orig

type ArrayType 

type ArrayType struct {
	// TODO(gri) consider using Name{"..."} instead of nil (permits attaching of comments)
	Len  Expr // nil means Len is ...
	Elem Expr
	// contains filtered or unexported fields
}

[Len]Elem

type AssertExpr 

type AssertExpr struct {
	X Expr
	// TODO(gri) consider using Name{"..."} instead of nil (permits attaching of comments)
	Type Expr
	// contains filtered or unexported fields
}

X.(Type)

type AssignStmt 

type AssignStmt struct {
	Op       Operator // 0 means no operation
	Lhs, Rhs Expr     // Rhs == ImplicitOne means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
	// contains filtered or unexported fields
}

type BasicLit 

type BasicLit struct {
	Value string
	Kind  LitKind
	// contains filtered or unexported fields
}

Value

type BlockStmt 

type BlockStmt struct {
	Body []Stmt
	// contains filtered or unexported fields
}

type BranchStmt 

type BranchStmt struct {
	Tok   token // Break, Continue, Fallthrough, or Goto
	Label *Name
	// contains filtered or unexported fields
}

type CallExpr 

type CallExpr struct {
	Fun     Expr
	ArgList []Expr
	HasDots bool // last argument is followed by ...
	// contains filtered or unexported fields
}

Fun(ArgList[0], ArgList[1], ...)

type CallStmt 

type CallStmt struct {
	Tok  token // Go or Defer
	Call *CallExpr
	// contains filtered or unexported fields
}

type CaseClause 

type CaseClause struct {
	Cases Expr // nil means default clause
	Body  []Stmt
	// contains filtered or unexported fields
}

func (*CaseClause) Line 

func (n *CaseClause) Line() uint32

type ChanDir 

type ChanDir uint
const (
	SendOnly ChanDir
	RecvOnly
)

type ChanType 

type ChanType struct {
	Dir  ChanDir // 0 means no direction
	Elem Expr
	// contains filtered or unexported fields
}
chan Elem

<-chan Elem chan<- Elem

type CommClause 

type CommClause struct {
	Comm SimpleStmt // send or receive stmt; nil means default clause
	Body []Stmt
	// contains filtered or unexported fields
}

func (*CommClause) Line 

func (n *CommClause) Line() uint32

type Comment 

type Comment struct {
	Kind CommentKind
	Text string
	Next *Comment
}

type CommentKind 

type CommentKind uint

TODO(gri) Consider renaming to CommentPos, CommentPlacement, etc. 

Kind = Above doesn't make much sense.

const (
	Above CommentKind = iota
	Below
	Left
	Right
)

type CompositeLit 

type CompositeLit struct {
	Type     Expr // nil means no literal type
	ElemList []Expr
	NKeys    int    // number of elements with keys
	EndLine  uint32 // TODO(mdempsky): Cleaner solution.
	// contains filtered or unexported fields
}

Type { ElemList[0], ElemList[1], ... }

type ConstDecl 

type ConstDecl struct {
	NameList []*Name
	Type     Expr   // nil means no type
	Values   Expr   // nil means no values
	Group    *Group // nil means not part of a group
	// contains filtered or unexported fields
}

NameList NameList = Values NameList Type = Values

type Decl 

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

type DeclStmt 

type DeclStmt struct {
	DeclList []Decl
	// contains filtered or unexported fields
}

type DotsType 

type DotsType struct {
	Elem Expr
	// contains filtered or unexported fields
}

...Elem

type EmptyStmt 

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

type ErrorHandler 

type ErrorHandler func(pos, line int, msg string)

type Expr 

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

type ExprStmt 

type ExprStmt struct {
	X Expr
	// contains filtered or unexported fields
}

type Field 

type Field struct {
	Name *Name // nil means anonymous field/parameter (structs/parameters), or embedded interface (interfaces)
	Type Expr  // field names declared in a list share the same Type (identical pointers)
	// contains filtered or unexported fields
}

Name Type 

Type

func (*Field) Line 

func (n *Field) Line() uint32

type File 

type File struct {
	PkgName  *Name
	DeclList []Decl
	Lines    int
	// contains filtered or unexported fields
}

package PkgName; DeclList[0], DeclList[1], ...

func Read 

func Read(src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error)

func ReadBytes 

func ReadBytes(src []byte, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error)

func ReadFile 

func ReadFile(filename string, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error)

func (*File) Line 

func (n *File) Line() uint32

type ForStmt 

type ForStmt struct {
	Init SimpleStmt // incl. *RangeClause
	Cond Expr
	Post SimpleStmt
	Body []Stmt
	// contains filtered or unexported fields
}

type FuncDecl 

type FuncDecl struct {
	Attr    map[string]bool // go:attr map
	Recv    *Field          // nil means regular function
	Name    *Name
	Type    *FuncType
	Body    []Stmt // nil means no body (forward declaration)
	Pragma  Pragma // TODO(mdempsky): Cleaner solution.
	EndLine uint32 // TODO(mdempsky): Cleaner solution.
	// contains filtered or unexported fields
}

func Name Type { Body } func Name Type func Receiver Name Type { Body } func Receiver Name Type

type FuncLit 

type FuncLit struct {
	Type    *FuncType
	Body    []Stmt
	EndLine uint32 // TODO(mdempsky): Cleaner solution.
	// contains filtered or unexported fields
}

func Type { Body }

type FuncType 

type FuncType struct {
	ParamList  []*Field
	ResultList []*Field
	// contains filtered or unexported fields
}

type Group 

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

All declarations belonging to the same group point to the same Group node.

type IfStmt 

type IfStmt struct {
	Init SimpleStmt
	Cond Expr
	Then []Stmt
	Else Stmt // either *IfStmt or *BlockStmt
	// contains filtered or unexported fields
}

type ImportDecl 

type ImportDecl struct {
	LocalPkgName *Name // including "."; nil means no rename present
	Path         *BasicLit
	Group        *Group // nil means not part of a group
	// contains filtered or unexported fields
}
Path

LocalPkgName Path

type IndexExpr 

type IndexExpr struct {
	X     Expr
	Index Expr
	// contains filtered or unexported fields
}

X[Index]

type InterfaceType 

type InterfaceType struct {
	MethodList []*Field
	// contains filtered or unexported fields
}

interface { MethodList[0]; MethodList[1]; ... }

type KeyValueExpr 

type KeyValueExpr struct {
	Key, Value Expr
	// contains filtered or unexported fields
}

Key: Value

type LabeledStmt 

type LabeledStmt struct {
	Label *Name
	Stmt  Stmt
	// contains filtered or unexported fields
}

type ListExpr 

type ListExpr struct {
	ElemList []Expr
	// contains filtered or unexported fields
}

ElemList[0], ElemList[1], ...

type LitKind 

type LitKind uint
const (
	IntLit LitKind = iota
	FloatLit
	ImagLit
	RuneLit
	StringLit
)

type MapType 

type MapType struct {
	Key   Expr
	Value Expr
	// contains filtered or unexported fields
}

map[Key]Value

type Mode 

type Mode uint

type Name 

type Name struct {
	Value string
	// contains filtered or unexported fields
}

Value

type Node 

type Node interface {
	Line() uint32
	// contains filtered or unexported methods
}

type Operation 

type Operation struct {
	Op   Operator
	X, Y Expr // Y == nil means unary expression
	// contains filtered or unexported fields
}

type Operator 

type Operator uint
const (
	Def  Operator // :=
	Not           // !
	Recv          // <-

	// precOrOr
	OrOr // ||

	// precAndAnd
	AndAnd // &&

	// precCmp
	Eql // ==
	Neq // !=
	Lss // <
	Leq // <=
	Gtr // >
	Geq // >=

	// precAdd
	Add // +
	Sub // -
	Or  // |
	Xor // ^

	// precMul
	Mul    // *
	Div    // /
	Rem    // %
	And    // &
	AndNot // &^
	Shl    // <<
	Shr    // >>
)

func (Operator) String 

func (op Operator) String() string

type ParenExpr 

type ParenExpr struct {
	X Expr
	// contains filtered or unexported fields
}

(X)

type Pragma 

type Pragma uint16

A Pragma value is a set of flags that augment a function declaration. Callers may assign meaning to the flags as appropriate.

type PragmaHandler 

type PragmaHandler func(pos, line int, text string) Pragma

A PragmaHandler is used to process //line and //go: directives as they're scanned. The returned Pragma value will be unioned into the next FuncDecl node.

type RangeClause 

type RangeClause struct {
	Lhs Expr // nil means no Lhs = or Lhs :=
	Def bool // means :=
	X   Expr // range X
	// contains filtered or unexported fields
}

type ReturnStmt 

type ReturnStmt struct {
	Results Expr // nil means no explicit return values
	// contains filtered or unexported fields
}

type SelectStmt 

type SelectStmt struct {
	Body []*CommClause
	// contains filtered or unexported fields
}

type SelectorExpr 

type SelectorExpr struct {
	X   Expr
	Sel *Name
	// contains filtered or unexported fields
}

X.Sel

type SendStmt 

type SendStmt struct {
	Chan, Value Expr // Chan <- Value
	// contains filtered or unexported fields
}

type SimpleStmt 

type SimpleStmt interface {
	Stmt
	// contains filtered or unexported methods
}

type SliceExpr 

type SliceExpr struct {
	X     Expr
	Index [3]Expr
	// Full indicates whether this is a simple or full slice expression.
	// In a valid AST, this is equivalent to Index[2] != nil.
	// TODO(mdempsky): This is only needed to report the "3-index
	// slice of string" error when Index[2] is missing.
	Full bool
	// contains filtered or unexported fields
}

X[Index[0] : Index[1] : Index[2]]

type SliceType 

type SliceType struct {
	Elem Expr
	// contains filtered or unexported fields
}

[]Elem

type Stmt 

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

type StructType 

type StructType struct {
	FieldList []*Field
	TagList   []*BasicLit // i >= len(TagList) || TagList[i] == nil means no tag for field i
	// contains filtered or unexported fields
}

struct { FieldList[0] TagList[0]; FieldList[1] TagList[1]; ... }

type SwitchStmt 

type SwitchStmt struct {
	Init SimpleStmt
	Tag  Expr
	Body []*CaseClause
	// contains filtered or unexported fields
}

type TypeDecl 

type TypeDecl struct {
	Name  *Name
	Type  Expr
	Alias bool
	Group *Group // nil means not part of a group
	// contains filtered or unexported fields
}

Name Type

type TypeSwitchGuard 

type TypeSwitchGuard struct {
	// TODO(gri) consider using Name{"..."} instead of nil (permits attaching of comments)
	Lhs *Name // nil means no Lhs :=
	X   Expr  // X.(type)
	// contains filtered or unexported fields
}

type VarDecl 

type VarDecl struct {
	NameList []*Name
	Type     Expr   // nil means no type
	Values   Expr   // nil means no values
	Group    *Group // nil means not part of a group
	// contains filtered or unexported fields
}

NameList Type NameList Type = Values NameList = Values

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.