Standard library · Encoding and data

encoding/xml

Reading, building and writing XML, with XPath, DTD validation, namespaces and a light simple interface.

import encoding.xml

On this page

Guide: read a feed with XPath
Guide: namespaces in an Atom feed
Guide: generate a sitemap
Guide: a small config with the simple nodes
Guide: scan a product feed with the tokenizer
Guide: report broken XML
Which interface for which job
Types
Constants and variables
Functions

This package reads, queries, edits and writes XML: feeds, sitemaps, SVG, SOAP replies, office files and old configuration formats. It has three interfaces for three sizes of job.

The document interface is the complete one. Parse reads the text into a Document, and every node has a numeric id you pass to functions such as Name, AttributeValue, Elements and Text. XPath 1.0 queries, namespaces, entities, DTD validation, editing and canonical output all work on it.
The simple node interface (Decode, Child, Attr, Encode) keeps the tree in plain XMLNode structs. It suits a small config or API reply you read once, and it is what encoding/serde uses to convert XML to and from a Value.
The tokenizer (NewXMLTokenizer, NextToken) hands out start tags, end tags and text one at a time without building a tree.

If you control both ends and only need to move data, encoding/json is simpler. Reach for this package when the other side speaks XML.

Untrusted input

Parse is safe to run on documents from outside. External entities (<!ENTITY x SYSTEM "file:///etc/passwd">) are never fetched, so a reference to one fails as undeclared, and entity expansion is capped by max_entity_expansion (256 KB by default) and max_entity_depth (32), which stops the "billion laughs" attack. Element nesting is capped at 1024 levels.

What trips people up

XPath matches names as written. A name test compares the element's full name, prefix included, with the query. //entry finds Atom entries in a default namespace, and //m:thumbnail works only if the document uses the prefix m. When the prefix may vary, test local-name() and namespace-uri(); the namespaces guide shows how.
Every value is text. Text and SelectString return strings; use SelectNumber or convert yourself.
Whitespace-only text is dropped by default. Set preserve_whitespace in ParseOptions when indentation matters, for example in mixed content.
Free what you take. A Document and each NodeList from Select hold memory until Free and FreeList.
The tokenizer does not check the document. It does not match end tags to start tags, it returns the whitespace between elements as text tokens, and it needs the whole text in memory. Run WellFormed first if the input may be broken.

Guide: read a feed with XPath

RSS and Atom feeds, sitemaps, SVG and office files are all XML, and XPath is the quickest way to pull values out of them. SelectString and SelectNumber answer a whole query in one call; Select returns the matching nodes, and a query run from one of those nodes is relative to it, so title means the title of that item.

encoding-xml-guide-rss.salam

import encoding.xml

func main:
    feed := `<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>Salam blog</title>
    <item>
      <title>Salam 0.5.5 is out</title>
      <link>https://example.com/posts/055</link>
      <category>release</category>
    </item>
    <item>
      <title>Writing a JSON API</title>
      <link>https://example.com/posts/json-api</link>
      <category>tutorial</category>
    </item>
    <item>
      <title>The Persian keywords</title>
      <link>https://example.com/posts/persian</link>
      <category>tutorial</category>
    </item>
  </channel>
</rss>`
    mut err := xml.NoError()
    mut d := xml.Parse(feed, err)
    if not err.ok:
        println "bad feed:", xml.ErrorText(err)
        ret 1
    end
    top := xml.DocumentNode(d)
    println "feed:", xml.SelectString(d, top, "/rss/channel/title", err)
    println "posts:", xml.SelectNumber(d, top, "count(//item)", err)

    mut items := xml.Select(d, top, "//item[category = 'tutorial']", err)
    each it in items.items:
        println "-", xml.SelectString(d, it, "title", err), "<" + xml.SelectString(d, it, "link", err) + ">"
    end
    xml.FreeList(items)
    xml.Free(d)
end

Outputfeed: Salam blog posts: 3 - Writing a JSON API <https://example.com/posts/json-api> - The Persian keywords <https://example.com/posts/persian>

The filter [category = 'tutorial'] keeps only the items whose child element has that text. Free the node list with FreeList and the document with Free when you are done.

Guide: namespaces in an Atom feed

Atom feeds, SVG, SOAP and office files put their elements in namespaces, often several at once. This feed uses Atom as the default namespace and Media RSS under the prefix m. The program shows how XPath in this package treats names, and the query that works whatever prefix the publisher chose.

encoding-xml-guide-namespaces.salam

import encoding.xml

func main:
    feed := `<feed xmlns="http://www.w3.org/2005/Atom" xmlns:m="http://search.yahoo.com/mrss/">
  <title>Salam videos</title>
  <entry>
    <title>Install Salam</title>
    <m:thumbnail url="https://cdn.example/install.jpg"/>
  </entry>
  <entry>
    <title>Your first web server</title>
    <m:thumbnail url="https://cdn.example/server.jpg"/>
  </entry>
</feed>`
    mut err := xml.NoError()
    mut d := xml.Parse(feed, err)
    if not err.ok:
        println xml.ErrorText(err)
        ret 1
    end
    top := xml.DocumentNode(d)
    println "entries by name:  ", xml.SelectNumber(d, top, "count(//entry)", err)
    println "with prefix m:    ", xml.SelectNumber(d, top, "count(//m:thumbnail)", err)
    println "with prefix media:", xml.SelectNumber(d, top, "count(//media:thumbnail)", err)

    query := "//*[local-name() = 'thumbnail' and namespace-uri() = 'http://search.yahoo.com/mrss/']"
    mut thumbs := xml.Select(d, top, query, err)
    each t in thumbs.items:
        println xml.Name(d, t), "local:", xml.LocalName(d, t), "->", xml.AttributeValue(d, t, "url")
    end
    xml.FreeList(thumbs)

    root := xml.Root(d)
    println "root namespace:", xml.NamespaceURI(d, root)
    xml.Free(d)
end

Outputentries by name: 2 with prefix m: 2 with prefix media: 0 m:thumbnail local: thumbnail -> https://cdn.example/install.jpg m:thumbnail local: thumbnail -> https://cdn.example/server.jpg root namespace: http://www.w3.org/2005/Atom

//entry matches because the entries have no prefix, and //m:thumbnail because the document happens to say m. A feed that writes media:thumbnail instead would break the second query, while the local-name() and namespace-uri() test keeps working. Outside XPath, LocalName, Prefix and NamespaceURI give the parts of any node's name, and AttributeValueNS reads a namespaced attribute.

