Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package saxon10 for openSUSE:Factory checked in at 2023-08-22 08:56:05 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/saxon10 (Old) and /work/SRC/openSUSE:Factory/.saxon10.new.1766 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "saxon10" Tue Aug 22 08:56:05 2023 rev:1 rq:1104920 version:10.9 Changes: -------- New Changes file: --- /dev/null 2023-08-17 02:06:42.426031384 +0200 +++ /work/SRC/openSUSE:Factory/.saxon10.new.1766/saxon10.changes 2023-08-22 08:56:06.790555015 +0200 @@ -0,0 +1,208 @@ +------------------------------------------------------------------- +Sun Mar 5 20:50:09 UTC 2023 - Anton Shvetz <shvetz.an...@gmail.com> + +- Update to v10.9 + * For a full list of bugs cleared in Saxon 10.9, please go to + https://saxonica.plan.io/projects/saxon/issues and filter the + list of bugs for those labelled as "Fixed in Maintenance + Release 10.9". + +------------------------------------------------------------------- +Fri May 6 18:44:40 UTC 2022 - Anton Shvetz <shvetz.an...@gmail.com> + +- Update to v10.8 + * For a full list of bugs cleared in Saxon 10.8, please go to + https://saxonica.plan.io/projects/saxon/issues and filter the + list of bugs for those labelled as "Fixed in Maintenance + Release 10.8". + * For a full list of bugs cleared in Saxon 10.7, please go to + https://saxonica.plan.io/projects/saxon/issues and filter the + list of bugs for those labelled as "Fixed in Maintenance + Release 10.7". +- The gizmo script renamed to gizmo10 to avoid conflict with future + saxon11. +- Add some markup to POD documentation; adjust references to online + documentation. +- Remove the _service file. + +------------------------------------------------------------------- +Wed Mar 23 11:20:05 UTC 2022 - Fridrich Strba <fst...@suse.com> + +- Build with java source and target levels 8 + +------------------------------------------------------------------- +Mon Jan 17 20:58:41 UTC 2022 - Fridrich Strba <fst...@suse.com> + +- Add the 10.6 version to compatibility versions for maven + metadata + +------------------------------------------------------------------- +Sat Sep 18 02:51:03 UTC 2021 - Anton Shvetz <shvetz.an...@gmail.com> + +- Update to v10.6 + * Bug #4759: Saxon.NET: InvalidCastException in + sun.net.ftp.impl.FtpClient (Missing IKVM DLL from build) + * Bug #4837: Two documents can have the same URI + * Feature #4860: Format of numbers generated by fn:xml-to-json + * Bug #4875: Testing option -unfolded is not working + * Bug #4968: Saxon-EE 10.5: Bug #3800 reproduced + * Bug #4969: Invalid schema-aware SEF (Invalid alpha code) + * Bug #4970: line/column number in trace listener + * Bug #4971: Deleting an entry from NamespaceMap can cause + IndexOutOfBoundsException + * Bug #4973: Schema for XML namespace is being fetched using HTTP + rather than using the local copy + * Bug #4974: XQuery Update: namespace propagation is not working + * Bug #4975: Null pointer exception when outputting a warning + with missing location information + * Bug #4981: saxon:in-summer-time extension function: can it + return empty sequence? + * Bug #4982: Loading xml schemas which are stored inside + a zip archive is very slow compared to Xerces + * Bug #4985: NullPointerException in Saxon-EE + * Bug #4987: NPE when references to static XSLT parameters + appear in non-static expressions + * Bug #4995: Schema validator throws exception if there are + IDREFs with no corresponding ID + * Bug #4996: Namespace information missing from default + XML Schema attribute added by validating XMLReader + * Bug #5000: LoopLifter NPE after updating to Saxon 10.5 EE + * Bug #5004: Incorrect update of namespace maps + * Bug #5005: XdmNode.Children(uri, localname) not returning + results (.NET) + * Bug #5006: Streamed shallow copy changes type annotation + from xs:untyped to xs:anyType + * Bug #5007: Streaming of fn:subsequence#2 + * Feature #5012: Support UTF-16LE and UTF-16BE in + bin:encode-string() and bin-decode-string() + * Bug #5013: saxon:capture doesn't copy accumulator + * Bug #5014: NullPointerException with use of capturing + accumulator in match pattern + * Bug #5015: `fn:uri-collection()` calls the CollectionFinder + associated with the Configuration, not the Controller + * Bug #5018: suppress-indentation should prevent word-wrapping + of HTML and XHTML output + * Bug #5023: In a streamed transformation using + distinct-values(), the xs:double value NaN + and the xs:float value NaN are considered distinct + * Bug #5026: ClassCastException: + net.sf.saxon.functions.ScalarSystemFunction$1 cannot be cast + to net.sf.saxon.expr.Literal + * Bug #5032: Saxon-HE 10.5N NuGet Package cannot simply be used + to replace binaries + * Bug #5035: SXST0067 Component cannot be streamed, although + it is guaranteed streamable according to W3C rules. + No watch implemented for locVarRef + * Bug #5044: Java reflexive calls, NullPointerException when + argument is null + * Bug #5045: HTML5 serialisation: DOCTYPE should not be output + unless the outermost element is HTML + * Bug #5047: Whitespace stripping in DocumentBuilder ignores + xml:space + * Bug #5048: Wrong result from map:merge() where one operand + is a saxon:range-key + * Bug #5049: Collation keys for alphanumeric collations are not + correctly ordered + * Bug #5054: Internal error optimising an inline function + that calls its containing named function + * Bug #5060: Overzealous type checking for lookup operator + * Bug #5061: Empty values in text constructors: data(text { ... }) + * Bug #5063: Repository information at + https://www.saxonica.com/documentation10/index.html#!about/support/patches + is out of date + * Bug #5064: Lookup expression `X?(<a>1</a>)` fails to parse + * Bug #5065: xml-to-json() fails to report invalid input + * Bug #5068: saxon:assign doesn't check that the value is of + the required type + * Bug #5069: Signatures of fold-left/fold-right are incorrectly + documented + * Bug #5071: saxon:decimal-divide() + * Bug #5075: Namespace Inherit Issue on XMLStreamWriter on + Saxon 10 + * Bug #5076: ClassCastException with match="$var" when the value + of $var is atomic + * Bug #5080: In .NET, the IEnumerable returned by Children + and by Steps can only be used once + * Bug #5084: Schema processing: invalid attribute reported twice + * Bug #5085: Function annotations not reported for anonymous + functions + * Bug #5086: saxon:evaluate() fails with NullPointerException + after importing from SEF + * Bug #5087: Poor diagnostics when stylesheet is not exportable + * Bug #5088: xsl:for-each with Saxon extension attribute + separator - failure on export/import + * Bug #5089: Test case deep-update-011 fails with export:on + * Bug #5090: xsl:source-document extension attributes lost + on package export/import + * Bug #5091: Tests that optimize a filter expression to use + a key fail after export/import + * Bug #5092: "java.lang.AssertionError: **** Component reference + mode xsl:unnamed is already bound" when using mode #all + and COMPILE_WITH_TRACING == true + * Bug #5093: AssertionError during trace code injection + * Bug #5094: Caching of last() at context level is not working +- Use spec-cleaner +- Set mode="localonly" in the _service file + +------------------------------------------------------------------- +Fri Apr 16 17:42:29 UTC 2021 - Anton Shvetz <shvetz.an...@gmail.com> + +- Update to v10.5 + +------------------------------------------------------------------- +Wed Nov 18 00:30:27 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + +- Specify Maven compat version as 10 to avoid conflict with saxon9. + +------------------------------------------------------------------- +Tue Nov 17 22:55:26 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + +- Installation locations for Maven artifacts were mistakenly + accounted twice. + +------------------------------------------------------------------- +Tue Nov 17 22:16:56 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + +- Code samples were packaged twice: in "demo" and "manual" + subpackages. Now they are located in the demo subpackage. +- Files from "demo" subpackage are moved to default documentation + directory. + +------------------------------------------------------------------- +Sat Oct 31 20:33:34 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + +- Specify net.sf.saxon.TransformerFactoryImpl as a service + provider for javax.xml.transform.TransformerFactory +- Package manual source files + +------------------------------------------------------------------- +Thu Oct 29 08:09:31 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + +- Update to v10.3 +- Add the gizmo script. +- Update obsolete and incomplete manual pages. + Sources for manual pages now provided as POD files. +- Remove unnecessary dependencies. +- Cleanup the spec file. +- Remove unneeded patch. +- Update package description. + +------------------------------------------------------------------- +Thu Sep 24 22:10:56 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + +- Package forgotten resources under net/sf/saxon/data/ into JAR file + +------------------------------------------------------------------- +Wed Aug 26 13:54:41 UTC 2020 - Anton Shvetz <t...@sectorb.msk.ru> + ++++ 11 more lines (skipped) ++++ between /dev/null ++++ and /work/SRC/openSUSE:Factory/.saxon10.new.1766/saxon10.changes New: ---- Saxon-HE-10.9.pom saxon-resources-10.zip saxon10-9source.zip saxon10.build.xml saxon10.changes saxon10.gizmo.pod saxon10.gizmo.script saxon10.saxon.pod saxon10.saxon.script saxon10.saxonq.pod saxon10.saxonq.script saxon10.spec ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ saxon10.spec ++++++ # # spec file # # Copyright (c) 2023 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed # upon. The license for this file, and modifications and additions to the # file, is the same license as for the pristine package itself (unless the # license for the pristine package is not an Open Source License, in which # case the license is the MIT License). An "Open Source License" is a # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. # Please submit bugfixes or comments via https://bugs.opensuse.org/ # %global saxon_version 10 %global saxon_release 9 %global saxon_compat_version 10 # net.sf.saxon.om.XMLChar is from ASL-licensed Xerces Name: saxon%{saxon_version} Version: %{saxon_version}.%{saxon_release} Release: 0 Summary: The SAXON XSLT Processor from Michael Kay License: Apache-2.0 AND MPL-2.0 Group: Productivity/Publishing/XML URL: https://www.saxonica.com/ Source0: https://github.com/Saxonica/Saxon-HE/raw/main/%{saxon_version}/source/saxon%{saxon_version}-%{saxon_release}source.zip Source1: https://github.com/Saxonica/Saxon-HE/raw/main/%{saxon_version}/resources/saxon-resources-%{saxon_version}.zip Source2: https://repo1.maven.org/maven2/net/sf/saxon/Saxon-HE/%{saxon_version}.%{saxon_release}/Saxon-HE-%{saxon_version}.%{saxon_release}.pom Source3: %{name}.build.xml Source10: %{name}.saxon.script Source11: %{name}.saxonq.script Source12: %{name}.gizmo.script Source20: %{name}.saxon.pod Source21: %{name}.saxonq.pod Source22: %{name}.gizmo.pod BuildRequires: ant BuildRequires: dom4j BuildRequires: dos2unix BuildRequires: fdupes BuildRequires: icu4j BuildRequires: java-devel >= 1.8 BuildRequires: javapackages-local >= 6 BuildRequires: jdom BuildRequires: jdom2 BuildRequires: jetbrains-annotations BuildRequires: jline >= 2 BuildRequires: sed BuildRequires: unzip BuildRequires: xml-commons-apis BuildRequires: xml-commons-resolver BuildRequires: xom Recommends: %{name}-scripts Provides: jaxp_transform_impl = %{version} BuildArch: noarch %description The Saxon package is a collection of tools for processing XML documents. The main components are: ⢠An XSLT processor, which can be used from the command line, or invoked from an application, using a supplied API. Saxon implements the XSLT 3.0 Recommendation. The product can also be used to run XSLT 2.0 stylesheets, or XSLT 1.0 stylesheets in backwards compatibility mode. ⢠An XPath processor accessible to applications via a supplied API. This supports XPath 2.0 and XPath 3.1. It can also be used in backwards-compatibility mode to evaluate XPath 1.0 expressions. ⢠An XQuery processor that can be used from the command line, or invoked from an application by use of a supplied API. This supports XQuery 3.1, which also allows XQuery 1.0 or 3.0 queries to be executed. With Saxon-EE, you can also use the XQuery extensions defined in the XQuery Update 1.0 Recommendation, but later working drafts of XQuery Update are not supported (W3C has abandoned work on these versions). ⢠An XML Schema Processor. This supports both XSD 1.0 and XSD 1.1. This can be used on its own to validate a schema for correctness, or to validate a source document against the definitions in a schema. It is also used to support the schema-aware functionality of the XSLT and XQuery processors. Like the other tools, it can be run from the command line, or invoked from an application. ⢠On the Java platform, when using XSLT, XPath, XQuery, or XML schema validation, Saxon offers a choice of APIs. If you need portability across different vendors' tools, you can use the JAXP API for XSLT, XPath, and XML Schema processing, and the XQJ interface for XQuery. On the other hand, if you want a more integrated and complete API offering access to all Saxon's facilities, the s9api interface is recommended. You can also dive down deeper into the Saxon internals if you need to: there has been no particular attempt to make interfaces private, and all public interfaces are documented in the JavaDoc. Clearly, the deeper you go, the greater the risk of interfaces changing in future releases. ⢠On the .NET platform, Saxon offers an API that enables close integration with other services available from .NET, notably the XML-related classes in the System.Xml namespace. It isn't possible to use Saxon as a transparent plug-in replacement for the System.Xml.Xsl processor, because the API for the Microsoft engine using concrete classes rather than abstract interfaces. However, it is possible to use it as a functional replacement with minor changes to your application code. %package manual Summary: Manual for %{name} Group: Productivity/Publishing/XML %description manual Manual for %{name}. %package javadoc Summary: Javadoc for %{name} Group: Productivity/Publishing/XML %description javadoc Javadoc for %{name}. %package demo Summary: Demos for %{name} Group: Productivity/Publishing/XML Requires: %{name} = %{version}-%{release} %description demo Demonstrations and samples for %{name}. %package scripts Summary: Utility scripts for %{name} Group: Productivity/Publishing/XML Requires: %{name} = %{version}-%{release} Requires: javapackages-tools Requires: jaxp_parser_impl Requires: jline Requires: xml-commons-apis Recommends: icu4j Recommends: jdom Recommends: jdom2 Recommends: xml-commons-resolver Recommends: xom %description scripts Utility scripts for %{name}. %prep %setup -q -c unzip -q %{SOURCE1} cp -p %{SOURCE3} ./build.xml # purge EE imports find -name \*.java |xargs sed -i -e 's/\(^import com\.saxonica\..*\)/\/\/\1/' # deadNET rm -rf net/sf/saxon/dotnet # This requires a EE edition feature (com.saxonica.xsltextn) rm -rf net/sf/saxon/option/sql/SQLElementFactory.java # cleanup unnecessary stuff we'll build ourselves rm -rf docs/api find . \( -name "*.jar" -name "*.pyc" \) -delete mkdir -p build/classes cat >build/classes/edition.properties <<__PROPERTIES__ config=net.sf.saxon.Configuration platform=net.sf.saxon.java.JavaPlatform __PROPERTIES__ %build export CLASSPATH=$(build-classpath xml-commons-apis jdom jdom2 xom dom4j icu4j xml-commons-resolver jline jetbrains-annotations) ant \ -Dj2se.javadoc=%{_javadocdir}/java \ -Djdom.javadoc=%{_javadocdir}/jdom \ -Ddom4j.javadoc=%{_javadocdir}/dom4j pod2man --release='%{name} %{version}' --section=1 --center='User Commands' --quotes=none %{SOURCE20} %{name}.1 pod2man --release='%{name} %{version}' --section=1 --center='User Commands' --quotes=none %{SOURCE21} %{name}q.1 pod2man --release='%{name} %{version}' --section=1 --center='User Commands' --quotes=none %{SOURCE22} gizmo%{saxon_version}.1 %install # JARs, POM, API documentation install -dm 0755 %{buildroot}%{_javadir} install -pm 0644 build/lib/saxon.jar %{buildroot}%{_javadir}/%{name}.jar install -dm 0755 %{buildroot}%{_mavenpomdir} %{mvn_install_pom} %{SOURCE2} %{buildroot}%{_mavenpomdir}/%{name}.pom %add_maven_depmap %{name}.pom %{name}.jar install -dm 0755 %{buildroot}%{_javadocdir}/%{name} cp -r build/api %{buildroot}%{_javadocdir}/%{name} %fdupes -s %{buildroot}%{_javadocdir}/%{name} # Demo install -dm0755 %{buildroot}%{_defaultdocdir}/%{name} cp -rf use-cases samples drivers %{buildroot}%{_defaultdocdir}/%{name} # Scripts install -dm0755 %{buildroot}%{_bindir} install -m0755 %{SOURCE10} %{buildroot}%{_bindir}/%{name} install -m0755 %{SOURCE11} %{buildroot}%{_bindir}/%{name}q install -m0755 %{SOURCE12} %{buildroot}%{_bindir}/gizmo%{saxon_version} # Manual pages install -dm0755 %{buildroot}%{_mandir}/man1 install -Dm0644 {%{name}{,q},gizmo%{saxon_version}}.1 %{buildroot}%{_mandir}/man1/ # jaxp_transform_impl ghost symlink install -dm0755 %{buildroot}%{_sysconfdir}/alternatives/ ln -sf %{_sysconfdir}/alternatives/jaxp_transform_impl.jar %{buildroot}%{_javadir}/jaxp_transform_impl.jar # Manual install -dm0755 %{buildroot}%{_defaultdocdir}/%{name}/{doc,source-userdoc} cp -rf doc/{index.html,img} %{buildroot}%{_defaultdocdir}/%{name}/doc unzip -qq -d %{buildroot}%{_defaultdocdir}/%{name}/source-userdoc source-userdoc.zip ln -s %{_javadocdir}/%{name} %{buildroot}%{_defaultdocdir}/%{name}/javadoc find %{buildroot}%{_defaultdocdir}/%{name} \ -name \*.class -delete -or -name \*.exe -delete find %{buildroot}%{_defaultdocdir}/%{name} \ \( -name \*.cs \ -or -name \*.xml \ -or -name \*.xsl \ -or -name \*.xq \ -or -name \*.xqlib \ -or -name \*.dtd \ -or -name \*.xsd \ -or -name \*.resx \ -or -name \*.out \ -or -name \*.cmd \ \) -print0 \ |xargs -0 dos2unix %fdupes %{buildroot}%{_defaultdocdir}/%{name} %post update-alternatives --install %{_javadir}/jaxp_transform_impl.jar \ jaxp_transform_impl %{_javadir}/%{name}.jar 25 %postun if [ $1 -eq 0 ] ; then update-alternatives --remove jaxp_transform_impl %{_javadir}/%{name}.jar fi %files -f .mfiles %{_javadir}/jaxp_transform_impl.jar %ghost %{_sysconfdir}/alternatives/jaxp_transform_impl.jar %license notices/{ASM,ICU-J,JAMESCLARK,JLINE2,LICENSE,THAI,UNICODE}.txt %files manual %{_defaultdocdir}/%{name} %exclude %{_defaultdocdir}/%{name}/drivers %exclude %{_defaultdocdir}/%{name}/samples %exclude %{_defaultdocdir}/%{name}/use-cases %files javadoc %{_javadocdir}/%{name} %files demo %{_defaultdocdir}/%{name}/drivers %{_defaultdocdir}/%{name}/samples %{_defaultdocdir}/%{name}/use-cases %files scripts %defattr(0755,root,root,0755) %{_bindir}/* %attr(0644,root,root) %{_mandir}/man1/*.1%{?ext_man} %changelog ++++++ Saxon-HE-10.9.pom ++++++ <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"; xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";> <modelVersion>4.0.0</modelVersion> <groupId>net.sf.saxon</groupId> <artifactId>Saxon-HE</artifactId> <version>10.9</version> <name>Saxon-HE</name> <description>The XSLT and XQuery Processor</description> <url>http://www.saxonica.com/</url> <inceptionYear>1999</inceptionYear> <organization> <name>Saxonica</name> <url>https://www.saxonica.com/</url> </organization> <licenses> <license> <name>Mozilla Public License Version 2.0</name> <url>http://www.mozilla.org/MPL/2.0/</url> <distribution>repo</distribution> </license> </licenses> <developers> <developer> <id>mike</id> <name>Michael Kay</name> <email>m...@saxonica.com</email> </developer> <developer> <id>ond1</id> <name>OâNeil Delpratt</name> <email>on...@saxonica.com</email> </developer> <developer> <id>debbie</id> <name>Debbie Lockett</name> <email>deb...@saxonica.com</email> </developer> <developer> <id>john</id> <name>John Lumley</name> <email>j...@saxonica.com</email> </developer> <developer> <id>norm</id> <name>Norman Walsh</name> <email>n...@saxonica.com</email> </developer> </developers> <scm> <connection>scm:git:https://saxonica.plan.io/projects/saxonmirrorhe/repository</connection> <developerConnection>scm:git:https://saxonica.plan.io/projects/saxonmirrorhe/repository</developerConnection> <url>https://saxonica.plan.io/projects/saxonmirrorhe/repository</url> </scm> <properties> <skipTests>false</skipTests> <maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ss</maven.build.timestamp.format> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven.javadoc.skip>true</maven.javadoc.skip> <maven.javadoc.failOnError>false</maven.javadoc.failOnError> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.jdom</groupId> <artifactId>jdom</artifactId> <version>1.1.3</version> <optional>true</optional> </dependency> <dependency> <groupId>org.jdom</groupId> <artifactId>jdom2</artifactId> <version>2.0.6.1</version> <optional>true</optional> </dependency> <dependency> <groupId>xom</groupId> <artifactId>xom</artifactId> <version>1.3.5</version> <optional>true</optional> </dependency> <dependency> <groupId>com.ibm.icu</groupId> <artifactId>icu4j</artifactId> <version>59.2</version> <optional>true</optional> </dependency> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> <optional>true</optional> </dependency> <dependency> <groupId>jline</groupId> <artifactId>jline</artifactId> <version>2.14.6</version> <optional>true</optional> </dependency> <dependency> <groupId>org.apache.ws.commons.axiom</groupId> <artifactId>axiom</artifactId> <version>1.2.15</version> <optional>true</optional> </dependency> <dependency> <groupId>org.apache.ws.commons.axiom</groupId> <artifactId>axiom-dom</artifactId> <version>1.2.15</version> <optional>true</optional> </dependency> <dependency> <groupId>org.apache.ws.commons.axiom</groupId> <artifactId>axiom-impl</artifactId> <version>1.2.15</version> <optional>true</optional> </dependency> </dependencies> </project> ++++++ saxon10.build.xml ++++++ <?xml version="1.0" encoding="UTF-8"?> <!-- simple generic build file --> <project name="saxon" default="all" basedir="."> <!-- Properties --> <property name="name" value="saxon"/> <property name="src" value="src"/> <property name="build" value="build"/> <property name="build.classes" value="${build}/classes"/> <property name="build.doc" value="${build}/api"/> <property name="build.lib" value="${build}/lib"/> <property name="j2se.javadoc" value="/usr/share/javadoc/j2se"/> <property name="jdom.javadoc" value="/usr/share/javadoc/jdom"/> <property name="fop.javadoc" value="/usr/share/javadoc/fop"/> <property name="dom4j.javadoc" value="/usr/share/javadoc/dom4j"/> <!-- Targets --> <!-- Prepare build directories --> <target name="prepare"> <mkdir dir="${src}"/> <mkdir dir="${build}"/> <mkdir dir="${build.classes}"/> <mkdir dir="${build.lib}"/> <mkdir dir="${build.doc}"/> <copy todir="${src}"> <fileset dir="." includes="com/**,org/**,net/**"/> </copy> </target> <!-- Kill all the created directories --> <target name="clean"> <delete dir="${build}"/> <delete dir="${src}"/> </target> <!-- Build classes --> <target name="classes" depends="prepare"> <javac srcdir="${src}" excludes="net/sf/saxon/option/axiom/**/*.java" destdir="${build.classes}" encoding="ISO-8859-1" includeantruntime="true" source="8" target="8" /> </target> <!-- Copy resources --> <target name="resources"> <copy todir="${build.classes}"> <fileset dir="${src}" includes="net/sf/saxon/data/**"/> </copy> </target> <!-- Build jar archives --> <target name="jar" depends="classes,resources"> <jar jarfile="${build.lib}/${name}.jar" basedir="${build.classes}" > <manifest> <attribute name="Main-Class" value="net.sf.saxon.Transform"/> </manifest> <service type="javax.xml.transform.TransformerFactory" provider="net.sf.saxon.TransformerFactoryImpl" /> </jar> </target> <!-- Build the full JavaDocs --> <target name="javadoc" depends="prepare"> <condition property="no.module.directories" value="--no-module-directories" else=""> <and> <javaversion atleast="9"/> <javaversion atmost="12"/> </and> </condition> <javadoc sourcepath="${src}" destdir="${build.doc}" windowtitle="${name} JavaDoc" package="true" author="true" version="true" excludepackagenames="net.sf.saxon.option.axiom.*" source="1.8" encoding="ISO-8859-1" docencoding="UTF-8" bottom="Copyright (c) 2004â2020 Saxonica Limited. All rights reserved." doctitle="Saxon 10 Java API Documentation" additionalparam="${no.module.directories}" > <group title="s9api Interface" packages="net.sf.saxon.s9api"/> <group title="Other Interfaces"> <!-- packagenames="net.sf.saxon.*,org.w3c.xsl.*" --> <package name="net.sf.saxon"/> <package name="net.sf.saxon.lib"/> <package name="net.sf.saxon.om"/> <package name="net.sf.saxon.query"/> <package name="net.sf.saxon.sxpath"/> <package name="net.sf.saxon.value"/> <package name="net.sf.saxon.type"/> <package name="net.sf.saxon.xpath"/> <package name="net.sf.saxon.xqj"/> <package name="com.saxonica.config"/> <package name="com.saxonica.jaxp"/> <package name="com.saxonica.schema"/> </group> <group title="External Interfaces"> <package name="javax.xml.xquery"/> </group> <link href="${j2se.javadoc}"/> <link href="${jdom.javadoc}"/> <link href="${fop.javadoc}"/> <link href="${dom4j.javadoc}"/> </javadoc> </target> <!-- Build everything --> <target name="all" depends="jar,javadoc"/> </project> ++++++ saxon10.gizmo.pod ++++++ ++++ 754 lines (skipped) ++++++ saxon10.gizmo.script ++++++ #!/bin/sh # # gizmo10 script # JPackage Project <http://www.jpackage.org/> . /usr/share/java-utils/java-functions MAIN_CLASS=net.sf.saxon.Gizmo BASE_JARS="saxon10 xml-commons-apis jaxp_parser_impl jline" # Optional jars CLASSPATH="$CLASSPATH:"$(build-classpath \ icu4j \ jdom \ jdom2 \ xml-commons-resolver \ xom \ 2>/dev/null) || : # Set parameters set_jvm set_classpath $BASE_JARS set_flags $BASE_FLAGS set_options $BASE_OPTIONS # Let's start run $args "$@" ++++++ saxon10.saxon.pod ++++++ ++++ 758 lines (skipped) ++++++ saxon10.saxon.script ++++++ #!/bin/sh # # saxon10 script # JPackage Project <http://www.jpackage.org/> . /usr/share/java-utils/java-functions MAIN_CLASS=net.sf.saxon.Transform BASE_JARS="saxon10 xml-commons-apis jaxp_parser_impl" # Optional jars CLASSPATH="$CLASSPATH:"$(build-classpath \ icu4j \ jdom \ jdom2 \ xml-commons-resolver \ xom \ 2>/dev/null) || : # If we have resolver, add the CatalogManager.properties dir to CLASSPATH, # and tweak command line options so that it's used. args= if echo "$CLASSPATH" | grep xml-commons-resolver >/dev/null 2>&1 && test -r /etc/java/resolver/CatalogManager.properties; then CLASSPATH="$CLASSPATH:/etc/java/resolver" # Tune options to use resolver. r=org.apache.xml.resolver.tools.ResolvingXMLReader for opt in -x -y ; do if ! echo $@ | grep "\\${opt}:" >/dev/null 2>&1 ; then args="$args ${opt}:$r" fi done r=org.apache.xml.resolver.tools.CatalogResolver if ! echo $@ | grep "\\-r:" >/dev/null 2>&1 ; then args="$args -r:$r" fi fi # Set parameters set_jvm set_classpath $BASE_JARS set_flags $BASE_FLAGS set_options $BASE_OPTIONS # Let's start run $args "$@" ++++++ saxon10.saxonq.pod ++++++ =encoding utf8 =head1 NAME saxon10q - Saxon XQuery 3.0 processor =head1 SYNOPSIS saxon10q [I<options>] [I<params>] =head1 DESCRIPTION A command to run a query contained in a file. Saxon 9.8 and later releases implement the XQuery 3.1 Recommendation dated 18 April 2017. Because XQuery 3.1 is backwards compatible with XQuery 1.0 and XQuery 3.0, Saxon will also execute queries written according to the 1.0 or 3.0 versions of the specification. Saxon no longer has a mode to execute as an XQuery 1.0 or 3.0 processor (that is, to reject constructs that were not present in earlier versions of the language). For information about the conformance of Saxon to the XQuery 3.1 specification, and about the handling of implementation-defined features of the specification, see L<Conformance|https://www.saxonica.com/documentation10/index.html#!conformance>. Saxon uses the same run-time engine to support both XQuery and XSLT, reflecting the fact that the two languages have very similar semantics. Most of the compile-time code (in particular, the type checking logic and the optimizer) is also common. The XQuery support in Saxon consists essentially of an XQuery parser (which is itself an extension of the XPath parser); the parser generates the same internal interpretable code as the XSLT processor. There are also some constructs in the internal expression tree that will only be generated from XQuery source rather than XSLT source; examples are the XQuery order by and group by clauses, which have no direct XSLT equivalent. The XQuery processor may be invoked either from the operating system command line, or via an API from a user-written application. There is no graphical user interface provided. Saxon is an in-memory processor. Unless you can take advantage of streaming, Saxon is designed to process source documents that fit in memory. Saxon has been used successfully to process source documents of 100Mbytes or more without streaming, but if you attempt anything this large, you need to be aware (a) that you will need to allocate sufficient memory to the Java VM (at least 5 times the size of the source document), and (b) that complex FLWOR expressions may be very time-consuming to execute. (In this scenario, Saxon-EE is recommended, because it has a more powerful optimizer for complex joins.) =head1 OPTIONS =over =item B<-backup>:(C<on>|C<off>) Only relevant when B<-update>:C<on> is specified. Default is on. When backup is enabled, any file that is updated by the query will be preserved in its original state by renaming it, adding âC<.bak>â to the original filename. If backup is disabled, updated files will be silently overwritten. =item B<-catalog>:I<filenames> I<filenames> is either a file name or a list of file names separated by semicolons; the files are OASIS XML catalogs used to define how public identifiers and system identifiers (URIs) used in a source document, query, or schema are to be redirected, typically to resources available locally. For more details see L<Using XML catalogs|https://www.saxonica.com/documentation10/index.html#!sourcedocs/xml-catalogs>. =item B<-config>:I<filename> Indicates that configuration information should be taken from the supplied configuration file. Any options supplied on the command line override options specified in the configuration file. =item B<-dtd>:(C<on>|C<off>|C<recover>) Setting B<-dtd>:C<on> requests DTD-based validation of the source file and of any files read using the C<doc()> function. Requires an XML parser that supports validation. The setting B<-dtd>:C<off> (which is the default) suppresses DTD validation. The setting B<-dtd>:C<recover> performs DTD validation but treats the error as non-fatal if it fails. Note that any external DTD is likely to be read even if not used for validation, because DTDs can contain definitions of entities. =item B<-expand>:(C<on>|C<off>) Normally, if validation using a DTD or schema is requested, any fixed or default values defined in the DTD or schema will be expanded. Specifying B<-expand>:C<off> suppresses this. (In the case of DTD-defined defaults, this might not work with all XML parsers. It does work with the Xerces parser (default for Java) and the Microsoft parser (default for .NET).) =item B<-explain>[:I<filename>] Display a query execution plan. This is a representation of the expression tree after rewriting by the optimizer. If no file name is specified the output is sent to the standard error stream. The output is a tree in XML format. =item B<-ext>:(C<on>|C<off>) If B<-ext>:C<off> is specified, suppress calls on dynamically-loaded external Java functions. This does not affect calls on integrated extension functions, including Saxon and EXSLT extension functions. This option is useful when loading an untrusted query, perhaps from a remote site using an C<http://> URL; it ensures that the query cannot call arbitrary Java methods and thereby gain privileged access to resources on your machine. =item B<-init>:I<initializer> The value is the name of a user-supplied class that implements the interface C<Initializer>; this initializer will be called during the initialization process, and may be used to set any options required on the C<Configuration> programmatically. =item B<-l>[:(C<on>|C<off>)] If B<-l> or B<-l>:C<on> is specified, causes line and column numbers to be maintained for source documents. These are accessible using the extension functions C<saxon:line-number()> and C<saxon:column-number()>. Line numbers are useful when the purpose of the query is to find errors or anomalies in the source XML file. Without this option, line numbers are available while source documents are being parsed and validated, but they are not retained in the tree representation of the document. =item B<-mr>:C<classname> Use the specified C<ModuleURIResolver> to process all query module URIs. The C<ModuleURIResolver> is a user-defined class that implements the C<ModuleURIResolver> interface. It is invoked to process URIs used in the import module declaration in the query prolog, and (if B<-u> is also specified, or if the file name begins with C<http:>, C<https:>, C<file:> or C<classpath:>) to process the URI of the query source file provided on the command line. =item B<-now>:I<yyyy-mm-ddThh:mm:ss+hh:mm> Sets the value of C<current-dateTime()> (and C<implicit-timezone()>) for the query. This is designed for testing, to enable repeatable results to be obtained for comparison with reference results, or to test that queries can handle significant dates and times such as end-of-year processing. =item B<-o>:I<filename> Send output to named file. In the absence of this option, the results go to standard output. The output format depends on whether the C<-wrap> option is present. The file is created if it does not already exist; any necessary directories will also be created. If the file does exist, it is overwritten (even if the query fails). =item B<-opt>:[B<->]I<flags> Allows individual optimizations to be enabled or disabled selectively. There is a set of single-letter flags identifying particular optimizations: =over =item C<c>: generate bytecode =item C<d>: detect void path expressions =item C<e>: cache regular expressions =item C<f>: inline functions =item C<g>: extract global variables =item C<j>: just-in-time compilation of template rules (currently XSLT-only) =item C<k>: create keys =item C<l>: loop lifting =item C<m>: miscellaneous =item C<n>: constant folding =item C<r>: template rule-sets (not relevant to XQuery) =item C<s>: extract common subexpressions =item C<t>: tail call optimization =item C<v>: inline variables =item C<w>: create switch statements =item C<x>: index predicates =back A value such as B<-opt>:C<gs> runs with only the selected optimizations; B<-opt>:C<-gs> runs with the selected optimizations disabled and all others enabled. The value B<-opt>:C<0> suppresses all optimizations. The default is full optimization; this feature allows optimization to be suppressed in cases where reducing compile time is important, or where optimization gets in the way of debugging, or causes extension functions with side-effects to behave unpredictably. (Note however, that even with no optimization, lazy evaluation may still cause the evaluation order to be not as expected.) =item B<-outval>:(C<recover>|C<fatal>) Normally, if validation of result documents is requested, a validation error is fatal. Setting the option B<-outval>:C<recover> causes such validation failures to be treated as warnings. The validation message is written both to the standard error stream, and (where possible) as a comment in the result document itself. =item B<-p>[:(C<on>|C<off>)] Enable recognition of query parameters (such as C<xinclude=yes>) in the C<StandardURIResolver>. This option is available in Saxon-PE and Saxon-EE only. It cannot be used in conjunction with the B<-r> option, and it automatically switches on the B<-u> and B<-sa> options. The effect is that Saxon-specific query parameters are recognized in a URI. One query parameter that is recognized is C<val>. This may take the values C<strict>, C<lax>, or C<strip>. For example, C<source.xml?val=strict> loads a document with strict schema validation. =item B<-projection>:(C<on>|C<off>) Use (or donât use) document projection. Document Projection is a mechanism that analyzes a query to determine what parts of a document it can potentially access, and then while building a tree to represent the document, leaves out those parts of the tree that cannot make any difference to the result of the query. Requires Saxon-EE. =item B<-q>:I<queryfile> Identifies the file containing the query. If this is the last option then the B<-q>: prefix may be omitted. The file can be specified as âC<->â to read the query from standard input: in this case the base URI is that of the current directory. =item B<-qs>:I<querystring> Allows the query to be specified inline (if it contains spaces, you will need quotes around the expression to keep the command line processor happy). The static base URI of the query is taken from the current working directory. So, for example, C<java net.sf.saxon.Query -qs:doc('a.xml')//p[1]> selects elements within the file F<a.xml> in the current directory. =item B<-quit>:(C<on>|C<off>) With the default setting, on, the command will quit the Java VM and return an exit code if a failure occurs. This is useful when running from an operating system shell. With the setting B<-quit>:C<off> the command instead throws a C<RunTimeException>, which is more useful when the command is invoked from another Java application such as Ant. =item B<-r>:I<classname> Use the specified C<URIResolver> to process all URIs. The C<URIResolver> is a user-defined class, that implements the C<URIResolver> interface defined in JAXP, whose function is to take a URI supplied as a string, and return a SAX C<InputSource>. It is invoked to process URIs used in the C<doc()> function, and (if B<-u> is also specified) to process the URI of the source file provided on the command line. =item B<-repeat>:I<integer> Performs the transformation I<N> times, where I<N> is the specified integer. This option is useful for performance measurement, since timings for the first few runs of the query are often dominated by Java warm-up time. =item B<-s>:I<filename-or-URI> Take input from the specified file. If the B<-u> option is specified, or if the name begins with âC<file:>â or âC<http:>â, then the name is assumed to be a URI rather than a filename. This file must contain an XML document. The document node of the document is made available to the query as the context item. The filename can be specified as âC<->â to read the source document from standard input: in this case the base URI is that of the current directory. =item B<-sa> Invoke a schema-aware query. Requires Saxon-EE to be installed. =item B<-scmin>:I<filename> Loads a precompiled schema component model from the given file. The file should be generated in a previous run using the B<-export> option. When this option is used, the B<-xsd> option should not be present. Schemas loaded from an SCM file are assumed to be valid, without checking. This option is retained for compatibility. From Saxon 9.7, SCM files can also be supplied in the B<-xsd> option. =item B<-stream>:(C<on>|C<off>) Use (or donât use) streaming. Streaming allows simple queries to be executed while the source document is being read, avoiding the need to build a tree representation of the document in memory. For information about the kind of queries that can be streamed, see L<Streaming XQuery|https://www.saxonica.com/documentation10/index.html#!sourcedocs/streaming/streamed-query>. If the query cannot be streamed, execution will fail with diagnostic errors. Requires Saxon-EE. =item B<-strip>:(C<all>|C<none>|C<ignorable>) Specifies what whitespace is to be stripped from source documents (applies both to the principal source document and to any documents loaded for example using the C<doc()> function). The default is none: no whitespace stripping. =item B<-t> Display version and timing information to the standard error output. The output also traces the files that are read and written, and extension modules that are loaded. =item B<-T>[:I<classname>] Notify query tracing information. Also switches line numbering on for the source document. If a classname is specified, it is a user-defined class, which must implement C<TraceListener>. If the classname is omitted, a system-supplied trace listener is used. This traces execution of function calls to the standard error output. For performance profiling, set classname to C<net.sf.saxon.trace.TimingTraceListener>. This creates an output file giving timings for each instruction executed. This output file can subsequently be analyzed to give an execution time profile for the query. See L<Performance Analysis|https://www.saxonica.com/documentation10/index.html#!using-xquery/performanceanalysis>. =item B<-TB>:I<filename> Monitors generation of hot-spot bytecode and produces an XML report on the given filename giving, for each expression that was a candidate for bytecode generation and that was actually executed, data about the number of times and speed of execution in the interpreter, the number of times and speed of execution in compiled form, and the cost of compilation. Note that if an expression I<A> contains an expression I<B> and both are candidates for bytecode generation, then the statistics for I<B> relate only to the time before I<A> was compiled in its own right. =item B<-TJ> Switches on tracing of the binding of calls to external Java methods. This is useful when analyzing why Saxon fails to find a Java method to match an extension function call in the query, or why it chooses one method over another when several are available. =item B<-Tlevel>:(C<none>|C<low>|C<normal>|C<high>) Controls the level of detail of the tracing produced by the C<-T> option. The values are: =over =item C<none> effectively switches tracing off. =item C<low> traces function calls. =item C<normal> traces execution of significant expressions such as element constructors. =item C<high> traces execution of finer-grained expressions such as the clauses of a FLWOR expression. =back =item B<-Tout>:I<filename> Directs the output of tracing to a specified file (assuming that B<-T> is enabled). =item B<-TP>:I<filename> This is equivalent to setting B<-T>:C<net.sf.saxon.trace.TimedTraceListener> and B<-traceout>:I<filename>; that is, it causes trace profile information to be set to the specified file. This output file can subsequently be analyzed to give an execution time profile for the query. See L<Performance Analysis|https://www.saxonica.com/documentation10/index.html#!using-xquery/performanceanalysis>. =item B<-traceout>:I<filename> Indicates that the output of the CC<trace()> function should be directed to a specified file. Alternatively, specify C<#out> to direct the output to C<System.out>, C<#err> to send it to C<System.err> (the default), or C<#null> to have it discarded. This option is ignored when a trace listener is in use: in that case, C<trace()> output goes to the registered trace listener. =item B<-tree>:(C<linked>|C<tiny>|C<tinyc>) Selects the implementation of the internal tree model. C<tiny> selects the âtiny treeâ model (the default), C<linked> selects the linked tree model, C<tinyc> selects the âcondensed tiny treeâ model. See L<Choosing a tree model|https://www.saxonica.com/documentation10/index.html#!sourcedocs/choosingmodel>. =item B<-u> Indicates that the name of the source document is a URI; otherwise it is taken as a filename, unless it starts with C<http:>, C<https:>, C<file:> or C<classpath:>, in which case it is taken as a URL. =item B<-update>:(C<on>|C<off>|C<discard>) Indicates whether XQuery Update syntax is accepted. This option requires Saxon-EE. The value on enables XQuery update; any eligible files updated by the query are written back to filestore. A file is eligible for updating if it was read using the C<doc()> or C<collection()> functions using a URI that represents an updateable location. The context document supplied using the B<-s> option is not eligible for updating. The default value off disables update (any use of XQuery update syntax is an error). The value discard allows XQuery Update syntax, but modifications made to files are not saved in filestore. If the document supplied in the B<-s> option is updated, the updated document is serialized as the result of the query (writing it to the B<-o> destination); updates to any other documents are simply discarded. Use of the B<-t> option is recommended: it gives feedback on which files have been updated by the query. =item B<-val>[:(C<strict>|C<lax>)] Requests schema-based validation of the source file and of any files read using the C<doc()> function. This option is available only with Saxon-EE, and it automatically switches on the B<-sa> option. Specify B<-val> or B<-val>:C<strict> to request strict validation, or B<-val>:C<lax> for lax validation. =item B<-wrap> Wraps the result sequence in an XML element structure that indicates the type of each node or atomic value in the query result. This format can handle any type of query result. In the absence of this option, the command effectively wraps a C<document{}> constructor around the supplied query, so that the result is a single XML document, which is then serialized. This will fail if the query result includes constructs that cannot be added to a document node in this way, notably free-standing attribute nodes. =item B<-x>:I<classname> Use the specified SAX parser for the source file and any files loaded using the C<doc()> function. The parser must be the fully-qualified class name of a Java class that implements the C<org.xml.sax.XMLReader> or C<javax.xml.parsers.SAXParserFactory> interface, and it must be instantiable using a zero-argument public constructor. =item B<-xi>:(C<on>|C<off>) Apply XInclude processing to all source XML documents (but not to schema documents). This currently only works when documents are parsed using the Xerces parser, which is the default in JDK 1.5 and later. =item B<-xmlversion>:(C<1.0>|C<1.1>) If B<-xmlversion>:C<1.1> is specified, allows XML 1.1 and XML Namespaces 1.1 constructs. This option must be set if source documents using XML 1.1 are to be read, or if result documents are to be serialized as XML 1.1. This option also enables use of XML 1.1 constructs within the query itself. =item B<-xsd>:I<file1>;I<file2>;I<file3>⦠Loads additional schema documents. The declarations in these schema documents are available when validating source documents (or for use by the C<validate{}> expression). This option may also be used to supply the locations of schema documents that are imported into the query, in the case where the import schema declaration gives the target namespace of the schema but not its location. =item B<-xsdversion>:(C<1.0>|C<1.1>) If B<-xsdversion>:C<1.1> is specified (the default), allows schema documents using XML Schema 1.1 to be read, and XML Schema 1.1 constructs such as assertions. =item B<-xsiloc>:(C<on>|C<off>) If set to C<on> (the default) the schema processor attempts to load any schema documents referenced in C<xsi:schemaLocation> and C<xsi:noNamespaceSchemaLocation> attributes in the instance document, unless a schema for the specified namespace (or non-namespace) is already available. If set to C<off>, these attributes are ignored. =item C<--feature>:I<value> Set a feature defined in the C<Configuration> interface. The names of features are defined in the Javadoc for class Feature (alternatively see L<Configuration Features|https://www.saxonica.com/documentation10/index.html#!configuration/config-features>): the value used here is the part of the name after the last âC</>â, for example B<--allow-external-functions>:C<off>. Only features accepting a string or boolean may be set; for booleans the values C<true>/C<false>, C<on>/C<off>, C<yes>/C<no>, and C<1>/C<0> are recognized. =item B<-?> Display command syntax. =item B<--?> Display a list of features that are available using the B<--feature>:I<value> syntax. =back =head2 COMMAND LINE PARAMETERS A I<param> takes the form I<name>=I<value>, name being the name of the parameter, and value the value of the parameter. These parameters are accessible within the query as external variables, using the C<$>I<name> syntax, provided they are declared in the query prolog. If there is no such declaration, the supplied parameter value is silently ignored. A param preceded by a leading question mark (C<?>) is interpreted as an XPath expression. For example, C<?time=current-dateTime()> sets the value of the external variable C<$time> to the value of the current date and time, as an instance of C<xs:dateTime>, while C<?debug=false()> sets the value of the variable C<$debug> to the boolean value false. If the parameter has a required type (for example C<declare variable $p as xs:date external;>), then the supplied value must be compatible with this type according to the standard rules for converting function arguments (it doesnât need to satisfy the stricter rules that apply to variable initialization). The static context for the XPath expression includes only the standard namespaces conventionally bound to the prefixes C<xs>, C<fn>, C<xsi>, and C<saxon>. The static base URI (used when calling the C<doc()> function) is the current directory. The dynamic context contains no context item, position, or size, and no variables. A param preceded by a leading plus sign (C<+>) is interpreted as a filename or directory. The content of the file is parsed as XML, and the resulting document node is passed to the stylesheet as the value of the parameter. If the parameter value is a directory, then all the immediately contained files are parsed as XML, and the resulting sequence of document nodes is passed as the value of the parameter. For example, C<+lookup=lookup.xml> sets the value of the external variable lookup to the document node at the root of the tree representing the parsed contents of the file F<lookup.xml>. A param preceded by a leading exclamation mark (C<!>) is interpreted as a serialization parameter. For example, C<!indent=yes> requests indented output, and C<!encoding=iso-8859-1> requests that the serialized output be in ISO 8859/1 encoding. This is equivalent to specifying the option declaration declare option C<saxon:output "indent=yes">; or declare option C<saxon:output "encoding=iso-8859-1">; in the query prolog. If you are using the bash shell, you will need to escape âC<!>â as âC<\!>â. Under Windows, and some other operating systems, it is possible to supply a value containing spaces by enclosing it in double quotes, for example C<name="John Smith">. This is a feature of the operating system shell, not something Saxon does, so it may not work the same way under every operating system. If the parameter name is in a non-null namespace, the parameter can be given a value using the syntax C<{>I<uri>C<}>I<localname>=I<value>. Here uri is the namespace URI of the parameterâs name, and localname is the local part of the name. This applies also to output parameters. For example, you can set the indentation level to 4 by using the parameter C<!{http://saxon.sf.net/}indent-spaces=4>. In this case, however, lexical QNames using the prefix saxon are also recognized, for example C<!saxon:indent-spaces=4>. For the extended set of output parameters supported by Saxon, see L<Additional serialization parameters|https://www.saxonica.com/documentation10/index.html#!extensions/output-extras>. =head1 SEE ALSO L<https://www.saxonica.com/documentation10/index.html>, L<saxon10(1)>, L<gizmo10(1)>. =head1 AUTHOR Michael H. Kay E<lt>L<m...@saxonica.com>E<gt> ++++++ saxon10.saxonq.script ++++++ #!/bin/sh # # saxon10q script # JPackage Project <http://www.jpackage.org/> . /usr/share/java-utils/java-functions MAIN_CLASS=net.sf.saxon.Query BASE_JARS="saxon10 xml-commons-apis jaxp_parser_impl" # Optional jars CLASSPATH="$CLASSPATH:"$(build-classpath \ icu4j \ jdom \ jdom2 \ xml-commons-resolver \ xom \ 2>/dev/null) || : # If we have resolver, add the CatalogManager.properties dir to CLASSPATH, # and tweak command line options so that it's used. args= if echo "$CLASSPATH" | grep xml-commons-resolver >/dev/null 2>&1 && test -r /etc/java/resolver/CatalogManager.properties; then CLASSPATH="$CLASSPATH:/etc/java/resolver" # Tune options to use resolver. r=org.apache.xml.resolver.tools.ResolvingXMLReader for opt in -x ; do if ! echo $@ | grep "\\${opt}:" >/dev/null 2>&1 ; then args="$args ${opt}:$r" fi done r=org.apache.xml.resolver.tools.CatalogResolver if ! echo $@ | grep "\\-r:" >/dev/null 2>&1 ; then args="$args -r:$r" fi fi # Set parameters set_jvm set_classpath $BASE_JARS set_flags $BASE_FLAGS set_options $BASE_OPTIONS # Let's start run $args "$@"
