text: package yaml
  
  import (
  	"encoding"
  	"fmt"
  	"io"
  	"reflect"
  	"regexp"
  	"sort"
  	"strconv"
  	"strings"
  	"time"
  	"unicode/utf8"
  )
  
  // jsonNumber is the interface of the encoding/json.Number datatype.
  // Repeating the interface here avoids a dependency on encoding/json, and also
  // supports other libraries like jsoniter, which use a similar datatype with
  // the same interface. Detecting this interface is useful when dealing with
  // structures containing json.Number, which is a string under the hood. The
  // encoder should prefer the use of Int64(), Float64() and string(), in that
  // order, when encoding this type.
  type jsonNumber interface {
  	Float64() (float64, error)
  	Int64() (int64, error)
  	String() string
  }
  
  type encoder struct {
  	emitter yaml_emitter_t
  	event   yaml_event_t
  	out     []byte
  	flow    bool
  	// doneInit holds whether the initial stream_start_event has been
  	// emitted.
  	doneInit bool
  }
  
  func newEncoder() *encoder {
  	e := &encoder{}
  	yaml_emitter_initialize(&e.emitter)
  	yaml_emitter_set_output_string(&e.emitter, &e.out)
  	yaml_emitter_set_unicode(&e.emitter, true)
  	return e
  }
  
  func newEncoderWithWriter(w io.Writer) *encoder {
  	e := &encoder{}
  	yaml_emitter_initialize(&e.emitter)
  	yaml_emitter_set_output_writer(&e.emitter, w)
  	yaml_emitter_set_unicode(&e.emitter, true)
  	return e
  }
  
  func (e *encoder) init() {
  	if e.doneInit {
  		return
  	}
  	yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
  	e.emit()
  	e.doneInit = true
  }
  
  func (e *encoder) finish() {
  	e.emitter.open_ended = false
  	yaml_stream_end_event_initialize(&e.event)
  	e.emit()
  }
  
  func (e *encoder) destroy() {
  	yaml_emitter_delete(&e.emitter)
  }
  
  func (e *encoder) emit() {
  	// This will internally delete the e.event value.
  	e.must(yaml_emitter_emit(&e.emitter, &e.event))
  }
  
  func (e *encoder) must(ok bool) {
  	if !ok {
  		msg := e.emitter.problem
  		if msg == "" {
  			msg = "unknown problem generating YAML content"
  		}
  		failf("%s", msg)
  	}
  }
  
  func (e *encoder) marshalDoc(tag string, in reflect.Value) {
  	e.init()
  	yaml_document_start_event_initialize(&e.event, nil, nil, true)
  	e.emit()
  	e.marshal(tag, in)
  	yaml_document_end_event_initialize(&e.event, true)
  	e.emit()
  }
  
  func (e *encoder) marshal(tag string, in reflect.Value) {
  	if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
  		e.nilv()
  		return
  	}
  	iface := in.Interface()
  	switch m := iface.(type) {
  	case jsonNumber:
  		integer, err := m.Int64()
  		if err == nil {
  			// In this case the json.Number is a valid int64
  			in = reflect.ValueOf(integer)
  			break
  		}
  		float, err := m.Float64()
  		if err == nil {
  			// In this case the json.Number is a valid float64
  			in = reflect.ValueOf(float)
  			break
  		}
  		// fallback case - no number could be obtained
  		in = reflect.ValueOf(m.String())
  	case time.Time, *time.Time:
  		// Although time.Time implements TextMarshaler,
  		// we don't want to treat it as a string for YAML
  		// purposes because YAML has special support for
  		// timestamps.
  	case Marshaler:
  		v, err := m.MarshalYAML()
  		if err != nil {
  			fail(err)
  		}
  		if v == nil {
  			e.nilv()
  			return
  		}
  		in = reflect.ValueOf(v)
  	case encoding.TextMarshaler:
  		text, err := m.MarshalText()
  		if err != nil {
  			fail(err)
  		}
  		in = reflect.ValueOf(string(text))
  	case nil:
  		e.nilv()
  		return
  	}
  	switch in.Kind() {
  	case reflect.Interface:
  		e.marshal(tag, in.Elem())
  	case reflect.Map:
  		e.mapv(tag, in)
  	case reflect.Ptr:
  		if in.Type() == ptrTimeType {
  			e.timev(tag, in.Elem())
  		} else {
  			e.marshal(tag, in.Elem())
  		}
  	case reflect.Struct:
  		if in.Type() == timeType {
  			e.timev(tag, in)
  		} else {
  			e.structv(tag, in)
  		}
  	case reflect.Slice, reflect.Array:
  		if in.Type().Elem() == mapItemType {
  			e.itemsv(tag, in)
  		} else {
  			e.slicev(tag, in)
  		}
  	case reflect.String:
  		e.stringv(tag, in)
  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  		if in.Type() == durationType {
  			e.stringv(tag, reflect.ValueOf(iface.(time.Duration).String()))
  		} else {
  			e.intv(tag, in)
  		}
  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  		e.uintv(tag, in)
  	case reflect.Float32, reflect.Float64:
  		e.floatv(tag, in)
  	case reflect.Bool:
  		e.boolv(tag, in)
  	default:
  		panic("cannot marshal type: " + in.Type().String())
  	}
  }
  
  func (e *encoder) mapv(tag string, in reflect.Value) {
  	e.mappingv(tag, func() {
  		keys := keyList(in.MapKeys())
  		sort.Sort(keys)
  		for _, k := range keys {
  			e.marshal("", k)
  			e.marshal("", in.MapIndex(k))
  		}
  	})
  }
  
  func (e *encoder) itemsv(tag string, in reflect.Value) {
  	e.mappingv(tag, func() {
  		slice := in.Convert(reflect.TypeOf([]MapItem{})).Interface().([]MapItem)
  		for _, item := range slice {
  			e.marshal("", reflect.ValueOf(item.Key))
  			e.marshal("", reflect.ValueOf(item.Value))
  		}
  	})
  }
  
  func (e *encoder) structv(tag string, in reflect.Value) {
  	sinfo, err := getStructInfo(in.Type())
  	if err != nil {
  		panic(err)
  	}
  	e.mappingv(tag, func() {
  		for _, info := range sinfo.FieldsList {
  			var value reflect.Value
  			if info.Inline == nil {
  				value = in.Field(info.Num)
  			} else {
  				value = in.FieldByIndex(info.Inline)
  			}
  			if info.OmitEmpty && isZero(value) {
  				continue
  			}
  			e.marshal("", reflect.ValueOf(info.Key))
  			e.flow = info.Flow
  			e.marshal("", value)
  		}
  		if sinfo.InlineMap >= 0 {
  			m := in.Field(sinfo.InlineMap)
  			if m.Len() > 0 {
  				e.flow = false
  				keys := keyList(m.MapKeys())
  				sort.Sort(keys)
  				for _, k := range keys {
  					if _, found := sinfo.FieldsMap[k.String()]; found {
  						panic(fmt.Sprintf("Can't have key %q in inlined map; conflicts with struct field", k.String()))
  					}
  					e.marshal("", k)
  					e.flow = false
  					e.marshal("", m.MapIndex(k))
  				}
  			}
  		}
  	})
  }
  
  func (e *encoder) mappingv(tag string, f func()) {
  	implicit := tag == ""
  	style := yaml_BLOCK_MAPPING_STYLE
  	if e.flow {
  		e.flow = false
  		style = yaml_FLOW_MAPPING_STYLE
  	}
  	yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
  	e.emit()
  	f()
  	yaml_mapping_end_event_initialize(&e.event)
  	e.emit()
  }
  
  func (e *encoder) slicev(tag string, in reflect.Value) {
  	implicit := tag == ""
  	style := yaml_BLOCK_SEQUENCE_STYLE
  	if e.flow {
  		e.flow = false
  		style = yaml_FLOW_SEQUENCE_STYLE
  	}
  	e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
  	e.emit()
  	n := in.Len()
  	for i := 0; i < n; i++ {
  		e.marshal("", in.Index(i))
  	}
  	e.must(yaml_sequence_end_event_initialize(&e.event))
  	e.emit()
  }
  
  // isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
  //
  // The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
  // in YAML 1.2 and by this package, but these should be marshalled quoted for
  // the time being for compatibility with other parsers.
  func isBase60Float(s string) (result bool) {
  	// Fast path.
  	if s == "" {
  		return false
  	}
  	c := s[0]
  	if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
  		return false
  	}
  	// Do the full match.
  	return base60float.MatchString(s)
  }
  
  // From http://yaml.org/type/float.html, except the regular expression there
  // is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
  var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
  
  func (e *encoder) stringv(tag string, in reflect.Value) {
  	var style yaml_scalar_style_t
  	s := in.String()
  	canUsePlain := true
  	switch {
  	case !utf8.ValidString(s):
  		if tag == yaml_BINARY_TAG {
  			failf("explicitly tagged !!binary data must be base64-encoded")
  		}
  		if tag != "" {
  			failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
  		}
  		// It can't be encoded directly as YAML so use a binary tag
  		// and encode it as base64.
  		tag = yaml_BINARY_TAG
  		s = encodeBase64(s)
  	case tag == "":
  		// Check to see if it would resolve to a specific
  		// tag when encoded unquoted. If it doesn't,
  		// there's no need to quote it.
  		rtag, _ := resolve("", s)
  		canUsePlain = rtag == yaml_STR_TAG && !isBase60Float(s)
  	}
  	// Note: it's possible for user code to emit invalid YAML
  	// if they explicitly specify a tag and a string containing
  	// text that's incompatible with that tag.
  	switch {
  	case strings.Contains(s, "\n"):
  		style = yaml_LITERAL_SCALAR_STYLE
  	case canUsePlain:
  		style = yaml_PLAIN_SCALAR_STYLE
  	default:
  		style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
  	}
  	e.emitScalar(s, "", tag, style)
  }
  
  func (e *encoder) boolv(tag string, in reflect.Value) {
  	var s string
  	if in.Bool() {
  		s = "true"
  	} else {
  		s = "false"
  	}
  	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
  }
  
  func (e *encoder) intv(tag string, in reflect.Value) {
  	s := strconv.FormatInt(in.Int(), 10)
  	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
  }
  
  func (e *encoder) uintv(tag string, in reflect.Value) {
  	s := strconv.FormatUint(in.Uint(), 10)
  	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
  }
  
  func (e *encoder) timev(tag string, in reflect.Value) {
  	t := in.Interface().(time.Time)
  	s := t.Format(time.RFC3339Nano)
  	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
  }
  
  func (e *encoder) floatv(tag string, in reflect.Value) {
  	// Issue #352: When formatting, use the precision of the underlying value
  	precision := 64
  	if in.Kind() == reflect.Float32 {
  		precision = 32
  	}
  
  	s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
  	switch s {
  	case "+Inf":
  		s = ".inf"
  	case "-Inf":
  		s = "-.inf"
  	case "NaN":
  		s = ".nan"
  	}
  	e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE)
  }
  
  func (e *encoder) nilv() {
  	e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE)
  }
  
  func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t) {
  	implicit := tag == ""
  	e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
  	e.emit()
  }
  