From d5363590597572228d4e0d0ae13f3469176ceb14 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 14 Dec 2011 15:41:54 +0000 Subject: libgo: Update to weekly.2011-12-06. From-SVN: r182338 --- libgo/go/text/template/multi_test.go | 29 --------------------------- libgo/go/text/template/parse/node.go | 8 ++++---- libgo/go/text/template/parse/parse.go | 32 ++++++++++++++++++++++++++++-- libgo/go/text/template/parse/parse_test.go | 29 +++++++++++++++++++++++++++ libgo/go/text/template/template.go | 28 ++------------------------ 5 files changed, 65 insertions(+), 61 deletions(-) (limited to 'libgo/go/text') diff --git a/libgo/go/text/template/multi_test.go b/libgo/go/text/template/multi_test.go index 7b35d263..3abb51f 100644 --- a/libgo/go/text/template/multi_test.go +++ b/libgo/go/text/template/multi_test.go @@ -13,35 +13,6 @@ import ( "text/template/parse" ) -type isEmptyTest struct { - name string - input string - empty bool -} - -var isEmptyTests = []isEmptyTest{ - {"empty", ``, true}, - {"nonempty", `hello`, false}, - {"spaces only", " \t\n \t\n", true}, - {"definition", `{{define "x"}}something{{end}}`, true}, - {"definitions and space", "{{define `x`}}something{{end}}\n\n{{define `y`}}something{{end}}\n\n", true}, - {"definitions and text", "{{define `x`}}something{{end}}\nx\n{{define `y`}}something{{end}}\ny\n}}", false}, - {"definition and action", "{{define `x`}}something{{end}}{{if 3}}foo{{end}}", false}, -} - -func TestIsEmpty(t *testing.T) { - for _, test := range isEmptyTests { - template, err := New("root").Parse(test.input) - if err != nil { - t.Errorf("%q: unexpected error: %v", test.name, err) - continue - } - if empty := isEmpty(template.Root); empty != test.empty { - t.Errorf("%q: expected %t got %t", test.name, test.empty, empty) - } - } -} - const ( noError = true hasError = false diff --git a/libgo/go/text/template/parse/node.go b/libgo/go/text/template/parse/node.go index a4e5514..4f43424 100644 --- a/libgo/go/text/template/parse/node.go +++ b/libgo/go/text/template/parse/node.go @@ -267,7 +267,7 @@ func newNumber(text string, typ itemType) (*NumberNode, error) { } // Imaginary constants can only be complex unless they are zero. if len(text) > 0 && text[len(text)-1] == 'i' { - f, err := strconv.Atof64(text[:len(text)-1]) + f, err := strconv.ParseFloat(text[:len(text)-1], 64) if err == nil { n.IsComplex = true n.Complex128 = complex(0, f) @@ -276,12 +276,12 @@ func newNumber(text string, typ itemType) (*NumberNode, error) { } } // Do integer test first so we get 0x123 etc. - u, err := strconv.Btoui64(text, 0) // will fail for -0; fixed below. + u, err := strconv.ParseUint(text, 0, 64) // will fail for -0; fixed below. if err == nil { n.IsUint = true n.Uint64 = u } - i, err := strconv.Btoi64(text, 0) + i, err := strconv.ParseInt(text, 0, 64) if err == nil { n.IsInt = true n.Int64 = i @@ -298,7 +298,7 @@ func newNumber(text string, typ itemType) (*NumberNode, error) { n.IsFloat = true n.Float64 = float64(n.Uint64) } else { - f, err := strconv.Atof64(text) + f, err := strconv.ParseFloat(text, 64) if err == nil { n.IsFloat = true n.Float64 = f diff --git a/libgo/go/text/template/parse/parse.go b/libgo/go/text/template/parse/parse.go index 346f613..4da7566 100644 --- a/libgo/go/text/template/parse/parse.go +++ b/libgo/go/text/template/parse/parse.go @@ -7,6 +7,7 @@ package parse import ( + "bytes" "fmt" "runtime" "strconv" @@ -177,10 +178,37 @@ func (t *Tree) Parse(s, leftDelim, rightDelim string, treeSet map[string]*Tree, // add adds tree to the treeSet. func (t *Tree) add(treeSet map[string]*Tree) { - if _, present := treeSet[t.Name]; present { + tree := treeSet[t.Name] + if tree == nil || IsEmptyTree(tree.Root) { + treeSet[t.Name] = t + return + } + if !IsEmptyTree(t.Root) { t.errorf("template: multiple definition of template %q", t.Name) } - treeSet[t.Name] = t +} + +// IsEmptyTree reports whether this tree (node) is empty of everything but space. +func IsEmptyTree(n Node) bool { + switch n := n.(type) { + case *ActionNode: + case *IfNode: + case *ListNode: + for _, node := range n.Nodes { + if !IsEmptyTree(node) { + return false + } + } + return true + case *RangeNode: + case *TemplateNode: + case *TextNode: + return len(bytes.TrimSpace(n.Text)) == 0 + case *WithNode: + default: + panic("unknown node: " + n.String()) + } + return false } // parse is the top-level parser for a template, essentially the same diff --git a/libgo/go/text/template/parse/parse_test.go b/libgo/go/text/template/parse/parse_test.go index fc93455..b70c214 100644 --- a/libgo/go/text/template/parse/parse_test.go +++ b/libgo/go/text/template/parse/parse_test.go @@ -257,3 +257,32 @@ func TestParse(t *testing.T) { } } } + +type isEmptyTest struct { + name string + input string + empty bool +} + +var isEmptyTests = []isEmptyTest{ + {"empty", ``, true}, + {"nonempty", `hello`, false}, + {"spaces only", " \t\n \t\n", true}, + {"definition", `{{define "x"}}something{{end}}`, true}, + {"definitions and space", "{{define `x`}}something{{end}}\n\n{{define `y`}}something{{end}}\n\n", true}, + {"definitions and text", "{{define `x`}}something{{end}}\nx\n{{define `y`}}something{{end}}\ny\n}}", false}, + {"definition and action", "{{define `x`}}something{{end}}{{if 3}}foo{{end}}", false}, +} + +func TestIsEmpty(t *testing.T) { + for _, test := range isEmptyTests { + tree, err := New("root").Parse(test.input, "", "", make(map[string]*Tree), nil) + if err != nil { + t.Errorf("%q: unexpected error: %v", test.name, err) + continue + } + if empty := IsEmptyTree(tree.Root); empty != test.empty { + t.Errorf("%q: expected %t got %t", test.name, test.empty, empty) + } + } +} diff --git a/libgo/go/text/template/template.go b/libgo/go/text/template/template.go index 04fca40..cbc6808 100644 --- a/libgo/go/text/template/template.go +++ b/libgo/go/text/template/template.go @@ -5,7 +5,6 @@ package template import ( - "bytes" "fmt" "reflect" "text/template/parse" @@ -198,8 +197,8 @@ func (t *Template) associate(new *Template) error { } name := new.name if old := t.tmpl[name]; old != nil { - oldIsEmpty := isEmpty(old.Root) - newIsEmpty := isEmpty(new.Root) + oldIsEmpty := parse.IsEmptyTree(old.Root) + newIsEmpty := parse.IsEmptyTree(new.Root) if !oldIsEmpty && !newIsEmpty { return fmt.Errorf("template: redefinition of template %q", name) } @@ -211,26 +210,3 @@ func (t *Template) associate(new *Template) error { t.tmpl[name] = new return nil } - -// isEmpty reports whether this tree (node) is empty of everything but space. -func isEmpty(n parse.Node) bool { - switch n := n.(type) { - case *parse.ActionNode: - case *parse.IfNode: - case *parse.ListNode: - for _, node := range n.Nodes { - if !isEmpty(node) { - return false - } - } - return true - case *parse.RangeNode: - case *parse.TemplateNode: - case *parse.TextNode: - return len(bytes.TrimSpace(n.Text)) == 0 - case *parse.WithNode: - default: - panic("unknown node: " + n.String()) - } - return false -} -- cgit v1.1