Guide: generate a sitemap

To write XML, build a document node by node with CreateElement, CreateText and Append, then write it out. A small helper per repeated element keeps the code short. WriteWith with declaration and indent set produces a file ready to serve as sitemap.xml.

encoding-xml-guide-sitemap.salam

import encoding.xml

func add_url(d &: xml.Document, parent: int, loc: str, changed: str):
    u := xml.CreateElement(d, "url")
    xml.Append(d, parent, u)
    l := xml.CreateElement(d, "loc")
    xml.Append(d, u, l)
    xml.Append(d, l, xml.CreateText(d, loc))
    m := xml.CreateElement(d, "lastmod")
    xml.Append(d, u, m)
    xml.Append(d, m, xml.CreateText(d, changed))
end

func main:
    mut d := xml.NewDocument()
    root := xml.CreateElement(d, "urlset")
    xml.Append(d, xml.DocumentNode(d), root)
    xml.SetAttribute(d, root, "xmlns", "http://www.sitemaps.org/schemas/sitemap/0.9")

    add_url(d, root, "https://example.com/", "2026-10-01")
    add_url(d, root, "https://example.com/search?q=tea&page=2", "2026-10-12")

    mut o := xml.DefaultWriteOptions()
    o.declaration = true
    o.indent = "  "
    print xml.WriteWith(d, o)
    xml.Free(d)
end

Output<?xml version="1.0" encoding="UTF-8"?> <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"> <url> <loc>https://example.com/</loc> <lastmod>2026-10-01</lastmod> </url> <url> <loc>https://example.com/search?q=tea&page=2</loc> <lastmod>2026-10-12</lastmod> </url> </urlset>

Text is escaped on the way out, so the & in the second URL is written as &, as XML requires. Building the document this way means you never have to escape anything by hand.

Guide: a small config with the simple nodes

For a short file you read once, the simple interface is enough: DecodeStrict gives the root as a plain struct, Child and Children find elements by name, and Attr reads an attribute. Found tells you whether Child found anything, and HasAttr lets an attribute have a default.

encoding-xml-guide-config.salam

import encoding.xml

func main:
    text := `<app name="shop">
  <listen host="0.0.0.0" port="8080"/>
  <plugin name="auth" enabled="true"/>
  <plugin name="cache" enabled="false"/>
  <plugin name="search"/>
</app>`
    mut ok := false
    app := xml.DecodeStrict(text, ok)
    if not ok:
        println "config is not well-formed"
        ret 1
    end
    println "app:", xml.Attr(app, "name")
    listen := xml.Child(app, "listen")
    if xml.Found(listen):
        println "listen:", xml.Attr(listen, "host") + ":" + xml.Attr(listen, "port")
    end
    plugins := xml.Children(app, "plugin")
    each p in plugins.items:
        mut enabled := true
        if xml.HasAttr(p, "enabled"):
            enabled = xml.Attr(p, "enabled") == "true"
        end
        println "plugin", xml.Attr(p, "name"), "enabled:", enabled
    end
    println "has a cache element:", xml.Found(xml.Child(app, "cache"))
end

Outputapp: shop listen: 0.0.0.0:8080 plugin auth enabled: true plugin cache enabled: false plugin search enabled: true has a cache element: false

Guide: scan a product feed with the tokenizer

Price lists and catalogue exports can have hundreds of thousands of records, and you often need only a few fields. The tokenizer walks the text once and builds no tree, so memory stays at the size of the text. Keep a little state, here which product you are in and whether you are inside a <name>, and react to the tokens you care about.

encoding-xml-guide-tokens.salam

import encoding.xml
import str

func main:
    feed := `<products>
  <product sku="TEA-01" stock="14"><name>Green tea</name><price>4.50</price></product>
  <product sku="CUP-02" stock="0"><name>Glass cup</name><price>7.25</price></product>
  <product sku="POT-03" stock="3"><name>Tea pot &amp; lid</name><price>21.00</price></product>
</products>`
    mut tz := xml.NewXMLTokenizer(feed)
    mut current := ""
    mut inName := false
    mut products := 0
    mut outOfStock := 0
    mut done := false
    until not done:
        tok := xml.NextToken(tz)
        if tok.kind == xml.XMLTokEOF:
            done = true
        else tok.kind == xml.XMLTokStartElement and tok.tag == "product":
            products += 1
            current = tok.attrs.get("sku")
            if tok.attrs.get("stock") == "0": outOfStock += 1 end
        else tok.kind == xml.XMLTokStartElement and tok.tag == "name":
            inName = true
        else tok.kind == xml.XMLTokEndElement and tok.tag == "name":
            inName = false
        else tok.kind == xml.XMLTokText and inName:
            println current, "is", str.Trim(tok.text)
        end
    end
    println products, "products,", outOfStock, "out of stock"
end

OutputTEA-01 is Green tea CUP-02 is Glass cup POT-03 is Tea pot & lid 3 products, 1 out of stock

Attributes of a start tag arrive in tok.attrs, and text has its entities decoded, so & comes out as &. Text tokens include the whitespace between tags, which is why the program trims the name and ignores text outside <name>. A self-closing tag such as   gives a start token followed by an end token.

Guide: report broken XML

XML is strict: one root, every tag closed in order, every & part of an entity. Parse stops at the first problem and ErrorText gives a line, a column and a readable reason, ready to show to whoever wrote the file. WellFormed only answers yes or no.

encoding-xml-guide-errors.salam

import encoding.xml

func check(label: str, text: str):
    mut err := xml.NoError()
    mut d := xml.Parse(text, err)
    if err.ok:
        println label, "ok"
    else:
        println label, xml.ErrorText(err)
    end
    xml.Free(d)
end

func main:
    check("good:      ", "<a><b>1</b></a>")
    check("mismatch:  ", "<a>\n  <b>1</a>")
    check("two roots: ", "<a/><b/>")
    check("bad entity:", "<a>&nope;</a>")
    check("raw amp:   ", "<a>salt & pepper</a>")
    mut err := xml.NoError()
    println "quick check:", xml.WellFormed("<x/>", err), xml.WellFormed("<x>", err)
    println "escaped text:", xml.EscapeText("salt & pepper")
end

