1.2.1 XML Concepts

XML is a set of encoding rules that allow simplified parsing of documents, which gives a simple way to represent hierarchical data sets in text. There are six basic constructs in XML:

Open tags: <foo>

Starts a level of hierarchy. An open tag and it's matching close tag constitute an XML element. An element can contain additional elements, data, or both.

Close tags: </foo>

Ends a level of hierarchy. There must be a close tag for every open tag.

Empty tags: <foo/>

Equivalent to <foo></foo>. Functions as a shorthand.

Text: <tag>data</tag>

Any additional text is data.

Attributes: <tag attribute="value"/>

Attributes are used to encode name=value pairs inside the open or empty tag. A specific attribute can appear only once per tag.

Namespaces: <prefix:tag xmlns:prefix="URI"/>

Defines the scope of a tag, as indicated by the prefix. This allows the same tag used in different namespaces to be unique. The URI is not dereferenced, but provides a unique name for the namespace. The "xmlns:" attribute maps the prefix to the given URI.

In addition, comments can be added in XML using the delimiters "<!‑‑" and "‑‑>". For example:

    <!-- This is a comment -->
	    

From these simple concepts, hierarchical documents are constructed, such as the following JUNOS configuration file:

    <configuration
           xmlns:junos="http://xml.juniper.net/junos/7.1I0/junos">
      <system>
        <host-name>my-router</host-name> 
        <domain-name>example.net</domain-name> 
        <time-zone>America/New_York</time-zone>
        <name-server>
          <name>10.4.1.40</name>
        </name-server>
        <accounting inactive="inactive">
          <events>login</events>
          <events>change-log</events>
          <events>interactive-commands</events>
          <destination>
            <tacplus>
              <server>
                <name>10.1.1.1</name>
              </server>
              <server>
                <name>10.2.2.2</name>
              </server> 
            </tacplus>
          </destination> 
        </accounting>
        <syslog>
          <archive>
            <size>64k</size>
            <files>5</files>
            <world-readable/>
          </archive>
          <host>
            <name>lhs</name>
            <contents>
              <name>any</name>
              <alert/>
            </contents>
            <explicit-priority/>
          </host>
        </syslog>
      </system>
      <routing-options>
        <static>
          <route>
            <name>0.0.0.0/0</name>
            <next-hop>10.10.1.1</next-hop>
            <retain/>
          </route>
        </static>
        <autonomous-system inactive="inactive">
          <as-number>42</as-number>
          <loops>9</loops>
        </autonomous-system>
      </routing-options>
    </configuration>
	    

See also http://www.w3c.org/TR/REC-xml.

1.2.2 XPath Concepts

The XPath expression language allows selection of arbitrary nodes from with an XML document. XSLT uses the XPath standard to specify and locate elements in the input document's XML hierarchy. XPath's powerful expression syntax allows complex criteria for selecting portions of the XML input document.

XPath views every piece of the document hierarchy as a node, including element nodes, text nodes, and attribute nodes.

An XPath expression can include a path of XML node names, which select child nodes based on their ancestors' names. Each member of the path must match an existing node, and only nodes that match all path members will be included in the results. The members of the path are separated by the slash character ('/').

For example, the following expression selects all <paragraph> elements that are parented by a <section> element, which in turn must be parented by a <chapter> element, which must be parented by a <doc> element.

    doc/chapter/section/paragraph
	    

XSLT views nodes as being arranged in certain "axes". The "ancestor" axis points from a node up through it's series of parent nodes. The "child" axis points through the list of an element node's direct child nodes. The "attribute" axis points through the list of an element node's set of attributes. The "following‑sibling" axis points through the nodes which follow a node but are under the same parent, while the "proceeding‑sibling" axis points through the nodes that appear before a node and are under the parent. The "descendant" axis contains all the descendents of a node. There are numerous other axes which are not detailed here.

