Work in progress This version may be updated without notice.

1 What is EXP ?

The Active Tags specification describes the generic behaviour of an engine that consider tags as actions to perform (such tags are active tags). As tags that are active are bound to a namespace URI, each set of tags that share the same namespace URI are belonging to a module. The Active Tags specification describes the usual behaviour of an engine, a data model, how tags of different modules may cooperate, and how modules are loaded automatically.

However, a user may find necessary to use an engine that doesn't automatically load the modules, or that must deal with specific custom modules. EXP is an Active Tags module that groups this kind of features together.

This specification describes the EXP module, that act on the engine behaviour. It describes how to invoke a processor, how to define reusable modules declarations and how to use these declarations for bootstrapping.

In addition, this specification explains how modules must define the bindings between the tags and attributes and their concrete implementation, between the predefined properties and their property resolver, and between the extended XPath functions and their implementation.

An engine that has unmarshalled an active sheet with its own settings is called a processor instance.

2 Processor usage

EXP provides various means to configure a processor for various purpose.

2.1 Internal tuning

Internal tuning means acting on the actual active sheet.

Tags that are bound to a module are active tags, and automatically unmarshalled to concrete actions when encountered. When such tags need to be inactive, it is necessary to disable the module for the tags that are using a specific prefix. Thus, the module is still available when using another prefix not disabled. Tags, foreign attributes, predefined properties and extended XPath functions that uses a disabled prefix are inactive, and may cause errors, as explained in the section "module resolution".

Two EXP foreign attributes are designed as directives that enable or disable the tags that are active, and another one that allow to specify a catalog :

@exp:disable-prefixes

This attribute contains a list of prefixes used by the tags to disable; prefixes are separated with blanks. The tags bound to a module for which their prefix is not in this list are active tags. The others are handled by the fallback module.

@exp:enable-prefixes

This attribute contains a list of prefixes used by the tags to enable; prefixes are separated with blanks. The tags bound to a module for which their prefix is in this list are active tags. The others are handled by the fallback module.

Usage

Each prefix listed in these attributes must be involved in a namespace declaration. The scope of the enable/disable directive is the whole active sheet.

Only one or zero of these attributes may be used within an active sheet. If none is used, each tag bound to a module is an active tag, others are handled by the fallback module. These attributes must be used in the root element of the active sheet.

An active sheet can't act on the EXP module on itself, that is to say on the active sheet that uses this directives. The EXP module is still active even if not specified when using @exp:enabled-prefixes, which automatically enables the prefix used in this attribute It can't be disabled with @exp:disabled-prefixes. Attempting to disable the EXP module cause a fatal error.

<?xml version="1.0" encoding="iso-8859-1"?>
<XCL:active-sheet exp:disable-prefixes="XCL"
    xmlns:exp="http://ns.inria.org/active-tags/exp"
    xmlns:xcl="http://ns.inria.org/active-tags/xcl"
    xmlns:XCL="http://ns.inria.org/active-tags/xcl"
    xmlns:sys="http://ns.inria.org/active-tags/sys">
    <xcl:for-each select="{$sys:env/logic}">
        <XCL:logic name="{name}">
            <XCL:set name="{param}" value="{value}"/>
        </XCL:logic>
    </xcl:for-each>
</XCL:active-sheet>

These directives should be used for active sheets that will run on a target not known by the user.

@exp:use-catalog

This attribute contains an URI reference to the catalog to use by the actual active sheet. If several catalogs must be specified, the user have to create a catalog that refers to all its catalogs and set its URI in the attribute.

This attribute must be specified on the root element of the active sheet.

If the catalog lead to a definition or a redefinition of some materials used at the same place (including the root element), the right implementation will be used, even if the version is specified.

2.2 Invoking

It is very useful to design XML documents that contains Active Tags snippet code; these XML documents became dynamic, like shown in the example below.

Invoke example

As a single document may be invoked directly, it is necessary to build another active sheet when a collection of dynamic XML documents needs to be performed. This new active sheet would be able to browse the collection and invoke each item as an active sheet, like shown in the example below, where only one dynamic document is invoked.

The <exp:invoke> tag has been designed for this purpose.

Invoke example

2.3 Bootstraping

When a program needs to be launched with fine grained control of its behaviour, one often uses command line options. For example :

myTool --super-option=on --another-option=useful --more-option=do_it_like_this  fileToProcess

EXP allows to express all the options needed by an Active Tags engine inside another active sheet.

Thus, an Active Tags engine could be simply launched like this, without options :

myEngine launcher.exp

The launcher.exp file is not really the file to process; it just instanciates another engine (with the real fileToProcess) with the appropriate options thanks to EXP tags and attributes.

However, implementations are still free to provide command line options or not.

To do so, the launcher simply uses the EXP tags, and eventually the XCL tags. Other modules could also be used, but the role of a launcher is just to customize a new engine that will do the job. Another advantage of using a launcher, is that it is able to pass as parameters any object type, whereas a command line could only pass strings.

Particularly, a launcher may register additional modules that are not known by the default implementation. Notice that for this purpose, the implemented engine is free to use any convenient way, such as defining a specific configuration file.

