xml

golang动态解析xml

package main

import (
    "encoding/xml"
    "fmt"
    "mahonia"
    "os"
    "strconv"
    "text/template"
)

type Attribute struct {
    Name  string
    Value string
}

type Token struct {
    Name       string
    Attributes []Attribute
    Tokens     []Token
}

type Result struct {
    Root Token
}

var result = Result{}

func main() {

    if !parse("config.xml") {
        return
    }

    if !output("code_h.tpl", "code.h") {
        return
    }

    if !output("code_cpp.tpl", "code.cpp") {
        return
    }

    fmt.Println("OK")
}

func parse_token(decoder *xml.Decoder, tt xml.Token, mytoken *Token) {

    token := tt.(xml.StartElement)
    name := token.Name.Local
    mytoken.Name = name

    for _, attr := range token.Attr {
        attrName := attr.Name.Local
        attrValue := attr.Value

        attr := Attribute{Name: attrName, Value: attrValue}

        mytoken.Attributes = append(mytoken.Attributes, attr)
    }

    var t xml.Token
    var err error

    for t, err = decoder.Token(); err == nil; t, err = decoder.Token() {

        switch t.(type) {
            // 处理元素开始（标签）
            case xml.StartElement:

            mytoken.Tokens = append(mytoken.Tokens, Token{})

            parse_token(decoder, t, &mytoken.Tokens[len(mytoken.Tokens)-1])

            // 处理元素结束（标签）
            case xml.EndElement:
            return
            case xml.CharData:
        default:
            return
        }
    }
}

func parse(filename string) bool {
    file, err := os.Open(filename)
    if err != nil {
        fmt.Println(err)
        return false
    }

    var t xml.Token

    decoder := xml.NewDecoder(file)
    t, decerr := decoder.Token()
    if decerr != nil {
        fmt.Println(decerr)
        return false
    }
    parse_token(decoder, t, &result.Root)
    fmt.Println("result", result.Root)
    return true
}

func genlist(n string) []string {
    num, _ := strconv.Atoi(n)
    ret := make([]string, num)
    for i := 0; i < num; i++ {
        ret[i] = strconv.Itoa(i)
    }
    return ret
}

func iconv(str string) string {
    enc := mahonia.NewEncoder("gb2312")
    return enc.ConvertString(str)
}

func output(src string, des string) bool {

    file, err := os.Create(des)
    if err != nil {
        fmt.Println(err)
        return false
    }

    t := template.New("text")
    if err != nil {
        fmt.Println(err)
        return false
    }

    t = t.Funcs(template.FuncMap{"genlist": genlist, "iconv": iconv})

    srcfile, err := os.Open(src)
    if err != nil {
        fmt.Println(err)
        return false
    }

    var buffer [1024 * 1024]byte
    n, rerr := srcfile.Read(buffer[0:])
    if rerr != nil {
        fmt.Println(rerr)
        return false
    }

    t, err = t.Parse(string(buffer[0:n]))
    if err != nil {
        fmt.Println(err)
        return false
    }

    err = t.Execute(file, result.Root)
    if err != nil {
        fmt.Println(err)
        return false
    }

    return true
}

本文由 创作，采用 知识共享署名4.0 国际许可协议进行许可。本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名。最后编辑时间为: 2020/08/08 12:13