When referring to an axis, use the axis name followed by two colons followed by the element name (which may include an optional prefix and it's trailing colon).

There are two axis aliases that make a convenient shorthand when writing expressions. The "@" alias refers to the attribute axis, allowing either "attribute::number" or "@number" to refer to the "number" attribute. The "//" alias refers to the "descendant‑or‑self" axis, so "doc//paragraph" will find all <paragraph> elements that have a <doc> element as an ancestor.

See also .....

Each XPath expression is evaluated from a particular node, which is referred to as the "context node" (or simply "context"). XSLT changes the context as the document's hierarchy is traversed, and XPath expressions are evaluated from that particular context node.

XPath expression contain two types of syntaxes, a path syntax and a predicate syntax. Path syntax allows traversal along one of the axis in the document's hierarchy from the current context node.

accounting-options

selects an element node named "accounting‑options" that is a child of the current context

server/name

selects an element node named "name" that is parented by an element named "server" that is a child of the current context

/configuration/system/domain-name

selects an element node named "domain‑name" that is parented by a "system" element that is parented by a "configuration" element that is the root element of the document.

parent::system/host-name

selects an element node name "host‑name" that is parented by an element named "system" that is the parent of the current context node. The "parent::" axis can be abbreviated as "..".

A predicate is a boolean test must be satisfied for a node to be selected. Each path member of the XPath expression can have zero or more predicates specified, and the expression will only select nodes for which all the predicates are true.

The predicate syntax allows tests to be performed at each member of the path syntax, and only nodes that pass the test are selected. A predicate appears inside square brackets ("[]") after a path member.

server[name == '10.1.1.1']

selects a "server" element that is a child of the current context and has a "name" element whose value is '10.1.1.1'

*[@inactive]

selects any node ('*' matches any node) that is a child of the current context that has an attribute ('@' selects node from the "attribute" axis) named "inactive"

route[starts-with(next-hop, '10.10.')]

selects a "route" element that is a child of the current context and has a "next‑hop" element whose value starts with the string "10.10."

The "starts‑with" function is one of many functions that are built into XPath. XPath also supports relational tests, equality tests, boolean operations, and many more features not listed here.

SLAX defines a concatenation operator "_" that concatenates its two arguments using the XPath "concat()" function. The following two lines are equivalent:

    expr "Today is " _ $date _ ", " _ $user _ "!!";
    expr concat("Today is ", $date, ", ", $user, "!!");
	    

The SLAX statement "expr" evaluates an XPath expression and inserts its value into the output tree.

XPath is fully described in the W3C's specification, http://w3c.org/TR/xpath.

1.2.3 XSLT Concepts

This section contains some overview material, intended as both overview and introduction. Careful reading of the specification or any of the numerous books on XSLT will certainly be helpful before using commit scripts, but the information here should provide a starting point.

XSLT is a language for transforming one XML document into another XML document. The basic model is that an XSLT engine (or processor) reads a script (or stylesheet) and an XML document. The XSLT engine uses the instructions in the script to process the XML document by traversing the document's hierarchy. The script indicates what portion of the tree should be traversed, how it should be inspected, and what XML should be generated at each point.

                        +-------------+
                        |  XSLT       |
                        |   Script    |
                        +-------------+
                               |
        +-----------+          |           +-----------+
        |XML Input  |          v           |XML Output |
        |  Document |   +-------------+    |  Document |
        |     i     |-->|  XSLT       |--->|     o     |
        |    /|\    |   |   Engine    |    |    / \    |
        |   i i i   |   +-------------+    |   o   o   |
        |  /| |  \  |                      |  /|\  |   |
        | i i i   i |                      | o o o o   |
        +-----------+                      +-----------+
	    

XSLT has seven basic concepts:

• XPath -- expression syntax for selecting node from the input document
• Templates -- maps input hierarchies to instructions that handle them
• Parameters -- a mechanism for passing arguments to templates
• Variables -- defines read-only references to nodes
• Programming Constructs -- how to define logic in XSLT
• Recursion -- templates that call themselves to facilitate looping
• Context (Dot) -- the node currently be inspected in the input document

XPath has be discussed above. The other concepts are discussed in the following sections. These sections are meant to be introductory in nature, and later sections will provide additional details and complete specifications.

    template my-template ($a, $b = 'false', $c = name) {
      /* ... body of the template goes here ... */
    }
	    

    call my-template($c = other-name);
	    

    match route[starts-with(next-hop, '10.10.')] {
      /* ... body of the template goes here ... */
    }
	    

    match route {
        <new> {
            apply-templates *[@changed];
        }
        <all> {
            apply-templates;
        }
    }
	    

    /*
     * This template matches on "/", the root of the XML document.
     * It then generates an element named "outer", and instructs
     * the XSLT engine to recursively apply templates to only the
     * subtree only "configuration/system".  A parameter called
     * "host" is passed to any templates that are processed.
     */
    match / {
        <outer> {
            apply-templates configuration/system {
                with $host=configuration/system/host-name;
            }
        }
    }

    /*
     * This template matches the "system" element, which is the top
     * of the subtree selected above.  The "host" parameter is
     * declared with no default value.  An "inner" element is
     * generated, which contains the value of the host parameter.
     */
    match system {
        param $name = host;
        <inner> $host;
    }
	    

    match system {
      call report-changed($changed = @changed || ../@changed);
    }

    template report-changed($dot = ., $changed = $dot/@changed) {
      /* ... */
    }
	    

    template emit-syslog ($device, $date, $user) {
        var $message = "Device " _ $device _ " was changed on "
                       _ $date _ " by user '" _ $user _ "'";
        <syslog> {
            <message> $message;
        }
    }
	    

    mvar $count = 10;
    if (this < that) {
        set $count = that;
    }

    mvar $errors;
    if ($count < 2) {
        append $errors += <error> {
            <location> location;
            <message> "Not good, dude.";
        }
    }
	    

    if (xpath-expression) {
        /* Code here is evaluated if the expression is true */
    }

    if (xpath-expression) {
        /*
         * xsl:choose is similar to a switch statement, but
         * the "test" expression can vary among "when" statements.
         */

    } else if (another-xpath-expression) {
        /*
         * xsl:when is the case of the switch statement.
         * Any number of "when" statements may appear.
         */

    } else {
        /* xsl:otherwise is the 'default' of the switch statement */
    }

    for-each (xpath-expression) {
        /*
         * Code here is evaluated for each node that matches 
         * the xpath expression.  The context is moved to the
         * node during each pass.
         */
    }

    for $item (items) {
        /* 
         * Code here is evaluated with the variable $item set
         * to each node that matches the xpath expression.
         * The context is not moved.
         */
    }

    for $i (1 ... 20) {
        /*
         * Code here is evaluated with the variable $i moving
         * thru a sequence of values between 1 and 20.  The
         * context is not changed.
         */
    }

    while ($count < 10) {
        /*
         * Code here is evaluated until the XPath expression is
         * false.  Note that this is normally only useful with
         * mutable variables.
         */
    }
	    

    if (@changed) {
        <source> {
            <notify> name();
            if (@changed == "changed") {
                <changed>;

            } else {
                <status> $changed;
            }
        }
    }
	    

    match count {
        call count-to-max($max = count);
    }

    template count-to-max ($cur = "1", $max = "1") {
        param $cur = "1";
        param $max = "1";
	    

        <out> $cur;
        if ($cur < $max) {
            call count($cur = $cur + 1, $max);
        }
    }
	    

    match system {
        var $system = .;

        for-each (name-server/name[starts-with(., "10.")]) {
            <tag> .;
            if (. == "10.1.1.1") {
                <match> $system/host-name;
            }
        }
    }
	    

1.2.4 Additional Resources

The XPath specification is on the W3C web site: (http://www.w3c.org/TR/xpath) and the XSLT specification is on the W3C web site (http://www.w3c.org/TR/xslt).

Books and tutorials on XSLT abound, helping programmers learn the technology. XSLT processors (programs that run XSLT scripts) are available from both commercial and open-source developers, allowing users to play with XSLT offline. IDEs with extended debuggers also exist. XSLT is common enough that piecing together a simple script is easy, as is finding help and advice.

This document lists the SLAX statements, with brief examples followed by their XSLT equivalents. The utility of SLAX will hopefully be appearent, as will the simple transformation that SLAX parsing code is performing.

2.1.1 expr

The "expr" statement adds an XPath expression to the result tree. The expression is the argument to the statement:

    expr "Test: ";
    expr substring-before(name, ".");
    expr status;
	    

2.1.2 uexpr

The "uexpr" behaves identically to the "expr" statement, except that the contents are not escaped. Normally characters like "<", ">", and "&" are escaped into proper XML (as "&lt;", "&gt;", and "&amp;", respectively), but uexpr avoids this escaping mechanism.

    uexpr "<:-&>";
	    

See also disable-output-escaping.

2.2.1 XML Elements

In SLAX, XML elements are encoded using braces instead of the closing tag. The element is given, wrapped in chevrons as in XML, but it then followed by an open brace, the elements contents, and a close brace. If the element is empty, a semi-colon can be used to signify an empty element. If the element contains only a single XPath expression, that expression can be used in place of the braces and the element is ended with a single semi-colon.

Elements are written with in a C-like syntax, with only the open tag. The contents of the tag appear immediately following the open tag. These contents can either be a simple expression, or a more complex expression placed inside braces.

The following SLAX is equivalent to the above XML data:

    <doc> {
        <chapter>
            <section> {
                <paragraph> "A brief introduction";
            }
        }
        <index>;
    }
	    

Programmers are accustomed to using braces, indentations, and editor support to delineate blocks of data. Using these nesting techniques and removing the close tag reduces the clutter and increases the clarity of code.

    <top> {
        <one>;
        <two> {
            <three>;
            <four>;
            <five> {
                <six>;
            }
        }
    }
	    

This is equivalent to:

    <top>
        <one/>
        <two>
            <three/>
            <four/>
            <five>
                <six/>
            </five>
        </two>
    </top>
	    

2.2.2  The "element" Statement

The name of an element can be specified by an XPath expression, using the "element" statement. The contents of the element must be placed inside a set of braces.

In this example, the value of the "name" node (rather than the literal string "name") will be used to create an XML element, whose contents are an empty element with a name of "from‑" concatenated with the value of the address node. Node values are selected from the current context.

    element name {
        element "from-" _ address;
    }
	    

2.3.1 XML Attributes

SLAX uses an identical encoding scheme for attributes:

    <chapter number="1" title="Introduction" ref="intro"> {
        <section number="1"> {
            /* .... content ... */
        }
    }
	    

In addition, XSLT introduces a means of assigning attribute values, called "attribute value templates" (AVT). SLAX encodes these as XPath values for attributes:

Attributes on elements follow the style of XML, with the attribute name, an equals sign, and the value of the attribute.

    <element attr1="one" attr2="two">;
	    

In this example, the attributes are assigned values using XPath values. The "tag" node value is assigned to the "ref" attribute, while the "title" attribute is assigned the value of the "$title" variable.

    <chapter number=position() title=$title ref=tag> {
        <section number=position()> {
            /* .... content ... */
        }
    }
	    

Where XSLT allow attribute value templates using curly braces, SLAX uses the normal expression syntax. Attribute values can be any XPath expression, including quoted strings, parameters, variables, and numbers, as well as the SLAX concatenation operator ("_").

    <location state=$location/state
              zip=$location/zip5 _ "-" _ $location/zip4>;
	    

The XSLT equivalent:

    <location state="{$location/state}"
              zip="{concat($location/zip5, "-", $location/zip4}"/>
	    

Note that curly braces placed inside quote strings are not interpreted as attribute value templates, but as real braces and are escaped when translated into XSLT.

    <avt sign="{here}">;
	    

The XSLT equivalent:

    <avt sign="{{here}}"/>
	    

2.3.2  The "attribute" Statement

The name of an attribute can be specified by an XPath expression, using the "attribute" statement. The contents of the attribute must be placed inside a set of braces.

In this example, the value of the "name" node (rather than the literal string "name") will be used to create an XML attribute, whose contents are an empty element with a name of "from‑" concatenated with the value of the address node. Node values are selected from the current context.

    attribute name {
        expr "from-" _ address;
    }
	    

2.4.1  The "attribute‑set" Statement

The "attribute‑set" statement defines a set of attributes that can be used repeatedly. The argument is the name of the attribute set, and the contents are a set of attribute statements.

    attribute-set table-attributes {
        attribute "order" { expr "0"; }
        attribute "cellpadding" { expr $cellpadding; }
        attribute "cellspacing" { expr $cellspacing; }
    }
	    

2.4.2  The "use‑attribute‑sets" Statement

The "use‑attribute‑sets" statement adds the attributes from a given set to the current element.

    <table> {
        use-attribute-sets table-attributes;
    }
	    

The use-attribute-sets statement can be used under the "element", "copy‑node", and "attribute‑sets" statements, as well as under a normal element.

2.5.1  The "ns" Statement

The "ns" statement defines a mapping from a prefix to a URI namespace identifier. Namespaces must be defined prior to their use.

By default, elements are in the "null" namespace, but the "ns" statement can be used to change the namespace for unprefixed elements.

The syntax of the "ns" statement is:

    ns [<prefix> <options> = ] <uri>;
	    

If a prefix is the value prefixed to element names to indicate their namespace should be that of the given URI. If no prefix is given, the given URI will be applied to all elements that do not include a prefix. The values and meanings of <options> are detailed below.

    ns junos =  "http://xml.juniper.net/junos";
    ns example = "http://www.example.com/example-one";
    ns fo = "http://www.w3.org/1999/XSL/Format";
    ns svg = "http://www.w3.org/Graphics/SVG/SVG-19990812.dtd";
	    

In this example, a default namespace is defined, as well as a namespace mapped to the "test" prefix:

    ns "http://example.com/main";
    ns test = "http://example.com/test";
	    

The XML equivalent is:

    <some-element xmlns="http://example.com/main"
            xmlns:test="http://example.com/test"/>
	    

See also http://www.w3.org/TR/xml#namespaces

Namespace definitions are supplied using the "ns" statement. This consists of either the "ns" keyword, a prefix string, an equal sign and a namespace URI or the "ns" keyword and a namespace URI. The second form defines the default namespace.

    ns junos = "http://www.juniper.net/junos/";
	    

The "ns" statement may appear either following the "version" statement at the beginning of the stylesheet or at the beginning of any block.

    ns a = "http://example.com/1";
    ns "http://example.com/global";
    ns b = "http://example.com/2";

    match / {
        ns c = "http://example.com/3";
        <top> {
            ns a = "http://example.com/4";
            apply-templates commit-script-input/configuration;
        }
    }
	    

When appearing at the beginning of the stylesheet, the ns statement may include either the "exclude" or "extension" keywords. These keywords instruct the parser to add the namespace prefix to the "exclude‑result‑prefixes" or "extension‑element‑prefixes" attribute.

    ns exclude foo = "http://example.com/foo";
    ns extension jcs = "http://xml.juniper.net/jcs";
	    

The XSLT equivalent:

    <xsl:stylesheet xmlns:foo="http://example.com/foo"
                    xmlns:jcs="http://xml.juniper.net/jcs"
                    exclude-result-prefixes="foo"
                    extension-element-prefixes="jcs">
        <!-- ... -->
    </xsl:stylesheet>
	    

2.5.2 Reserved Prefixes

The XML specification reserved all prefixes and attributes beginning with the characters "xml". In addition, SLAX reserves all prefixes and attributes that begin with the characters "slax". These reservations help to future proof against changes and enhancements to the language.

2.5.3  The "extension" Statement

The "extension" statement instructs the processing engine that extenstion namespaces, which will cause elements in that namespace to be given special handling by the engine.

For libslax, the extension keyword instructs the library to search for an extension library associated with the namespace. If found, the extension library is loaded and initialized so the script can use functions and elements defined within that library.

    ns pref extension = "http://some.example.com";
	    

See also http://www.w3.org/TR/xslt#extension-element

2.5.4  The "exclude" Statement

The "exclude" statement prevents the namespace from appearing in the final result tree, effectively blocking it from output.

    ns xslax extension = "http://libslax.org/slax";
	    

See also http://www.w3.org/TR/xslt#literal-result-element

2.6.1  The "processing‑instruction" Statement

The "processing‑instruction" statement adds a processing instruction to the result tree. The argument to the statement is that name of the processing instruction and the contents of the statement (within braces) is the value of that instruction.

    processing-instruction "my-app" {
        expr "my-value";
    }
	    

Both the argument and the value may be XPath expressions.

2.7.1  The "comment" Statement

The "comment" statement adds an XML comment to the result tree. The argument is an XPath expression containing the comment to be added:

    comment "This script was run by " _ $user _ " on " _ $date;
	    

See also comment

The "comment" statement mimics the <xsl:comment> element, allowing XML comments to be generated.

    comment "Added by user " _ $user _ " on " _ $date;
	    

The XSLT equivalent:

    <xsl:comment>
      <xsl:value-of 
           select='concat("Added by user ", $user, " on ", $date)'/>
    </xsl:comment>
	    

2.8.1  The "copy‑of" Statement

The "copy‑of" statement performs a deep copy of a given set of nodes. The argument to the statement is an XPath expression specifying which nodes should be copied.

    copy-of $top/my/stuff;
    copy-of .;
	    

See also copy (Section 2.8.2).

The "copy‑of" statement mimics the functionality of the <xsl:copy‑of> element.

    copy-of configuration/protocols/bgp;
	    

The XSLT equivalent:

   <xsl:copy-of select="configuration/protocols/bgp"/>
	    

2.8.2  The "copy‑node" Statement

The "copy‑node" statement performs a shallow copy of the specific node to the result tree, along with any namespace nodes, but none other child nodes (including attribute nodes) are copied. The contents of the statement are a template specifying what should be inserted into the new node.

    copy-node {
        <that> "one";
    }
	    

See also copy-of (Section 2.8.1).

2.9.1  The "number" Statement

The "number" statement inserts a generated number into the result tree. This statement has two distinct forms. When used with an argument, the statement inserts the number given by that XPath expression, and a set of optional statements can be used to specify the formatting to be used for that number.

When used without an argument, the number is generated based on position of the current node in the source document, and a set of optional statements can be used to specify formatting.

The formatting statements are given in the following table:

The value of the "format" statement gives the style of numbering, as

The selection statements used when the number statement has no argument are given in the following table:

The "level" statement indicates how to count tags:

In the following example, the value of $this is formatted with three digits of output and the number of "section" elements before the current context value is emitted.

    number $this {
        format "001";
    }
    number {
        count section;
    }
	    

See also the format-number() XPath function.

3.1.1  The "template" Statement

Named templates are defined using their name and parameters and invoked using the "call" statement. The template definition consists of the "template" keyword, the template name, a set of parameters, and a braces-delineated block of code. Parameter declarations can be either inline, with the parameter name and optionally an equals sign ("=") and a value expression. Additional parameters can be declared inside the block using the "param" statement.

The template is invoked using the "call" statement, which consists of the "call" keyword followed by a set of parameter bindings. These binding are a comma-separated list of parameter names, optionally followed by an equal sign and a value expression. If the value is not given, the current value of that variable or parameter is passed, giving a simple shorthand for passing parameters if common names are used. Additional template parameters can be supplied inside the block using the "with" statement.

3.1.2  The "call" Statement

Named templates accept parameters by name, rather than by position. This means the caller needs to indicate the name of the desired parameter when passing a value:

    call test($arg1 = 1, $arg4 = 4, $arg2 = 2);
	    

As a convenience, arguments with the same local name as the argument name can be passed directly:

    var $message = "test " _ $name _ " is " _ $status;
    call emit-message($message)
	    

This is identical to "call emit-message($message = $message)", but is simpler and the use of common names increased readability.

The call statement can be used as the initial value of a variable or parameter, without using an enclosing set of braces:

    var $a = call test($a = 1);
	    

    call test {
        with $arg1 = 1;
        with $arg4 = 4;
        with $arg2 = 2;
    }
	    

    SYNTAX::
        'template' template-name 'match' xpath-expression '{'
            template-contents
        '}'

    template test match paragraph ($message) {
        <message> $message;
    }

    match / {
        call test($message = "called as named template");
        apply-templates {
            with $message = "called as match template";
        }
    } 
	    

3.1.3 Example with XSLT Translation

This section includes a short example, allow with the XSLT into which the script translates.

    match configuration {
        var $name-servers = name-servers/name;
        call my:thing();
        call my:thing($name-servers, $size = count($name-servers));
        call my:thing() {
            with $name-servers;
            with $size = count($name-servers);
        }
    }

    template my:thing($name-servers, $size = 0) {
        <output> "template called with size " _ $size;
    }
	    

The XSLT equivalent:

    <xsl:template match="configuration">
      <xsl:variable name="name-servers" select="name-servers/name"/>
      <xsl:call-template name="my:thing"/>
      <xsl:call-template name="my:thing">
        <xsl:with-param name="name-servers" select="$name-servers"/>
        <xsl:with-param name="size" select="count($name-servers)"/>
      </xsl:call-template>
      <xsl:call-template name="my:thing">
        <xsl:with-param name="name-servers" select="$name-servers"/>
        <xsl:with-param name="size" select="count($name-servers)"/>
      </xsl:call-template>
    </xsl:template>

    <xsl:template name="my:thing">
      <xsl:param name="name-servers"/>
      <xsl:param name="size" select="0"/>
      <output>
        <xsl:value-of
             select="concat('template called with size ', $size)"/>
      </output>
    </xsl:template>
	    

3.2.1  The "match" Statement

The "match" statement defines a match template, with its matching criteria and its template. The keyword "match" is followed by an XPath expression that selects the nodes on which this template should be executed. This is followed by a set of curly braces containing the template.

    SYNTAX::
        'match' xpath-expression '{'
            template-contents
        '}'
	    

The template consists of SLAX code, whose statements are defined later in this document.

    match configuration {
        <error> {
            <message> "System is named " _ system/host-name;
        }
    }
	    

3.2.2  The "apply‑templates" Statement

The "apply‑templates" statement instructs the processing engine to apply the set of templates given in the script to a set of nodes. The statement takes as its argument an XPath expression that selects a set of nodes to use. If no expression is given, the current node is used.

The set of XML input nodes is processed according to the set of templates, and the XML output nodes are given to the context in which the apply-templates statement was issued.

Match templates are applied using the "apply‑templates" statement. The statement accepts an optional XPath expression, which is equivalent to the "select" in an <xsl:apply‑templates> element.

    match configuration {
        apply-template system/host-name;
    }

    match host-name {
        <hello> .;
    }
	    

The XSLT equivalent:

    <xsl:template match="configuration">
      <xsl:apply-templates select="system/host-name"/>
    </xsl:template>

    <xsl:template match="host-name">
      <hello>
        <xsl:value-of select="."/>
      </hello>
    </xsl:template>
	    

3.2.3  The "apply‑imports" Statement

The "apply‑imports" statement mimics the <xsl:apply‑imports> element, allowing the script to invoke any imported templates.

    apply-imports;
	    

The XSLT equivalent:

   <xsl:apply-imports/>
	    

3.2.4  The "mode" Statement

The "mode" statement allows the apply-template to choice a distinct set of rules to use during processing. The argument to the "mode" statement is a text string that identifies the mode for both the template and the template processing. Templates processing will only select templates that match the current mode value. If no mode statement is given with an "apply‑templates" invocation, then the current mode remains in effect.

In this example, template processing is invoked twice, first for mode "content" and then for mode "index".

    match doc {
        apply-templates {
            mode "content";
        }
        apply-template {
            mode "index";
        }
    }

    match paragraph {
        mode "content";
        ... template ...
    }

    match paragraph {
        mode "index";
        ... template ...
    }
	    

See also http://www.w3.org/TR/xslt#modes

The "mode" attribute of the <xsl:template> element is available using the "mode" statement. This statement can appear inside a "match" statement and inside an "apply‑templates" statement.

    match * {
        mode "one";
        <one> .;
    }

    match * {
        mode "two";
        <two> string-length(.);
    }

    match / {
        apply-templates version {
            mode "one";
        }
        apply-templates version {
            mode "two";
        }
    }
	    

The XSLT equivalent:

    <xsl:template match="*" mode="one">
      <one>
        <xsl:value-of select="."/>
      </one>
    </xsl:template>

    <xsl:template match="*" mode="two">
      <two>
        <xsl:value-of select="string-length(.)"/>
      </two>
    </xsl:template>

    <xsl:template match="/">
      <xsl:apply-template select="version" mode="one"/>
      <xsl:apply-template select="version" mode="two"/>
    </xsl:template>
	    

3.2.5  The "priority" Statement

The "priority" statement sets the priority of the template, which is used as part of the conflict resolution when more that one template matches a source node. The highest priority rule is chosen. The argument to the "priority" statement is a real number (positive or negative).

In this example, the template is given a high priority:

    match paragraph {
        priority 100;
        ...
    }
	    

See also http://www.w3.org/TR/xslt#conflict

The "priority" statement mimics the "priority" attribute of the <xsl:template> element. It may appear inside a "match" statement.

    match * {
        priority 10;
        <output> .;
    }
	    

The XSLT equivalent:

    <xsl:template match="*" priority="10">
      <output>
        <xsl:value-of select="."/>
      </output>
    </xsl:template>
	    

3.2.6  The "param" Statement

Template can accept parameters from their callers, and scripts can accept parameters from the calling environment (typically the command line). The "param" statement declares a parameter, along with an optional default value.

    SYNTAX::
        'param' parameter-name [ '=' optional-value ] ';'
	    

For example:

    param $address = "10.1.2.3";
    param $count = 25;

    templace count {
        /*
         * This defines a local parameter $count and sets
         * its value to that of the global parameter $count.
         */
        param $count = $count;
    }
	    

Template parameters can also be defined in a C style following the template name:

    template area ($width = 10, $length = 10, $scale = 1) {
        <area> $width * $length * $scale;
    }
	    

3.2.7  The "with" Statement

The "with" statement supplies a value for a given parameter.

    call area {
        with $length = 2;
        with $width = 100;
    }
	    

Parameter values may also be passed using a C/perl style, but since arguments in SLAX (and XSLT) are passed by name, the parameter names are also given:

    call area($width = 100, $length = 2);
	    

Parameters may be passed to match templates using the "with" statement. The "with" statement consists of the keyword "with" and the name of the parameter, optionally followed by an equals sign ("=") and a value expression. If no value is given, the current value of that variable or parameter (in the current scope) is passed, giving a simple shorthand for passing parameters if common names are used.

    match configuration {
        var $domain = domain-name;
        apply-template system/host-name {
            with $message = "Invalid host-name";
            with $domain;
        }
    }

    match host-name {
        param $message = "Error";
        param $domain;
        <hello> $message _ ":: " _ . _ " (" _ $domain _ ")";
    }
	    

The XSLT equivalent:

    <xsl:template match="configuration">
      <xsl:apply-templates select="system/host-name">
        <xsl:with-param name="message" select="'Invalid host-name'"/>
        <xsl:with-param name="domain" select="$domain"/>
      </xsl:apply-templates>
    </xsl:template>

    <xsl:template match="host-name">
      <xsl:param name="message" select="'Error'"/>
      <xsl:param name="domain"/>
      <hello>
        <xsl:value-of select="concat($message, ':: ', ., 
                                    ' (', $domain, ')')"/>
      </hello>
    </xsl:template>
	    

