net.sf.saxon.trans

Class SimpleMode

java.lang.Object

net.sf.saxon.expr.instruct.ComponentCode<SimpleMode>

net.sf.saxon.trans.Mode

net.sf.saxon.trans.SimpleMode

All Implemented Interfaces:

SourceLocator, Location, InstructionInfo, Locator

Direct Known Subclasses:

ModePE

public class SimpleMode
extends Mode

A Mode is a collection of rules; the selection of a rule to apply to a given element is determined by a Pattern. A SimpleMode is a mode contained within a single package, as opposed to a CompoundMode which can combine rules from several packages

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	SimpleMode.RuleGroupAction Interface used around a group of rules - principally at the group start and the group end

Nested classes/interfaces inherited from class net.sf.saxon.trans.Mode

Mode.RuleAction, Mode.RuleFilter

Field Summary

Fields

Modifier and Type	Field and Description
protected Rule	atomicValueRuleChain
protected Rule	commentRuleChain
protected Rule	documentRuleChain
protected Rule	functionItemRuleChain
protected Rule	genericRuleChain
protected IntHashMap<Rule>	namedAttributeRuleChains
protected IntHashMap<Rule>	namedElementRuleChains
protected Rule	namespaceRuleChain
protected Rule	processingInstructionRuleChain
protected Map<StructuredQName,Rule>	qNamedAttributeRuleChains
protected Map<StructuredQName,Rule>	qNamedElementRuleChains
protected Rule	textRuleChain
protected Rule	unnamedAttributeRuleChain
protected Rule	unnamedElementRuleChain

Fields inherited from class net.sf.saxon.trans.Mode

DEFAULT_MODE_NAME, hasRules, modeName, mustBeTyped, mustBeUntyped, OMNI_MODE, UNNAMED_MODE_NAME

Fields inherited from class net.sf.saxon.expr.instruct.ComponentCode

body

Constructor Summary

Constructors

Constructor and Description
SimpleMode(StructuredQName modeName) Default constructor - creates a Mode containing no rules

Method Summary

Methods

