ast

type Action ¶

type Action struct {
	Pattern []Expr
	Stmts   Stmts
}

Action is pattern-action section of a program.

func (a *Action) String() string

type ArrayExpr ¶

type ArrayExpr struct {
	Scope VarScope
	Index int
	Name  string
}

ArrayExpr is an array reference. Not really a stand-alone expression, except as an argument to split() or a user function call.

func (e *ArrayExpr) String() string

type AssignExpr ¶

type AssignExpr struct {
	Left  Expr // can be one of: var, array[x], $n
	Right Expr
}

AssignExpr is an expression like x = 1234.

func (e *AssignExpr) String() string

type AugAssignExpr ¶

type AugAssignExpr struct {
	Left  Expr // can be one of: var, array[x], $n
	Op    Token
	Right Expr
}

AugAssignExpr is an assignment expression like x += 5.

func (e *AugAssignExpr) String() string

type BinaryExpr ¶

type BinaryExpr struct {
	Left  Expr
	Op    Token
	Right Expr
}

BinaryExpr is an expression like 1 + 2.

func (e *BinaryExpr) String() string

type BlockStmt ¶

type BlockStmt struct {
	Body Stmts
}

BlockStmt is a stand-alone block like { print "x" }.

func (s *BlockStmt) String() string

type BreakStmt ¶

type BreakStmt struct{}

BreakStmt is a break statement.

func (s *BreakStmt) String() string

type CallExpr ¶

type CallExpr struct {
	Func Token
	Args []Expr
}

CallExpr is a builtin function call like length($1).

func (e *CallExpr) String() string

type CondExpr ¶

type CondExpr struct {
	Cond  Expr
	True  Expr
	False Expr
}

CondExpr is an expression like cond ? 1 : 0.

func (e *CondExpr) String() string

type ContinueStmt ¶

type ContinueStmt struct{}

ContinueStmt is a continue statement.

func (s *ContinueStmt) String() string

type DeleteStmt ¶

type DeleteStmt struct {
	Array *ArrayExpr
	Index []Expr
}

DeleteStmt is a statement like delete a[k].

func (s *DeleteStmt) String() string

type DoWhileStmt ¶

type DoWhileStmt struct {
	Body Stmts
	Cond Expr
}

DoWhileStmt is a do-while loop.

func (s *DoWhileStmt) String() string

type ExitStmt ¶

type ExitStmt struct {
	Status Expr
}

ExitStmt is an exit statement.

func (s *ExitStmt) String() string

type Expr ¶

type Expr interface {
	String() string
	// contains filtered or unexported methods
}

Expr is the abstract syntax tree for any AWK expression.

type ExprStmt ¶

type ExprStmt struct {
	Expr Expr
}

ExprStmt is statement like a bare function call: my_func(x).

func (s *ExprStmt) String() string

type FieldExpr ¶

type FieldExpr struct {
	Index Expr
}

FieldExpr is an expression like $0.

func (e *FieldExpr) String() string

type ForInStmt ¶

type ForInStmt struct {
	Var   *VarExpr
	Array *ArrayExpr
	Body  Stmts
}

ForInStmt is a for loop like for (k in a) print k, a[k].

func (s *ForInStmt) String() string

type ForStmt ¶

type ForStmt struct {
	Pre  Stmt
	Cond Expr
	Post Stmt
	Body Stmts
}

ForStmt is a C-like for loop: for (i=0; i<10; i++) print i.

func (s *ForStmt) String() string

type Function ¶

type Function struct {
	Name   string
	Params []string
	Arrays []bool
	Body   Stmts
}

Function is the AST for a user-defined function.

func (f *Function) String() string

type GetlineExpr ¶

type GetlineExpr struct {
	Command Expr
	Target  Expr
	File    Expr
}

GetlineExpr is an expression read from file or pipe input.

func (e *GetlineExpr) String() string

type IfStmt ¶

type IfStmt struct {
	Cond Expr
	Body Stmts
	Else Stmts
}