4.1.1  The "var" Statement

Variable are defined using the "var" statement, which accept a variable name and an initial value. Variable names (and parameter names) always begin with a dollar sign ("$").

    SYNTAX::
        'var' variable-name '=' initial-value ';'
	    

The initial value can be an XPath expresion, an element, or a block of statements (enclosed in braces) that emit a set of nodes.

    var $x = 4;
    var $y = <price> cost div weight;
    var $z = {
        expr "this: ";
        copy-of $this;
    }
	    

These same constraints apply to parameters as well.

    SYNTAX::
        'mvar' variable-name '=' initial-value ';'
        'set' variable-name '=' new-value ';'
        'append' variable-name '+=' new-content ';'
	    

    mvar $test;

    set $test = <block> "start here";

    for $item (list) {
        append $test += <item> {
            <name> $item/name;
            <size> $item/size;
        }
    }
	    

4.2.1  The ":=" Operator

The ":=" operator is designed to hide the conversion of RTFs to node sets from the programmer. It is used in assigning initial values to variables and parameters.

    var $this := <this> {
        <that> "one";
        <the-other> "one";
    }
    if ($this/that == "one") {
        <output> "not an invalid type error";
    }
	    

Calling named templates can also produce RTFs, since the "call" statement would be considered complex variable content. But using the ":=" operator removes this problem:

    var $output := call matching-color($match = "corn");
	    

