syntax

package
v0.0.0-...-083ab76 Latest Latest
Warning

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

 Go to latest Published: May 24, 2019 License: BSD-3-Clause Imports: 9 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
)
View Source 
const PosMax = 1 << 30

PosMax is the largest line or column value that can be represented without loss. Incoming values (arguments) larger than PosMax will be set to PosMax.

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
	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 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 // nil means no arguments
	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 Pos
	// contains filtered or unexported fields
}

func (*CaseClause) Pos 

func (n *CaseClause) Pos() 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 Pos
	// contains filtered or unexported fields
}

func (*CommClause) Pos 

func (n *CommClause) Pos() 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   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 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() 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 *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 errh != nil, it is called with each error encountered, and Parse will process as much source as possible. In this case, the returned syntax tree is only nil if no correct package clause was found. If errh is nil, Parse will terminate immediately upon encountering the first error, and the returned syntax tree is nil.

If pragh != nil, it is called with each pragma encountered.

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() 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 nil, *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, 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() 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 is the : in :=
	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 (i Operator) String() string

type ParenExpr 

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

(X)

type Pos 

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

A Pos represents an absolute (line, col) source position with a reference to position base for computing relative (to a file, or line directive) position information. Pos values are intentionally light-weight so that they can be created without too much concern about space use.

func MakePos 

func MakePos(base *PosBase, line, col uint) Pos

MakePos returns a new Pos for the given PosBase, line and column.

func (Pos) Base 

func (pos Pos) Base() *PosBase

func (Pos) Col 

func (pos Pos) Col() uint

func (Pos) IsKnown 

func (pos Pos) IsKnown() bool

func (Pos) Line 

func (pos Pos) Line() uint

func (Pos) RelCol 

func (pos Pos) RelCol() uint

func (Pos) RelFilename 

func (pos Pos) RelFilename() string

func (Pos) RelLine 

func (pos Pos) RelLine() uint

func (Pos) String 

func (pos Pos) String() string

type PosBase 

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

A PosBase represents the base for relative position information: At position pos, the relative position is filename:line:col.

func NewFileBase 

func NewFileBase(filename string) *PosBase

NewFileBase returns a new PosBase for the given filename. A file PosBase's position is relative to itself, with the position being filename:1:1.

func NewLineBase 

func NewLineBase(pos Pos, filename string, line, col uint) *PosBase

NewLineBase returns a new PosBase for a line directive "line filename:line:col" relative to pos, which is the position of the character immediately following the comment containing the line directive. For a directive in a line comment, that position is the beginning of the next line (i.e., the newline character belongs to the line comment).

func (*PosBase) Col 

func (base *PosBase) Col() uint

func (*PosBase) Filename 

func (base *PosBase) Filename() string

func (*PosBase) IsFileBase 

func (base *PosBase) IsFileBase() bool

func (*PosBase) Line 

func (base *PosBase) Line() uint

func (*PosBase) Pos 

func (base *PosBase) Pos() (_ Pos)

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 Pos, text string) Pragma

A PragmaHandler is used to process //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 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 // incl. *TypeSwitchGuard
	Body   []*CaseClause
	Rbrace 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 {
	Lhs *Name // nil means no Lhs :=
	X   Expr  // X.(type)
	// contains filtered or unexported fields
}

X.(type) Lhs := X.(type)

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.