1
2
3
4
5 package xml
6
7 import (
8 "bufio"
9 "bytes"
10 "encoding"
11 "fmt"
12 "io"
13 "reflect"
14 "strconv"
15 "strings"
16 )
17
18 const (
19
20
21
22 Header = `<?xml version="1.0" encoding="UTF-8"?>` + "\n"
23 )
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75 func Marshal(v interface{}) ([]byte, error) {
76 var b bytes.Buffer
77 if err := NewEncoder(&b).Encode(v); err != nil {
78 return nil, err
79 }
80 return b.Bytes(), nil
81 }
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99 type Marshaler interface {
100 MarshalXML(e *Encoder, start StartElement) error
101 }
102
103
104
105
106
107
108
109
110
111
112
113
114 type MarshalerAttr interface {
115 MarshalXMLAttr(name Name) (Attr, error)
116 }
117
118
119
120
121 func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
122 var b bytes.Buffer
123 enc := NewEncoder(&b)
124 enc.Indent(prefix, indent)
125 if err := enc.Encode(v); err != nil {
126 return nil, err
127 }
128 return b.Bytes(), nil
129 }
130
131
132 type Encoder struct {
133 p printer
134 }
135
136
137 func NewEncoder(w io.Writer) *Encoder {
138 e := &Encoder{printer{Writer: bufio.NewWriter(w)}}
139 e.p.encoder = e
140 return e
141 }
142
143
144
145
146 func (enc *Encoder) Indent(prefix, indent string) {
147 enc.p.prefix = prefix
148 enc.p.indent = indent
149 }
150
151
152
153
154
155
156
157 func (enc *Encoder) Encode(v interface{}) error {
158 err := enc.p.marshalValue(reflect.ValueOf(v), nil, nil)
159 if err != nil {
160 return err
161 }
162 return enc.p.Flush()
163 }
164
165
166
167
168
169
170
171
172 func (enc *Encoder) EncodeElement(v interface{}, start StartElement) error {
173 err := enc.p.marshalValue(reflect.ValueOf(v), nil, &start)
174 if err != nil {
175 return err
176 }
177 return enc.p.Flush()
178 }
179
180 var (
181 begComment = []byte("<!--")
182 endComment = []byte("-->")
183 endProcInst = []byte("?>")
184 )
185
186
187
188
189
190
191
192
193
194
195
196
197
198 func (enc *Encoder) EncodeToken(t Token) error {
199
200 p := &enc.p
201 switch t := t.(type) {
202 case StartElement:
203 if err := p.writeStart(&t); err != nil {
204 return err
205 }
206 case EndElement:
207 if err := p.writeEnd(t.Name); err != nil {
208 return err
209 }
210 case CharData:
211 escapeText(p, t, false)
212 case Comment:
213 if bytes.Contains(t, endComment) {
214 return fmt.Errorf("xml: EncodeToken of Comment containing --> marker")
215 }
216 p.WriteString("<!--")
217 p.Write(t)
218 p.WriteString("-->")
219 return p.cachedWriteError()
220 case ProcInst:
221
222
223 if t.Target == "xml" && p.Buffered() != 0 {
224 return fmt.Errorf("xml: EncodeToken of ProcInst xml target only valid for xml declaration, first token encoded")
225 }
226 if !isNameString(t.Target) {
227 return fmt.Errorf("xml: EncodeToken of ProcInst with invalid Target")
228 }
229 if bytes.Contains(t.Inst, endProcInst) {
230 return fmt.Errorf("xml: EncodeToken of ProcInst containing ?> marker")
231 }
232 p.WriteString("<?")
233 p.WriteString(t.Target)
234 if len(t.Inst) > 0 {
235 p.WriteByte(' ')
236 p.Write(t.Inst)
237 }
238 p.WriteString("?>")
239 case Directive:
240 if !isValidDirective(t) {
241 return fmt.Errorf("xml: EncodeToken of Directive containing wrong < or > markers")
242 }
243 p.WriteString("<!")
244 p.Write(t)
245 p.WriteString(">")
246 default:
247 return fmt.Errorf("xml: EncodeToken of invalid token type")
248
249 }
250 return p.cachedWriteError()
251 }
252
253
254
255 func isValidDirective(dir Directive) bool {
256 var (
257 depth int
258 inquote uint8
259 incomment bool
260 )
261 for i, c := range dir {
262 switch {
263 case incomment:
264 if c == '>' {
265 if n := 1 + i - len(endComment); n >= 0 && bytes.Equal(dir[n:i+1], endComment) {
266 incomment = false
267 }
268 }
269
270 case inquote != 0:
271 if c == inquote {
272 inquote = 0
273 }
274
275 case c == '\'' || c == '"':
276 inquote = c
277 case c == '<':
278 if i+len(begComment) < len(dir) && bytes.Equal(dir[i:i+len(begComment)], begComment) {
279 incomment = true
280 } else {
281 depth++
282 }
283 case c == '>':
284 if depth == 0 {
285 return false
286 }
287 depth--
288 }
289 }
290 return depth == 0 && inquote == 0 && !incomment
291 }
292
293
294
295 func (enc *Encoder) Flush() error {
296 return enc.p.Flush()
297 }
298
299 type printer struct {
300 *bufio.Writer
301 encoder *Encoder
302 seq int
303 indent string
304 prefix string
305 depth int
306 indentedIn bool
307 putNewline bool
308 attrNS map[string]string
309 attrPrefix map[string]string
310 prefixes []string
311 tags []Name
312 }
313
314
315
316 func (p *printer) createAttrPrefix(url string) string {
317 if prefix := p.attrPrefix[url]; prefix != "" {
318 return prefix
319 }
320
321
322
323
324
325 if url == xmlURL {
326 return xmlPrefix
327 }
328
329
330 if p.attrPrefix == nil {
331 p.attrPrefix = make(map[string]string)
332 p.attrNS = make(map[string]string)
333 }
334
335
336
337 prefix := strings.TrimRight(url, "/")
338 if i := strings.LastIndex(prefix, "/"); i >= 0 {
339 prefix = prefix[i+1:]
340 }
341 if prefix == "" || !isName([]byte(prefix)) || strings.Contains(prefix, ":") {
342 prefix = "_"
343 }
344 if strings.HasPrefix(prefix, "xml") {
345
346 prefix = "_" + prefix
347 }
348 if p.attrNS[prefix] != "" {
349
350 for p.seq++; ; p.seq++ {
351 if id := prefix + "_" + strconv.Itoa(p.seq); p.attrNS[id] == "" {
352 prefix = id
353 break
354 }
355 }
356 }
357
358 p.attrPrefix[url] = prefix
359 p.attrNS[prefix] = url
360
361 p.WriteString(`xmlns:`)
362 p.WriteString(prefix)
363 p.WriteString(`="`)
364 EscapeText(p, []byte(url))
365 p.WriteString(`" `)
366
367 p.prefixes = append(p.prefixes, prefix)
368
369 return prefix
370 }
371
372
373 func (p *printer) deleteAttrPrefix(prefix string) {
374 delete(p.attrPrefix, p.attrNS[prefix])
375 delete(p.attrNS, prefix)
376 }
377
378 func (p *printer) markPrefix() {
379 p.prefixes = append(p.prefixes, "")
380 }
381
382 func (p *printer) popPrefix() {
383 for len(p.prefixes) > 0 {
384 prefix := p.prefixes[len(p.prefixes)-1]
385 p.prefixes = p.prefixes[:len(p.prefixes)-1]
386 if prefix == "" {
387 break
388 }
389 p.deleteAttrPrefix(prefix)
390 }
391 }
392
393 var (
394 marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
395 marshalerAttrType = reflect.TypeOf((*MarshalerAttr)(nil)).Elem()
396 textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
397 )
398
399
400
401 func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplate *StartElement) error {
402 if startTemplate != nil && startTemplate.Name.Local == "" {
403 return fmt.Errorf("xml: EncodeElement of StartElement with missing name")
404 }
405
406 if !val.IsValid() {
407 return nil
408 }
409 if finfo != nil && finfo.flags&fOmitEmpty != 0 && isEmptyValue(val) {
410 return nil
411 }
412
413
414
415
416 for val.Kind() == reflect.Interface || val.Kind() == reflect.Ptr {
417 if val.IsNil() {
418 return nil
419 }
420 val = val.Elem()
421 }
422
423 kind := val.Kind()
424 typ := val.Type()
425
426
427 if val.CanInterface() && typ.Implements(marshalerType) {
428 return p.marshalInterface(val.Interface().(Marshaler), defaultStart(typ, finfo, startTemplate))
429 }
430 if val.CanAddr() {
431 pv := val.Addr()
432 if pv.CanInterface() && pv.Type().Implements(marshalerType) {
433 return p.marshalInterface(pv.Interface().(Marshaler), defaultStart(pv.Type(), finfo, startTemplate))
434 }
435 }
436
437
438 if val.CanInterface() && typ.Implements(textMarshalerType) {
439 return p.marshalTextInterface(val.Interface().(encoding.TextMarshaler), defaultStart(typ, finfo, startTemplate))
440 }
441 if val.CanAddr() {
442 pv := val.Addr()
443 if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
444 return p.marshalTextInterface(pv.Interface().(encoding.TextMarshaler), defaultStart(pv.Type(), finfo, startTemplate))
445 }
446 }
447
448
449 if (kind == reflect.Slice || kind == reflect.Array) && typ.Elem().Kind() != reflect.Uint8 {
450 for i, n := 0, val.Len(); i < n; i++ {
451 if err := p.marshalValue(val.Index(i), finfo, startTemplate); err != nil {
452 return err
453 }
454 }
455 return nil
456 }
457
458 tinfo, err := getTypeInfo(typ)
459 if err != nil {
460 return err
461 }
462
463
464
465
466
467
468
469 var start StartElement
470
471 if startTemplate != nil {
472 start.Name = startTemplate.Name
473 start.Attr = append(start.Attr, startTemplate.Attr...)
474 } else if tinfo.xmlname != nil {
475 xmlname := tinfo.xmlname
476 if xmlname.name != "" {
477 start.Name.Space, start.Name.Local = xmlname.xmlns, xmlname.name
478 } else if v, ok := xmlname.value(val).Interface().(Name); ok && v.Local != "" {
479 start.Name = v
480 }
481 }
482 if start.Name.Local == "" && finfo != nil {
483 start.Name.Space, start.Name.Local = finfo.xmlns, finfo.name
484 }
485 if start.Name.Local == "" {
486 name := typ.Name()
487 if name == "" {
488 return &UnsupportedTypeError{typ}
489 }
490 start.Name.Local = name
491 }
492
493
494 for i := range tinfo.fields {
495 finfo := &tinfo.fields[i]
496 if finfo.flags&fAttr == 0 {
497 continue
498 }
499 fv := finfo.value(val)
500
501 if finfo.flags&fOmitEmpty != 0 && isEmptyValue(fv) {
502 continue
503 }
504
505 if fv.Kind() == reflect.Interface && fv.IsNil() {
506 continue
507 }
508
509 name := Name{Space: finfo.xmlns, Local: finfo.name}
510 if err := p.marshalAttr(&start, name, fv); err != nil {
511 return err
512 }
513 }
514
515 if err := p.writeStart(&start); err != nil {
516 return err
517 }
518
519 if val.Kind() == reflect.Struct {
520 err = p.marshalStruct(tinfo, val)
521 } else {
522 s, b, err1 := p.marshalSimple(typ, val)
523 if err1 != nil {
524 err = err1
525 } else if b != nil {
526 EscapeText(p, b)
527 } else {
528 p.EscapeString(s)
529 }
530 }
531 if err != nil {
532 return err
533 }
534
535 if err := p.writeEnd(start.Name); err != nil {
536 return err
537 }
538
539 return p.cachedWriteError()
540 }
541
542
543 func (p *printer) marshalAttr(start *StartElement, name Name, val reflect.Value) error {
544 if val.CanInterface() && val.Type().Implements(marshalerAttrType) {
545 attr, err := val.Interface().(MarshalerAttr).MarshalXMLAttr(name)
546 if err != nil {
547 return err
548 }
549 if attr.Name.Local != "" {
550 start.Attr = append(start.Attr, attr)
551 }
552 return nil
553 }
554
555 if val.CanAddr() {
556 pv := val.Addr()
557 if pv.CanInterface() && pv.Type().Implements(marshalerAttrType) {
558 attr, err := pv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
559 if err != nil {
560 return err
561 }
562 if attr.Name.Local != "" {
563 start.Attr = append(start.Attr, attr)
564 }
565 return nil
566 }
567 }
568
569 if val.CanInterface() && val.Type().Implements(textMarshalerType) {
570 text, err := val.Interface().(encoding.TextMarshaler).MarshalText()
571 if err != nil {
572 return err
573 }
574 start.Attr = append(start.Attr, Attr{name, string(text)})
575 return nil
576 }
577
578 if val.CanAddr() {
579 pv := val.Addr()
580 if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
581 text, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
582 if err != nil {
583 return err
584 }
585 start.Attr = append(start.Attr, Attr{name, string(text)})
586 return nil
587 }
588 }
589
590
591 switch val.Kind() {
592 case reflect.Ptr, reflect.Interface:
593 if val.IsNil() {
594 return nil
595 }
596 val = val.Elem()
597 }
598
599
600 if val.Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
601 n := val.Len()
602 for i := 0; i < n; i++ {
603 if err := p.marshalAttr(start, name, val.Index(i)); err != nil {
604 return err
605 }
606 }
607 return nil
608 }
609
610 if val.Type() == attrType {
611 start.Attr = append(start.Attr, val.Interface().(Attr))
612 return nil
613 }
614
615 s, b, err := p.marshalSimple(val.Type(), val)
616 if err != nil {
617 return err
618 }
619 if b != nil {
620 s = string(b)
621 }
622 start.Attr = append(start.Attr, Attr{name, s})
623 return nil
624 }
625
626
627
628 func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
629 var start StartElement
630
631
632 if startTemplate != nil {
633 start.Name = startTemplate.Name
634 start.Attr = append(start.Attr, startTemplate.Attr...)
635 } else if finfo != nil && finfo.name != "" {
636 start.Name.Local = finfo.name
637 start.Name.Space = finfo.xmlns
638 } else if typ.Name() != "" {
639 start.Name.Local = typ.Name()
640 } else {
641
642
643 start.Name.Local = typ.Elem().Name()
644 }
645 return start
646 }
647
648
649 func (p *printer) marshalInterface(val Marshaler, start StartElement) error {
650
651
652 p.tags = append(p.tags, Name{})
653 n := len(p.tags)
654
655 err := val.MarshalXML(p.encoder, start)
656 if err != nil {
657 return err
658 }
659
660
661 if len(p.tags) > n {
662 return fmt.Errorf("xml: %s.MarshalXML wrote invalid XML: <%s> not closed", receiverType(val), p.tags[len(p.tags)-1].Local)
663 }
664 p.tags = p.tags[:n-1]
665 return nil
666 }
667
668
669 func (p *printer) marshalTextInterface(val encoding.TextMarshaler, start StartElement) error {
670 if err := p.writeStart(&start); err != nil {
671 return err
672 }
673 text, err := val.MarshalText()
674 if err != nil {
675 return err
676 }
677 EscapeText(p, text)
678 return p.writeEnd(start.Name)
679 }
680
681
682 func (p *printer) writeStart(start *StartElement) error {
683 if start.Name.Local == "" {
684 return fmt.Errorf("xml: start tag with no name")
685 }
686
687 p.tags = append(p.tags, start.Name)
688 p.markPrefix()
689
690 p.writeIndent(1)
691 p.WriteByte('<')
692 p.WriteString(start.Name.Local)
693
694 if start.Name.Space != "" {
695 p.WriteString(` xmlns="`)
696 p.EscapeString(start.Name.Space)
697 p.WriteByte('"')
698 }
699
700
701 for _, attr := range start.Attr {
702 name := attr.Name
703 if name.Local == "" {
704 continue
705 }
706 p.WriteByte(' ')
707 if name.Space != "" {
708 p.WriteString(p.createAttrPrefix(name.Space))
709 p.WriteByte(':')
710 }
711 p.WriteString(name.Local)
712 p.WriteString(`="`)
713 p.EscapeString(attr.Value)
714 p.WriteByte('"')
715 }
716 p.WriteByte('>')
717 return nil
718 }
719
720 func (p *printer) writeEnd(name Name) error {
721 if name.Local == "" {
722 return fmt.Errorf("xml: end tag with no name")
723 }
724 if len(p.tags) == 0 || p.tags[len(p.tags)-1].Local == "" {
725 return fmt.Errorf("xml: end tag </%s> without start tag", name.Local)
726 }
727 if top := p.tags[len(p.tags)-1]; top != name {
728 if top.Local != name.Local {
729 return fmt.Errorf("xml: end tag </%s> does not match start tag <%s>", name.Local, top.Local)
730 }
731 return fmt.Errorf("xml: end tag </%s> in namespace %s does not match start tag <%s> in namespace %s", name.Local, name.Space, top.Local, top.Space)
732 }
733 p.tags = p.tags[:len(p.tags)-1]
734
735 p.writeIndent(-1)
736 p.WriteByte('<')
737 p.WriteByte('/')
738 p.WriteString(name.Local)
739 p.WriteByte('>')
740 p.popPrefix()
741 return nil
742 }
743
744 func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
745 switch val.Kind() {
746 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
747 return strconv.FormatInt(val.Int(), 10), nil, nil
748 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
749 return strconv.FormatUint(val.Uint(), 10), nil, nil
750 case reflect.Float32, reflect.Float64:
751 return strconv.FormatFloat(val.Float(), 'g', -1, val.Type().Bits()), nil, nil
752 case reflect.String:
753 return val.String(), nil, nil
754 case reflect.Bool:
755 return strconv.FormatBool(val.Bool()), nil, nil
756 case reflect.Array:
757 if typ.Elem().Kind() != reflect.Uint8 {
758 break
759 }
760
761 var bytes []byte
762 if val.CanAddr() {
763 bytes = val.Slice(0, val.Len()).Bytes()
764 } else {
765 bytes = make([]byte, val.Len())
766 reflect.Copy(reflect.ValueOf(bytes), val)
767 }
768 return "", bytes, nil
769 case reflect.Slice:
770 if typ.Elem().Kind() != reflect.Uint8 {
771 break
772 }
773
774 return "", val.Bytes(), nil
775 }
776 return "", nil, &UnsupportedTypeError{typ}
777 }
778
779 var ddBytes = []byte("--")
780
781
782
783
784
785 func indirect(vf reflect.Value) reflect.Value {
786 for vf.Kind() == reflect.Interface || vf.Kind() == reflect.Ptr {
787 if vf.IsNil() {
788 return vf
789 }
790 vf = vf.Elem()
791 }
792 return vf
793 }
794
795 func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {
796 s := parentStack{p: p}
797 for i := range tinfo.fields {
798 finfo := &tinfo.fields[i]
799 if finfo.flags&fAttr != 0 {
800 continue
801 }
802 vf := finfo.value(val)
803
804 switch finfo.flags & fMode {
805 case fCDATA, fCharData:
806 emit := EscapeText
807 if finfo.flags&fMode == fCDATA {
808 emit = emitCDATA
809 }
810 if err := s.trim(finfo.parents); err != nil {
811 return err
812 }
813 if vf.CanInterface() && vf.Type().Implements(textMarshalerType) {
814 data, err := vf.Interface().(encoding.TextMarshaler).MarshalText()
815 if err != nil {
816 return err
817 }
818 if err := emit(p, data); err != nil {
819 return err
820 }
821 continue
822 }
823 if vf.CanAddr() {
824 pv := vf.Addr()
825 if pv.CanInterface() && pv.Type().Implements(textMarshalerType) {
826 data, err := pv.Interface().(encoding.TextMarshaler).MarshalText()
827 if err != nil {
828 return err
829 }
830 if err := emit(p, data); err != nil {
831 return err
832 }
833 continue
834 }
835 }
836
837 var scratch [64]byte
838 vf = indirect(vf)
839 switch vf.Kind() {
840 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
841 if err := emit(p, strconv.AppendInt(scratch[:0], vf.Int(), 10)); err != nil {
842 return err
843 }
844 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
845 if err := emit(p, strconv.AppendUint(scratch[:0], vf.Uint(), 10)); err != nil {
846 return err
847 }
848 case reflect.Float32, reflect.Float64:
849 if err := emit(p, strconv.AppendFloat(scratch[:0], vf.Float(), 'g', -1, vf.Type().Bits())); err != nil {
850 return err
851 }
852 case reflect.Bool:
853 if err := emit(p, strconv.AppendBool(scratch[:0], vf.Bool())); err != nil {
854 return err
855 }
856 case reflect.String:
857 if err := emit(p, []byte(vf.String())); err != nil {
858 return err
859 }
860 case reflect.Slice:
861 if elem, ok := vf.Interface().([]byte); ok {
862 if err := emit(p, elem); err != nil {
863 return err
864 }
865 }
866 }
867 continue
868
869 case fComment:
870 if err := s.trim(finfo.parents); err != nil {
871 return err
872 }
873 vf = indirect(vf)
874 k := vf.Kind()
875 if !(k == reflect.String || k == reflect.Slice && vf.Type().Elem().Kind() == reflect.Uint8) {
876 return fmt.Errorf("xml: bad type for comment field of %s", val.Type())
877 }
878 if vf.Len() == 0 {
879 continue
880 }
881 p.writeIndent(0)
882 p.WriteString("<!--")
883 dashDash := false
884 dashLast := false
885 switch k {
886 case reflect.String:
887 s := vf.String()
888 dashDash = strings.Contains(s, "--")
889 dashLast = s[len(s)-1] == '-'
890 if !dashDash {
891 p.WriteString(s)
892 }
893 case reflect.Slice:
894 b := vf.Bytes()
895 dashDash = bytes.Contains(b, ddBytes)
896 dashLast = b[len(b)-1] == '-'
897 if !dashDash {
898 p.Write(b)
899 }
900 default:
901 panic("can't happen")
902 }
903 if dashDash {
904 return fmt.Errorf(`xml: comments must not contain "--"`)
905 }
906 if dashLast {
907
908 p.WriteByte(' ')
909 }
910 p.WriteString("-->")
911 continue
912
913 case fInnerXml:
914 vf = indirect(vf)
915 iface := vf.Interface()
916 switch raw := iface.(type) {
917 case []byte:
918 p.Write(raw)
919 continue
920 case string:
921 p.WriteString(raw)
922 continue
923 }
924
925 case fElement, fElement | fAny:
926 if err := s.trim(finfo.parents); err != nil {
927 return err
928 }
929 if len(finfo.parents) > len(s.stack) {
930 if vf.Kind() != reflect.Ptr && vf.Kind() != reflect.Interface || !vf.IsNil() {
931 if err := s.push(finfo.parents[len(s.stack):]); err != nil {
932 return err
933 }
934 }
935 }
936 }
937 if err := p.marshalValue(vf, finfo, nil); err != nil {
938 return err
939 }
940 }
941 s.trim(nil)
942 return p.cachedWriteError()
943 }
944
945
946 func (p *printer) cachedWriteError() error {
947 _, err := p.Write(nil)
948 return err
949 }
950
951 func (p *printer) writeIndent(depthDelta int) {
952 if len(p.prefix) == 0 && len(p.indent) == 0 {
953 return
954 }
955 if depthDelta < 0 {
956 p.depth--
957 if p.indentedIn {
958 p.indentedIn = false
959 return
960 }
961 p.indentedIn = false
962 }
963 if p.putNewline {
964 p.WriteByte('\n')
965 } else {
966 p.putNewline = true
967 }
968 if len(p.prefix) > 0 {
969 p.WriteString(p.prefix)
970 }
971 if len(p.indent) > 0 {
972 for i := 0; i < p.depth; i++ {
973 p.WriteString(p.indent)
974 }
975 }
976 if depthDelta > 0 {
977 p.depth++
978 p.indentedIn = true
979 }
980 }
981
982 type parentStack struct {
983 p *printer
984 stack []string
985 }
986
987
988
989
990 func (s *parentStack) trim(parents []string) error {
991 split := 0
992 for ; split < len(parents) && split < len(s.stack); split++ {
993 if parents[split] != s.stack[split] {
994 break
995 }
996 }
997 for i := len(s.stack) - 1; i >= split; i-- {
998 if err := s.p.writeEnd(Name{Local: s.stack[i]}); err != nil {
999 return err
1000 }
1001 }
1002 s.stack = s.stack[:split]
1003 return nil
1004 }
1005
1006
1007 func (s *parentStack) push(parents []string) error {
1008 for i := 0; i < len(parents); i++ {
1009 if err := s.p.writeStart(&StartElement{Name: Name{Local: parents[i]}}); err != nil {
1010 return err
1011 }
1012 }
1013 s.stack = append(s.stack, parents...)
1014 return nil
1015 }
1016
1017
1018
1019 type UnsupportedTypeError struct {
1020 Type reflect.Type
1021 }
1022
1023 func (e *UnsupportedTypeError) Error() string {
1024 return "xml: unsupported type: " + e.Type.String()
1025 }
1026
1027 func isEmptyValue(v reflect.Value) bool {
1028 switch v.Kind() {
1029 case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
1030 return v.Len() == 0
1031 case reflect.Bool:
1032 return !v.Bool()
1033 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1034 return v.Int() == 0
1035 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1036 return v.Uint() == 0
1037 case reflect.Float32, reflect.Float64:
1038 return v.Float() == 0
1039 case reflect.Interface, reflect.Ptr:
1040 return v.IsNil()
1041 }
1042 return false
1043 }
1044
View as plain text