Behind the scenes, SLAX is performing the ext:node-set() call but the details are hidden from the user.

4.2.2  The "?:" Operator

The "?:" operator allows simple logic tests to be coded with the familiar C and Perl operator.

    var $x = ($a > 10) ? $b : $c;
    var $y = $action ?: "display";
	    

The generated XSLT uses an <xsl:choose> element:

    <xsl:variable name="slax-ternary-1">
      <xsl:choose>
        <xsl:when test="($a &gt; 10)">
          <xsl:copy-of select="$b"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:copy-of select="$c"/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:variable>
    <xsl:variable name="x" select="slax:value($slax-ternary-1)"/>
	    

The use of slax:value() make the "?:" operator non-standard, in that it requires a non-standard extension function. Use of the "?:" should be limited to environments where this function is available.

4.3.1  The "for‑each" Statement

The "for‑each" statement iterates through the members of a node set, evaluating the contents of the statement with the context set to each node.

    SYNTAX::
        'for-each' '(' xpath-expression ')' '{'
            contents
        '}'
	    

The XPath expression is evaluated into a set of nodes, and then each node is considered as the "context" node, the contents of the "for‑each" statement are evaluated.

    for-each ($inventory/chassis/chassis-module
              /chassis-sub-module[part-number == '750-000610']) {
        <message> "Down rev PIC in " _ ../name _ ", "
                     _ name _ ": " _ description;
    }
	    

