syntax

type Array ¶

type Array struct {
	Items []Node
	// contains filtered or unexported fields
}

Array represents an array of operands. Arrays defined by the user will contain only a single type, either being a literal, or an array or object. [Items[0], Items[1], ...]

func (n Array) Err(msg string) error

func (n Array) Pos() Pos

type AssignStmt ¶

type AssignStmt struct {
	Left  Node
	Right Node
	// contains filtered or unexported fields
}

AssignStmt for assigning values to variables. Left = Right

func (n AssignStmt) Err(msg string) error

func (n AssignStmt) Pos() Pos

type BlockStmt ¶

type BlockStmt struct {
	Nodes []Node
	// contains filtered or unexported fields
}

BlockStmt for a list of top-level statements, each separated by a semi. {Nodes[0]; Nodes[1]; ...}

func (n BlockStmt) Err(msg string) error

func (n BlockStmt) Pos() Pos

type BranchStmt ¶

type BranchStmt struct {
	Tok token
	// contains filtered or unexported fields
}

BranchStmt for break or continue statements within a for-loop.

func (n BranchStmt) Err(msg string) error

func (n BranchStmt) Pos() Pos

type CaseStmt ¶

type CaseStmt struct {
	Value Node
	Then  Node
	// contains filtered or unexported fields
}

CaseStmt for use within a match statement. If the condition of the match statement matches the value, the Then block is executed. Value -> Then Value -> { Then }

func (n CaseStmt) Err(msg string) error

func (n CaseStmt) Pos() Pos

type ChainExpr ¶

type ChainExpr struct {
	Commands []*CommandStmt
	// contains filtered or unexported fields
}

ChainExpr for using the output of one command as the first argument to a subsequent command. Commands[0] -> Commands[1] -> ...

func (n ChainExpr) Err(msg string) error

func (n ChainExpr) Pos() Pos

type CommandStmt ¶

type CommandStmt struct {
	Name *Name
	Args []Node
	// contains filtered or unexported fields
}

CommandStmt for the invocation of a command. The arguments passed to the command are space separated. Name Args[0] Args[1] ...

func (n CommandStmt) Err(msg string) error

func (n CommandStmt) Pos() Pos

type DotExpr ¶

type DotExpr struct {
	Left  Node
	Right Node
	// contains filtered or unexported fields
}

DotExpr for selecting fields on an entity. The left most node of this expression will always be a Ref. $Left.Right

func (n DotExpr) Err(msg string) error

func (n DotExpr) Pos() Pos

type ExprList ¶

type ExprList struct {
	Nodes []Node
	// contains filtered or unexported fields
}

ExprList is a list of comma separated expressions. Node[0], Node[1], ...

func (n ExprList) Err(msg string) error

func (n ExprList) Pos() Pos

type ForStmt ¶

type ForStmt struct {
	Init Node
	Cond Node
	Post Node
	Body *BlockStmt
	// contains filtered or unexported fields
}

ForStmt for executing a block code multiple times. for Cond { Body } for Init; Cond; Post { Body }

func (n ForStmt) Err(msg string) error

func (n ForStmt) Pos() Pos

type IfStmt ¶

type IfStmt struct {
	Cond Node
	Then Node
	Else Node
	// contains filtered or unexported fields
}

IfStmt for checking the condition and executing the given Then node if that condition evaluates to a truthy value. if Cond { Then } else { Else }

func (n IfStmt) Err(msg string) error

func (n IfStmt) Pos() Pos

type IndExpr ¶

type IndExpr struct {
	Left  Node
	Right Node
	// contains filtered or unexported fields
}

IndExpr for accessing items in an indexable type such as an array or an object. The left most node of this expression will always be a Ref. $Left[Right]

func (n IndExpr) Err(msg string) error

func (n IndExpr) Pos() Pos

type KeyExpr ¶

type KeyExpr struct {
	Key   *Name
	Value Node
	// contains filtered or unexported fields
}

KeyExpr for defining a key-value pair within an object. The key of this pair is a name and not a string literal. Key: Value

func (n KeyExpr) Err(msg string) error

func (n KeyExpr) Pos() Pos

type Lit ¶

type Lit struct {
	Type  LitType
	Value string
	// contains filtered or unexported fields
}

Lit represents either a String, Int, or Bool literal. Value

func (n Lit) Err(msg string) error

func (n Lit) Pos() Pos

type LitType ¶

type LitType uint

const (
	StringLit   LitType = iota + 1 // string
	IntLit                         // int
	FloatLit                       // float
	DurationLit                    // duration
	BoolLit                        // bool
)

func (i LitType) String() string

type MatchStmt ¶

type MatchStmt struct {
	Cond    Node
	Cases   []*CaseStmt
	Default Node
	// contains filtered or unexported fields
}

MatchStmt for checking the condition against different literals. The default condition for a match statement is defined with the name _.

match Cond {
    Cases[0];
    Cases[1];
    Default;
}

func (n MatchStmt) Err(msg string) error

func (n MatchStmt) Pos() Pos

type Name ¶

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

Name represents an identifier, such as a variable name, object key, or reference name. Value

func (n Name) Err(msg string) error

func (n Name) Pos() Pos

type Node ¶

type Node interface {
	// Pos returns the position the node can be found out in the original
	// source.
	Pos() Pos

	// Err reports an error that occurred at the node's position.
	Err(msg string) error
}

func Parse(name string, r io.Reader, errh func(Pos, string)) ([]Node, error)

func ParseExpr(s string) ([]Node, error)

func ParseFile(fname string, errh func(Pos, string)) ([]Node, error)

func ParseRef(s string) (Node, error)

type Object ¶

type Object struct {
	Pairs []*KeyExpr
	// contains filtered or unexported fields
}

Object is the type for key-value pairs. {Pairs[0], Pairs[1], ...}

func (n Object) Err(msg string) error

func (n Object) Pos() Pos

type Op ¶

type Op uint

const (
	EqOp  Op = iota + 1 // ==
	NeqOp               // !=
	LtOp                // <
	LeqOp               // <=
	GtOp                // >
	GeqOp               // >=

	// pseudo-operators
	InOp  // in
	AndOp // and
	OrOp  // or
)

func (i Op) String() string

type Operation ¶

type Operation struct {
	Op    Op
	Left  Node
	Right Node
	// contains filtered or unexported fields
}

Operation represents a binary expression. Left Op Right

func (n Operation) Err(msg string) error

func (n Operation) Pos() Pos

type Pos ¶

type Pos struct {
	File string
	Line int
	Col  int
}

func (p Pos) Err(msg string) error

func (p Pos) String() string

type Range ¶

type Range struct {
	Left  Node
	Right Node
	// contains filtered or unexported fields
}

Range for iterating over iterable values such as arrays and objects. Left = range Right

func (n Range) Err(msg string) error

func (n Range) Pos() Pos

type Ref ¶

type Ref struct {
	Left Node
	// contains filtered or unexported fields
}

Ref for referring to previous variable declarations. $Left

func (n Ref) Err(msg string) error

func (n Ref) Pos() Pos