Version 0.9-1

Minor fixes to DESCRIPTION and NAMESPACE re. methods.

Version 0.9-0

Added an XSL extension function callI in the R XSL namespace which guarantees returning the R object exactly as is and not converting the value to an XSL data type. This can then be passed back to R in a subsequent R function call from XSL. Allow complex R objects to be passed from R to XSL and preserved as R objects to be passed back to R in subsequent function calls. This allows for sequential calls Introduced <r:eval> element in XSL for evaluating R code. Registered the as(), length(), and class() R functions as XSL functions so one can call as r:as( value, "Rtype"), r:length(value), r:class(value) from within XSL. Primarily used to convert the result from an earlier call to R. Methods for XPathNodeSet for unlist(x) and x[] to retrieve the values. Access to attribute nodes is improved rather than being returned as of class "XMLUnknownInternalNode"
Allow complex R objects to be passed from R to XSL and preserved as R objects to be passed back to R in subsequent function calls. This allows for sequential calls Introduced <r:eval> element in XSL for evaluating R code. Registered the as(), length(), and class() R functions as XSL functions so one can call as r:as( value, "Rtype"), r:length(value), r:class(value) from within XSL. Primarily used to convert the result from an earlier call to R. Methods for XPathNodeSet for unlist(x) and x[] to retrieve the values. Access to attribute nodes is improved rather than being returned as of class "XMLUnknownInternalNode"
Introduced <r:eval> element in XSL for evaluating R code. Registered the as(), length(), and class() R functions as XSL functions so one can call as r:as( value, "Rtype"), r:length(value), r:class(value) from within XSL. Primarily used to convert the result from an earlier call to R. Methods for XPathNodeSet for unlist(x) and x[] to retrieve the values. Access to attribute nodes is improved rather than being returned as of class "XMLUnknownInternalNode"
Registered the as(), length(), and class() R functions as XSL functions so one can call as r:as( value, "Rtype"), r:length(value), r:class(value) from within XSL. Primarily used to convert the result from an earlier call to R. Methods for XPathNodeSet for unlist(x) and x[] to retrieve the values. Access to attribute nodes is improved rather than being returned as of class "XMLUnknownInternalNode": Primarily used to convert the result from an earlier call to R.
Methods for XPathNodeSet for unlist(x) and x[] to retrieve the values. Access to attribute nodes is improved rather than being returned as of class "XMLUnknownInternalNode"
Access to attribute nodes is improved rather than being returned as of class "XMLUnknownInternalNode"

Version 0.8-1

Added a status field to the XMLInternalXSLTDocument returned by xsltApplyStyleSheet. This gives us the state of the XSLT context used in the transformation, if this is available. The values are NA, OK = 0, ERROR = 1, STOPPED = 2.

Version 0.8-0