Modifier and Type	Method and Description
void	addRule(Pattern pattern, Rule newRule)
void	addRule(Pattern pattern, RuleTarget action, StylesheetModule module, int precedence, double priority, boolean explicitMode) Add a rule to the Mode.
void	allocateAllBindingSlots(StylesheetPackage pack) Allocate slot numbers to all the external component references in this component
void	allocateAllPatternSlots() Allocate slots for local variables in all patterns used by the rules in this mode.
void	allocatePatternSlots(int slots) Specify how many slots for local variables are required by a particular pattern
void	checkForConflictingProperties() Check that the mode does not contain conflicting property values
void	computeRankings(int start) Compute a rank for each rule, as a combination of the precedence and priority, to allow rapid comparison.
void	computeStreamability() Compute the streamability of all template rules.
static void	copyRules(SimpleMode from, SimpleMode to) Construct a new Mode, copying the contents of an existing Mode
void	explainTemplateRules(ExpressionPresenter out) Explain all template rules in this mode by showing their expression tree represented in XML.
void	exportTemplateRules(ExpressionPresenter out) Export all template rules in this mode in a form that can be re-imported.
static void	forceAllocateAllBindingSlots(StylesheetPackage pack, SimpleMode mode, List<ComponentBinding> bindings)
SimpleMode	getActivePart() Get the active component of this mode.
BuiltInRuleSet	getBuiltInRuleSet() Get the built-in template rules to be used with this Mode in the case where there is no explicit template rule
Set<String>	getExplicitNamespaces(NamePool pool) Get the "explicit namespaces" matched by this mode.
int	getMaxPrecedence() Get the maximum precedence of the rules in this mode
int	getMaxRank() Get the highest rank of the rules in this mode
protected Rule	getNamedRuleChain(XPathContext c, int kind, String uri, String local) Get a rule chain for a particular node name without allocating a fingerprint from the name pool
String	getPropertyValue(String name) Get the value of a property of this mode, e.g.
Rule	getRule(Item item, XPathContext context) Get the rule corresponding to a given item, by finding the best pattern match.
Rule	getRule(Item item, XPathContext context, Mode.RuleFilter filter) Get the rule corresponding to a given item, by finding the best Pattern match.
int	getStackFrameSlotsNeeded()
void	invertStreamableTemplates() For a streamable mode, invert all the templates to generate streamable code.
boolean	isEmpty() Ask whether there are any template rules in this mode (a mode could exist merely because it is referenced in apply-templates)
Rule	makeRule(Pattern pattern, RuleTarget action, int precedence, int minImportPrecedence, double priority, int sequence) Generate a new rule - so it can be overridden to make more specialist rules
protected RuleSearchState	makeRuleSearchState() Generate a search state for processing a given node
void	optimizeRules()
void	prepareStreamability() Prepare for possible streamability - null here, but can be subclassed
void	processRuleChain(Rule r, Mode.RuleAction action) Walk over all the rules, applying a specified action to each one.
void	processRuleChain(Rule r, Mode.RuleAction action, SimpleMode.RuleGroupAction group)
void	processRuleChains(IntHashMap<Rule> chains, Mode.RuleAction action, SimpleMode.RuleGroupAction group)
void	processRules(Mode.RuleAction action) Walk over all the rules, applying a specified action to each one.
void	processRules(Mode.RuleAction action, SimpleMode.RuleGroupAction group) Walk over all the rules, applying a specified action to each one.
protected void	reportAmbiguity(Item item, Rule r1, Rule r2, XPathContext c) Report an ambiguity, that is, the situation where two rules of the same precedence and priority match the same node
protected boolean	ruleMatches(Rule r, Item item, XPathContextMajor context, RuleSearchState pre) Does this rule match the given item? Can be overridden
protected Rule	searchRuleChain(Item item, XPathContext context, Rule bestRule, Rule head, RuleSearchState ruleSearchState) Search a chain of rules
protected Rule	searchRuleChain(Item item, XPathContext context, Rule bestRule, Rule head, RuleSearchState ruleSearchState, Mode.RuleFilter filter) Search a chain of rules
void	setBuiltInRuleSet(BuiltInRuleSet defaultRules) Set the built-in template rules to be used with this Mode in the case where there is no explicit template rule
void	setExplicitProperty(String name, String value, int precedence) Set an explicit property at a particular precedence.
protected SimpleMode.RuleGroupAction	setGroup(SimpleMode.RuleGroupAction group, String type) Set the string associated with a rule group
void	setStackFrameSlotsNeeded(int slots)

Methods inherited from class net.sf.saxon.trans.Mode

applyTemplates, explain, export, getBuiltInRuleSetForCode, getCodeForBuiltInRuleSet, getComponentKind, getConstructType, getModeName, getModeTitle, getNextMatchRule, getObjectName, getRecoveryPolicy, getRule, getSymbolicName, isDeclaredStreamable, isUnnamedMode, makeNewContext, makeNewContextIfNeeded, setRecoveryPolicy, setStreamable

Methods inherited from class net.sf.saxon.expr.instruct.ComponentCode

allocateBindingSlotsRecursive, getBody, getColumnNumber, getDeclaredVisibility, getDeclaringComponent, getLineNumber, getLocation, getPackageData, getProperties, getProperty, getPublicId, getRetainedStaticContext, getStackFrameMap, getSystemId, makeDeclaringComponent, saveLocation, setBody, setDeclaredVisibility, setDeclaringComponent, setLineNumber, setPackageData, setRetainedStaticContext, setStackFrameMap, setSystemId

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

genericRuleChain

protected Rule genericRuleChain

atomicValueRuleChain

protected Rule atomicValueRuleChain

functionItemRuleChain

protected Rule functionItemRuleChain

documentRuleChain

protected Rule documentRuleChain

textRuleChain

protected Rule textRuleChain

commentRuleChain

protected Rule commentRuleChain

processingInstructionRuleChain

protected Rule processingInstructionRuleChain

namespaceRuleChain

protected Rule namespaceRuleChain

unnamedElementRuleChain

protected Rule unnamedElementRuleChain

