Source file src/github.com/ugorji/go/codec/gen.go

Documentation: github.com/ugorji/go/codec

     1  // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
     2  // Use of this source code is governed by a MIT license found in the LICENSE file.
     3  
     4  //go:build codecgen.exec
     5  // +build codecgen.exec
     6  
     7  package codec
     8  
     9  import (
    10  	"bytes"
    11  	"encoding/base32"
    12  	"errors"
    13  	"fmt"
    14  	"go/format"
    15  	"io"
    16  	"io/ioutil"
    17  	"math/rand"
    18  	"os"
    19  	"reflect"
    20  	"regexp"
    21  	"sort"
    22  	"strconv"
    23  	"strings"
    24  	"sync"
    25  	"text/template"
    26  	"time"
    27  	// "ugorji.net/zz"
    28  	"unicode"
    29  	"unicode/utf8"
    30  )
    31  
    32  // ---------------------------------------------------
    33  // codecgen supports the full cycle of reflection-based codec:
    34  //    - RawExt
    35  //    - Raw
    36  //    - Extensions
    37  //    - (Binary|Text|JSON)(Unm|M)arshal
    38  //    - generic by-kind
    39  //
    40  // This means that, for dynamic things, we MUST use reflection to at least get the reflect.Type.
    41  // In those areas, we try to only do reflection or interface-conversion when NECESSARY:
    42  //    - Extensions, only if Extensions are configured.
    43  //
    44  // However, note following codecgen caveats:
    45  //   - Canonical option.
    46  //     If Canonical=true, codecgen'ed code may delegate encoding maps to reflection-based code.
    47  //     This is due to the runtime work needed to marshal a map in canonical mode.
    48  //     However, if map key is a pre-defined/builtin numeric or string type, codecgen
    49  //     will try to write it out itself
    50  //   - CheckCircularRef option.
    51  //     When encoding a struct, a circular reference can lead to a stack overflow.
    52  //     If CheckCircularRef=true, codecgen'ed code will delegate encoding structs to reflection-based code.
    53  //   - MissingFielder implementation.
    54  //     If a type implements MissingFielder, a Selfer is not generated (with a warning message).
    55  //     Statically reproducing the runtime work needed to extract the missing fields and marshal them
    56  //     along with the struct fields, while handling the Canonical=true special case, was onerous to implement.
    57  //
    58  // During encode/decode, Selfer takes precedence.
    59  // A type implementing Selfer will know how to encode/decode itself statically.
    60  //
    61  // The following field types are supported:
    62  //     array: [n]T
    63  //     slice: []T
    64  //     map: map[K]V
    65  //     primitive: [u]int[n], float(32|64), bool, string
    66  //     struct
    67  //
    68  // ---------------------------------------------------
    69  // Note that a Selfer cannot call (e|d).(En|De)code on itself,
    70  // as this will cause a circular reference, as (En|De)code will call Selfer methods.
    71  // Any type that implements Selfer must implement completely and not fallback to (En|De)code.
    72  //
    73  // In addition, code in this file manages the generation of fast-path implementations of
    74  // encode/decode of slices/maps of primitive keys/values.
    75  //
    76  // Users MUST re-generate their implementations whenever the code shape changes.
    77  // The generated code will panic if it was generated with a version older than the supporting library.
    78  // ---------------------------------------------------
    79  //
    80  // codec framework is very feature rich.
    81  // When encoding or decoding into an interface, it depends on the runtime type of the interface.
    82  // The type of the interface may be a named type, an extension, etc.
    83  // Consequently, we fallback to runtime codec for encoding/decoding interfaces.
    84  // In addition, we fallback for any value which cannot be guaranteed at runtime.
    85  // This allows us support ANY value, including any named types, specifically those which
    86  // do not implement our interfaces (e.g. Selfer).
    87  //
    88  // This explains some slowness compared to other code generation codecs (e.g. msgp).
    89  // This reduction in speed is only seen when your refers to interfaces,
    90  // e.g. type T struct { A interface{}; B []interface{}; C map[string]interface{} }
    91  //
    92  // codecgen will panic if the file was generated with an old version of the library in use.
    93  //
    94  // Note:
    95  //   It was a conscious decision to have gen.go always explicitly call EncodeNil or TryDecodeAsNil.
    96  //   This way, there isn't a function call overhead just to see that we should not enter a block of code.
    97  //
    98  // Note:
    99  //   codecgen-generated code depends on the variables defined by fast-path.generated.go.
   100  //   consequently, you cannot run with tags "codecgen codec.notfastpath".
   101  //
   102  // Note:
   103  //   genInternalXXX functions are used for generating fast-path and other internally generated
   104  //   files, and not for use in codecgen.
   105  
   106  // Size of a struct or value is not portable across machines, especially across 32-bit vs 64-bit
   107  // operating systems. This is due to types like int, uintptr, pointers, (and derived types like slice), etc
   108  // which use the natural word size on those machines, which may be 4 bytes (on 32-bit) or 8 bytes (on 64-bit).
   109  //
   110  // Within decInferLen calls, we may generate an explicit size of the entry.
   111  // We do this because decInferLen values are expected to be approximate,
   112  // and serve as a good hint on the size of the elements or key+value entry.
   113  //
   114  // Since development is done on 64-bit machines, the sizes will be roughly correctly
   115  // on 64-bit OS, and slightly larger than expected on 32-bit OS.
   116  // This is ok.
   117  //
   118  // For reference, look for 'Size' in fast-path.go.tmpl, gen-dec-(array|map).go.tmpl and gen.go (this file).
   119  
   120  // GenVersion is the current version of codecgen.
   121  //
   122  // MARKER: Increment this value each time codecgen changes fundamentally.
   123  // Also update codecgen/gen.go (minimumCodecVersion, genVersion, etc).
   124  // Fundamental changes are:
   125  //   - helper methods change (signature change, new ones added, some removed, etc)
   126  //   - codecgen command line changes
   127  //
   128  // v1: Initial Version
   129  // v2: -
   130  // v3: For Kubernetes: changes in signature of some unpublished helper methods and codecgen cmdline arguments.
   131  // v4: Removed separator support from (en|de)cDriver, and refactored codec(gen)
   132  // v5: changes to support faster json decoding. Let encoder/decoder maintain state of collections.
   133  // v6: removed unsafe from gen, and now uses codecgen.exec tag
   134  // v7: -
   135  // v8: current - we now maintain compatibility with old generated code.
   136  // v9: - skipped
   137  // v10: modified encDriver and decDriver interfaces.
   138  // v11: remove deprecated methods of encDriver and decDriver.
   139  // v12: removed deprecated methods from genHelper and changed container tracking logic
   140  // v13: 20190603 removed DecodeString - use DecodeStringAsBytes instead
   141  // v14: 20190611 refactored nil handling: TryDecodeAsNil -> selective TryNil, etc
   142  // v15: 20190626 encDriver.EncodeString handles StringToRaw flag inside handle
   143  // v16: 20190629 refactoring for v1.1.6
   144  // v17: 20200911 reduce number of types for which we generate fast path functions (v1.1.8)
   145  // v18: 20201004 changed definition of genHelper...Extension (to take interface{}) and eliminated I2Rtid method
   146  // v19: 20201115 updated codecgen cmdline flags and optimized output
   147  // v20: 20201120 refactored GenHelper to one exported function
   148  // v21: 20210104 refactored generated code to honor ZeroCopy=true for more efficiency
   149  // v22: 20210118 fixed issue in generated code when encoding a type which is also a codec.Selfer
   150  // v23: 20210203 changed slice/map types for which we generate fast-path functions
   151  // v24: 20210226 robust handling for Canonical|CheckCircularRef flags and MissingFielder implementations
   152  // v25: 20210406 pass base reflect.Type to side(En|De)code and (En|De)codeExt calls
   153  // v26: 20230201 genHelper changes for more inlining and consequent performance
   154  // v27: 20230219 fix error decoding struct from array - due to misplaced counter increment
   155  // v28: 20230224  fix decoding missing fields of struct from array, due to double counter increment
   156  const genVersion = 28
   157  
   158  const (
   159  	genCodecPkg        = "codec1978" // MARKER: keep in sync with codecgen/gen.go
   160  	genTempVarPfx      = "yy"
   161  	genTopLevelVarName = "x"
   162  
   163  	// ignore canBeNil parameter, and always set to true.
   164  	// This is because nil can appear anywhere, so we should always check.
   165  	genAnythingCanBeNil = true
   166  
   167  	// genStructCanonical configures whether we generate 2 paths based on Canonical flag
   168  	// when encoding struct fields.
   169  	genStructCanonical = true
   170  
   171  	// genFastpathCanonical configures whether we support Canonical in fast path.
   172  	// The savings is not much.
   173  	//
   174  	// MARKER: This MUST ALWAYS BE TRUE. fast-path.go.tmp doesn't handle it being false.
   175  	genFastpathCanonical = true
   176  
   177  	// genFastpathTrimTypes configures whether we trim uncommon fastpath types.
   178  	genFastpathTrimTypes = true
   179  )
   180  
   181  type genStringDecAsBytes string
   182  type genStringDecZC string
   183  
   184  var genStringDecAsBytesTyp = reflect.TypeOf(genStringDecAsBytes(""))
   185  var genStringDecZCTyp = reflect.TypeOf(genStringDecZC(""))
   186  var genFormats = []string{"Json", "Cbor", "Msgpack", "Binc", "Simple"}
   187  
   188  var (
   189  	errGenAllTypesSamePkg        = errors.New("All types must be in the same package")
   190  	errGenExpectArrayOrMap       = errors.New("unexpected type - expecting array/map/slice")
   191  	errGenUnexpectedTypeFastpath = errors.New("fast-path: unexpected type - requires map or slice")
   192  
   193  	// don't use base64, only 63 characters allowed in valid go identifiers
   194  	// ie ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_
   195  	//
   196  	// don't use numbers, as a valid go identifer must start with a letter.
   197  	genTypenameEnc  = base32.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef")
   198  	genQNameRegex = regexp.MustCompile(`[A-Za-z_.]+`)
   199  )
   200  
   201  type genBuf struct {
   202  	buf []byte
   203  }
   204  
   205  func (x *genBuf) sIf(b bool, s, t string) *genBuf {
   206  	if b {
   207  		x.buf = append(x.buf, s...)
   208  	} else {
   209  		x.buf = append(x.buf, t...)
   210  	}
   211  	return x
   212  }
   213  func (x *genBuf) s(s string) *genBuf              { x.buf = append(x.buf, s...); return x }
   214  func (x *genBuf) b(s []byte) *genBuf              { x.buf = append(x.buf, s...); return x }
   215  func (x *genBuf) v() string                       { return string(x.buf) }
   216  func (x *genBuf) f(s string, args ...interface{}) { x.s(fmt.Sprintf(s, args...)) }
   217  func (x *genBuf) reset() {
   218  	if x.buf != nil {
   219  		x.buf = x.buf[:0]
   220  	}
   221  }
   222  
   223  // genRunner holds some state used during a Gen run.
   224  type genRunner struct {
   225  	w io.Writer // output
   226  	c uint64    // counter used for generating varsfx
   227  	f uint64    // counter used for saying false
   228  
   229  	t  []reflect.Type   // list of types to run selfer on
   230  	tc reflect.Type     // currently running selfer on this type
   231  	te map[uintptr]bool // types for which the encoder has been created
   232  	td map[uintptr]bool // types for which the decoder has been created
   233  	tz map[uintptr]bool // types for which GenIsZero has been created
   234  
   235  	cp string // codec import path
   236  
   237  	im  map[string]reflect.Type // imports to add
   238  	imn map[string]string       // package names of imports to add
   239  	imc uint64                  // counter for import numbers
   240  
   241  	is map[reflect.Type]struct{} // types seen during import search
   242  	bp string                    // base PkgPath, for which we are generating for
   243  
   244  	cpfx string // codec package prefix
   245  
   246  	ty map[reflect.Type]struct{} // types for which GenIsZero *should* be created
   247  	tm map[reflect.Type]struct{} // types for which enc/dec must be generated
   248  	ts []reflect.Type            // types for which enc/dec must be generated
   249  
   250  	xs string // top level variable/constant suffix
   251  	hn string // fn helper type name
   252  
   253  	ti *TypeInfos
   254  	// rr *rand.Rand // random generator for file-specific types
   255  
   256  	jsonOnlyWhen, toArrayWhen, omitEmptyWhen *bool
   257  
   258  	nx bool // no extensions
   259  }
   260  
   261  type genIfClause struct {
   262  	hasIf bool
   263  }
   264  
   265  func (g *genIfClause) end(x *genRunner) {
   266  	if g.hasIf {
   267  		x.line("}")
   268  	}
   269  }
   270  
   271  func (g *genIfClause) c(last bool) (v string) {
   272  	if last {
   273  		if g.hasIf {
   274  			v = " } else { "
   275  		}
   276  	} else if g.hasIf {
   277  		v = " } else if "
   278  	} else {
   279  		v = "if "
   280  		g.hasIf = true
   281  	}
   282  	return
   283  }
   284  
   285  // Gen will write a complete go file containing Selfer implementations for each
   286  // type passed. All the types must be in the same package.
   287  //
   288  // Library users: DO NOT USE IT DIRECTLY. IT WILL CHANGE CONTINUOUSLY WITHOUT NOTICE.
   289  func Gen(w io.Writer, buildTags, pkgName, uid string, noExtensions bool,
   290  	jsonOnlyWhen, toArrayWhen, omitEmptyWhen *bool,
   291  	ti *TypeInfos, types ...reflect.Type) (warnings []string) {
   292  	// All types passed to this method do not have a codec.Selfer method implemented directly.
   293  	// codecgen already checks the AST and skips any types that define the codec.Selfer methods.
   294  	// Consequently, there's no need to check and trim them if they implement codec.Selfer
   295  
   296  	if len(types) == 0 {
   297  		return
   298  	}
   299  	x := genRunner{
   300  		w:             w,
   301  		t:             types,
   302  		te:            make(map[uintptr]bool),
   303  		td:            make(map[uintptr]bool),
   304  		tz:            make(map[uintptr]bool),
   305  		im:            make(map[string]reflect.Type),
   306  		imn:           make(map[string]string),
   307  		is:            make(map[reflect.Type]struct{}),
   308  		tm:            make(map[reflect.Type]struct{}),
   309  		ty:            make(map[reflect.Type]struct{}),
   310  		ts:            []reflect.Type{},
   311  		bp:            genImportPath(types[0]),
   312  		xs:            uid,
   313  		ti:            ti,
   314  		jsonOnlyWhen:  jsonOnlyWhen,
   315  		toArrayWhen:   toArrayWhen,
   316  		omitEmptyWhen: omitEmptyWhen,
   317  
   318  		nx: noExtensions,
   319  	}
   320  	if x.ti == nil {
   321  		x.ti = defTypeInfos
   322  	}
   323  	if x.xs == "" {
   324  		rr := rand.New(rand.NewSource(time.Now().UnixNano()))
   325  		x.xs = strconv.FormatInt(rr.Int63n(9999), 10)
   326  	}
   327  
   328  	// gather imports first:
   329  	x.cp = genImportPath(reflect.TypeOf(x))
   330  	x.imn[x.cp] = genCodecPkg
   331  
   332  	// iterate, check if all in same package, and remove any missingfielders
   333  	for i := 0; i < len(x.t); {
   334  		t := x.t[i]
   335  		// xdebugf("###########: PkgPath: '%v', Name: '%s'\n", genImportPath(t), t.Name())
   336  		if genImportPath(t) != x.bp {
   337  			halt.onerror(errGenAllTypesSamePkg)
   338  		}
   339  		ti1 := x.ti.get(rt2id(t), t)
   340  		if ti1.flagMissingFielder || ti1.flagMissingFielderPtr {
   341  			// output diagnostic message  - that nothing generated for this type
   342  			warnings = append(warnings, fmt.Sprintf("type: '%v' not generated; implements codec.MissingFielder", t))
   343  			copy(x.t[i:], x.t[i+1:])
   344  			x.t = x.t[:len(x.t)-1]
   345  			continue
   346  		}
   347  		x.genRefPkgs(t)
   348  		i++
   349  	}
   350  
   351  	x.line("// +build go1.6")
   352  	if buildTags != "" {
   353  		x.line("// +build " + buildTags)
   354  	}
   355  	x.line(`
   356  
   357  // Code generated by codecgen - DO NOT EDIT.
   358  
   359  `)
   360  	x.line("package " + pkgName)
   361  	x.line("")
   362  	x.line("import (")
   363  	if x.cp != x.bp {
   364  		x.cpfx = genCodecPkg + "."
   365  		x.linef("%s \"%s\"", genCodecPkg, x.cp)
   366  	}
   367  	// use a sorted set of im keys, so that we can get consistent output
   368  	imKeys := make([]string, 0, len(x.im))
   369  	for k := range x.im {
   370  		imKeys = append(imKeys, k)
   371  	}
   372  	sort.Strings(imKeys)
   373  	for _, k := range imKeys { // for k, _ := range x.im {
   374  		if k == x.imn[k] {
   375  			x.linef("\"%s\"", k)
   376  		} else {
   377  			x.linef("%s \"%s\"", x.imn[k], k)
   378  		}
   379  	}
   380  	// add required packages
   381  	for _, k := range [...]string{"runtime", "errors", "strconv", "sort"} { // "reflect", "fmt"
   382  		if _, ok := x.im[k]; !ok {
   383  			x.line("\"" + k + "\"")
   384  		}
   385  	}
   386  	x.line(")")
   387  	x.line("")
   388  
   389  	x.line("const (")
   390  	x.linef("// ----- content types ----")
   391  	x.linef("codecSelferCcUTF8%s = %v", x.xs, int64(cUTF8))
   392  	x.linef("codecSelferCcRAW%s = %v", x.xs, int64(cRAW))
   393  	x.linef("// ----- value types used ----")
   394  	for _, vt := range [...]valueType{
   395  		valueTypeArray, valueTypeMap, valueTypeString,
   396  		valueTypeInt, valueTypeUint, valueTypeFloat,
   397  		valueTypeNil,
   398  	} {
   399  		x.linef("codecSelferValueType%s%s = %v", vt.String(), x.xs, int64(vt))
   400  	}
   401  
   402  	x.linef("codecSelferBitsize%s = uint8(32 << (^uint(0) >> 63))", x.xs)
   403  	x.linef("codecSelferDecContainerLenNil%s = %d", x.xs, int64(containerLenNil))
   404  	x.line(")")
   405  	x.line("var (")
   406  	x.line("errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + " = " + "errors.New(`only encoded map or array can be decoded into a struct`)")
   407  	x.line("_ sort.Interface = nil")
   408  	x.line(")")
   409  	x.line("")
   410  
   411  	x.hn = "codecSelfer" + x.xs
   412  	x.line("type " + x.hn + " struct{}")
   413  	x.line("")
   414  	x.linef("func %sFalse() bool { return false }", x.hn)
   415  	x.linef("func %sTrue() bool { return true }", x.hn)
   416  	x.line("")
   417  
   418  	// add types for sorting canonical
   419  	for _, s := range []string{"string", "uint64", "int64", "float64"} {
   420  		x.linef("type %s%sSlice []%s", x.hn, s, s)
   421  		x.linef("func (p %s%sSlice) Len() int      { return len(p) }", x.hn, s)
   422  		x.linef("func (p %s%sSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }", x.hn, s)
   423  		x.linef("func (p %s%sSlice) Less(i, j int) bool { return p[uint(i)] < p[uint(j)] }", x.hn, s)
   424  	}
   425  
   426  	x.line("")
   427  	x.varsfxreset()
   428  	x.line("func init() {")
   429  	x.linef("if %sGenVersion != %v {", x.cpfx, genVersion)
   430  	x.line("_, file, _, _ := runtime.Caller(0)")
   431  	x.linef("ver := strconv.FormatInt(int64(%sGenVersion), 10)", x.cpfx)
   432  	x.outf(`panic(errors.New("codecgen version mismatch: current: %v, need " + ver + ". Re-generate file: " + file))`, genVersion)
   433  	x.linef("}")
   434  	if len(imKeys) > 0 {
   435  		x.line("if false { // reference the types, but skip this branch at build/run time")
   436  		for _, k := range imKeys {
   437  			t := x.im[k]
   438  			x.linef("var _ %s.%s", x.imn[k], t.Name())
   439  		}
   440  		x.line("} ") // close if false
   441  	}
   442  	x.line("}") // close init
   443  	x.line("")
   444  
   445  	// generate rest of type info
   446  	for _, t := range x.t {
   447  		x.tc = t
   448  		x.linef("func (%s) codecSelferViaCodecgen() {}", x.genTypeName(t))
   449  		x.selfer(true)
   450  		x.selfer(false)
   451  		x.tryGenIsZero(t)
   452  	}
   453  
   454  	for _, t := range x.ts {
   455  		rtid := rt2id(t)
   456  		// generate enc functions for all these slice/map types.
   457  		x.varsfxreset()
   458  		x.linef("func (x %s) enc%s(v %s%s, e *%sEncoder) {", x.hn, x.genMethodNameT(t), x.arr2str(t, "*"), x.genTypeName(t), x.cpfx)
   459  		x.genRequiredMethodVars(true)
   460  		switch t.Kind() {
   461  		case reflect.Array, reflect.Slice, reflect.Chan:
   462  			x.encListFallback("v", t)
   463  		case reflect.Map:
   464  			x.encMapFallback("v", t)
   465  		default:
   466  			halt.onerror(errGenExpectArrayOrMap)
   467  		}
   468  		x.line("}")
   469  		x.line("")
   470  
   471  		// generate dec functions for all these slice/map types.
   472  		x.varsfxreset()
   473  		x.linef("func (x %s) dec%s(v *%s, d *%sDecoder) {", x.hn, x.genMethodNameT(t), x.genTypeName(t), x.cpfx)
   474  		x.genRequiredMethodVars(false)
   475  		switch t.Kind() {
   476  		case reflect.Array, reflect.Slice, reflect.Chan:
   477  			x.decListFallback("v", rtid, t)
   478  		case reflect.Map:
   479  			x.decMapFallback("v", rtid, t)
   480  		default:
   481  			halt.onerror(errGenExpectArrayOrMap)
   482  		}
   483  		x.line("}")
   484  		x.line("")
   485  	}
   486  
   487  	for t := range x.ty {
   488  		x.tryGenIsZero(t)
   489  		x.line("")
   490  	}
   491  
   492  	x.line("")
   493  	return
   494  }
   495  
   496  func (x *genRunner) checkForSelfer(t reflect.Type, varname string) bool {
   497  	// return varname != genTopLevelVarName && t != x.tc
   498  	// the only time we checkForSelfer is if we are not at the TOP of the generated code.
   499  	return varname != genTopLevelVarName
   500  }
   501  
   502  func (x *genRunner) arr2str(t reflect.Type, s string) string {
   503  	if t.Kind() == reflect.Array {
   504  		return s
   505  	}
   506  	return ""
   507  }
   508  
   509  func (x *genRunner) genRequiredMethodVars(encode bool) {
   510  	x.line("var h " + x.hn)
   511  	if encode {
   512  		x.line("z, r := " + x.cpfx + "GenHelper().Encoder(e)")
   513  	} else {
   514  		x.line("z, r := " + x.cpfx + "GenHelper().Decoder(d)")
   515  	}
   516  	x.line("_, _, _ = h, z, r")
   517  }
   518  
   519  func (x *genRunner) genRefPkgs(t reflect.Type) {
   520  	if _, ok := x.is[t]; ok {
   521  		return
   522  	}
   523  	x.is[t] = struct{}{}
   524  	tpkg, tname := genImportPath(t), t.Name()
   525  	if tpkg != "" && tpkg != x.bp && tpkg != x.cp && tname != "" && tname[0] >= 'A' && tname[0] <= 'Z' {
   526  		if _, ok := x.im[tpkg]; !ok {
   527  			x.im[tpkg] = t
   528  			if idx := strings.LastIndex(tpkg, "/"); idx < 0 {
   529  				x.imn[tpkg] = tpkg
   530  			} else {
   531  				x.imc++
   532  				x.imn[tpkg] = "pkg" + strconv.FormatUint(x.imc, 10) + "_" + genGoIdentifier(tpkg[idx+1:], false)
   533  			}
   534  		}
   535  	}
   536  	switch t.Kind() {
   537  	case reflect.Array, reflect.Slice, reflect.Ptr, reflect.Chan:
   538  		x.genRefPkgs(t.Elem())
   539  	case reflect.Map:
   540  		x.genRefPkgs(t.Elem())
   541  		x.genRefPkgs(t.Key())
   542  	case reflect.Struct:
   543  		for i := 0; i < t.NumField(); i++ {
   544  			if fname := t.Field(i).Name; fname != "" && fname[0] >= 'A' && fname[0] <= 'Z' {
   545  				x.genRefPkgs(t.Field(i).Type)
   546  			}
   547  		}
   548  	}
   549  }
   550  
   551  // sayFalse will either say "false" or use a function call that returns false.
   552  func (x *genRunner) sayFalse() string {
   553  	x.f++
   554  	if x.f%2 == 0 {
   555  		return x.hn + "False()"
   556  	}
   557  	return "false"
   558  }
   559  
   560  // sayFalse will either say "true" or use a function call that returns true.
   561  func (x *genRunner) sayTrue() string {
   562  	x.f++
   563  	if x.f%2 == 0 {
   564  		return x.hn + "True()"
   565  	}
   566  	return "true"
   567  }
   568  
   569  func (x *genRunner) varsfx() string {
   570  	x.c++
   571  	return strconv.FormatUint(x.c, 10)
   572  }
   573  
   574  func (x *genRunner) varsfxreset() {
   575  	x.c = 0
   576  }
   577  
   578  func (x *genRunner) out(s string) {
   579  	_, err := io.WriteString(x.w, s)
   580  	genCheckErr(err)
   581  }
   582  
   583  func (x *genRunner) outf(s string, params ...interface{}) {
   584  	_, err := fmt.Fprintf(x.w, s, params...)
   585  	genCheckErr(err)
   586  }
   587  
   588  func (x *genRunner) line(s string) {
   589  	x.out(s)
   590  	if len(s) == 0 || s[len(s)-1] != '\n' {
   591  		x.out("\n")
   592  	}
   593  }
   594  
   595  func (x *genRunner) lineIf(s string) {
   596  	if s != "" {
   597  		x.line(s)
   598  	}
   599  }
   600  
   601  func (x *genRunner) linef(s string, params ...interface{}) {
   602  	x.outf(s, params...)
   603  	if len(s) == 0 || s[len(s)-1] != '\n' {
   604  		x.out("\n")
   605  	}
   606  }
   607  
   608  func (x *genRunner) genTypeName(t reflect.Type) (n string) {
   609  	// if the type has a PkgPath, which doesn't match the current package,
   610  	// then include it.
   611  	// We cannot depend on t.String() because it includes current package,
   612  	// or t.PkgPath because it includes full import path,
   613  	//
   614  	var ptrPfx string
   615  	for t.Kind() == reflect.Ptr {
   616  		ptrPfx += "*"
   617  		t = t.Elem()
   618  	}
   619  	if tn := t.Name(); tn != "" {
   620  		return ptrPfx + x.genTypeNamePrim(t)
   621  	}
   622  	switch t.Kind() {
   623  	case reflect.Map:
   624  		return ptrPfx + "map[" + x.genTypeName(t.Key()) + "]" + x.genTypeName(t.Elem())
   625  	case reflect.Slice:
   626  		return ptrPfx + "[]" + x.genTypeName(t.Elem())
   627  	case reflect.Array:
   628  		return ptrPfx + "[" + strconv.FormatInt(int64(t.Len()), 10) + "]" + x.genTypeName(t.Elem())
   629  	case reflect.Chan:
   630  		return ptrPfx + t.ChanDir().String() + " " + x.genTypeName(t.Elem())
   631  	default:
   632  		if t == intfTyp {
   633  			return ptrPfx + "interface{}"
   634  		} else {
   635  			return ptrPfx + x.genTypeNamePrim(t)
   636  		}
   637  	}
   638  }
   639  
   640  func (x *genRunner) genTypeNamePrim(t reflect.Type) (n string) {
   641  	if t.Name() == "" {
   642  		return t.String()
   643  	} else if genImportPath(t) == "" || genImportPath(t) == genImportPath(x.tc) {
   644  		return t.Name()
   645  	} else {
   646  		return x.imn[genImportPath(t)] + "." + t.Name()
   647  		// return t.String() // best way to get the package name inclusive
   648  	}
   649  }
   650  
   651  func (x *genRunner) genZeroValueR(t reflect.Type) string {
   652  	// if t is a named type, w
   653  	switch t.Kind() {
   654  	case reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Func,
   655  		reflect.Slice, reflect.Map, reflect.Invalid:
   656  		return "nil"
   657  	case reflect.Bool:
   658  		return "false"
   659  	case reflect.String:
   660  		return `""`
   661  	case reflect.Struct, reflect.Array:
   662  		return x.genTypeName(t) + "{}"
   663  	default: // all numbers
   664  		return "0"
   665  	}
   666  }
   667  
   668  func (x *genRunner) genMethodNameT(t reflect.Type) (s string) {
   669  	return genMethodNameT(t, x.tc)
   670  }
   671  
   672  func (x *genRunner) tryGenIsZero(t reflect.Type) (done bool) {
   673  	if t.Kind() != reflect.Struct || t.Implements(isCodecEmptyerTyp) {
   674  		return
   675  	}
   676  
   677  	rtid := rt2id(t)
   678  
   679  	if _, ok := x.tz[rtid]; ok {
   680  		delete(x.ty, t)
   681  		return
   682  	}
   683  
   684  	x.tz[rtid] = true
   685  	delete(x.ty, t)
   686  
   687  	ti := x.ti.get(rtid, t)
   688  	tisfi := ti.sfi.source() // always use sequence from file. decStruct expects same thing.
   689  	varname := genTopLevelVarName
   690  
   691  	x.linef("func (%s *%s) IsCodecEmpty() bool {", varname, x.genTypeName(t))
   692  
   693  	anonSeen := make(map[reflect.Type]bool)
   694  	var omitline genBuf
   695  	for _, si := range tisfi {
   696  		if si.path.parent != nil {
   697  			root := si.path.root()
   698  			if anonSeen[root.typ] {
   699  				continue
   700  			}
   701  			anonSeen[root.typ] = true
   702  		}
   703  		t2 := genOmitEmptyLinePreChecks(varname, t, si, &omitline, true)
   704  		// if Ptr, we already checked if nil above
   705  		if t2.Type.Kind() != reflect.Ptr {
   706  			x.doEncOmitEmptyLine(t2, varname, &omitline)
   707  			omitline.s(" || ")
   708  		}
   709  	}
   710  	omitline.s(" false")
   711  	x.linef("return !(%s)", omitline.v())
   712  
   713  	x.line("}")
   714  	x.line("")
   715  	return true
   716  }
   717  
   718  func (x *genRunner) selfer(encode bool) {
   719  	t := x.tc
   720  	// ti := x.ti.get(rt2id(t), t)
   721  	t0 := t
   722  	// always make decode use a pointer receiver,
   723  	// and structs/arrays always use a ptr receiver (encode|decode)
   724  	isptr := !encode || t.Kind() == reflect.Array || (t.Kind() == reflect.Struct && t != timeTyp)
   725  	x.varsfxreset()
   726  
   727  	fnSigPfx := "func (" + genTopLevelVarName + " "
   728  	if isptr {
   729  		fnSigPfx += "*"
   730  	}
   731  	fnSigPfx += x.genTypeName(t)
   732  	x.out(fnSigPfx)
   733  
   734  	if isptr {
   735  		t = reflect.PtrTo(t)
   736  	}
   737  	if encode {
   738  		x.line(") CodecEncodeSelf(e *" + x.cpfx + "Encoder) {")
   739  		x.genRequiredMethodVars(true)
   740  		if t0.Kind() == reflect.Struct {
   741  			x.linef("if z.EncBasicHandle().CheckCircularRef { z.EncEncode(%s); return }", genTopLevelVarName)
   742  		}
   743  		x.encVar(genTopLevelVarName, t)
   744  	} else {
   745  		x.line(") CodecDecodeSelf(d *" + x.cpfx + "Decoder) {")
   746  		x.genRequiredMethodVars(false)
   747  		// do not use decVar, as there is no need to check TryDecodeAsNil
   748  		// or way to elegantly handle that, and also setting it to a
   749  		// non-nil value doesn't affect the pointer passed.
   750  		// x.decVar(genTopLevelVarName, t, false)
   751  		x.dec(genTopLevelVarName, t0, true)
   752  	}
   753  	x.line("}")
   754  	x.line("")
   755  
   756  	if encode || t0.Kind() != reflect.Struct {
   757  		return
   758  	}
   759  
   760  	// write is containerMap
   761  	x.out(fnSigPfx)
   762  	x.line(") codecDecodeSelfFromMap(l int, d *" + x.cpfx + "Decoder) {")
   763  	x.genRequiredMethodVars(false)
   764  	x.decStructMap(genTopLevelVarName, "l", rt2id(t0), t0)
   765  	x.line("}")
   766  	x.line("")
   767  
   768  	// write containerArray
   769  	x.out(fnSigPfx)
   770  	x.line(") codecDecodeSelfFromArray(l int, d *" + x.cpfx + "Decoder) {")
   771  	x.genRequiredMethodVars(false)
   772  	x.decStructArray(genTopLevelVarName, "l", "return", rt2id(t0), t0)
   773  	x.line("}")
   774  	x.line("")
   775  
   776  }
   777  
   778  // used for chan, array, slice, map
   779  func (x *genRunner) xtraSM(varname string, t reflect.Type, ti *typeInfo, encode, isptr bool) {
   780  	var ptrPfx, addrPfx string
   781  	if isptr {
   782  		ptrPfx = "*"
   783  	} else {
   784  		addrPfx = "&"
   785  	}
   786  	if encode {
   787  		x.linef("h.enc%s((%s%s)(%s), e)", x.genMethodNameT(t), ptrPfx, x.genTypeName(t), varname)
   788  	} else {
   789  		x.linef("h.dec%s((*%s)(%s%s), d)", x.genMethodNameT(t), x.genTypeName(t), addrPfx, varname)
   790  	}
   791  	x.registerXtraT(t, ti)
   792  }
   793  
   794  func (x *genRunner) registerXtraT(t reflect.Type, ti *typeInfo) {
   795  	// recursively register the types
   796  	tk := t.Kind()
   797  	if tk == reflect.Ptr {
   798  		x.registerXtraT(t.Elem(), nil)
   799  		return
   800  	}
   801  	if _, ok := x.tm[t]; ok {
   802  		return
   803  	}
   804  
   805  	switch tk {
   806  	case reflect.Chan, reflect.Slice, reflect.Array, reflect.Map:
   807  	default:
   808  		return
   809  	}
   810  	// only register the type if it will not default to a fast-path
   811  	if ti == nil {
   812  		ti = x.ti.get(rt2id(t), t)
   813  	}
   814  	if _, rtidu := genFastpathUnderlying(t, ti.rtid, ti); fastpathAvIndex(rtidu) != -1 {
   815  		return
   816  	}
   817  	x.tm[t] = struct{}{}
   818  	x.ts = append(x.ts, t)
   819  	// check if this refers to any xtra types eg. a slice of array: add the array
   820  	x.registerXtraT(t.Elem(), nil)
   821  	if tk == reflect.Map {
   822  		x.registerXtraT(t.Key(), nil)
   823  	}
   824  }
   825  
   826  // encVar will encode a variable.
   827  // The parameter, t, is the reflect.Type of the variable itself
   828  func (x *genRunner) encVar(varname string, t reflect.Type) {
   829  	var checkNil bool
   830  	// case reflect.Ptr, reflect.Interface, reflect.Slice, reflect.Map, reflect.Chan:
   831  	// do not include checkNil for slice and maps, as we already checkNil below it
   832  	switch t.Kind() {
   833  	case reflect.Ptr, reflect.Interface, reflect.Chan:
   834  		checkNil = true
   835  	}
   836  	x.encVarChkNil(varname, t, checkNil)
   837  }
   838  
   839  func (x *genRunner) encVarChkNil(varname string, t reflect.Type, checkNil bool) {
   840  	if checkNil {
   841  		x.linef("if %s == nil { r.EncodeNil() } else {", varname)
   842  	}
   843  
   844  	switch t.Kind() {
   845  	case reflect.Ptr:
   846  		telem := t.Elem()
   847  		tek := telem.Kind()
   848  		if tek == reflect.Array || (tek == reflect.Struct && telem != timeTyp) {
   849  			x.enc(varname, genNonPtr(t), true)
   850  			break
   851  		}
   852  		i := x.varsfx()
   853  		x.line(genTempVarPfx + i + " := *" + varname)
   854  		x.enc(genTempVarPfx+i, genNonPtr(t), false)
   855  	case reflect.Struct, reflect.Array:
   856  		if t == timeTyp {
   857  			x.enc(varname, t, false)
   858  			break
   859  		}
   860  		i := x.varsfx()
   861  		x.line(genTempVarPfx + i + " := &" + varname)
   862  		x.enc(genTempVarPfx+i, t, true)
   863  	default:
   864  		x.enc(varname, t, false)
   865  	}
   866  
   867  	if checkNil {
   868  		x.line("}")
   869  	}
   870  }
   871  
   872  // enc will encode a variable (varname) of type t, where t represents T.
   873  // if t is !time.Time and t is of kind reflect.Struct or reflect.Array, varname is of type *T
   874  // (to prevent copying),
   875  // else t is of type T
   876  func (x *genRunner) enc(varname string, t reflect.Type, isptr bool) {
   877  	rtid := rt2id(t)
   878  	ti2 := x.ti.get(rtid, t)
   879  	// We call CodecEncodeSelf if one of the following are honored:
   880  	//   - the type already implements Selfer, call that
   881  	//   - the type has a Selfer implementation just created, use that
   882  	//   - the type is in the list of the ones we will generate for, but it is not currently being generated
   883  
   884  	mi := x.varsfx()
   885  	// tptr := reflect.PtrTo(t)
   886  	// tk := t.Kind()
   887  
   888  	// check if
   889  	//   - type is time.Time, RawExt, Raw
   890  	//   - the type implements (Text|JSON|Binary)(Unm|M)arshal
   891  
   892  	var hasIf genIfClause
   893  	defer hasIf.end(x) // end if block (if necessary)
   894  
   895  	var ptrPfx, addrPfx string
   896  	if isptr {
   897  		ptrPfx = "*"
   898  	} else {
   899  		addrPfx = "&"
   900  	}
   901  
   902  	if t == timeTyp {
   903  		x.linef("%s z.EncBasicHandle().TimeBuiltin() { r.EncodeTime(%s%s)", hasIf.c(false), ptrPfx, varname)
   904  		// return
   905  	}
   906  	if t == rawTyp {
   907  		x.linef("%s z.EncRaw(%s%s)", hasIf.c(true), ptrPfx, varname)
   908  		return
   909  	}
   910  	if t == rawExtTyp {
   911  		x.linef("%s r.EncodeRawExt(%s%s)", hasIf.c(true), addrPfx, varname)
   912  		return
   913  	}
   914  	// only check for extensions if extensions are configured,
   915  	// and the type is named, and has a packagePath,
   916  	// and this is not the CodecEncodeSelf or CodecDecodeSelf method (i.e. it is not a Selfer)
   917  	if !x.nx && varname != genTopLevelVarName && t != genStringDecAsBytesTyp &&
   918  		t != genStringDecZCTyp && genImportPath(t) != "" && t.Name() != "" {
   919  		yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
   920  		x.linef("%s %s := z.Extension(%s); %s != nil { z.EncExtension(%s, %s) ",
   921  			hasIf.c(false), yy, varname, yy, varname, yy)
   922  	}
   923  
   924  	if x.checkForSelfer(t, varname) {
   925  		if ti2.flagSelfer {
   926  			x.linef("%s %s.CodecEncodeSelf(e)", hasIf.c(true), varname)
   927  			return
   928  		}
   929  		if ti2.flagSelferPtr {
   930  			if isptr {
   931  				x.linef("%s %s.CodecEncodeSelf(e)", hasIf.c(true), varname)
   932  			} else {
   933  				x.linef("%s %ssf%s := &%s", hasIf.c(true), genTempVarPfx, mi, varname)
   934  				x.linef("%ssf%s.CodecEncodeSelf(e)", genTempVarPfx, mi)
   935  			}
   936  			return
   937  		}
   938  
   939  		if _, ok := x.te[rtid]; ok {
   940  			x.linef("%s %s.CodecEncodeSelf(e)", hasIf.c(true), varname)
   941  			return
   942  		}
   943  	}
   944  
   945  	inlist := false
   946  	for _, t0 := range x.t {
   947  		if t == t0 {
   948  			inlist = true
   949  			if x.checkForSelfer(t, varname) {
   950  				x.linef("%s %s.CodecEncodeSelf(e)", hasIf.c(true), varname)
   951  				return
   952  			}
   953  			break
   954  		}
   955  	}
   956  
   957  	var rtidAdded bool
   958  	if t == x.tc {
   959  		x.te[rtid] = true
   960  		rtidAdded = true
   961  	}
   962  
   963  	if ti2.flagBinaryMarshaler {
   964  		x.linef("%s z.EncBinary() { z.EncBinaryMarshal(%s%v) ", hasIf.c(false), ptrPfx, varname)
   965  	} else if ti2.flagBinaryMarshalerPtr {
   966  		x.linef("%s z.EncBinary() { z.EncBinaryMarshal(%s%v) ", hasIf.c(false), addrPfx, varname)
   967  	}
   968  
   969  	if ti2.flagJsonMarshaler {
   970  		x.linef("%s !z.EncBinary() && z.IsJSONHandle() { z.EncJSONMarshal(%s%v) ", hasIf.c(false), ptrPfx, varname)
   971  	} else if ti2.flagJsonMarshalerPtr {
   972  		x.linef("%s !z.EncBinary() && z.IsJSONHandle() { z.EncJSONMarshal(%s%v) ", hasIf.c(false), addrPfx, varname)
   973  	} else if ti2.flagTextMarshaler {
   974  		x.linef("%s !z.EncBinary() { z.EncTextMarshal(%s%v) ", hasIf.c(false), ptrPfx, varname)
   975  	} else if ti2.flagTextMarshalerPtr {
   976  		x.linef("%s !z.EncBinary() { z.EncTextMarshal(%s%v) ", hasIf.c(false), addrPfx, varname)
   977  	}
   978  
   979  	x.lineIf(hasIf.c(true))
   980  
   981  	switch t.Kind() {
   982  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   983  		x.line("r.EncodeInt(int64(" + varname + "))")
   984  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   985  		x.line("r.EncodeUint(uint64(" + varname + "))")
   986  	case reflect.Float32:
   987  		x.line("r.EncodeFloat32(float32(" + varname + "))")
   988  	case reflect.Float64:
   989  		x.line("r.EncodeFloat64(float64(" + varname + "))")
   990  	case reflect.Complex64:
   991  		x.linef("z.EncEncodeComplex64(complex64(%s))", varname)
   992  	case reflect.Complex128:
   993  		x.linef("z.EncEncodeComplex128(complex128(%s))", varname)
   994  	case reflect.Bool:
   995  		x.line("r.EncodeBool(bool(" + varname + "))")
   996  	case reflect.String:
   997  		x.linef("r.EncodeString(string(%s))", varname)
   998  	case reflect.Chan:
   999  		x.xtraSM(varname, t, ti2, true, false)
  1000  		// x.encListFallback(varname, rtid, t)
  1001  	case reflect.Array:
  1002  		_, rtidu := genFastpathUnderlying(t, rtid, ti2)
  1003  		if fastpathAvIndex(rtidu) != -1 {
  1004  			g := x.newFastpathGenV(ti2.key)
  1005  			x.linef("z.F.%sV((%s)(%s[:]), e)", g.MethodNamePfx("Enc", false), x.genTypeName(ti2.key), varname)
  1006  		} else {
  1007  			x.xtraSM(varname, t, ti2, true, true)
  1008  		}
  1009  	case reflect.Slice:
  1010  		// if nil, call dedicated function
  1011  		// if a []byte, call dedicated function
  1012  		// if a known fastpath slice, call dedicated function
  1013  		// else write encode function in-line.
  1014  		// - if elements are primitives or Selfers, call dedicated function on each member.
  1015  		// - else call Encoder.encode(XXX) on it.
  1016  
  1017  		x.linef("if %s == nil { r.EncodeNil() } else {", varname)
  1018  		if rtid == uint8SliceTypId {
  1019  			x.line("r.EncodeStringBytesRaw([]byte(" + varname + "))")
  1020  		} else {
  1021  			tu, rtidu := genFastpathUnderlying(t, rtid, ti2)
  1022  			if fastpathAvIndex(rtidu) != -1 {
  1023  				g := x.newFastpathGenV(tu)
  1024  				if rtid == rtidu {
  1025  					x.linef("z.F.%sV(%s, e)", g.MethodNamePfx("Enc", false), varname)
  1026  				} else {
  1027  					x.linef("z.F.%sV((%s)(%s), e)", g.MethodNamePfx("Enc", false), x.genTypeName(tu), varname)
  1028  				}
  1029  			} else {
  1030  				x.xtraSM(varname, t, ti2, true, false)
  1031  			}
  1032  		}
  1033  		x.linef("} // end block: if %s slice == nil", varname)
  1034  	case reflect.Map:
  1035  		// if nil, call dedicated function
  1036  		// if a known fastpath map, call dedicated function
  1037  		// else write encode function in-line.
  1038  		// - if elements are primitives or Selfers, call dedicated function on each member.
  1039  		// - else call Encoder.encode(XXX) on it.
  1040  		x.linef("if %s == nil { r.EncodeNil() } else {", varname)
  1041  		tu, rtidu := genFastpathUnderlying(t, rtid, ti2)
  1042  		if fastpathAvIndex(rtidu) != -1 {
  1043  			g := x.newFastpathGenV(tu)
  1044  			if rtid == rtidu {
  1045  				x.linef("z.F.%sV(%s, e)", g.MethodNamePfx("Enc", false), varname)
  1046  			} else {
  1047  				x.linef("z.F.%sV((%s)(%s), e)", g.MethodNamePfx("Enc", false), x.genTypeName(tu), varname)
  1048  			}
  1049  		} else {
  1050  			x.xtraSM(varname, t, ti2, true, false)
  1051  		}
  1052  		x.linef("} // end block: if %s map == nil", varname)
  1053  	case reflect.Struct:
  1054  		if !inlist {
  1055  			delete(x.te, rtid)
  1056  			x.line("z.EncFallback(" + varname + ")")
  1057  			break
  1058  		}
  1059  		x.encStruct(varname, rtid, t)
  1060  	default:
  1061  		if rtidAdded {
  1062  			delete(x.te, rtid)
  1063  		}
  1064  		x.line("z.EncFallback(" + varname + ")")
  1065  	}
  1066  }
  1067  
  1068  func (x *genRunner) encZero(t reflect.Type) {
  1069  	switch t.Kind() {
  1070  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  1071  		x.line("r.EncodeInt(0)")
  1072  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  1073  		x.line("r.EncodeUint(0)")
  1074  	case reflect.Float32:
  1075  		x.line("r.EncodeFloat32(0)")
  1076  	case reflect.Float64:
  1077  		x.line("r.EncodeFloat64(0)")
  1078  	case reflect.Complex64:
  1079  		x.line("z.EncEncodeComplex64(0)")
  1080  	case reflect.Complex128:
  1081  		x.line("z.EncEncodeComplex128(0)")
  1082  	case reflect.Bool:
  1083  		x.line("r.EncodeBool(false)")
  1084  	case reflect.String:
  1085  		x.linef(`r.EncodeString("")`)
  1086  	default:
  1087  		x.line("r.EncodeNil()")
  1088  	}
  1089  }
  1090  
  1091  func genOmitEmptyLinePreChecks(varname string, t reflect.Type, si *structFieldInfo, omitline *genBuf, oneLevel bool) (t2 reflect.StructField) {
  1092  	// xdebug2f("calling genOmitEmptyLinePreChecks on: %v", t)
  1093  	t2typ := t
  1094  	varname3 := varname
  1095  	// go through the loop, record the t2 field explicitly,
  1096  	// and gather the omit line if embedded in pointers.
  1097  	fullpath := si.path.fullpath()
  1098  	for i, path := range fullpath {
  1099  		for t2typ.Kind() == reflect.Ptr {
  1100  			t2typ = t2typ.Elem()
  1101  		}
  1102  		t2 = t2typ.Field(int(path.index))
  1103  		t2typ = t2.Type
  1104  		varname3 = varname3 + "." + t2.Name
  1105  		// do not include actual field in the omit line.
  1106  		// that is done subsequently (right after - below).
  1107  		if i+1 < len(fullpath) && t2typ.Kind() == reflect.Ptr {
  1108  			omitline.s(varname3).s(" != nil && ")
  1109  		}
  1110  		if oneLevel {
  1111  			break
  1112  		}
  1113  	}
  1114  	return
  1115  }
  1116  
  1117  func (x *genRunner) doEncOmitEmptyLine(t2 reflect.StructField, varname string, buf *genBuf) {
  1118  	x.f = 0
  1119  	x.encOmitEmptyLine(t2, varname, buf)
  1120  }
  1121  
  1122  func (x *genRunner) encOmitEmptyLine(t2 reflect.StructField, varname string, buf *genBuf) {
  1123  	// xdebugf("calling encOmitEmptyLine on: %v", t2.Type)
  1124  	// smartly check omitEmpty on a struct type, as it may contain uncomparable map/slice/etc.
  1125  	// also, for maps/slices, check if len ! 0 (not if == zero value)
  1126  	varname2 := varname + "." + t2.Name
  1127  	switch t2.Type.Kind() {
  1128  	case reflect.Struct:
  1129  		rtid2 := rt2id(t2.Type)
  1130  		ti2 := x.ti.get(rtid2, t2.Type)
  1131  		// xdebugf(">>>> structfield: omitempty: type: %s, field: %s\n", t2.Type.Name(), t2.Name)
  1132  		if ti2.rtid == timeTypId {
  1133  			buf.s("!(").s(varname2).s(".IsZero())")
  1134  			break
  1135  		}
  1136  		if ti2.flagIsZeroerPtr || ti2.flagIsZeroer {
  1137  			buf.s("!(").s(varname2).s(".IsZero())")
  1138  			break
  1139  		}
  1140  		if t2.Type.Implements(isCodecEmptyerTyp) {
  1141  			buf.s("!(").s(varname2).s(".IsCodecEmpty())")
  1142  			break
  1143  		}
  1144  		_, ok := x.tz[rtid2]
  1145  		if ok {
  1146  			buf.s("!(").s(varname2).s(".IsCodecEmpty())")
  1147  			break
  1148  		}
  1149  		// if we *should* create a IsCodecEmpty for it, but haven't yet, add it here
  1150  		// _, ok = x.ty[rtid2]
  1151  		if genImportPath(t2.Type) == x.bp {
  1152  			x.ty[t2.Type] = struct{}{}
  1153  			buf.s("!(").s(varname2).s(".IsCodecEmpty())")
  1154  			break
  1155  		}
  1156  		if ti2.flagComparable {
  1157  			buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
  1158  			break
  1159  		}
  1160  		// buf.s("(")
  1161  		buf.s(x.sayFalse()) // buf.s("false")
  1162  		var wrote bool
  1163  		for i, n := 0, t2.Type.NumField(); i < n; i++ {
  1164  			f := t2.Type.Field(i)
  1165  			if f.PkgPath != "" { // unexported
  1166  				continue
  1167  			}
  1168  			buf.s(" || ")
  1169  			x.encOmitEmptyLine(f, varname2, buf)
  1170  			wrote = true
  1171  		}
  1172  		if !wrote {
  1173  			buf.s(" || ").s(x.sayTrue())
  1174  		}
  1175  		//buf.s(")")
  1176  	case reflect.Bool:
  1177  		buf.s("bool(").s(varname2).s(")")
  1178  	case reflect.Map, reflect.Slice, reflect.Chan:
  1179  		buf.s("len(").s(varname2).s(") != 0")
  1180  	case reflect.Array:
  1181  		tlen := t2.Type.Len()
  1182  		if tlen == 0 {
  1183  			buf.s(x.sayFalse())
  1184  		} else if t2.Type.Comparable() {
  1185  			buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
  1186  		} else { // then we cannot even compare the individual values
  1187  			// TODO use playground to check if you can compare to a
  1188  			// zero value of an array, even if array not comparable.
  1189  			buf.s(x.sayTrue())
  1190  		}
  1191  	default:
  1192  		buf.s(varname2).s(" != ").s(x.genZeroValueR(t2.Type))
  1193  	}
  1194  }
  1195  
  1196  func (x *genRunner) encStruct(varname string, rtid uintptr, t reflect.Type) {
  1197  	// Use knowledge from structfieldinfo (mbs, encodable fields. Ignore omitempty. )
  1198  	// replicate code in kStruct i.e. for each field, deref type to non-pointer, and call x.enc on it
  1199  
  1200  	// if t === type currently running selfer on, do for all
  1201  	ti := x.ti.get(rtid, t)
  1202  	i := x.varsfx()
  1203  	// sepVarname := genTempVarPfx + "sep" + i
  1204  	numfieldsvar := genTempVarPfx + "q" + i
  1205  	ti2arrayvar := genTempVarPfx + "r" + i
  1206  	struct2arrvar := genTempVarPfx + "2arr" + i
  1207  
  1208  	tisfi := ti.sfi.source() // always use sequence from file. decStruct expects same thing.
  1209  
  1210  	type genFQN struct {
  1211  		i       string
  1212  		fqname  string
  1213  		nilLine genBuf
  1214  		nilVar  string
  1215  		canNil  bool
  1216  		sf      reflect.StructField
  1217  	}
  1218  
  1219  	genFQNs := make([]genFQN, len(tisfi))
  1220  	si2Pos := make(map[*structFieldInfo]int) // stores position in sorted structFieldInfos
  1221  
  1222  	for j, si := range tisfi {
  1223  		si2Pos[si] = j
  1224  		q := &genFQNs[j]
  1225  		q.i = x.varsfx()
  1226  		q.nilVar = genTempVarPfx + "n" + q.i
  1227  		q.canNil = false
  1228  		q.fqname = varname
  1229  		{
  1230  			t2typ := t
  1231  			fullpath := si.path.fullpath()
  1232  			for _, path := range fullpath {
  1233  				for t2typ.Kind() == reflect.Ptr {
  1234  					t2typ = t2typ.Elem()
  1235  				}
  1236  				q.sf = t2typ.Field(int(path.index))
  1237  				t2typ = q.sf.Type
  1238  				q.fqname += "." + q.sf.Name
  1239  				if t2typ.Kind() == reflect.Ptr {
  1240  					if !q.canNil {
  1241  						q.nilLine.f("%s == nil", q.fqname)
  1242  						q.canNil = true
  1243  					} else {
  1244  						q.nilLine.f(" || %s == nil", q.fqname)
  1245  					}
  1246  				}
  1247  			}
  1248  		}
  1249  	}
  1250  
  1251  	// x.line(sepVarname + " := !z.EncBinary()")
  1252  	x.linef("%s := z.EncBasicHandle().StructToArray", struct2arrvar)
  1253  	// x.linef("_, _ = %s, %s", sepVarname, struct2arrvar)
  1254  	x.linef("_ = %s", struct2arrvar)
  1255  	x.linef("const %s bool = %v // struct tag has 'toArray'", ti2arrayvar, ti.toArray)
  1256  
  1257  	for j := range genFQNs {
  1258  		q := &genFQNs[j]
  1259  		if q.canNil {
  1260  			x.linef("var %s bool = %s", q.nilVar, q.nilLine.v())
  1261  		}
  1262  	}
  1263  
  1264  	// var nn int
  1265  	// due to omitEmpty, we need to calculate the
  1266  	// number of non-empty things we write out first.
  1267  	// This is required as we need to pre-determine the size of the container,
  1268  	// to support length-prefixing.
  1269  	omitEmptySometimes := x.omitEmptyWhen == nil
  1270  	omitEmptyAlways := (x.omitEmptyWhen != nil && *(x.omitEmptyWhen))
  1271  	// omitEmptyNever := (x.omitEmptyWhen != nil && !*(x.omitEmptyWhen))
  1272  
  1273  	toArraySometimes := x.toArrayWhen == nil
  1274  	toArrayAlways := (x.toArrayWhen != nil && *(x.toArrayWhen))
  1275  	toArrayNever := (x.toArrayWhen != nil && !(*(x.toArrayWhen)))
  1276  
  1277  	if (omitEmptySometimes && ti.anyOmitEmpty) || omitEmptyAlways {
  1278  		x.linef("var %s = [%v]bool{ // should field at this index be written?", numfieldsvar, len(tisfi))
  1279  
  1280  		for _, si := range tisfi {
  1281  			if omitEmptySometimes && !si.path.omitEmpty {
  1282  				x.linef("true, // %s", si.encName) // si.fieldName)
  1283  				continue
  1284  			}
  1285  			var omitline genBuf
  1286  			t2 := genOmitEmptyLinePreChecks(varname, t, si, &omitline, false)
  1287  			x.doEncOmitEmptyLine(t2, varname, &omitline)
  1288  			x.linef("%s, // %s", omitline.v(), si.encName) // si.fieldName)
  1289  		}
  1290  		x.line("}")
  1291  		x.linef("_ = %s", numfieldsvar)
  1292  	}
  1293  
  1294  	if toArraySometimes {
  1295  		x.linef("if %s || %s {", ti2arrayvar, struct2arrvar) // if ti.toArray
  1296  	}
  1297  	if toArraySometimes || toArrayAlways {
  1298  		x.linef("z.EncWriteArrayStart(%d)", len(tisfi))
  1299  
  1300  		for j, si := range tisfi {
  1301  			doOmitEmptyCheck := (omitEmptySometimes && si.path.omitEmpty) || omitEmptyAlways
  1302  			q := &genFQNs[j]
  1303  			// if the type of the field is a Selfer, or one of the ones
  1304  			if q.canNil {
  1305  				x.linef("if %s { z.EncWriteArrayElem(); r.EncodeNil() } else { ", q.nilVar)
  1306  			}
  1307  			x.linef("z.EncWriteArrayElem()")
  1308  			if doOmitEmptyCheck {
  1309  				x.linef("if %s[%v] {", numfieldsvar, j)
  1310  			}
  1311  			x.encVarChkNil(q.fqname, q.sf.Type, false)
  1312  			if doOmitEmptyCheck {
  1313  				x.linef("} else {")
  1314  				x.encZero(q.sf.Type)
  1315  				x.linef("}")
  1316  			}
  1317  			if q.canNil {
  1318  				x.line("}")
  1319  			}
  1320  		}
  1321  
  1322  		x.line("z.EncWriteArrayEnd()")
  1323  	}
  1324  	if toArraySometimes {
  1325  		x.linef("} else {") // if not ti.toArray
  1326  	}
  1327  	if toArraySometimes || toArrayNever {
  1328  		if (omitEmptySometimes && ti.anyOmitEmpty) || omitEmptyAlways {
  1329  			x.linef("var %snn%s int", genTempVarPfx, i)
  1330  			x.linef("for _, b := range %s { if b { %snn%s++ } }", numfieldsvar, genTempVarPfx, i)
  1331  			x.linef("z.EncWriteMapStart(%snn%s)", genTempVarPfx, i)
  1332  			x.linef("%snn%s = %v", genTempVarPfx, i, 0)
  1333  		} else {
  1334  			x.linef("z.EncWriteMapStart(%d)", len(tisfi))
  1335  		}
  1336  
  1337  		fn := func(tisfi []*structFieldInfo) {
  1338  			// tisfi here may be source or sorted, so use the src position stored elsewhere
  1339  			for _, si := range tisfi {
  1340  				pos := si2Pos[si]
  1341  				q := &genFQNs[pos]
  1342  				doOmitEmptyCheck := (omitEmptySometimes && si.path.omitEmpty) || omitEmptyAlways
  1343  				if doOmitEmptyCheck {
  1344  					x.linef("if %s[%v] {", numfieldsvar, pos)
  1345  				}
  1346  				x.linef("z.EncWriteMapElemKey()")
  1347  
  1348  				// emulate EncStructFieldKey
  1349  				switch ti.keyType {
  1350  				case valueTypeInt:
  1351  					x.linef("r.EncodeInt(z.M.Int(strconv.ParseInt(`%s`, 10, 64)))", si.encName)
  1352  				case valueTypeUint:
  1353  					x.linef("r.EncodeUint(z.M.Uint(strconv.ParseUint(`%s`, 10, 64)))", si.encName)
  1354  				case valueTypeFloat:
  1355  					x.linef("r.EncodeFloat64(z.M.Float(strconv.ParseFloat(`%s`, 64)))", si.encName)
  1356  				default: // string
  1357  					if x.jsonOnlyWhen == nil {
  1358  						if si.path.encNameAsciiAlphaNum {
  1359  							x.linef(`if z.IsJSONHandle() { z.EncWr().WriteStr("\"%s\"") } else { `, si.encName)
  1360  						}
  1361  						x.linef("r.EncodeString(`%s`)", si.encName)
  1362  						if si.path.encNameAsciiAlphaNum {
  1363  							x.linef("}")
  1364  						}
  1365  					} else if *(x.jsonOnlyWhen) {
  1366  						if si.path.encNameAsciiAlphaNum {
  1367  							x.linef(`z.EncWr().WriteStr("\"%s\"")`, si.encName)
  1368  						} else {
  1369  							x.linef("r.EncodeString(`%s`)", si.encName)
  1370  						}
  1371  					} else {
  1372  						x.linef("r.EncodeString(`%s`)", si.encName)
  1373  					}
  1374  				}
  1375  				x.line("z.EncWriteMapElemValue()")
  1376  				if q.canNil {
  1377  					x.line("if " + q.nilVar + " { r.EncodeNil() } else { ")
  1378  					x.encVarChkNil(q.fqname, q.sf.Type, false)
  1379  					x.line("}")
  1380  				} else {
  1381  					x.encVarChkNil(q.fqname, q.sf.Type, false)
  1382  				}
  1383  				if doOmitEmptyCheck {
  1384  					x.line("}")
  1385  				}
  1386  			}
  1387  		}
  1388  
  1389  		if genStructCanonical {
  1390  			x.linef("if z.EncBasicHandle().Canonical {") // if Canonical block
  1391  			fn(ti.sfi.sorted())
  1392  			x.linef("} else {") // else !Canonical block
  1393  			fn(ti.sfi.source())
  1394  			x.linef("}") // end if Canonical block
  1395  		} else {
  1396  			fn(tisfi)
  1397  		}
  1398  
  1399  		x.line("z.EncWriteMapEnd()")
  1400  	}
  1401  	if toArraySometimes {
  1402  		x.linef("} ") // end if/else ti.toArray
  1403  	}
  1404  }
  1405  
  1406  func (x *genRunner) encListFallback(varname string, t reflect.Type) {
  1407  	x.linef("if %s == nil { r.EncodeNil(); return }", varname)
  1408  	elemBytes := t.Elem().Kind() == reflect.Uint8
  1409  	if t.AssignableTo(uint8SliceTyp) {
  1410  		x.linef("r.EncodeStringBytesRaw([]byte(%s))", varname)
  1411  		return
  1412  	}
  1413  	if t.Kind() == reflect.Array && elemBytes {
  1414  		x.linef("r.EncodeStringBytesRaw(((*[%d]byte)(%s))[:])", t.Len(), varname)
  1415  		return
  1416  	}
  1417  	i := x.varsfx()
  1418  	if t.Kind() == reflect.Chan {
  1419  		type ts struct {
  1420  			Label, Chan, Slice, Sfx string
  1421  		}
  1422  		tm, err := template.New("").Parse(genEncChanTmpl)
  1423  		genCheckErr(err)
  1424  		x.linef("if %s == nil { r.EncodeNil() } else { ", varname)
  1425  		x.linef("var sch%s []%s", i, x.genTypeName(t.Elem()))
  1426  		err = tm.Execute(x.w, &ts{"Lsch" + i, varname, "sch" + i, i})
  1427  		genCheckErr(err)
  1428  		if elemBytes {
  1429  			x.linef("r.EncodeStringBytesRaw([]byte(%s))", "sch"+i)
  1430  			x.line("}")
  1431  			return
  1432  		}
  1433  		varname = "sch" + i
  1434  	}
  1435  
  1436  	x.line("z.EncWriteArrayStart(len(" + varname + "))")
  1437  
  1438  	// x.linef("for _, %sv%s := range %s {", genTempVarPfx, i, varname)
  1439  	// x.linef("z.EncWriteArrayElem()")
  1440  	// x.encVar(genTempVarPfx+"v"+i, t.Elem())
  1441  	// x.line("}")
  1442  
  1443  	x.linef("for %sv%s := range %s {", genTempVarPfx, i, varname)
  1444  	x.linef("z.EncWriteArrayElem()")
  1445  	x.encVar(fmt.Sprintf("%s[%sv%s]", varname, genTempVarPfx, i), t.Elem())
  1446  	x.line("}")
  1447  
  1448  	x.line("z.EncWriteArrayEnd()")
  1449  	if t.Kind() == reflect.Chan {
  1450  		x.line("}")
  1451  	}
  1452  }
  1453  
  1454  func (x *genRunner) encMapFallback(varname string, t reflect.Type) {
  1455  	x.linef("if %s == nil { r.EncodeNil()", varname)
  1456  	x.line("} else if z.EncBasicHandle().Canonical {")
  1457  
  1458  	// Solve for easy case accomodated by sort package without reflection i.e.
  1459  	// map keys of type: float, int, string (pre-defined/builtin types).
  1460  	//
  1461  	// To do this, we will get the keys into an array of uint64|float64|string,
  1462  	// sort them, then write them out, and grab the value and encode it appropriately
  1463  	tkey := t.Key()
  1464  	tkind := tkey.Kind()
  1465  	// tkeybase := tkey
  1466  	// for tkeybase.Kind() == reflect.Ptr {
  1467  	// 	tkeybase = tkeybase.Elem()
  1468  	// }
  1469  	// tikey := x.ti.get(rt2id(tkeybase), tkeybase)
  1470  
  1471  	// pre-defined types have a name and no pkgpath and appropriate kind
  1472  	predeclared := tkey.PkgPath() == "" && tkey.Name() != ""
  1473  
  1474  	canonSortKind := reflect.Invalid
  1475  	switch tkind {
  1476  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  1477  		canonSortKind = reflect.Int64
  1478  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
  1479  		canonSortKind = reflect.Uint64
  1480  	case reflect.Float32, reflect.Float64:
  1481  		canonSortKind = reflect.Float64
  1482  	case reflect.String:
  1483  		canonSortKind = reflect.String
  1484  	}
  1485  
  1486  	var i string = x.varsfx()
  1487  
  1488  	fnCanonNumBoolStrKind := func() {
  1489  		if !predeclared {
  1490  			x.linef("var %svv%s %s", genTempVarPfx, i, x.genTypeName(tkey))
  1491  			x.linef("%sencfn%s := z.EncFnGivenAddr(&%svv%s)", genTempVarPfx, i, genTempVarPfx, i)
  1492  		}
  1493  		// get the type, get the slice type its mapped to, and complete the code
  1494  		x.linef("%ss%s := make([]%s, 0, len(%s))", genTempVarPfx, i, canonSortKind, varname)
  1495  		x.linef("for k, _ := range %s {", varname)
  1496  		x.linef("  %ss%s = append(%ss%s, %s(k))", genTempVarPfx, i, genTempVarPfx, i, canonSortKind)
  1497  		x.linef("}")
  1498  		x.linef("sort.Sort(%s%sSlice(%ss%s))", x.hn, canonSortKind, genTempVarPfx, i)
  1499  		x.linef("z.EncWriteMapStart(len(%s))", varname)
  1500  		x.linef("for _, %sv%s := range %ss%s {", genTempVarPfx, i, genTempVarPfx, i)
  1501  		x.linef("  z.EncWriteMapElemKey()")
  1502  		if predeclared {
  1503  			switch tkind {
  1504  			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32:
  1505  				x.linef("r.EncodeInt(int64(%sv%s))", genTempVarPfx, i)
  1506  			case reflect.Int64:
  1507  				x.linef("r.EncodeInt(%sv%s)", genTempVarPfx, i)
  1508  			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
  1509  				x.linef("r.EncodeUint(%sv%s)", genTempVarPfx, i)
  1510  			case reflect.Uint64:
  1511  				x.linef("r.EncodeUint(uint64(%sv%s))", genTempVarPfx, i)
  1512  			case reflect.Float32:
  1513  				x.linef("r.EncodeFloat32(float32(%sv%s))", genTempVarPfx, i)
  1514  			case reflect.Float64:
  1515  				x.linef("r.EncodeFloat64(%sv%s)", genTempVarPfx, i)
  1516  			case reflect.String:
  1517  				x.linef("r.EncodeString(%sv%s)", genTempVarPfx, i)
  1518  			}
  1519  		} else {
  1520  			x.linef("%svv%s = %s(%sv%s)", genTempVarPfx, i, x.genTypeName(tkey), genTempVarPfx, i)
  1521  			x.linef("z.EncEncodeNumBoolStrKindGivenAddr(&%svv%s, %sencfn%s)", genTempVarPfx, i, genTempVarPfx, i)
  1522  		}
  1523  		x.linef("  z.EncWriteMapElemValue()")
  1524  		vname := genTempVarPfx + "e" + i
  1525  		if predeclared {
  1526  			x.linef("%s := %s[%s(%sv%s)]", vname, varname, x.genTypeName(tkey), genTempVarPfx, i)
  1527  		} else {
  1528  			x.linef("%s := %s[%svv%s]", vname, varname, genTempVarPfx, i)
  1529  		}
  1530  		x.encVar(vname, t.Elem())
  1531  		x.linef("}")
  1532  
  1533  		x.line("z.EncWriteMapEnd()")
  1534  
  1535  	}
  1536  
  1537  	// if canonSortKind != reflect.Invalid && !tikey.flagMarshalInterface {
  1538  	// 	if predeclared {
  1539  	// 		fnCanonNumBoolStrKind()
  1540  	// 	} else {
  1541  	// 		// handle if an extension
  1542  	// 		x.linef("if z.Extension(%s(%s)) != nil { z.EncEncodeMapNonNil(%s) } else {",
  1543  	// 			x.genTypeName(tkey), x.genZeroValueR(tkey), varname)
  1544  	// 		fnCanonNumBoolStrKind()
  1545  	// 		x.line("}")
  1546  	// 	}
  1547  	// } else {
  1548  	// 	x.linef("z.EncEncodeMapNonNil(%s)", varname)
  1549  	// }
  1550  
  1551  	if canonSortKind != reflect.Invalid {
  1552  		fnCanonNumBoolStrKind()
  1553  	} else {
  1554  		x.linef("z.EncEncodeMapNonNil(%s)", varname)
  1555  	}
  1556  
  1557  	x.line("} else {")
  1558  
  1559  	x.linef("z.EncWriteMapStart(len(%s))", varname)
  1560  	x.linef("for %sk%s, %sv%s := range %s {", genTempVarPfx, i, genTempVarPfx, i, varname)
  1561  	x.linef("z.EncWriteMapElemKey()")
  1562  	x.encVar(genTempVarPfx+"k"+i, t.Key())
  1563  	x.line("z.EncWriteMapElemValue()")
  1564  	x.encVar(genTempVarPfx+"v"+i, t.Elem())
  1565  	x.line("}")
  1566  	x.line("z.EncWriteMapEnd()")
  1567  
  1568  	x.line("}")
  1569  }
  1570  
  1571  func (x *genRunner) decVarInitPtr(varname, nilvar string, t reflect.Type, si *structFieldInfo,
  1572  	newbuf, nilbuf *genBuf) (varname3 string, t2 reflect.StructField) {
  1573  	//we must accommodate anonymous fields, where the embedded field is a nil pointer in the value.
  1574  	// t2 = t.FieldByIndex(si.is)
  1575  	varname3 = varname
  1576  	t2typ := t
  1577  	t2kind := t2typ.Kind()
  1578  	var nilbufed bool
  1579  	if si != nil {
  1580  		fullpath := si.path.fullpath()
  1581  		for _, path := range fullpath {
  1582  			// only one-level pointers can be seen in a type
  1583  			if t2typ.Kind() == reflect.Ptr {
  1584  				t2typ = t2typ.Elem()
  1585  			}
  1586  			t2 = t2typ.Field(int(path.index))
  1587  			t2typ = t2.Type
  1588  			varname3 = varname3 + "." + t2.Name
  1589  			t2kind = t2typ.Kind()
  1590  			if t2kind != reflect.Ptr {
  1591  				continue
  1592  			}
  1593  			if newbuf != nil {
  1594  				if len(newbuf.buf) > 0 {
  1595  					newbuf.s("\n")
  1596  				}
  1597  				newbuf.f("if %s == nil { %s = new(%s) }", varname3, varname3, x.genTypeName(t2typ.Elem()))
  1598  			}
  1599  			if nilbuf != nil {
  1600  				if !nilbufed {
  1601  					nilbuf.s("if ").s(varname3).s(" != nil")
  1602  					nilbufed = true
  1603  				} else {
  1604  					nilbuf.s(" && ").s(varname3).s(" != nil")
  1605  				}
  1606  			}
  1607  		}
  1608  	}
  1609  	if nilbuf != nil {
  1610  		if nilbufed {
  1611  			nilbuf.s(" { ").s("// remove the if-true\n")
  1612  		}
  1613  		if nilvar != "" {
  1614  			nilbuf.s(nilvar).s(" = true")
  1615  		} else if tk := t2typ.Kind(); tk == reflect.Ptr {
  1616  			if strings.IndexByte(varname3, '.') != -1 || strings.IndexByte(varname3, '[') != -1 {
  1617  				nilbuf.s(varname3).s(" = nil")
  1618  			} else {
  1619  				nilbuf.s("*").s(varname3).s(" = ").s(x.genZeroValueR(t2typ.Elem()))
  1620  			}
  1621  		} else {
  1622  			nilbuf.s(varname3).s(" = ").s(x.genZeroValueR(t2typ))
  1623  		}
  1624  		if nilbufed {
  1625  			nilbuf.s("}")
  1626  		}
  1627  	}
  1628  	return
  1629  }
  1630  
  1631  // decVar takes a variable called varname, of type t
  1632  func (x *genRunner) decVarMain(varname, rand string, t reflect.Type, checkNotNil bool) {
  1633  	// We only encode as nil if a nillable value.
  1634  	// This removes some of the wasted checks for TryDecodeAsNil.
  1635  	// We need to think about this more, to see what happens if omitempty, etc
  1636  	// cause a nil value to be stored when something is expected.
  1637  	// This could happen when decoding from a struct encoded as an array.
  1638  	// For that, decVar should be called with canNil=true, to force true as its value.
  1639  	var varname2 string
  1640  	if t.Kind() != reflect.Ptr {
  1641  		if t.PkgPath() != "" || !x.decTryAssignPrimitive(varname, t, false) {
  1642  			x.dec(varname, t, false)
  1643  		}
  1644  	} else {
  1645  		if checkNotNil {
  1646  			x.linef("if %s == nil { %s = new(%s) }", varname, varname, x.genTypeName(t.Elem()))
  1647  		}
  1648  		// Ensure we set underlying ptr to a non-nil value (so we can deref to it later).
  1649  		// There's a chance of a **T in here which is nil.
  1650  		var ptrPfx string
  1651  		for t = t.Elem(); t.Kind() == reflect.Ptr; t = t.Elem() {
  1652  			ptrPfx += "*"
  1653  			if checkNotNil {
  1654  				x.linef("if %s%s == nil { %s%s = new(%s)}", ptrPfx, varname, ptrPfx, varname, x.genTypeName(t))
  1655  			}
  1656  		}
  1657  		// Should we create temp var if a slice/map indexing? No. dec(...) can now handle it.
  1658  
  1659  		if ptrPfx == "" {
  1660  			x.dec(varname, t, true)
  1661  		} else {
  1662  			varname2 = genTempVarPfx + "z" + rand
  1663  			x.line(varname2 + " := " + ptrPfx + varname)
  1664  			x.dec(varname2, t, true)
  1665  		}
  1666  	}
  1667  }
  1668  
  1669  // decVar takes a variable called varname, of type t
  1670  func (x *genRunner) decVar(varname, nilvar string, t reflect.Type, canBeNil, checkNotNil bool) {
  1671  
  1672  	// We only encode as nil if a nillable value.
  1673  	// This removes some of the wasted checks for TryDecodeAsNil.
  1674  	// We need to think about this more, to see what happens if omitempty, etc
  1675  	// cause a nil value to be stored when something is expected.
  1676  	// This could happen when decoding from a struct encoded as an array.
  1677  	// For that, decVar should be called with canNil=true, to force true as its value.
  1678  
  1679  	i := x.varsfx()
  1680  	if t.Kind() == reflect.Ptr {
  1681  		var buf genBuf
  1682  		x.decVarInitPtr(varname, nilvar, t, nil, nil, &buf)
  1683  		x.linef("if r.TryNil() { %s } else {", buf.buf)
  1684  		x.decVarMain(varname, i, t, checkNotNil)
  1685  		x.line("} ")
  1686  	} else {
  1687  		x.decVarMain(varname, i, t, checkNotNil)
  1688  	}
  1689  }
  1690  
  1691  // dec will decode a variable (varname) of type t or ptrTo(t) if isptr==true.
  1692  func (x *genRunner) dec(varname string, t reflect.Type, isptr bool) {
  1693  	// assumptions:
  1694  	//   - the varname is to a pointer already. No need to take address of it
  1695  	//   - t is always a baseType T (not a *T, etc).
  1696  	rtid := rt2id(t)
  1697  	ti2 := x.ti.get(rtid, t)
  1698  
  1699  	// check if
  1700  	//   - type is time.Time, Raw, RawExt
  1701  	//   - the type implements (Text|JSON|Binary)(Unm|M)arshal
  1702  
  1703  	mi := x.varsfx()
  1704  
  1705  	var hasIf genIfClause
  1706  	defer hasIf.end(x)
  1707  
  1708  	var ptrPfx, addrPfx string
  1709  	if isptr {
  1710  		ptrPfx = "*"
  1711  	} else {
  1712  		addrPfx = "&"
  1713  	}
  1714  	if t == timeTyp {
  1715  		x.linef("%s z.DecBasicHandle().TimeBuiltin() { %s%v = r.DecodeTime()", hasIf.c(false), ptrPfx, varname)
  1716  		// return
  1717  	}
  1718  	if t == rawTyp {
  1719  		x.linef("%s %s%v = z.DecRaw()", hasIf.c(true), ptrPfx, varname)
  1720  		return
  1721  	}
  1722  
  1723  	if t == rawExtTyp {
  1724  		x.linef("%s r.DecodeExt(%s%v, 0, nil)", hasIf.c(true), addrPfx, varname)
  1725  		return
  1726  	}
  1727  
  1728  	// only check for extensions if extensions are configured,
  1729  	// and the type is named, and has a packagePath,
  1730  	// and this is not the CodecEncodeSelf or CodecDecodeSelf method (i.e. it is not a Selfer)
  1731  	// xdebugf("genRunner.dec: varname: %v, t: %v, genImportPath: %v, t.Name: %v", varname, t, genImportPath(t), t.Name())
  1732  	if !x.nx && varname != genTopLevelVarName && t != genStringDecAsBytesTyp &&
  1733  		t != genStringDecZCTyp && genImportPath(t) != "" && t.Name() != "" {
  1734  		// first check if extensions are configued, before doing the interface conversion
  1735  		yy := fmt.Sprintf("%sxt%s", genTempVarPfx, mi)
  1736  		x.linef("%s %s := z.Extension(%s); %s != nil { z.DecExtension(%s%s, %s) ", hasIf.c(false), yy, varname, yy, addrPfx, varname, yy)
  1737  	}
  1738  
  1739  	if x.checkForSelfer(t, varname) {
  1740  		if ti2.flagSelfer {
  1741  			x.linef("%s %s.CodecDecodeSelf(d)", hasIf.c(true), varname)
  1742  			return
  1743  		}
  1744  		if ti2.flagSelferPtr {
  1745  			x.linef("%s %s.CodecDecodeSelf(d)", hasIf.c(true), varname)
  1746  			return
  1747  		}
  1748  		if _, ok := x.td[rtid]; ok {
  1749  			x.linef("%s %s.CodecDecodeSelf(d)", hasIf.c(true), varname)
  1750  			return
  1751  		}
  1752  	}
  1753  
  1754  	inlist := false
  1755  	for _, t0 := range x.t {
  1756  		if t == t0 {
  1757  			inlist = true
  1758  			if x.checkForSelfer(t, varname) {
  1759  				x.linef("%s %s.CodecDecodeSelf(d)", hasIf.c(true), varname)
  1760  				return
  1761  			}
  1762  			break
  1763  		}
  1764  	}
  1765  
  1766  	var rtidAdded bool
  1767  	if t == x.tc {
  1768  		x.td[rtid] = true
  1769  		rtidAdded = true
  1770  	}
  1771  
  1772  	if ti2.flagBinaryUnmarshaler {
  1773  		x.linef("%s z.DecBinary() { z.DecBinaryUnmarshal(%s%v) ", hasIf.c(false), ptrPfx, varname)
  1774  	} else if ti2.flagBinaryUnmarshalerPtr {
  1775  		x.linef("%s z.DecBinary() { z.DecBinaryUnmarshal(%s%v) ", hasIf.c(false), addrPfx, varname)
  1776  	}
  1777  	if ti2.flagJsonUnmarshaler {
  1778  		x.linef("%s !z.DecBinary() && z.IsJSONHandle() { z.DecJSONUnmarshal(%s%v)", hasIf.c(false), ptrPfx, varname)
  1779  	} else if ti2.flagJsonUnmarshalerPtr {
  1780  		x.linef("%s !z.DecBinary() && z.IsJSONHandle() { z.DecJSONUnmarshal(%s%v)", hasIf.c(false), addrPfx, varname)
  1781  	} else if ti2.flagTextUnmarshaler {
  1782  		x.linef("%s !z.DecBinary() { z.DecTextUnmarshal(%s%v)", hasIf.c(false), ptrPfx, varname)
  1783  	} else if ti2.flagTextUnmarshalerPtr {
  1784  		x.linef("%s !z.DecBinary() { z.DecTextUnmarshal(%s%v)", hasIf.c(false), addrPfx, varname)
  1785  	}
  1786  
  1787  	x.lineIf(hasIf.c(true))
  1788  
  1789  	if x.decTryAssignPrimitive(varname, t, isptr) {
  1790  		return
  1791  	}
  1792  
  1793  	switch t.Kind() {
  1794  	case reflect.Chan:
  1795  		x.xtraSM(varname, t, ti2, false, isptr)
  1796  	case reflect.Array:
  1797  		_, rtidu := genFastpathUnderlying(t, rtid, ti2)
  1798  		if fastpathAvIndex(rtidu) != -1 {
  1799  			g := x.newFastpathGenV(ti2.key)
  1800  			x.linef("z.F.%sN((%s)(%s[:]), d)", g.MethodNamePfx("Dec", false), x.genTypeName(ti2.key), varname)
  1801  		} else {
  1802  			x.xtraSM(varname, t, ti2, false, isptr)
  1803  		}
  1804  	case reflect.Slice:
  1805  		// if a []byte, call dedicated function
  1806  		// if a known fastpath slice, call dedicated function
  1807  		// else write encode function in-line.
  1808  		// - if elements are primitives or Selfers, call dedicated function on each member.
  1809  		// - else call Encoder.encode(XXX) on it.
  1810  
  1811  		if rtid == uint8SliceTypId {
  1812  			x.linef("%s%s = z.DecodeBytesInto(%s(%s[]byte)(%s))", ptrPfx, varname, ptrPfx, ptrPfx, varname)
  1813  		} else {
  1814  			tu, rtidu := genFastpathUnderlying(t, rtid, ti2)
  1815  			if fastpathAvIndex(rtidu) != -1 {
  1816  				g := x.newFastpathGenV(tu)
  1817  				if rtid == rtidu {
  1818  					x.linef("z.F.%sX(%s%s, d)", g.MethodNamePfx("Dec", false), addrPfx, varname)
  1819  				} else {
  1820  					x.linef("z.F.%sX((*%s)(%s%s), d)", g.MethodNamePfx("Dec", false), x.genTypeName(tu), addrPfx, varname)
  1821  				}
  1822  			} else {
  1823  				x.xtraSM(varname, t, ti2, false, isptr)
  1824  				// x.decListFallback(varname, rtid, false, t)
  1825  			}
  1826  		}
  1827  	case reflect.Map:
  1828  		// if a known fastpath map, call dedicated function
  1829  		// else write encode function in-line.
  1830  		// - if elements are primitives or Selfers, call dedicated function on each member.
  1831  		// - else call Encoder.encode(XXX) on it.
  1832  
  1833  		tu, rtidu := genFastpathUnderlying(t, rtid, ti2)
  1834  		if fastpathAvIndex(rtidu) != -1 {
  1835  			g := x.newFastpathGenV(tu)
  1836  			if rtid == rtidu {
  1837  				x.linef("z.F.%sX(%s%s, d)", g.MethodNamePfx("Dec", false), addrPfx, varname)
  1838  			} else {
  1839  				x.linef("z.F.%sX((*%s)(%s%s), d)", g.MethodNamePfx("Dec", false), x.genTypeName(tu), addrPfx, varname)
  1840  			}
  1841  		} else {
  1842  			x.xtraSM(varname, t, ti2, false, isptr)
  1843  		}
  1844  	case reflect.Struct:
  1845  		if inlist {
  1846  			// no need to create temp variable if isptr, or x.F or x[F]
  1847  			if isptr || strings.IndexByte(varname, '.') != -1 || strings.IndexByte(varname, '[') != -1 {
  1848  				x.decStruct(varname, rtid, t)
  1849  			} else {
  1850  				varname2 := genTempVarPfx + "j" + mi
  1851  				x.line(varname2 + " := &" + varname)
  1852  				x.decStruct(varname2, rtid, t)
  1853  			}
  1854  		} else {
  1855  			// delete(x.td, rtid)
  1856  			x.line("z.DecFallback(" + addrPfx + varname + ", false)")
  1857  		}
  1858  	default:
  1859  		if rtidAdded {
  1860  			delete(x.te, rtid)
  1861  		}
  1862  		x.line("z.DecFallback(" + addrPfx + varname + ", true)")
  1863  	}
  1864  }
  1865  
  1866  func (x *genRunner) decTryAssignPrimitive(varname string, t reflect.Type, isptr bool) (done bool) {
  1867  	// This should only be used for exact primitives (ie un-named types).
  1868  	// Named types may be implementations of Selfer, Unmarshaler, etc.
  1869  	// They should be handled by dec(...)
  1870  
  1871  	var ptr string
  1872  	if isptr {
  1873  		ptr = "*"
  1874  	}
  1875  	switch t.Kind() {
  1876  	case reflect.Int:
  1877  		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), codecSelferBitsize%s))", ptr, varname, x.genTypeName(t), x.xs)
  1878  	case reflect.Int8:
  1879  		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), 8))", ptr, varname, x.genTypeName(t))
  1880  	case reflect.Int16:
  1881  		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), 16))", ptr, varname, x.genTypeName(t))
  1882  	case reflect.Int32:
  1883  		x.linef("%s%s = (%s)(z.C.IntV(r.DecodeInt64(), 32))", ptr, varname, x.genTypeName(t))
  1884  	case reflect.Int64:
  1885  		x.linef("%s%s = (%s)(r.DecodeInt64())", ptr, varname, x.genTypeName(t))
  1886  
  1887  	case reflect.Uint:
  1888  		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), codecSelferBitsize%s))", ptr, varname, x.genTypeName(t), x.xs)
  1889  	case reflect.Uint8:
  1890  		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), 8))", ptr, varname, x.genTypeName(t))
  1891  	case reflect.Uint16:
  1892  		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), 16))", ptr, varname, x.genTypeName(t))
  1893  	case reflect.Uint32:
  1894  		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), 32))", ptr, varname, x.genTypeName(t))
  1895  	case reflect.Uint64:
  1896  		x.linef("%s%s = (%s)(r.DecodeUint64())", ptr, varname, x.genTypeName(t))
  1897  	case reflect.Uintptr:
  1898  		x.linef("%s%s = (%s)(z.C.UintV(r.DecodeUint64(), codecSelferBitsize%s))", ptr, varname, x.genTypeName(t), x.xs)
  1899  
  1900  	case reflect.Float32:
  1901  		x.linef("%s%s = (%s)(z.DecDecodeFloat32())", ptr, varname, x.genTypeName(t))
  1902  	case reflect.Float64:
  1903  		x.linef("%s%s = (%s)(r.DecodeFloat64())", ptr, varname, x.genTypeName(t))
  1904  
  1905  	case reflect.Complex64:
  1906  		x.linef("%s%s = (%s)(complex(z.DecDecodeFloat32(), 0))", ptr, varname, x.genTypeName(t))
  1907  	case reflect.Complex128:
  1908  		x.linef("%s%s = (%s)(complex(r.DecodeFloat64(), 0))", ptr, varname, x.genTypeName(t))
  1909  
  1910  	case reflect.Bool:
  1911  		x.linef("%s%s = (%s)(r.DecodeBool())", ptr, varname, x.genTypeName(t))
  1912  	case reflect.String:
  1913  		if t == genStringDecAsBytesTyp {
  1914  			x.linef("%s%s = r.DecodeStringAsBytes()", ptr, varname)
  1915  		} else if t == genStringDecZCTyp {
  1916  			x.linef("%s%s = (string)(z.DecStringZC(r.DecodeStringAsBytes()))", ptr, varname)
  1917  		} else {
  1918  			x.linef("%s%s = (%s)(z.DecStringZC(r.DecodeStringAsBytes()))", ptr, varname, x.genTypeName(t))
  1919  		}
  1920  	default:
  1921  		return false
  1922  	}
  1923  	return true
  1924  }
  1925  
  1926  func (x *genRunner) decListFallback(varname string, rtid uintptr, t reflect.Type) {
  1927  	if t.AssignableTo(uint8SliceTyp) {
  1928  		x.line("*" + varname + " = z.DecodeBytesInto(*((*[]byte)(" + varname + ")))")
  1929  		return
  1930  	}
  1931  	if t.Kind() == reflect.Array && t.Elem().Kind() == reflect.Uint8 {
  1932  		x.linef("r.DecodeBytes( ((*[%d]byte)(%s))[:])", t.Len(), varname)
  1933  		return
  1934  	}
  1935  	type tstruc struct {
  1936  		TempVar   string
  1937  		Sfx       string
  1938  		Rand      string
  1939  		Varname   string
  1940  		CTyp      string
  1941  		Typ       string
  1942  		Immutable bool
  1943  		Size      int
  1944  	}
  1945  	telem := t.Elem()
  1946  	ts := tstruc{genTempVarPfx, x.xs, x.varsfx(), varname, x.genTypeName(t), x.genTypeName(telem), genIsImmutable(telem), int(telem.Size())}
  1947  
  1948  	funcs := make(template.FuncMap)
  1949  
  1950  	funcs["decLineVar"] = func(varname string) string {
  1951  		x.decVar(varname, "", telem, false, true)
  1952  		return ""
  1953  	}
  1954  	funcs["var"] = func(s string) string {
  1955  		return ts.TempVar + s + ts.Rand
  1956  	}
  1957  	funcs["xs"] = func() string {
  1958  		return ts.Sfx
  1959  	}
  1960  	funcs["zero"] = func() string {
  1961  		return x.genZeroValueR(telem)
  1962  	}
  1963  	funcs["isArray"] = func() bool {
  1964  		return t.Kind() == reflect.Array
  1965  	}
  1966  	funcs["isSlice"] = func() bool {
  1967  		return t.Kind() == reflect.Slice
  1968  	}
  1969  	funcs["isChan"] = func() bool {
  1970  		return t.Kind() == reflect.Chan
  1971  	}
  1972  	tm, err := template.New("").Funcs(funcs).Parse(genDecListTmpl)
  1973  	genCheckErr(err)
  1974  	genCheckErr(tm.Execute(x.w, &ts))
  1975  }
  1976  
  1977  func (x *genRunner) decMapFallback(varname string, rtid uintptr, t reflect.Type) {
  1978  	type tstruc struct {
  1979  		TempVar string
  1980  		Sfx     string
  1981  		Rand    string
  1982  		Varname string
  1983  		KTyp    string
  1984  		Typ     string
  1985  		Size    int
  1986  	}
  1987  	telem := t.Elem()
  1988  	tkey := t.Key()
  1989  	ts := tstruc{
  1990  		genTempVarPfx, x.xs, x.varsfx(), varname, x.genTypeName(tkey),
  1991  		x.genTypeName(telem), int(telem.Size() + tkey.Size()),
  1992  	}
  1993  
  1994  	funcs := make(template.FuncMap)
  1995  	funcs["decElemZero"] = func() string {
  1996  		return x.genZeroValueR(telem)
  1997  	}
  1998  	funcs["decElemKindImmutable"] = func() bool {
  1999  		return genIsImmutable(telem)
  2000  	}
  2001  	funcs["decElemKindPtr"] = func() bool {
  2002  		return telem.Kind() == reflect.Ptr
  2003  	}
  2004  	funcs["decElemKindIntf"] = func() bool {
  2005  		return telem.Kind() == reflect.Interface
  2006  	}
  2007  	funcs["decLineVarKStrBytes"] = func(varname string) string {
  2008  		x.decVar(varname, "", genStringDecAsBytesTyp, false, true)
  2009  		return ""
  2010  	}
  2011  	funcs["decLineVarKStrZC"] = func(varname string) string {
  2012  		x.decVar(varname, "", genStringDecZCTyp, false, true)
  2013  		return ""
  2014  	}
  2015  	funcs["decLineVarK"] = func(varname string) string {
  2016  		x.decVar(varname, "", tkey, false, true)
  2017  		return ""
  2018  	}
  2019  	funcs["decLineVar"] = func(varname, decodedNilVarname string) string {
  2020  		x.decVar(varname, decodedNilVarname, telem, false, true)
  2021  		return ""
  2022  	}
  2023  	funcs["var"] = func(s string) string {
  2024  		return ts.TempVar + s + ts.Rand
  2025  	}
  2026  	funcs["xs"] = func() string {
  2027  		return ts.Sfx
  2028  	}
  2029  
  2030  	tm, err := template.New("").Funcs(funcs).Parse(genDecMapTmpl)
  2031  	genCheckErr(err)
  2032  	genCheckErr(tm.Execute(x.w, &ts))
  2033  }
  2034  
  2035  func (x *genRunner) decStructMapSwitch(kName string, varname string, rtid uintptr, t reflect.Type) {
  2036  	ti := x.ti.get(rtid, t)
  2037  	tisfi := ti.sfi.source() // always use sequence from file. decStruct expects same thing.
  2038  	x.line("switch string(" + kName + ") {")
  2039  	var newbuf, nilbuf genBuf
  2040  	for _, si := range tisfi {
  2041  		x.line("case \"" + si.encName + "\":")
  2042  		newbuf.reset()
  2043  		nilbuf.reset()
  2044  		varname3, t2 := x.decVarInitPtr(varname, "", t, si, &newbuf, &nilbuf)
  2045  		if len(newbuf.buf) > 0 {
  2046  			x.linef("if r.TryNil() { %s } else { %s", nilbuf.buf, newbuf.buf)
  2047  		}
  2048  		x.decVarMain(varname3, x.varsfx(), t2.Type, false)
  2049  		if len(newbuf.buf) > 0 {
  2050  			x.line("}")
  2051  		}
  2052  	}
  2053  	x.line("default:")
  2054  	// pass the slice here, so that the string will not escape, and maybe save allocation
  2055  	x.linef("z.DecStructFieldNotFound(-1, string(%s))", kName)
  2056  	x.linef("} // end switch %s", kName)
  2057  }
  2058  
  2059  func (x *genRunner) decStructMap(varname, lenvarname string, rtid uintptr, t reflect.Type) {
  2060  	tpfx := genTempVarPfx
  2061  	ti := x.ti.get(rtid, t)
  2062  	i := x.varsfx()
  2063  	kName := tpfx + "s" + i
  2064  
  2065  	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
  2066  	x.linef("for %sj%s := 0; z.DecContainerNext(%sj%s, %s, %shl%s); %sj%s++ {",
  2067  		tpfx, i, tpfx, i, lenvarname, tpfx, i, tpfx, i)
  2068  
  2069  	x.line("z.DecReadMapElemKey()")
  2070  
  2071  	// emulate decstructfieldkey
  2072  	switch ti.keyType {
  2073  	case valueTypeInt:
  2074  		x.linef("%s := strconv.AppendInt(z.DecScratchArrayBuffer()[:0], r.DecodeInt64(), 10)", kName)
  2075  	case valueTypeUint:
  2076  		x.linef("%s := strconv.AppendUint(z.DecScratchArrayBuffer()[:0], r.DecodeUint64(), 10)", kName)
  2077  	case valueTypeFloat:
  2078  		x.linef("%s := strconv.AppendFloat(z.DecScratchArrayBuffer()[:0], r.DecodeFloat64(), 'f', -1, 64)", kName)
  2079  	default: // string
  2080  		x.linef("%s := r.DecodeStringAsBytes()", kName)
  2081  	}
  2082  
  2083  	x.line("z.DecReadMapElemValue()")
  2084  	x.decStructMapSwitch(kName, varname, rtid, t)
  2085  
  2086  	x.line("} // end for " + tpfx + "j" + i)
  2087  }
  2088  
  2089  func (x *genRunner) decStructArray(varname, lenvarname, breakString string, rtid uintptr, t reflect.Type) {
  2090  	tpfx := genTempVarPfx
  2091  	i := x.varsfx()
  2092  	ti := x.ti.get(rtid, t)
  2093  	tisfi := ti.sfi.source() // always use sequence from file. decStruct expects same thing.
  2094  	x.linef("var %sj%s int", tpfx, i)
  2095  	x.linef("var %sb%s bool", tpfx, i)                        // break
  2096  	x.linef("var %shl%s bool = %s >= 0", tpfx, i, lenvarname) // has length
  2097  	var newbuf, nilbuf genBuf
  2098  	for _, si := range tisfi {
  2099  		x.linef("%sb%s = !z.DecContainerNext(%sj%s, %s, %shl%s)", tpfx, i, tpfx, i, lenvarname, tpfx, i)
  2100  		x.linef("if %sb%s { z.DecReadArrayEnd(); %s }", tpfx, i, breakString)
  2101  		x.line("z.DecReadArrayElem()")
  2102  		newbuf.reset()
  2103  		nilbuf.reset()
  2104  		varname3, t2 := x.decVarInitPtr(varname, "", t, si, &newbuf, &nilbuf)
  2105  		if len(newbuf.buf) > 0 {
  2106  			x.linef("if r.TryNil() { %s } else { %s", nilbuf.buf, newbuf.buf)
  2107  		}
  2108  		x.decVarMain(varname3, x.varsfx(), t2.Type, false)
  2109  		if len(newbuf.buf) > 0 {
  2110  			x.line("}")
  2111  		}
  2112  		x.linef("%sj%s++", tpfx, i)
  2113  	}
  2114  	// read remaining values and throw away.
  2115  	x.linef("for ; z.DecContainerNext(%sj%s, %s, %shl%s); %sj%s++ {",
  2116  		tpfx, i, lenvarname, tpfx, i, tpfx, i)
  2117  	x.line("z.DecReadArrayElem()")
  2118  	x.linef(`z.DecStructFieldNotFound(%sj%s - 1, "")`, tpfx, i)
  2119  	x.line("}")
  2120  }
  2121  
  2122  func (x *genRunner) decStruct(varname string, rtid uintptr, t reflect.Type) {
  2123  	// varname MUST be a ptr, or a struct field or a slice element.
  2124  	i := x.varsfx()
  2125  	x.linef("%sct%s := r.ContainerType()", genTempVarPfx, i)
  2126  	x.linef("if %sct%s == codecSelferValueTypeNil%s {", genTempVarPfx, i, x.xs)
  2127  	x.linef("*(%s) = %s{}", varname, x.genTypeName(t))
  2128  	x.linef("} else if %sct%s == codecSelferValueTypeMap%s {", genTempVarPfx, i, x.xs)
  2129  	x.line(genTempVarPfx + "l" + i + " := z.DecReadMapStart()")
  2130  	x.linef("if %sl%s == 0 {", genTempVarPfx, i)
  2131  
  2132  	x.line("} else { ")
  2133  	x.linef("%s.codecDecodeSelfFromMap(%sl%s, d)", varname, genTempVarPfx, i)
  2134  
  2135  	x.line("}")
  2136  	x.line("z.DecReadMapEnd()")
  2137  
  2138  	// else if container is array
  2139  	x.linef("} else if %sct%s == codecSelferValueTypeArray%s {", genTempVarPfx, i, x.xs)
  2140  	x.line(genTempVarPfx + "l" + i + " := z.DecReadArrayStart()")
  2141  	x.linef("if %sl%s != 0 {", genTempVarPfx, i)
  2142  	x.linef("%s.codecDecodeSelfFromArray(%sl%s, d)", varname, genTempVarPfx, i)
  2143  	x.line("}")
  2144  	x.line("z.DecReadArrayEnd()")
  2145  	// else panic
  2146  	x.line("} else { ")
  2147  	x.line("panic(errCodecSelferOnlyMapOrArrayEncodeToStruct" + x.xs + ")")
  2148  	x.line("} ")
  2149  }
  2150  
  2151  // --------
  2152  
  2153  type fastpathGenV struct {
  2154  	// fastpathGenV is either a primitive (Primitive != "") or a map (MapKey != "") or a slice
  2155  	MapKey      string
  2156  	Elem        string
  2157  	Primitive   string
  2158  	Size        int
  2159  	NoCanonical bool
  2160  }
  2161  
  2162  func (x *genRunner) newFastpathGenV(t reflect.Type) (v fastpathGenV) {
  2163  	v.NoCanonical = !genFastpathCanonical
  2164  	switch t.Kind() {
  2165  	case reflect.Slice, reflect.Array:
  2166  		te := t.Elem()
  2167  		v.Elem = x.genTypeName(te)
  2168  		v.Size = int(te.Size())
  2169  	case reflect.Map:
  2170  		te := t.Elem()
  2171  		tk := t.Key()
  2172  		v.Elem = x.genTypeName(te)
  2173  		v.MapKey = x.genTypeName(tk)
  2174  		v.Size = int(te.Size() + tk.Size())
  2175  	default:
  2176  		halt.onerror(errGenUnexpectedTypeFastpath)
  2177  	}
  2178  	return
  2179  }
  2180  
  2181  func (x *fastpathGenV) MethodNamePfx(prefix string, prim bool) string {
  2182  	var name []byte
  2183  	if prefix != "" {
  2184  		name = append(name, prefix...)
  2185  	}
  2186  	if prim {
  2187  		name = append(name, genTitleCaseName(x.Primitive)...)
  2188  	} else {
  2189  		if x.MapKey == "" {
  2190  			name = append(name, "Slice"...)
  2191  		} else {
  2192  			name = append(name, "Map"...)
  2193  			name = append(name, genTitleCaseName(x.MapKey)...)
  2194  		}
  2195  		name = append(name, genTitleCaseName(x.Elem)...)
  2196  	}
  2197  	return string(name)
  2198  }
  2199  
  2200  // genImportPath returns import path of a non-predeclared named typed, or an empty string otherwise.
  2201  //
  2202  // This handles the misbehaviour that occurs when 1.5-style vendoring is enabled,
  2203  // where PkgPath returns the full path, including the vendoring pre-fix that should have been stripped.
  2204  // We strip it here.
  2205  func genImportPath(t reflect.Type) (s string) {
  2206  	s = t.PkgPath()
  2207  	if genCheckVendor {
  2208  		// HACK: always handle vendoring. It should be typically on in go 1.6, 1.7
  2209  		s = genStripVendor(s)
  2210  	}
  2211  	return
  2212  }
  2213  
  2214  // A go identifier is (letter|_)[letter|number|_]*
  2215  func genGoIdentifier(s string, checkFirstChar bool) string {
  2216  	b := make([]byte, 0, len(s))
  2217  	t := make([]byte, 4)
  2218  	var n int
  2219  	for i, r := range s {
  2220  		if checkFirstChar && i == 0 && !unicode.IsLetter(r) {
  2221  			b = append(b, '_')
  2222  		}
  2223  		// r must be unicode_letter, unicode_digit or _
  2224  		if unicode.IsLetter(r) || unicode.IsDigit(r) {
  2225  			n = utf8.EncodeRune(t, r)
  2226  			b = append(b, t[:n]...)
  2227  		} else {
  2228  			b = append(b, '_')
  2229  		}
  2230  	}
  2231  	return string(b)
  2232  }
  2233  
  2234  func genNonPtr(t reflect.Type) reflect.Type {
  2235  	for t.Kind() == reflect.Ptr {
  2236  		t = t.Elem()
  2237  	}
  2238  	return t
  2239  }
  2240  
  2241  func genFastpathUnderlying(t reflect.Type, rtid uintptr, ti *typeInfo) (tu reflect.Type, rtidu uintptr) {
  2242  	tu = t
  2243  	rtidu = rtid
  2244  	if ti.flagHasPkgPath {
  2245  		tu = ti.fastpathUnderlying
  2246  		rtidu = rt2id(tu)
  2247  	}
  2248  	return
  2249  }
  2250  
  2251  func genTitleCaseName(s string) string {
  2252  	switch s {
  2253  	case "interface{}", "interface {}":
  2254  		return "Intf"
  2255  	case "[]byte", "[]uint8", "bytes":
  2256  		return "Bytes"
  2257  	default:
  2258  		return strings.ToUpper(s[0:1]) + s[1:]
  2259  	}
  2260  }
  2261  
  2262  func genMethodNameT(t reflect.Type, tRef reflect.Type) (n string) {
  2263  	var ptrPfx string
  2264  	for t.Kind() == reflect.Ptr {
  2265  		ptrPfx += "Ptrto"
  2266  		t = t.Elem()
  2267  	}
  2268  	tstr := t.String()
  2269  	if tn := t.Name(); tn != "" {
  2270  		if tRef != nil && genImportPath(t) == genImportPath(tRef) {
  2271  			return ptrPfx + tn
  2272  		} else {
  2273  			if genQNameRegex.MatchString(tstr) {
  2274  				return ptrPfx + strings.Replace(tstr, ".", "_", 1000)
  2275  			} else {
  2276  				return ptrPfx + genCustomTypeName(tstr)
  2277  			}
  2278  		}
  2279  	}
  2280  	switch t.Kind() {
  2281  	case reflect.Map:
  2282  		return ptrPfx + "Map" + genMethodNameT(t.Key(), tRef) + genMethodNameT(t.Elem(), tRef)
  2283  	case reflect.Slice:
  2284  		return ptrPfx + "Slice" + genMethodNameT(t.Elem(), tRef)
  2285  	case reflect.Array:
  2286  		return ptrPfx + "Array" + strconv.FormatInt(int64(t.Len()), 10) + genMethodNameT(t.Elem(), tRef)
  2287  	case reflect.Chan:
  2288  		var cx string
  2289  		switch t.ChanDir() {
  2290  		case reflect.SendDir:
  2291  			cx = "ChanSend"
  2292  		case reflect.RecvDir:
  2293  			cx = "ChanRecv"
  2294  		default:
  2295  			cx = "Chan"
  2296  		}
  2297  		return ptrPfx + cx + genMethodNameT(t.Elem(), tRef)
  2298  	default:
  2299  		if t == intfTyp {
  2300  			return ptrPfx + "Interface"
  2301  		} else {
  2302  			if tRef != nil && genImportPath(t) == genImportPath(tRef) {
  2303  				if t.Name() != "" {
  2304  					return ptrPfx + t.Name()
  2305  				} else {
  2306  					return ptrPfx + genCustomTypeName(tstr)
  2307  				}
  2308  			} else {
  2309  				// best way to get the package name inclusive
  2310  				if t.Name() != "" && genQNameRegex.MatchString(tstr) {
  2311  					return ptrPfx + strings.Replace(tstr, ".", "_", 1000)
  2312  				} else {
  2313  					return ptrPfx + genCustomTypeName(tstr)
  2314  				}
  2315  			}
  2316  		}
  2317  	}
  2318  }
  2319  
  2320  // genCustomNameForType base32 encodes the t.String() value in such a way
  2321  // that it can be used within a function name.
  2322  func genCustomTypeName(tstr string) string {
  2323  	len2 := genTypenameEnc.EncodedLen(len(tstr))
  2324  	bufx := make([]byte, len2)
  2325  	genTypenameEnc.Encode(bufx, []byte(tstr))
  2326  	for i := len2 - 1; i >= 0; i-- {
  2327  		if bufx[i] == '=' {
  2328  			len2--
  2329  		} else {
  2330  			break
  2331  		}
  2332  	}
  2333  	return string(bufx[:len2])
  2334  }
  2335  
  2336  func genIsImmutable(t reflect.Type) (v bool) {
  2337  	return scalarBitset.isset(byte(t.Kind()))
  2338  }
  2339  
  2340  type genInternal struct {
  2341  	Version int
  2342  	Values  []fastpathGenV
  2343  	Formats []string
  2344  }
  2345  
  2346  func (x genInternal) FastpathLen() (l int) {
  2347  	for _, v := range x.Values {
  2348  		// if v.Primitive == "" && !(v.MapKey == "" && v.Elem == "uint8") {
  2349  		if v.Primitive == "" {
  2350  			l++
  2351  		}
  2352  	}
  2353  	return
  2354  }
  2355  
  2356  func genInternalZeroValue(s string) string {
  2357  	switch s {
  2358  	case "interface{}", "interface {}":
  2359  		return "nil"
  2360  	case "[]byte", "[]uint8", "bytes":
  2361  		return "nil"
  2362  	case "bool":
  2363  		return "false"
  2364  	case "string":
  2365  		return `""`
  2366  	default:
  2367  		return "0"
  2368  	}
  2369  }
  2370  
  2371  var genInternalNonZeroValueIdx [6]uint64
  2372  var genInternalNonZeroValueStrs = [...][6]string{
  2373  	{`"string-is-an-interface-1"`, "true", `"some-string-1"`, `[]byte("some-string-1")`, "11.1", "111"},
  2374  	{`"string-is-an-interface-2"`, "false", `"some-string-2"`, `[]byte("some-string-2")`, "22.2", "77"},
  2375  	{`"string-is-an-interface-3"`, "true", `"some-string-3"`, `[]byte("some-string-3")`, "33.3e3", "127"},
  2376  }
  2377  
  2378  // Note: last numbers must be in range: 0-127 (as they may be put into a int8, uint8, etc)
  2379  
  2380  func genInternalNonZeroValue(s string) string {
  2381  	var i int
  2382  	switch s {
  2383  	case "interface{}", "interface {}":
  2384  		i = 0
  2385  	case "bool":
  2386  		i = 1
  2387  	case "string":
  2388  		i = 2
  2389  	case "bytes", "[]byte", "[]uint8":
  2390  		i = 3
  2391  	case "float32", "float64", "float", "double", "complex", "complex64", "complex128":
  2392  		i = 4
  2393  	default:
  2394  		i = 5
  2395  	}
  2396  	genInternalNonZeroValueIdx[i]++
  2397  	idx := genInternalNonZeroValueIdx[i]
  2398  	slen := uint64(len(genInternalNonZeroValueStrs))
  2399  	return genInternalNonZeroValueStrs[idx%slen][i] // return string, to remove ambiguity
  2400  }
  2401  
  2402  // Note: used for fastpath only
  2403  func genInternalEncCommandAsString(s string, vname string) string {
  2404  	switch s {
  2405  	case "uint64":
  2406  		return "e.e.EncodeUint(" + vname + ")"
  2407  	case "uint", "uint8", "uint16", "uint32":
  2408  		return "e.e.EncodeUint(uint64(" + vname + "))"
  2409  	case "int64":
  2410  		return "e.e.EncodeInt(" + vname + ")"
  2411  	case "int", "int8", "int16", "int32":
  2412  		return "e.e.EncodeInt(int64(" + vname + "))"
  2413  	case "[]byte", "[]uint8", "bytes":
  2414  		return "e.e.EncodeStringBytesRaw(" + vname + ")"
  2415  	case "string":
  2416  		return "e.e.EncodeString(" + vname + ")"
  2417  	case "float32":
  2418  		return "e.e.EncodeFloat32(" + vname + ")"
  2419  	case "float64":
  2420  		return "e.e.EncodeFloat64(" + vname + ")"
  2421  	case "bool":
  2422  		return "e.e.EncodeBool(" + vname + ")"
  2423  	// case "symbol":
  2424  	// 	return "e.e.EncodeSymbol(" + vname + ")"
  2425  	default:
  2426  		return "e.encode(" + vname + ")"
  2427  	}
  2428  }
  2429  
  2430  // Note: used for fastpath only
  2431  func genInternalDecCommandAsString(s string, mapkey bool) string {
  2432  	switch s {
  2433  	case "uint":
  2434  		return "uint(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))"
  2435  	case "uint8":
  2436  		return "uint8(chkOvf.UintV(d.d.DecodeUint64(), 8))"
  2437  	case "uint16":
  2438  		return "uint16(chkOvf.UintV(d.d.DecodeUint64(), 16))"
  2439  	case "uint32":
  2440  		return "uint32(chkOvf.UintV(d.d.DecodeUint64(), 32))"
  2441  	case "uint64":
  2442  		return "d.d.DecodeUint64()"
  2443  	case "uintptr":
  2444  		return "uintptr(chkOvf.UintV(d.d.DecodeUint64(), uintBitsize))"
  2445  	case "int":
  2446  		return "int(chkOvf.IntV(d.d.DecodeInt64(), intBitsize))"
  2447  	case "int8":
  2448  		return "int8(chkOvf.IntV(d.d.DecodeInt64(), 8))"
  2449  	case "int16":
  2450  		return "int16(chkOvf.IntV(d.d.DecodeInt64(), 16))"
  2451  	case "int32":
  2452  		return "int32(chkOvf.IntV(d.d.DecodeInt64(), 32))"
  2453  	case "int64":
  2454  		return "d.d.DecodeInt64()"
  2455  
  2456  	case "string":
  2457  		// if mapkey {
  2458  		// 	return "d.stringZC(d.d.DecodeStringAsBytes())"
  2459  		// }
  2460  		// return "string(d.d.DecodeStringAsBytes())"
  2461  		return "d.stringZC(d.d.DecodeStringAsBytes())"
  2462  	case "[]byte", "[]uint8", "bytes":
  2463  		return "d.d.DecodeBytes([]byte{})"
  2464  	case "float32":
  2465  		return "float32(d.decodeFloat32())"
  2466  	case "float64":
  2467  		return "d.d.DecodeFloat64()"
  2468  	case "complex64":
  2469  		return "complex(d.decodeFloat32(), 0)"
  2470  	case "complex128":
  2471  		return "complex(d.d.DecodeFloat64(), 0)"
  2472  	case "bool":
  2473  		return "d.d.DecodeBool()"
  2474  	default:
  2475  		halt.onerror(errors.New("gen internal: unknown type for decode: " + s))
  2476  	}
  2477  	return ""
  2478  }
  2479  
  2480  // func genInternalSortType(s string, elem bool) string {
  2481  // 	for _, v := range [...]string{
  2482  // 		"int",
  2483  // 		"uint",
  2484  // 		"float",
  2485  // 		"bool",
  2486  // 		"string",
  2487  // 		"bytes", "[]uint8", "[]byte",
  2488  // 	} {
  2489  // 		if v == "[]byte" || v == "[]uint8" {
  2490  // 			v = "bytes"
  2491  // 		}
  2492  // 		if strings.HasPrefix(s, v) {
  2493  // 			if v == "int" || v == "uint" || v == "float" {
  2494  // 				v += "64"
  2495  // 			}
  2496  // 			if elem {
  2497  // 				return v
  2498  // 			}
  2499  // 			return v + "Slice"
  2500  // 		}
  2501  // 	}
  2502  // 	halt.onerror(errors.New("sorttype: unexpected type: " + s))
  2503  // }
  2504  
  2505  func genInternalSortType(s string, elem bool) string {
  2506  	if elem {
  2507  		return s
  2508  	}
  2509  	return s + "Slice"
  2510  }
  2511  
  2512  // MARKER: keep in sync with codecgen/gen.go
  2513  func genStripVendor(s string) string {
  2514  	// HACK: Misbehaviour occurs in go 1.5. May have to re-visit this later.
  2515  	// if s contains /vendor/ OR startsWith vendor/, then return everything after it.
  2516  	const vendorStart = "vendor/"
  2517  	const vendorInline = "/vendor/"
  2518  	if i := strings.LastIndex(s, vendorInline); i >= 0 {
  2519  		s = s[i+len(vendorInline):]
  2520  	} else if strings.HasPrefix(s, vendorStart) {
  2521  		s = s[len(vendorStart):]
  2522  	}
  2523  	return s
  2524  }
  2525  
  2526  // var genInternalMu sync.Mutex
  2527  var genInternalV = genInternal{Version: genVersion}
  2528  var genInternalTmplFuncs template.FuncMap
  2529  var genInternalOnce sync.Once
  2530  
  2531  func genInternalInit() {
  2532  	wordSizeBytes := int(intBitsize) / 8
  2533  
  2534  	typesizes := map[string]int{
  2535  		"interface{}": 2 * wordSizeBytes,
  2536  		"string":      2 * wordSizeBytes,
  2537  		"[]byte":      3 * wordSizeBytes,
  2538  		"uint":        1 * wordSizeBytes,
  2539  		"uint8":       1,
  2540  		"uint16":      2,
  2541  		"uint32":      4,
  2542  		"uint64":      8,
  2543  		"uintptr":     1 * wordSizeBytes,
  2544  		"int":         1 * wordSizeBytes,
  2545  		"int8":        1,
  2546  		"int16":       2,
  2547  		"int32":       4,
  2548  		"int64":       8,
  2549  		"float32":     4,
  2550  		"float64":     8,
  2551  		"complex64":   8,
  2552  		"complex128":  16,
  2553  		"bool":        1,
  2554  	}
  2555  
  2556  	// keep as slice, so it is in specific iteration order.
  2557  	// Initial order was uint64, string, interface{}, int, int64, ...
  2558  
  2559  	var types = [...]string{
  2560  		"interface{}",
  2561  		"string",
  2562  		"[]byte",
  2563  		"float32",
  2564  		"float64",
  2565  		"uint",
  2566  		"uint8",
  2567  		"uint16",
  2568  		"uint32",
  2569  		"uint64",
  2570  		"uintptr",
  2571  		"int",
  2572  		"int8",
  2573  		"int16",
  2574  		"int32",
  2575  		"int64",
  2576  		"bool",
  2577  	}
  2578  
  2579  	var primitivetypes, slicetypes, mapkeytypes, mapvaltypes []string
  2580  
  2581  	primitivetypes = types[:]
  2582  	slicetypes = types[:]
  2583  	mapkeytypes = types[:]
  2584  	mapvaltypes = types[:]
  2585  
  2586  	if genFastpathTrimTypes {
  2587  		// Note: we only create fast-paths for commonly used types.
  2588  		// Consequently, things like int8, uint16, uint, etc are commented out.
  2589  
  2590  		slicetypes = genInternalFastpathSliceTypes()
  2591  		mapkeytypes = genInternalFastpathMapKeyTypes()
  2592  		mapvaltypes = genInternalFastpathMapValueTypes()
  2593  	}
  2594  
  2595  	// var mapkeytypes [len(&types) - 1]string // skip bool
  2596  	// copy(mapkeytypes[:], types[:])
  2597  
  2598  	// var mb []byte
  2599  	// mb = append(mb, '|')
  2600  	// for _, s := range mapkeytypes {
  2601  	// 	mb = append(mb, s...)
  2602  	// 	mb = append(mb, '|')
  2603  	// }
  2604  	// var mapkeytypestr = string(mb)
  2605  
  2606  	var gt = genInternal{Version: genVersion, Formats: genFormats}
  2607  
  2608  	// For each slice or map type, there must be a (symmetrical) Encode and Decode fast-path function
  2609  
  2610  	for _, s := range primitivetypes {
  2611  		gt.Values = append(gt.Values,
  2612  			fastpathGenV{Primitive: s, Size: typesizes[s], NoCanonical: !genFastpathCanonical})
  2613  	}
  2614  	for _, s := range slicetypes {
  2615  		// if s != "uint8" { // do not generate fast path for slice of bytes. Treat specially already.
  2616  		// 	gt.Values = append(gt.Values, fastpathGenV{Elem: s, Size: typesizes[s]})
  2617  		// }
  2618  		gt.Values = append(gt.Values,
  2619  			fastpathGenV{Elem: s, Size: typesizes[s], NoCanonical: !genFastpathCanonical})
  2620  	}
  2621  	for _, s := range mapkeytypes {
  2622  		// if _, ok := typesizes[s]; !ok {
  2623  		// if strings.Contains(mapkeytypestr, "|"+s+"|") {
  2624  		// 	gt.Values = append(gt.Values, fastpathGenV{MapKey: s, Elem: s, Size: 2 * typesizes[s]})
  2625  		// }
  2626  		for _, ms := range mapvaltypes {
  2627  			gt.Values = append(gt.Values,
  2628  				fastpathGenV{MapKey: s, Elem: ms, Size: typesizes[s] + typesizes[ms], NoCanonical: !genFastpathCanonical})
  2629  		}
  2630  	}
  2631  
  2632  	funcs := make(template.FuncMap)
  2633  	// funcs["haspfx"] = strings.HasPrefix
  2634  	funcs["encmd"] = genInternalEncCommandAsString
  2635  	funcs["decmd"] = genInternalDecCommandAsString
  2636  	funcs["zerocmd"] = genInternalZeroValue
  2637  	funcs["nonzerocmd"] = genInternalNonZeroValue
  2638  	funcs["hasprefix"] = strings.HasPrefix
  2639  	funcs["sorttype"] = genInternalSortType
  2640  
  2641  	genInternalV = gt
  2642  	genInternalTmplFuncs = funcs
  2643  }
  2644  
  2645  // genInternalGoFile is used to generate source files from templates.
  2646  func genInternalGoFile(r io.Reader, w io.Writer) (err error) {
  2647  	genInternalOnce.Do(genInternalInit)
  2648  
  2649  	gt := genInternalV
  2650  
  2651  	t := template.New("").Funcs(genInternalTmplFuncs)
  2652  
  2653  	tmplstr, err := ioutil.ReadAll(r)
  2654  	if err != nil {
  2655  		return
  2656  	}
  2657  
  2658  	if t, err = t.Parse(string(tmplstr)); err != nil {
  2659  		return
  2660  	}
  2661  
  2662  	var out bytes.Buffer
  2663  	err = t.Execute(&out, gt)
  2664  	if err != nil {
  2665  		return
  2666  	}
  2667  
  2668  	bout, err := format.Source(out.Bytes())
  2669  	if err != nil {
  2670  		w.Write(out.Bytes()) // write out if error, so we can still see.
  2671  		// w.Write(bout) // write out if error, as much as possible, so we can still see.
  2672  		return
  2673  	}
  2674  	w.Write(bout)
  2675  	return
  2676  }
  2677  
  2678  func genInternalFastpathSliceTypes() []string {
  2679  	return []string{
  2680  		"interface{}",
  2681  		"string",
  2682  		"[]byte",
  2683  		"float32",
  2684  		"float64",
  2685  		// "uint",
  2686  		// "uint8", // no need for fastpath of []uint8, as it is handled specially
  2687  		"uint8", // keep fast-path, so it doesn't have to go through reflection
  2688  		// "uint16",
  2689  		// "uint32",
  2690  		"uint64",
  2691  		// "uintptr",
  2692  		"int",
  2693  		// "int8",
  2694  		// "int16",
  2695  		"int32", // rune
  2696  		"int64",
  2697  		"bool",
  2698  	}
  2699  }
  2700  
  2701  func genInternalFastpathMapKeyTypes() []string {
  2702  	return []string{
  2703  		// "interface{}",
  2704  		"string",
  2705  		// "[]byte",
  2706  		// "float32",
  2707  		// "float64",
  2708  		// "uint",
  2709  		"uint8", // byte
  2710  		// "uint16",
  2711  		// "uint32",
  2712  		"uint64", // used for keys
  2713  		// "uintptr",
  2714  		"int", // default number key
  2715  		// "int8",
  2716  		// "int16",
  2717  		"int32", // rune
  2718  		// "int64",
  2719  		// "bool",
  2720  	}
  2721  }
  2722  
  2723  func genInternalFastpathMapValueTypes() []string {
  2724  	return []string{
  2725  		"interface{}",
  2726  		"string",
  2727  		"[]byte",
  2728  		// "uint",
  2729  		"uint8", // byte
  2730  		// "uint16",
  2731  		// "uint32",
  2732  		"uint64", // used for keys, etc
  2733  		// "uintptr",
  2734  		"int", // default number
  2735  		//"int8",
  2736  		// "int16",
  2737  		"int32", // rune (mostly used for unicode)
  2738  		// "int64",
  2739  		// "float32",
  2740  		"float64",
  2741  		"bool",
  2742  	}
  2743  }
  2744  
  2745  // sort-slice ...
  2746  // generates sort implementations for
  2747  // various slice types and combination slice+reflect.Value types.
  2748  //
  2749  // The combination slice+reflect.Value types are used
  2750  // during canonical encode, and the others are used during fast-path
  2751  // encoding of map keys.
  2752  
  2753  // genInternalSortableTypes returns the types
  2754  // that are used for fast-path canonical's encoding of maps.
  2755  //
  2756  // For now, we only support the highest sizes for
  2757  // int64, uint64, float64, bool, string, bytes.
  2758  func genInternalSortableTypes() []string {
  2759  	return genInternalFastpathMapKeyTypes()
  2760  }
  2761  
  2762  // genInternalSortablePlusTypes returns the types
  2763  // that are used for reflection-based canonical's encoding of maps.
  2764  //
  2765  // For now, we only support the highest sizes for
  2766  // int64, uint64, float64, string, bytes.
  2767  func genInternalSortablePlusTypes() []string {
  2768  	return []string{
  2769  		"string",
  2770  		"float64",
  2771  		"uint64",
  2772  		// "uintptr",
  2773  		"int64",
  2774  		// "bool",
  2775  		"time",
  2776  		"bytes",
  2777  	}
  2778  }
  2779  
  2780  func genTypeForShortName(s string) string {
  2781  	switch s {
  2782  	case "time":
  2783  		return "time.Time"
  2784  	case "bytes":
  2785  		return "[]byte"
  2786  	}
  2787  	return s
  2788  }
  2789  
  2790  func genArgs(args ...interface{}) map[string]interface{} {
  2791  	m := make(map[string]interface{}, len(args)/2)
  2792  	for i := 0; i < len(args); {
  2793  		m[args[i].(string)] = args[i+1]
  2794  		i += 2
  2795  	}
  2796  	return m
  2797  }
  2798  
  2799  func genEndsWith(s0 string, sn ...string) bool {
  2800  	for _, s := range sn {
  2801  		if strings.HasSuffix(s0, s) {
  2802  			return true
  2803  		}
  2804  	}
  2805  	return false
  2806  }
  2807  
  2808  func genCheckErr(err error) {
  2809  	halt.onerror(err)
  2810  }
  2811  
  2812  func genRunSortTmpl2Go(fnameIn, fnameOut string) {
  2813  	var err error
  2814  
  2815  	funcs := make(template.FuncMap)
  2816  	funcs["sortables"] = genInternalSortableTypes
  2817  	funcs["sortablesplus"] = genInternalSortablePlusTypes
  2818  	funcs["tshort"] = genTypeForShortName
  2819  	funcs["endswith"] = genEndsWith
  2820  	funcs["args"] = genArgs
  2821  
  2822  	t := template.New("").Funcs(funcs)
  2823  	fin, err := os.Open(fnameIn)
  2824  	genCheckErr(err)
  2825  	defer fin.Close()
  2826  	fout, err := os.Create(fnameOut)
  2827  	genCheckErr(err)
  2828  	defer fout.Close()
  2829  	tmplstr, err := ioutil.ReadAll(fin)
  2830  	genCheckErr(err)
  2831  	t, err = t.Parse(string(tmplstr))
  2832  	genCheckErr(err)
  2833  	var out bytes.Buffer
  2834  	err = t.Execute(&out, 0)
  2835  	genCheckErr(err)
  2836  	bout, err := format.Source(out.Bytes())
  2837  	if err != nil {
  2838  		fout.Write(out.Bytes()) // write out if error, so we can still see.
  2839  	}
  2840  	genCheckErr(err)
  2841  	// write out if error, as much as possible, so we can still see.
  2842  	_, err = fout.Write(bout)
  2843  	genCheckErr(err)
  2844  }
  2845  
  2846  func genRunTmpl2Go(fnameIn, fnameOut string) {
  2847  	// println("____ " + fnameIn + " --> " + fnameOut + " ______")
  2848  	fin, err := os.Open(fnameIn)
  2849  	genCheckErr(err)
  2850  	defer fin.Close()
  2851  	fout, err := os.Create(fnameOut)
  2852  	genCheckErr(err)
  2853  	defer fout.Close()
  2854  	err = genInternalGoFile(fin, fout)
  2855  	genCheckErr(err)
  2856  }
  2857  
  2858  // --- some methods here for other types, which are only used in codecgen
  2859  
  2860  // depth returns number of valid nodes in the hierachy
  2861  func (path *structFieldInfoPathNode) root() *structFieldInfoPathNode {
  2862  TOP:
  2863  	if path.parent != nil {
  2864  		path = path.parent
  2865  		goto TOP
  2866  	}
  2867  	return path
  2868  }
  2869  
  2870  func (path *structFieldInfoPathNode) fullpath() (p []*structFieldInfoPathNode) {
  2871  	// this method is mostly called by a command-line tool - it's not optimized, and that's ok.
  2872  	// it shouldn't be used in typical runtime use - as it does unnecessary allocation.
  2873  	d := path.depth()
  2874  	p = make([]*structFieldInfoPathNode, d)
  2875  	for d--; d >= 0; d-- {
  2876  		p[d] = path
  2877  		path = path.parent
  2878  	}
  2879  	return
  2880  }
  2881  

View as plain text