<?xml version="1.0" encoding="iso-8859-1"?>
<xcl:active-sheet
    xmlns:exp="http://ns.inria.org/active-tags/exp"
    xmlns:xcl="http://ns.inria.org/active-tags/xcl">
    <exp:unmarshal name="engine" source="file:///path/to/active-sheet.xcl">
        <!--supply the catalog that defines custom modules-->
        <xcl:param name="use-catalog" value="file:///path/to/my-resources.cat"/>
    </exp:unmarshal>
    <exp:invoke processor="{ $engine }"/>
</xcl:active-sheet>

The engine to invoke will have the knowledge of custom module bindings if an Active Catalog that declares these resources has been specified, like shown above. The following example is such a catalog.

Declaring EXP modules with Active Catalog

The following document is a catalog that bind resources (module definitions and schemata) to a namespace URI : <?xml version="1.0" encoding="iso-8859-1"?> <cat:catalog xmlns:cat="http://ns.inria.org/active-catalog" xmlns:exp="http://ns.inria.org/active-tags/exp" xmlns:xcl="http://ns.inria.org/active-tags/xcl" xmlns:asl="http://ns.inria.org/active-schema"> <cat:resource name="http://www.acme.org/purchase-orders" selector="exp:module" uri="file:///path/to/po-module.exp"/> <cat:resource name="http://www.acme.org/purchase-orders" selector="asl:schema" uri="file:///path/to/po-schema.asl"/> </cat:catalog> The customized processor instance will first registers the modules provided by the default implementation. Then, the additional modules will be registered. Notice that it is possible to override some tags of the modules provided by the default implementation : in fact, another version of the module must be specified (the version is indicated inside the module definition). This catalog file should be placed in a directory where the Active Tags engine automatically adds the files in its own catalog list, if such feature is provided, or explicitely referenced as a parameter name "use-catalog" of the <exp:unmarshal> element. If several catalogs have to be used, this parameter can be specified several times, but a master catalog is more appropriate. Please refer to the Active Catalog specification for further information about XML catalogs. A processor instance should always be backed by a primal catalog that defines the resources needed for the engine to work. A catalog only defines mappings ; the processor instance will use it only on module requests, that take care of module enabling/disabling. Notice that an active sheet can also self-define a catalog to use, as explained in the "internal tuning" section.

EXP is the sole module that can't be overriden. Furthermore, to escape EXP in an active sheet, it is mandatory to use a launcher that disables EXP in the outer active sheet.

External tuning

The only way to act on the EXP module in an active sheet is to use a second active sheet for bootstrapping (see the section about internal tuning).

For this purpose, <exp:unmarshal> uses the following two attributes :

• @disable-prefixes
• @enable-prefixes

Notice that @exp:disable-prefixes and @exp:enable-prefixes in one hand, and @disable-prefixes and @enable-prefixes of the <exp:unmarshal> element on the other hand are not the same attributes.

The formers (that are foreign attributes) are designed to act on the active sheet they belong (if they are active), the latters (that are not foreign attributes) are designed to act on an external active sheet.

@disable-prefixes and @enable-prefixes are taking precedence on @exp:disable-prefixes and @exp:enable-prefixes.

<?xml version="1.0" encoding="iso-8859-1"?>
<xcl:active-sheet
    xmlns:exp="http://ns.inria.org/active-tags/exp"
    xmlns:xcl="http://ns.inria.org/active-tags/xcl">
    <exp:unmarshal disable-prefix="exp" name="proc" source="file:///path/to/active-sheet.xcl"/>
    <exp:invoke processor="{$proc}"/>
</xcl:active-sheet>

2.4 Passing parameters

The <exp:invoke> element uses a context to pass parameters to the data set used by the invoked processor, and the <exp:exports> element to keep return values in the data set used by the invoker.

    <exp:invoke processor="{$proc}">
        <!-- the target processor will be able to use $boat-name -->
        <xcl:param name="boat-name" value="titanic"/>
        <exp:exports>
            <!-- if the target processor has created the property $captain-age
                 it is reproduced inside this launcher when exiting the target
                 processor -->
            <exp:export name="captain-age" scope="global" value="{$captain-age}"/>
            <xcl:if test="{ $boat/@has-sunk }">
                <!-- another property is created inside this launcher, but there
                     is a condition -->
                <exp:export name="casualties" scope="local" value="{ value( $boat/@casualties )}"/>
            </xcl:if>
        </exp:exports>
    </exp:invoke>

2.5 Miscellaneous features

Logging

EXP allows to tune the logs at runtime. This can be done thanks to the <exp:log> active tag :

• The @level attribute is used to set the log verbosity. The values allowed are implementation dependent. It must be possible to turn on/off the logs.
• The @processor attribute, if present, is a reference to the processor to which the directive applies. When omitted, it applies to the current processor instance. Notice that when nested within an <exp:invoke> action, the current processor instance becames the invoked instance, not the hosted instance.
• The @persistence attribute, that indicates if the level must be set definitively (by default or specified by permanent), or if it is volatile (applies to the current thread only).

Additionally, the log output flow may be specified with the <exp:log-stream> element and its @output attribute. If the value is a string, it denotes a file to write to, otherwise it must be a reference to an output stream. A log output flow may be specified only once on behalf of a processor instance.