Outputgood: ok mismatch: line 2, column 7: </a> closes two roots: line 1, column 5: a document may hold only one root element, and is a second bad entity: line 1, column 4: the entity "&nope;" is not declared raw amp: line 1, column 9: an entity reference has no closing semicolon quick check: true false escaped text: salt & pepper

The last case is the most common one in hand-written files: a bare & in text. When you build XML from strings yourself, pass text through EscapeText and attribute values through EscapeAttr, or build the document with the functions above, which escape for you.

Which interface for which job

Job	Use
Small config or response, read once	`Decode`, `Child`, `Children`, `Attr`
Find values anywhere in a document	`Parse` and `Select`, `SelectString`, `SelectNumber`
Elements in namespaces	XPath with `local-name()` and `namespace-uri()`, or `LocalName` and `NamespaceURI`
Walk or change a document	`Root`, `Elements`, `ChildAt`, `SetText`, `RemoveChild`
Write a new document	`NewDocument`, `CreateElement`, `Append`, `WriteIndent`
Large files, one pass, no tree	`NewXMLTokenizer` and `NextToken`
Check against a DTD	the DTD functions in the reference below
Convert to JSON or YAML	encoding/serde

Types

`WriteOptions`

struct WriteOptions

The write options.

Name	Type	Description
`indent`	`str = ""`	The indent unit; empty means no indenting.
`newline`	`str = " "`	The newline between elements when there is indenting.
`declaration`	`bool = false`	Write the `<?xml ...?>` declaration.
`doctype`	`bool = false`	Write the DOCTYPE.
`empty_as_pair`	`bool = false`	Write an empty element as `<a></a>`.
`sort_attributes`	`bool = false`	Put the attributes in alphabetical order.
`escape_newlines_in_attributes`	`bool = false`	Write a newline in an attribute value as ` `.

encoding-xml-Build.salam

import encoding.xml

func main:
    mut d := xml.NewDocument()
    root := xml.CreateElement(d, "note")
    xml.Append(d, xml.DocumentNode(d), root)
    xml.SetAttribute(d, root, "id", "7")
    xml.SetAttribute(d, root, "draft", "yes")
    recipient := xml.CreateElement(d, "to")
    xml.Append(d, root, recipient)
    xml.Append(d, recipient, xml.CreateText(d, "Maryam & Reza"))
    body := xml.CreateElement(d, "body")
    xml.Append(d, root, body)
    xml.Append(d, body, xml.CreateCData(d, "<b>bold</b>"))
    xml.InsertBefore(d, root, xml.CreateComment(d, "recipient"), recipient)
    xml.Append(d, xml.DocumentNode(d), xml.CreateProcessingInstruction(d, "app", "v=1"))
    println xml.Write(d)
    println xml.RemoveAttribute(d, root, "draft"), xml.RemoveChild(d, root, body)
    xml.SetText(d, recipient, "everyone")
    println xml.WriteIndent(d, "  ")
    println xml.WriteNode(d, recipient), xml.WriteNodeIndent(d, recipient, "\t")
    mut o := xml.DefaultWriteOptions()
    o.declaration = true
    o.empty_as_pair = true
    println xml.WriteWith(d, o)
    println xml.WriteDocument(d)
    mut err := xml.NoError()
    mut d2 := xml.Parse("<r b=\"2\"   a=\"1\"><x/></r>", err)
    println xml.Canonical(d2), xml.CanonicalNode(d2, xml.ChildAt(d2, xml.Root(d2), 0))
    xml.Free(d2)
    xml.Free(d)
end

Output<note id="7" draft="yes"><to>Maryam & Reza</to><body><![CDATA[bold]]></body></note><?app v=1?> true true <note id="7">  <to>everyone</to> </note> <?app v=1?> <to>everyone</to> <to>everyone</to> <?xml version="1.0" encoding="UTF-8"?> <note id="7"><to>everyone</to></note><?app v=1?> <?xml version="1.0" encoding="UTF-8"?> <note id="7"><to>everyone</to></note><?app v=1?> <r a="1" b="2"><x></x></r> <x></x>

`ParseError`

struct ParseError

An XML parse error.

Name	Type	Description
`ok`	`bool = true`	Whether the parse succeeded.
`message`	`str = ""`	The error message.
`line`	`int = 0`	The line of the error.
`col`	`int = 0`	The column of the error.
`offset`	`int = 0`	The position of the error in bytes.

encoding-xml-Parse.salam

import encoding.xml

func main:
    src := "<?xml version=\"1.0\"?>\n<library xmlns:b=\"urn:books\">\n  <!-- the list -->\n  <b:book id=\"1\" lang=\"en\"><title>Dune</title><year>1965</year></b:book>\n  <b:book id=\"2\"><title>Solaris</title></b:book>\n</library>"
    mut err := xml.NoError()
    mut d := xml.Parse(src, err)
    println err.ok, d.version, xml.NodeCount(d) > 0
    r := xml.Root(d)
    println xml.Name(d, r), xml.Kind(d, r) == xml.KindElement, xml.Parent(d, r) == xml.DocumentNode(d)
    mut books := xml.Elements(d, r)
    println books.items.len()
    b := books.items[0]
    println xml.Name(d, b), xml.LocalName(d, b), xml.Prefix(d, b), xml.NamespaceURI(d, b)
    println xml.Line(d, b), xml.Column(d, b), xml.Depth(d, b), xml.Path(d, b)
    println xml.AttributeCount(d, b), xml.HasAttribute(d, b, "lang"), xml.AttributeValue(d, b, "id")
    a := xml.AttributeAt(d, b, 1)
    println a.name, a.value
    t := xml.FirstElementNamed(d, b, "title")
    println xml.Text(d, t), xml.Text(d, b), xml.IsElement(d, t)
    println xml.ChildCount(d, b), xml.Name(d, xml.ChildAt(d, b, 1))
    println xml.Name(d, xml.NextSibling(d, t)), xml.PreviousSibling(d, t)
    mut all := xml.Descendants(d, r)
    mut named := xml.ElementsNamed(d, r, "b:book")
    mut up := xml.Ancestors(d, t)
    mut kids := xml.ChildNodes(d, r)
    println all.items.len(), named.items.len(), up.items.len(), kids.items.len()
    println xml.Exists(d, 9999), xml.Value(d, xml.ChildAt(d, t, 0))
    xml.FreeList(all)
    xml.FreeList(named)
    xml.FreeList(up)
    xml.FreeList(kids)
    xml.FreeList(books)
    _ := xml.Parse("<a><b></a>", err)
    println err.ok, err.line, xml.ErrorText(err)
    println xml.WellFormed("<x/>", err)
    xml.Free(d)
    mut o := xml.DefaultOptions()
    o.keep_comments = false
    mut d2 := xml.ParseWith("<!DOCTYPE p [<!ENTITY site \"hello\">]><p xmlns:x=\"urn:x\" x:id=\"7\">&site; <b>b</b> end</p>", o, err)
    p := xml.Root(d2)
    println err.ok, xml.EntityCount(d2), xml.EntityValue(d2, "site")
    println "[" + xml.DirectText(d2, p) + "]", xml.AttributeValueNS(d2, p, "urn:x", "id")
    println xml.EntityDepthLimit, xml.EntityExpansionLimit, o.max_depth
    xml.Free(d2)
