bldy.build / skylark / syntax

Index | Files | Exmaples | Directories
go get bldy.build/skylark/syntax

Package syntax provides a Skylark parser and abstract syntax tree.

Index

Package Files

parse.go quote.go scan.go syntax.go walk.go

func Walk

func Walk(n Node, f func(Node) bool)

Walk traverses a syntax tree in depth-first order. It starts by calling f(n); n must not be nil. If f returns true, Walk calls itself recursively for each non-nil child of n. Walk then calls f(nil).

type AssignStmt

type AssignStmt struct {
    OpPos Position
    Op    Token // = EQ | {PLUS,MINUS,STAR,PERCENT}_EQ
    LHS   Expr
    RHS   Expr
}

An AssignStmt represents an assignment:

x = 0
x, y = y, x
x += 1

func (*AssignStmt) Span

func (x *AssignStmt) Span() (start, end Position)

type BinaryExpr

type BinaryExpr struct {
    X     Expr
    OpPos Position
    Op    Token
    Y     Expr
}

A BinaryExpr represents a binary expression: X Op Y.

func (*BinaryExpr) Span

func (x *BinaryExpr) Span() (start, end Position)

type BranchStmt

type BranchStmt struct {
    Token    Token // = BREAK | CONTINUE | PASS
    TokenPos Position
}

A BranchStmt changes the flow of control: break, continue, pass.

func (*BranchStmt) Span

func (x *BranchStmt) Span() (start, end Position)

type CallExpr

type CallExpr struct {
    Fn     Expr
    Lparen Position
    Args   []Expr
    Rparen Position
}

A CallExpr represents a function call expression: Fn(Args).

func (*CallExpr) Span

func (x *CallExpr) Span() (start, end Position)

type Comprehension

type Comprehension struct {
    Curly   bool // {x:y for ...} or {x for ...}, not [x for ...]
    Lbrack  Position
    Body    Expr
    Clauses []Node // = *ForClause | *IfClause
    Rbrack  Position
}

A Comprehension represents a list or dict comprehension: [Body for ... if ...] or {Body for ... if ...}

func (*Comprehension) Span

func (x *Comprehension) Span() (start, end Position)

type CondExpr

type CondExpr struct {
    If      Position
    Cond    Expr
    True    Expr
    ElsePos Position
    False   Expr
}

CondExpr represents the conditional: X if COND else ELSE.

func (*CondExpr) Span

func (x *CondExpr) Span() (start, end Position)

type DefStmt

type DefStmt struct {
    Def  Position
    Name *Ident
    Function
}

A DefStmt represents a function definition.

func (*DefStmt) Span

func (x *DefStmt) Span() (start, end Position)

type DictEntry

type DictEntry struct {
    Key   Expr
    Colon Position
    Value Expr
}

A DictEntry represents a dictionary entry: Key: Value. Used only within a DictExpr.

func (*DictEntry) Span

func (x *DictEntry) Span() (start, end Position)

type DictExpr

type DictExpr struct {
    Lbrace Position
    List   []Expr // all *DictEntrys
    Rbrace Position
}

A DictExpr represents a dictionary literal: { List }.

func (*DictExpr) Span

func (x *DictExpr) Span() (start, end Position)

type DotExpr

type DotExpr struct {
    X       Expr
    Dot     Position
    NamePos Position
    Name    *Ident
}

A DotExpr represents a field or method selector: X.Name.

func (*DotExpr) Span

func (x *DotExpr) Span() (start, end Position)

type Error

type Error struct {
    Pos Position
    Msg string
}

An Error describes the nature and position of a scanner or parser error.

func (Error) Error

func (e Error) Error() string

type Expr

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

An Expr is a Skylark expression.

func ParseExpr

func ParseExpr(filename string, src interface{}) (expr Expr, err error)

ParseExpr parses a Skylark expression. See Parse for explanation of parameters.

type ExprStmt

type ExprStmt struct {
    X Expr
}

An ExprStmt is an expression evaluated for side effects.

func (*ExprStmt) Span

func (x *ExprStmt) Span() (start, end Position)

type File

