1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // Package xml implements a simple XML 1.0 parser that
6 // understands XML name spaces.
10 // Annotated XML spec: http://www.xml.com/axml/testaxml.htm
11 // XML name spaces: http://www.w3.org/TR/REC-xml-names/
14 // Test error handling.
28 // A SyntaxError represents a syntax error in the XML input stream.
29 type SyntaxError
struct {
34 func (e
*SyntaxError
) Error() string {
35 return "XML syntax error on line " + strconv
.Itoa(e
.Line
) + ": " + e
.Msg
38 // A Name represents an XML name (Local) annotated
39 // with a name space identifier (Space).
40 // In tokens returned by Decoder.Token, the Space identifier
41 // is given as a canonical URL, not the short prefix used
42 // in the document being parsed.
47 // An Attr represents an attribute in an XML element (Name=Value).
53 // A Token is an interface holding one of the token types:
54 // StartElement, EndElement, CharData, Comment, ProcInst, or Directive.
55 type Token
interface{}
57 // A StartElement represents an XML start element.
58 type StartElement
struct {
63 func (e StartElement
) Copy() StartElement
{
64 attrs
:= make([]Attr
, len(e
.Attr
))
70 // End returns the corresponding XML end element.
71 func (e StartElement
) End() EndElement
{
72 return EndElement
{e
.Name
}
75 // An EndElement represents an XML end element.
76 type EndElement
struct {
80 // A CharData represents XML character data (raw text),
81 // in which XML escape sequences have been replaced by
82 // the characters they represent.
85 func makeCopy(b
[]byte) []byte {
86 b1
:= make([]byte, len(b
))
91 func (c CharData
) Copy() CharData
{ return CharData(makeCopy(c
)) }
93 // A Comment represents an XML comment of the form <!--comment-->.
94 // The bytes do not include the <!-- and --> comment markers.
97 func (c Comment
) Copy() Comment
{ return Comment(makeCopy(c
)) }
99 // A ProcInst represents an XML processing instruction of the form <?target inst?>
100 type ProcInst
struct {
105 func (p ProcInst
) Copy() ProcInst
{
106 p
.Inst
= makeCopy(p
.Inst
)
110 // A Directive represents an XML directive of the form <!text>.
111 // The bytes do not include the <! and > markers.
112 type Directive
[]byte
114 func (d Directive
) Copy() Directive
{ return Directive(makeCopy(d
)) }
116 // CopyToken returns a copy of a Token.
117 func CopyToken(t Token
) Token
{
118 switch v
:= t
.(type) {
133 // A Decoder represents an XML parser reading a particular input stream.
134 // The parser assumes that its input is encoded in UTF-8.
135 type Decoder
struct {
136 // Strict defaults to true, enforcing the requirements
137 // of the XML specification.
138 // If set to false, the parser allows input containing common
140 // * If an element is missing an end tag, the parser invents
141 // end tags as necessary to keep the return values from Token
142 // properly balanced.
143 // * In attribute values and character data, unknown or malformed
144 // character entities (sequences beginning with &) are left alone.
149 // d.AutoClose = HTMLAutoClose;
150 // d.Entity = HTMLEntity
152 // creates a parser that can handle typical HTML.
154 // Strict mode does not enforce the requirements of the XML name spaces TR.
155 // In particular it does not reject name space tags using undefined prefixes.
156 // Such tags are recorded with the unknown prefix as the name space URL.
159 // When Strict == false, AutoClose indicates a set of elements to
160 // consider closed immediately after they are opened, regardless
161 // of whether an end element is present.
164 // Entity can be used to map non-standard entity names to string replacements.
165 // The parser behaves as if these standard mappings are present in the map,
166 // regardless of the actual map content:
173 Entity
map[string]string
175 // CharsetReader, if non-nil, defines a function to generate
176 // charset-conversion readers, converting from the provided
177 // non-UTF-8 charset into UTF-8. If CharsetReader is nil or
178 // returns an error, parsing stops with an error. One of the
179 // the CharsetReader's result values must be non-nil.
180 CharsetReader
func(charset
string, input io
.Reader
) (io
.Reader
, error
)
182 // DefaultSpace sets the default name space used for unadorned tags,
183 // as if the entire XML stream were wrapped in an element containing
184 // the attribute xmlns="DefaultSpace".
203 // NewDecoder creates a new XML parser reading from r.
204 // If r does not implement io.ByteReader, NewDecoder will
205 // do its own buffering.
206 func NewDecoder(r io
.Reader
) *Decoder
{
208 ns
: make(map[string]string),
217 // Token returns the next XML token in the input stream.
218 // At the end of the input stream, Token returns nil, io.EOF.
220 // Slices of bytes in the returned token data refer to the
221 // parser's internal buffer and remain valid only until the next
222 // call to Token. To acquire a copy of the bytes, call CopyToken
223 // or the token's Copy method.
225 // Token expands self-closing elements such as <br/>
226 // into separate start and end elements returned by successive calls.
228 // Token guarantees that the StartElement and EndElement
229 // tokens it returns are properly nested and matched:
230 // if Token encounters an unexpected end element
231 // or EOF before all expected end elements,
232 // it will return an error.
234 // Token implements XML name spaces as described by
235 // http://www.w3.org/TR/REC-xml-names/. Each of the
236 // Name structures contained in the Token has the Space
237 // set to the URL identifying its name space when known.
238 // If Token encounters an unrecognized name space prefix,
239 // it uses the prefix as the Space rather than report an error.
240 func (d
*Decoder
) Token() (Token
, error
) {
243 if d
.stk
!= nil && d
.stk
.kind
== stkEOF
{
246 if d
.nextToken
!= nil {
249 } else if t
, err
= d
.rawToken(); err
!= nil {
250 if err
== io
.EOF
&& d
.stk
!= nil && d
.stk
.kind
!= stkEOF
{
251 err
= d
.syntaxError("unexpected EOF")
257 if t1
, ok
:= d
.autoClose(t
); ok
{
262 switch t1
:= t
.(type) {
264 // In XML name spaces, the translations listed in the
265 // attributes apply to the element name and
266 // to the other attribute names, so process
267 // the translations first.
268 for _
, a
:= range t1
.Attr
{
269 if a
.Name
.Space
== "xmlns" {
270 v
, ok
:= d
.ns
[a
.Name
.Local
]
271 d
.pushNs(a
.Name
.Local
, v
, ok
)
272 d
.ns
[a
.Name
.Local
] = a
.Value
274 if a
.Name
.Space
== "" && a
.Name
.Local
== "xmlns" {
275 // Default space for untagged names
282 d
.translate(&t1
.Name
, true)
283 for i
:= range t1
.Attr
{
284 d
.translate(&t1
.Attr
[i
].Name
, false)
286 d
.pushElement(t1
.Name
)
290 d
.translate(&t1
.Name
, true)
291 if !d
.popElement(&t1
) {
299 const xmlURL
= "http://www.w3.org/XML/1998/namespace"
301 // Apply name space translation to name n.
302 // The default name space (for Space=="")
303 // applies only to element names, not to attribute names.
304 func (d
*Decoder
) translate(n
*Name
, isElementName
bool) {
306 case n
.Space
== "xmlns":
308 case n
.Space
== "" && !isElementName
:
310 case n
.Space
== "xml":
312 case n
.Space
== "" && n
.Local
== "xmlns":
315 if v
, ok
:= d
.ns
[n
.Space
]; ok
{
317 } else if n
.Space
== "" {
318 n
.Space
= d
.DefaultSpace
322 func (d
*Decoder
) switchToReader(r io
.Reader
) {
323 // Get efficient byte at a time reader.
324 // Assume that if reader has its own
325 // ReadByte, it's efficient enough.
326 // Otherwise, use bufio.
327 if rb
, ok
:= r
.(io
.ByteReader
); ok
{
330 d
.r
= bufio
.NewReader(r
)
334 // Parsing state - stack holds old name space translations
335 // and the current set of open elements. The translations to pop when
336 // ending a given tag are *below* it on the stack, which is
337 // more work but forced on us by XML.
351 func (d
*Decoder
) push(kind
int) *stack
{
364 func (d
*Decoder
) pop() *stack
{
374 // Record that after the current element is finished
375 // (that element is already pushed on the stack)
376 // Token should return EOF until popEOF is called.
377 func (d
*Decoder
) pushEOF() {
378 // Walk down stack to find Start.
379 // It might not be the top, because there might be stkNs
382 for start
.kind
!= stkStart
{
385 // The stkNs entries below a start are associated with that
386 // element too; skip over them.
387 for start
.next
!= nil && start
.next
.kind
== stkNs
{
402 // The element must have been finished, so the EOF should be at the top of the stack.
403 func (d
*Decoder
) popEOF() bool {
404 if d
.stk
== nil || d
.stk
.kind
!= stkEOF
{
411 // Record that we are starting an element with the given name.
412 func (d
*Decoder
) pushElement(name Name
) {
413 s
:= d
.push(stkStart
)
417 // Record that we are changing the value of ns[local].
418 // The old value is url, ok.
419 func (d
*Decoder
) pushNs(local
string, url
string, ok
bool) {
426 // Creates a SyntaxError with the current line number.
427 func (d
*Decoder
) syntaxError(msg
string) error
{
428 return &SyntaxError
{Msg
: msg
, Line
: d
.line
}
431 // Record that we are ending an element with the given name.
432 // The name must match the record at the top of the stack,
433 // which must be a pushElement record.
434 // After popping the element, apply any undo records from
435 // the stack to restore the name translations that existed
436 // before we saw this element.
437 func (d
*Decoder
) popElement(t
*EndElement
) bool {
441 case s
== nil || s
.kind
!= stkStart
:
442 d
.err
= d
.syntaxError("unexpected end element </" + name
.Local
+ ">")
444 case s
.name
.Local
!= name
.Local
:
451 d
.err
= d
.syntaxError("element <" + s
.name
.Local
+ "> closed by </" + name
.Local
+ ">")
453 case s
.name
.Space
!= name
.Space
:
454 d
.err
= d
.syntaxError("element <" + s
.name
.Local
+ "> in space " + s
.name
.Space
+
455 "closed by </" + name
.Local
+ "> in space " + name
.Space
)
459 // Pop stack until a Start or EOF is on the top, undoing the
460 // translations that were associated with the element we just closed.
461 for d
.stk
!= nil && d
.stk
.kind
!= stkStart
&& d
.stk
.kind
!= stkEOF
{
464 d
.ns
[s
.name
.Local
] = s
.name
.Space
466 delete(d
.ns
, s
.name
.Local
)
473 // If the top element on the stack is autoclosing and
474 // t is not the end tag, invent the end tag.
475 func (d
*Decoder
) autoClose(t Token
) (Token
, bool) {
476 if d
.stk
== nil || d
.stk
.kind
!= stkStart
{
479 name
:= strings
.ToLower(d
.stk
.name
.Local
)
480 for _
, s
:= range d
.AutoClose
{
481 if strings
.ToLower(s
) == name
{
482 // This one should be auto closed if t doesn't close it.
483 et
, ok
:= t
.(EndElement
)
484 if !ok || et
.Name
.Local
!= name
{
485 return EndElement
{d
.stk
.name
}, true
493 var errRawToken
= errors
.New("xml: cannot use RawToken from UnmarshalXML method")
495 // RawToken is like Token but does not verify that
496 // start and end elements match and does not translate
497 // name space prefixes to their corresponding URLs.
498 func (d
*Decoder
) RawToken() (Token
, error
) {
499 if d
.unmarshalDepth
> 0 {
500 return nil, errRawToken
505 func (d
*Decoder
) rawToken() (Token
, error
) {
510 // The last element we read was self-closing and
511 // we returned just the StartElement half.
512 // Return the EndElement half now.
514 return EndElement
{d
.toClose
}, nil
525 data
:= d
.text(-1, false)
529 return CharData(data
), nil
532 if b
, ok
= d
.mustgetc(); !ok
{
539 if name
, ok
= d
.nsname(); !ok
{
541 d
.err
= d
.syntaxError("expected element name after </")
546 if b
, ok
= d
.mustgetc(); !ok
{
550 d
.err
= d
.syntaxError("invalid characters between </" + name
.Local
+ " and >")
553 return EndElement
{name
}, nil
556 // <?: Processing instruction.
558 if target
, ok
= d
.name(); !ok
{
560 d
.err
= d
.syntaxError("expected target name after <?")
568 if b
, ok
= d
.mustgetc(); !ok
{
572 if b0
== '?' && b
== '>' {
577 data
:= d
.buf
.Bytes()
578 data
= data
[0 : len(data
)-2] // chop ?>
581 content
:= string(data
)
582 ver
:= procInst("version", content
)
583 if ver
!= "" && ver
!= "1.0" {
584 d
.err
= fmt
.Errorf("xml: unsupported version %q; only version 1.0 is supported", ver
)
587 enc
:= procInst("encoding", content
)
588 if enc
!= "" && enc
!= "utf-8" && enc
!= "UTF-8" && !strings
.EqualFold(enc
, "utf-8") {
589 if d
.CharsetReader
== nil {
590 d
.err
= fmt
.Errorf("xml: encoding %q declared but Decoder.CharsetReader is nil", enc
)
593 newr
, err
:= d
.CharsetReader(enc
, d
.r
.(io
.Reader
))
595 d
.err
= fmt
.Errorf("xml: opening charset %q: %v", enc
, err
)
599 panic("CharsetReader returned a nil Reader for charset " + enc
)
601 d
.switchToReader(newr
)
604 return ProcInst
{target
, data
}, nil
607 // <!: Maybe comment, maybe CDATA.
608 if b
, ok
= d
.mustgetc(); !ok
{
613 // Probably <!-- for a comment.
614 if b
, ok
= d
.mustgetc(); !ok
{
618 d
.err
= d
.syntaxError("invalid sequence <!- not part of <!--")
621 // Look for terminator.
625 if b
, ok
= d
.mustgetc(); !ok
{
629 if b0
== '-' && b1
== '-' {
631 d
.err
= d
.syntaxError(
632 `invalid sequence "--" not allowed in comments`)
639 data
:= d
.buf
.Bytes()
640 data
= data
[0 : len(data
)-3] // chop -->
641 return Comment(data
), nil
644 // Probably <![CDATA[.
645 for i
:= 0; i
< 6; i
++ {
646 if b
, ok
= d
.mustgetc(); !ok
{
649 if b
!= "CDATA["[i
] {
650 d
.err
= d
.syntaxError("invalid <![ sequence")
654 // Have <![CDATA[. Read text until ]]>.
655 data
:= d
.text(-1, true)
659 return CharData(data
), nil
662 // Probably a directive: <!DOCTYPE ...>, <!ENTITY ...>, etc.
663 // We don't care, but accumulate for caller. Quoted angle
664 // brackets do not count for nesting.
670 if b
, ok
= d
.mustgetc(); !ok
{
673 if inquote
== 0 && b
== '>' && depth
== 0 {
683 // in quotes, no special action
685 case b
== '\'' || b
== '"':
688 case b
== '>' && inquote
== 0:
691 case b
== '<' && inquote
== 0:
692 // Look for <!-- to begin comment.
694 for i
:= 0; i
< len(s
); i
++ {
695 if b
, ok
= d
.mustgetc(); !ok
{
699 for j
:= 0; j
< i
; j
++ {
700 d
.buf
.WriteByte(s
[j
])
707 // Remove < that was written above.
708 d
.buf
.Truncate(d
.buf
.Len() - 1)
710 // Look for terminator.
713 if b
, ok
= d
.mustgetc(); !ok
{
716 if b0
== '-' && b1
== '-' && b
== '>' {
723 return Directive(d
.buf
.Bytes()), nil
726 // Must be an open element like <a href="foo">
734 if name
, ok
= d
.nsname(); !ok
{
736 d
.err
= d
.syntaxError("expected element name after <")
744 if b
, ok
= d
.mustgetc(); !ok
{
749 if b
, ok
= d
.mustgetc(); !ok
{
753 d
.err
= d
.syntaxError("expected /> in element")
765 nCap
:= 2 * cap(attr
)
769 nattr
:= make([]Attr
, n
, nCap
)
775 if a
.Name
, ok
= d
.nsname(); !ok
{
777 d
.err
= d
.syntaxError("expected attribute name in element")
782 if b
, ok
= d
.mustgetc(); !ok
{
787 d
.err
= d
.syntaxError("attribute name without = in element")
791 a
.Value
= a
.Name
.Local
799 a
.Value
= string(data
)
806 return StartElement
{name
, attr
}, nil
809 func (d
*Decoder
) attrval() []byte {
810 b
, ok
:= d
.mustgetc()
814 // Handle quoted attribute values
815 if b
== '"' || b
== '\'' {
816 return d
.text(int(b
), false)
818 // Handle unquoted attribute values for strict parsers
820 d
.err
= d
.syntaxError("unquoted or missing attribute value in element")
823 // Handle unquoted attribute values for unstrict parsers
831 // http://www.w3.org/TR/REC-html40/intro/sgmltut.html#h-3.2.2
832 if 'a' <= b
&& b
<= 'z' ||
'A' <= b
&& b
<= 'Z' ||
833 '0' <= b
&& b
<= '9' || b
== '_' || b
== ':' || b
== '-' {
843 // Skip spaces if any
844 func (d
*Decoder
) space() {
851 case ' ', '\r', '\n', '\t':
859 // Read a single byte.
860 // If there is no byte to read, return ok==false
861 // and leave the error in d.err.
862 // Maintain line number.
863 func (d
*Decoder
) getc() (b
byte, ok
bool) {
871 b
, d
.err
= d
.r
.ReadByte()
886 // InputOffset returns the input stream byte offset of the current decoder position.
887 // The offset gives the location of the end of the most recently returned token
888 // and the beginning of the next token.
889 func (d
*Decoder
) InputOffset() int64 {
893 // Return saved offset.
894 // If we did ungetc (nextByte >= 0), have to back up one.
895 func (d
*Decoder
) savedOffset() int {
903 // Must read a single byte.
904 // If there is no byte to read,
905 // set d.err to SyntaxError("unexpected EOF")
906 // and return ok==false
907 func (d
*Decoder
) mustgetc() (b
byte, ok
bool) {
908 if b
, ok
= d
.getc(); !ok
{
910 d
.err
= d
.syntaxError("unexpected EOF")
916 // Unread a single byte.
917 func (d
*Decoder
) ungetc(b
byte) {
925 var entity
= map[string]int{
933 // Read plain text section (XML calls it character data).
934 // If quote >= 0, we are in a quoted string and need to find the matching quote.
935 // If cdata == true, we are in a <![CDATA[ section and need to find ]]>.
936 // On failure return nil and leave the error in d.err.
937 func (d
*Decoder
) text(quote
int, cdata
bool) []byte {
947 d
.err
= d
.syntaxError("unexpected EOF in CDATA section")
954 // <![CDATA[ section ends with ]]>.
955 // It is an error for ]]> to appear in ordinary text.
956 if b0
== ']' && b1
== ']' && b
== '>' {
961 d
.err
= d
.syntaxError("unescaped ]]> not in CDATA section")
965 // Stop reading text if we see a <.
966 if b
== '<' && !cdata
{
968 d
.err
= d
.syntaxError("unescaped < inside quoted string")
974 if quote
>= 0 && b
== byte(quote
) {
977 if b
== '&' && !cdata
{
978 // Read escaped character expression up to semicolon.
979 // XML in all its glory allows a document to define and use
980 // its own character names with <!ENTITY ...> directives.
981 // Parsers are required to recognize lt, gt, amp, apos, and quot
982 // even if they have not been declared.
983 before
:= d
.buf
.Len()
988 if b
, ok
= d
.mustgetc(); !ok
{
993 if b
, ok
= d
.mustgetc(); !ok
{
1000 if b
, ok
= d
.mustgetc(); !ok
{
1004 start
:= d
.buf
.Len()
1005 for '0' <= b
&& b
<= '9' ||
1006 base
== 16 && 'a' <= b
&& b
<= 'f' ||
1007 base
== 16 && 'A' <= b
&& b
<= 'F' {
1009 if b
, ok
= d
.mustgetc(); !ok
{
1016 s
:= string(d
.buf
.Bytes()[start
:])
1017 d
.buf
.WriteByte(';')
1018 n
, err
:= strconv
.ParseUint(s
, base
, 64)
1019 if err
== nil && n
<= unicode
.MaxRune
{
1032 if b
, ok
= d
.mustgetc(); !ok
{
1038 name
:= d
.buf
.Bytes()[before
+1:]
1039 d
.buf
.WriteByte(';')
1042 if r
, ok
:= entity
[s
]; ok
{
1045 } else if d
.Entity
!= nil {
1046 text
, haveText
= d
.Entity
[s
]
1053 d
.buf
.Truncate(before
)
1054 d
.buf
.Write([]byte(text
))
1062 ent
:= string(d
.buf
.Bytes()[before
:])
1063 if ent
[len(ent
)-1] != ';' {
1064 ent
+= " (no semicolon)"
1066 d
.err
= d
.syntaxError("invalid character entity " + ent
)
1070 // We must rewrite unescaped \r and \r\n into \n.
1072 d
.buf
.WriteByte('\n')
1073 } else if b1
== '\r' && b
== '\n' {
1074 // Skip \r\n--we already wrote \n.
1081 data
:= d
.buf
.Bytes()
1082 data
= data
[0 : len(data
)-trunc
]
1084 // Inspect each rune for being a disallowed character.
1087 r
, size
:= utf8
.DecodeRune(buf
)
1088 if r
== utf8
.RuneError
&& size
== 1 {
1089 d
.err
= d
.syntaxError("invalid UTF-8")
1093 if !isInCharacterRange(r
) {
1094 d
.err
= d
.syntaxError(fmt
.Sprintf("illegal character code %U", r
))
1102 // Decide whether the given rune is in the XML Character Range, per
1103 // the Char production of http://www.xml.com/axml/testaxml.htm,
1104 // Section 2.2 Characters.
1105 func isInCharacterRange(r rune
) (inrange
bool) {
1109 r
>= 0x20 && r
<= 0xDF77 ||
1110 r
>= 0xE000 && r
<= 0xFFFD ||
1111 r
>= 0x10000 && r
<= 0x10FFFF
1114 // Get name space name: name with a : stuck in the middle.
1115 // The part before the : is the name space identifier.
1116 func (d
*Decoder
) nsname() (name Name
, ok
bool) {
1121 i
:= strings
.Index(s
, ":")
1126 name
.Local
= s
[i
+1:]
1131 // Get name: /first(first|second)*/
1132 // Do not set d.err if the name is missing (unless unexpected EOF is received):
1133 // let the caller provide better context.
1134 func (d
*Decoder
) name() (s
string, ok
bool) {
1140 // Now we check the characters.
1143 d
.err
= d
.syntaxError("invalid XML name: " + string(b
))
1146 return string(b
), true
1149 // Read a name and append its bytes to d.buf.
1150 // The name is delimited by any single-byte character not valid in names.
1151 // All multi-byte characters are accepted; the caller must check their validity.
1152 func (d
*Decoder
) readName() (ok
bool) {
1154 if b
, ok
= d
.mustgetc(); !ok
{
1157 if b
< utf8
.RuneSelf
&& !isNameByte(b
) {
1164 if b
, ok
= d
.mustgetc(); !ok
{
1167 if b
< utf8
.RuneSelf
&& !isNameByte(b
) {
1176 func isNameByte(c
byte) bool {
1177 return 'A' <= c
&& c
<= 'Z' ||
1178 'a' <= c
&& c
<= 'z' ||
1179 '0' <= c
&& c
<= '9' ||
1180 c
== '_' || c
== ':' || c
== '.' || c
== '-'
1183 func isName(s
[]byte) bool {
1187 c
, n
:= utf8
.DecodeRune(s
)
1188 if c
== utf8
.RuneError
&& n
== 1 {
1191 if !unicode
.Is(first
, c
) {
1196 c
, n
= utf8
.DecodeRune(s
)
1197 if c
== utf8
.RuneError
&& n
== 1 {
1200 if !unicode
.Is(first
, c
) && !unicode
.Is(second
, c
) {
1207 func isNameString(s
string) bool {
1211 c
, n
:= utf8
.DecodeRuneInString(s
)
1212 if c
== utf8
.RuneError
&& n
== 1 {
1215 if !unicode
.Is(first
, c
) {
1220 c
, n
= utf8
.DecodeRuneInString(s
)
1221 if c
== utf8
.RuneError
&& n
== 1 {
1224 if !unicode
.Is(first
, c
) && !unicode
.Is(second
, c
) {
1231 // These tables were generated by cut and paste from Appendix B of
1232 // the XML spec at http://www.xml.com/axml/testaxml.htm
1233 // and then reformatting. First corresponds to (Letter | '_' | ':')
1234 // and second corresponds to NameChar.
1236 var first
= &unicode
.RangeTable
{
1237 R16
: []unicode
.Range16
{
1238 {0x003A, 0x003A, 1},
1239 {0x0041, 0x005A, 1},
1240 {0x005F, 0x005F, 1},
1241 {0x0061, 0x007A, 1},
1242 {0x00C0, 0x00D6, 1},
1243 {0x00D8, 0x00F6, 1},
1244 {0x00F8, 0x00FF, 1},
1245 {0x0100, 0x0131, 1},
1246 {0x0134, 0x013E, 1},
1247 {0x0141, 0x0148, 1},
1248 {0x014A, 0x017E, 1},
1249 {0x0180, 0x01C3, 1},
1250 {0x01CD, 0x01F0, 1},
1251 {0x01F4, 0x01F5, 1},
1252 {0x01FA, 0x0217, 1},
1253 {0x0250, 0x02A8, 1},
1254 {0x02BB, 0x02C1, 1},
1255 {0x0386, 0x0386, 1},
1256 {0x0388, 0x038A, 1},
1257 {0x038C, 0x038C, 1},
1258 {0x038E, 0x03A1, 1},
1259 {0x03A3, 0x03CE, 1},
1260 {0x03D0, 0x03D6, 1},
1261 {0x03DA, 0x03E0, 2},
1262 {0x03E2, 0x03F3, 1},
1263 {0x0401, 0x040C, 1},
1264 {0x040E, 0x044F, 1},
1265 {0x0451, 0x045C, 1},
1266 {0x045E, 0x0481, 1},
1267 {0x0490, 0x04C4, 1},
1268 {0x04C7, 0x04C8, 1},
1269 {0x04CB, 0x04CC, 1},
1270 {0x04D0, 0x04EB, 1},
1271 {0x04EE, 0x04F5, 1},
1272 {0x04F8, 0x04F9, 1},
1273 {0x0531, 0x0556, 1},
1274 {0x0559, 0x0559, 1},
1275 {0x0561, 0x0586, 1},
1276 {0x05D0, 0x05EA, 1},
1277 {0x05F0, 0x05F2, 1},
1278 {0x0621, 0x063A, 1},
1279 {0x0641, 0x064A, 1},
1280 {0x0671, 0x06B7, 1},
1281 {0x06BA, 0x06BE, 1},
1282 {0x06C0, 0x06CE, 1},
1283 {0x06D0, 0x06D3, 1},
1284 {0x06D5, 0x06D5, 1},
1285 {0x06E5, 0x06E6, 1},
1286 {0x0905, 0x0939, 1},
1287 {0x093D, 0x093D, 1},
1288 {0x0958, 0x0961, 1},
1289 {0x0985, 0x098C, 1},
1290 {0x098F, 0x0990, 1},
1291 {0x0993, 0x09A8, 1},
1292 {0x09AA, 0x09B0, 1},
1293 {0x09B2, 0x09B2, 1},
1294 {0x09B6, 0x09B9, 1},
1295 {0x09DC, 0x09DD, 1},
1296 {0x09DF, 0x09E1, 1},
1297 {0x09F0, 0x09F1, 1},
1298 {0x0A05, 0x0A0A, 1},
1299 {0x0A0F, 0x0A10, 1},
1300 {0x0A13, 0x0A28, 1},
1301 {0x0A2A, 0x0A30, 1},
1302 {0x0A32, 0x0A33, 1},
1303 {0x0A35, 0x0A36, 1},
1304 {0x0A38, 0x0A39, 1},
1305 {0x0A59, 0x0A5C, 1},
1306 {0x0A5E, 0x0A5E, 1},
1307 {0x0A72, 0x0A74, 1},
1308 {0x0A85, 0x0A8B, 1},
1309 {0x0A8D, 0x0A8D, 1},
1310 {0x0A8F, 0x0A91, 1},
1311 {0x0A93, 0x0AA8, 1},
1312 {0x0AAA, 0x0AB0, 1},
1313 {0x0AB2, 0x0AB3, 1},
1314 {0x0AB5, 0x0AB9, 1},
1315 {0x0ABD, 0x0AE0, 0x23},
1316 {0x0B05, 0x0B0C, 1},
1317 {0x0B0F, 0x0B10, 1},
1318 {0x0B13, 0x0B28, 1},
1319 {0x0B2A, 0x0B30, 1},
1320 {0x0B32, 0x0B33, 1},
1321 {0x0B36, 0x0B39, 1},
1322 {0x0B3D, 0x0B3D, 1},
1323 {0x0B5C, 0x0B5D, 1},
1324 {0x0B5F, 0x0B61, 1},
1325 {0x0B85, 0x0B8A, 1},
1326 {0x0B8E, 0x0B90, 1},
1327 {0x0B92, 0x0B95, 1},
1328 {0x0B99, 0x0B9A, 1},
1329 {0x0B9C, 0x0B9C, 1},
1330 {0x0B9E, 0x0B9F, 1},
1331 {0x0BA3, 0x0BA4, 1},
1332 {0x0BA8, 0x0BAA, 1},
1333 {0x0BAE, 0x0BB5, 1},
1334 {0x0BB7, 0x0BB9, 1},
1335 {0x0C05, 0x0C0C, 1},
1336 {0x0C0E, 0x0C10, 1},
1337 {0x0C12, 0x0C28, 1},
1338 {0x0C2A, 0x0C33, 1},
1339 {0x0C35, 0x0C39, 1},
1340 {0x0C60, 0x0C61, 1},
1341 {0x0C85, 0x0C8C, 1},
1342 {0x0C8E, 0x0C90, 1},
1343 {0x0C92, 0x0CA8, 1},
1344 {0x0CAA, 0x0CB3, 1},
1345 {0x0CB5, 0x0CB9, 1},
1346 {0x0CDE, 0x0CDE, 1},
1347 {0x0CE0, 0x0CE1, 1},
1348 {0x0D05, 0x0D0C, 1},
1349 {0x0D0E, 0x0D10, 1},
1350 {0x0D12, 0x0D28, 1},
1351 {0x0D2A, 0x0D39, 1},
1352 {0x0D60, 0x0D61, 1},
1353 {0x0E01, 0x0E2E, 1},
1354 {0x0E30, 0x0E30, 1},
1355 {0x0E32, 0x0E33, 1},
1356 {0x0E40, 0x0E45, 1},
1357 {0x0E81, 0x0E82, 1},
1358 {0x0E84, 0x0E84, 1},
1359 {0x0E87, 0x0E88, 1},
1360 {0x0E8A, 0x0E8D, 3},
1361 {0x0E94, 0x0E97, 1},
1362 {0x0E99, 0x0E9F, 1},
1363 {0x0EA1, 0x0EA3, 1},
1364 {0x0EA5, 0x0EA7, 2},
1365 {0x0EAA, 0x0EAB, 1},
1366 {0x0EAD, 0x0EAE, 1},
1367 {0x0EB0, 0x0EB0, 1},
1368 {0x0EB2, 0x0EB3, 1},
1369 {0x0EBD, 0x0EBD, 1},
1370 {0x0EC0, 0x0EC4, 1},
1371 {0x0F40, 0x0F47, 1},
1372 {0x0F49, 0x0F69, 1},
1373 {0x10A0, 0x10C5, 1},
1374 {0x10D0, 0x10F6, 1},
1375 {0x1100, 0x1100, 1},
1376 {0x1102, 0x1103, 1},
1377 {0x1105, 0x1107, 1},
1378 {0x1109, 0x1109, 1},
1379 {0x110B, 0x110C, 1},
1380 {0x110E, 0x1112, 1},
1381 {0x113C, 0x1140, 2},
1382 {0x114C, 0x1150, 2},
1383 {0x1154, 0x1155, 1},
1384 {0x1159, 0x1159, 1},
1385 {0x115F, 0x1161, 1},
1386 {0x1163, 0x1169, 2},
1387 {0x116D, 0x116E, 1},
1388 {0x1172, 0x1173, 1},
1389 {0x1175, 0x119E, 0x119E - 0x1175},
1390 {0x11A8, 0x11AB, 0x11AB - 0x11A8},
1391 {0x11AE, 0x11AF, 1},
1392 {0x11B7, 0x11B8, 1},
1393 {0x11BA, 0x11BA, 1},
1394 {0x11BC, 0x11C2, 1},
1395 {0x11EB, 0x11F0, 0x11F0 - 0x11EB},
1396 {0x11F9, 0x11F9, 1},
1397 {0x1E00, 0x1E9B, 1},
1398 {0x1EA0, 0x1EF9, 1},
1399 {0x1F00, 0x1F15, 1},
1400 {0x1F18, 0x1F1D, 1},
1401 {0x1F20, 0x1F45, 1},
1402 {0x1F48, 0x1F4D, 1},
1403 {0x1F50, 0x1F57, 1},
1404 {0x1F59, 0x1F5B, 0x1F5B - 0x1F59},
1405 {0x1F5D, 0x1F5D, 1},
1406 {0x1F5F, 0x1F7D, 1},
1407 {0x1F80, 0x1FB4, 1},
1408 {0x1FB6, 0x1FBC, 1},
1409 {0x1FBE, 0x1FBE, 1},
1410 {0x1FC2, 0x1FC4, 1},
1411 {0x1FC6, 0x1FCC, 1},
1412 {0x1FD0, 0x1FD3, 1},
1413 {0x1FD6, 0x1FDB, 1},
1414 {0x1FE0, 0x1FEC, 1},
1415 {0x1FF2, 0x1FF4, 1},
1416 {0x1FF6, 0x1FFC, 1},
1417 {0x2126, 0x2126, 1},
1418 {0x212A, 0x212B, 1},
1419 {0x212E, 0x212E, 1},
1420 {0x2180, 0x2182, 1},
1421 {0x3007, 0x3007, 1},
1422 {0x3021, 0x3029, 1},
1423 {0x3041, 0x3094, 1},
1424 {0x30A1, 0x30FA, 1},
1425 {0x3105, 0x312C, 1},
1426 {0x4E00, 0x9FA5, 1},
1427 {0xAC00, 0xD7A3, 1},
1431 var second
= &unicode
.RangeTable
{
1432 R16
: []unicode
.Range16
{
1433 {0x002D, 0x002E, 1},
1434 {0x0030, 0x0039, 1},
1435 {0x00B7, 0x00B7, 1},
1436 {0x02D0, 0x02D1, 1},
1437 {0x0300, 0x0345, 1},
1438 {0x0360, 0x0361, 1},
1439 {0x0387, 0x0387, 1},
1440 {0x0483, 0x0486, 1},
1441 {0x0591, 0x05A1, 1},
1442 {0x05A3, 0x05B9, 1},
1443 {0x05BB, 0x05BD, 1},
1444 {0x05BF, 0x05BF, 1},
1445 {0x05C1, 0x05C2, 1},
1446 {0x05C4, 0x0640, 0x0640 - 0x05C4},
1447 {0x064B, 0x0652, 1},
1448 {0x0660, 0x0669, 1},
1449 {0x0670, 0x0670, 1},
1450 {0x06D6, 0x06DC, 1},
1451 {0x06DD, 0x06DF, 1},
1452 {0x06E0, 0x06E4, 1},
1453 {0x06E7, 0x06E8, 1},
1454 {0x06EA, 0x06ED, 1},
1455 {0x06F0, 0x06F9, 1},
1456 {0x0901, 0x0903, 1},
1457 {0x093C, 0x093C, 1},
1458 {0x093E, 0x094C, 1},
1459 {0x094D, 0x094D, 1},
1460 {0x0951, 0x0954, 1},
1461 {0x0962, 0x0963, 1},
1462 {0x0966, 0x096F, 1},
1463 {0x0981, 0x0983, 1},
1464 {0x09BC, 0x09BC, 1},
1465 {0x09BE, 0x09BF, 1},
1466 {0x09C0, 0x09C4, 1},
1467 {0x09C7, 0x09C8, 1},
1468 {0x09CB, 0x09CD, 1},
1469 {0x09D7, 0x09D7, 1},
1470 {0x09E2, 0x09E3, 1},
1471 {0x09E6, 0x09EF, 1},
1472 {0x0A02, 0x0A3C, 0x3A},
1473 {0x0A3E, 0x0A3F, 1},
1474 {0x0A40, 0x0A42, 1},
1475 {0x0A47, 0x0A48, 1},
1476 {0x0A4B, 0x0A4D, 1},
1477 {0x0A66, 0x0A6F, 1},
1478 {0x0A70, 0x0A71, 1},
1479 {0x0A81, 0x0A83, 1},
1480 {0x0ABC, 0x0ABC, 1},
1481 {0x0ABE, 0x0AC5, 1},
1482 {0x0AC7, 0x0AC9, 1},
1483 {0x0ACB, 0x0ACD, 1},
1484 {0x0AE6, 0x0AEF, 1},
1485 {0x0B01, 0x0B03, 1},
1486 {0x0B3C, 0x0B3C, 1},
1487 {0x0B3E, 0x0B43, 1},
1488 {0x0B47, 0x0B48, 1},
1489 {0x0B4B, 0x0B4D, 1},
1490 {0x0B56, 0x0B57, 1},
1491 {0x0B66, 0x0B6F, 1},
1492 {0x0B82, 0x0B83, 1},
1493 {0x0BBE, 0x0BC2, 1},
1494 {0x0BC6, 0x0BC8, 1},
1495 {0x0BCA, 0x0BCD, 1},
1496 {0x0BD7, 0x0BD7, 1},
1497 {0x0BE7, 0x0BEF, 1},
1498 {0x0C01, 0x0C03, 1},
1499 {0x0C3E, 0x0C44, 1},
1500 {0x0C46, 0x0C48, 1},
1501 {0x0C4A, 0x0C4D, 1},
1502 {0x0C55, 0x0C56, 1},
1503 {0x0C66, 0x0C6F, 1},
1504 {0x0C82, 0x0C83, 1},
1505 {0x0CBE, 0x0CC4, 1},
1506 {0x0CC6, 0x0CC8, 1},
1507 {0x0CCA, 0x0CCD, 1},
1508 {0x0CD5, 0x0CD6, 1},
1509 {0x0CE6, 0x0CEF, 1},
1510 {0x0D02, 0x0D03, 1},
1511 {0x0D3E, 0x0D43, 1},
1512 {0x0D46, 0x0D48, 1},
1513 {0x0D4A, 0x0D4D, 1},
1514 {0x0D57, 0x0D57, 1},
1515 {0x0D66, 0x0D6F, 1},
1516 {0x0E31, 0x0E31, 1},
1517 {0x0E34, 0x0E3A, 1},
1518 {0x0E46, 0x0E46, 1},
1519 {0x0E47, 0x0E4E, 1},
1520 {0x0E50, 0x0E59, 1},
1521 {0x0EB1, 0x0EB1, 1},
1522 {0x0EB4, 0x0EB9, 1},
1523 {0x0EBB, 0x0EBC, 1},
1524 {0x0EC6, 0x0EC6, 1},
1525 {0x0EC8, 0x0ECD, 1},
1526 {0x0ED0, 0x0ED9, 1},
1527 {0x0F18, 0x0F19, 1},
1528 {0x0F20, 0x0F29, 1},
1529 {0x0F35, 0x0F39, 2},
1530 {0x0F3E, 0x0F3F, 1},
1531 {0x0F71, 0x0F84, 1},
1532 {0x0F86, 0x0F8B, 1},
1533 {0x0F90, 0x0F95, 1},
1534 {0x0F97, 0x0F97, 1},
1535 {0x0F99, 0x0FAD, 1},
1536 {0x0FB1, 0x0FB7, 1},
1537 {0x0FB9, 0x0FB9, 1},
1538 {0x20D0, 0x20DC, 1},
1539 {0x20E1, 0x3005, 0x3005 - 0x20E1},
1540 {0x302A, 0x302F, 1},
1541 {0x3031, 0x3035, 1},
1542 {0x3099, 0x309A, 1},
1543 {0x309D, 0x309E, 1},
1544 {0x30FC, 0x30FE, 1},
1548 // HTMLEntity is an entity map containing translations for the
1549 // standard HTML entity characters.
1550 var HTMLEntity
= htmlEntity
1552 var htmlEntity
= map[string]string{
1554 hget http://www.w3.org/TR/html4/sgml/entities.html |
1556 ,y /\>/ x/\<(.|\n)+/ s/\n/ /g
1557 ,x v/^\<!ENTITY/d
1558 ,s/\<!ENTITY ([^ ]+) .*U\+([0-9A-F][0-9A-F][0-9A-F][0-9A-F]) .+/ "\1": "\\u\2",/g
1662 "Epsilon": "\u0395",
1672 "Omicron": "\u039F",
1677 "Upsilon": "\u03A5",
1686 "epsilon": "\u03B5",
1696 "omicron": "\u03BF",
1702 "upsilon": "\u03C5",
1707 "thetasym": "\u03D1",
1720 "alefsym": "\u2135",
1815 // HTMLAutoClose is the set of HTML elements that
1816 // should be considered to close automatically.
1817 var HTMLAutoClose
= htmlAutoClose
1819 var htmlAutoClose
= []string{
1821 hget http://www.w3.org/TR/html4/loose.dtd |
1822 9 sed -n 's/<!ELEMENT ([^ ]*) +- O EMPTY.+/ "\1",/p' | tr A-Z a-z
1840 esc_quot
= []byte(""") // shorter than """
1841 esc_apos
= []byte("'") // shorter than "'"
1842 esc_amp
= []byte("&")
1843 esc_lt
= []byte("<")
1844 esc_gt
= []byte(">")
1845 esc_tab
= []byte("	")
1846 esc_nl
= []byte("
")
1847 esc_cr
= []byte("
")
1848 esc_fffd
= []byte("\uFFFD") // Unicode replacement character
1851 // EscapeText writes to w the properly escaped XML equivalent
1852 // of the plain text data s.
1853 func EscapeText(w io
.Writer
, s
[]byte) error
{
1854 return escapeText(w
, s
, true)
1857 // escapeText writes to w the properly escaped XML equivalent
1858 // of the plain text data s. If escapeNewline is true, newline
1859 // characters will be escaped.
1860 func escapeText(w io
.Writer
, s
[]byte, escapeNewline
bool) error
{
1863 for i
:= 0; i
< len(s
); {
1864 r
, width
:= utf8
.DecodeRune(s
[i
:])
1887 if !isInCharacterRange(r
) ||
(r
== 0xFFFD && width
== 1) {
1893 if _
, err
:= w
.Write(s
[last
: i
-width
]); err
!= nil {
1896 if _
, err
:= w
.Write(esc
); err
!= nil {
1901 if _
, err
:= w
.Write(s
[last
:]); err
!= nil {
1907 // EscapeString writes to p the properly escaped XML equivalent
1908 // of the plain text data s.
1909 func (p
*printer
) EscapeString(s
string) {
1912 for i
:= 0; i
< len(s
); {
1913 r
, width
:= utf8
.DecodeRuneInString(s
[i
:])
1933 if !isInCharacterRange(r
) ||
(r
== 0xFFFD && width
== 1) {
1939 p
.WriteString(s
[last
: i
-width
])
1943 p
.WriteString(s
[last
:])
1946 // Escape is like EscapeText but omits the error return value.
1947 // It is provided for backwards compatibility with Go 1.0.
1948 // Code targeting Go 1.1 or later should use EscapeText.
1949 func Escape(w io
.Writer
, s
[]byte) {
1954 cdataStart
= []byte("<![CDATA[")
1955 cdataEnd
= []byte("]]>")
1956 cdataEscape
= []byte("]]]]><![CDATA[>")
1959 // emitCDATA writes to w the CDATA-wrapped plain text data s.
1960 // It escapes CDATA directives nested in s.
1961 func emitCDATA(w io
.Writer
, s
[]byte) error
{
1965 if _
, err
:= w
.Write(cdataStart
); err
!= nil {
1969 i
:= bytes
.Index(s
, cdataEnd
)
1970 if i
>= 0 && i
+len(cdataEnd
) <= len(s
) {
1971 // Found a nested CDATA directive end.
1972 if _
, err
:= w
.Write(s
[:i
]); err
!= nil {
1975 if _
, err
:= w
.Write(cdataEscape
); err
!= nil {
1980 if _
, err
:= w
.Write(s
); err
!= nil {
1987 if _
, err
:= w
.Write(cdataEnd
); err
!= nil {
1993 // procInst parses the `param="..."` or `param='...'`
1994 // value out of the provided string, returning "" if not found.
1995 func procInst(param
, s
string) string {
1996 // TODO: this parsing is somewhat lame and not exact.
1997 // It works for all actual cases, though.
1999 idx
:= strings
.Index(s
, param
)
2003 v
:= s
[idx
+len(param
):]
2007 if v
[0] != '\'' && v
[0] != '"' {
2010 idx
= strings
.IndexRune(v
[1:], rune(v
[0]))