end

Outputtrue 1.0 true library true true 2 b:book book b urn:books 4 3 2 /library[1]/b:book[1] 2 true 1 lang en Dune Dune1965 true 2 year year -1 9 2 3 3 false Dune false 1 line 1, column 7: </a> closes true true 1 hello [hello end] 7 32 262144 1024

`ParseOptions`

struct ParseOptions

The parse options.

Name	Type	Description
`preserve_whitespace`	`bool = false`	Keep text nodes that are only whitespace.
`keep_comments`	`bool = true`	Keep the comments.
`keep_instructions`	`bool = true`	Keep the processing instructions.
`namespaces`	`bool = true`	Resolve the namespaces.
`expand_entities`	`bool = true`	Replace entities with their values.
`max_depth`	`int = 1024`	The greatest element depth.
`max_entity_depth`	`int`	The greatest depth of nested entities.
`max_entity_expansion`	`int`	The greatest text length after entities are expanded; a guard against the "entity bomb" attack.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ElementDecl`

struct ElementDecl

The declaration of one element in the DTD.

Name	Type	Description
`name`	`str = ""`	The element name.
`content`	`int = 1`	The content kind; one of the `Content` constants.
`model`	`str = ""`	The content model as text, such as `(to, body)`.
`root`	`int = -1`	The root of the model tree.
`mixed`	`Vector`	The names of the elements allowed in mixed content.

encoding-xml-DTD.salam

import encoding.xml

func main:
    dtd := xml.ParseDTD("<!ELEMENT note (to, body)>\n<!ELEMENT to (#PCDATA)>\n<!ELEMENT body (#PCDATA)>\n<!ATTLIST note id ID #REQUIRED kind (a|b) \"a\">")
    println dtd.ok, xml.DeclaredElementCount(dtd), xml.DeclaredAttributeCount(dtd)
    el := dtd.elements[0]
    println el.name, el.content == xml.ContentChildren, el.model
    at := dtd.attributes[1]
    println at.name, at.kind == xml.AttrEnumeration, at.mode == xml.DefaultValue, at.value, at.values
    mut err := xml.NoError()
    mut good := xml.Parse("<note id=\"n1\"><to>me</to><body>hello</body></note>", err)
    mut report := xml.Validate(good, dtd)
    println report.ok
    xml.FreeReport(report)
    println xml.ApplyDefaults(good, dtd), xml.AttributeValue(good, xml.Root(good), "kind")
    mut bad := xml.Parse("<note><body>no recipient</body></note>", err)
    mut r2 := xml.Validate(bad, dtd)
    println r2.ok, r2.items.len()
    println xml.ReportText(r2)
    xml.FreeReport(r2)
    mut inner := xml.Parse("<!DOCTYPE a [<!ELEMENT a EMPTY>]><a>text</a>", err)
    mut r3 := xml.ValidateInternalSubset(inner)
    println r3.ok, inner.doctype
    xml.FreeReport(r3)
    mut ns := xml.Parse("<a xmlns:x=\"urn:x\"><x:b/></a>", err)
    mut r4 := xml.CheckNamespaces(ns)
    println r4.ok
    xml.FreeReport(r4)
    mut dtd2 := dtd
    xml.FreeDTD(dtd2)
    xml.Free(good)
    xml.Free(bad)
    xml.Free(inner)
    xml.Free(ns)
end

Outputtrue 3 2 note true (to, body) kind true true a ["a", "b"] true 1 a false 2 line 1, column 1: the children of <note> do not match (to, body) line 1, column 1: <note> is missing the required attribute "id" false a true

`AttrDecl`

struct AttrDecl

The declaration of one attribute in the DTD.

Name	Type	Description
`element`	`str = ""`	The element that owns the attribute.
`name`	`str = ""`	The attribute name.
`kind`	`int = 0`	The attribute type; one of the `Attr` constants.
`mode`	`int = 1`	The default mode; one of the `Default` constants.
`value`	`str = ""`	The default value.
`values`	`Vector`	The allowed values of an enumerated attribute.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`DTD`

struct DTD

A document type definition.

Name	Type	Description
`ok`	`bool = true`	Whether the DTD was read correctly.
`message`	`str = ""`	The error message.
`elements`	`Vector`	The element declarations.
`attributes`	`Vector`	The attribute declarations.
`notations`	`Vector`	The notations.
`models`	`Vector`	The trees of the content models.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`Violation`

struct Violation

One violation found during validation.

Name	Type	Description
`message`	`str = ""`	What the problem is.
`line`	`int = 0`	The line.
`col`	`int = 0`	The column.
`node`	`int = -1`	The id of the node.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`Report`

struct Report

The result of a validation.

Name	Type	Description
`ok`	`bool = true`	True when there is no violation at all.
`items`	`Vector`	The violations.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`XMLNode`

struct XMLNode

A simple node: one element with its attributes, children and text; for small jobs without a document.

Name	Type	Description
`tag`	`str = ""`	The element name.
`attrs`	`HashMap`	The attributes.
`children`	`Vector`	The child elements.
`text`	`str = ""`	The text of the element.

encoding-xml-Simple.salam

import encoding.xml
import encoding.value

func main:
    n := xml.Decode("<config env=\"prod\"><db host=\"localhost\" port=\"5432\"/><feature>search</feature><feature>chat</feature></config>")
    println n.tag, xml.HasAttr(n, "env"), xml.Attr(n, "env")
    db := xml.Child(n, "db")
    println xml.Found(db), xml.Attr(db, "port"), xml.Found(xml.Child(n, "cache"))
    feats := xml.Children(n, "feature")
    println feats.items.len(), feats.items[1].text
    mut item := xml.NewXMLNode("item")
    xml.SetAttr(item, "id", "3")
    mut name := xml.NewXMLNode("name")
    name.text = "book"
    xml.AppendChild(item, name)
    println xml.Encode(item)
    println xml.EncodeIndent(item, "  ")
    println xml.EncodeDeclaration(item)
    println xml.Valid("<a><b/></a>"), xml.Valid("<a><b></a>")
    mut ok := false
    _ := xml.DecodeStrict("<a>", ok)
    println ok
    v := xml.ToValue(n)
    println value.ToDebugString(v)
    println xml.Encode(xml.FromValue(v, "root"))
    println xml.EscapeText("a < b & c"), xml.EscapeAttr(`"x"`), xml.UnescapeEntities("&lt;p&gt; &amp; &#115;")
    mut tz := xml.NewXMLTokenizer("<a x=\"1\">hello<!--c--></a>")
    until true:
        t := xml.NextToken(tz)
        if t.kind == xml.XMLTokEOF or t.kind == xml.XMLTokError:
            break
        end
        println t.kind, t.tag, t.text
    end
    println xml.XMLTokStartElement, xml.XMLTokEndElement, xml.XMLTokText, xml.XMLTokComment, xml.XMLTokCData
end

Outputconfig true prod true 5432 false 2 chat <item id="3"><name>book</name></item> <item id="3"> <name>book</name> </item> <?xml version="1.0" encoding="UTF-8"?> <item id="3"><name>book</name></item> true false false object{@env: string(prod), db: object{@host: string(localhost), @port: string(5432)}, feature: array[string(search), string(chat)]} <root env="prod"><db host="localhost" port="5432"/><feature>search</feature><feature>chat</feature></root> a & s 1 a 3 hello 4 c 2 a 1 2 3 4 5

`XMLNodeList`

struct XMLNodeList

A list of simple nodes.

Name	Type	Description
`items`	`Vector`	The nodes.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`XMLToken`

struct XMLToken

One token from the tokenizer.

Name	Type	Description
`kind`	`int = 0`	The token kind; one of the `XMLTok` constants.
`tag`	`str = ""`	The element name.
`attrs`	`HashMap`	The attributes of a start element.
`text`	`str = ""`	The text of a text or comment token.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`XMLTokenizer`

struct XMLTokenizer

The tokenizer: reads the text token by token without building a tree; for large files.

Name	Type	Description
`text`	`str = ""`	The input text.
`pos`	`int = 0`	The current position.
`bad`	`bool = false`	Reserved for errors; the tokenizer does not set it yet.
`pendingEnd`	`str = ""`	A self closing element whose end token has not been handed out yet.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`XPathValue`

struct XPathValue

The result of an XPath evaluation: a node set, a string, a number or a boolean.

Name	Type	Description
`kind`	`int = 0`	The kind of the result; one of the `Value` constants.
`nodes`	`NodeList`	The nodes, when the result is a node set.
`text`	`str = ""`	The string result.
`number`	`f64 = 0`	The numeric result.
`flag`	`bool = false`	The boolean result.

encoding-xml-XPath.salam

import encoding.xml

func main:
    mut err := xml.NoError()
    mut d := xml.Parse("<shop><item price=\"120\">tea</item><item price=\"80\">sugar</item><item price=\"45\">bread</item></shop>", err)
    r := xml.DocumentNode(d)
    mut cheap := xml.Select(d, r, "//item[@price < 100]", err)
    println cheap.items.len()
    each n in cheap.items:
        println xml.Text(d, n)
    end
    xml.FreeList(cheap)
    println xml.SelectString(d, r, "/shop/item[1]", err), xml.SelectNumber(d, r, "sum(//item/@price)", err), xml.SelectBoolean(d, r, "count(//item) = 3", err)
    last := xml.SelectFirst(d, r, "//item[last()]", err)
    println xml.NodeName(d, last), xml.StringValue(d, last)
    mut v := xml.Evaluate(d, r, "//item/@price", err)
    println v.kind == xml.ValueNodeSet, v.nodes.items.len()
    first := v.nodes.items[0]
    println xml.IsAttributeRef(first), xml.ReferencedAttribute(d, first).value, xml.IsAttributeRef(xml.AttributeRef(0))
    xml.FreeValue(v)
    num := xml.Evaluate(d, r, "string-length('hello')", err)
    println num.kind == xml.ValueNumber, num.number, xml.ValueString, xml.ValueBoolean
    _ := xml.Select(d, r, "//item[@", err)
    println err.ok
    xml.Free(d)
end

Output2 sugar bread tea 245 true item bread true 3 true 120 true true 5 1 3 false

`Attribute`

struct Attribute

One element attribute.

Name	Type	Description
`owner`	`int = -1`	The id of the element.
`name`	`str = ""`	The full name.
`prefix`	`str = ""`	The prefix.
`local`	`str = ""`	The name without the prefix.
`uri`	`str = ""`	The namespace URI.
`value`	`str = ""`	The value, with entities resolved.
`line`	`int = 0`	The line.
`col`	`int = 0`	The column.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Node`