type File struct {
    Path  string
    Stmts []Stmt

    // set by resolver:
    Locals []*Ident // this file's (comprehension-)local variables
}

A File represents a Skylark file.

func Parse

func Parse(filename string, src interface{}) (f *File, err error)

Parse parses the input data and returns the corresponding parse tree.

If src != nil, ParseFile parses the source from src and the filename is only used when recording position information. The type of the argument for the src parameter must be string, []byte, or io.Reader. If src == nil, ParseFile parses the file specified by filename.

func (*File) Span

func (x *File) Span() (start, end Position)

type ForClause

type ForClause struct {
    For  Position
    Vars Expr // name, or tuple of names
    In   Position
    X    Expr
}

A ForClause represents a for clause in a list comprehension: for Vars in X.

func (*ForClause) Span

func (x *ForClause) Span() (start, end Position)

type ForStmt

type ForStmt struct {
    For  Position
    Vars Expr // name, or tuple of names
    X    Expr
    Body []Stmt
}

A ForStmt represents a loop: for Vars in X: Body.

func (*ForStmt) Span

func (x *ForStmt) Span() (start, end Position)

type Function

type Function struct {
    StartPos Position // position of DEF or LAMBDA token
    Params   []Expr   // param = ident | ident=expr | *ident | **ident
    Body     []Stmt

    // set by resolver:
    HasVarargs bool     // whether params includes *args (convenience)
    HasKwargs  bool     // whether params includes **kwargs (convenience)
    Locals     []*Ident // this function's local variables, parameters first
    FreeVars   []*Ident // enclosing local variables to capture in closure
}

A Function represents the common parts of LambdaExpr and DefStmt.

func (*Function) Span

func (x *Function) Span() (start, end Position)

type Ident

type Ident struct {
    NamePos Position
    Name    string

    Scope uint8 // one of resolve.{Undefined,Local,Free,Global,Builtin}
    Index int   // index into enclosing {DefStmt,File}.Locals (if scope==Local) or DefStmt.FreeVars (if scope==Free)
}

An Ident represents an identifier.

func (*Ident) Span

func (x *Ident) Span() (start, end Position)

type IfClause

type IfClause struct {
    If   Position
    Cond Expr
}

An IfClause represents an if clause in a list comprehension: if Cond.

func (*IfClause) Span

func (x *IfClause) Span() (start, end Position)

type IfStmt

type IfStmt struct {
    If      Position // IF or ELIF
    Cond    Expr
    True    []Stmt
    ElsePos Position // ELSE or ELIF
    False   []Stmt   // optional
}

An IfStmt is a conditional: If Cond: True; else: False. 'elseif' is desugared into a chain of IfStmts.

func (*IfStmt) Span

func (x *IfStmt) Span() (start, end Position)

type IndexExpr

type IndexExpr struct {
    X      Expr
    Lbrack Position
    Y      Expr
    Rbrack Position
}

An IndexExpr represents an index expression: X[Y].

func (*IndexExpr) Span

func (x *IndexExpr) Span() (start, end Position)

type LambdaExpr

type LambdaExpr struct {
    Lambda Position
    Function
}

A LambdaExpr represents an inline function abstraction.

Although they may be added in future, lambda expressions are not currently part of the Skylark spec, so their use is controlled by the resolver.AllowLambda flag.

func (*LambdaExpr) Span

func (x *LambdaExpr) Span() (start, end Position)

type ListExpr

type ListExpr struct {
    Lbrack Position
    List   []Expr
    Rbrack Position
}

A ListExpr represents a list literal: [ List ].

func (*ListExpr) Span

func (x *ListExpr) Span() (start, end Position)

type Literal

type Literal struct {
    Token    Token // = STRING | INT
    TokenPos Position
    Raw      string      // uninterpreted text
    Value    interface{} // = string | int
}

A Literal represents a literal string or number.

func (*Literal) Span

func (x *Literal) Span() (start, end Position)

type LoadStmt

type LoadStmt struct {
    Load   Position
    Module *Literal // a string
    From   []*Ident // name defined in loading module
    To     []*Ident // name in loaded module
    Rparen Position
}