The "for‑each" statement mimics functionality of the <xsl:for‑each> element. The statement consists of the "for‑each" keyword, the parentheses-delimited select expression, and a block.

    for-each ($inventory/chassis/chassis-module
              /chassis-sub-module[part-number == '750-000610']) {
        <message> "Down rev PIC in " _ ../name _ ", "
                     _ name _ ": " _ description;
    }
	    

The XSLT equivalent:

    <xsl:for-each select="$inventory/chassis/chassis-module
              /chassis-sub-module[part-number == '750-000610']">
        <message>
            <xsl:value-of select="concat('Down rev PIC in ', ../name,
                                  ', ', name, ': ', description)"/>
        </message>
    </xsl:for-each>
	    

4.3.2  The "for" Statement

In addition to the standard XSLT "for‑each" statement, SLAX incorporates a "for" statement that allows iteration through a node set without changing the context (".").

    SYNTAX::
        'for' variable-name '(' xpath-expression ')' '{'
            contents
        '}'
	    

The variable is assigned each member of the node-set selected by the expression in sequence, and the contents are then evaluated.

    for $item (item-list) {
        <item> $item;
    }
	    

Internally, this is translated into normal XSLT constructs involving a pair of nested for-each loops, one to iterate and one to put the context back to the previous setting. This allows the script writer to ignore the context change.

