smile

type BadExpr ¶

type BadExpr struct {
	From, To token.Pos // position range of bad expression
}

A BadExpr node is a placeholder for expressions containing syntax errors for which no correct expression nodes can be created.

func (x *BadExpr) End() token.Pos

func (x *BadExpr) Pos() token.Pos

type BasicLit ¶

type BasicLit struct {
	ValuePos token.Pos   // literal position
	Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
	Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
}

A BasicLit node represents a literal of basic type.

func (x *BasicLit) End() token.Pos

func (x *BasicLit) Pos() token.Pos

type BinaryExpr ¶

type BinaryExpr struct {
	X     Expr        // left operand
	OpPos token.Pos   // position of Op
	Op    token.Token // operator
	Y     Expr        // right operand
}

A BinaryExpr node represents a binary expression.

func (x *BinaryExpr) End() token.Pos

func (x *BinaryExpr) Pos() token.Pos

type CallExpr ¶

type CallExpr struct {
	Fun    Expr      // function expression
	Lparen token.Pos // position of "("
	Args   []Expr    // function arguments; or nil
	Rparen token.Pos // position of ")"
}

A CallExpr node represents an expression followed by an argument list.

func (x *CallExpr) End() token.Pos

func (x *CallExpr) Pos() token.Pos

type Error ¶

type Error struct {
	Pos token.Position
	Msg string
}

Within ErrorVector, an error is represented by an Error node. The position Pos, if valid, points to the beginning of the offending token, and the error condition is described by Msg.

func (e *Error) Error() string

type ErrorHandler ¶

type ErrorHandler interface {
	Error(pos token.Position, msg string)
}

An implementation of an ErrorHandler may be provided to the Scanner. If a syntax error is encountered and a handler was installed, Error is called with a position and an error message. The position points to the beginning of the offending token.

type ErrorList ¶

type ErrorList []*Error

An ErrorList is a (possibly sorted) list of Errors.

func (p ErrorList) Error() string

func (p ErrorList) Len() int

func (p ErrorList) Less(i, j int) bool

func (p ErrorList) Swap(i, j int)

type ErrorVector ¶

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

ErrorVector implements the ErrorHandler interface. It maintains a list of errors which can be retrieved with GetErrorList and GetError. The zero value for an ErrorVector is an empty ErrorVector ready to use.

A common usage pattern is to embed an ErrorVector alongside a scanner in a data structure that uses the scanner. By passing a reference to an ErrorVector to the scanner's Init call, default error handling is obtained.

func (h *ErrorVector) Error(pos token.Position, msg string)

func (h *ErrorVector) ErrorCount() int

func (h *ErrorVector) GetError(mode int) error

func (h *ErrorVector) GetErrorList(mode int) ErrorList

func (h *ErrorVector) Reset()

type Expr ¶

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

func Parse(name, eqn string) (Expr, error)

type Ident ¶

type Ident struct {
	NamePos token.Pos // identifier position
	Name    string    // identifier name
}

An Ident node represents an identifier.

func NewIdent(name string) *Ident

func (x *Ident) End() token.Pos

func (x *Ident) Pos() token.Pos

type IndexExpr ¶

type IndexExpr struct {
	X      Expr      // expression
	Lbrack token.Pos // position of "["
	Index  Expr      // index expression
	Rbrack token.Pos // position of "]"
}

An IndexExpr node represents an expression followed by an index.

func (x *IndexExpr) End() token.Pos

func (x *IndexExpr) Pos() token.Pos

type Node ¶

type Node interface {
	Pos() token.Pos // position of first character belonging to the node
	End() token.Pos // position of first character immediately after the node
}

type ParenExpr ¶

type ParenExpr struct {
	Lparen token.Pos // position of "("
	X      Expr      // parenthesized expression
	Rparen token.Pos // position of ")"
}

A ParenExpr node represents a parenthesized expression.

func (x *ParenExpr) End() token.Pos

func (x *ParenExpr) Pos() token.Pos

type Token ¶

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

A Token provides information about a particular run of consecutive runes in a file.

func (t *Token) String() string

type UnaryExpr ¶

type UnaryExpr struct {
	OpPos token.Pos   // position of Op
	Op    token.Token // operator
	X     Expr        // operand
}

A UnaryExpr node represents a unary expression. Unary "*" expressions are represented via StarExpr nodes.

func (x *UnaryExpr) End() token.Pos

func (x *UnaryExpr) Pos() token.Pos

type Visitor ¶

type Visitor interface {
	Visit(node Node) (w Visitor)
}

A Visitor's Visit method is invoked for each node encountered by Walk. If the result visitor w is not nil, Walk visits each of the children of node with the visitor w, followed by a call of w.Visit(nil).