getTemplate() now reports the file and line number for the node. [ method for XPathNodeSet to allow access to a subset of the nodes in the set. The result is not an XPathNodeSet, but a list containing the specified nodes. Only works for numeric indices, i.e. not names. processXSLXInclude() function for explicitly resolving an XInclude node. Added a duplicate parameter to XPathNodeSet() to control whether nodes are "cloned"/duplicated when being inserted into the node set. Reconciled two definitions of XPathNodeSet and the C code that manipulated them. Added xslGlobalVariableNames() Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
[ method for XPathNodeSet to allow access to a subset of the nodes in the set. The result is not an XPathNodeSet, but a list containing the specified nodes. Only works for numeric indices, i.e. not names. processXSLXInclude() function for explicitly resolving an XInclude node. Added a duplicate parameter to XPathNodeSet() to control whether nodes are "cloned"/duplicated when being inserted into the node set. Reconciled two definitions of XPathNodeSet and the C code that manipulated them. Added xslGlobalVariableNames() Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
processXSLXInclude() function for explicitly resolving an XInclude node. Added a duplicate parameter to XPathNodeSet() to control whether nodes are "cloned"/duplicated when being inserted into the node set. Reconciled two definitions of XPathNodeSet and the C code that manipulated them. Added xslGlobalVariableNames() Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Added a duplicate parameter to XPathNodeSet() to control whether nodes are "cloned"/duplicated when being inserted into the node set. Reconciled two definitions of XPathNodeSet and the C code that manipulated them. Added xslGlobalVariableNames() Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Reconciled two definitions of XPathNodeSet and the C code that manipulated them. Added xslGlobalVariableNames() Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Added xslGlobalVariableNames() Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Added xslWarning, xslError and xslStop Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Added xsltGetCurrentTemplate() & xsltGetCurrentInputNode() as accessors to some of the information available in the XSL transformation context. The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
The XSL document() function passes an XMLInternalNode object to R within an XPathNodeSet object. r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
r:call() handles R name space qualifiers in the function name, e.g. Sxslt::parseEval or Sxslt:::parseEval. Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Quoting of params is done only on characters, with other types (numbers and logicals) converted to/left as numbers. getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
getTemplate() function allows one to explore what the XSL engine will use for a given node. When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
When an R function called from XSL that returns a node, if that node is from a different document than the target/output document, it will be reparented to that target document. Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Added xsltGetXMLSourceNode() and xsltGetXSLNode() to provide access to the XML node being processed and the XSL instruction (and hence template) in effect. This allows the R programmer to generate some reflection information, especially useful for debugging. Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Support in xsltApplyStylesheet for getting profile information about the calls to the XSL style rules including the number of calls and the time taken and the mode in which the rule was called. Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Support for controlling XInclude on the processed document (before applying the XSL style sheet). XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace. Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
XPathNodeSet made into an S4 class to avoid issues with setOldClass and methods for length in a namespace.
Add setXSLTFunctions for "brute force" control over the R functions registered for registration with XSL when an R extension in XSL is initialized. This allows one to manage the list of registered functions, including removing entries that one has added for a particular application of a style sheet. Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
Renamed includeStyleSheets() to importStyleSheets(). (Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.
(Pending) Function to read style sheet from the XML document being processed and merge it with additional style sheet(s) specified in xsltApplyStyleSheet(). This allows for local templates in the XML file.

Version 0.7-0

Added support for defining new XSLT extensions, i.e. ones with different namespaces and registering functions for a particular namespace identified either by the prefix or the URI. See registerXSLTExtension() and inst/examples/extension.xsl and extension.R. xsltApplyStyleSheet accepts multiple style sheet file names and the subsequent ones are import'ed into the first style sheet. This is a convenience mechanism to avoid the need to create a separate stylesheet document that merely lists the files to import. includeStyleSheets is the function that does the actual operation and can handle both import and include merging. A function being added for registration with the XSL engine can be of (S3) class can have class "ClosureGenerator" (typically created with the function closureGenerator()) and such a function will be invoked and the list of functions it returns will be registered, not the original function itself. This allows for groups of functions with a shared environment to be created for each XSL processing task/"session" and so avoid shared "non-local" variables.: See registerXSLTExtension() and inst/examples/extension.xsl and extension.R.
xsltApplyStyleSheet accepts multiple style sheet file names and the subsequent ones are import'ed into the first style sheet. This is a convenience mechanism to avoid the need to create a separate stylesheet document that merely lists the files to import. includeStyleSheets is the function that does the actual operation and can handle both import and include merging. A function being added for registration with the XSL engine can be of (S3) class can have class "ClosureGenerator" (typically created with the function closureGenerator()) and such a function will be invoked and the list of functions it returns will be registered, not the original function itself. This allows for groups of functions with a shared environment to be created for each XSL processing task/"session" and so avoid shared "non-local" variables.: This is a convenience mechanism to avoid the need to create a separate stylesheet document that merely lists the files to import. includeStyleSheets is the function that does the actual operation and can handle both import and include merging.
A function being added for registration with the XSL engine can be of (S3) class can have class "ClosureGenerator" (typically created with the function closureGenerator()) and such a function will be invoked and the list of functions it returns will be registered, not the original function itself. This allows for groups of functions with a shared environment to be created for each XSL processing task/"session" and so avoid shared "non-local" variables.

Version 0.6-0

Functions to generate content in the output document directly from within R functions, e.g. apply a template to a node, Installation uses '-enable-R-only' as default so does not try to build the stand-alone Sxsltproc. To build that, use R CMD INSTALL --configure-args='--enable-R-only=no' Sxslt Allow XSL content to be given as a string rather than a file name. This allows one to work with dynamically constructed XSL files. getXSLVariables() function for accessing the values of param and variable elements in XSL. Additional built-in/pre-registered functions: nullEval() (to ignore result) and evalWithOutput() which returns the value from calling capture.output() when evaluating the R command. Improved support for returning XML nodes from R functions which are inserted into the result document or left as elements of a node set. r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
Installation uses '-enable-R-only' as default so does not try to build the stand-alone Sxsltproc. To build that, use R CMD INSTALL --configure-args='--enable-R-only=no' Sxslt Allow XSL content to be given as a string rather than a file name. This allows one to work with dynamically constructed XSL files. getXSLVariables() function for accessing the values of param and variable elements in XSL. Additional built-in/pre-registered functions: nullEval() (to ignore result) and evalWithOutput() which returns the value from calling capture.output() when evaluating the R command. Improved support for returning XML nodes from R functions which are inserted into the result document or left as elements of a node set. r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
Allow XSL content to be given as a string rather than a file name. This allows one to work with dynamically constructed XSL files. getXSLVariables() function for accessing the values of param and variable elements in XSL. Additional built-in/pre-registered functions: nullEval() (to ignore result) and evalWithOutput() which returns the value from calling capture.output() when evaluating the R command. Improved support for returning XML nodes from R functions which are inserted into the result document or left as elements of a node set. r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
getXSLVariables() function for accessing the values of param and variable elements in XSL. Additional built-in/pre-registered functions: nullEval() (to ignore result) and evalWithOutput() which returns the value from calling capture.output() when evaluating the R command. Improved support for returning XML nodes from R functions which are inserted into the result document or left as elements of a node set. r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
Additional built-in/pre-registered functions: nullEval() (to ignore result) and evalWithOutput() which returns the value from calling capture.output() when evaluating the R command. Improved support for returning XML nodes from R functions which are inserted into the result document or left as elements of a node set. r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
Improved support for returning XML nodes from R functions which are inserted into the result document or left as elements of a node set. r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
r:eval() function in XSL now evaluates the expression in the global environment (globalenv()) which should simplify finding variables assigned in one call and referenced in another. Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
Functions that are of class XSLTContextFunction are passed a reference to the xmlXPathParserContext as the first argument. The default is not to make this available, but it can be used within R to access and manipulate the XSLT process and contents of the tree. Use the function xsltContextFunction() to make convert a regular function to one of this type. Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
Added mechanisms for returning XML nodes. We can return a XMLInternalDocument (via xmlTree()$value()), or an XMLInternalNode (e.g. xmlRoot(xmlTree()$value()) or creating the nodes directly) and node set (xmlXPathNodeSet instance). [ method for XPathNodeSet is now gone and [[ is to be used.
[ method for XPathNodeSet is now gone and [[ is to be used.

Version 0.5-4

Checks whether Rembedded.h is in the R include directory or not and does a #include if it is, and doesn't if it is not present, i.e. in versions of R earlier than R-2.4.0

Version 0.5-3

saveXML() when writing to a string does not assume an ASCII encoding. Added an encoding argument to saveXML (here and in the generic in the XML package) so that the caller can specify the type of encoding
Added an encoding argument to saveXML (here and in the generic in the XML package) so that the caller can specify the type of encoding

Version 0.5-2

The xsl: prefix in the fix for 0.5-1 causes problems if the xmlns:xsl refers to a different URI than libxslt's view of things. With libxslt-1.1.16, this fails to work unless we remove the xsl: prefix.
The -o file option for Sxsltproc causes a segmentation fault for libxslt-1.1.15. This is fixed in libxslt-1.1.16.: Thanks to Naras Balasubramanian ("Naras") for identifying this.

Version 0.5-1

Update of some XSL files in the examples to include the all-important xsl:extension-element-prefixes="r" declaration in the xsl:stylesheet element.: Without this, xslt cannot find the relevant registered functions in the R module.

Version 0.5-0

Ability to set an R function that is called each time the XSLT extension is initialized (i.e. for each application of a stylesheet that requires it). This function can register extension functions and generally do any initialization it wants. This happens after the basic functions are registered. To have any effect, this is where registerXSLFunction() should be called. Calling registerXSLFunction() outside of this will either raise an error or have no effect by working on a unused context. Mechanism for pre-registering R functions that will be registered with the XSLT extension module each time it is initialized. Use addXSLTFunctions() rather than registerXSLFunction() to specify these. Added a name space (NAMESPACE). Now depends on the XML package due to the need to export a method for saveXML() which requires the generic to be defined. Added classes to xsl sheet and XMLInternalDocument. When calling XSLT from R, we can now use registered R functions in the XSL. This has been possible from the beginning but there were issues such as avoid reinitializing R each time. Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().
Mechanism for pre-registering R functions that will be registered with the XSLT extension module each time it is initialized. Use addXSLTFunctions() rather than registerXSLFunction() to specify these. Added a name space (NAMESPACE). Now depends on the XML package due to the need to export a method for saveXML() which requires the generic to be defined. Added classes to xsl sheet and XMLInternalDocument. When calling XSLT from R, we can now use registered R functions in the XSL. This has been possible from the beginning but there were issues such as avoid reinitializing R each time. Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().
Added a name space (NAMESPACE). Now depends on the XML package due to the need to export a method for saveXML() which requires the generic to be defined. Added classes to xsl sheet and XMLInternalDocument. When calling XSLT from R, we can now use registered R functions in the XSL. This has been possible from the beginning but there were issues such as avoid reinitializing R each time. Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().
Now depends on the XML package due to the need to export a method for saveXML() which requires the generic to be defined. Added classes to xsl sheet and XMLInternalDocument. When calling XSLT from R, we can now use registered R functions in the XSL. This has been possible from the beginning but there were issues such as avoid reinitializing R each time. Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().
Added classes to xsl sheet and XMLInternalDocument. When calling XSLT from R, we can now use registered R functions in the XSL. This has been possible from the beginning but there were issues such as avoid reinitializing R each time. Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().
When calling XSLT from R, we can now use registered R functions in the XSL. This has been possible from the beginning but there were issues such as avoid reinitializing R each time. Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().: This has been possible from the beginning but there were issues such as avoid reinitializing R each time.
Off-by-one error in dealing with parameters that caused a segmentation fault in xsltApplyStyleSheet().

Version 0.4-1

Added libexslt to the list of libraries used at link time. Needs more work in the configuration script. Updated the configuration to work better if we want --enable-R-only, i.e. calling XSLT from R only and not R from xsltproc. The source code for libxslt is no longer necessary in this case. Changed email address, Web site references to UC Davis.: Needs more work in the configuration script.
Updated the configuration to work better if we want --enable-R-only, i.e. calling XSLT from R only and not R from xsltproc. The source code for libxslt is no longer necessary in this case. Changed email address, Web site references to UC Davis.: The source code for libxslt is no longer necessary in this case.
Changed email address, Web site references to UC Davis.

Version 0.4-1

Bug fix for saving to a string (via saveXML.XMLInternalXSLTDocument())

Version 0.4

Some documentation in Docs/SxsltInS.pdf describes using libxslt from within S.
Can call Sxslt from within a regular R session, i.e. embedding libxslt within S.
Annotated discussion examples Support for the "value" attribute of an XMLNode. Improvements to handling node sets in R that are passed from XSL functions.
Support for the "value" attribute of an XMLNode. Improvements to handling node sets in R that are passed from XSL functions.
Improvements to handling node sets in R that are passed from XSL functions.

Version 0.3

New examples. lm.xml, sqrt.xsl, sqrt.xml, literal.xsl. Configuration changes Works with libxslt 1.0.7 This version requires libxml2-2.4.10.: lm.xml, sqrt.xsl, sqrt.xml, literal.xsl.
Configuration changes Works with libxslt 1.0.7 This version requires libxml2-2.4.10.
Works with libxslt 1.0.7 This version requires libxml2-2.4.10.: This version requires libxml2-2.4.10.

Version 0.2.1

Configuration updates for Solaris and testing of XSLT_HOME, etc.
Omit xsltUnregisterAllExtModules().

Version 0.2.0

Support for accessing the nodeset and its internal elements: nodes, children, attributes, etc.: All of these are provided as references to the underlying C level objects in the libxslt/libxml libraries.

Version 0.1.0

Initial release

Duncan Temple Lang <duncan@research.bell-labs.com>

Last modified: Wed Nov 3 12:39:59 PDT 2010