Fast fail

When unmarshalling, the engine usually use schemata to check the validity of tags unmarshalled by the engine. When a constraint violation is encountered, the engine must go on to report other errors. The @fail-fast attribute of the <exp:unmarshal> element is a directive that allows to stop the unmarshall phase as soon as an error occurs.

Notice that validity checking may also be turned off.

3 Module definition

This chapter introduces the structure that allows to map Active Tags materials (tags, foreign attributes, predefined properties and extended XPath functions) with their concrete implementation. See also the chapter about modularization of the Active Tags specification.

A module definition will be unmarshalled by the processor only if it is used.

3.1 Implementations binding

The <exp:module> element is used to define the Active Tags materials of the module. It is the root element of the module definition.

A processor instance will use the module bindings known by the implementation :

• the core modules (EXP, XCL, ASL, Active Catalog and the internal fallback modules)
• the modules provided by the implementation (for example : I/O, System, RDBMS...), if any,
• the modules provided by other vendors (for example : an LDAP module that wouldn't be part of the implementation used), if any,
• other shared modules (for example : a Foo module), if any.

Of course, the self-bindings are implementation dependant ; others should be defined inside a catalog.

The <exp:module> element works with 2 usages :

• if the @source attribute is defined, it contains an object reference to the external resource, as an expression :
  • a string is used as an URI to the XML resource,
  • an XML document ready to unmarshal,
  • a module definition already unmarshalled.
  The <exp:module> element must be empty. Refering to a module definition is the same as if the underlying definitions were declared in-line.
• otherwise, the @version attribute must be defined.

In both cases, @target contains a prefix that must be bound to a namespace URI. This prefix is used for the mappings of the module, defined by the subelements.

<?xml version="1.0" encoding="iso-8859-1"?>
<exp:module target="acme" version="1.0"
                xmlns:exp="http://ns.inria.org/active-tags/exp"
                xmlns:acme="http://www.acme.org/purchase-order">
        <exp:element name="acme:send-purchase-order" source="..."/>
        <exp:attribute name="acme:notify-customer" source="..."/>
        <exp:property name="acme:discount" source="..."/>
        <exp:function name="acme:check-customer-account" source="..."/>
    </exp:module>

The elements <exp:element>, <exp:attribute>, <exp:property>, and <exp:function>, may appear in any order zero or more times.

• The @name attribute contains the qualified name of the material. The prefix used in the qualified name must be bound to the same namespace URI as those declared by the module (@target attribute).
• The @source attribute contains a value that refers to the implementation of the material : an URI of the material to unmarshal or instanciate, or a reference to the relevant typed data (#exp:element-definition, #exp:attribute-definition, #exp:property-definition, #exp:function-definition). EXP doesn't offer means to retrieve the concrete classes of that types ; if an URI is supplied, it must be understood by the underlying implementation for building/getting the implementation of the actual material.

In addition :

• The <exp:element> may also use the @enable-ns and @disable-ns attributes to locally specify which subtags are active when the tag delegates unmarshalling to the engine. They work like the @enable-prefixes and @disable-prefixes attributes for the <exp:unmarshal> element on behalf of the tag specified, except that :
  • the scope is limited to the immediate sublevel,
  • the directive applies to the namespace URIs, not to the prefixes,
  • a disabled prefix is still ignored,
  • an enabled namespace works on enabled prefixes only (prefixes that has not been explicitely disabled or prefixes that has been explicitely enabled).
  Subtags that are not using these directives or that unmarshal themselves their subsubtags are ruled by the standard behaviour specified in the Active Tags specification. These directives apply to all tags specified with the @name attribute. [FIXME: I don't remember why I did this ; I just remember that it was usefull ; but for what purpose ?]
• The @name attribute may be omitted ; in this case, if the resource is not found with its name, the definition that doesn't use the @name attribute will be used as a fallback definition that returns -or not- the implementation. If the fallback definition of an element (<exp:element>), a foreign attribute (<exp:attribute>), or an XPath function (<exp:function>) doesn't return an implementation, a fatal error must be launched. If the fallback definition of a property (<exp:property>) doesn't return an implementation, then the property is simply not found.

If <exp:module> is the root of an XML active sheet, the module definition produced is set on the current object.

Additional attributes may have other roles when unmarshalling or at runtime. Please refer to the reference for the exhaustive description.

The @deferred attribute ("yes" or "no") may be used to force the module definitions to be loaded when unmarshalling. By default, the bindings are processed the first time the module is invoked.

3.1.1 Inline implementation (macro definitions)

When the @source attribute is missing, the implementation is given by the subelements of the definition ; thus, a definition can be a kind of "macro". When a macro is processed, a new data set is used, but parameters may be passed, and some properties set by the macro may also be kept (with the <exp:export> element).

• For an element definition (<exp:element>) : at runtime, the $exp:params predefined property is set to a collection of named items ; each unprefixed attributes used in the element defined becomes a named item in the collection. This item has the same name as the attribute, and its value is the attribute value evaluated as an expression. The $exp:element predefined property is set to the element that invokes the macro in the source active sheet.
  If the element defined is used with subtags, they are processed like the <exp:invoke> element to pass parameters before processing the macro-element, and may also use the <exp:exports> element to keep properties after processing the macro-element.
• For an XPath function (<exp:function>) : at runtime, the $exp:args predefined property is set to a collection of unnamed items ; all arguments used in the function defined is an entry in the collection. The function returns the current object that may be set after running the subtags. The current object is saved before execution, and restored after execution, so that the current object of the caller is not affected by the function execution. Moreover, the macro itself can use the <exp:exports> element to keep properties after processing the macro-function. See an example of macro function here.
• For a predefined property (<exp:property>) : at runtime, the property is set to the current object that may be set after running the subtags. The current object is saved before execution, and restored after execution, so that the current object of the caller is not affected by the subtags execution. Like macro functions, the macro itself can use the <exp:exports> element to keep properties after processing the macro-property.
• A foreign attribute can't have an inline implementation.

The example below shows an active tag which is defined inline. This other example shows several XPath functions which are also defined inline.

    <exp:element name="macro:transform-and-save"
    xmlns:io="http://ns.inria.org/active-tags/io"
    xmlns:xcl="http://ns.inria.org/active-tags/xcl"
    xmlns:serialize="http://ns.inria.org/active-tags/serialize"
    xmlns:macro="http://www.foo.com/macros">
        <xcl:parse name="xml" source="{$exp:params/file}"/>
        <xcl:transform name="fo" source="{$xml}" stylesheet="{$exp:params/xslt}"/>
        <serialize:to-pdf output="{substring-before( $exp:params/file/@absolute-path, '.xml' )}.pdf"
 source="{$fo}" stylesheet="{$exp:params/xslt}"/>
    </exp:element>

<?xml version="1.0" encoding="iso-8859-1"?>
<xcl:active-sheet
    xmlns:xcl="http://ns.inria.org/active-tags/xcl"
    xmlns:macro="http://www.foo.com/macros">
    <xcl:logic>
        <!-- the same stylesheet for all XML files -->
        <xcl:parse-stylesheet name="xslt" source="file:///path/to/myStylesheet.xsl"/>
        <xcl:set name="myXMLFiles"
 value="{io:file( '/path/to/my/xml/docs' )//*[@is-file][ends-with( name(), '.xml' )]}"/>
        <xcl:for-each name="file" select="{$myXMLFiles}">
            <!-- our custom element ; check how its attributes are used in its implementation -->
            <macro:transform-and-save file="{$file}" xslt="{$xslt}"/>
        </xcl:for-each>
    </xcl:logic>
</xcl:active-sheet>

An inline implementation may use itself an element defined by an inline implementation. For this purpose, $exp:params must be saved before using, and restored after. Similarly, $exp:args must be saved before using an extended XPath function, and restored after.

The element definition must be unmarshalled only once it is invoked (unused elements won't be unmarshalled).

3.1.2 Dynamic content production

Inline implementation may be used advantageously to produce content inside a dynamic active sheet. These usage is close to "web server pages" technologies such as JSP, ASP or PHP. When a family of tags are encountered and recognized as belonging to a module, they are replaced by the result produced at runtime.

<?xml version="1.0" encoding="iso-8859-1"?>

<exp:module target="macro"
    xmlns:exp="http://ns.inria.org/active-tags/exp"
    xmlns:xcl="http://ns.inria.org/active-tags/xcl"
    xmlns:macro="http://www.acme.org/active-tags/macro">
    <exp:element name="macro:insert-toc">
        <p>Table of content</p>
        <ul>
            <xcl:for-each name="item" select="{ $this//(h1|h2|h3) }">
                <li>{ $item/text() }</li>
            </xcl:for-each>
        </ul>
    </exp:element>
    <exp:element><!-- others elements "macro:*" -->
        <!-- keep the content of the element that has been performed before -->
        <xcl:set name="content" value="{ context() }"/>
        <!-- copy the element... -->
        <xcl:element name="{ name( $exp:element ) }">
            <!-- ...with all its attributes... -->
            <xcl:for-each name="attr" select="{ $exp:element/@* }">
                <xcl:attribute name="{ name( $attr ) }" value="{ value( $attr ) }"/>
            </xcl:for-each>
            <!-- ...and its content -->{ $content }<!-- this comment prevents
                                                adding undesirable spaces -->
        </xcl:element>
    </exp:element>
</exp:module>

<?xml version="1.0" encoding="iso-8859-1"?>
<html>
    <body>
        <macro:insert-toc
            xmlns:macro="http://www.acme.org/active-tags/macro"/>
        <h1>Intro</h1>
            <h2>Abstract</h2>
                <p>...</p>
            <h2>Terminology</h2>
                <p>...</p>
        <h1>Outro</h1>
            <p>...</p>
    </body>
</html>

<?xml version="1.0" encoding="iso-8859-1"?>
<html>
    <body>
        <p>Table of content</p>
        <ul>
                <li>Intro</li>
                <li>Abstract</li>
                <li>Terminology</li>
                <li>Outro</li>
        </ul>
        <h1>Intro</h1>
            <h2>Abstract</h2>
                <p>...</p>
            <h2>Terminology</h2>
                <p>...</p>
        <h1>Outro</h1>
            <p>...</p>
    </body>
</html>

3.2 Versioning

Any module must define a foreign attribute that sets the version of the module used. When used, this attribute must appear only once per module on the root element.

The name of this attribute is a qualified name; its prefix is those of the module, and its local-name is "version".

For example, exp:version="1.0" xcl:version="1.0" are valid declarations.

Some modules may oblige to use such attribute.

When not specified, the processor will use the last known version of the module.

Module designers may define a namespace URI per version of their module if they don't want to deal with versioning.

As the versionings are defined with foreign attributes, they are applied with the restrictions propers to foreign attributes :

Restrictions for foreign attributes

Foreign attributes are applied in the order they defined by their own, that is version dependant. Once found, the foreign attributes are ordered and applied; thus, if a version setting has been specified, it can be applied only on things that has not been yet resolved : the element that hosts the foreign attribute that defines a version must endorsed the version expected, whereas the other foreign attributes can't.

Versions should be specified within elements that don't use other foreign attributes of the same module. The only tolerate foreign attributes are @exp:disable-prefixes and @exp:enable-prefixes.

For exemple, foo:version="2.1" shouldn't be used in the same element that also contains foo:bar="oof-rab", because the @foo:bar attribute won't be bind to the appropriate implementation, but to a previous version of the implementation. However, in <foo:foo foo:version="2.1">, the <foo:foo> element will be unmarshalled with the implementation expected (version 2.1).

3.3 Module resolution

A module is loaded on behalf of a processor instance. A processor instance is created for each active sheet used. Each processor instance uses its own module resolution strategy according to its own settings.

A module is identified with a namespace URI. When a module request is raised, its namespace URI must be specified.

A processor instance will lookup for a module in its internal registry and with the help of its catalog lists. When a catalog lookup is performed, the lookup key is composed of the namespace URI of the module ; the type of the lookup key is exp:module. Please refer to the Active Catalog specification for further information about XML catalogs.

Module request

A module may be requested when unmarshalling or at runtime. Once a module is loaded, it can't be discarded from the processor instance that loads it.

A module request is raised when :

• a tag or an attribute bound to a namespace URI is encountered when unmarshalling,
• a property is bound to a namespace URI,
• an extended XPath function is bound to a namespace URI.

A request depends also on the processor instance settings, as explained below.

Resolution strategy

The resolution strategy of a module request depends on the processor instance settings (the directive that enables/disables the prefixes).

• if none used (default), the processor will try to load the module requested; if it is registered to the processor, it will be used; otherwise, the fallback module will be used if the request was caused by a tag or an attribute. If the request was caused by an extended XPath function, it is a fatal error if the module can't be found.
• prefixes enabled : only the prefixes specified are raising a module request. It is a fatal error if such a module can't be found.
• prefixes disabled : the behaviour is the same as the default, except for the prefixes specified for which no module request will be raised in any case. It is a fatal error if an extended XPath function is using a disabled prefix.

4 EXP module reference

	Must be an adt:expression that computes an object of the type expected.
	Must be a hard-coded value (litteral)
	Can be either a hard-coded value or an adt:expression
	This material may be missing
	Denotes a value to use by default
	Allows a read operation.
	Allows a write operation.
	Allows a rename operation.
	Allows an update operation.
	Allows a delete operation.

4.1 Elements

4.2 Foreign attributes

@exp:version

• Priority : 0

The version of the EXP module to use. This attribute should be encountered before any EXP element, but it takes precedence on the element inside which it is hosted.

@exp:enable-prefixes

• Priority : -1

The list of prefixes to enable in the current active sheet. When used, the @exp:disable-prefixes attribute must be omitted.

@exp:disable-prefixes

• Priority : -1

The list of prefixes to disable in the current active sheet. When used, the @exp:enable-prefixes attribute must be omitted.

@exp:use-catalog

• Priority : -1

A reference to a catalog to apply on the actual active sheet. When used, the catalog is effective before unmarshalling all the materials not yet encountered (including the host element and its foreign attributes that have a lower priority).

4.3 Predefined properties

$exp:this

Property type: #exp:x-processor-instance

$exp:this is a reference to the processor instance. Notice that $this is a reference to the corresponding active sheet.

$exp:dataset

Property type: #exp:x-dataset

$exp:dataset is a reference to the exp:x-dataset currently in use.

$exp:element

Property type: #xml:element

$exp:element is set to the element that invokes an active tag defined by an inline implementation (macro tag).

When the macro uses itself elements that are defined by an inline implementation, the $exp:element property is restored to the value before invokation.

$exp:ns-fallback

Property type: #adt:map of #xs:anyURI

$exp:ns-fallback is a collection used to store additional namespace declarations needed at runtime.

Namespaces must be declared for XML elements, attributes, and extended XPath functions. However, qualified names may also be used in content and attribute values; in this cases, if a namespace declaration is missing in the XML active sheet document, the property $exp:ns-fallback may be used to store dynamically additional namespace declarations.

By default, $exp:ns-fallback is not defined. It is the user responsibility to add namespaces declarations at runtime.

$exp:ns-fallback is a collection of named items; each item is defined by :

• a prefix used as the key of the item
• the namespace URI as the value of the item

Example using $exp:ns-fallback

<?xml version="1.0" encoding="iso-8859-1"?> <xcl:active-sheet xmlns:exp="http://ns.inria.org/active-tags/exp" xmlns:xcl="http://ns.inria.org/active-tags/xcl"> <xcl:logic> <xcl:set name="exp:ns-fallback"> <xcl:item name="foo" value="http://www.foo.com/"/> <xcl:item name="oof" value="http://www.oof.com/"/> </xcl:set> <xcl:set name="foo:bar" value="This is valid"/> <xcl:set name="oof:rab" value="{$foo:bar}"/> </xcl:logic> </xcl:active-sheet> The two properties $foo:bar and $oof:rab will be bound to the right namespace URI defined by $exp:ns-fallback because the xmlns declaration is missing for the two prefixes foo and oof.

A processor must try to bind the names used to the namespace URI declared when unmarshalling. Unresolved prefixes must be fix at runtime with the help of $exp:ns-fallback if it exists. It is a fatal error if a prefix can't be resolved at runtime.

It is the user responsability to define $exp:ns-fallback with the appropriate scope.

This property doesn't fix namespaces violations when parsing the active-sheet.

$exp:params

Property type: #adt:map of #any

$exp:params is a collection of named items. When an element has been defined with an inline implementation, each of its attribute will be used to feed $exp:params with an item :

• the name of the attribute is the name of the item,
• the result of the evaluation of the attribute value is the value of the item.

An item of the name xml:base is set to the current base location.

Outside an element that has been defined with an inline implementation, $exp:params doesn't exists.

$exp:args

Property type: #adt:list of #any

$exp:args is a collection of unnamed items. When an extended XPath function has been defined with an inline implementation, each of its arguments will be used to feed $exp:args with an item.

Outside an extended XPath function that has been defined with an inline implementation, $exp:args doesn't exists.

4.4 Extended XPath functions

No additional functions are defined by this module.

4.5 Data types

#exp:x-processor-instance type

• Built with <exp:unmarshal>
• Built with $exp:this

The processor instance is the concrete engine obtained after unmarshalling an active sheet.

Operation			read | write | rename | update | delete
	Type	Value	Comment
	#xs:QName		The new name of the processor instance.
type()
	#xs:QName	#exp:x-processor-instance	This type
name()
	#xs:QName		The name of the processor instance if any.
string()
	#xs:string		The string name of the processor instance if any.
parent::
	#exp:x-processor-instance		The processor instance that hosts this one, if any.
child::
	#adt:list of #exp:x-dataset		The data sets known by this instance.
attribute::
	#adt:map of #xml:attribute		A fixed set of attributes (see below).
@active-sheet
	#xml:document		The XML document used for unmarshalling.
@catalogs
	#adt:list of #xs:anyURI		The references of the catalogs registered to this processor instance.
@default-action
	#exp:element-definition		The default action to perform.
@main-action
	#exp:element-definition		The main action to perform.
@disabled-prefixes
	#adt:list of #adt:prefix		The prefixes that has been explicitely disabled.
@enabled-prefixes
	#adt:list of #adt:prefix		The prefixes that has been explicitely enabled.
@modules
	#adt:map{ of #xs:anyURI, of #xs:string}		The modules known by this processor instance. The key of an entry in the map is the namespace URI of a module. The value is the version of the module.
@procedures
	#adt:map of #exp:element-definition		The procedures defined for this processor instance. The key of the map is the qualified name of the procedures.
@shared-properties
	#adt:map of #any object		The properties of the processor instance that will be shared by all data set that will run on it.
@status
The status of the processor instance.
	#xs:string	runnable	ready to process data sets.
		ready	ready to unmarshal.
		unmarshalling	is currently unmarshalling its active sheet.
		fail	fail to unmarshal.

#exp:x-dataset type

• Given by #exp:x-processor-instance::child:*

The data set is used to store the properties computed at runtime.

Operation			read | write | rename | update | delete
	Type	Value	Comment
	#xs:QName		The new name of the dataset.
type()
	#xs:QName	#exp:x-dataset	This type
name()
	#xs:QName		The name of the dataset if any.
string()
	#xs:string		The string name of the dataset if any.
parent::
	#exp:x-processor-instance		The processor instance that uses this dataset.
child::
	#adt:map of #any object		The properties of the dataset.
attribute::
	#adt:map of #xml:attribute		A fixed set of attributes (see below).
@current
	#any object		The current object.
@context
	#adt:list of #any object		The context.
@local-properties
	#adt:map of #any object		The local properties of the dataset.
@global-properties
	#adt:map of #any object		The global properties of the dataset.
@shared-properties
	#adt:map of #any object		The shared properties of the dataset.
@main-action
	#exp:element-definition		The main action that uses this dataset, if any.

#exp:x-module type

• Built with <exp:module>

A module contains the definitions of the active tags materials.

Operation			read | write | rename | update | delete
	Type	Value	Comment
type()
	#xs:QName	#exp:x-module	This type
string()
	#xs:string		The namespace URI of the module.
attribute::
	#adt:map of #xml:attribute		A fixed set of attributes (see below).
@target
	#xs:anyURI		The namespace URI of the module.
@version
	#xs:string		The version of this module.
@versions
	#adt:list of #exp:x-module		All the versions of the module, sorted by version.
@elements
	#adt:list of #xs:QName		The elements defined by this module.
@attributes
	#adt:list of #xs:QName		The foreign attributes defined by this module.
@properties
	#adt:list of #xs:QName		The predefined properties defined by this module.
@functions
	#adt:list of #xs:QName		The extended functions defined by this module.

#exp:element-definition type

• Built with <exp:element>

A formal type for the implementation of an active tag.

#exp:attribute-definition type

• Built with <exp:attribute>

A formal type for the implementation of a foreign attribute.

#exp:property-definition type

• Built with <exp:property>

A formal type for the implementation of a predefined property.

#exp:function-definition type

• Built with <exp:function>

A formal type for the implementation of a function.

Appendix

A Glossary

B Related Active Tags specifications

This list is not exhaustive; it is a list of common modules usable by an engine that implements the Active Tags specifications that implementors may use. Additional modules are welcome.

C Lists

C.1 Examples list

• Prefix disabling
• Example using EXP for bootstraping
• Declaring EXP modules with Active Catalog
• EXP prefix disabling
• Passing parameters example
• Macro tag
• Dynamic content production
• Macro initialization
• Example using $exp:ns-fallback

C.2 Figures list

D Active Schema for EXP

[schema.asl]

<asl:active-schema asl:version="1.0" target="exp" schema-version="1.0" xml:lang="en"
    xmlns:exp="http://ns.inria.org/active-tags/exp"
    xmlns:xcl="http://ns.inria.org/active-tags/xcl"
    xmlns:asl="http://ns.inria.org/active-schema"
    xmlns:adt="http://ns.inria.org/active-datatypes"
    xmlns:xs="http://www.w3.org/2001/XMLSchema-datatypes"
    xmlns="http://www.w3.org/1999/xhtml"
    xmlns:at="http://ns.inria.org/active-tags/reference">
<!--adt:version="1.0" xs:version="1.0"-->
    <asl:attribute name="exp:version" min-occurs="0" ref-type="xs:string"/>

    <asl:attribute name="exp:enable-prefixes" min-occurs="0" ref-type="adt:prefixes">
        <asl:assert test="asl:element()/.. = asl:document()" id="exp:mustBeOnTheRootElement-assert">
            <asl:desc id="exp:mustBeOnTheRootElement-desc">
                This attribute must be set only on root elements.
            </asl:desc>
        </asl:assert>
    </asl:attribute>

    <asl:attribute name="exp:disable-prefixes" min-occurs="0" ref-type="adt:prefixes">
        <asl:use scope="global" ref-id="exp:mustBeOnTheRootElement-assert"/>
    </asl:attribute>

    <asl:type name="exp:dynURI">
        <asl:desc id="exp:dynURI-desc">A dynamic URI is either hard-coded or computed at runtime.</asl:desc>
        <asl:type ref-type="xs:anyURI"/>
        <asl:type ref-type="adt:expression"/>
    </asl:type>

    <asl:element name="exp:bootstrap" root="always">
        <asl:block id="exp:rootAttributes-block">
            <asl:attribute ref-ns="#other" min-occurs="0" max-occurs="unbounded"/>
            <asl:attribute ref-attr="exp:version"
 min-occurs="{ number( asl:element()/.. = asl:document() ) }"
 max-occurs="{ $asl:min-occurs }"/>
        </asl:block>
        <asl:choice min-occurs="0" max-occurs="unbounded">
            <asl:element ref-ns="#any"/>
        </asl:choice>
    </asl:element>

    <asl:element name="exp:module" root="sometimes">
        <asl:use ref-id="exp:rootAttributes-block"/>
        <asl:attribute name="target" ref-type="adt:prefix"/>
        <asl:attribute name="version" ref-type="xs:string"/>
        <asl:attribute name="deferred" min-occurs="0">
            <asl:text value="yes"/>
            <asl:text value="no"/>
        </asl:attribute>
        <asl:attribute name="source" ref-type="exp:dynURI"
 min-occurs="{number( not( asl:element()/* ) )}"
 max-occurs="{ $asl:min-occurs }"/>
        <asl:choice min-occurs="{number( not( asl:element()/@source ) )}" max-occurs="unbounded">
            <asl:element ref-elem="exp:element" min-occurs="0"/>
            <asl:element ref-elem="exp:extended-function" min-occurs="0"/>
            <asl:element ref-elem="exp:predefined-property" min-occurs="0"/>
            <asl:element ref-elem="exp:foreign-attribute" min-occurs="0"/>
            <asl:element ref-ns="#other" min-occurs="0"/>
        </asl:choice>
    </asl:element>

    <asl:element name="exp:element">
        <asl:block id="exp:material-block">
            <asl:attribute ref-ns="#other" min-occurs="0" max-occurs="unbounded"/>
            <asl:attribute name="name" ref-type="xs:QName" min-occurs="0"/>
            <asl:attribute name="impl" ref-type="xs:string" min-occurs="{count( not( asl:element()/* ) )}"
 max-occurs="{$asl:min-occurs}"/>
            <asl:step min-occurs="{ number( not( asl:element()/@impl ) ) }"
 max-occurs="{$asl:min-occurs}">
                <asl:choice min-occurs="1" max-occurs="unbounded">
                    <asl:element ref-ns="#other"/>
                </asl:choice>
            </asl:step>
            <asl:assert test="asl:element()/ancestor::exp:module"
 id="exp:mustBeADescendentOfModule-assert">
                <asl:desc id="exp:mustBeADescendentOfModule-desc">
                    <at:element>{name( asl:element() )}</at:element> must be a descendent of <at:element>exp:module</at:element>
                </asl:desc>
            </asl:assert>
        </asl:block>
    </asl:element>

    <asl:element name="exp:predefined-property">
        <asl:use ref-id="exp:material-block"/>
    </asl:element>

    <asl:element name="exp:extended-function">
        <asl:use ref-id="exp:material-block"/>
    </asl:element>

    <asl:element name="exp:foreign-attribute">
        <asl:use scope="global" ref-id="exp:mustBeADescendentOfModule-assert"/>
        <asl:attribute ref-ns="#other" min-occurs="0" max-occurs="unbounded"/>
        <asl:attribute name="name" ref-type="xs:QName" min-occurs="0"/>
        <asl:attribute name="impl" ref-type="xs:string" min-occurs="0"/>
    </asl:element>

    <asl:element name="exp:processor">
        <asl:attribute name="name" ref-type="asl:dynQName" min-occurs="0"/>
        <asl:attribute name="source" ref-type="adt:expression"/>
        <asl:attribute name="module-bindings" ref-type="adt:expression" min-occurs="0"
 max-occurs="{count( not( asl:element()//exp:module-bindings ) )}"/>/>
        <asl:attribute name="enable-prefixes" min-occurs="0" ref-type="adt:prefixes"/>
        <asl:attribute name="disable-prefixes" min-occurs="0" ref-type="adt:prefixes"/>
        <asl:attribute name="validate" min-occurs="0">
            <asl:text value="yes"/>
            <asl:text value="progress"/>
            <asl:text value="no"/>
        </asl:attribute>
        <asl:attribute name="fail-fast" min-occurs="0">
            <asl:text value="stop"/>
            <asl:text value="progress"/>
            <asl:text value="complete"/>
        </asl:attribute>
        <asl:choice min-occurs="0" max-occurs="unbounded">
            <asl:element ref-elem="module-bindings" min-occurs="0"
 max-occurs="{count( not( asl:element()/@impl ) )}"/>
            <asl:element ref-ns="#other"/>
        </asl:choice>
    </asl:element>

    <asl:element name="exp:invoke">
        <asl:attribute name="processor" ref-type="adt:expression" min-occurs="0"/>
        <asl:attribute name="logic-procedure" min-occurs="0">
            <asl:type>
                <asl:choice>
                    <asl:text value="#default"/>
                    <asl:text value="#main"/>
                    <asl:text ref-type="asl:dynQName"/>
                </asl:choice>
            </asl:type>
        </asl:attribute>
        <asl:attribute name="sync" min-occurs="0">
            <asl:text value="yes"/>
            <asl:text value="no"/>
        </asl:attribute>
        <asl:choice min-occurs="0" max-occurs="unbounded">
            <asl:element ref-ns="#other"/>
        </asl:choice>
        <asl:sequence>
            <asl:element ref-elem="exp:exports" min-occurs="0"/>
        </asl:sequence>
    </asl:element>

    <asl:element name="exp:exports">
        <asl:attribute ref-ns="#other" min-occurs="0" max-occurs="unbounded"/>
        <asl:choice min-occurs="0" max-occurs="unbounded">
            <asl:element ref-ns="#any"/>
        </asl:choice>
    </asl:element>

    <asl:element name="exp:export">
        <asl:attribute ref-ns="#other" min-occurs="0" max-occurs="unbounded"/>
        <asl:attribute name="name" ref-type="asl:dynQName"/>
        <asl:attribute name="scope" min-occurs="0">
            <asl:text value="local"/>
            <asl:text value="global"/>
            <asl:text value="shared"/>
        </asl:attribute>
        <asl:attribute name="value" ref-type="adt:expression"/>
    </asl:element>

    <asl:element name="exp:instance">
        <asl:attribute name="impl" ref-type="xs:string"/>
    </asl:element>

    <asl:element name="exp:inactive-tags">
        <asl:attribute ref-ns="#other" min-occurs="0" max-occurs="unbounded"/>
        <asl:choice min-occurs="0" max-occurs="unbounded">
            <asl:element ref-ns="#any"/>
        </asl:choice>
    </asl:element>

    <asl:element name="exp:module-bindings" root="sometimes">
        <!--TODO-->
    </asl:element>

    <asl:element name="exp:log">
        <!--TODO-->
    </asl:element>

    <asl:element name="exp:log-stream">
        <!--TODO-->
    </asl:element>

</asl:active-schema>