syntax

package
Version: v0.0.0-...-8a52383 Latest Latest
Warning

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

Go to latest
Published: Jan 31, 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

Jump to

Keyboard shortcuts

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