syntax

package
v0.0.0-...-d5b0ec8 Latest Latest
Warning

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

Go to latest
Published: Aug 17, 2017 License: BSD-3-Clause Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source
const (
	// 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

Types

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 BadExpr

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

Placeholder for an expression that failed to parse correctly and where we can't provide a better node.

type BasicLit

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

Value

type BlockStmt

type BlockStmt struct {
	List   []Stmt
	Rbrace src.Pos
	// contains filtered or unexported fields
}

type BranchStmt

type BranchStmt struct {
	Tok   token // Break, Continue, Fallthrough, or Goto
	Label *Name
	// Target is the continuation of the control flow after executing
	// the branch; it is computed by the parser if CheckBranches is set.
	// Target is a *LabeledStmt for gotos, and a *SwitchStmt, *SelectStmt,
	// or *ForStmt for breaks and continues, depending on the context of
	// the branch. Target is not set for fallthroughs.
	Target Stmt
	// 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
	Colon src.Pos
	// contains filtered or unexported fields
}

func (*CaseClause) Pos

func (n *CaseClause) Pos() src.Pos

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
	Colon src.Pos
	// contains filtered or unexported fields
}

func (*CommClause) Pos

func (n *CommClause) Pos() src.Pos

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
	Rbrace   src.Pos
	// 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 Error

type Error struct {
	Pos src.Pos
	Msg string
}

Error describes a syntax error. Error implements the error interface.

func (Error) Error

func (err Error) Error() string

type ErrorHandler

type ErrorHandler func(err error)

An ErrorHandler is called for each error encountered reading a .go file.

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) Pos

func (n *Field) Pos() src.Pos

type File

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

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

func Parse

func Parse(base *src.PosBase, src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode) (_ *File, first error)

Parse parses a single Go source file from src and returns the corresponding syntax tree. If there are errors, Parse will return the first error found, and a possibly partially constructed syntax tree, or nil if no correct package clause was found. The base argument is only used for position information.

If errh != nil, it is called with each error encountered, and Parse will process as much source as possible. If errh is nil, Parse will terminate immediately upon encountering an error.

If a PragmaHandler is provided, it is called with each pragma encountered.

The Mode argument is currently ignored.

func ParseBytes

func ParseBytes(base *src.PosBase, src []byte, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error)

ParseBytes behaves like Parse but it reads the source from the []byte slice provided.

func ParseFile

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

ParseFile behaves like Parse but it reads the source from the named file.

func (*File) Pos

func (n *File) Pos() src.Pos

type ForStmt

type ForStmt struct {
	Init SimpleStmt // incl. *RangeClause
	Cond Expr
	Post SimpleStmt
	Body *BlockStmt
	// 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   *BlockStmt // nil means no body (forward declaration)
	Pragma Pragma     // 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 *BlockStmt
	// 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 *BlockStmt
	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

Mode describes the parser mode.

const (
	CheckBranches Mode = 1 << iota // check correct use of labels, break, continue, and goto statements
)

Modes supported by the parser.

type Name

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

Value

type Node

type Node interface {
	// Pos() returns the position associated with the node as follows:
	// 1) The position of a node representing a terminal syntax production
	//    (Name, BasicLit, etc.) is the position of the respective production
	//    in the source.
	// 2) The position of a node representing a non-terminal production
	//    (IndexExpr, IfStmt, etc.) is the position of a token uniquely
	//    associated with that production; usually the left-most one
	//    ('[' for IndexExpr, 'if' for IfStmt, etc.)
	Pos() src.Pos
	// 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 or type declaration. Callers may assign meaning to the flags as appropriate.

type PragmaHandler

type PragmaHandler func(pos src.Pos, 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
	Rbrace src.Pos
	// 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
	Rbrace src.Pos
	// contains filtered or unexported fields
}

type TypeDecl

type TypeDecl struct {
	Name   *Name
	Alias  bool
	Type   Expr
	Group  *Group // nil means not part of a group
	Pragma Pragma
	// 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

Jump to

Keyboard shortcuts

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