struct Node

One node: an element, text, a comment and so on.

Name	Type	Description
`kind`	`int = 0`	The node kind; one of the `Kind` constants.
`name`	`str = ""`	The full name with its prefix.
`prefix`	`str = ""`	The namespace prefix.
`local`	`str = ""`	The name without the prefix.
`uri`	`str = ""`	The namespace URI.
`value`	`str = ""`	The text of text nodes, comments and the like.
`parent`	`int = -1`	The id of the parent; -1 for the document node.
`children`	`Vector`	The ids of the children.
`attrs`	`Vector`	The indices of the attributes.
`line`	`int = 0`	The line number in the text.
`col`	`int = 0`	The column number in the text.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Document`

struct Document

One XML document, parsed or built. Nodes are taken out of it by number, their id.

Name	Type	Description
`nodes`	`Vector`	Every node; the id of a node is its index in this vector.
`attributes`	`Vector`	Every attribute.
`version`	`str = ""`	The version in the `<?xml ...?>` declaration.
`encoding`	`str = ""`	The encoding in the declaration.
`standalone`	`str = ""`	The `standalone` value in the declaration.
`doctype`	`str = ""`	The name of the root element in `<!DOCTYPE>`.
`doctype_public`	`str = ""`	The public identifier of the DOCTYPE.
`doctype_system`	`str = ""`	The system identifier of the DOCTYPE.
`internal_subset`	`str = ""`	The text of the internal subset of the DOCTYPE, between `[` and `]`.
`entity_names`	`Vector`	The names of the defined entities.
`entity_values`	`Vector`	The values of the entities.
`owned`	`Vector`	The strings the document holds.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`NodeList`

struct NodeList

A list of node ids.

Name	Type	Description
`items`	`Vector`	The ids.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

Constants and variables

Entity limits `Entity…`

The default values of max_entity_depth and max_entity_expansion in the parse options.

Name	Value
`EntityDepthLimit`	`32`
`EntityExpansionLimit`	`262144`

The example for this item is shown with the ones above: encoding-xml-Parse.salam

DTD element content kinds `Content…`

Empty (EMPTY), any (ANY), mixed text and elements, or child elements only with a given model.

Name	Value
`ContentEmpty`	`0`
`ContentAny`	`1`
`ContentMixed`	`2`
`ContentChildren`	`3`

The example for this item is shown with the ones above: encoding-xml-DTD.salam

DTD attribute types `Attr…`

The declared type of an attribute: text, id, id reference, entity, name token, a list of values, or a notation.

Name	Value
`AttrCData`	`0`
`AttrId`	`1`
`AttrIdRef`	`2`
`AttrIdRefs`	`3`
`AttrEntity`	`4`
`AttrEntities`	`5`
`AttrNmToken`	`6`
`AttrNmTokens`	`7`
`AttrEnumeration`	`8`
`AttrNotation`	`9`

The example for this item is shown with the ones above: encoding-xml-DTD.salam

DTD attribute default modes `Default…`

Required (#REQUIRED), optional (#IMPLIED), fixed (#FIXED), or carrying a default value.

Name	Value
`DefaultRequired`	`0`
`DefaultImplied`	`1`
`DefaultFixed`	`2`
`DefaultValue`	`3`

The example for this item is shown with the ones above: encoding-xml-DTD.salam

Token kinds `XMLTok…`

The kind of every token from the tokenizer. A self-closing tag gives a start token and then an end token; XMLTokError is reserved and not returned yet.

Name	Value
`XMLTokStartElement`	`1`
`XMLTokEndElement`	`2`
`XMLTokText`	`3`
`XMLTokComment`	`4`
`XMLTokCData`	`5`
`XMLTokEOF`	`6`
`XMLTokError`	`7`

The example for this item is shown with the ones above: encoding-xml-Simple.salam

XPath result kinds `Value…`

The value of the kind field in the result of Evaluate.

Name	Value
`ValueNodeSet`	`0`
`ValueString`	`1`
`ValueNumber`	`2`
`ValueBoolean`	`3`

The example for this item is shown with the ones above: encoding-xml-XPath.salam

Node kinds `Kind…`

The kind of every node in the document.

Name	Value
`KindDocument`	`0`
`KindElement`	`1`
`KindText`	`2`
`KindCData`	`3`
`KindComment`	`4`
`KindProcessingInstruction`	`5`
`KindDoctype`	`6`

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`XMLNamespaceURI`

const XMLNamespaceURI: str = "http://www.w3.org/XML/1998/namespace"

The namespace URI of the xml prefix.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`XMLNSNamespaceURI`

const XMLNSNamespaceURI: str = "http://www.w3.org/2000/xmlns/"

The namespace URI of xmlns.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

Functions

`DefaultWriteOptions`

func DefaultWriteOptions(): WriteOptions

The default write options.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`Write`

func Write(d: Document): str

Writes the document compactly and without a declaration.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`WriteIndent`

func WriteIndent(d: Document, unit: str): str

Writes the document with indenting.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`WriteWith`

func WriteWith(d: Document, opts: WriteOptions): str

Writes the document with the given options.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`WriteNode`

func WriteNode(d: Document, id: int): str

Writes one node and its descendants.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`WriteNodeIndent`

func WriteNodeIndent(d: Document, id: int, unit: str): str

Writes one node with indenting.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`WriteDocument`

func WriteDocument(d: Document): str

Writes the document together with the XML declaration.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`Canonical`

func Canonical(d: Document): str

The canonical form of the document (Canonical XML): attributes sorted, empty elements as a pair, no extra whitespace; for comparing or for digital signatures.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`CanonicalNode`

func CanonicalNode(d: Document, id: int): str

The canonical form of one node.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`DefaultOptions`

func DefaultOptions(): ParseOptions

The default parse options.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`NoError`

func NoError(): ParseError

An empty error to pass to the parse functions.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ErrorText`