unnamedAttributeRuleChain

protected Rule unnamedAttributeRuleChain

namedElementRuleChains

protected IntHashMap<Rule> namedElementRuleChains

namedAttributeRuleChains

protected IntHashMap<Rule> namedAttributeRuleChains

qNamedElementRuleChains

protected Map<StructuredQName,Rule> qNamedElementRuleChains

qNamedAttributeRuleChains

protected Map<StructuredQName,Rule> qNamedAttributeRuleChains

Constructor Detail

SimpleMode

public SimpleMode(StructuredQName modeName)

Default constructor - creates a Mode containing no rules

Parameters:

modeName - the name of the mode

Method Detail

setBuiltInRuleSet

public void setBuiltInRuleSet(BuiltInRuleSet defaultRules)

Set the built-in template rules to be used with this Mode in the case where there is no explicit template rule

Parameters:

defaultRules - the built-in rule set

getBuiltInRuleSet

public BuiltInRuleSet getBuiltInRuleSet()

Get the built-in template rules to be used with this Mode in the case where there is no explicit template rule

Specified by:

getBuiltInRuleSet in class Mode

Returns:

the built-in rule set, defaulting to the TextOnlyCopyRuleSet if no other rule set has been supplied

getActivePart

public SimpleMode getActivePart()

Get the active component of this mode. For a simple mode this is the mode itself; for a compound mode it is the "overriding" part

Specified by:

getActivePart in class Mode

checkForConflictingProperties

public void checkForConflictingProperties()
                                   throws XPathException

Check that the mode does not contain conflicting property values

Throws:

XPathException - if there are conflicts

copyRules

public static void copyRules(SimpleMode from,
             SimpleMode to)

Construct a new Mode, copying the contents of an existing Mode

Parameters:

from - the existing mode.

to - the name of the new mode to be created

makeRuleSearchState

protected RuleSearchState makeRuleSearchState()

Generate a search state for processing a given node

Returns:

a new object capable of holding the state of a search for a rule

isEmpty

public boolean isEmpty()

Ask whether there are any template rules in this mode (a mode could exist merely because it is referenced in apply-templates)

Specified by:

isEmpty in class Mode

Returns:

true if no template rules exist in this mode

setExplicitProperty

public void setExplicitProperty(String name,
                       String value,
                       int precedence)

Set an explicit property at a particular precedence. Used for detecting conflicts

Parameters:

name - the name of the property

value - the value of the property

precedence - the import precedence of this property value

getPropertyValue

public String getPropertyValue(String name)

Get the value of a property of this mode, e.g. the "typed" property

Parameters:

name - the property name, e.g. "typed"

Returns:

the property value

getExplicitNamespaces

public Set<String> getExplicitNamespaces(NamePool pool)

Get the "explicit namespaces" matched by this mode. Returns a set containing all the namespaces matched by specific template rules in this mode

Specified by:

getExplicitNamespaces in class Mode

Parameters:

pool - the NamePool for the configuration

Returns:

the set of all namespace URIs of names explicitly matched by rules in this mode

addRule

public void addRule(Pattern pattern,
           RuleTarget action,
           StylesheetModule module,
           int precedence,
           double priority,
           boolean explicitMode)

Add a rule to the Mode.

Parameters:

pattern - a Pattern

action - the Object to return from getRule() when the supplied node matches this Pattern

module - the stylesheet module containing the rule

precedence - the import precedence of the rule

priority - the priority of the rule

explicitMode - true if adding a template rule for a specific (default or named) mode;

makeRule

public Rule makeRule(Pattern pattern,
            RuleTarget action,
            int precedence,
            int minImportPrecedence,
            double priority,
            int sequence)

Generate a new rule - so it can be overridden to make more specialist rules

Parameters:

pattern - the pattern that this rule matches

action - the object invoked by this rule (usually a Template)

precedence - the precedence of the rule

minImportPrecedence - the minumum import precedence for xsl:apply-imports

priority - the priority of the rule

sequence - a sequence number for ordering of rules

Returns:

the newly created rule

addRule

