kubernetes/vendor/github.com/google/cel-go/parser/helper.go

type parserHelper …

func newParserHelper(source common.Source, fac ast.ExprFactory) *parserHelper { … }

func (p *parserHelper) getSourceInfo() *ast.SourceInfo { … }

func (p *parserHelper) newLiteral(ctx any, value ref.Val) ast.Expr { … }

func (p *parserHelper) newLiteralBool(ctx any, value bool) ast.Expr { … }

func (p *parserHelper) newLiteralString(ctx any, value string) ast.Expr { … }

func (p *parserHelper) newLiteralBytes(ctx any, value []byte) ast.Expr { … }

func (p *parserHelper) newLiteralInt(ctx any, value int64) ast.Expr { … }

func (p *parserHelper) newLiteralUint(ctx any, value uint64) ast.Expr { … }

func (p *parserHelper) newLiteralDouble(ctx any, value float64) ast.Expr { … }

func (p *parserHelper) newIdent(ctx any, name string) ast.Expr { … }

func (p *parserHelper) newSelect(ctx any, operand ast.Expr, field string) ast.Expr { … }

func (p *parserHelper) newPresenceTest(ctx any, operand ast.Expr, field string) ast.Expr { … }

func (p *parserHelper) newGlobalCall(ctx any, function string, args ...ast.Expr) ast.Expr { … }

func (p *parserHelper) newReceiverCall(ctx any, function string, target ast.Expr, args ...ast.Expr) ast.Expr { … }

func (p *parserHelper) newList(ctx any, elements []ast.Expr, optionals ...int32) ast.Expr { … }

func (p *parserHelper) newMap(ctx any, entries ...ast.EntryExpr) ast.Expr { … }

func (p *parserHelper) newMapEntry(entryID int64, key ast.Expr, value ast.Expr, optional bool) ast.EntryExpr { … }

func (p *parserHelper) newObject(ctx any, typeName string, fields ...ast.EntryExpr) ast.Expr { … }

func (p *parserHelper) newObjectField(fieldID int64, field string, value ast.Expr, optional bool) ast.EntryExpr { … }

func (p *parserHelper) newComprehension(ctx any,
	iterRange ast.Expr,
	iterVar string,
	accuVar string,
	accuInit ast.Expr,
	condition ast.Expr,
	step ast.Expr,
	result ast.Expr) ast.Expr { … }

func (p *parserHelper) newID(ctx any) int64 { … }

func (p *parserHelper) newExpr(ctx any) ast.Expr { … }

func (p *parserHelper) id(ctx any) int64 { … }

func (p *parserHelper) deleteID(id int64) { … }

func (p *parserHelper) getLocation(id int64) common.Location { … }

func (p *parserHelper) getLocationByOffset(offset int32) common.Location { … }

// buildMacroCallArg iterates the expression and returns a new expression
// where all macros have been replaced by their IDs in MacroCalls
func (p *parserHelper) buildMacroCallArg(expr ast.Expr) ast.Expr { … }

// addMacroCall adds the macro the the MacroCalls map in source info. If a macro has args/subargs/target
// that are macros, their ID will be stored instead for later self-lookups.
func (p *parserHelper) addMacroCall(exprID int64, function string, target ast.Expr, args ...ast.Expr) { … }

type logicManager …

// newVariadicLogicManager creates a logic manager instance bound to a specific function and its first term.
func newVariadicLogicManager(fac ast.ExprFactory, function string, term ast.Expr) *logicManager { … }

// newBalancingLogicManager creates a logic manager instance bound to a specific function and its first term.
func newBalancingLogicManager(fac ast.ExprFactory, function string, term ast.Expr) *logicManager { … }

// addTerm adds an operation identifier and term to the set of terms to be balanced.
func (l *logicManager) addTerm(op int64, term ast.Expr) { … }

// toExpr renders the logic graph into an Expr value, either balancing a tree of logical
// operations or creating a variadic representation of the logical operator.
func (l *logicManager) toExpr() ast.Expr { … }

// balancedTree recursively balances the terms provided to a commutative operator.
func (l *logicManager) balancedTree(lo, hi int) ast.Expr { … }

type exprHelper …

func (e *exprHelper) nextMacroID() int64 { … }

// Copy implements the ExprHelper interface method by producing a copy of the input Expr value
// with a fresh set of numeric identifiers the Expr and all its descendants.
func (e *exprHelper) Copy(expr ast.Expr) ast.Expr { … }

// NewLiteral implements the ExprHelper interface method.
func (e *exprHelper) NewLiteral(value ref.Val) ast.Expr { … }

// NewList implements the ExprHelper interface method.
func (e *exprHelper) NewList(elems ...ast.Expr) ast.Expr { … }

// NewMap implements the ExprHelper interface method.
func (e *exprHelper) NewMap(entries ...ast.EntryExpr) ast.Expr { … }

// NewMapEntry implements the ExprHelper interface method.
func (e *exprHelper) NewMapEntry(key ast.Expr, val ast.Expr, optional bool) ast.EntryExpr { … }

// NewStruct implements the ExprHelper interface method.
func (e *exprHelper) NewStruct(typeName string, fieldInits ...ast.EntryExpr) ast.Expr { … }

// NewStructField implements the ExprHelper interface method.
func (e *exprHelper) NewStructField(field string, init ast.Expr, optional bool) ast.EntryExpr { … }

// NewComprehension implements the ExprHelper interface method.
func (e *exprHelper) NewComprehension(
	iterRange ast.Expr,
	iterVar string,
	accuVar string,
	accuInit ast.Expr,
	condition ast.Expr,
	step ast.Expr,
	result ast.Expr) ast.Expr { … }

// NewIdent implements the ExprHelper interface method.
func (e *exprHelper) NewIdent(name string) ast.Expr { … }

// NewAccuIdent implements the ExprHelper interface method.
func (e *exprHelper) NewAccuIdent() ast.Expr { … }

// NewGlobalCall implements the ExprHelper interface method.
func (e *exprHelper) NewCall(function string, args ...ast.Expr) ast.Expr { … }

// NewMemberCall implements the ExprHelper interface method.
func (e *exprHelper) NewMemberCall(function string, target ast.Expr, args ...ast.Expr) ast.Expr { … }

// NewPresenceTest implements the ExprHelper interface method.
func (e *exprHelper) NewPresenceTest(operand ast.Expr, field string) ast.Expr { … }

// NewSelect implements the ExprHelper interface method.
func (e *exprHelper) NewSelect(operand ast.Expr, field string) ast.Expr { … }

// OffsetLocation implements the ExprHelper interface method.
func (e *exprHelper) OffsetLocation(exprID int64) common.Location { … }

// NewError associates an error message with a given expression id, populating the source offset location of the error if possible.
func (e *exprHelper) NewError(exprID int64, message string) *common.Error { … }

var exprHelperPool …