func ErrorText(e: ParseError): str

Writes the error as "line, column: message".

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ParseWith`

func ParseWith(text: str, opts: ParseOptions, err &: ParseError): Document

Reads the text with the given options.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Parse`

func Parse(text: str, err &: ParseError): Document

Reads the text; err.ok becomes false when the XML is not well formed.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`WellFormed`

func WellFormed(text: str, err &: ParseError): bool

True when the text is well formed.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ParseDTD`

func ParseDTD(text: str): DTD

Reads DTD text.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`FreeDTD`

func FreeDTD(dtd &: DTD)

Frees the memory of the DTD.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`FreeReport`

func FreeReport(r &: Report)

Frees the memory of the report.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`ReportText`

func ReportText(r: Report): str

Every violation, one per line.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`DeclaredElementCount`

func DeclaredElementCount(dtd: DTD): int

The number of declared elements.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`DeclaredAttributeCount`

func DeclaredAttributeCount(dtd: DTD): int

The number of declared attributes.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`Validate`

func Validate(d: Document, dtd: DTD): Report

Validates the document against the given DTD: the content model, the required attributes, the allowed values and the ids.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`ValidateInternalSubset`

func ValidateInternalSubset(d: Document): Report

Validates the document against the DTD inside its own DOCTYPE.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`CheckNamespaces`

func CheckNamespaces(d: Document): Report

Checks that every prefix is defined.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`ApplyDefaults`

func ApplyDefaults(d &: Document, dtd: DTD): int

Adds the default value of the attributes that were left out and returns how many.

The example for this item is shown with the ones above: encoding-xml-DTD.salam

`UnescapeEntities`

func UnescapeEntities(s: str): str

Resolves entities and character references such as < and س.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`EscapeText`

func EscapeText(s: str): str

Escapes the special characters for text.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`EscapeAttr`

func EscapeAttr(s: str): str

Escapes the special characters for an attribute value, the quote included.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`NewXMLTokenizer`

func NewXMLTokenizer(text: str): XMLTokenizer

A new tokenizer over the text.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`NextToken`

func NextToken(tz &: XMLTokenizer): XMLToken

The next token; XMLTokEOF when the text is used up. Comments, CDATA and text come as their own kinds; <?...?> and <!DOCTYPE> are skipped.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`NewXMLNode`

func NewXMLNode(tag: str): XMLNode

A new simple node with the given name.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Found`