public void addRule(Pattern pattern,
           Rule newRule)

allocatePatternSlots

public void allocatePatternSlots(int slots)

Specify how many slots for local variables are required by a particular pattern

Parameters:

slots - the number of slots needed

getRule

public Rule getRule(Item item,
           XPathContext context)
             throws XPathException

Get the rule corresponding to a given item, by finding the best pattern match.

Specified by:

getRule in class Mode

Parameters:

item - the item to be matched

context - the XPath dynamic evaluation context

Returns:

the best matching rule, if any (otherwise null).

Throws:

XPathException - if an error occurs matching a pattern

getNamedRuleChain

protected Rule getNamedRuleChain(XPathContext c,
                     int kind,
                     String uri,
                     String local)

Get a rule chain for a particular node name without allocating a fingerprint from the name pool

Parameters:

kind - the kind of node (element or attribute)

uri - the namespace URI of the node

local - the local name of the node

Returns:

the Rule at the head of the rule chain for nodes of this name, or null if there are no rules to consider

searchRuleChain

protected Rule searchRuleChain(Item item,
                   XPathContext context,
                   Rule bestRule,
                   Rule head,
                   RuleSearchState ruleSearchState)
                        throws XPathException

Search a chain of rules

Parameters:

item - the item being matched

context - XPath dynamic context

bestRule - the best rule so far in terms of precedence and priority (may be null)

head - the rule at the head of the chain to be searched

ruleSearchState - An appropriate rule state object

Returns:

the best match rule found in the chain, or the previous best rule, or null

Throws:

XPathException - if an error occurs matching a pattern

ruleMatches

protected boolean ruleMatches(Rule r,
                  Item item,
                  XPathContextMajor context,
                  RuleSearchState pre)
                       throws XPathException

Does this rule match the given item? Can be overridden

Parameters:

r - the rule to check

item - the context item

context - the static context for evaluation

pre - An appropriate matcher for preconditions in this mode

Returns:

true if this rule does match

Throws:

XPathException

getRule

public Rule getRule(Item item,
           XPathContext context,
           Mode.RuleFilter filter)
             throws XPathException

Get the rule corresponding to a given item, by finding the best Pattern match.

Specified by:

getRule in class Mode

Parameters:

item - the item to be matched

context - the XPath dynamic evaluation context

filter - a filter to select which rules should be considered

Returns:

the best matching rule, if any (otherwise null).

Throws:

XPathException - if an error occurs

searchRuleChain

protected Rule searchRuleChain(Item item,
                   XPathContext context,
                   Rule bestRule,
                   Rule head,
                   RuleSearchState ruleSearchState,
                   Mode.RuleFilter filter)
                        throws XPathException

Search a chain of rules

Parameters:

item - the item being matched

context - XPath dynamic context

bestRule - the best rule so far in terms of precedence and priority (may be null)

head - the rule at the head of the chain to be searched

ruleSearchState - An appropriate ruleState in this mode

filter - filter used to select which rules are candidates to be searched

Returns:

the best match rule found in the chain, or the previous best rule, or null

Throws:

XPathException - if an error occurs while matching a pattern

reportAmbiguity

protected void reportAmbiguity(Item item,
                   Rule r1,
                   Rule r2,
                   XPathContext c)
                        throws XPathException

Report an ambiguity, that is, the situation where two rules of the same precedence and priority match the same node

Parameters:

item - The item that matches two or more rules

r1 - The first rule that the node matches

r2 - The second rule that the node matches

c - The context for the transformation

Throws:

XPathException - if the system is configured to treat ambiguous template matching as a non-recoverable error

prepareStreamability

public void prepareStreamability()
                          throws XPathException

Prepare for possible streamability - null here, but can be subclassed

Throws:

XPathException

allocateAllBindingSlots

public void allocateAllBindingSlots(StylesheetPackage pack)

Allocate slot numbers to all the external component references in this component

Overrides:

allocateAllBindingSlots in class ComponentCode<SimpleMode>

Parameters:

pack - the containing package

forceAllocateAllBindingSlots