4.3.3  The "while" Statement

The "while" statement allows a block of code to be repeated until a condition is no longer true. This construct is only useful when combined with mutable variables (Section 4.1.1.1).

    SYNTAX::
        'while' '(' xpath-expression ')' '{'
            contents
        '}'
	    

The xpath-expression is cast to a boolean type and if true, the contents are evaluated. The context is not changed. This loop continues until the expression is no longer true. Care must be taken to avoid infinite loops.

    mvar $seen;
    mvar $count = 1;
    while (not($seen)) {
        if (item[$count]/value) {
                set $seen = true();
        }
        set $count = $count + 1;
    }
	    

4.3.4  The "..." Operator

Often a loop is required to iterator through a range of integer values, such a 1 to 10. SLAX introduces the "..." operator to generate sequences of such numbers:

    for $i (1 ... 10) {
        <player number=$i>;
    }
	    

The operator translates into an XPath function that generates the sequence as a node set.

4.3.5  The "sort" Statement

The "for‑each" normally considers nodes in document order, but the "sort" statement indicates the specific order the programmer needs.

The "sort" statement takes an expression argument that is used as the key, as well as substatements that alter the normal sort behavior.

Multiple "sort" statements can be used to given secondary sorting keys.

    for-each (author) {
        sort name/last;
        sort name/first;
        sort age {
            order "descending";
        }
    }
	    

XSLT equivalent:

4.3.6  The "if" and "else" Statements

SLAX supports an "if" statement that uses a C-like syntax. The expressions that appear in parentheses are extended form of XPath expressions, which support the double equal sign ("==") in place of XPath's single equal sign ("="). This allows C programmers to avoid slipping into dangerous habits.

    if (this && that || the/other[one]) {
        /* SLAX has a simple "if" statement */
    } else if (yet[more == "fun"]) {
        /* ... and it has "else if" */
    } else {
        /* ... and "else" */
    }
	    

Depending on the presence of the "else" clause, an "if" statement can be transformed into either an <xsl:if> element or an <xsl:choose> element.

    if (starts-with(name, "fe-")) {
        if (mtu < 1500) {
           /* Deal with fast ethernet interfaces with low MTUs */
        }
    } else {
        if (mtu > 8096) {
           /* Deal with non-fe interfaces with high MTUs */
        }
    }
	    

The XSLT equivalent:

    <xsl:choose>
      <xsl:when select="starts-with(name, 'fe-')">
        <xsl:if test="mtu &lt; 1500">
          <!-- Deal with fast ethernet interfaces with low MTUs -->
        </xsl:if>
      </xsl:when>
      <xsl:otherwise>
        <xsl:if test="mtu &gt; 8096">
          <!-- Deal with non-fe interfaces with high MTUs -->
        </xsl:if>
      </xsl:otherwise>
    </xsl:choose>
	    

4.4.1  The "function" Statement

The "function" statement defines a function that can be called in XPath expressions.

    SYNTAX::
        'function' function-name '(' argument-list ')' '{'
            function-template
        '}'
	    