func Found(n: XMLNode): bool

True when the node was found, meaning its name is not empty.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`HasAttr`

func HasAttr(node: XMLNode, name: str): bool

True when the simple node has this attribute.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Attr`

func Attr(node: XMLNode, name: str): str

The value of an attribute of a simple node.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`SetAttr`

func SetAttr(node &: XMLNode, name: str, value: str)

Sets an attribute of a simple node.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`AppendChild`

func AppendChild(node &: XMLNode, child: XMLNode)

Adds a child to a simple node.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Child`

func Child(node: XMLNode, tag: str): XMLNode

The first child with the given name; when there is none, a node whose Found is false.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Children`

func Children(node: XMLNode, tag: str): XMLNodeList

Every child with the given name.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`DecodeStrict`

func DecodeStrict(text: str, ok &: bool): XMLNode

Turns the text into a simple node; ok becomes false when it is not valid.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Decode`

func Decode(text: str): XMLNode

Turns the text into a simple node.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Valid`

func Valid(text: str): bool

True when the text is valid XML.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Encode`

func Encode(node: XMLNode): str

Turns a simple node into text.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`EncodeIndent`

func EncodeIndent(node: XMLNode, unit: str): str

Writes a simple node with indenting.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`EncodeDeclaration`

func EncodeDeclaration(node: XMLNode): str

Writes a simple node together with the XML declaration.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`ToValue`

func ToValue(node: XMLNode): value.Value

Turns a simple node into a value; the attributes get an @ prefix and children sharing a name become an array.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`FromValue`

func FromValue(v: value.Value, rootTag: str): XMLNode

Turns a value into a simple node with the given root name, by the same rule. Numbers and booleans are written as their text; null becomes an empty element.

The example for this item is shown with the ones above: encoding-xml-Simple.salam

`Evaluate`

func Evaluate(d: Document, context: int, expression: str, err &: ParseError): XPathValue

Evaluates an XPath 1.0 expression from the context node.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`FreeValue`

func FreeValue(v &: XPathValue)

Frees the memory of the result.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`Select`

func Select(d: Document, context: int, expression: str, err &: ParseError): NodeList

The nodes the expression picks, such as //item[@price < 100].

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`SelectFirst`

func SelectFirst(d: Document, context: int, expression: str, err &: ParseError): int

The first node picked; -1 when there is none.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`SelectString`

func SelectString(d: Document, context: int, expression: str, err &: ParseError): str

Turns the result into a string.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`SelectNumber`

func SelectNumber(d: Document, context: int, expression: str, err &: ParseError): f64