A LoadStmt loads another module and binds names from it: load(Module, "x", y="foo").

The AST is slightly unfaithful to the concrete syntax here because Skylark's load statement, so that it can be implemented in Python, binds some names (like y above) with an identifier and some (like x) without. For consistency we create fake identifiers for all the strings.

func (*LoadStmt) Span

func (x *LoadStmt) Span() (start, end Position)

type Node

type Node interface {
    // Span returns the start and end position of the expression.
    Span() (start, end Position)
}

A Node is a node in a Skylark syntax tree.

type Position

type Position struct {
    Line int32 // 1-based line number
    Col  int32 // 1-based column number (strictly: rune)
    // contains filtered or unexported fields
}

A Position describes the location of a rune of input.

func End

func End(n Node) Position

End returns the end position of the expression.

func Start

func Start(n Node) Position

Start returns the start position of the expression.

func (Position) Filename

func (p Position) Filename() string

Filename returns the name of the file containing this position.

func (Position) IsValid

func (p Position) IsValid() bool

IsValid reports whether the position is valid.

func (Position) String

func (p Position) String() string

type ReturnStmt

type ReturnStmt struct {
    Return Position
    Result Expr // may be nil
}

A ReturnStmt returns from a function.

func (*ReturnStmt) Span

func (x *ReturnStmt) Span() (start, end Position)

type SliceExpr

type SliceExpr struct {
    X            Expr
    Lbrack       Position
    Lo, Hi, Step Expr // all optional
    Rbrack       Position
}

A SliceExpr represents a slice or substring expression: X[Lo:Hi:Step].

func (*SliceExpr) Span

func (x *SliceExpr) Span() (start, end Position)

type Stmt

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

A Stmt is a Skylark statement.

type Token

type Token int8

A Token represents a Skylark lexical token.

const (
    ILLEGAL Token = iota
    EOF

    NEWLINE
    INDENT
    OUTDENT

    // Tokens with values
    IDENT  // x
    INT    // 123
    FLOAT  // 1.23e45
    STRING // "foo" or 'foo' or '''foo''' or r'foo' or r"foo"

    // Punctuation
    PLUS          // +
    MINUS         // -
    STAR          // *
    SLASH         // /
    SLASHSLASH    // //
    PERCENT       // %
    AMP           // &
    PIPE          // |
    DOT           // .
    COMMA         // ,
    EQ            // =
    SEMI          // ;
    COLON         // :
    LPAREN        // (
    RPAREN        // )
    LBRACK        // [
    RBRACK        // ]
    LBRACE        // {
    RBRACE        // }
    LT            // <
    GT            // >
    GE            // >=
    LE            // <=
    EQL           // ==
    NEQ           // !=
    PLUS_EQ       // +=    (keep order consistent with PLUS..PERCENT)
    MINUS_EQ      // -=
    STAR_EQ       // *=
    SLASH_EQ      // /=
    SLASHSLASH_EQ // //=
    PERCENT_EQ    // %=
    STARSTAR      // **

    // Keywords
    AND
    BREAK
    CONTINUE
    DEF
    ELIF
    ELSE
    FOR
    IF
    IN
    LAMBDA
    NOT
    NOT_IN // synthesized by parser from NOT IN
    OR
    PASS
    RETURN
)

func (Token) GoString

func (tok Token) GoString() string

GoString is like String but quotes punctuation tokens. Use Sprintf("%#v", tok) when constructing error messages.

func (Token) String

func (tok Token) String() string

type TupleExpr

type TupleExpr struct {
    Lparen Position // optional (e.g. in x, y = 0, 1), but required if List is empty
    List   []Expr
    Rparen Position
}

A TupleExpr represents a tuple literal: (List).

func (*TupleExpr) Span

func (x *TupleExpr) Span() (start, end Position)

type UnaryExpr

type UnaryExpr struct {
    OpPos Position
    Op    Token
    X     Expr
}

A UnaryExpr represents a unary expression: Op X.

func (*UnaryExpr) Span

func (x *UnaryExpr) Span() (start, end Position)

Subdirectories

testdata