The argument-list is a comma separated list of parameter names, which will be positionally assigned based on the function call. Trailing arguments can have default values, in a similar way to templates. If there are fewer parameters in the invocation than in the definition, then the default values will be used for any trailing arguments. If is an error for the function to be invoke with more arguments than are defined.

    function size ($width, $length, $scale = 1) {
        ...
    }
	    

Function parameters can also be defined using the "param" statement.

4.4.2  The "result" Statement

The "result" statement defines a value or template used as the return value of the function.

    SYNTAX::
        'result' value ';'
        'result' element
        'result' '{'
            result-template
        '}'
	    

The value can be a simple XPath expression, an XML element, or a set of instructions that emit the value to be returned.

    function size ($width, $length, $scale = 1) {
        result $width * $length * $scale;
    }

    function box-parts ($width, $height, $depth, $scale = 1) {
        result <box> {
            <part count=2> size($width, $depth);
            <part count=2> size($width, $height);
            <part count=2> size($depth, $height);
        }
    }

    function ark () {
        result {
            <ark> {
                expr box-parts(2.5, 1.5, 1.5);
            }
        }
    }
	    

5.5.1  The "message" Statement

The "message" statement allows output to be generated immediately, without waiting until the script generates its final result tree.

    SYNTAX::
        'message' message-expression ';'
	    

The message-expression is an XPath expression that is emitted as output, typically on the standard error file descriptor.

    if (not(valid)) {
        message "The " _ name() _ " node is not valid";
    }
	    

See also http://www.w3.org/TR/xslt#message

5.5.2  The "terminate" Statement

The "terminate" statement can be used to deliver a message to the user and then exit the script.

    SYNTAX::
        'terminate' message-expression ';'
	    

The message-expression is an XPath expression that is emitted as output, like the "message" statement. The script then stops any further processing.

5.5.3  The "trace" Statement

Trace output is vital to writing, debugging, and maintaining scripts. SLAX introduces a trace facility that will record XPath expressions or template contents in a trace file. If tracing is not enabled, then no trace output is generated. The enabling of tracing and the naming of trace files is not covered here, since it is typically a feature of the environment in which a SLAX script is called. For example, the "slaxproc" command uses the "‑t" and "-T file" to enable tracing.

    SYNTAX::
        'trace' trace-message ';'
        'trace' '{'
            trace-template
        '}'
	    

The trace-message is an XPath expression that is written to the trace file. The trace-template is executed and the results are written to the trace file.

    trace "max " _ $max _ "; min " _ $min;
    trace {
        <max> $max;
        <min> $min;
    }
    trace {
        if ($my-trace-flag) {
            expr "max " _ $max _ "; min " _ $min;
            copy-of options;
        }
    }
	    

5.7.1  The "strip‑space" Statement

The "strip‑space" statement tells the engine to discard the given elements if they contain only whitespace.

    SYNTAX::
        'strip-space' list-of-element-names ';'
	    

The list-of-element-names is a space separated list of element names that should have their contents discarded if they contain only whitespace.

    strip-space section paragraph bullet;
	    

See also http://www.w3.org/TR/xslt#strip

The "strip‑space" statement mimics the <xsl:strip‑space> element, instructing the XSLT processor that certain elements should have internal whitespace removed.

    strip-space foo goo moo;
	    

The XSLT equivalent:

    <xsl:strip-space elements="foo goo moo"/>
	    

5.7.2  The "preserve‑space" Statement

The "preserve‑space" statement works similar to the "strip‑space" statement, but with the opposite result.

    SYNTAX::
        'preserve-space' list-of-element-names ';'
	    

The list-of-element-names is a space separated list of element names that should have their contents retained even if they contain only whitespace.

    preserve-space art picture line;
	    

See also http://www.w3.org/TR/xslt#strip

The "preserve‑space" statement mimics the <xsl:preserve‑space> element, instructing the XSLT processor that certain elements should have internal whitespace retained.

    preserve-space foo goo moo;
	    

The XSLT equivalent:

    <xsl:preserve-space elements="foo goo moo"/>
	    

6.1.1 slax:base64-decode

Use the slax:base64-decode function to decode BASE64 encoded data. BASE64 is means of encoding arbitrary data into a radix-64 format that can be more easily transmitted, typically via STMP or HTTP.

The argument is a string of BASE64 encoded data and an option string which is used to replace any non-XML control characters, if any, in the decoded string. If this argument is an empty string, then non-xml characters will be removed. The decoded data is returned to the caller.

    SYNTAX::
        string slax:base64-decode(string [,control])

    EXAMPLE::
        var $real-data = slax:base64-decode($encoded-data, "@");
	    

6.1.2 slax:base64-encode

Use the slax:base64-encode function to encode a string of data in the BASE64 encoding format. BASE64 is means of encoding arbitrary data into a radix-64 format that can be more easily transmitted, typically via STMP or HTTP.

The argument is a string of data, and the encoded data is returned.

    SYNTAX::
        string slax:base64-encode(string)

    EXAMPLE::
        var $encoded-data = slax:base64-encode($real-data);
	    

6.1.3 slax:break-lines