Turns the result into a number, such as sum(//item/@price).

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`SelectBoolean`

func SelectBoolean(d: Document, context: int, expression: str, err &: ParseError): bool

Turns the result into a boolean.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`IsAttributeRef`

func IsAttributeRef(id: int): bool

True when an id returned by XPath points at an attribute.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`AttributeRef`

func AttributeRef(aid: int): int

Turns an attribute index into the id that XPath returns for attributes.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`ReferencedAttribute`

func ReferencedAttribute(d: Document, id: int): Attribute

The attribute that an XPath id points at.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`StringValue`

func StringValue(d: Document, id: int): str

The string value of a node as XPath defines it: the text of every descendant, or the value of an attribute.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`NodeName`

func NodeName(d: Document, id: int): str

The name of the node or attribute for an XPath id.

The example for this item is shown with the ones above: encoding-xml-XPath.salam

`NewDocument`

func NewDocument(): Document

An empty document, to build one from scratch.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`Free`

func Free(d &: Document)

Frees the memory of the document.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`FreeList`

func FreeList(list &: NodeList)

Frees the memory of the list.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`NodeCount`

func NodeCount(d: Document): int

The number of nodes.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`DocumentNode`

func DocumentNode(d: Document): int

The id of the document node, whose child is the root element.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Root`

func Root(d: Document): int

The id of the root element.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Exists`

func Exists(d: Document, id: int): bool

True when the id points at a node.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Kind`

func Kind(d: Document, id: int): int

The kind of the node.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Name`

func Name(d: Document, id: int): str

The full name of the node.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`LocalName`

func LocalName(d: Document, id: int): str

The name without the prefix.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Prefix`

func Prefix(d: Document, id: int): str

The namespace prefix.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`NamespaceURI`

func NamespaceURI(d: Document, id: int): str

The namespace URI of the node.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Value`

func Value(d: Document, id: int): str

The text of a text or comment node; empty for an element.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Parent`

func Parent(d: Document, id: int): int

The id of the parent.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Line`

func Line(d: Document, id: int): int

The line number of the node in the text.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Column`

func Column(d: Document, id: int): int

The column number of the node.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`IsElement`

func IsElement(d: Document, id: int): bool

True when the node is an element.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ChildCount`

func ChildCount(d: Document, id: int): int

The number of children.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ChildAt`

func ChildAt(d: Document, id: int, index: int): int

The id of child number index.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ChildNodes`

func ChildNodes(d: Document, id: int): NodeList

Every child, text nodes included.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Elements`

func Elements(d: Document, id: int): NodeList

The children that are elements.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`ElementsNamed`

func ElementsNamed(d: Document, id: int, name: str): NodeList

The element children with the given name.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`FirstElementNamed`

func FirstElementNamed(d: Document, id: int, name: str): int

The first child with the given name; -1 when there is none.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Descendants`

func Descendants(d: Document, id: int): NodeList

Every descendant, in document order.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Ancestors`

func Ancestors(d: Document, id: int): NodeList

The parent, its parent, and so on up to the document node.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`NextSibling`

func NextSibling(d: Document, id: int): int

The next node with the same parent; -1 when there is none.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`PreviousSibling`

func PreviousSibling(d: Document, id: int): int

The previous node with the same parent; -1 when there is none.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Depth`

func Depth(d: Document, id: int): int

The depth of the node; the root element is 1.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`AttributeCount`

func AttributeCount(d: Document, id: int): int

The number of attributes of the element.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`AttributeAt`

func AttributeAt(d: Document, id: int, index: int): Attribute

Attribute number index.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`HasAttribute`

func HasAttribute(d: Document, id: int, name: str): bool

True when the element has this attribute.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`AttributeValue`

func AttributeValue(d: Document, id: int, name: str): str

The value of the attribute with the full name; an empty string when there is none.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`AttributeValueNS`

func AttributeValueNS(d: Document, id: int, uri: str, local: str): str

The value of the attribute with the given namespace URI and local name.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Text`

func Text(d: Document, id: int): str

All the text inside the element and its descendants, one after another.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`DirectText`

func DirectText(d: Document, id: int): str

Only the text of the direct children, without the text of inner elements.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`Path`

func Path(d: Document, id: int): str

The path of the node, such as /library[1]/b:book[1].

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`EntityCount`

func EntityCount(d: Document): int

The number of entities defined in the DOCTYPE.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`EntityValue`

func EntityValue(d: Document, name: str): str

The value of one entity.

The example for this item is shown with the ones above: encoding-xml-Parse.salam

`CreateElement`

func CreateElement(d &: Document, name: str): int

Makes a new element and returns its id; it is not attached anywhere yet.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`CreateText`

func CreateText(d &: Document, text: str): int

Makes a new text node and returns its id; it is not attached anywhere yet.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`CreateCData`

func CreateCData(d &: Document, text: str): int

Makes a new CDATA section and returns its id; it is not attached anywhere yet.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`CreateComment`

func CreateComment(d &: Document, text: str): int

Makes a new comment and returns its id; it is not attached anywhere yet.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`CreateProcessingInstruction`

func CreateProcessingInstruction(d &: Document, target: str, data: str): int

Makes a new processing instruction and returns its id; it is not attached anywhere yet.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`Append`

func Append(d &: Document, parent: int, child: int)

Makes the node the last child of the parent.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`InsertBefore`

func InsertBefore(d &: Document, parent: int, child: int, before: int)

Puts the node before the child before.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`RemoveChild`

func RemoveChild(d &: Document, parent: int, child: int): bool

Detaches the child and says whether it was found.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`SetAttribute`

func SetAttribute(d &: Document, id: int, name: str, value: str)

Sets or adds an attribute.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`RemoveAttribute`

func RemoveAttribute(d &: Document, id: int, name: str): bool

Removes an attribute.

The example for this item is shown with the ones above: encoding-xml-Build.salam

`SetText`

func SetText(d &: Document, id: int, text: str)

Replaces every child of the element with one text node.

The example for this item is shown with the ones above: encoding-xml-Build.salam

encoding/xml

Untrusted input

What trips people up

Guide: read a feed with XPath

Guide: namespaces in an Atom feed

Guide: generate a sitemap

Guide: a small config with the simple nodes

Guide: scan a product feed with the tokenizer

Guide: report broken XML

Which interface for which job

Types

WriteOptions

ParseError

ParseOptions

ElementDecl

AttrDecl

DTD

Violation

Report

XMLNode

XMLNodeList

XMLToken

XMLTokenizer

XPathValue

Attribute

Node

Document

NodeList

Constants and variables

Entity limits Entity…

DTD element content kinds Content…

DTD attribute types Attr…

DTD attribute default modes Default…

Token kinds XMLTok…

XPath result kinds Value…

Node kinds Kind…

XMLNamespaceURI

XMLNSNamespaceURI

Functions

DefaultWriteOptions

Write

WriteIndent

WriteWith

WriteNode

WriteNodeIndent

WriteDocument

Canonical

CanonicalNode

DefaultOptions

NoError

ErrorText

ParseWith

Parse

WellFormed

ParseDTD

FreeDTD

FreeReport

ReportText

DeclaredElementCount

DeclaredAttributeCount

Validate

ValidateInternalSubset

CheckNamespaces

ApplyDefaults

UnescapeEntities

EscapeText

EscapeAttr

NewXMLTokenizer

NextToken

NewXMLNode

Found

HasAttr

Attr

SetAttr

AppendChild

Child

Children

DecodeStrict

Decode

Valid

`WriteOptions`

`ParseError`

`ParseOptions`

`ElementDecl`

`AttrDecl`

`DTD`

`Violation`

`Report`

`XMLNode`

`XMLNodeList`

`XMLToken`

`XMLTokenizer`

`XPathValue`

`Attribute`

`Node`

`Document`

`NodeList`

Entity limits `Entity…`

DTD element content kinds `Content…`

DTD attribute types `Attr…`

DTD attribute default modes `Default…`

Token kinds `XMLTok…`

XPath result kinds `Value…`

Node kinds `Kind…`

`XMLNamespaceURI`

`XMLNSNamespaceURI`

`DefaultWriteOptions`

`Write`

`WriteIndent`

`WriteWith`

`WriteNode`

`WriteNodeIndent`

`WriteDocument`

`Canonical`

`CanonicalNode`

`DefaultOptions`

`NoError`

`ErrorText`

`ParseWith`

`Parse`

`WellFormed`

`ParseDTD`

`FreeDTD`

`FreeReport`

`ReportText`

`DeclaredElementCount`

`DeclaredAttributeCount`

`Validate`

`ValidateInternalSubset`

`CheckNamespaces`

`ApplyDefaults`

`UnescapeEntities`

`EscapeText`

`EscapeAttr`

`NewXMLTokenizer`

`NextToken`

`NewXMLNode`

`Found`

`HasAttr`

`Attr`

`SetAttr`

`AppendChild`

`Child`

`Children`

`DecodeStrict`

`Decode`

`Valid`

`Encode`

`EncodeIndent`

`EncodeDeclaration`

`ToValue`

`FromValue`

`Evaluate`

`FreeValue`

`Select`

`SelectFirst`

`SelectString`

`SelectNumber`

`SelectBoolean`

`IsAttributeRef`