ast

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

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

type ArrExpr struct {
	Lparen token.Pos // position of "("
	Vars   []Expr    // array elements
	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   // position of token
	Rbracket token.Pos   // position of ']'
}

type AssignStmt struct {
	Local  token.Pos // position of "local" keyword, if any
	Lhs    Expr      // left-hand side (variable name)
	Assign token.Pos // position of "="
	Rhs    Expr      // right-hand side (value)
}

type BinaryExpr struct {
	Compress bool        // true if spaces are compressed around operator
	X        Expr        // left operand
	OpPos    token.Pos   // position of Op
	Op       token.Token // operator (EQ, NE, LT, GT, etc.)
	Y        Expr        // right operand
}

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

type CaseClause struct {
	Conds  []Expr     // pattern expressions
	Rparen token.Pos  // position of ")"
	Body   *BlockStmt // commands to execute
	Semi   token.Pos  // position of ";;"
}

type CaseConversionExp struct {
	FirstChar bool // true for single character conversion
	ToUpper   bool // true for uppercase conversion
}

type CaseStmt struct {
	Case     token.Pos     // position of "case"
	X        Expr          // expression to match
	In       token.Pos     // position of "in"
	Patterns []*CaseClause // list of case clauses
	Else     *BlockStmt    // else clause (optional)
	Esac     token.Pos     // position of "esac"
}

type CmdExpr struct {
	Name *Ident // command name
	Recv []Expr // command arguments
}

type CmdGroup struct {
	Op      token.Token // Token.LBRACE or Token.LPAREN
	Opening token.Pos   // position of opening brace/paren
	List    []Expr      // list of commands
	Closing token.Pos   // position of closing brace/paren
}

type CmdListExpr struct {
	CtrOp token.Token // Token.OrOr or Token.AndAnd
	Cmds  []Expr      // list of commands
}

type CmdSubst struct {
	Dollar  token.Pos   // position of "$"
	Tok     token.Token // Token.DollParen or Token.BckQuote or Token.DollBrace
	Opening token.Pos   // position of opening delimiter
	X       Expr        // command expression
	Closing token.Pos   // position of closing delimiter
}

type Comment struct {
	Hash token.Pos // position of "#" character
	Text string    // comment text (excluding '#' and trailing newline)
}

type CommentGroup struct {
	List []*Comment // len(List) > 0
}

type DefaultValAssignExp struct {
	Colon  token.Pos // position of ":"
	Assign token.Pos // position of "="
	Val    Expr      // default value
}

type DefaultValExp struct {
	Colon token.Pos // position of ":"
	Sub   token.Pos // position of "-"
	Val   Expr      // default value
}

type DelPrefix struct {
	Longest bool      // true for ## (longest match)
	Hash    token.Pos // position of "#" or "##"
	Val     Expr      // prefix to delete
}

type DelSuffix struct {
	Longest bool      // true for %% (longest match)
	Mod     token.Pos // position of "%" or "%%"
	Val     Expr      // suffix to delete
}

type ExpOperator string

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

type ExprStmt struct {
	X Expr // expression
}

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

type File struct {
	Doc *CommentGroup // associated documentation

	Stmts []Stmt // list of statements
}

type ForInStmt struct {
	For  token.Pos  // position of "for"
	Var  Expr       // variable name
	In   token.Pos  // position of "in"
	List Expr       // list expression
	Semi token.Pos  // position of ";"
	Do   token.Pos  // position of "do"
	Body *BlockStmt // loop body
	Done token.Pos  // position of "done"
}

type ForStmt struct {
	For    token.Pos  // position of "for"
	Lparen token.Pos  // position of "(("
	Init   Node       // initialization expression
	Semi1  token.Pos  // position of ";"
	Cond   Expr       // condition expression
	Semi2  token.Pos  // position of ";"
	Post   Node       // post-iteration expression
	Rparen token.Pos  // position of "))"
	Do     token.Pos  // position of "do"
	Body   *BlockStmt // loop body
	Done   token.Pos  // position of "done"
}

type FuncDecl struct {
	Function token.Pos  // position of "function" keyword, if any
	Name     *Ident     // function name
	Lparen   token.Pos  // position of "("
	Rparen   token.Pos  // position of ")"
	Body     *BlockStmt // function body
}

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

type IfStmt struct {
	If   token.Pos  // position of "if"
	Cond Expr       // condition expression
	Semi token.Pos  // position of ";"
	Then token.Pos  // position of "then"
	Body *BlockStmt // if body
	Else Stmt       // else clause (can be IfStmt for elif)
	Fi   token.Pos  // position of "fi"
}

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

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

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 NonNullCheckExp struct {
	Colon token.Pos // position of ":"
	Quest token.Pos // position of "?"
	Val   Expr      // error message
}

type NonNullExp struct {
	Colon token.Pos // position of ":"
	Add   token.Pos // position of "+"
	Val   Expr      // value to substitute
}

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

type ParamExp interface {
	// contains filtered or unexported methods
}

type ParamExpExpr struct {
	Dollar   token.Pos // position of "$"
	Lbrace   token.Pos // position of "{"
	Var      Expr      // variable name
	ParamExp ParamExp  // parameter expansion operation
	Rbrace   token.Pos // position of "}"
}

type PipelineExpr struct {
	CtrOp token.Token // Token.Or or Token.OrAnd
	Cmds  []Expr      // list of commands
}

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 {
	CtrOp   token.Token // Token.CmdIn or Token.CmdOut
	Opening token.Pos   // position of opening delimiter
	X       Expr        // command expression
	Closing token.Pos   // position of closing delimiter
}

type Redirect struct {
	N     Expr        // file descriptor number (optional)
	CtrOp token.Token // redirection operator
	OpPos token.Pos   // position of operator
	Word  Expr        // target file or descriptor
}

type ReplaceExp struct {
	All  bool      // true for // (global replacement)
	Div1 token.Pos // position of "/" or "//"
	Old  string    // pattern to replace
	Div2 token.Pos // position of "/"
	New  string    // replacement string
}

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

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

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

type SelectStmt struct {
	Select token.Pos  // position of "select"
	Var    Expr       // variable name
	In     token.Pos  // position of "in"
	List   Expr       // list expression
	Semi   token.Pos  // position of ";"
	Do     token.Pos  // position of "do"
	Body   *BlockStmt // loop body
	Done   token.Pos  // position of "done"
}

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

type SubstringExp struct {
	Colon1 token.Pos // position of ":"
	Offset int       // offset value
	Colon2 token.Pos // position of ":" (for length)
	Length int       // length value
}

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

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

type UntilStmt struct {
	Until token.Pos  // position of "until"
	Cond  Expr       // condition expression
	Semi  token.Pos  // position of ";"
	Do    token.Pos  // position of "do"
	Body  *BlockStmt // loop body
	Done  token.Pos  // position of "done"
}

type VarExpExpr struct {
	Dollar token.Pos // position of "$"
	X      Expr      // variable name
}

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

type WhileStmt struct {
	While token.Pos  // position of "while"
	Cond  Expr       // condition expression
	Semi  token.Pos  // position of ";"
	Do    token.Pos  // position of "do"
	Body  *BlockStmt // loop body
	Done  token.Pos  // position of "done"
}

type Word struct {
	Val    string    // word value
	ValPos token.Pos // word position
}