Use the slax:break-lines function to break multi-line text content into multiple elements, each containing a single line of text.

    SYNTAX::
        node-set slax:break-lines(node-set)

    EXAMPLE::
        var $lines = slax:break-lines(.//p);
        for-each ($lines) {
            if (start-with("pfe:", .)) {
                <output> .;
            }
        }
	    

6.1.4 slax:dampen

Use the slax:dampen() function to limit the rate of occurrence of a named event. If slax:dampen() is called more than "max" times in "time‑period" minutes, it will return "true", allowing the caller to react to this condition.

    SYNTAX::
        boolean slax:dampen(name, max, time-period)

    EXAMPLE::
        if (slax:dampen("reset", 2, 10)) {
            message "reset avoided";
        } else {
            <reset>;
        }
	    

6.1.5 slax:document

Use the slax:document() function to read a data from a file or URL. The data can be encoded in any character set (defaulting to "utf‑8") and can be BASE64 encoded. In addition, non-XML control characters, if any, can be replaced.

    SYNTAX::
        string slax:document(url [, options])

    EXAMPLE::
        var $data = slax:document($url);

        var $options := {
            <format> "base64";
            <encoding> "ascii";
            <non-xml> "#";
        }
        var $data2 = slax:document($url, $options);
	    

If the <non‑xml> value is an empty string, then non-xml characters will be removed, otherwise they will be replaced with the given string.

6.1.6 slax:evaluate

Use the slax:evaluate() function to evaluate a SLAX expression. This permits expressions using the extended syntax that SLAX provides in addition to what is allowed in XPath (see Section 2.1). The results of the expression are returned.

    SYNTAX::
        object slax:evaluate(expression)

    EXAMPLE::
        var $result = slax:evaluate("expr[name == '&']");
	    

6.1.7 slax:first-of

Use the slax:first-of() function to find the first value present in a test of arguments. The first non-empty or non-zero length string will be returned.

    SYNTAX::
        object slax:first-of(object+)

    EXAMPLE::
        var $title = slax:first-of(@title, $title, "Unknown");
	    

6.1.8 slax:get-command

Use the slax:get-command() function to return an input string provided by the user in response to a given prompt string. If the "readline" (or "libedit") library was found at install time, the returned value is entered in the readline history, and will be available via the readline history keystrokes (Control-P and Control-N).

    SYNTAX::
        string slax:get-command(prompt)

    EXAMPLE::
        var $response = slax:get-command("# ");
	    

6.1.9 slax:get-input

Use the slax:get-input() function to return an input string provided by the user in response to a given prompt string.

    SYNTAX::
        string slax:get-input(prompt)

    EXAMPLE::
        var $response = slax:get-input("Enter peer address: ");
	    

6.1.10 slax:get-secret

Use the slax:get-secret() function to return an input string provided by the user in response to a given prompt string. Any text entered by the user will not be displayed or echoed back to the user, making this function suitable for obtaining secret information such as passwords.

    SYNTAX::
        string slax:get-secret(prompt)

    EXAMPLE::
        var $response = slax:get-secret("Enter password: ");
	    

6.1.11 slax:is-empty

Use the slax:is-empty() function to determine if a node-set or RTF is truly empty.

    SYNTAX::
        boolean slax:is-empty(object)

    EXAMPLE::
        if (slax:is-empty($result)) {
            message "missing result";
        }
	    

6.1.12 slax:printf

Use the slax:printf() function to format text in the manner of the standard "C" "printf" function (printf(3)). The normal printf format values are honored, as are a number of "%j" extensions.

    SYNTAX::
        string slax:printf(format, string*)

    EXAMPLE::
        for-each (article) {
            for-each (author) {
                message  slax:printf("%8j1s%8s%8jcj1s %jt{b:}s",
                                    ../title, name, dept, born);
            }
        }
	    

6.1.13 slax:regex

    SYNTAX::
        node-set slax:regex(pattern, string, opts?)
	    

Match a regex, returning a node set of the full string matched plus any parenthesized matches. Options include "b", "i", "n", "^", and "$", for boolean results, ICASE, NEWLINE, NOTBOL, and NOTEOL.

6.1.14 slax:sleep

    SYNTAX::
        void slax:sleep(seconds, milliseconds)
	    

Sleep for a given time period.

6.1.15 slax:split

    SYNTAX::
        node-set slax:split(pattern, string, limit)
	    

Break a string into a set of elements, up to the limit times, at the pattern.

6.1.16 slax:sysctl

    SYNTAX::
        string slax:sysctl(name, format)
	    

Retrieve a sysctl variable. Format is "i" or "s".

6.1.17 slax:string-to-xml

    SYNTAX::
        node-set slax:string-to-xml(string+)
	    

Return parsed XML of concatenated arguments.

6.1.18 slax:syslog

    SYNTAX::
        void slax:syslog(priority, string+)
	    

Syslog the concatenation of set of arguments.

6.1.19 slax:xml-to-string

    SYNTAX::
        string slax:xml-to-string(node-set+)
	    

Return stringified XML hierarchies.

7.2.1  Argument Handling

slaxproc accept the script name, input name, and output name in two ways. You can say:

    slaxproc script.slax input.xml output.xml
	    

using positional arguments. This way allows slaxproc to be plug compatible with xsltproc.

The other way is to give explicit option values using "‑n", "‑i", and "‑o". The above command line can be given as:

   slaxproc -i input.xml -n script.slax -o output.xml
	    

These options can be in any order and can be intermixed with other arguments. If none of the values are given, they can still be parsed positionally. In this example, the script name is positional but the input and output file names are positional.

   slaxproc -i input.xml -o output.xml -g -v script.slax
	    

    #!/usr/bin/slaxproc -n
	    

    #!/opt/local/bin/slaxproc -n
	    

    #!/usr/bin/slaxproc -E -n 
	    

    $ that-script -g output.xml
	    

    /usr/bin/slaxproc -E -n /path/to/that-script -g output.xml
	    

7.2.2 Command Line Options

Command line options to slaxproc can be divided into two types. Mode options affect the

8.2.1 curl Elements

Curl operations are directed using a set of elements, passed to the curl extension functions. This section gives details on the elements supported.

    SYNTAX::
      <url> "target-url";
	    

    SYNTAX::
      <method> $method;
	    

    SYNTAX::
      <username> "username";
	    

    SYNTAX::
      <password> "password";
	    

    SYNTAX::
      <content-type> "mime/type";
	    

    SYNTAX::
      <contents> "multi-\nline\ncontents\n";
	    

    SYNTAX::
      <server> "email-server.example.com";
	    

    SYNTAX::
      <local> "local host name";
	    

    SYNTAX::
      <from> "source-user@email.example.com";
	    

    SYNTAX::
      <subject> "email subject string";
	    

    SYNTAX::
      <upload>;
	    

    SYNTAX::
      <fail-on-error>;
	    

    SYNTAX::
      <verbose>;
	    

    SYNTAX::
      <insecure>;
	    

    SYNTAX::
      <secure>;
	    

    SYNTAX::
      <to> "to-user@email.examplecom";
	    

    SYNTAX::
      <cc> "cc-user@email.examplecom";
	    

    SYNTAX::
      <header name="name"> "value";
	    

    SYNTAX::
      <param name="x"> "y";
	    

8.2.2 curl:perform

The "curl:perform" extension function performs simple transfers.

8.2.3 curl:open

The "curl:perform" extension function opens a connection to a remote server, allowing multiple operations over a single connection.

8.2.4 curl:set

The "curl:set" extension function records a set of parameters that will persist for the lifespan of a connection.

8.2.5 curl:single

The "curl:single" extension function performs transfer operations without using a persistent connection.

8.2.6 curl:close

The "curl:close" extension function closes an open connection. Further operations cannot be performed over the connection.