net.sf.saxon.regex

Class Operation

java.lang.Object

net.sf.saxon.regex.Operation

Direct Known Subclasses:

OpAtom, OpBackReference, OpBOL, OpCapture, OpCharClass, OpChoice, OpEndProgram, OpEOL, OpNothing, OpRepeat, OpSequence, OpTrace

public abstract class Operation
extends java.lang.Object

Represents an operation or instruction in the regular expression program. The class Operation is abstract, and has concrete subclasses for each kind of operation/instruction

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	Operation.ForceProgressIterator The ForceProgressIterator is used to protect against non-termination; specifically, iterators that return an infinite number of zero-length matches.

Field Summary

Fields

Modifier and Type	Field and Description
protected static int	MATCHES_ZLS_ANYWHERE
protected static int	MATCHES_ZLS_AT_END
protected static int	MATCHES_ZLS_AT_START
protected static int	MATCHES_ZLS_NEVER

Constructor Summary

Constructors

Constructor and Description
Operation()

Method Summary

Modifier and Type	Method and Description
boolean	containsCapturingExpressions() Ask whether the expression contains any capturing sub-expressions
abstract java.lang.String	display() Display the operation as a regular expression, possibly in abbreviated form
CharacterClass	getInitialCharacterClass(boolean caseBlind) Get a CharacterClass identifying the set of characters that can appear as the first character of a non-empty string that matches this term.
int	getMatchLength() Get the length of the matches returned by this operation if they are fixed-length
int	getMinimumMatchLength() Get the minimum length of the matches returned by this operation
abstract IntIterator	iterateMatches(REMatcher matcher, int position) Get an iterator returning all the matches for this operation
abstract int	matchesEmptyString() Ask whether the regular expression is known, after static analysis, to match a zero-length string
Operation	optimize(REProgram program, REFlags flags) Optimize the operation

Methods inherited from class java.lang.Object

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

Field Detail

MATCHES_ZLS_AT_START

protected static final int MATCHES_ZLS_AT_START

See Also:

Constant Field Values

MATCHES_ZLS_AT_END

protected static final int MATCHES_ZLS_AT_END

See Also:

Constant Field Values

MATCHES_ZLS_ANYWHERE

protected static final int MATCHES_ZLS_ANYWHERE

See Also:

Constant Field Values

MATCHES_ZLS_NEVER

protected static final int MATCHES_ZLS_NEVER

See Also:

Constant Field Values

Constructor Detail

Operation

public Operation()

Method Detail

iterateMatches

public abstract IntIterator iterateMatches(REMatcher matcher,
                                           int position)

Get an iterator returning all the matches for this operation

Parameters:

matcher - supplies the context for the matching; may be updated with information about captured groups

position - the start position to seek a match

Returns:

an iterator returning the endpoints of all matches starting at the supplied position

getMatchLength

public int getMatchLength()

Get the length of the matches returned by this operation if they are fixed-length

Returns:

the length of the matches, or -1 if the length is variable

getMinimumMatchLength

public int getMinimumMatchLength()

Get the minimum length of the matches returned by this operation

Returns:

the length of the shortest string that will match the operation

matchesEmptyString

public abstract int matchesEmptyString()

Ask whether the regular expression is known, after static analysis, to match a zero-length string

Returns:

a value indicating whether the regex is statically known to match a zero-length string. Specifically:

• returns MATCHES_ZLS_AT_START if the expression is statically known to match a zero-length string at the start of the supplied input;
• returns MATCHES_ZLS_AT_END if it is statically known to return a zero-length string at the end of the supplied input;
• returns MATCHES_ZLS_ANYWHERE if it is statically known to match a zero-length string anywhere in the input.
• returns MATCHES_ZLS_NEVER if it is statically known that the regex will never match a zero length string.

Returning 0 means that it is not known statically whether or not the regex will match a zero-length string; this case typically arises when back-references are involved.

containsCapturingExpressions

public boolean containsCapturingExpressions()

Ask whether the expression contains any capturing sub-expressions

Returns:

true if the expression contains any capturing sub-expressions (but not if it is a capturing expression itself, unless it contains nested capturing expressions)

getInitialCharacterClass

public CharacterClass getInitialCharacterClass(boolean caseBlind)

Get a CharacterClass identifying the set of characters that can appear as the first character of a non-empty string that matches this term. This is allowed to be an over-estimate (that is, the returned Character class must match every character that can legitimately appear at the start of the matched string, but it can also match other characters).

Parameters:

caseBlind - true if case-blind matching is in force ("i" flag)

optimize

public Operation optimize(REProgram program,
                          REFlags flags)

Optimize the operation

Parameters:

program - the program being optimized

flags - the regular expression flags

Returns:

the optimized operation

display

public abstract java.lang.String display()

Display the operation as a regular expression, possibly in abbreviated form

Returns:

the operation in a form that is recognizable as a regular expression or abbreviated regular expression