Subversion Repositories openrisc

// Copyright 2011 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package xml

import (

        "bufio"

        "bytes"

        "fmt"

        "io"

        "reflect"

        "strconv"

        "strings"

)

const (

        // A generic XML header suitable for use with the output of Marshal.

        // This is not automatically added to any output of this package,

        // it is provided as a convenience.

        Header = `` + "\n"

)

// Marshal returns the XML encoding of v.

//

// Marshal handles an array or slice by marshalling each of the elements.

// Marshal handles a pointer by marshalling the value it points at or, if the

// pointer is nil, by writing nothing.  Marshal handles an interface value by

// marshalling the value it contains or, if the interface value is nil, by

// writing nothing.  Marshal handles all other data by writing one or more XML

// elements containing the data.

//

// The name for the XML elements is taken from, in order of preference:

//     - the tag on the XMLName field, if the data is a struct

//     - the value of the XMLName field of type xml.Name

//     - the tag of the struct field used to obtain the data

//     - the name of the struct field used to obtain the data

//     - the name of the marshalled type

//

// The XML element for a struct contains marshalled elements for each of the

// exported fields of the struct, with these exceptions:

//     - the XMLName field, described above, is omitted.

//     - a field with tag "-" is omitted.

//     - a field with tag "name,attr" becomes an attribute with

//       the given name in the XML element.

//     - a field with tag ",attr" becomes an attribute with the

//       field name in the in the XML element.

//     - a field with tag ",chardata" is written as character data,

//       not as an XML element.

//     - a field with tag ",innerxml" is written verbatim, not subject

//       to the usual marshalling procedure.

//     - a field with tag ",comment" is written as an XML comment, not

//       subject to the usual marshalling procedure. It must not contain

//       the "--" string within it.

//

// If a field uses a tag "a>b>c", then the element c will be nested inside

// parent elements a and b.  Fields that appear next to each other that name

// the same parent will be enclosed in one XML element.  For example:

//

//      type Result struct {

//              XMLName   xml.Name `xml:"result"`

//              Id        int      `xml:"id,attr"`

//              FirstName string   `xml:"person>name>first"`

//              LastName  string   `xml:"person>name>last"`

//              Age       int      `xml:"person>age"`

//      }

//

//      xml.Marshal(&Result{Id: 13, FirstName: "John", LastName: "Doe", Age: 42})

//

// would be marshalled as:

//

//      

//              

//                      

//                              John

//                              Doe

//                      

//                      42

//              

//      

//

// Marshal will return an error if asked to marshal a channel, function, or map.

func Marshal(v interface{}) ([]byte, error) {

        var b bytes.Buffer

        if err := NewEncoder(&b).Encode(v); err != nil {

                return nil, err

        }

        return b.Bytes(), nil

}

// An Encoder writes XML data to an output stream.

type Encoder struct {

        printer

}

// NewEncoder returns a new encoder that writes to w.

func NewEncoder(w io.Writer) *Encoder {

        return &Encoder{printer{bufio.NewWriter(w)}}

}

// Encode writes the XML encoding of v to the stream.

//

// See the documentation for Marshal for details about the conversion

// of Go values to XML.

func (enc *Encoder) Encode(v interface{}) error {

        err := enc.marshalValue(reflect.ValueOf(v), nil)

        enc.Flush()

        return err

}

type printer struct {

        *bufio.Writer

}

func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo) error {

        if !val.IsValid() {

                return nil

        }

        kind := val.Kind()

        typ := val.Type()

        // Drill into pointers/interfaces

        if kind == reflect.Ptr || kind == reflect.Interface {

                if val.IsNil() {

                        return nil

                }

                return p.marshalValue(val.Elem(), finfo)

        }

        // Slices and arrays iterate over the elements. They do not have an enclosing tag.

        if (kind == reflect.Slice || kind == reflect.Array) && typ.Elem().Kind() != reflect.Uint8 {

                for i, n := 0, val.Len(); i < n; i++ {

                        if err := p.marshalValue(val.Index(i), finfo); err != nil {

                                return err

                        }

                }

                return nil

        }

        tinfo, err := getTypeInfo(typ)

        if err != nil {

                return err

        }

        // Precedence for the XML element name is:

        // 1. XMLName field in underlying struct;

        // 2. field name/tag in the struct field; and

        // 3. type name

        var xmlns, name string

        if tinfo.xmlname != nil {

                xmlname := tinfo.xmlname

                if xmlname.name != "" {

                        xmlns, name = xmlname.xmlns, xmlname.name

                } else if v, ok := val.FieldByIndex(xmlname.idx).Interface().(Name); ok && v.Local != "" {

                        xmlns, name = v.Space, v.Local

                }

        }

        if name == "" && finfo != nil {

                xmlns, name = finfo.xmlns, finfo.name

        }

        if name == "" {

                name = typ.Name()

                if name == "" {

                        return &UnsupportedTypeError{typ}

                }

        }

        p.WriteByte('<')

        p.WriteString(name)

        if xmlns != "" {

                p.WriteString(` xmlns="`)

                // TODO: EscapeString, to avoid the allocation.

                Escape(p, []byte(xmlns))

                p.WriteByte('"')

        }

        // Attributes

        for i := range tinfo.fields {

                finfo := &tinfo.fields[i]

                if finfo.flags&fAttr == 0 {

                        continue

                }

                fv := val.FieldByIndex(finfo.idx)

                switch fv.Kind() {

                case reflect.String, reflect.Array, reflect.Slice:

                        // TODO: Should we really do this once ,omitempty is in?

                        if fv.Len() == 0 {

                                continue

                        }

                }

                p.WriteByte(' ')

                p.WriteString(finfo.name)

                p.WriteString(`="`)

                if err := p.marshalSimple(fv.Type(), fv); err != nil {

                        return err

                }

                p.WriteByte('"')

        }

        p.WriteByte('>')

        if val.Kind() == reflect.Struct {

                err = p.marshalStruct(tinfo, val)

        } else {

                err = p.marshalSimple(typ, val)

        }

        if err != nil {

                return err

        }

        p.WriteByte('<')

        p.WriteByte('/')

        p.WriteString(name)

        p.WriteByte('>')

        return nil

}

