go语言解析INI文件

package main
 
 import (
 	"bufio"
 	"bytes"
 	"io"
 	"os"
 	"unicode"
 )
 
 const (
 	stat_none = iota
 	stat_group
 	stat_key
 	stat_value
 	stat_comment
 )
 
 type Attr struct {
 	Name    string
 	Value   string
 	Comment string
 	next    *Attr
 }
 
 type Element struct {
 	Element string
 	Attr    *Attr
 	next    *Element
 }
 
 type Decoder struct {
 	state int
 	b     byte
 	t     bytes.Buffer
 	r     io.ByteReader
 	err   error
 	m     *Element
 	n     string
 }
 
 func (d *Decoder) getAttr(m *Element, e string) string {
 	for n := m.Attr; nil != n; n = n.next {
 		if e == n.Name {
 			return n.Value
 		}
 	}
 	return ""
 }
 
 func (d *Decoder) GetElement(e string, a string) string {
 	for n := d.m; nil != n; n = n.next {
 		if e == n.Element {
 			return d.getAttr(n, a)
 		}
 	}
 	return ""
 }
 
 func (d *Decoder) newAttrNextComment(value string) {
 	d.m.Attr.Comment = value
 	println(value)
 }
 
 func (d *Decoder) newAttrNext(name string, value string) {
 	attr := new(Attr)
 	attr.Name = name
 	attr.Value = value
 	if nil == d.m.Attr {
 		attr.next = nil
 	} else {
 		attr.next = d.m.Attr
 	}
 	d.m.Attr = attr
 }
 
 func (d *Decoder) newElement(name string) {
 	element := new(Element)
 	element.Element = name
 	element.Attr = nil
 	if nil == d.m {
 		element.next = nil
 	} else {
 		element.next = d.m
 	}
 	d.m = element
 }
 
 func (d *Decoder) switchToMap() {
 	for {
 		d.b, d.err = d.r.ReadByte()
 		if d.err != nil {
 			break
 		}
 		switch d.state {
 		case stat_none:
 			if d.b == '[' {
 				d.state = stat_group
 			} else if d.b == ';' {
 				d.state = stat_comment
 			} else if !unicode.IsSpace(rune(d.b)) {
 				d.state = stat_key
 				d.t.WriteByte(byte(d.b))
 			}
 			break
 		case stat_group:
 			if d.b == ']' {
 				d.state = stat_none
 				d.newElement(d.t.String())
 				d.t.Reset()
 			} else if !unicode.IsSpace(rune(d.b)) {
 				d.t.WriteByte(byte(d.b))
 			}
 			break
 		case stat_key:
 			if d.b == '=' {
 				d.state = stat_value
 				d.n = d.t.String()
 				d.t.Reset()
 			} else if !unicode.IsSpace(rune(d.b)) {
 				d.t.WriteByte(byte(d.b))
 			}
 			break
 		case stat_value:
 			if !unicode.IsSpace(rune(d.b)) {
 				d.t.WriteByte(byte(d.b))
 			} else {
 				d.state = stat_none
 				d.newAttrNext(d.n, d.t.String())
 				d.t.Reset()
 			}
 			break
 		case stat_comment:
 			if !unicode.IsSpace(rune(d.b)) {
 				d.t.WriteByte(byte(d.b))
 			} else {
 				d.state = stat_none
 				d.newAttrNextComment(d.t.String())
 				d.t.Reset()
 			}
 			break
 		default:
 			d.state = stat_none
 			break
 		}
 	}
 }
 
 func (d *Decoder) switchToReader(r io.Reader) {
 	if rb, ok := r.(io.ByteReader); ok {
 		d.r = rb
 	} else {
 		d.r = bufio.NewReader(r)
 	}
 	d.switchToMap()
 }
 
 func NewDecoder(r io.Reader) *Decoder {
 	d := &Decoder{}
 	d.switchToReader(r)
 	return d
 }
 
 func main() {
 	xmlFile, err := os.Open("hh.ini")
 	if nil != err {
 		return
 	}
 	defer xmlFile.Close()
 	d := NewDecoder(xmlFile)
 	println(d.GetElement("aaaa", "ac"))
 }