aboutsummaryrefslogtreecommitdiff
path: root/src/text/template/exec.go
AgeCommit message (Collapse)Author
2018-06-22text/template/parse: undo breaking API changesDaniel Theophanes
golang.org/cl/84480 altered the API for the parse package for clarity and consistency. However, the changes also broke the API for consumers of the package. This CL reverts the API to the previous spelling, adding only a single new exported symbol. Fixes #25968 Change-Id: Ieb81054b61eeac7df3bc3864ef446df43c26b80f Reviewed-on: https://go-review.googlesource.com/120355 Reviewed-by: Daniel Martí <mvdan@mvdan.cc> Reviewed-by: Rob Pike <r@golang.org> Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org>
2018-04-30all: skip unsupported tests for js/wasmRichard Musiol
The general policy for the current state of js/wasm is that it only has to support tests that are also supported by nacl. The test nilptr3.go makes assumptions about which nil checks can be removed. Since WebAssembly does not signal on reading a null pointer, all nil checks have to be explicit. Updates #18892 Change-Id: I06a687860b8d22ae26b1c391499c0f5183e4c485 Reviewed-on: https://go-review.googlesource.com/110096 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2018-04-04text/template: add variable assignmentsDaniel Martí
Variables can be declared and shadowing is supported, but modifying existing variables via assignments was not available. This meant that modifying a variable from a nested block was not possible: {{ $v := "init" }} {{ if true }} {{ $v := "changed" }} {{ end }} v: {{ $v }} {{/* "init" */}} Introduce the "=" assignment token, such that one can now do: {{ $v := "init" }} {{ if true }} {{ $v = "changed" }} {{ end }} v: {{ $v }} {{/* "changed" */}} To avoid confusion, rename PipeNode.Decl to PipeNode.Vars, as the variables may not always be declared after this change. Also change a few other names to better reflect the added ambiguity of variables in pipelines. Modifying the text/template/parse package in a backwards incompatible manner is acceptable, given that the package godoc clearly states that it isn't intended for general use. It's the equivalent of an internal package, back when internal packages didn't exist yet. To make the changes to the parse package sit well with the cmd/api test, update except.txt with the changes that we aren't worried about. Fixes #10608. Change-Id: I1f83a4297ee093fd45f9993cebb78fc9a9e81295 Reviewed-on: https://go-review.googlesource.com/84480 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rob Pike <r@golang.org>
2018-02-19text/template: differentiate nil from missing argDaniel Martí
reflect.Value is a struct and does not have a kind nor any flag for untyped nils. As a result, it is tricky to differentiate when we're missing a value, from when we have one but it is untyped nil. We could start using *reflect.Value instead, to add one level of indirection, using nil for missing values and new(reflect.Value) for untyped nils. However, that is a fairly invasive change, and would also mean unnecessary allocations. Instead, use a special reflect.Value that depicts when a value is missing. This is the case for the "final" reflect.Value in multiple scenarios, such as the start of a pipeline. Give it a specific, unexported type too, to make sure it cannot be mistaken for any other valid value. Finally, replace "final.IsValid()" with "final != missingVal", since final.IsValid() will be false when final is an untyped nil. Also add a few test cases, all different variants of the untyped nil versus missing value scenario. Fixes #18716. Change-Id: Ia9257a84660ead5a7007fd1cced7782760b62d9d Reviewed-on: https://go-review.googlesource.com/95215 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rob Pike <r@golang.org>
2018-02-13text/template: never call reflect.Zero(nil)Daniel Martí
It makes no sense to try to get the zero value of a nil type, hence the panic. When we have a nil type, use reflect.ValueOf(nil) instead. This was showing itself if one used a missing field on the data between parentheses, when the data was a nil interface: t := template.Must(template.New("test").Parse(`{{ (.).foo }}`)) var v interface{} t.Execute(os.Stdout, v) Resulting in: panic: reflect: Zero(nil) [recovered] panic: reflect: Zero(nil) Fixes #21171. Change-Id: Ifcc4a0c67e6df425b65bc9f82fde6fcf03828579 Reviewed-on: https://go-review.googlesource.com/84482 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rob Pike <r@golang.org>
2018-02-06text/template: revert CL 66410 "add break, continue actions in ranges"Ian Lance Taylor
The new break and continue actions do not work in html/template, and fixing them requires thinking about security issues that seem too tricky at this stage of the release. We will try again for 1.11. Original CL description: text/template: add break, continue actions in ranges Adds the two range control actions "break" and "continue". They act the same as the Go keywords break and continue, but are simplified in that only the innermost range statement can be broken out of or continued. Fixes #20531 Updates #20531 Updates #23683 Change-Id: Ia7fd3c409163e3bcb5dc42947ae90b15bdf89853 Reviewed-on: https://go-review.googlesource.com/92155 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Russ Cox <rsc@golang.org>
2017-10-17text/template: add break, continue actions in rangesTim Cooper
Adds the two range control actions "break" and "continue". They act the same as the Go keywords break and continue, but are simplified in that only the innermost range statement can be broken out of or continued. Fixes #20531 Change-Id: I4412b3bbfd4dadb0ab74ae718e308c1ac7a0a1e9 Reviewed-on: https://go-review.googlesource.com/66410 Reviewed-by: Rob Pike <r@golang.org>
2017-09-22all: use sort.Slice in a few more placesDaniel Martí
Do the low-hanging fruit - tiny Less functions that are used exactly once. This reduces the amount of code and puts the logic in a single place. Change-Id: I9d4544cd68de5a95e55019bdad1fca0a1dbfae9c Reviewed-on: https://go-review.googlesource.com/63171 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-09-12all: remove strings.Contains check around ReplaceDaniel Martí
It doesn't change the outcome. It might have been useful at some point to avoid Replace from doing work or allocating. However, nowadays the func returns early without doing any work if Count returns 0. Change-Id: Id69dc74042a6e39672b405016484db8b50f43d58 Reviewed-on: https://go-review.googlesource.com/62991 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Dave Cheney <dave@cheney.net>
2017-05-05template: warn about interleaved nature of writesDieter Plaetinck
Execute incurs separate writes for each "step", e.g. each variable that needs to be printed, and the final newline. While it is correct to state that templates can be executed concurrently, there is a more subtle nuance that is easily missed: when writing to the same writer, the writes from concurrent execute calls can be interleaved, leading to unexpected output. Change-Id: I0abbd7960d8a8d15e109a8a3eeff3b43b852bbbf Reviewed-on: https://go-review.googlesource.com/37444 Reviewed-by: Rob Pike <r@golang.org>
2017-02-09text/template: fix method lookup on addressable nil pointerRuss Cox
Fixes #18816. Change-Id: I4f8f1cac2680dbde492c56d3a5a038577605e7c1 Reviewed-on: https://go-review.googlesource.com/36542 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Rob Pike <r@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2017-02-07text/template: remove duplicate logic in conditionalSeth Vargo
It looks like this conditional may have been refactored at some point, but the logic was still very confusing. The outer conditional checks if the function is variadic, so there's no need to verify that in the result. Additionally, since the function isn't variadic, there is no reason to permit the function call if the number of input arguments is less than the function signature requires. Change-Id: Ia957cf83d1c900c08dd66384efcb74f0c368422e Reviewed-on: https://go-review.googlesource.com/35491 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2016-11-18text/template: handle option missingkey=error consistentlyÖzgür Kesim
The existing implementation of text/template handles the option "missingkey=error" in an inconsitent manner: If the provided data is a nil-interface, no error is returned (despite the fact that no key can be found in it). This patch makes text/template return an error if "missingkey=error" is set and the provided data is a not a valid reflect.Value. Fixes #15356 Change-Id: Ia0a83da48652ecfaf31f18bdbd78cb21dbca1164 Reviewed-on: https://go-review.googlesource.com/31638 Reviewed-by: Rob Pike <r@golang.org> Run-TryBot: Rob Pike <r@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-11-11text/template: reintroduce implicit indirect of interface values in builtin ↵Russ Cox
funcs CL 31462 made it possible to operate directly on reflect.Values instead of always forcing a round trip to interface{} and back. The round trip was losing addressability, which hurt users. The round trip was also losing "interface-ness", which helped users. That is, using reflect.ValueOf(v.Interface()) instead of v was doing an implicit indirect any time v was itself an interface{} value: the result was the reflect.Value for the underlying concrete value contained in the interface, not the interface itself. CL 31462 eliminated some "unnecessary" reflect.Value round trips in order to preserve addressability, but in doing so it lost this implicit indirection. This CL adds the indirection back. It may help to compare the changes in this CL against funcs.go from CL 31462: https://go-review.googlesource.com/#/c/31462/4/src/text/template/funcs.go Everywhere CL 31462 changed 'v := reflect.ValueOf(x)' to 'v := x', this CL changes 'v := x' to 'v := indirectInterface(x)'. Fixes #17714. Change-Id: I67cec4eb41fed1d56e1c19f12b0abbd0e59d35a2 Reviewed-on: https://go-review.googlesource.com/33139 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Rob Pike <r@golang.org>
2016-10-28html/template, text/template: drop defined template list from errorsRuss Cox
The report in #17414 points out that if you have many many templates, then this is an overwhelming list and just hurts the signal-to-noise ratio of the error. Even the test of the old behavior also supports the idea that this is noise: template: empty: "empty" is an incomplete or empty template; defined templates are: "secondary" The chance that someone mistyped "secondary" as "empty" is slim at best. Similarly, the compiler does not augment an error like 'unknown variable x' by dumping the full list of all the known variables. For all these reasons, drop the list. Fixes #17414. Change-Id: I78f92d2c591df7218385fe723a4abc497913acf8 Reviewed-on: https://go-review.googlesource.com/32116 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rob Pike <r@golang.org>
2016-10-19text/template: add support for reflect.Value args, results in funcsRuss Cox
Add support for passing reflect.Values to and returning reflect.Values from any registered functions in the FuncMap, much as if they were interface{} values. Keeping the reflect.Value instead of round-tripping to interface{} preserves addressability of the value, which is important for method lookup. Change index and a few other built-in functions to use reflect.Values, making a loop using explicit indexing now match the semantics that range has always had. Fixes #14916. Change-Id: Iae1a2fd9bb426886a7fcd9204f30a2d6ad4646ad Reviewed-on: https://go-review.googlesource.com/31462 Reviewed-by: Rob Pike <r@golang.org>
2016-05-12text/template: detect pathologically recursive template invocationsAndrew Gerrand
Return an error message instead of eating memory and eventually triggering a stack overflow. Fixes #15618 Change-Id: I3dcf1d669104690a17847a20fbfeb6d7e39e8751 Reviewed-on: https://go-review.googlesource.com/23091 Reviewed-by: Rob Pike <r@golang.org>
2016-04-10text/template: emit field error over nil pointer error where appropriateAndrew Gerrand
When evaluating "{{.MissingField}}" on a nil *T, Exec returns "can't evaluate field MissingField in type *T" instead of "nil pointer evaluating *T.MissingField". Fixes golang/go#15125 Change-Id: I6e73f61b8a72c694179c1f8cdc808766c90b6f57 Reviewed-on: https://go-review.googlesource.com/21705 Reviewed-by: Rob Pike <r@golang.org>
2016-03-02all: single space after period.Brad Fitzpatrick
The tree's pretty inconsistent about single space vs double space after a period in documentation. Make it consistently a single space, per earlier decisions. This means contributors won't be confused by misleading precedence. This CL doesn't use go/doc to parse. It only addresses // comments. It was generated with: $ perl -i -npe 's,^(\s*// .+[a-z]\.) +([A-Z]),$1 $2,' $(git grep -l -E '^\s*//(.+\.) +([A-Z])') $ go test go/doc -update Change-Id: Iccdb99c37c797ef1f804a94b22ba5ee4b500c4f7 Reviewed-on: https://go-review.googlesource.com/20022 Reviewed-by: Rob Pike <r@golang.org> Reviewed-by: Dave Day <djd@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-29all: remove public named return values when uselessBrad Fitzpatrick
Named returned values should only be used on public funcs and methods when it contributes to the documentation. Named return values should not be used if they're only saving the programmer a few lines of code inside the body of the function, especially if that means there's stutter in the documentation or it was only there so the programmer could use a naked return statement. (Naked returns should not be used except in very small functions) This change is a manual audit & cleanup of public func signatures. Signatures were not changed if: * the func was private (wouldn't be in public godoc) * the documentation referenced it * the named return value was an interesting name. (i.e. it wasn't simply stutter, repeating the name of the type) There should be no changes in behavior. (At least: none intended) Change-Id: I3472ef49619678fe786e5e0994bdf2d9de76d109 Reviewed-on: https://go-review.googlesource.com/20024 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Andrew Gerrand <adg@golang.org>
2016-02-19all: replace strings.Index with strings.Contains where possibleNathan VanBenschoten
Change-Id: Ia613f1c37bfce800ece0533a5326fca91d99a66a Reviewed-on: https://go-review.googlesource.com/18120 Reviewed-by: Robert Griesemer <gri@golang.org> Run-TryBot: Robert Griesemer <gri@golang.org>
2015-11-24text/template,html/template: correct comment in DefinedTemplatesRob Pike
The prefix includes a semicolon. Change-Id: I4bdb79aa9931e835e297f3ea2c46a001cd123d56 Reviewed-on: https://go-review.googlesource.com/17200 Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-10-28text/template: remove redundant indirectNodir Turakulov
Change-Id: I8cc9783fd044bed48347824dcf973c61c78275a5 Reviewed-on: https://go-review.googlesource.com/15833 Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-10-15text/template: resolve non-empty interfaceNodir Turakulov
Read what a non-empty interface points to. The deleted lines were added in https://codereview.appspot.com/4810060/, which attempted to break an infinite loop. That was a long time ago. If I just delete these lines with current codebase, the test "bug1" (added in that CL) does not fail. All new tests fail without this fix. Fixes #12924 Change-Id: I9370ca44facd6af3019850aa065b936e5a482d37 Reviewed-on: https://go-review.googlesource.com/15809 Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-10-01text/template: change IsTrue to take interface{} instead of reflect.Value.David Symonds
This is a follow-up to a326c3e to avoid reflect being in the API. Fixes #12801. Change-Id: Ic4c2e592e2c35b5911f75d88f1d9c44787c80f30 Reviewed-on: https://go-review.googlesource.com/15240 Run-TryBot: David Symonds <dsymonds@golang.org> Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-09-17text/template: export isTrueRob Pike
The definition of 'truth' used by if etc. is not trivial to compute, so publish the implementation to allow custom template functions to have the same definition as the template language itself. Fixes #12033. Change-Id: Icdfd6039722d7d3f984ba0905105eb3253e14831 Reviewed-on: https://go-review.googlesource.com/14593 Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-09-09text/template: perform value validity checksNodir Turakulov
Check reflect.Value.IsValid() before calling other reflect.Value methods that panic on zero values. Added tests for cases with untyped nils. They panicked without these fixes. Removed a TODO. Fixes #12356 Change-Id: I9b5cbed26db09a0a7c36d99a93f8b9729899d51e Reviewed-on: https://go-review.googlesource.com/14340 Reviewed-by: Rob Pike <r@golang.org>
2015-08-27text/template: add ExecError type and return it from Execute on errorRob Pike
Useful to discriminate evaluation errors from write errors. Fixes #11898. Change-Id: I907d339a3820e887872d78e0e2d8fd011451fd19 Reviewed-on: https://go-review.googlesource.com/13957 Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-06-24text/template: make zero Template work againRuss Cox
Fixes #11379. Change-Id: Idbb5c3faad472b77e9867dd2d4551fef5e4ac5f1 Reviewed-on: https://go-review.googlesource.com/11421 Reviewed-by: Rob Pike <r@golang.org>
2015-06-01text/template: fix variadic function call corner caseDidier Spezia
Executing a template involving variadic functions featuring a []interface{} slice (such as printf) could result in a panic in reflect.Value.Call, due to incorrect type checking. The following expressions failed (with a panic): {{true|printf}} {{1|printf}} {{1.1|printf}} {{'x'|printf}} {{1+2i|printf}} Implemented proper type checks for the fixed parameters of the variadic functions. Fixes #10946 Change-Id: Ia75333f651f73b3d2e024cb0c47cc30d90cb6852 Reviewed-on: https://go-review.googlesource.com/10403 Reviewed-by: Rob Pike <r@golang.org>
2015-06-01text/template: template must be initialized at the time of creationAamir Khan
t.init() should be called at the time of template creation i.e, template.New() and t.New() instead of later in the process. - Removed calls of t.init() from t.Parse(), t.Execute(), t.Funcs() - Also got rid of t.common != nil checks as it should never be nil Fixes #10879 Change-Id: I1b7ac812f02c841ae80037babce7e2b0a2df13e8 Reviewed-on: https://go-review.googlesource.com/10240 Reviewed-by: Rob Pike <r@golang.org>
2015-05-14text/template: need to validate type when an argument is a function callRob Pike
Missed a case; just need to call validateType. Fixes #10800. Change-Id: I81997ca7a9feb1be31c8b47e631b32712d7ffb86 Reviewed-on: https://go-review.googlesource.com/10031 Reviewed-by: Andrew Gerrand <adg@golang.org>
2015-04-03text/template: provide a mechanism for optionsRob Pike
Add one option, which is the motivating example, a way to control what happens when a map is indexed with a key that is not in the map. Rather than do something specific for that case, we provide a simple general option mechanism to avoid adding API if something else comes up. This general approach also makes it easy for html/template to track (and adapt, should that become important). New method: Option(option string...). The option strings are key=value pairs or just simple strings (no =). New option: missingkey: Control the behavior during execution if a map is indexed with a key that is not present in the map. "missingkey=default" or "missingkey=invalid" The default behavior: Do nothing and continue execution. If printed, the result of the index operation is the string "<no value>". "missingkey=zero" The operation returns the zero value for the map type's element. "missingkey=error" Execution stops immediately with an error. Fixes #6288. Change-Id: Id811e2b99dc05aff324d517faac113ef3c25293a Reviewed-on: https://go-review.googlesource.com/8462 Reviewed-by: Robert Griesemer <gri@golang.org>
2015-03-20html/template: fix crash when escaping incomplete templateRob Pike
text/template turned this into an error but html/template crashed. Refactor text/template.Execute to export a new function, text/template.DefinedTemplates, so html/template can get the same helpful error message in this case, and invoke it when there is no definition for a template being escaped. Fixes #10204. Change-Id: I1d04e9e7ebca829bc08509caeb65e75da969711f Reviewed-on: https://go-review.googlesource.com/7855 Reviewed-by: Russ Cox <rsc@golang.org>
2015-03-16text/template: protect against explicit nil in field chainsRob Pike
An explicit nil in an expression like nil.Foo caused a panic because the evaluator attempted to reflect on the nil. A typeless nil like this cannot be used to do anything, so just error out. Fixes #9426 Change-Id: Icd2c9c7533dda742748bf161eced163991a12f54 Reviewed-on: https://go-review.googlesource.com/7643 Reviewed-by: David Symonds <dsymonds@golang.org>
2014-10-18text/template: fix bug in pipelined variadicsRob Pike
Simple bug in argument processing: The final arg may be the pipeline value, in which case it gets bound to the fixed argument section. The code got that wrong. Easy to fix. Fixes #8950. LGTM=bradfitz R=golang-codereviews, bradfitz CC=golang-codereviews https://golang.org/cl/161750043
2014-09-22text/template: type-check chained node as argumentRob Pike
Was just a missing case (literally) in the type checker. Fixes #8473. LGTM=adg R=golang-codereviews, adg CC=golang-codereviews https://golang.org/cl/142460043
2014-09-08build: move package sources from src/pkg to srcRuss Cox
Preparation was in CL 134570043. This CL contains only the effect of 'hg mv src/pkg/* src'. For more about the move, see golang.org/s/go14nopkg.
generated by cgit v1.3-5-g9baa (git 2.53.0) at 2026-04-17 15:06:08 +0000