Source file src/text/template/funcs.go

Documentation: text/template

     1  // Copyright 2011 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package template
     6  
     7  import (
     8  	"bytes"
     9  	"errors"
    10  	"fmt"
    11  	"io"
    12  	"net/url"
    13  	"reflect"
    14  	"strings"
    15  	"unicode"
    16  	"unicode/utf8"
    17  )
    18  
    19  // FuncMap is the type of the map defining the mapping from names to functions.
    20  // Each function must have either a single return value, or two return values of
    21  // which the second has type error. In that case, if the second (error)
    22  // return value evaluates to non-nil during execution, execution terminates and
    23  // Execute returns that error.
    24  //
    25  // When template execution invokes a function with an argument list, that list
    26  // must be assignable to the function's parameter types. Functions meant to
    27  // apply to arguments of arbitrary type can use parameters of type interface{} or
    28  // of type reflect.Value. Similarly, functions meant to return a result of arbitrary
    29  // type can return interface{} or reflect.Value.
    30  type FuncMap map[string]interface{}
    31  
    32  var builtins = FuncMap{
    33  	"and":      and,
    34  	"call":     call,
    35  	"html":     HTMLEscaper,
    36  	"index":    index,
    37  	"slice":    slice,
    38  	"js":       JSEscaper,
    39  	"len":      length,
    40  	"not":      not,
    41  	"or":       or,
    42  	"print":    fmt.Sprint,
    43  	"printf":   fmt.Sprintf,
    44  	"println":  fmt.Sprintln,
    45  	"urlquery": URLQueryEscaper,
    46  
    47  	// Comparisons
    48  	"eq": eq, // ==
    49  	"ge": ge, // >=
    50  	"gt": gt, // >
    51  	"le": le, // <=
    52  	"lt": lt, // <
    53  	"ne": ne, // !=
    54  }
    55  
    56  var builtinFuncs = createValueFuncs(builtins)
    57  
    58  // createValueFuncs turns a FuncMap into a map[string]reflect.Value
    59  func createValueFuncs(funcMap FuncMap) map[string]reflect.Value {
    60  	m := make(map[string]reflect.Value)
    61  	addValueFuncs(m, funcMap)
    62  	return m
    63  }
    64  
    65  // addValueFuncs adds to values the functions in funcs, converting them to reflect.Values.
    66  func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
    67  	for name, fn := range in {
    68  		if !goodName(name) {
    69  			panic(fmt.Errorf("function name %q is not a valid identifier", name))
    70  		}
    71  		v := reflect.ValueOf(fn)
    72  		if v.Kind() != reflect.Func {
    73  			panic("value for " + name + " not a function")
    74  		}
    75  		if !goodFunc(v.Type()) {
    76  			panic(fmt.Errorf("can't install method/function %q with %d results", name, v.Type().NumOut()))
    77  		}
    78  		out[name] = v
    79  	}
    80  }
    81  
    82  // addFuncs adds to values the functions in funcs. It does no checking of the input -
    83  // call addValueFuncs first.
    84  func addFuncs(out, in FuncMap) {
    85  	for name, fn := range in {
    86  		out[name] = fn
    87  	}
    88  }
    89  
    90  // goodFunc reports whether the function or method has the right result signature.
    91  func goodFunc(typ reflect.Type) bool {
    92  	// We allow functions with 1 result or 2 results where the second is an error.
    93  	switch {
    94  	case typ.NumOut() == 1:
    95  		return true
    96  	case typ.NumOut() == 2 && typ.Out(1) == errorType:
    97  		return true
    98  	}
    99  	return false
   100  }
   101  
   102  // goodName reports whether the function name is a valid identifier.
   103  func goodName(name string) bool {
   104  	if name == "" {
   105  		return false
   106  	}
   107  	for i, r := range name {
   108  		switch {
   109  		case r == '_':
   110  		case i == 0 && !unicode.IsLetter(r):
   111  			return false
   112  		case !unicode.IsLetter(r) && !unicode.IsDigit(r):
   113  			return false
   114  		}
   115  	}
   116  	return true
   117  }
   118  
   119  // findFunction looks for a function in the template, and global map.
   120  func findFunction(name string, tmpl *Template) (reflect.Value, bool) {
   121  	if tmpl != nil && tmpl.common != nil {
   122  		tmpl.muFuncs.RLock()
   123  		defer tmpl.muFuncs.RUnlock()
   124  		if fn := tmpl.execFuncs[name]; fn.IsValid() {
   125  			return fn, true
   126  		}
   127  	}
   128  	if fn := builtinFuncs[name]; fn.IsValid() {
   129  		return fn, true
   130  	}
   131  	return reflect.Value{}, false
   132  }
   133  
   134  // prepareArg checks if value can be used as an argument of type argType, and
   135  // converts an invalid value to appropriate zero if possible.
   136  func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
   137  	if !value.IsValid() {
   138  		if !canBeNil(argType) {
   139  			return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
   140  		}
   141  		value = reflect.Zero(argType)
   142  	}
   143  	if value.Type().AssignableTo(argType) {
   144  		return value, nil
   145  	}
   146  	if intLike(value.Kind()) && intLike(argType.Kind()) && value.Type().ConvertibleTo(argType) {
   147  		value = value.Convert(argType)
   148  		return value, nil
   149  	}
   150  	return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
   151  }
   152  
   153  func intLike(typ reflect.Kind) bool {
   154  	switch typ {
   155  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   156  		return true
   157  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   158  		return true
   159  	}
   160  	return false
   161  }
   162  
   163  // indexArg checks if a reflect.Value can be used as an index, and converts it to int if possible.
   164  func indexArg(index reflect.Value, cap int) (int, error) {
   165  	var x int64
   166  	switch index.Kind() {
   167  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   168  		x = index.Int()
   169  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   170  		x = int64(index.Uint())
   171  	case reflect.Invalid:
   172  		return 0, fmt.Errorf("cannot index slice/array with nil")
   173  	default:
   174  		return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
   175  	}
   176  	if x < 0 || int(x) < 0 || int(x) > cap {
   177  		return 0, fmt.Errorf("index out of range: %d", x)
   178  	}
   179  	return int(x), nil
   180  }
   181  
   182  // Indexing.
   183  
   184  // index returns the result of indexing its first argument by the following
   185  // arguments. Thus "index x 1 2 3" is, in Go syntax, x[1][2][3]. Each
   186  // indexed item must be a map, slice, or array.
   187  func index(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
   188  	v := indirectInterface(item)
   189  	if !v.IsValid() {
   190  		return reflect.Value{}, fmt.Errorf("index of untyped nil")
   191  	}
   192  	for _, i := range indexes {
   193  		index := indirectInterface(i)
   194  		var isNil bool
   195  		if v, isNil = indirect(v); isNil {
   196  			return reflect.Value{}, fmt.Errorf("index of nil pointer")
   197  		}
   198  		switch v.Kind() {
   199  		case reflect.Array, reflect.Slice, reflect.String:
   200  			x, err := indexArg(index, v.Len())
   201  			if err != nil {
   202  				return reflect.Value{}, err
   203  			}
   204  			v = v.Index(x)
   205  		case reflect.Map:
   206  			index, err := prepareArg(index, v.Type().Key())
   207  			if err != nil {
   208  				return reflect.Value{}, err
   209  			}
   210  			if x := v.MapIndex(index); x.IsValid() {
   211  				v = x
   212  			} else {
   213  				v = reflect.Zero(v.Type().Elem())
   214  			}
   215  		case reflect.Invalid:
   216  			// the loop holds invariant: v.IsValid()
   217  			panic("unreachable")
   218  		default:
   219  			return reflect.Value{}, fmt.Errorf("can't index item of type %s", v.Type())
   220  		}
   221  	}
   222  	return v, nil
   223  }
   224  
   225  // Slicing.
   226  
   227  // slice returns the result of slicing its first argument by the remaining
   228  // arguments. Thus "slice x 1 2" is, in Go syntax, x[1:2], while "slice x"
   229  // is x[:], "slice x 1" is x[1:], and "slice x 1 2 3" is x[1:2:3]. The first
   230  // argument must be a string, slice, or array.
   231  func slice(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
   232  	var (
   233  		cap int
   234  		v   = indirectInterface(item)
   235  	)
   236  	if !v.IsValid() {
   237  		return reflect.Value{}, fmt.Errorf("slice of untyped nil")
   238  	}
   239  	if len(indexes) > 3 {
   240  		return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
   241  	}
   242  	switch v.Kind() {
   243  	case reflect.String:
   244  		if len(indexes) == 3 {
   245  			return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
   246  		}
   247  		cap = v.Len()
   248  	case reflect.Array, reflect.Slice:
   249  		cap = v.Cap()
   250  	default:
   251  		return reflect.Value{}, fmt.Errorf("can't slice item of type %s", v.Type())
   252  	}
   253  	// set default values for cases item[:], item[i:].
   254  	idx := [3]int{0, v.Len()}
   255  	for i, index := range indexes {
   256  		x, err := indexArg(index, cap)
   257  		if err != nil {
   258  			return reflect.Value{}, err
   259  		}
   260  		idx[i] = x
   261  	}
   262  	// given item[i:j], make sure i <= j.
   263  	if idx[0] > idx[1] {
   264  		return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
   265  	}
   266  	if len(indexes) < 3 {
   267  		return item.Slice(idx[0], idx[1]), nil
   268  	}
   269  	// given item[i:j:k], make sure i <= j <= k.
   270  	if idx[1] > idx[2] {
   271  		return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
   272  	}
   273  	return item.Slice3(idx[0], idx[1], idx[2]), nil
   274  }
   275  
   276  // Length
   277  
   278  // length returns the length of the item, with an error if it has no defined length.
   279  func length(item interface{}) (int, error) {
   280  	v := reflect.ValueOf(item)
   281  	if !v.IsValid() {
   282  		return 0, fmt.Errorf("len of untyped nil")
   283  	}
   284  	v, isNil := indirect(v)
   285  	if isNil {
   286  		return 0, fmt.Errorf("len of nil pointer")
   287  	}
   288  	switch v.Kind() {
   289  	case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String:
   290  		return v.Len(), nil
   291  	}
   292  	return 0, fmt.Errorf("len of type %s", v.Type())
   293  }
   294  
   295  // Function invocation
   296  
   297  // call returns the result of evaluating the first argument as a function.
   298  // The function must return 1 result, or 2 results, the second of which is an error.
   299  func call(fn reflect.Value, args ...reflect.Value) (reflect.Value, error) {
   300  	v := indirectInterface(fn)
   301  	if !v.IsValid() {
   302  		return reflect.Value{}, fmt.Errorf("call of nil")
   303  	}
   304  	typ := v.Type()
   305  	if typ.Kind() != reflect.Func {
   306  		return reflect.Value{}, fmt.Errorf("non-function of type %s", typ)
   307  	}
   308  	if !goodFunc(typ) {
   309  		return reflect.Value{}, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
   310  	}
   311  	numIn := typ.NumIn()
   312  	var dddType reflect.Type
   313  	if typ.IsVariadic() {
   314  		if len(args) < numIn-1 {
   315  			return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
   316  		}
   317  		dddType = typ.In(numIn - 1).Elem()
   318  	} else {
   319  		if len(args) != numIn {
   320  			return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
   321  		}
   322  	}
   323  	argv := make([]reflect.Value, len(args))
   324  	for i, arg := range args {
   325  		value := indirectInterface(arg)
   326  		// Compute the expected type. Clumsy because of variadics.
   327  		argType := dddType
   328  		if !typ.IsVariadic() || i < numIn-1 {
   329  			argType = typ.In(i)
   330  		}
   331  
   332  		var err error
   333  		if argv[i], err = prepareArg(value, argType); err != nil {
   334  			return reflect.Value{}, fmt.Errorf("arg %d: %s", i, err)
   335  		}
   336  	}
   337  	return safeCall(v, argv)
   338  }
   339  
   340  // safeCall runs fun.Call(args), and returns the resulting value and error, if
   341  // any. If the call panics, the panic value is returned as an error.
   342  func safeCall(fun reflect.Value, args []reflect.Value) (val reflect.Value, err error) {
   343  	defer func() {
   344  		if r := recover(); r != nil {
   345  			if e, ok := r.(error); ok {
   346  				err = e
   347  			} else {
   348  				err = fmt.Errorf("%v", r)
   349  			}
   350  		}
   351  	}()
   352  	ret := fun.Call(args)
   353  	if len(ret) == 2 && !ret[1].IsNil() {
   354  		return ret[0], ret[1].Interface().(error)
   355  	}
   356  	return ret[0], nil
   357  }
   358  
   359  // Boolean logic.
   360  
   361  func truth(arg reflect.Value) bool {
   362  	t, _ := isTrue(indirectInterface(arg))
   363  	return t
   364  }
   365  
   366  // and computes the Boolean AND of its arguments, returning
   367  // the first false argument it encounters, or the last argument.
   368  func and(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
   369  	if !truth(arg0) {
   370  		return arg0
   371  	}
   372  	for i := range args {
   373  		arg0 = args[i]
   374  		if !truth(arg0) {
   375  			break
   376  		}
   377  	}
   378  	return arg0
   379  }
   380  
   381  // or computes the Boolean OR of its arguments, returning
   382  // the first true argument it encounters, or the last argument.
   383  func or(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
   384  	if truth(arg0) {
   385  		return arg0
   386  	}
   387  	for i := range args {
   388  		arg0 = args[i]
   389  		if truth(arg0) {
   390  			break
   391  		}
   392  	}
   393  	return arg0
   394  }
   395  
   396  // not returns the Boolean negation of its argument.
   397  func not(arg reflect.Value) bool {
   398  	return !truth(arg)
   399  }
   400  
   401  // Comparison.
   402  
   403  // TODO: Perhaps allow comparison between signed and unsigned integers.
   404  
   405  var (
   406  	errBadComparisonType = errors.New("invalid type for comparison")
   407  	errBadComparison     = errors.New("incompatible types for comparison")
   408  	errNoComparison      = errors.New("missing argument for comparison")
   409  )
   410  
   411  type kind int
   412  
   413  const (
   414  	invalidKind kind = iota
   415  	boolKind
   416  	complexKind
   417  	intKind
   418  	floatKind
   419  	stringKind
   420  	uintKind
   421  )
   422  
   423  func basicKind(v reflect.Value) (kind, error) {
   424  	switch v.Kind() {
   425  	case reflect.Bool:
   426  		return boolKind, nil
   427  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   428  		return intKind, nil
   429  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   430  		return uintKind, nil
   431  	case reflect.Float32, reflect.Float64:
   432  		return floatKind, nil
   433  	case reflect.Complex64, reflect.Complex128:
   434  		return complexKind, nil
   435  	case reflect.String:
   436  		return stringKind, nil
   437  	}
   438  	return invalidKind, errBadComparisonType
   439  }
   440  
   441  // eq evaluates the comparison a == b || a == c || ...
   442  func eq(arg1 reflect.Value, arg2 ...reflect.Value) (bool, error) {
   443  	v1 := indirectInterface(arg1)
   444  	k1, err := basicKind(v1)
   445  	if err != nil {
   446  		return false, err
   447  	}
   448  	if len(arg2) == 0 {
   449  		return false, errNoComparison
   450  	}
   451  	for _, arg := range arg2 {
   452  		v2 := indirectInterface(arg)
   453  		k2, err := basicKind(v2)
   454  		if err != nil {
   455  			return false, err
   456  		}
   457  		truth := false
   458  		if k1 != k2 {
   459  			// Special case: Can compare integer values regardless of type's sign.
   460  			switch {
   461  			case k1 == intKind && k2 == uintKind:
   462  				truth = v1.Int() >= 0 && uint64(v1.Int()) == v2.Uint()
   463  			case k1 == uintKind && k2 == intKind:
   464  				truth = v2.Int() >= 0 && v1.Uint() == uint64(v2.Int())
   465  			default:
   466  				return false, errBadComparison
   467  			}
   468  		} else {
   469  			switch k1 {
   470  			case boolKind:
   471  				truth = v1.Bool() == v2.Bool()
   472  			case complexKind:
   473  				truth = v1.Complex() == v2.Complex()
   474  			case floatKind:
   475  				truth = v1.Float() == v2.Float()
   476  			case intKind:
   477  				truth = v1.Int() == v2.Int()
   478  			case stringKind:
   479  				truth = v1.String() == v2.String()
   480  			case uintKind:
   481  				truth = v1.Uint() == v2.Uint()
   482  			default:
   483  				panic("invalid kind")
   484  			}
   485  		}
   486  		if truth {
   487  			return true, nil
   488  		}
   489  	}
   490  	return false, nil
   491  }
   492  
   493  // ne evaluates the comparison a != b.
   494  func ne(arg1, arg2 reflect.Value) (bool, error) {
   495  	// != is the inverse of ==.
   496  	equal, err := eq(arg1, arg2)
   497  	return !equal, err
   498  }
   499  
   500  // lt evaluates the comparison a < b.
   501  func lt(arg1, arg2 reflect.Value) (bool, error) {
   502  	v1 := indirectInterface(arg1)
   503  	k1, err := basicKind(v1)
   504  	if err != nil {
   505  		return false, err
   506  	}
   507  	v2 := indirectInterface(arg2)
   508  	k2, err := basicKind(v2)
   509  	if err != nil {
   510  		return false, err
   511  	}
   512  	truth := false
   513  	if k1 != k2 {
   514  		// Special case: Can compare integer values regardless of type's sign.
   515  		switch {
   516  		case k1 == intKind && k2 == uintKind:
   517  			truth = v1.Int() < 0 || uint64(v1.Int()) < v2.Uint()
   518  		case k1 == uintKind && k2 == intKind:
   519  			truth = v2.Int() >= 0 && v1.Uint() < uint64(v2.Int())
   520  		default:
   521  			return false, errBadComparison
   522  		}
   523  	} else {
   524  		switch k1 {
   525  		case boolKind, complexKind:
   526  			return false, errBadComparisonType
   527  		case floatKind:
   528  			truth = v1.Float() < v2.Float()
   529  		case intKind:
   530  			truth = v1.Int() < v2.Int()
   531  		case stringKind:
   532  			truth = v1.String() < v2.String()
   533  		case uintKind:
   534  			truth = v1.Uint() < v2.Uint()
   535  		default:
   536  			panic("invalid kind")
   537  		}
   538  	}
   539  	return truth, nil
   540  }
   541  
   542  // le evaluates the comparison <= b.
   543  func le(arg1, arg2 reflect.Value) (bool, error) {
   544  	// <= is < or ==.
   545  	lessThan, err := lt(arg1, arg2)
   546  	if lessThan || err != nil {
   547  		return lessThan, err
   548  	}
   549  	return eq(arg1, arg2)
   550  }
   551  
   552  // gt evaluates the comparison a > b.
   553  func gt(arg1, arg2 reflect.Value) (bool, error) {
   554  	// > is the inverse of <=.
   555  	lessOrEqual, err := le(arg1, arg2)
   556  	if err != nil {
   557  		return false, err
   558  	}
   559  	return !lessOrEqual, nil
   560  }
   561  
   562  // ge evaluates the comparison a >= b.
   563  func ge(arg1, arg2 reflect.Value) (bool, error) {
   564  	// >= is the inverse of <.
   565  	lessThan, err := lt(arg1, arg2)
   566  	if err != nil {
   567  		return false, err
   568  	}
   569  	return !lessThan, nil
   570  }
   571  
   572  // HTML escaping.
   573  
   574  var (
   575  	htmlQuot = []byte("&#34;") // shorter than "&quot;"
   576  	htmlApos = []byte("&#39;") // shorter than "&apos;" and apos was not in HTML until HTML5
   577  	htmlAmp  = []byte("&amp;")
   578  	htmlLt   = []byte("&lt;")
   579  	htmlGt   = []byte("&gt;")
   580  	htmlNull = []byte("\uFFFD")
   581  )
   582  
   583  // HTMLEscape writes to w the escaped HTML equivalent of the plain text data b.
   584  func HTMLEscape(w io.Writer, b []byte) {
   585  	last := 0
   586  	for i, c := range b {
   587  		var html []byte
   588  		switch c {
   589  		case '\000':
   590  			html = htmlNull
   591  		case '"':
   592  			html = htmlQuot
   593  		case '\'':
   594  			html = htmlApos
   595  		case '&':
   596  			html = htmlAmp
   597  		case '<':
   598  			html = htmlLt
   599  		case '>':
   600  			html = htmlGt
   601  		default:
   602  			continue
   603  		}
   604  		w.Write(b[last:i])
   605  		w.Write(html)
   606  		last = i + 1
   607  	}
   608  	w.Write(b[last:])
   609  }
   610  
   611  // HTMLEscapeString returns the escaped HTML equivalent of the plain text data s.
   612  func HTMLEscapeString(s string) string {
   613  	// Avoid allocation if we can.
   614  	if !strings.ContainsAny(s, "'\"&<>\000") {
   615  		return s
   616  	}
   617  	var b bytes.Buffer
   618  	HTMLEscape(&b, []byte(s))
   619  	return b.String()
   620  }
   621  
   622  // HTMLEscaper returns the escaped HTML equivalent of the textual
   623  // representation of its arguments.
   624  func HTMLEscaper(args ...interface{}) string {
   625  	return HTMLEscapeString(evalArgs(args))
   626  }
   627  
   628  // JavaScript escaping.
   629  
   630  var (
   631  	jsLowUni = []byte(`\u00`)
   632  	hex      = []byte("0123456789ABCDEF")
   633  
   634  	jsBackslash = []byte(`\\`)
   635  	jsApos      = []byte(`\'`)
   636  	jsQuot      = []byte(`\"`)
   637  	jsLt        = []byte(`\x3C`)
   638  	jsGt        = []byte(`\x3E`)
   639  )
   640  
   641  // JSEscape writes to w the escaped JavaScript equivalent of the plain text data b.
   642  func JSEscape(w io.Writer, b []byte) {
   643  	last := 0
   644  	for i := 0; i < len(b); i++ {
   645  		c := b[i]
   646  
   647  		if !jsIsSpecial(rune(c)) {
   648  			// fast path: nothing to do
   649  			continue
   650  		}
   651  		w.Write(b[last:i])
   652  
   653  		if c < utf8.RuneSelf {
   654  			// Quotes, slashes and angle brackets get quoted.
   655  			// Control characters get written as \u00XX.
   656  			switch c {
   657  			case '\\':
   658  				w.Write(jsBackslash)
   659  			case '\'':
   660  				w.Write(jsApos)
   661  			case '"':
   662  				w.Write(jsQuot)
   663  			case '<':
   664  				w.Write(jsLt)
   665  			case '>':
   666  				w.Write(jsGt)
   667  			default:
   668  				w.Write(jsLowUni)
   669  				t, b := c>>4, c&0x0f
   670  				w.Write(hex[t : t+1])
   671  				w.Write(hex[b : b+1])
   672  			}
   673  		} else {
   674  			// Unicode rune.
   675  			r, size := utf8.DecodeRune(b[i:])
   676  			if unicode.IsPrint(r) {
   677  				w.Write(b[i : i+size])
   678  			} else {
   679  				fmt.Fprintf(w, "\\u%04X", r)
   680  			}
   681  			i += size - 1
   682  		}
   683  		last = i + 1
   684  	}
   685  	w.Write(b[last:])
   686  }
   687  
   688  // JSEscapeString returns the escaped JavaScript equivalent of the plain text data s.
   689  func JSEscapeString(s string) string {
   690  	// Avoid allocation if we can.
   691  	if strings.IndexFunc(s, jsIsSpecial) < 0 {
   692  		return s
   693  	}
   694  	var b bytes.Buffer
   695  	JSEscape(&b, []byte(s))
   696  	return b.String()
   697  }
   698  
   699  func jsIsSpecial(r rune) bool {
   700  	switch r {
   701  	case '\\', '\'', '"', '<', '>':
   702  		return true
   703  	}
   704  	return r < ' ' || utf8.RuneSelf <= r
   705  }
   706  
   707  // JSEscaper returns the escaped JavaScript equivalent of the textual
   708  // representation of its arguments.
   709  func JSEscaper(args ...interface{}) string {
   710  	return JSEscapeString(evalArgs(args))
   711  }
   712  
   713  // URLQueryEscaper returns the escaped value of the textual representation of
   714  // its arguments in a form suitable for embedding in a URL query.
   715  func URLQueryEscaper(args ...interface{}) string {
   716  	return url.QueryEscape(evalArgs(args))
   717  }
   718  
   719  // evalArgs formats the list of arguments into a string. It is therefore equivalent to
   720  //	fmt.Sprint(args...)
   721  // except that each argument is indirected (if a pointer), as required,
   722  // using the same rules as the default string evaluation during template
   723  // execution.
   724  func evalArgs(args []interface{}) string {
   725  	ok := false
   726  	var s string
   727  	// Fast path for simple common case.
   728  	if len(args) == 1 {
   729  		s, ok = args[0].(string)
   730  	}
   731  	if !ok {
   732  		for i, arg := range args {
   733  			a, ok := printableValue(reflect.ValueOf(arg))
   734  			if ok {
   735  				args[i] = a
   736  			} // else let fmt do its thing
   737  		}
   738  		s = fmt.Sprint(args...)
   739  	}
   740  	return s
   741  }
   742  

View as plain text