This class represents a query module, and includes information about the static context of the query module.
The class is intended for internal Saxon use. User settings that affect the static context are made in the
StaticQueryContext object, and those settings are copied to each QueryModule when the query module is compiled.
addImportedNamespace
public void addImportedNamespace(String uri)
Register that this module imports a particular module namespace
This method is intended for internal use.
uri
- the URI of the imported namespace.
addImportedSchema
public void addImportedSchema(String targetNamespace)
Add an imported schema to this static context. A query module can reference
types in a schema provided two conditions are satisfied: the schema containing those
types has been loaded into the Configuration, and the target namespace has been imported
by this query module. This method achieves the second of these conditions. It does not
cause the schema to be loaded.
targetNamespace
- The target namespace of the schema to be added
bindUnboundFunctionCalls
public void bindUnboundFunctionCalls()
throws XPathException
Bind function calls that could not be bound when first encountered. These
will either be forwards references to functions declared later in the same query module,
or in modules that are being imported recursively, or errors.
This method is for internal use only.
XPathException
- if a function call refers to a function that has
not been declared
bindUnboundVariables
public void bindUnboundVariables()
throws XPathException
Bind unbound variables (these are typically variables that reference another module
participating in a same-namespace cycle, since local forwards references are not allowed
bindVariable
public VariableReference bindVariable(StructuredQName qName)
throws XPathException
Bind a variable used in a query to the expression in which it is declared.
This method is provided for use by the XQuery parser, and it should not be called by the user of
the API, or overridden, unless variables are to be declared using a mechanism other than the
declareVariable method of this class.
- bindVariable in interface StaticContext
qName
- the name of the variable to be bound
- a VariableReference object representing a reference to a variable on the abstract syntac rtee of
the query.
checkForCircularities
public void checkForCircularities(List compiledVars,
XQueryFunctionLibrary globalFunctionLibrary)
throws XPathException
Check for circular definitions of global variables.
This method is intended for internal use
checkImportedFunctionSignature
public void checkImportedFunctionSignature(XQueryFunction fd)
throws XPathException
Check that all the types used in the signature of an imported function
are available in the module of the caller of the function
fd
- the declaration of the imported function
checkImportedType
public void checkImportedType(SequenceType importedType,
Declaration declaration)
throws XPathException
Check that a SequenceType used in the definition of an imported variable or function
is available in the importing module
importedType
- the type that is to be checkeddeclaration
- the containing query or function definition
checkURIForPrefix
public String checkURIForPrefix(String prefix)
Get the URI for a prefix if there is one, return null if not.
This method is used by the XQuery parser to resolve namespace prefixes.
This method is intended primarily for internal use.
prefix
- The prefix. Supply "" to obtain the default namespace for elements and types.
- the corresponding namespace URI, or null if the prefix has not
been declared. If the prefix is "" and the default namespace is the non-namespace,
return "".
declareActiveNamespace
public void declareActiveNamespace(String prefix,
String uri)
Declare an active namespace, that is, a namespace which as well as affecting the static
context of the query, will also be copied to the result tree when element constructors
are evaluated. When searching for a prefix-URI binding, active namespaces are searched
first, then passive namespaces. Active namespaces are later undeclared (in reverse sequence)
using
undeclareNamespace()
.
This method is intended for internal use only.
prefix
- the namespace prefixuri
- the namespace URI
declareFunction
public void declareFunction(XQueryFunction function)
throws XPathException
Register a user-defined XQuery function.
This method is intended for internal use only.
function
- the function being declared
declarePrologNamespace
public void declarePrologNamespace(String prefix,
String uri)
throws XPathException
Register a namespace that is explicitly declared in the prolog of the query module.
prefix
- The namespace prefix. Must not be null.uri
- The namespace URI. Must not be null. The value "" (zero-length string) is used
to undeclare a namespace; it is not an error if there is no existing binding for
the namespace prefix.
declareVariable
public void declareVariable(VariableDeclaration var)
throws XPathException
Declare a global variable. A variable must normally be declared before an expression referring
to it is compiled, but there are exceptions where a set of modules in the same namespace
import each other cyclically. Global variables are normally declared in the Query Prolog, but
they can also be predeclared using this API. All global variables are held in the StaticQueryContext
for the main module. The fact that a global variable is present therefore does not mean that it
is visible: there are two additional conditions (a) the namespace must be imported into the
module where the reference appears, and (b) the declaration must not be in the same module and textually
after the reference.
Note that the same VariableDeclaration object cannot be used with more than one query. This is because
the VariableDeclaration is modified internally to hold a list of references to all the places where
the variable is used.
var
- the Variable declaration being declared
explainGlobalFunctions
public void explainGlobalFunctions(ExpressionPresenter out)
Output "explain" information about each declared function.
This method is intended primarily for internal use.
out
- the expression presenter used to display the output
fixupGlobalFunctions
public void fixupGlobalFunctions()
throws XPathException
Fixup all references to global functions. This method is called
on completion of query parsing. Each XQueryFunction is required to
bind all references to that function to the object representing the run-time
executable code of the function.
This method is for internal use only. It is called only on the StaticQueryContext for the main
query body (not for library modules).
fixupGlobalVariables
public List fixupGlobalVariables(SlotManager globalVariableMap)
throws XPathException
Fixup all references to global variables.
This method is for internal use by the Query Parser only.
globalVariableMap
- a SlotManager that holds details of the assignment of slots to global variables.
- a list containing the global variable definitions.
getActiveNamespaceCodes
public int[] getActiveNamespaceCodes()
Get an array containing the namespace codes of all active namespaces.
This method is for internal use only.
- an array of namespace codes. A namespace code is an int that holds a prefix code in the
top half and a uri code in the bottom half.
getCollation
public StringCollator getCollation(String name)
Get a named collation.
- getCollation in interface StaticContext
name
- The name of the required collation. Supply null to get the default collation.
- the collation; or null if the required collation is not found.
getConstructionMode
public int getConstructionMode()
Get the current construction mode
getDefaultCollationName
public String getDefaultCollationName()
Get the name of the default collation.
- getDefaultCollationName in interface StaticContext
- the name of the default collation; or the name of the codepoint collation
if no default collation has been defined
getDefaultElementNamespace
public String getDefaultElementNamespace()
Get the default XPath namespace for elements and types. Note that this is not necessarily
the default namespace declared in the query prolog; within an expression, it may change in response
to namespace declarations on element constructors.
- getDefaultElementNamespace in interface StaticContext
- the default namespace, or NamespaceConstant.NULL for the non-namespace
getDefaultFunctionNamespace
public String getDefaultFunctionNamespace()
Get the default function namespace
- getDefaultFunctionNamespace in interface StaticContext
- the default namespace for function names
getExecutable
public Executable getExecutable()
Get the Executable, an object representing the compiled query and its environment.
This method is intended for internal use only.
getFunctionLibrary
public FunctionLibrary getFunctionLibrary()
Get the function library containing all the in-scope functions available in this static
context (that is, the functions available in this query module).
This method is provided for use by advanced applications.
The details of the interface are subject to change.
- getFunctionLibrary in interface StaticContext
- the FunctionLibrary used. For XQuery, this will always be a FunctionLibraryList.
getGlobalFunctionLibrary
public XQueryFunctionLibrary getGlobalFunctionLibrary()
Get the function library object that holds details of global functions
- the library of global functions
getGlobalStackFrameMap
public SlotManager getGlobalStackFrameMap()
Get the stack frame map for global variables.
This method is intended for internal use.
- the stack frame map (a SlotManager) for global variables.
getImportedFunctionLibrary
public ImportedFunctionLibrary getImportedFunctionLibrary()
Get the function library object that holds details of imported functions
- the library of imported functions
getImportedSchemaNamespaces
public Set getImportedSchemaNamespaces()
Get the set of imported schemas
- getImportedSchemaNamespaces in interface StaticContext
- a Set, the set of URIs representing the names of imported schemas
getLineNumber
public int getLineNumber()
Get the line number of the expression within that container.
Used to construct error messages. This method is provided to satisfy the StaticContext interface,
but the value is meaningful only for XPath expressions within a document such as a stylesheet.
- getLineNumber in interface StaticContext
getLocalFunctionLibrary
public XQueryFunctionLibrary getLocalFunctionLibrary()
Get the functions declared locally within this module
- a FunctionLibrary object containing the function declarations
getLocationMap
public LocationMap getLocationMap()
Get the LocationMap, an data structure used to identify the location of compiled expressions within
the query source text.
This method is intended for internal use only.
- getLocationMap in interface StaticContext
getLocationURI
public URI getLocationURI()
Get the location URI for a module
getModuleNamespace
public String getModuleNamespace()
Get the namespace of the current library module.
This method is intended primarily for internal use.
- the module namespace, or null if this is a main module
getModuleNamespaceCode
public short getModuleNamespaceCode()
Get the namesapce code of the current library module.
This method is intended primarily for internal use.
- the module namespace, or null if this is a main module
getModuleVariables
public Iterator getModuleVariables()
Get global variables declared in this module
- an Iterator whose items are GlobalVariableDefinition objects
getNamespaceResolver
public NamespaceResolver getNamespaceResolver()
Get a copy of the Namespace Context. This method is used internally
by the query parser when a construct is encountered that needs
to save the namespace context for use at run-time.
This method is for internal use only.
- getNamespaceResolver in interface StaticContext
getTopLevelModule
public QueryModule getTopLevelModule(QueryModule start)
Get the QueryModule for the top-level module. This will normally be a main module,
but in the case of saxon:import-query it will be the library module that is imported into
the stylesheet
start
- the StaticQueryContext where the search started
- the StaticQueryContext object associated with the top level module
getURIForPrefix
public String getURIForPrefix(String prefix)
throws XPathException
Get the URI for a prefix.
This method is used by the XQuery parser to resolve namespace prefixes.
This method is intended primarily for internal use.
- getURIForPrefix in interface StaticContext
- the corresponding namespace URI
getUserDefinedFunction
public UserFunction getUserDefinedFunction(String uri,
String localName,
int arity)
Get the function with a given name and arity. This method is provided so that XQuery functions
can be called directly from a Java application. Note that there is no type checking or conversion
of arguments when this is done: the arguments must be provided in exactly the form that the function
signature declares them.
uri
- the uri of the function namelocalName
- the local part of the function namearity
- the number of arguments.
- the user-defined function
getUserQueryContext
public StaticQueryContext getUserQueryContext()
Get the StaticQueryContext object containing options set up by the user
- the user-created StaticQueryContext object
importsNamespace
public boolean importsNamespace(String uri)
Ask whether this module directly imports a particular namespace
This method is intended for internal use.
uri
- the URI of the possibly-imported namespace.
- true if the schema for the namespace has been imported
importsNamespaceIndirectly
public boolean importsNamespaceIndirectly(String uri)
Test whether this module imports a particular namespace directly or indirectly
This method is intended for internal use.
uri
- the URI of the possibly-imported namespace.
- true if the schema for the namespace has been imported
isAllowedBuiltInType
public boolean isAllowedBuiltInType(BuiltInAtomicType type)
Determine whether a built-in type is available in this context. This method caters for differences
between host languages as to which set of types are built in.
- isAllowedBuiltInType in interface StaticContext
type
- the supposedly built-in type. This will always be a type in the
XS or XDT namespace.
- true if this type can be used in this static context
isEmptyLeast
public boolean isEmptyLeast()
Ask what is the option for where an empty sequence appears in the collation order, if not otherwise
specified in the "order by" clause
- true if the empty sequence is considered less than any other value (the default),
false if it is considered greater than any other value
isImportedSchema
public boolean isImportedSchema(String namespace)
Get the schema for a given namespace, if it has been imported
- isImportedSchema in interface StaticContext
namespace
- The namespace of the required schema. Supply "" for
a no-namespace schema.
- The schema if found, or null if not found.
isInBackwardsCompatibleMode
public boolean isInBackwardsCompatibleMode()
Determine whether Backwards Compatible Mode is used
- isInBackwardsCompatibleMode in interface StaticContext
- false; XPath 1.0 compatibility mode is not supported in XQuery
isInheritNamespaces
public boolean isInheritNamespaces()
Get the namespace inheritance mode
- true if namespaces are inherited, false if not
isMainModule
public boolean isMainModule()
Ask whether this is a "main" module, in the sense of the XQuery language specification
- true if this is a main module, false if it is a library model
isPreserveBoundarySpace
public boolean isPreserveBoundarySpace()
Ask whether the policy for boundary space is "preserve" or "strip"
- true if the policy is to preserve boundary space, false if it is to strip it
isPreserveNamespaces
public boolean isPreserveNamespaces()
Get the namespace copy mode
- true if namespaces are preserved, false if not
isTopLevelModule
public boolean isTopLevelModule()
Test whether this is a "top-level" module. This is true for a main module and also for a
module directly imported into an XSLT stylesheet. It may also be true in future for independently-compiled
modules
- true if this is top-level module
issueWarning
public void issueWarning(String s,
SourceLocator locator)
Issue a compile-time warning. This method is used during XQuery expression compilation to
output warning conditions.
This method is intended for internal use only.
- issueWarning in interface StaticContext
iterateImportedNamespaces
public Iterator iterateImportedNamespaces()
Get an iterator over all the module namespaces that this module imports
- an iterator over the imported namespaces (delivered as strings)
lookForModuleCycles
public void lookForModuleCycles(Stack referees,
int lineNumber)
throws XPathException
Look for module cycles. This is a restriction introduced in the PR specification because of
difficulties in defining the formal semantics.
[Definition: A module M1 directly depends on another module M2 (different from M1) if a
variable or function declared in M1 depends on a variable or function declared in M2.]
It is a static error [err:XQST0093] to import a module M1 if there exists a sequence
of modules M1 ... Mi ... M1 such that each module directly depends on the next module
in the sequence (informally, if M1 depends on itself through some chain of module dependencies.)
referees
- a Stack containing the chain of module import references leading to this
modulelineNumber
- used for diagnostics
makeQueryModule
public static QueryModule makeQueryModule(String baseURI,
Executable executable,
QueryModule importer,
String query,
String namespaceURI,
boolean allowCycles)
throws XPathException
Supporting method to load an imported library module.
Used also by saxon:import-query in XSLT.
This method is intended for internal use only.
baseURI
- The base URI and location URI of the moduleexecutable
- The Executableimporter
- The importing query module (used to check for cycles). This is null
when loading a query module from XSLT.query
- The text of the query, after decoding and normalizing line endingsnamespaceURI
- namespace of the query module to be loadedallowCycles
- True if cycles of module imports (disallowed by the spec) are to be permitted
- The StaticQueryContext representing the loaded query module
mayImportModule
public boolean mayImportModule(String namespace)
Check whether this module is allowed to import a module with namespace N. Note that before
calling this we have already handled the exception case where a module imports another in the same
namespace (this is the only case where cycles are allowed, though as a late change to the spec they
are no longer useful, since they cannot depend on each other cyclically)
namespace
- the namespace to be tested
- true if the import is permitted
optimizeGlobalFunctions
public void optimizeGlobalFunctions()
throws XPathException
Optimize the body of all global functions.
This method is for internal use only. It is called only on the StaticQueryContext for the main
query body (not for library modules).
reportFatalError
public void reportFatalError(XPathException err)
Report a fatal error in the query (via the registered ErrorListener)
err
- the error to be signalled
setBaseURI
public void setBaseURI(String uri)
Set the base URI for a module
setConstructionMode
public void setConstructionMode(int mode)
Set the construction mode for this module
setDefaultCollationName
public void setDefaultCollationName(String collation)
Set the name of the default collation
collation
- the URI of the default collation
setDefaultElementNamespace
public void setDefaultElementNamespace(String uri)
Set the default element namespace as declared in the query prolog
uri
- the default namespace for elements and types
setDefaultFunctionNamespace
public void setDefaultFunctionNamespace(String uri)
Set the default function namespace
uri
- the default namespace for functions
setEmptyLeast
public void setEmptyLeast(boolean least)
Set the option for where an empty sequence appears in the collation order, if not otherwise
specified in the "order by" clause
least
- true if the empty sequence is considered less than any other value (the default),
false if it is considered greater than any other value
setExecutable
public void setExecutable(Executable executable)
Set the executable.
This method is intended for internal use only.
executable
- the Executable
setFunctionLibraryList
public void setFunctionLibraryList(FunctionLibraryList functionLibrary)
Set the function library used for binding any function call appearing within the query module.
This method is available for use by advanced applications. The details of the FunctionLibrary
interface are subject to change. Applications using this interface take responsibility for
ensuring that the results conform to the constraints imposed by the XQuery language specification,
for example that one function within a query module can call other functions defined in the same
query module.
functionLibrary
- the FunctionLibrary to be used. This will typically be a
FunctionLibraryList; in most cases it will be a slightly modified copy of a FunctionLibraryList
constructed by the system and obtained using the getFunctionLibrary()
method.
setInheritNamespaces
public void setInheritNamespaces(boolean inherit)
Set the namespace inheritance mode
inherit
- true if namespaces are inherited, false if not
setLocationURI
public void setLocationURI(URI uri)
Set the location URI for a module
setModuleNamespace
public void setModuleNamespace(String uri)
Set the namespace for a library module.
This method is for internal use only.
uri
- the module namespace URI of the library module
setPreserveBoundarySpace
public void setPreserveBoundarySpace(boolean preserve)
Set the policy for preserving boundary space
preserve
- true if boundary space is to be preserved, false if it is to be stripped
setPreserveNamespaces
public void setPreserveNamespaces(boolean inherit)
Set the namespace copy mode
inherit
- true if namespaces are preserved, false if not
typeCheckGlobalVariables
public void typeCheckGlobalVariables(List compiledVars)
throws XPathException
Perform type checking on global variables.
This method is intended for internal use
undeclareNamespace
public void undeclareNamespace()
Undeclare the most recently-declared active namespace. This method is called
when a namespace declaration goes out of scope (while processing an element end tag).
It is NOT called when an XML 1.1-style namespace undeclaration is encountered.
This method is intended for internal use only.