public static void forceAllocateAllBindingSlots(StylesheetPackage pack,
                                SimpleMode mode,
                                List<ComponentBinding> bindings)

computeStreamability

public void computeStreamability()
                          throws XPathException

Compute the streamability of all template rules. No action in Saxon-HE.

Throws:

XPathException

invertStreamableTemplates

public void invertStreamableTemplates()
                               throws XPathException

For a streamable mode, invert all the templates to generate streamable code. No action in Saxon-HE.

Throws:

XPathException - if there is a non-streamable template in the mode

explainTemplateRules

public void explainTemplateRules(ExpressionPresenter out)

Explain all template rules in this mode by showing their expression tree represented in XML. Note that this produces more information than the simpler exportTemplateRules() method: this method is intended for the human reader wanting diagnostic explanations, whereas exportTemplateRules() is designed to produce a package that can be re-imported.

Specified by:

explainTemplateRules in class Mode

Parameters:

out - used to display the expression tree

exportTemplateRules

public void exportTemplateRules(ExpressionPresenter out)

Export all template rules in this mode in a form that can be re-imported. Note that template rules with union patterns may have been split into multiple rules. We need to avoid outputting them more than once.

Specified by:

exportTemplateRules in class Mode

Parameters:

out - used to display the expression tree

processRules

public void processRules(Mode.RuleAction action)
                  throws XPathException

Walk over all the rules, applying a specified action to each one.

Specified by:

processRules in class Mode

Parameters:

action - an action that is to be applied to all the rules in this Mode

Throws:

XPathException - if an error occurs processing any of the rules

processRules

public void processRules(Mode.RuleAction action,
                SimpleMode.RuleGroupAction group)
                  throws XPathException

Walk over all the rules, applying a specified action to each one.

Parameters:

action - an action that is to be applied to all the rules in this Mode

group - - actions to be performed at group start and group end

Throws:

XPathException - if an error occurs processing any of the rules

setGroup

protected SimpleMode.RuleGroupAction setGroup(SimpleMode.RuleGroupAction group,
                                  String type)

Set the string associated with a rule group

Parameters:

group - the group action object

type - the type of the rule group

Returns:

modified rulegroup action

processRuleChains

public void processRuleChains(IntHashMap<Rule> chains,
                     Mode.RuleAction action,
                     SimpleMode.RuleGroupAction group)
                       throws XPathException

Throws:

XPathException

processRuleChain

public void processRuleChain(Rule r,
                    Mode.RuleAction action)
                      throws XPathException

Walk over all the rules, applying a specified action to each one.

Parameters:

action - an action that is to be applied to all the rules in this Mode

Throws:

XPathException - if an error occurs processing any of the rules

processRuleChain

public void processRuleChain(Rule r,
                    Mode.RuleAction action,
                    SimpleMode.RuleGroupAction group)
                      throws XPathException

Throws:

XPathException

optimizeRules

public void optimizeRules()

getMaxPrecedence

public int getMaxPrecedence()

Description copied from class: Mode

Get the maximum precedence of the rules in this mode

Specified by:

getMaxPrecedence in class Mode

computeRankings

public void computeRankings(int start)
                     throws XPathException

Compute a rank for each rule, as a combination of the precedence and priority, to allow rapid comparison. This method also checks that there are no conflicts for property values in different xsl:mode declarations

Specified by:

computeRankings in class Mode

Parameters:

start - the lowest rank to use

Throws:

XPathException - if an error occurs processing the rules

getMaxRank

public int getMaxRank()

Description copied from class: Mode

Get the highest rank of the rules in this mode

Specified by:

getMaxRank in class Mode

Returns:

the highest rank

allocateAllPatternSlots

public void allocateAllPatternSlots()
                             throws XPathException

Allocate slots for local variables in all patterns used by the rules in this mode. Currently used only for accumulator rules

Throws:

XPathException - if anything goes wrong

getStackFrameSlotsNeeded

public int getStackFrameSlotsNeeded()

Specified by:

getStackFrameSlotsNeeded in class Mode

setStackFrameSlotsNeeded

public void setStackFrameSlotsNeeded(int slots)