IfStmt is an if or if-else statement.

func (s *IfStmt) String() string

type InExpr ¶

type InExpr struct {
	Index []Expr
	Array *ArrayExpr
}

InExpr is an expression like (index in array).

func (e *InExpr) String() string

type IncrExpr ¶

type IncrExpr struct {
	Expr Expr
	Op   Token
	Pre  bool
}

IncrExpr is an increment or decrement expression like x++ or --y.

func (e *IncrExpr) String() string

type IndexExpr ¶

type IndexExpr struct {
	Array *ArrayExpr
	Index []Expr
}

IndexExpr is an expression like a[k] (rvalue or lvalue).

func (e *IndexExpr) String() string

type MultiExpr ¶

type MultiExpr struct {
	Exprs []Expr
}

MultiExpr isn't an interpretable expression, but it's used as a pseudo-expression for print[f] parsing.

func (e *MultiExpr) String() string

type NamedFieldExpr ¶ added in v1.17.0

type NamedFieldExpr struct {
	Field Expr
}

NamedFieldExpr is an expression like @"name".

func (e *NamedFieldExpr) String() string

type NextStmt ¶

type NextStmt struct{}

NextStmt is a next statement.

func (s *NextStmt) String() string

type NumExpr ¶

type NumExpr struct {
	Value float64
}

NumExpr is a literal number like 1234.

func (e *NumExpr) String() string

type PrintStmt ¶

type PrintStmt struct {
	Args     []Expr
	Redirect Token
	Dest     Expr
}

PrintStmt is a statement like print $1, $3.

func (s *PrintStmt) String() string

type PrintfStmt ¶

type PrintfStmt struct {
	Args     []Expr
	Redirect Token
	Dest     Expr
}

PrintfStmt is a statement like printf "%3d", 1234.

func (s *PrintfStmt) String() string

type Program ¶ added in v1.15.0

type Program struct {
	Begin     []Stmts
	Actions   []Action
	End       []Stmts
	Functions []Function
	Scalars   map[string]int
	Arrays    map[string]int
}

Program is an entire AWK program.

func (p *Program) String() string

type RegExpr ¶

type RegExpr struct {
	Regex string
}

RegExpr is a stand-alone regex expression, equivalent to: $0 ~ /regex/.

func (e *RegExpr) String() string

type ReturnStmt ¶

type ReturnStmt struct {
	Value Expr
}

ReturnStmt is a return statement.

func (s *ReturnStmt) String() string

type Stmt ¶

type Stmt interface {
	String() string
	// contains filtered or unexported methods
}

Stmt is the abstract syntax tree for any AWK statement.

type Stmts ¶

type Stmts []Stmt

Stmts is a block containing multiple statements.

func (ss Stmts) String() string

type StrExpr ¶

type StrExpr struct {
	Value string
}

StrExpr is a literal string like "foo".

func (e *StrExpr) String() string

type UnaryExpr ¶

type UnaryExpr struct {
	Op    Token
	Value Expr
}

UnaryExpr is an expression like -1234.

func (e *UnaryExpr) String() string

type UserCallExpr ¶

type UserCallExpr struct {
	Native bool // false = AWK-defined function, true = native Go func
	Index  int
	Name   string
	Args   []Expr
}

UserCallExpr is a user-defined function call like my_func(1, 2, 3)

Index is the resolved function index used by the interpreter; Name is the original name used by String().

func (e *UserCallExpr) String() string

type VarExpr ¶

type VarExpr struct {
	Scope VarScope
	Index int
	Name  string
}

VarExpr is a variable reference (special var, global, or local). Index is the resolved variable index used by the interpreter; Name is the original name used by String().

func (e *VarExpr) String() string

type VarScope ¶

type VarScope int

const (
	ScopeSpecial VarScope = iota
	ScopeGlobal
	ScopeLocal
)

type WhileStmt ¶

type WhileStmt struct {
	Cond Expr
	Body Stmts
}

WhileStmt is a while loop.

func (s *WhileStmt) String() string