func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) error {

        switch val.Kind() {

        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

                p.WriteString(strconv.FormatInt(val.Int(), 10))

        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:

                p.WriteString(strconv.FormatUint(val.Uint(), 10))

        case reflect.Float32, reflect.Float64:

                p.WriteString(strconv.FormatFloat(val.Float(), 'g', -1, 64))

        case reflect.String:

                // TODO: Add EscapeString.

                Escape(p, []byte(val.String()))

        case reflect.Bool:

                p.WriteString(strconv.FormatBool(val.Bool()))

        case reflect.Array:

                // will be [...]byte

                bytes := make([]byte, val.Len())

                for i := range bytes {

                        bytes[i] = val.Index(i).Interface().(byte)

                }

                Escape(p, bytes)

        case reflect.Slice:

                // will be []byte

                Escape(p, val.Bytes())

        default:

                return &UnsupportedTypeError{typ}

        }

        return nil

}

var ddBytes = []byte("--")

func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {

        s := parentStack{printer: p}

        for i := range tinfo.fields {

                finfo := &tinfo.fields[i]

                if finfo.flags&(fAttr|fAny) != 0 {

                        continue

                }

                vf := val.FieldByIndex(finfo.idx)

                switch finfo.flags & fMode {

                case fCharData:

                        switch vf.Kind() {

                        case reflect.String:

                                Escape(p, []byte(vf.String()))

                        case reflect.Slice:

                                if elem, ok := vf.Interface().([]byte); ok {

                                        Escape(p, elem)

                                }

                        }

                        continue

                case fComment:

                        k := vf.Kind()

                        if !(k == reflect.String || k == reflect.Slice && vf.Type().Elem().Kind() == reflect.Uint8) {

                                return fmt.Errorf("xml: bad type for comment field of %s", val.Type())

                        }

                        if vf.Len() == 0 {

                                continue

                        }

                        p.WriteString("" is invalid grammar. Make it "- -->"

                                p.WriteByte(' ')

                        }

                        p.WriteString("-->")

                        continue

                case fInnerXml:

                        iface := vf.Interface()

                        switch raw := iface.(type) {

                        case []byte:

                                p.Write(raw)

                                continue

                        case string:

                                p.WriteString(raw)

                                continue

                        }

                case fElement:

                        s.trim(finfo.parents)

                        if len(finfo.parents) > len(s.stack) {

                                if vf.Kind() != reflect.Ptr && vf.Kind() != reflect.Interface || !vf.IsNil() {

                                        s.push(finfo.parents[len(s.stack):])

                                }

                        }

                }

                if err := p.marshalValue(vf, finfo); err != nil {

                        return err

                }

        }

        s.trim(nil)

        return nil

}

type parentStack struct {

        *printer

        stack []string

}

// trim updates the XML context to match the longest common prefix of the stack

// and the given parents.  A closing tag will be written for every parent

// popped.  Passing a zero slice or nil will close all the elements.

func (s *parentStack) trim(parents []string) {

        split := 0

        for ; split < len(parents) && split < len(s.stack); split++ {

                if parents[split] != s.stack[split] {

                        break

                }

        }

        for i := len(s.stack) - 1; i >= split; i-- {

                s.WriteString("

                s.WriteString(s.stack[i])

                s.WriteByte('>')

        }

        s.stack = parents[:split]

}

// push adds parent elements to the stack and writes open tags.

func (s *parentStack) push(parents []string) {

        for i := 0; i < len(parents); i++ {

                s.WriteString("<")

                s.WriteString(parents[i])

                s.WriteByte('>')

        }

        s.stack = append(s.stack, parents...)

}

// A MarshalXMLError is returned when Marshal encounters a type

// that cannot be converted into XML.

type UnsupportedTypeError struct {

        Type reflect.Type

}

func (e *UnsupportedTypeError) Error() string {

        return "xml: unsupported type: " + e.Type.String()

}