var maxExecDepth … func initMaxExecDepth() int { … } type state … type variable … // push pushes a new variable on the stack. func (s *state) push(name string, value reflect.Value) { … } // mark returns the length of the variable stack. func (s *state) mark() int { … } // pop pops the variable stack up to the mark. func (s *state) pop(mark int) { … } // setVar overwrites the last declared variable with the given name. // Used by variable assignments. func (s *state) setVar(name string, value reflect.Value) { … } // setTopVar overwrites the top-nth variable on the stack. Used by range iterations. func (s *state) setTopVar(n int, value reflect.Value) { … } // varValue returns the value of the named variable. func (s *state) varValue(name string) reflect.Value { … } var zero … type missingValType … var missingVal … var missingValReflectType … func isMissing(v reflect.Value) bool { … } // at marks the state to be on node n, for error reporting. func (s *state) at(node parse.Node) { … } // doublePercent returns the string with %'s replaced by %%, if necessary, // so it can be used safely inside a Printf format string. func doublePercent(str string) string { … } type ExecError … func (e ExecError) Error() string { … } func (e ExecError) Unwrap() error { … } // errorf records an ExecError and terminates processing. func (s *state) errorf(format string, args ...any) { … } type writeError … func (s *state) writeError(err error) { … } // errRecover is the handler that turns panics into returns from the top // level of Parse. func errRecover(errp *error) { … } // ExecuteTemplate applies the template associated with t that has the given name // to the specified data object and writes the output to wr. // If an error occurs executing the template or writing its output, // execution stops, but partial results may already have been written to // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error { … } // Execute applies a parsed template to the specified data object, // and writes the output to wr. // If an error occurs executing the template or writing its output, // execution stops, but partial results may already have been written to // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. // // If data is a [reflect.Value], the template applies to the concrete // value that the reflect.Value holds, as in [fmt.Print]. func (t *Template) Execute(wr io.Writer, data any) error { … } func (t *Template) execute(wr io.Writer, data any) (err error) { … } // DefinedTemplates returns a string listing the defined templates, // prefixed by the string "; defined templates are: ". If there are none, // it returns the empty string. For generating an error message here // and in [html/template]. func (t *Template) DefinedTemplates() string { … } var walkBreak … var walkContinue … // Walk functions step through the major pieces of the template structure, // generating output as they go. func (s *state) walk(dot reflect.Value, node parse.Node) { … } // walkIfOrWith walks an 'if' or 'with' node. The two control structures // are identical in behavior except that 'with' sets dot. func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) { … } // IsTrue reports whether the value is 'true', in the sense of not the zero of its type, // and whether the value has a meaningful truth value. This is the definition of // truth used by if and other such actions. func IsTrue(val any) (truth, ok bool) { … } func isTrue(val reflect.Value) (truth, ok bool) { … } func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) { … } func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) { … } // evalPipeline returns the value acquired by evaluating a pipeline. If the // pipeline has a variable declaration, the variable will be pushed on the // stack. Callers should therefore pop the stack after they are finished // executing commands depending on the pipeline value. func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) { … } func (s *state) notAFunction(args []parse.Node, final reflect.Value) { … } func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value { … } // idealConstant is called to return the value of a number in a context where // we don't know the type. In that case, the syntax of the number tells us // its type, and we use Go rules to resolve. Note there is no such thing as // a uint ideal constant in this situation - the value must be of int type. func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value { … } func isRuneInt(s string) bool { … } func isHexInt(s string) bool { … } func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value { … } func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value { … } func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value { … } // evalFieldChain evaluates .X.Y.Z possibly followed by arguments. // dot is the environment in which to evaluate arguments, while // receiver is the value being walked along the chain. func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value { … } func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value { … } // evalField evaluates an expression like (.Field) or (.Field arg1 arg2). // The 'final' argument represents the return value from the preceding // value of the pipeline, if any. func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value { … } var errorType … var fmtStringerType … var reflectValueType … // evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so // it looks just like a function call. The arg list, if non-nil, includes (in the manner of the shell), arg[0] // as the function itself. func (s *state) evalCall(dot, fun reflect.Value, isBuiltin bool, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value { … } // canBeNil reports whether an untyped nil can be assigned to the type. See reflect.Zero. func canBeNil(typ reflect.Type) bool { … } // validateType guarantees that the value is valid and assignable to the type. func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value { … } func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value { … } func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value { … } // indirect returns the item at the end of indirection, and a bool to indicate // if it's nil. If the returned bool is true, the returned value's kind will be // either a pointer or interface. func indirect(v reflect.Value) (rv reflect.Value, isNil bool) { … } // indirectInterface returns the concrete value in an interface value, // or else the zero reflect.Value. // That is, if v represents the interface value x, the result is the same as reflect.ValueOf(x): // the fact that x was an interface value is forgotten. func indirectInterface(v reflect.Value) reflect.Value { … } // printValue writes the textual representation of the value to the output of // the template. func (s *state) printValue(n parse.Node, v reflect.Value) { … } // printableValue returns the, possibly indirected, interface value inside v that // is best for a call to formatted printer. func printableValue(v reflect.Value) (any, bool) { … }
Codebase Browser
go