| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056 |
- // Copyright 2009 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 implements a simple XML 1.0 parser that
- // understands XML name spaces.
- package xml
- // References:
- // Annotated XML spec: https://www.xml.com/axml/testaxml.htm
- // XML name spaces: https://www.w3.org/TR/REC-xml-names/
- // TODO(rsc):
- // Test error handling.
- import (
- "bufio"
- "bytes"
- "errors"
- "fmt"
- "io"
- "reflect"
- "strconv"
- "strings"
- "unicode"
- "unicode/utf8"
- )
- // A SyntaxError represents a syntax error in the XML input stream.
- type SyntaxError struct {
- Msg string
- Line int
- }
- func (e *SyntaxError) Error() string {
- return "XML syntax error on line " + strconv.Itoa(e.Line) + ": " + e.Msg
- }
- // A Name represents an XML name (Local) annotated
- // with a name space identifier (Space).
- // In tokens returned by Decoder.Token, the Space identifier
- // is given as a canonical URL, not the short prefix used
- // in the document being parsed.
- type Name struct {
- Space, Local string
- }
- // An Attr represents an attribute in an XML element (Name=Value).
- type Attr struct {
- Name Name
- Value string
- }
- // A Token is an interface holding one of the token types:
- // StartElement, EndElement, CharData, Comment, ProcInst, or Directive.
- type Token interface{}
- // A StartElement represents an XML start element.
- type StartElement struct {
- Name Name
- Attr []Attr
- }
- // Copy creates a new copy of StartElement.
- func (e StartElement) Copy() StartElement {
- attrs := make([]Attr, len(e.Attr))
- copy(attrs, e.Attr)
- e.Attr = attrs
- return e
- }
- // End returns the corresponding XML end element.
- func (e StartElement) End() EndElement {
- return EndElement{e.Name}
- }
- // An EndElement represents an XML end element.
- type EndElement struct {
- Name Name
- }
- // A CharData represents XML character data (raw text),
- // in which XML escape sequences have been replaced by
- // the characters they represent.
- type CharData []byte
- func makeCopy(b []byte) []byte {
- b1 := make([]byte, len(b))
- copy(b1, b)
- return b1
- }
- // Copy creates a new copy of CharData.
- func (c CharData) Copy() CharData { return CharData(makeCopy(c)) }
- // A Comment represents an XML comment of the form <!--comment-->.
- // The bytes do not include the <!-- and --> comment markers.
- type Comment []byte
- // Copy creates a new copy of Comment.
- func (c Comment) Copy() Comment { return Comment(makeCopy(c)) }
- // A ProcInst represents an XML processing instruction of the form <?target inst?>
- type ProcInst struct {
- Target string
- Inst []byte
- }
- // Copy creates a new copy of ProcInst.
- func (p ProcInst) Copy() ProcInst {
- p.Inst = makeCopy(p.Inst)
- return p
- }
- // A Directive represents an XML directive of the form <!text>.
- // The bytes do not include the <! and > markers.
- type Directive []byte
- // Copy creates a new copy of Directive.
- func (d Directive) Copy() Directive { return Directive(makeCopy(d)) }
- // CopyToken returns a copy of a Token.
- func CopyToken(t Token) Token {
- switch v := t.(type) {
- case CharData:
- return v.Copy()
- case Comment:
- return v.Copy()
- case Directive:
- return v.Copy()
- case ProcInst:
- return v.Copy()
- case StartElement:
- return v.Copy()
- }
- return t
- }
- // A TokenReader is anything that can decode a stream of XML tokens, including a
- // Decoder.
- //
- // When Token encounters an error or end-of-file condition after successfully
- // reading a token, it returns the token. It may return the (non-nil) error from
- // the same call or return the error (and a nil token) from a subsequent call.
- // An instance of this general case is that a TokenReader returning a non-nil
- // token at the end of the token stream may return either io.EOF or a nil error.
- // The next Read should return nil, io.EOF.
- //
- // Implementations of Token are discouraged from returning a nil token with a
- // nil error. Callers should treat a return of nil, nil as indicating that
- // nothing happened; in particular it does not indicate EOF.
- type TokenReader interface {
- Token() (Token, error)
- }
- // A Decoder represents an XML parser reading a particular input stream.
- // The parser assumes that its input is encoded in UTF-8.
- type Decoder struct {
- // Strict defaults to true, enforcing the requirements
- // of the XML specification.
- // If set to false, the parser allows input containing common
- // mistakes:
- // * If an element is missing an end tag, the parser invents
- // end tags as necessary to keep the return values from Token
- // properly balanced.
- // * In attribute values and character data, unknown or malformed
- // character entities (sequences beginning with &) are left alone.
- //
- // Setting:
- //
- // d.Strict = false
- // d.AutoClose = xml.HTMLAutoClose
- // d.Entity = xml.HTMLEntity
- //
- // creates a parser that can handle typical HTML.
- //
- // Strict mode does not enforce the requirements of the XML name spaces TR.
- // In particular it does not reject name space tags using undefined prefixes.
- // Such tags are recorded with the unknown prefix as the name space URL.
- Strict bool
- // When Strict == false, AutoClose indicates a set of elements to
- // consider closed immediately after they are opened, regardless
- // of whether an end element is present.
- AutoClose []string
- // Entity can be used to map non-standard entity names to string replacements.
- // The parser behaves as if these standard mappings are present in the map,
- // regardless of the actual map content:
- //
- // "lt": "<",
- // "gt": ">",
- // "amp": "&",
- // "apos": "'",
- // "quot": `"`,
- Entity map[string]string
- // CharsetReader, if non-nil, defines a function to generate
- // charset-conversion readers, converting from the provided
- // non-UTF-8 charset into UTF-8. If CharsetReader is nil or
- // returns an error, parsing stops with an error. One of the
- // CharsetReader's result values must be non-nil.
- CharsetReader func(charset string, input io.Reader) (io.Reader, error)
- // DefaultSpace sets the default name space used for unadorned tags,
- // as if the entire XML stream were wrapped in an element containing
- // the attribute xmlns="DefaultSpace".
- DefaultSpace string
- // TypeFunc is used to map type names to actual types.
- TypeFunc func(string) (reflect.Type, bool)
- r io.ByteReader
- t TokenReader
- buf bytes.Buffer
- saved *bytes.Buffer
- stk *stack
- free *stack
- needClose bool
- toClose Name
- nextToken Token
- nextByte int
- ns map[string]string
- err error
- line int
- offset int64
- unmarshalDepth int
- }
- // NewDecoder creates a new XML parser reading from r.
- // If r does not implement io.ByteReader, NewDecoder will
- // do its own buffering.
- func NewDecoder(r io.Reader) *Decoder {
- d := &Decoder{
- ns: make(map[string]string),
- nextByte: -1,
- line: 1,
- Strict: true,
- }
- d.switchToReader(r)
- return d
- }
- // NewTokenDecoder creates a new XML parser using an underlying token stream.
- func NewTokenDecoder(t TokenReader) *Decoder {
- // Is it already a Decoder?
- if d, ok := t.(*Decoder); ok {
- return d
- }
- d := &Decoder{
- ns: make(map[string]string),
- t: t,
- nextByte: -1,
- line: 1,
- Strict: true,
- }
- return d
- }
- // Token returns the next XML token in the input stream.
- // At the end of the input stream, Token returns nil, io.EOF.
- //
- // Slices of bytes in the returned token data refer to the
- // parser's internal buffer and remain valid only until the next
- // call to Token. To acquire a copy of the bytes, call CopyToken
- // or the token's Copy method.
- //
- // Token expands self-closing elements such as <br/>
- // into separate start and end elements returned by successive calls.
- //
- // Token guarantees that the StartElement and EndElement
- // tokens it returns are properly nested and matched:
- // if Token encounters an unexpected end element
- // or EOF before all expected end elements,
- // it will return an error.
- //
- // Token implements XML name spaces as described by
- // https://www.w3.org/TR/REC-xml-names/. Each of the
- // Name structures contained in the Token has the Space
- // set to the URL identifying its name space when known.
- // If Token encounters an unrecognized name space prefix,
- // it uses the prefix as the Space rather than report an error.
- func (d *Decoder) Token() (Token, error) {
- var t Token
- var err error
- if d.stk != nil && d.stk.kind == stkEOF {
- return nil, io.EOF
- }
- if d.nextToken != nil {
- t = d.nextToken
- d.nextToken = nil
- } else if t, err = d.rawToken(); err != nil {
- switch {
- case err == io.EOF && d.t != nil:
- err = nil
- case err == io.EOF && d.stk != nil && d.stk.kind != stkEOF:
- err = d.syntaxError("unexpected EOF")
- }
- return t, err
- }
- if !d.Strict {
- if t1, ok := d.autoClose(t); ok {
- d.nextToken = t
- t = t1
- }
- }
- switch t1 := t.(type) {
- case StartElement:
- // In XML name spaces, the translations listed in the
- // attributes apply to the element name and
- // to the other attribute names, so process
- // the translations first.
- for _, a := range t1.Attr {
- if a.Name.Space == xmlnsPrefix {
- v, ok := d.ns[a.Name.Local]
- d.pushNs(a.Name.Local, v, ok)
- d.ns[a.Name.Local] = a.Value
- }
- if a.Name.Space == "" && a.Name.Local == xmlnsPrefix {
- // Default space for untagged names
- v, ok := d.ns[""]
- d.pushNs("", v, ok)
- d.ns[""] = a.Value
- }
- }
- d.translate(&t1.Name, true)
- for i := range t1.Attr {
- d.translate(&t1.Attr[i].Name, false)
- }
- d.pushElement(t1.Name)
- t = t1
- case EndElement:
- d.translate(&t1.Name, true)
- if !d.popElement(&t1) {
- return nil, d.err
- }
- t = t1
- }
- return t, err
- }
- const (
- xmlURL = "http://www.w3.org/XML/1998/namespace"
- xmlnsPrefix = "xmlns"
- xmlPrefix = "xml"
- )
- // Apply name space translation to name n.
- // The default name space (for Space=="")
- // applies only to element names, not to attribute names.
- func (d *Decoder) translate(n *Name, isElementName bool) {
- switch {
- case n.Space == xmlnsPrefix:
- return
- case n.Space == "" && !isElementName:
- return
- case n.Space == xmlPrefix:
- n.Space = xmlURL
- case n.Space == "" && n.Local == xmlnsPrefix:
- return
- }
- if v, ok := d.ns[n.Space]; ok {
- n.Space = v
- } else if n.Space == "" {
- n.Space = d.DefaultSpace
- }
- }
- func (d *Decoder) switchToReader(r io.Reader) {
- // Get efficient byte at a time reader.
- // Assume that if reader has its own
- // ReadByte, it's efficient enough.
- // Otherwise, use bufio.
- if rb, ok := r.(io.ByteReader); ok {
- d.r = rb
- } else {
- d.r = bufio.NewReader(r)
- }
- }
- // Parsing state - stack holds old name space translations
- // and the current set of open elements. The translations to pop when
- // ending a given tag are *below* it on the stack, which is
- // more work but forced on us by XML.
- type stack struct {
- next *stack
- kind int
- name Name
- ok bool
- }
- const (
- stkStart = iota
- stkNs
- stkEOF
- )
- func (d *Decoder) push(kind int) *stack {
- s := d.free
- if s != nil {
- d.free = s.next
- } else {
- s = new(stack)
- }
- s.next = d.stk
- s.kind = kind
- d.stk = s
- return s
- }
- func (d *Decoder) pop() *stack {
- s := d.stk
- if s != nil {
- d.stk = s.next
- s.next = d.free
- d.free = s
- }
- return s
- }
- // Record that after the current element is finished
- // (that element is already pushed on the stack)
- // Token should return EOF until popEOF is called.
- func (d *Decoder) pushEOF() {
- // Walk down stack to find Start.
- // It might not be the top, because there might be stkNs
- // entries above it.
- start := d.stk
- for start.kind != stkStart {
- start = start.next
- }
- // The stkNs entries below a start are associated with that
- // element too; skip over them.
- for start.next != nil && start.next.kind == stkNs {
- start = start.next
- }
- s := d.free
- if s != nil {
- d.free = s.next
- } else {
- s = new(stack)
- }
- s.kind = stkEOF
- s.next = start.next
- start.next = s
- }
- // Undo a pushEOF.
- // The element must have been finished, so the EOF should be at the top of the stack.
- func (d *Decoder) popEOF() bool {
- if d.stk == nil || d.stk.kind != stkEOF {
- return false
- }
- d.pop()
- return true
- }
- // Record that we are starting an element with the given name.
- func (d *Decoder) pushElement(name Name) {
- s := d.push(stkStart)
- s.name = name
- }
- // Record that we are changing the value of ns[local].
- // The old value is url, ok.
- func (d *Decoder) pushNs(local string, url string, ok bool) {
- s := d.push(stkNs)
- s.name.Local = local
- s.name.Space = url
- s.ok = ok
- }
- // Creates a SyntaxError with the current line number.
- func (d *Decoder) syntaxError(msg string) error {
- return &SyntaxError{Msg: msg, Line: d.line}
- }
- // Record that we are ending an element with the given name.
- // The name must match the record at the top of the stack,
- // which must be a pushElement record.
- // After popping the element, apply any undo records from
- // the stack to restore the name translations that existed
- // before we saw this element.
- func (d *Decoder) popElement(t *EndElement) bool {
- s := d.pop()
- name := t.Name
- switch {
- case s == nil || s.kind != stkStart:
- d.err = d.syntaxError("unexpected end element </" + name.Local + ">")
- return false
- case s.name.Local != name.Local:
- if !d.Strict {
- d.needClose = true
- d.toClose = t.Name
- t.Name = s.name
- return true
- }
- d.err = d.syntaxError("element <" + s.name.Local + "> closed by </" + name.Local + ">")
- return false
- case s.name.Space != name.Space:
- d.err = d.syntaxError("element <" + s.name.Local + "> in space " + s.name.Space +
- "closed by </" + name.Local + "> in space " + name.Space)
- return false
- }
- // Pop stack until a Start or EOF is on the top, undoing the
- // translations that were associated with the element we just closed.
- for d.stk != nil && d.stk.kind != stkStart && d.stk.kind != stkEOF {
- s := d.pop()
- if s.ok {
- d.ns[s.name.Local] = s.name.Space
- } else {
- delete(d.ns, s.name.Local)
- }
- }
- return true
- }
- // If the top element on the stack is autoclosing and
- // t is not the end tag, invent the end tag.
- func (d *Decoder) autoClose(t Token) (Token, bool) {
- if d.stk == nil || d.stk.kind != stkStart {
- return nil, false
- }
- name := strings.ToLower(d.stk.name.Local)
- for _, s := range d.AutoClose {
- if strings.ToLower(s) == name {
- // This one should be auto closed if t doesn't close it.
- et, ok := t.(EndElement)
- if !ok || et.Name.Local != name {
- return EndElement{d.stk.name}, true
- }
- break
- }
- }
- return nil, false
- }
- var errRawToken = errors.New("xml: cannot use RawToken from UnmarshalXML method")
- // RawToken is like Token but does not verify that
- // start and end elements match and does not translate
- // name space prefixes to their corresponding URLs.
- func (d *Decoder) RawToken() (Token, error) {
- if d.unmarshalDepth > 0 {
- return nil, errRawToken
- }
- return d.rawToken()
- }
- func (d *Decoder) rawToken() (Token, error) {
- if d.t != nil {
- return d.t.Token()
- }
- if d.err != nil {
- return nil, d.err
- }
- if d.needClose {
- // The last element we read was self-closing and
- // we returned just the StartElement half.
- // Return the EndElement half now.
- d.needClose = false
- return EndElement{d.toClose}, nil
- }
- b, ok := d.getc()
- if !ok {
- return nil, d.err
- }
- if b != '<' {
- // Text section.
- d.ungetc(b)
- data := d.text(-1, false)
- if data == nil {
- return nil, d.err
- }
- return CharData(data), nil
- }
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- switch b {
- case '/':
- // </: End element
- var name Name
- if name, ok = d.nsname(); !ok {
- if d.err == nil {
- d.err = d.syntaxError("expected element name after </")
- }
- return nil, d.err
- }
- d.space()
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b != '>' {
- d.err = d.syntaxError("invalid characters between </" + name.Local + " and >")
- return nil, d.err
- }
- return EndElement{name}, nil
- case '?':
- // <?: Processing instruction.
- var target string
- if target, ok = d.name(); !ok {
- if d.err == nil {
- d.err = d.syntaxError("expected target name after <?")
- }
- return nil, d.err
- }
- d.space()
- d.buf.Reset()
- var b0 byte
- for {
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- d.buf.WriteByte(b)
- if b0 == '?' && b == '>' {
- break
- }
- b0 = b
- }
- data := d.buf.Bytes()
- data = data[0 : len(data)-2] // chop ?>
- if target == "xml" {
- content := string(data)
- ver := procInst("version", content)
- if ver != "" && ver != "1.0" {
- d.err = fmt.Errorf("xml: unsupported version %q; only version 1.0 is supported", ver)
- return nil, d.err
- }
- enc := procInst("encoding", content)
- if enc != "" && enc != "utf-8" && enc != "UTF-8" && !strings.EqualFold(enc, "utf-8") {
- if d.CharsetReader == nil {
- d.err = fmt.Errorf("xml: encoding %q declared but Decoder.CharsetReader is nil", enc)
- return nil, d.err
- }
- newr, err := d.CharsetReader(enc, d.r.(io.Reader))
- if err != nil {
- d.err = fmt.Errorf("xml: opening charset %q: %v", enc, err)
- return nil, d.err
- }
- if newr == nil {
- panic("CharsetReader returned a nil Reader for charset " + enc)
- }
- d.switchToReader(newr)
- }
- }
- return ProcInst{target, data}, nil
- case '!':
- // <!: Maybe comment, maybe CDATA.
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- switch b {
- case '-': // <!-
- // Probably <!-- for a comment.
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b != '-' {
- d.err = d.syntaxError("invalid sequence <!- not part of <!--")
- return nil, d.err
- }
- // Look for terminator.
- d.buf.Reset()
- var b0, b1 byte
- for {
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- d.buf.WriteByte(b)
- if b0 == '-' && b1 == '-' {
- if b != '>' {
- d.err = d.syntaxError(
- `invalid sequence "--" not allowed in comments`)
- return nil, d.err
- }
- break
- }
- b0, b1 = b1, b
- }
- data := d.buf.Bytes()
- data = data[0 : len(data)-3] // chop -->
- return Comment(data), nil
- case '[': // <![
- // Probably <![CDATA[.
- for i := 0; i < 6; i++ {
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b != "CDATA["[i] {
- d.err = d.syntaxError("invalid <![ sequence")
- return nil, d.err
- }
- }
- // Have <![CDATA[. Read text until ]]>.
- data := d.text(-1, true)
- if data == nil {
- return nil, d.err
- }
- return CharData(data), nil
- }
- // Probably a directive: <!DOCTYPE ...>, <!ENTITY ...>, etc.
- // We don't care, but accumulate for caller. Quoted angle
- // brackets do not count for nesting.
- d.buf.Reset()
- d.buf.WriteByte(b)
- inquote := uint8(0)
- depth := 0
- for {
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if inquote == 0 && b == '>' && depth == 0 {
- break
- }
- HandleB:
- d.buf.WriteByte(b)
- switch {
- case b == inquote:
- inquote = 0
- case inquote != 0:
- // in quotes, no special action
- case b == '\'' || b == '"':
- inquote = b
- case b == '>' && inquote == 0:
- depth--
- case b == '<' && inquote == 0:
- // Look for <!-- to begin comment.
- s := "!--"
- for i := 0; i < len(s); i++ {
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b != s[i] {
- for j := 0; j < i; j++ {
- d.buf.WriteByte(s[j])
- }
- depth++
- goto HandleB
- }
- }
- // Remove < that was written above.
- d.buf.Truncate(d.buf.Len() - 1)
- // Look for terminator.
- var b0, b1 byte
- for {
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b0 == '-' && b1 == '-' && b == '>' {
- break
- }
- b0, b1 = b1, b
- }
- }
- }
- return Directive(d.buf.Bytes()), nil
- }
- // Must be an open element like <a href="foo">
- d.ungetc(b)
- var (
- name Name
- empty bool
- attr []Attr
- )
- if name, ok = d.nsname(); !ok {
- if d.err == nil {
- d.err = d.syntaxError("expected element name after <")
- }
- return nil, d.err
- }
- attr = []Attr{}
- for {
- d.space()
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b == '/' {
- empty = true
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b != '>' {
- d.err = d.syntaxError("expected /> in element")
- return nil, d.err
- }
- break
- }
- if b == '>' {
- break
- }
- d.ungetc(b)
- a := Attr{}
- if a.Name, ok = d.nsname(); !ok {
- if d.err == nil {
- d.err = d.syntaxError("expected attribute name in element")
- }
- return nil, d.err
- }
- d.space()
- if b, ok = d.mustgetc(); !ok {
- return nil, d.err
- }
- if b != '=' {
- if d.Strict {
- d.err = d.syntaxError("attribute name without = in element")
- return nil, d.err
- }
- d.ungetc(b)
- a.Value = a.Name.Local
- } else {
- d.space()
- data := d.attrval()
- if data == nil {
- return nil, d.err
- }
- a.Value = string(data)
- }
- attr = append(attr, a)
- }
- if empty {
- d.needClose = true
- d.toClose = name
- }
- return StartElement{name, attr}, nil
- }
- func (d *Decoder) attrval() []byte {
- b, ok := d.mustgetc()
- if !ok {
- return nil
- }
- // Handle quoted attribute values
- if b == '"' || b == '\'' {
- return d.text(int(b), false)
- }
- // Handle unquoted attribute values for strict parsers
- if d.Strict {
- d.err = d.syntaxError("unquoted or missing attribute value in element")
- return nil
- }
- // Handle unquoted attribute values for unstrict parsers
- d.ungetc(b)
- d.buf.Reset()
- for {
- b, ok = d.mustgetc()
- if !ok {
- return nil
- }
- // https://www.w3.org/TR/REC-html40/intro/sgmltut.html#h-3.2.2
- if 'a' <= b && b <= 'z' || 'A' <= b && b <= 'Z' ||
- '0' <= b && b <= '9' || b == '_' || b == ':' || b == '-' {
- d.buf.WriteByte(b)
- } else {
- d.ungetc(b)
- break
- }
- }
- return d.buf.Bytes()
- }
- // Skip spaces if any
- func (d *Decoder) space() {
- for {
- b, ok := d.getc()
- if !ok {
- return
- }
- switch b {
- case ' ', '\r', '\n', '\t':
- default:
- d.ungetc(b)
- return
- }
- }
- }
- // Read a single byte.
- // If there is no byte to read, return ok==false
- // and leave the error in d.err.
- // Maintain line number.
- func (d *Decoder) getc() (b byte, ok bool) {
- if d.err != nil {
- return 0, false
- }
- if d.nextByte >= 0 {
- b = byte(d.nextByte)
- d.nextByte = -1
- } else {
- b, d.err = d.r.ReadByte()
- if d.err != nil {
- return 0, false
- }
- if d.saved != nil {
- d.saved.WriteByte(b)
- }
- }
- if b == '\n' {
- d.line++
- }
- d.offset++
- return b, true
- }
- // InputOffset returns the input stream byte offset of the current decoder position.
- // The offset gives the location of the end of the most recently returned token
- // and the beginning of the next token.
- func (d *Decoder) InputOffset() int64 {
- return d.offset
- }
- // Return saved offset.
- // If we did ungetc (nextByte >= 0), have to back up one.
- func (d *Decoder) savedOffset() int {
- n := d.saved.Len()
- if d.nextByte >= 0 {
- n--
- }
- return n
- }
- // Must read a single byte.
- // If there is no byte to read,
- // set d.err to SyntaxError("unexpected EOF")
- // and return ok==false
- func (d *Decoder) mustgetc() (b byte, ok bool) {
- if b, ok = d.getc(); !ok {
- if d.err == io.EOF {
- d.err = d.syntaxError("unexpected EOF")
- }
- }
- return
- }
- // Unread a single byte.
- func (d *Decoder) ungetc(b byte) {
- if b == '\n' {
- d.line--
- }
- d.nextByte = int(b)
- d.offset--
- }
- var entity = map[string]rune{
- "lt": '<',
- "gt": '>',
- "amp": '&',
- "apos": '\'',
- "quot": '"',
- }
- // Read plain text section (XML calls it character data).
- // If quote >= 0, we are in a quoted string and need to find the matching quote.
- // If cdata == true, we are in a <![CDATA[ section and need to find ]]>.
- // On failure return nil and leave the error in d.err.
- func (d *Decoder) text(quote int, cdata bool) []byte {
- var b0, b1 byte
- var trunc int
- d.buf.Reset()
- Input:
- for {
- b, ok := d.getc()
- if !ok {
- if cdata {
- if d.err == io.EOF {
- d.err = d.syntaxError("unexpected EOF in CDATA section")
- }
- return nil
- }
- break Input
- }
- // <![CDATA[ section ends with ]]>.
- // It is an error for ]]> to appear in ordinary text.
- if b0 == ']' && b1 == ']' && b == '>' {
- if cdata {
- trunc = 2
- break Input
- }
- d.err = d.syntaxError("unescaped ]]> not in CDATA section")
- return nil
- }
- // Stop reading text if we see a <.
- if b == '<' && !cdata {
- if quote >= 0 {
- d.err = d.syntaxError("unescaped < inside quoted string")
- return nil
- }
- d.ungetc('<')
- break Input
- }
- if quote >= 0 && b == byte(quote) {
- break Input
- }
- if b == '&' && !cdata {
- // Read escaped character expression up to semicolon.
- // XML in all its glory allows a document to define and use
- // its own character names with <!ENTITY ...> directives.
- // Parsers are required to recognize lt, gt, amp, apos, and quot
- // even if they have not been declared.
- before := d.buf.Len()
- d.buf.WriteByte('&')
- var ok bool
- var text string
- var haveText bool
- if b, ok = d.mustgetc(); !ok {
- return nil
- }
- if b == '#' {
- d.buf.WriteByte(b)
- if b, ok = d.mustgetc(); !ok {
- return nil
- }
- base := 10
- if b == 'x' {
- base = 16
- d.buf.WriteByte(b)
- if b, ok = d.mustgetc(); !ok {
- return nil
- }
- }
- start := d.buf.Len()
- for '0' <= b && b <= '9' ||
- base == 16 && 'a' <= b && b <= 'f' ||
- base == 16 && 'A' <= b && b <= 'F' {
- d.buf.WriteByte(b)
- if b, ok = d.mustgetc(); !ok {
- return nil
- }
- }
- if b != ';' {
- d.ungetc(b)
- } else {
- s := string(d.buf.Bytes()[start:])
- d.buf.WriteByte(';')
- n, err := strconv.ParseUint(s, base, 64)
- if err == nil && n <= unicode.MaxRune {
- text = string(rune(n))
- haveText = true
- }
- }
- } else {
- d.ungetc(b)
- if !d.readName() {
- if d.err != nil {
- return nil
- }
- }
- if b, ok = d.mustgetc(); !ok {
- return nil
- }
- if b != ';' {
- d.ungetc(b)
- } else {
- name := d.buf.Bytes()[before+1:]
- d.buf.WriteByte(';')
- if isName(name) {
- s := string(name)
- if r, ok := entity[s]; ok {
- text = string(r)
- haveText = true
- } else if d.Entity != nil {
- text, haveText = d.Entity[s]
- }
- }
- }
- }
- if haveText {
- d.buf.Truncate(before)
- d.buf.Write([]byte(text))
- b0, b1 = 0, 0
- continue Input
- }
- if !d.Strict {
- b0, b1 = 0, 0
- continue Input
- }
- ent := string(d.buf.Bytes()[before:])
- if ent[len(ent)-1] != ';' {
- ent += " (no semicolon)"
- }
- d.err = d.syntaxError("invalid character entity " + ent)
- return nil
- }
- // We must rewrite unescaped \r and \r\n into \n.
- if b == '\r' {
- d.buf.WriteByte('\n')
- } else if b1 == '\r' && b == '\n' {
- // Skip \r\n--we already wrote \n.
- } else {
- d.buf.WriteByte(b)
- }
- b0, b1 = b1, b
- }
- data := d.buf.Bytes()
- data = data[0 : len(data)-trunc]
- // Inspect each rune for being a disallowed character.
- buf := data
- for len(buf) > 0 {
- r, size := utf8.DecodeRune(buf)
- if r == utf8.RuneError && size == 1 {
- d.err = d.syntaxError("invalid UTF-8")
- return nil
- }
- buf = buf[size:]
- if !isInCharacterRange(r) {
- d.err = d.syntaxError(fmt.Sprintf("illegal character code %U", r))
- return nil
- }
- }
- return data
- }
- // Decide whether the given rune is in the XML Character Range, per
- // the Char production of https://www.xml.com/axml/testaxml.htm,
- // Section 2.2 Characters.
- func isInCharacterRange(r rune) (inrange bool) {
- return r == 0x09 ||
- r == 0x0A ||
- r == 0x0D ||
- r >= 0x20 && r <= 0xD7FF ||
- r >= 0xE000 && r <= 0xFFFD ||
- r >= 0x10000 && r <= 0x10FFFF
- }
- // Get name space name: name with a : stuck in the middle.
- // The part before the : is the name space identifier.
- func (d *Decoder) nsname() (name Name, ok bool) {
- s, ok := d.name()
- if !ok {
- return
- }
- i := strings.Index(s, ":")
- if i < 0 {
- name.Local = s
- } else {
- name.Space = s[0:i]
- name.Local = s[i+1:]
- }
- return name, true
- }
- // Get name: /first(first|second)*/
- // Do not set d.err if the name is missing (unless unexpected EOF is received):
- // let the caller provide better context.
- func (d *Decoder) name() (s string, ok bool) {
- d.buf.Reset()
- if !d.readName() {
- return "", false
- }
- // Now we check the characters.
- b := d.buf.Bytes()
- if !isName(b) {
- d.err = d.syntaxError("invalid XML name: " + string(b))
- return "", false
- }
- return string(b), true
- }
- // Read a name and append its bytes to d.buf.
- // The name is delimited by any single-byte character not valid in names.
- // All multi-byte characters are accepted; the caller must check their validity.
- func (d *Decoder) readName() (ok bool) {
- var b byte
- if b, ok = d.mustgetc(); !ok {
- return
- }
- if b < utf8.RuneSelf && !isNameByte(b) {
- d.ungetc(b)
- return false
- }
- d.buf.WriteByte(b)
- for {
- if b, ok = d.mustgetc(); !ok {
- return
- }
- if b < utf8.RuneSelf && !isNameByte(b) {
- d.ungetc(b)
- break
- }
- d.buf.WriteByte(b)
- }
- return true
- }
- func isNameByte(c byte) bool {
- return 'A' <= c && c <= 'Z' ||
- 'a' <= c && c <= 'z' ||
- '0' <= c && c <= '9' ||
- c == '_' || c == ':' || c == '.' || c == '-'
- }
- func isName(s []byte) bool {
- if len(s) == 0 {
- return false
- }
- c, n := utf8.DecodeRune(s)
- if c == utf8.RuneError && n == 1 {
- return false
- }
- if !unicode.Is(first, c) {
- return false
- }
- for n < len(s) {
- s = s[n:]
- c, n = utf8.DecodeRune(s)
- if c == utf8.RuneError && n == 1 {
- return false
- }
- if !unicode.Is(first, c) && !unicode.Is(second, c) {
- return false
- }
- }
- return true
- }
- func isNameString(s string) bool {
- if len(s) == 0 {
- return false
- }
- c, n := utf8.DecodeRuneInString(s)
- if c == utf8.RuneError && n == 1 {
- return false
- }
- if !unicode.Is(first, c) {
- return false
- }
- for n < len(s) {
- s = s[n:]
- c, n = utf8.DecodeRuneInString(s)
- if c == utf8.RuneError && n == 1 {
- return false
- }
- if !unicode.Is(first, c) && !unicode.Is(second, c) {
- return false
- }
- }
- return true
- }
- // These tables were generated by cut and paste from Appendix B of
- // the XML spec at https://www.xml.com/axml/testaxml.htm
- // and then reformatting. First corresponds to (Letter | '_' | ':')
- // and second corresponds to NameChar.
- var first = &unicode.RangeTable{
- R16: []unicode.Range16{
- {0x003A, 0x003A, 1},
- {0x0041, 0x005A, 1},
- {0x005F, 0x005F, 1},
- {0x0061, 0x007A, 1},
- {0x00C0, 0x00D6, 1},
- {0x00D8, 0x00F6, 1},
- {0x00F8, 0x00FF, 1},
- {0x0100, 0x0131, 1},
- {0x0134, 0x013E, 1},
- {0x0141, 0x0148, 1},
- {0x014A, 0x017E, 1},
- {0x0180, 0x01C3, 1},
- {0x01CD, 0x01F0, 1},
- {0x01F4, 0x01F5, 1},
- {0x01FA, 0x0217, 1},
- {0x0250, 0x02A8, 1},
- {0x02BB, 0x02C1, 1},
- {0x0386, 0x0386, 1},
- {0x0388, 0x038A, 1},
- {0x038C, 0x038C, 1},
- {0x038E, 0x03A1, 1},
- {0x03A3, 0x03CE, 1},
- {0x03D0, 0x03D6, 1},
- {0x03DA, 0x03E0, 2},
- {0x03E2, 0x03F3, 1},
- {0x0401, 0x040C, 1},
- {0x040E, 0x044F, 1},
- {0x0451, 0x045C, 1},
- {0x045E, 0x0481, 1},
- {0x0490, 0x04C4, 1},
- {0x04C7, 0x04C8, 1},
- {0x04CB, 0x04CC, 1},
- {0x04D0, 0x04EB, 1},
- {0x04EE, 0x04F5, 1},
- {0x04F8, 0x04F9, 1},
- {0x0531, 0x0556, 1},
- {0x0559, 0x0559, 1},
- {0x0561, 0x0586, 1},
- {0x05D0, 0x05EA, 1},
- {0x05F0, 0x05F2, 1},
- {0x0621, 0x063A, 1},
- {0x0641, 0x064A, 1},
- {0x0671, 0x06B7, 1},
- {0x06BA, 0x06BE, 1},
- {0x06C0, 0x06CE, 1},
- {0x06D0, 0x06D3, 1},
- {0x06D5, 0x06D5, 1},
- {0x06E5, 0x06E6, 1},
- {0x0905, 0x0939, 1},
- {0x093D, 0x093D, 1},
- {0x0958, 0x0961, 1},
- {0x0985, 0x098C, 1},
- {0x098F, 0x0990, 1},
- {0x0993, 0x09A8, 1},
- {0x09AA, 0x09B0, 1},
- {0x09B2, 0x09B2, 1},
- {0x09B6, 0x09B9, 1},
- {0x09DC, 0x09DD, 1},
- {0x09DF, 0x09E1, 1},
- {0x09F0, 0x09F1, 1},
- {0x0A05, 0x0A0A, 1},
- {0x0A0F, 0x0A10, 1},
- {0x0A13, 0x0A28, 1},
- {0x0A2A, 0x0A30, 1},
- {0x0A32, 0x0A33, 1},
- {0x0A35, 0x0A36, 1},
- {0x0A38, 0x0A39, 1},
- {0x0A59, 0x0A5C, 1},
- {0x0A5E, 0x0A5E, 1},
- {0x0A72, 0x0A74, 1},
- {0x0A85, 0x0A8B, 1},
- {0x0A8D, 0x0A8D, 1},
- {0x0A8F, 0x0A91, 1},
- {0x0A93, 0x0AA8, 1},
- {0x0AAA, 0x0AB0, 1},
- {0x0AB2, 0x0AB3, 1},
- {0x0AB5, 0x0AB9, 1},
- {0x0ABD, 0x0AE0, 0x23},
- {0x0B05, 0x0B0C, 1},
- {0x0B0F, 0x0B10, 1},
- {0x0B13, 0x0B28, 1},
- {0x0B2A, 0x0B30, 1},
- {0x0B32, 0x0B33, 1},
- {0x0B36, 0x0B39, 1},
- {0x0B3D, 0x0B3D, 1},
- {0x0B5C, 0x0B5D, 1},
- {0x0B5F, 0x0B61, 1},
- {0x0B85, 0x0B8A, 1},
- {0x0B8E, 0x0B90, 1},
- {0x0B92, 0x0B95, 1},
- {0x0B99, 0x0B9A, 1},
- {0x0B9C, 0x0B9C, 1},
- {0x0B9E, 0x0B9F, 1},
- {0x0BA3, 0x0BA4, 1},
- {0x0BA8, 0x0BAA, 1},
- {0x0BAE, 0x0BB5, 1},
- {0x0BB7, 0x0BB9, 1},
- {0x0C05, 0x0C0C, 1},
- {0x0C0E, 0x0C10, 1},
- {0x0C12, 0x0C28, 1},
- {0x0C2A, 0x0C33, 1},
- {0x0C35, 0x0C39, 1},
- {0x0C60, 0x0C61, 1},
- {0x0C85, 0x0C8C, 1},
- {0x0C8E, 0x0C90, 1},
- {0x0C92, 0x0CA8, 1},
- {0x0CAA, 0x0CB3, 1},
- {0x0CB5, 0x0CB9, 1},
- {0x0CDE, 0x0CDE, 1},
- {0x0CE0, 0x0CE1, 1},
- {0x0D05, 0x0D0C, 1},
- {0x0D0E, 0x0D10, 1},
- {0x0D12, 0x0D28, 1},
- {0x0D2A, 0x0D39, 1},
- {0x0D60, 0x0D61, 1},
- {0x0E01, 0x0E2E, 1},
- {0x0E30, 0x0E30, 1},
- {0x0E32, 0x0E33, 1},
- {0x0E40, 0x0E45, 1},
- {0x0E81, 0x0E82, 1},
- {0x0E84, 0x0E84, 1},
- {0x0E87, 0x0E88, 1},
- {0x0E8A, 0x0E8D, 3},
- {0x0E94, 0x0E97, 1},
- {0x0E99, 0x0E9F, 1},
- {0x0EA1, 0x0EA3, 1},
- {0x0EA5, 0x0EA7, 2},
- {0x0EAA, 0x0EAB, 1},
- {0x0EAD, 0x0EAE, 1},
- {0x0EB0, 0x0EB0, 1},
- {0x0EB2, 0x0EB3, 1},
- {0x0EBD, 0x0EBD, 1},
- {0x0EC0, 0x0EC4, 1},
- {0x0F40, 0x0F47, 1},
- {0x0F49, 0x0F69, 1},
- {0x10A0, 0x10C5, 1},
- {0x10D0, 0x10F6, 1},
- {0x1100, 0x1100, 1},
- {0x1102, 0x1103, 1},
- {0x1105, 0x1107, 1},
- {0x1109, 0x1109, 1},
- {0x110B, 0x110C, 1},
- {0x110E, 0x1112, 1},
- {0x113C, 0x1140, 2},
- {0x114C, 0x1150, 2},
- {0x1154, 0x1155, 1},
- {0x1159, 0x1159, 1},
- {0x115F, 0x1161, 1},
- {0x1163, 0x1169, 2},
- {0x116D, 0x116E, 1},
- {0x1172, 0x1173, 1},
- {0x1175, 0x119E, 0x119E - 0x1175},
- {0x11A8, 0x11AB, 0x11AB - 0x11A8},
- {0x11AE, 0x11AF, 1},
- {0x11B7, 0x11B8, 1},
- {0x11BA, 0x11BA, 1},
- {0x11BC, 0x11C2, 1},
- {0x11EB, 0x11F0, 0x11F0 - 0x11EB},
- {0x11F9, 0x11F9, 1},
- {0x1E00, 0x1E9B, 1},
- {0x1EA0, 0x1EF9, 1},
- {0x1F00, 0x1F15, 1},
- {0x1F18, 0x1F1D, 1},
- {0x1F20, 0x1F45, 1},
- {0x1F48, 0x1F4D, 1},
- {0x1F50, 0x1F57, 1},
- {0x1F59, 0x1F5B, 0x1F5B - 0x1F59},
- {0x1F5D, 0x1F5D, 1},
- {0x1F5F, 0x1F7D, 1},
- {0x1F80, 0x1FB4, 1},
- {0x1FB6, 0x1FBC, 1},
- {0x1FBE, 0x1FBE, 1},
- {0x1FC2, 0x1FC4, 1},
- {0x1FC6, 0x1FCC, 1},
- {0x1FD0, 0x1FD3, 1},
- {0x1FD6, 0x1FDB, 1},
- {0x1FE0, 0x1FEC, 1},
- {0x1FF2, 0x1FF4, 1},
- {0x1FF6, 0x1FFC, 1},
- {0x2126, 0x2126, 1},
- {0x212A, 0x212B, 1},
- {0x212E, 0x212E, 1},
- {0x2180, 0x2182, 1},
- {0x3007, 0x3007, 1},
- {0x3021, 0x3029, 1},
- {0x3041, 0x3094, 1},
- {0x30A1, 0x30FA, 1},
- {0x3105, 0x312C, 1},
- {0x4E00, 0x9FA5, 1},
- {0xAC00, 0xD7A3, 1},
- },
- }
- var second = &unicode.RangeTable{
- R16: []unicode.Range16{
- {0x002D, 0x002E, 1},
- {0x0030, 0x0039, 1},
- {0x00B7, 0x00B7, 1},
- {0x02D0, 0x02D1, 1},
- {0x0300, 0x0345, 1},
- {0x0360, 0x0361, 1},
- {0x0387, 0x0387, 1},
- {0x0483, 0x0486, 1},
- {0x0591, 0x05A1, 1},
- {0x05A3, 0x05B9, 1},
- {0x05BB, 0x05BD, 1},
- {0x05BF, 0x05BF, 1},
- {0x05C1, 0x05C2, 1},
- {0x05C4, 0x0640, 0x0640 - 0x05C4},
- {0x064B, 0x0652, 1},
- {0x0660, 0x0669, 1},
- {0x0670, 0x0670, 1},
- {0x06D6, 0x06DC, 1},
- {0x06DD, 0x06DF, 1},
- {0x06E0, 0x06E4, 1},
- {0x06E7, 0x06E8, 1},
- {0x06EA, 0x06ED, 1},
- {0x06F0, 0x06F9, 1},
- {0x0901, 0x0903, 1},
- {0x093C, 0x093C, 1},
- {0x093E, 0x094C, 1},
- {0x094D, 0x094D, 1},
- {0x0951, 0x0954, 1},
- {0x0962, 0x0963, 1},
- {0x0966, 0x096F, 1},
- {0x0981, 0x0983, 1},
- {0x09BC, 0x09BC, 1},
- {0x09BE, 0x09BF, 1},
- {0x09C0, 0x09C4, 1},
- {0x09C7, 0x09C8, 1},
- {0x09CB, 0x09CD, 1},
- {0x09D7, 0x09D7, 1},
- {0x09E2, 0x09E3, 1},
- {0x09E6, 0x09EF, 1},
- {0x0A02, 0x0A3C, 0x3A},
- {0x0A3E, 0x0A3F, 1},
- {0x0A40, 0x0A42, 1},
- {0x0A47, 0x0A48, 1},
- {0x0A4B, 0x0A4D, 1},
- {0x0A66, 0x0A6F, 1},
- {0x0A70, 0x0A71, 1},
- {0x0A81, 0x0A83, 1},
- {0x0ABC, 0x0ABC, 1},
- {0x0ABE, 0x0AC5, 1},
- {0x0AC7, 0x0AC9, 1},
- {0x0ACB, 0x0ACD, 1},
- {0x0AE6, 0x0AEF, 1},
- {0x0B01, 0x0B03, 1},
- {0x0B3C, 0x0B3C, 1},
- {0x0B3E, 0x0B43, 1},
- {0x0B47, 0x0B48, 1},
- {0x0B4B, 0x0B4D, 1},
- {0x0B56, 0x0B57, 1},
- {0x0B66, 0x0B6F, 1},
- {0x0B82, 0x0B83, 1},
- {0x0BBE, 0x0BC2, 1},
- {0x0BC6, 0x0BC8, 1},
- {0x0BCA, 0x0BCD, 1},
- {0x0BD7, 0x0BD7, 1},
- {0x0BE7, 0x0BEF, 1},
- {0x0C01, 0x0C03, 1},
- {0x0C3E, 0x0C44, 1},
- {0x0C46, 0x0C48, 1},
- {0x0C4A, 0x0C4D, 1},
- {0x0C55, 0x0C56, 1},
- {0x0C66, 0x0C6F, 1},
- {0x0C82, 0x0C83, 1},
- {0x0CBE, 0x0CC4, 1},
- {0x0CC6, 0x0CC8, 1},
- {0x0CCA, 0x0CCD, 1},
- {0x0CD5, 0x0CD6, 1},
- {0x0CE6, 0x0CEF, 1},
- {0x0D02, 0x0D03, 1},
- {0x0D3E, 0x0D43, 1},
- {0x0D46, 0x0D48, 1},
- {0x0D4A, 0x0D4D, 1},
- {0x0D57, 0x0D57, 1},
- {0x0D66, 0x0D6F, 1},
- {0x0E31, 0x0E31, 1},
- {0x0E34, 0x0E3A, 1},
- {0x0E46, 0x0E46, 1},
- {0x0E47, 0x0E4E, 1},
- {0x0E50, 0x0E59, 1},
- {0x0EB1, 0x0EB1, 1},
- {0x0EB4, 0x0EB9, 1},
- {0x0EBB, 0x0EBC, 1},
- {0x0EC6, 0x0EC6, 1},
- {0x0EC8, 0x0ECD, 1},
- {0x0ED0, 0x0ED9, 1},
- {0x0F18, 0x0F19, 1},
- {0x0F20, 0x0F29, 1},
- {0x0F35, 0x0F39, 2},
- {0x0F3E, 0x0F3F, 1},
- {0x0F71, 0x0F84, 1},
- {0x0F86, 0x0F8B, 1},
- {0x0F90, 0x0F95, 1},
- {0x0F97, 0x0F97, 1},
- {0x0F99, 0x0FAD, 1},
- {0x0FB1, 0x0FB7, 1},
- {0x0FB9, 0x0FB9, 1},
- {0x20D0, 0x20DC, 1},
- {0x20E1, 0x3005, 0x3005 - 0x20E1},
- {0x302A, 0x302F, 1},
- {0x3031, 0x3035, 1},
- {0x3099, 0x309A, 1},
- {0x309D, 0x309E, 1},
- {0x30FC, 0x30FE, 1},
- },
- }
- // HTMLEntity is an entity map containing translations for the
- // standard HTML entity characters.
- //
- // See the Decoder.Strict and Decoder.Entity fields' documentation.
- var HTMLEntity map[string]string = htmlEntity
- var htmlEntity = map[string]string{
- /*
- hget http://www.w3.org/TR/html4/sgml/entities.html |
- ssam '
- ,y /\>/ x/\<(.|\n)+/ s/\n/ /g
- ,x v/^\<!ENTITY/d
- ,s/\<!ENTITY ([^ ]+) .*U\+([0-9A-F][0-9A-F][0-9A-F][0-9A-F]) .+/ "\1": "\\u\2",/g
- '
- */
- "nbsp": "\u00A0",
- "iexcl": "\u00A1",
- "cent": "\u00A2",
- "pound": "\u00A3",
- "curren": "\u00A4",
- "yen": "\u00A5",
- "brvbar": "\u00A6",
- "sect": "\u00A7",
- "uml": "\u00A8",
- "copy": "\u00A9",
- "ordf": "\u00AA",
- "laquo": "\u00AB",
- "not": "\u00AC",
- "shy": "\u00AD",
- "reg": "\u00AE",
- "macr": "\u00AF",
- "deg": "\u00B0",
- "plusmn": "\u00B1",
- "sup2": "\u00B2",
- "sup3": "\u00B3",
- "acute": "\u00B4",
- "micro": "\u00B5",
- "para": "\u00B6",
- "middot": "\u00B7",
- "cedil": "\u00B8",
- "sup1": "\u00B9",
- "ordm": "\u00BA",
- "raquo": "\u00BB",
- "frac14": "\u00BC",
- "frac12": "\u00BD",
- "frac34": "\u00BE",
- "iquest": "\u00BF",
- "Agrave": "\u00C0",
- "Aacute": "\u00C1",
- "Acirc": "\u00C2",
- "Atilde": "\u00C3",
- "Auml": "\u00C4",
- "Aring": "\u00C5",
- "AElig": "\u00C6",
- "Ccedil": "\u00C7",
- "Egrave": "\u00C8",
- "Eacute": "\u00C9",
- "Ecirc": "\u00CA",
- "Euml": "\u00CB",
- "Igrave": "\u00CC",
- "Iacute": "\u00CD",
- "Icirc": "\u00CE",
- "Iuml": "\u00CF",
- "ETH": "\u00D0",
- "Ntilde": "\u00D1",
- "Ograve": "\u00D2",
- "Oacute": "\u00D3",
- "Ocirc": "\u00D4",
- "Otilde": "\u00D5",
- "Ouml": "\u00D6",
- "times": "\u00D7",
- "Oslash": "\u00D8",
- "Ugrave": "\u00D9",
- "Uacute": "\u00DA",
- "Ucirc": "\u00DB",
- "Uuml": "\u00DC",
- "Yacute": "\u00DD",
- "THORN": "\u00DE",
- "szlig": "\u00DF",
- "agrave": "\u00E0",
- "aacute": "\u00E1",
- "acirc": "\u00E2",
- "atilde": "\u00E3",
- "auml": "\u00E4",
- "aring": "\u00E5",
- "aelig": "\u00E6",
- "ccedil": "\u00E7",
- "egrave": "\u00E8",
- "eacute": "\u00E9",
- "ecirc": "\u00EA",
- "euml": "\u00EB",
- "igrave": "\u00EC",
- "iacute": "\u00ED",
- "icirc": "\u00EE",
- "iuml": "\u00EF",
- "eth": "\u00F0",
- "ntilde": "\u00F1",
- "ograve": "\u00F2",
- "oacute": "\u00F3",
- "ocirc": "\u00F4",
- "otilde": "\u00F5",
- "ouml": "\u00F6",
- "divide": "\u00F7",
- "oslash": "\u00F8",
- "ugrave": "\u00F9",
- "uacute": "\u00FA",
- "ucirc": "\u00FB",
- "uuml": "\u00FC",
- "yacute": "\u00FD",
- "thorn": "\u00FE",
- "yuml": "\u00FF",
- "fnof": "\u0192",
- "Alpha": "\u0391",
- "Beta": "\u0392",
- "Gamma": "\u0393",
- "Delta": "\u0394",
- "Epsilon": "\u0395",
- "Zeta": "\u0396",
- "Eta": "\u0397",
- "Theta": "\u0398",
- "Iota": "\u0399",
- "Kappa": "\u039A",
- "Lambda": "\u039B",
- "Mu": "\u039C",
- "Nu": "\u039D",
- "Xi": "\u039E",
- "Omicron": "\u039F",
- "Pi": "\u03A0",
- "Rho": "\u03A1",
- "Sigma": "\u03A3",
- "Tau": "\u03A4",
- "Upsilon": "\u03A5",
- "Phi": "\u03A6",
- "Chi": "\u03A7",
- "Psi": "\u03A8",
- "Omega": "\u03A9",
- "alpha": "\u03B1",
- "beta": "\u03B2",
- "gamma": "\u03B3",
- "delta": "\u03B4",
- "epsilon": "\u03B5",
- "zeta": "\u03B6",
- "eta": "\u03B7",
- "theta": "\u03B8",
- "iota": "\u03B9",
- "kappa": "\u03BA",
- "lambda": "\u03BB",
- "mu": "\u03BC",
- "nu": "\u03BD",
- "xi": "\u03BE",
- "omicron": "\u03BF",
- "pi": "\u03C0",
- "rho": "\u03C1",
- "sigmaf": "\u03C2",
- "sigma": "\u03C3",
- "tau": "\u03C4",
- "upsilon": "\u03C5",
- "phi": "\u03C6",
- "chi": "\u03C7",
- "psi": "\u03C8",
- "omega": "\u03C9",
- "thetasym": "\u03D1",
- "upsih": "\u03D2",
- "piv": "\u03D6",
- "bull": "\u2022",
- "hellip": "\u2026",
- "prime": "\u2032",
- "Prime": "\u2033",
- "oline": "\u203E",
- "frasl": "\u2044",
- "weierp": "\u2118",
- "image": "\u2111",
- "real": "\u211C",
- "trade": "\u2122",
- "alefsym": "\u2135",
- "larr": "\u2190",
- "uarr": "\u2191",
- "rarr": "\u2192",
- "darr": "\u2193",
- "harr": "\u2194",
- "crarr": "\u21B5",
- "lArr": "\u21D0",
- "uArr": "\u21D1",
- "rArr": "\u21D2",
- "dArr": "\u21D3",
- "hArr": "\u21D4",
- "forall": "\u2200",
- "part": "\u2202",
- "exist": "\u2203",
- "empty": "\u2205",
- "nabla": "\u2207",
- "isin": "\u2208",
- "notin": "\u2209",
- "ni": "\u220B",
- "prod": "\u220F",
- "sum": "\u2211",
- "minus": "\u2212",
- "lowast": "\u2217",
- "radic": "\u221A",
- "prop": "\u221D",
- "infin": "\u221E",
- "ang": "\u2220",
- "and": "\u2227",
- "or": "\u2228",
- "cap": "\u2229",
- "cup": "\u222A",
- "int": "\u222B",
- "there4": "\u2234",
- "sim": "\u223C",
- "cong": "\u2245",
- "asymp": "\u2248",
- "ne": "\u2260",
- "equiv": "\u2261",
- "le": "\u2264",
- "ge": "\u2265",
- "sub": "\u2282",
- "sup": "\u2283",
- "nsub": "\u2284",
- "sube": "\u2286",
- "supe": "\u2287",
- "oplus": "\u2295",
- "otimes": "\u2297",
- "perp": "\u22A5",
- "sdot": "\u22C5",
- "lceil": "\u2308",
- "rceil": "\u2309",
- "lfloor": "\u230A",
- "rfloor": "\u230B",
- "lang": "\u2329",
- "rang": "\u232A",
- "loz": "\u25CA",
- "spades": "\u2660",
- "clubs": "\u2663",
- "hearts": "\u2665",
- "diams": "\u2666",
- "quot": "\u0022",
- "amp": "\u0026",
- "lt": "\u003C",
- "gt": "\u003E",
- "OElig": "\u0152",
- "oelig": "\u0153",
- "Scaron": "\u0160",
- "scaron": "\u0161",
- "Yuml": "\u0178",
- "circ": "\u02C6",
- "tilde": "\u02DC",
- "ensp": "\u2002",
- "emsp": "\u2003",
- "thinsp": "\u2009",
- "zwnj": "\u200C",
- "zwj": "\u200D",
- "lrm": "\u200E",
- "rlm": "\u200F",
- "ndash": "\u2013",
- "mdash": "\u2014",
- "lsquo": "\u2018",
- "rsquo": "\u2019",
- "sbquo": "\u201A",
- "ldquo": "\u201C",
- "rdquo": "\u201D",
- "bdquo": "\u201E",
- "dagger": "\u2020",
- "Dagger": "\u2021",
- "permil": "\u2030",
- "lsaquo": "\u2039",
- "rsaquo": "\u203A",
- "euro": "\u20AC",
- }
- // HTMLAutoClose is the set of HTML elements that
- // should be considered to close automatically.
- //
- // See the Decoder.Strict and Decoder.Entity fields' documentation.
- var HTMLAutoClose []string = htmlAutoClose
- var htmlAutoClose = []string{
- /*
- hget http://www.w3.org/TR/html4/loose.dtd |
- 9 sed -n 's/<!ELEMENT ([^ ]*) +- O EMPTY.+/ "\1",/p' | tr A-Z a-z
- */
- "basefont",
- "br",
- "area",
- "link",
- "img",
- "param",
- "hr",
- "input",
- "col",
- "frame",
- "isindex",
- "base",
- "meta",
- }
- var (
- escQuot = []byte(""") // shorter than """
- escApos = []byte("'") // shorter than "'"
- escAmp = []byte("&")
- escLT = []byte("<")
- escGT = []byte(">")
- escTab = []byte("	")
- escNL = []byte("
")
- escCR = []byte("
")
- escFFFD = []byte("\uFFFD") // Unicode replacement character
- )
- // EscapeText writes to w the properly escaped XML equivalent
- // of the plain text data s.
- func EscapeText(w io.Writer, s []byte) error {
- return escapeText(w, s, true)
- }
- // escapeText writes to w the properly escaped XML equivalent
- // of the plain text data s. If escapeNewline is true, newline
- // characters will be escaped.
- func escapeText(w io.Writer, s []byte, escapeNewline bool) error {
- var esc []byte
- last := 0
- for i := 0; i < len(s); {
- r, width := utf8.DecodeRune(s[i:])
- i += width
- switch r {
- case '"':
- esc = escQuot
- case '\'':
- esc = escApos
- case '&':
- esc = escAmp
- case '<':
- esc = escLT
- case '>':
- esc = escGT
- case '\t':
- esc = escTab
- case '\n':
- if !escapeNewline {
- continue
- }
- esc = escNL
- case '\r':
- esc = escCR
- default:
- if !isInCharacterRange(r) || (r == 0xFFFD && width == 1) {
- esc = escFFFD
- break
- }
- continue
- }
- if _, err := w.Write(s[last : i-width]); err != nil {
- return err
- }
- if _, err := w.Write(esc); err != nil {
- return err
- }
- last = i
- }
- _, err := w.Write(s[last:])
- return err
- }
- // EscapeString writes to p the properly escaped XML equivalent
- // of the plain text data s.
- func (p *printer) EscapeString(s string) {
- var esc []byte
- last := 0
- for i := 0; i < len(s); {
- r, width := utf8.DecodeRuneInString(s[i:])
- i += width
- switch r {
- case '"':
- esc = escQuot
- case '\'':
- esc = escApos
- case '&':
- esc = escAmp
- case '<':
- esc = escLT
- case '>':
- esc = escGT
- case '\t':
- esc = escTab
- case '\n':
- esc = escNL
- case '\r':
- esc = escCR
- default:
- if !isInCharacterRange(r) || (r == 0xFFFD && width == 1) {
- esc = escFFFD
- break
- }
- continue
- }
- p.WriteString(s[last : i-width])
- p.Write(esc)
- last = i
- }
- p.WriteString(s[last:])
- }
- // Escape is like EscapeText but omits the error return value.
- // It is provided for backwards compatibility with Go 1.0.
- // Code targeting Go 1.1 or later should use EscapeText.
- func Escape(w io.Writer, s []byte) {
- EscapeText(w, s)
- }
- var (
- cdataStart = []byte("<![CDATA[")
- cdataEnd = []byte("]]>")
- cdataEscape = []byte("]]]]><![CDATA[>")
- )
- // emitCDATA writes to w the CDATA-wrapped plain text data s.
- // It escapes CDATA directives nested in s.
- func emitCDATA(w io.Writer, s []byte) error {
- if len(s) == 0 {
- return nil
- }
- if _, err := w.Write(cdataStart); err != nil {
- return err
- }
- for {
- i := bytes.Index(s, cdataEnd)
- if i >= 0 && i+len(cdataEnd) <= len(s) {
- // Found a nested CDATA directive end.
- if _, err := w.Write(s[:i]); err != nil {
- return err
- }
- if _, err := w.Write(cdataEscape); err != nil {
- return err
- }
- i += len(cdataEnd)
- } else {
- if _, err := w.Write(s); err != nil {
- return err
- }
- break
- }
- s = s[i:]
- }
- _, err := w.Write(cdataEnd)
- return err
- }
- // procInst parses the `param="..."` or `param='...'`
- // value out of the provided string, returning "" if not found.
- func procInst(param, s string) string {
- // TODO: this parsing is somewhat lame and not exact.
- // It works for all actual cases, though.
- param = param + "="
- idx := strings.Index(s, param)
- if idx == -1 {
- return ""
- }
- v := s[idx+len(param):]
- if v == "" {
- return ""
- }
- if v[0] != '\'' && v[0] != '"' {
- return ""
- }
- idx = strings.IndexRune(v[1:], rune(v[0]))
- if idx == -1 {
- return ""
- }
- return v[1 : idx+1]
- }
|