ast

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

type ArithExp struct {
	Dollar token.Pos // position of "$"
	Lparen token.Pos // position of "(("
	X      Expr
	Rparen token.Pos // position of "))"
}

type ArrayIndexExp struct {
	Bitnot   token.Pos   // position of '!'
	Lbracket token.Pos   // position of '['
	Tok      token.Token // Token.AT or Token.MUL
	TokPos   token.Pos
	Rbracket token.Pos // position of ']'
}

type AssignStmt struct {
	Local  bool
	Lhs    Expr
	Assign token.Pos // position of "="
	Rhs    Expr
}

type BasicLit struct {
	Kind     token.Token // Token.Empty | Token.Null | Token.Boolean | Token.Byte | Token.Integer | Token.Currency | Token.Long | Token.Single | Token.Double | Token.Date | Token.String | Token.Object | Token.Error
	Value    string
	ValuePos token.Pos // literal position
}

type BasicTestExpr struct {
	Lbrack token.Pos // position of "["
	X      Expr
	Rbrack token.Pos // position of "]"
}

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

type BlockStmt struct {
	Tok     token.Token // Token.NONE | Token.LBRACE
	Opening token.Pos
	List    []Stmt
	Closing token.Pos
}

type BreakStmt struct {
	Break token.Pos // position of "break"
}

type CallExpr struct {
	Func *Ident
	Recv []Expr
}

type CaseClause struct {
	Case  token.Pos // position of "case"
	Conds []Expr
	Body  *BlockStmt
}

type CaseConversionExp struct {
	FirstChar bool
	ToUpper   bool
}

type CmdGroup struct {
	Lbrace token.Pos // position of "{"
	List   []Stmt
	Rbrace token.Pos // position of "}"
}

type CmdSubst struct {
	Dollar  token.Pos
	Tok     token.Token // Token.LPAREN or Token.BACK_QUOTE
	Opening token.Pos
	X       Expr
	Closing token.Pos
}

type Comment struct {
	Hash token.Pos // position of "#"
	Text string
}

type CommentGroup struct {
	List []*Comment
}

type ContinueStmt struct {
	Continue token.Pos // position of "continue"
}

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

type DefaultValAssignExp struct {
	Colon  token.Pos
	Assign token.Pos
	Val    Expr
}

type DefaultValExp struct {
	Colon token.Pos
	Sub   token.Pos
	Val   Expr
}

type DelPrefix struct {
	Longest bool
	Hash    token.Pos // position of "#" or "##"
	Val     Expr
}

type DelSuffix struct {
	Longest bool
	Mod     token.Pos // position of "%" or "%%"
	Val     Expr
}

type ExpOperator string

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

type ExprStmt struct {
	X Expr
}

type ExtendedTestExpr struct {
	Lbrack token.Pos // position of "[["
	X      Expr
	Rbrack token.Pos // position of "]]"
}

type File struct {
	Doc *CommentGroup

	Stmts []Stmt
	Decls []Decl
}

type ForeachStmt struct {
	For    token.Pos // position of "for"
	Elem   Expr
	In     token.Pos // position of "in"
	Group  []Expr
	Body   *BlockStmt
	EndPos token.Pos // position of "end"
}

type FuncDecl struct {
	Function token.Pos // position of "function"
	Name     *Ident
	Recv     []Expr
	Body     *BlockStmt
	EndPos   token.Pos // position of "end"
}

type Ident struct {
	NamePos token.Pos
	Name    string
}

type IfStmt struct {
	If     token.Pos // position of "if"
	Cond   Expr
	Body   *BlockStmt
	Elif   []*IfStmt
	Else   *BlockStmt
	EndPos token.Pos // position of "end"
}

type LengthExp struct {
	Hash token.Pos // position of "#"
}

type Node interface {
	Pos() token.Pos
	End() token.Pos
}

type NonNullCheckExp struct {
	Colon token.Pos
	Quest token.Pos
	Val   Expr
}

type NonNullExp struct {
	Colon token.Pos
	Add   token.Pos
	Val   Expr
}

type OperatorExp struct {
	At token.Pos // position of "@"
	Op ExpOperator
}

type ParamExp struct {
	Dollar               token.Pos // position of "$"
	Lbrace               token.Pos // position of "{"
	Var                  Expr
	*DefaultValExp                 // ${var:-val}
	*DefaultValAssignExp           // ${var:=val}
	*NonNullCheckExp               // ${var:?val}
	*NonNullExp                    // ${var:+val}
	*PrefixExp                     // ${!var*}
	*PrefixArrayExp                // ${!var@}
	*ArrayIndexExp                 // ${!var[*]} or ${!var[@]}
	*LengthExp                     // ${#var}
	*DelPrefix                     // ${var#val} or ${var##val}
	*DelSuffix                     // ${var%val} or ${var%%val}
	*SubstringExp                  // ${var:offset} or ${var:offset:length}
	*ReplaceExp                    // ${var/old/new}
	*ReplacePrefixExp              // ${var/#old/new}
	*ReplaceSuffixExp              // ${var/%old/new}
	*CaseConversionExp             // ${var,} or ${var^} or ${var,,} or ${var^^}
	*OperatorExp                   // ${var@op}
	Rbrace               token.Pos // position of "}"
}

type PrefixArrayExp struct {
	Bitnot token.Pos // position of '!'
	At     token.Pos // position of '@'
}

type PrefixExp struct {
	Bitnot token.Pos // position of '!'
	Mul    token.Pos // position of '*'
}

type ProcSubst struct {
	Tok    token.Token // Token.GT or Token.LT
	TokPos token.Pos
	Lparen token.Pos // position of "("
	X      Expr
	Rparen token.Pos // position of ")"
}

type ReplaceExp struct {
	All  bool
	Div1 token.Pos // position of "/" or "//"
	Old  string
	Div2 token.Pos // position of "/"
	New  string
}

type ReplacePrefixExp struct {
	Div1 token.Pos // position of "/"
	Hash token.Pos // position of "#"
	Old  string
	Div2 token.Pos // position of "/"
	New  string
}

type ReplaceSuffixExp struct {
	Div1 token.Pos // position of "/"
	Mod  token.Pos // position of "%"
	Old  string
	Div2 token.Pos // position of "/"
	New  string
}

type ReturnStmt struct {
	Return token.Pos // position of "return"
	X      Expr
}

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

type SubstringExp struct {
	Colon1 token.Pos // position of ":"
	Offset int
	Colon2 token.Pos // position of ":"
	Length int
}

type SwitchStmt struct {
	Switch token.Pos // position of "switch"
	Lparen token.Pos // position of "("
	Var    Expr
	Rparen token.Pos // position of ")"
	Cases  []*CaseClause
	Else   *BlockStmt
	EndPos token.Pos // position of "end"
}

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

type WhileStmt struct {
	While  token.Pos // position of "while"
	Cond   Expr
	Body   *BlockStmt
	EndPos token.Pos // position of "end"
}