Lorem Ipsum
`) 13 | if err != nil { 14 | t.Errorf("Failed to parse: %s", err) 15 | return 16 | } 17 | defer doc.Free() 18 | 19 | root, err := doc.DocumentElement() 20 | if !assert.NoError(t, err, "DocumentElement() should succeed") { 21 | return 22 | } 23 | if !assert.True(t, root.IsSameNode(root), "root == root") { 24 | return 25 | } 26 | 27 | nodes := xpath.NodeList(doc.Find("/html/body/h1")) 28 | if len(nodes) != 1 { 29 | t.Errorf("Could not find matching nodes") 30 | return 31 | } 32 | 33 | if nodes[0].TextContent() != "Hello, World!" { 34 | t.Errorf("h1 content is not 'Hello, World!', got %s", nodes[0].TextContent()) 35 | return 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /internal/cmd/genwrapnode/genwrapnode.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | "go/format" 7 | "io" 8 | "log" 9 | "os" 10 | "strconv" 11 | 12 | "github.com/pkg/errors" 13 | ) 14 | 15 | func main() { 16 | if err := _main(); err != nil { 17 | log.Printf("%s", err) 18 | os.Exit(1) 19 | } 20 | } 21 | 22 | func _main() error { 23 | var buf bytes.Buffer 24 | 25 | buf.WriteString("package dom") 26 | buf.WriteString("\n\n// Auto-generated by internal/cmd/genwrapnode/genwrapnode.go. DO NOT EDIT!") 27 | buf.WriteString("\n\nimport (") 28 | buf.WriteString("\n\"fmt\"\n") 29 | for _, lib := range []string{"github.com/lestrrat-go/libxml2/clib", "github.com/lestrrat-go/libxml2/types"} { 30 | fmt.Fprintf(&buf, "\n%s", strconv.Quote(lib)) 31 | } 32 | buf.WriteString("\n)") 33 | 34 | nodeTypes := []string{ 35 | `Namespace`, 36 | `Attribute`, 37 | `CDataSection`, 38 | `Comment`, 39 | `Element`, 40 | `Text`, 41 | `Pi`, 42 | } 43 | 44 | for _, typ := range nodeTypes { 45 | fmt.Fprintf(&buf, "\n\nfunc wrap%sNode(ptr uintptr) *%s {", typ, typ) 46 | fmt.Fprintf(&buf, "\nvar n %s", typ) 47 | buf.WriteString("\nn.ptr = ptr") 48 | buf.WriteString("\nreturn &n") 49 | buf.WriteString("\n}") 50 | } 51 | 52 | buf.WriteString("\n\n// WrapNode is a function created with the sole purpose of allowing") 53 | buf.WriteString("\n// go-libxml2 consumers that can generate a C.xmlNode pointer to") 54 | buf.WriteString("\n// create libxml2.Node types, e.g. go-xmlsec.") 55 | buf.WriteString("\nfunc WrapNode(n uintptr) (types.Node, error) {") 56 | buf.WriteString("\nswitch typ := clib.XMLGetNodeTypeRaw(n); typ {") 57 | 58 | for _, typ := range nodeTypes { 59 | // XXX hmm, this never existed. don't have time to debug right now. 60 | // possibly an omission bug? 61 | if typ == "Namespace" { 62 | continue 63 | } 64 | fmt.Fprintf(&buf, "\ncase clib.%sNode:", typ) 65 | fmt.Fprintf(&buf, "\nreturn wrap%sNode(n), nil", typ) 66 | } 67 | 68 | buf.WriteString("\ndefault:") 69 | buf.WriteString("\nreturn nil, fmt.Errorf(\"unknown node: %%d\", typ)") 70 | buf.WriteString("\n}") 71 | buf.WriteString("\n}") 72 | 73 | src, err := format.Source(buf.Bytes()) 74 | if err != nil { 75 | log.Printf("%s", buf.Bytes()) 76 | return err 77 | } 78 | 79 | var out io.Writer = os.Stdout 80 | args := os.Args 81 | if len(args) > 2 && args[1] == "--" { 82 | args = append(append([]string(nil), args[1:]...), args[2:]...) 83 | } 84 | 85 | if len(args) > 1 { 86 | f, err := os.OpenFile(args[1], os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) 87 | if err != nil { 88 | return errors.Wrapf(err, `failed to open %s`, args[1]) 89 | } 90 | defer f.Close() 91 | out = f 92 | } 93 | 94 | _, _ = out.Write(src) 95 | return nil 96 | } 97 | -------------------------------------------------------------------------------- /internal/debug/debug_off.go: -------------------------------------------------------------------------------- 1 | //go:build !debug 2 | // +build !debug 3 | 4 | package debug 5 | 6 | const Enabled = false 7 | 8 | // Printf is no op unless you compile with the `debug` tag 9 | func Printf(_ string, _ ...interface{}) {} 10 | -------------------------------------------------------------------------------- /internal/debug/debug_on.go: -------------------------------------------------------------------------------- 1 | //+build debug 2 | 3 | package debug 4 | 5 | import ( 6 | "log" 7 | "os" 8 | ) 9 | 10 | const Enabled = true 11 | 12 | var logger = log.New(os.Stdout, "|DEBUG| ", 0) 13 | 14 | // Printf prints debug messages. Only available if compiled with "debug" tag 15 | func Printf(f string, args ...interface{}) { 16 | logger.Printf(f, args...) 17 | } 18 | -------------------------------------------------------------------------------- /internal/option/interface.go: -------------------------------------------------------------------------------- 1 | package option 2 | 3 | const ( 4 | OptKeyWithURI = `with-uri` 5 | ) 6 | -------------------------------------------------------------------------------- /internal/option/option.go: -------------------------------------------------------------------------------- 1 | package option 2 | 3 | type Interface interface { 4 | Name() string 5 | Value() interface{} 6 | } 7 | 8 | type Option struct { 9 | name string 10 | value interface{} 11 | } 12 | 13 | func New(name string, value interface{}) *Option { 14 | return &Option{ 15 | name: name, 16 | value: value, 17 | } 18 | } 19 | 20 | func (o *Option) Name() string { 21 | return o.name 22 | } 23 | func (o *Option) Value() interface{} { 24 | return o.value 25 | } 26 | -------------------------------------------------------------------------------- /libxml2.go: -------------------------------------------------------------------------------- 1 | //go:generate go run internal/cmd/genwrapnode/genwrapnode.go -- dom/node_wrap.go 2 | 3 | /* 4 | Package libxml2 is an interface to libxml2 library, providing XML and HTML parsers 5 | with DOM interface. The inspiration is Perl5's XML::LibXML module. 6 | 7 | This library is still in very early stages of development. API may still change 8 | without notice. 9 | 10 | For the time being, the API is being written so that thye are as close as we 11 | can get to DOM Layer 3, but some methods will, for the time being, be punted 12 | and aliases for simpler methods that don't necessarily check for the DOM's 13 | correctness will be used. 14 | 15 | Also, the return values are still shaky -- I'm still debating how to handle error cases gracefully. 16 | */ 17 | package libxml2 18 | -------------------------------------------------------------------------------- /libxml2_bench_test.go: -------------------------------------------------------------------------------- 1 | // This file is build-tag protected because it involves loading an external 2 | // library (xmlpath) 3 | package libxml2_test 4 | 5 | import ( 6 | "bytes" 7 | "encoding/xml" 8 | "os" 9 | "path/filepath" 10 | "testing" 11 | 12 | "github.com/lestrrat-go/libxml2" 13 | "github.com/lestrrat-go/libxml2/dom" 14 | "github.com/lestrrat-go/libxml2/xpath" 15 | "github.com/stretchr/testify/assert" 16 | "gopkg.in/xmlpath.v1" 17 | ) 18 | 19 | var xmlfile = filepath.Join("test", "feed.atom") 20 | 21 | func BenchmarkXmlpathXmlpath(b *testing.B) { 22 | f, err := os.Open(xmlfile) 23 | if err != nil { 24 | b.Fatalf("%s", err) 25 | } 26 | 27 | root, err := xmlpath.Parse(f) 28 | if err != nil { 29 | b.Fatalf("%s", err) 30 | } 31 | for i := 0; i < b.N; i++ { 32 | p, err := xmlpath.Compile(`//entry`) 33 | if err != nil { 34 | b.Fatalf("%s", err) 35 | } 36 | it := p.Iter(root) 37 | for it.Next() { 38 | n := it.Node() 39 | _ = n 40 | } 41 | } 42 | } 43 | 44 | func TestBenchmarkLibxml2Xmlpath(t *testing.T) { 45 | f, err := os.Open(xmlfile) 46 | if !assert.NoError(t, err, "os.Open succeeds") { 47 | return 48 | } 49 | 50 | doc, err := libxml2.ParseReader(f) 51 | if !assert.NoError(t, err, "ParseReader succeeds") { 52 | return 53 | } 54 | 55 | xpc, err := xpath.NewContext(doc) 56 | if !assert.NoError(t, err, "xpath.NewContext succeeds") { 57 | return 58 | } 59 | xpc.RegisterNS("atom", "http://www.w3.org/2005/Atom") 60 | 61 | res, err := xpc.Find(`//atom:entry`) 62 | if !assert.NoError(t, err, "xpc.Find succeeds") { 63 | return 64 | } 65 | defer res.Free() 66 | 67 | iter := res.NodeIter() 68 | if !assert.NotEmpty(t, iter, "res.NodeIter succeeds") { 69 | return 70 | } 71 | 72 | count := 0 73 | for iter.Next() { 74 | n := iter.Node() 75 | if !assert.NotEmpty(t, n, "iter.Node returns something") { 76 | return 77 | } 78 | count++ 79 | } 80 | if !assert.True(t, count > 0, "there's at least 1 node") { 81 | return 82 | } 83 | } 84 | 85 | func BenchmarkLibxml2Xmlpath(b *testing.B) { 86 | f, err := os.Open(xmlfile) 87 | if err != nil { 88 | b.Fatalf("%s", err) 89 | } 90 | 91 | doc, err := libxml2.ParseReader(f) 92 | if err != nil { 93 | b.Fatalf("%s", err) 94 | } 95 | 96 | xpc, err := xpath.NewContext(doc) 97 | if err != nil { 98 | b.Fatalf("%s", err) 99 | } 100 | xpc.RegisterNS("atom", "http://www.w3.org/2005/Atom") 101 | for i := 0; i < b.N; i++ { 102 | iter := xpath.NodeIter(xpc.Find(`//atom:entry`)) 103 | for iter.Next() { 104 | n := iter.Node() 105 | _ = n 106 | } 107 | } 108 | } 109 | 110 | //nolint:musttag 111 | type Foo struct { 112 | XMLName xml.Name `xml:"https://github.com/lestrrat-go/libxml2/foo foo:foo"` 113 | Field1 string 114 | Field2 string `xml:",attr"` 115 | } 116 | 117 | func BenchmarkEncodingXMLDOM(b *testing.B) { 118 | var buf bytes.Buffer 119 | f := Foo{ 120 | Field1: "Hello, World!", 121 | Field2: "Hello, Attribute!", 122 | } 123 | for i := 0; i < b.N; i++ { 124 | buf.Reset() 125 | enc := xml.NewEncoder(&buf) 126 | enc.Encode(f) 127 | } 128 | } 129 | 130 | func BenchmarkLibxml2DOM(b *testing.B) { 131 | var buf bytes.Buffer 132 | const nsuri = `https://github.com/lestrrat-go/libxml2/foo` 133 | f := Foo{ 134 | Field1: "Hello, World!", 135 | Field2: "Hello, Attribute!", 136 | } 137 | for i := 0; i < b.N; i++ { 138 | d := dom.CreateDocument() 139 | 140 | root, err := d.CreateElementNS(nsuri, "foo:foo") 141 | if err != nil { 142 | d.Free() 143 | panic(err) 144 | } 145 | d.SetDocumentElement(root) 146 | 147 | f1xml, err := d.CreateElement("Field1") 148 | if err != nil { 149 | d.Free() 150 | panic(err) 151 | } 152 | root.AddChild(f1xml) 153 | 154 | f1xml.SetAttribute("Field2", f.Field2) 155 | 156 | f1xml.AppendText(f.Field1) 157 | buf.Reset() 158 | buf.WriteString(d.Dump(false)) 159 | d.Free() 160 | } 161 | } 162 | -------------------------------------------------------------------------------- /libxml2_example_test.go: -------------------------------------------------------------------------------- 1 | package libxml2_test 2 | 3 | import ( 4 | "log" 5 | "net/http" 6 | 7 | "github.com/lestrrat-go/libxml2" 8 | "github.com/lestrrat-go/libxml2/parser" 9 | "github.com/lestrrat-go/libxml2/types" 10 | "github.com/lestrrat-go/libxml2/xpath" 11 | ) 12 | 13 | //nolint:testableexamples 14 | func ExampleXML() { 15 | //nolint:noctx 16 | res, err := http.Get("http://blog.golang.org/feed.atom") 17 | if err != nil { 18 | panic("failed to get blog.golang.org: " + err.Error()) 19 | } 20 | 21 | p := parser.New() 22 | doc, err := p.ParseReader(res.Body) 23 | defer res.Body.Close() 24 | 25 | if err != nil { 26 | panic("failed to parse XML: " + err.Error()) 27 | } 28 | defer doc.Free() 29 | 30 | doc.Walk(func(n types.Node) error { 31 | log.Println(n.NodeName()) 32 | return nil 33 | }) 34 | 35 | root, err := doc.DocumentElement() 36 | if err != nil { 37 | log.Printf("Failed to fetch document element: %s", err) 38 | return 39 | } 40 | 41 | ctx, err := xpath.NewContext(root) 42 | if err != nil { 43 | log.Printf("Failed to create xpath context: %s", err) 44 | return 45 | } 46 | defer ctx.Free() 47 | 48 | ctx.RegisterNS("atom", "http://www.w3.org/2005/Atom") 49 | title := xpath.String(ctx.Find("/atom:feed/atom:title/text()")) 50 | log.Printf("feed title = %s", title) 51 | } 52 | 53 | //nolint:testableexamples 54 | func ExampleHTML() { 55 | //nolint:noctx 56 | res, err := http.Get("http://golang.org") 57 | if err != nil { 58 | panic("failed to get golang.org: " + err.Error()) 59 | } 60 | defer res.Body.Close() 61 | 62 | doc, err := libxml2.ParseHTMLReader(res.Body) 63 | if err != nil { 64 | panic("failed to parse HTML: " + err.Error()) 65 | } 66 | defer doc.Free() 67 | 68 | doc.Walk(func(n types.Node) error { 69 | log.Println(n.NodeName()) 70 | return nil 71 | }) 72 | 73 | nodes := xpath.NodeList(doc.Find(`//div[@id="menu"]/a`)) 74 | for i := 0; i < len(nodes); i++ { 75 | log.Printf("Found node: %s", nodes[i].NodeName()) 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /parser.go: -------------------------------------------------------------------------------- 1 | package libxml2 2 | 3 | import ( 4 | "io" 5 | 6 | "github.com/lestrrat-go/libxml2/parser" 7 | "github.com/lestrrat-go/libxml2/types" 8 | ) 9 | 10 | // Parse parses the given buffer and returns a Document. 11 | func Parse(buf []byte, o ...parser.Option) (types.Document, error) { 12 | p := parser.New(o...) 13 | return p.Parse(buf) 14 | } 15 | 16 | // ParseString parses the given string and returns a Document. 17 | func ParseString(s string, o ...parser.Option) (types.Document, error) { 18 | p := parser.New(o...) 19 | return p.ParseString(s) 20 | } 21 | 22 | // ParseReader parses XML from the given io.Reader and returns a Document. 23 | func ParseReader(rdr io.Reader, o ...parser.Option) (types.Document, error) { 24 | p := parser.New(o...) 25 | return p.ParseReader(rdr) 26 | } 27 | -------------------------------------------------------------------------------- /parser/interface.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import "errors" 4 | 5 | var ( 6 | // ErrMalformedXML is returned when the XML source is malformed 7 | ErrMalformedXML = errors.New("malformed XML") 8 | ) 9 | 10 | // HTMLOption represents the HTML parser options that 11 | // can be used when parsing HTML 12 | type HTMLOption int 13 | 14 | const ( 15 | // HTMLParseRecover enables relaxed parsing 16 | HTMLParseRecover HTMLOption = 1 << 0 17 | // HTMLParseNoDefDTD disables using a default doctype when absent 18 | HTMLParseNoDefDTD = 1 << 2 19 | // HTMLParseNoError suppresses error reports 20 | HTMLParseNoError = 1 << 5 21 | // HTMLParseNoWarning suppresses warning reports 22 | HTMLParseNoWarning = 1 << 6 23 | // HTMLParsePedantic enables pedantic error reporting 24 | HTMLParsePedantic = 1 << 7 25 | // HTMLParseNoBlanks removes blank nodes 26 | HTMLParseNoBlanks = 1 << 8 27 | // HTMLParseNoNet forbids network access during parsing 28 | HTMLParseNoNet = 1 << 11 29 | // HTMLParseNoImplied disables implied html/body elements 30 | HTMLParseNoImplied = 1 << 13 31 | // HTMLParseCompact enables compaction of small text nodes 32 | HTMLParseCompact = 1 << 16 33 | // HTMLParseIgnoreEnc ignores internal document encoding hints 34 | HTMLParseIgnoreEnc = 1 << 21 35 | ) 36 | 37 | // DefaultHTMLOptions represents the default set of options 38 | // used in the ParseHTML* functions 39 | const DefaultHTMLOptions = HTMLParseCompact | HTMLParseNoBlanks | HTMLParseNoError | HTMLParseNoWarning 40 | 41 | // Option represents the parser option bit 42 | type Option int 43 | 44 | const ( 45 | XMLParseRecover Option = 1 << iota /* recover on errors */ 46 | XMLParseNoEnt /* substitute entities */ 47 | XMLParseDTDLoad /* load the external subset */ 48 | XMLParseDTDAttr /* default DTD attributes */ 49 | XMLParseDTDValid /* validate with the DTD */ 50 | XMLParseNoError /* suppress error reports */ 51 | XMLParseNoWarning /* suppress warning reports */ 52 | XMLParsePedantic /* pedantic error reporting */ 53 | XMLParseNoBlanks /* remove blank nodes */ 54 | XMLParseSAX1 /* use the SAX1 interface internally */ 55 | XMLParseXInclude /* Implement XInclude substitution */ 56 | XMLParseNoNet /* Forbid network access */ 57 | XMLParseNoDict /* Do not reuse the context dictionary */ 58 | XMLParseNsclean /* remove redundant namespaces declarations */ 59 | XMLParseNoCDATA /* merge CDATA as text nodes */ 60 | XMLParseNoXIncNode /* do not generate XINCLUDE START/END nodes */ 61 | XMLParseCompact /* compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree) */ 62 | XMLParseOld10 /* parse using XML-1.0 before update 5 */ 63 | XMLParseNoBaseFix /* do not fixup XINCLUDE xml:base uris */ 64 | XMLParseHuge /* relax any hardcoded limit from the parser */ 65 | XMLParseOldSAX /* parse using SAX2 interface before 2.7.0 */ 66 | XMLParseIgnoreEnc /* ignore internal document encoding hint */ 67 | XMLParseBigLines /* Store big lines numbers in text PSVI field */ 68 | XMLParseMax 69 | XMLParseEmptyOption Option = 0 70 | ) 71 | 72 | // Ctxt represents the Parser context. You normally should be using 73 | // Parser, but if you for some reason need to do more low-level 74 | // magic you will have to tinker with this struct 75 | type Ctxt struct { 76 | ptr uintptr // *C.xmlParserCtxt 77 | } 78 | 79 | // Parser represents the high-level parser. 80 | type Parser struct { 81 | Options Option 82 | } 83 | -------------------------------------------------------------------------------- /parser/parser.go: -------------------------------------------------------------------------------- 1 | package parser 2 | 3 | import ( 4 | "bytes" 5 | "io" 6 | 7 | "github.com/lestrrat-go/libxml2/clib" 8 | "github.com/lestrrat-go/libxml2/dom" 9 | "github.com/lestrrat-go/libxml2/types" 10 | "github.com/pkg/errors" 11 | ) 12 | 13 | const _OptionName = "RecoverNoEntDTDLoadDTDAttrDTDValidNoErrorNoWarningPedanticNoBlanksSAX1XIncludeNoNetNoDictNscleanNoCDATANoXIncNodeCompactOld10NoBaseFixHugeOldSAXIgnoreEncBigLines" 14 | 15 | var _OptionMap = map[int]string{ 16 | 1: _OptionName[0:7], 17 | 2: _OptionName[7:12], 18 | 4: _OptionName[12:19], 19 | 8: _OptionName[19:26], 20 | 16: _OptionName[26:34], 21 | 32: _OptionName[34:41], 22 | 64: _OptionName[41:50], 23 | 128: _OptionName[50:58], 24 | 256: _OptionName[58:66], 25 | 512: _OptionName[66:70], 26 | 1024: _OptionName[70:78], 27 | 2048: _OptionName[78:83], 28 | 4096: _OptionName[83:89], 29 | 8192: _OptionName[89:96], 30 | 16384: _OptionName[96:103], 31 | 32768: _OptionName[103:113], 32 | 65536: _OptionName[113:120], 33 | 131072: _OptionName[120:125], 34 | 262144: _OptionName[125:134], 35 | 524288: _OptionName[134:138], 36 | 1048576: _OptionName[138:144], 37 | 2097152: _OptionName[144:153], 38 | 4194304: _OptionName[153:161], 39 | } 40 | 41 | // Set flips the option bit in the given Option 42 | func (o *Option) Set(options ...Option) { 43 | v := int(*o) // current value 44 | for _, i := range options { 45 | v = v | int(i) 46 | } 47 | *o = Option(v) 48 | } 49 | 50 | // String creates a string representation of the Option 51 | func (o Option) String() string { 52 | if o == XMLParseEmptyOption { 53 | return "[]" 54 | } 55 | 56 | i := int(o) 57 | b := bytes.Buffer{} 58 | b.Write([]byte{'['}) 59 | for x := 1; x < int(XMLParseMax); x = x << 1 { 60 | if (i & x) == x { 61 | v, ok := _OptionMap[x] 62 | if !ok { 63 | v = "Option(Unknown)" 64 | } 65 | b.WriteString(v) 66 | b.Write([]byte{'|'}) 67 | } 68 | } 69 | x := b.Bytes() 70 | if x[len(x)-1] == '|' { 71 | x[len(x)-1] = ']' 72 | } else { 73 | x = append(x, ']') 74 | } 75 | return string(x) 76 | } 77 | 78 | // New creates a new Parser with the given options. 79 | func New(opts ...Option) *Parser { 80 | var o Option 81 | 82 | for _, opt := range opts { 83 | o = o | opt 84 | } 85 | 86 | return &Parser{ 87 | Options: o, 88 | } 89 | } 90 | 91 | // Parse parses XML from the given byte buffer 92 | func (p *Parser) Parse(buf []byte) (types.Document, error) { 93 | return p.ParseString(string(buf)) 94 | } 95 | 96 | // ParseString parses XML from the given string 97 | func (p *Parser) ParseString(s string) (types.Document, error) { 98 | ctx, err := NewCtxt(s, p.Options) 99 | if err != nil { 100 | return nil, errors.Wrap(err, "failed to create parse context") 101 | } 102 | defer func() { _ = ctx.Free() }() 103 | 104 | docptr, err := clib.XMLCtxtReadMemory(ctx, s, "", "", int(p.Options)) 105 | if err != nil { 106 | return nil, errors.Wrap(err, "failed to create parse input") 107 | } 108 | 109 | if docptr != 0 { 110 | return dom.WrapDocument(docptr), nil 111 | } 112 | return nil, errors.New("failed to generate document pointer") 113 | } 114 | 115 | // ParseReader parses XML from the given io.Reader 116 | func (p *Parser) ParseReader(in io.Reader) (types.Document, error) { 117 | buf := &bytes.Buffer{} 118 | if _, err := buf.ReadFrom(in); err != nil { 119 | return nil, errors.Wrap(err, "failed to read from reader") 120 | } 121 | 122 | return p.ParseString(buf.String()) 123 | } 124 | 125 | // NewCtxt creates a new Parser context 126 | func NewCtxt(s string, o Option) (*Ctxt, error) { 127 | ctxptr, err := clib.XMLCreateMemoryParserCtxt(s, int(o)) 128 | if err != nil { 129 | return nil, errors.Wrap(err, "failed to execute XMLCreateMemoryParserCtxt") 130 | } 131 | return &Ctxt{ptr: ctxptr}, nil 132 | } 133 | 134 | // Pointer returns the underlying C struct 135 | func (ctx Ctxt) Pointer() uintptr { 136 | return ctx.ptr 137 | } 138 | 139 | // Parse starts the parsing on the Ctxt 140 | func (ctx Ctxt) Parse() error { 141 | return clib.XMLParseDocument(ctx) 142 | } 143 | 144 | // Free releases the underlying C struct 145 | func (ctx *Ctxt) Free() error { 146 | if err := clib.XMLFreeParserCtxt(ctx); err != nil { 147 | return errors.Wrap(err, "failed to free parser context") 148 | } 149 | 150 | ctx.ptr = 0 151 | return nil 152 | } 153 | -------------------------------------------------------------------------------- /parser_test.go: -------------------------------------------------------------------------------- 1 | package libxml2 2 | 3 | import ( 4 | "regexp" 5 | "testing" 6 | 7 | "github.com/lestrrat-go/libxml2/dom" 8 | "github.com/lestrrat-go/libxml2/types" 9 | 10 | "github.com/lestrrat-go/libxml2/clib" 11 | "github.com/lestrrat-go/libxml2/parser" 12 | "github.com/stretchr/testify/assert" 13 | ) 14 | 15 | const stdXMLDecl = `` + "\n" 16 | 17 | var ( 18 | goodWFNSStrings = []string{ 19 | stdXMLDecl + `Lorem Ipsum
`) 9 | if err != nil { 10 | panic(err) 11 | } 12 | doc.Free() 13 | } 14 | -------------------------------------------------------------------------------- /test/schema/lib/types/cksum.xsd: -------------------------------------------------------------------------------- 1 | 2 |86 | /KaCzo4Syrom78z3EQ5SbbB4sF7ey80etKII864WF64B81uRpH5t9jQTxe 87 | Eu0ImbzRMqzVDZkVG9xD7nN1kuFw== 88 |
89 |li7dzDacuo67Jg7mtqEm2TRuOMU=90 |