Perl5Compiler

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> org >> apache >> oro >> text >> [ regex overview ]

PREV CLASS NEXT CLASS

SUMMARY:

JAVADOC |

Sourc code of org.apache.oro.text.regex.Perl5Compiler

SOURCE |

Download org.apache.oro.text.regex.Perl5Compiler

DOWNLOAD | NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

org.apache.oro.text.regex
Class Perl5Compiler

java.lang.Object
  org.apache.oro.text.regex.Perl5Compiler

All Implemented Interfaces:: PatternCompiler

public final class Perl5Compiler
extends java.lang.Object
implements PatternCompiler

The Perl5Compiler class is used to create compiled regular expressions conforming to the Perl5 regular expression syntax. It generates Perl5Pattern instances upon compilation to be used in conjunction with a Perl5Matcher instance. Please see the user's guide for more information about Perl5 regular expressions.

Perl5Compiler and Perl5Matcher are designed with the intent that you use a separate instance of each per thread to avoid the overhead of both synchronization and concurrent access (e.g., a match that takes a long time in one thread will block the progress of another thread with a shorter match). If you want to use a single instance of each in a concurrent program, you must appropriately protect access to the instances with critical sections. If you want to share Perl5Pattern instances between concurrently executing instances of Perl5Matcher, you must compile the patterns with READ_ONLY_MASK 55 .

Since:: 1.0
Version:: @version@

Field Summary

private static char __CASE_INSENSITIVE


private int __cost


private static char __EXTENDED


private static char __GLOBAL


private static java.util.HashMap __hashPOSIX
          Lookup table for POSIX character class names

private static java.lang.String __HEX_DIGIT


private CharStringPointer __input


private static char __KEEP


private char[] __modifierFlags


private static char __MULTILINE


private static int __NONNULL


private int __numParentheses


private char[] __program


private int __programSize


private static char __READ_ONLY


private boolean __sawBackreference


private static int __SIMPLE


private static char __SINGLELINE


private static int __SPSTART


private static int __TRYAGAIN


private static int __WORSTCASE


static int CASE_INSENSITIVE_MASK
          A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should be case insensitive.

static int DEFAULT_MASK
          The default mask for the compile 55 methods.

static int EXTENDED_MASK
          A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should be treated as a Perl5 extended pattern (i.e., a pattern using the /x modifier).

static int MULTILINE_MASK
          A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should treat input as having multiple lines.

static int READ_ONLY_MASK
          A mask passed as an option to the compile 55 methods to indicate that the resulting Perl5Pattern should be treated as a read only data structure by Perl5Matcher, making it safe to share a single Perl5Pattern instance among multiple threads without needing synchronization.

static int SINGLELINE_MASK
          A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should treat input as being a single line.

Constructor Summary

Perl5Compiler()


Method Summary

private int __emitArgNode(char operator, char arg)


private void __emitCode(char code)


private int __emitNode(char operator)


private char __getNextChar()


private static boolean __isComplexRepetitionOp(char[] ch, int offset)


private static boolean __isSimpleRepetitionOp(char ch)


private int __parseAlternation(int[] retFlags)


private int __parseAtom(int[] retFlags)


private int __parseBranch(int[] retFlags)


private int __parseExpression(boolean isParenthesized, int[] hintFlags)


private static int __parseHex(char[] str, int offset, int maxLength, int[] scanned)


private static int __parseOctal(char[] str, int offset, int maxLength, int[] scanned)


private char __parsePOSIX(boolean[] negFlag)
          Parse POSIX epxression like [:foo:].

private static boolean __parseRepetition(char[] str, int offset)


private int __parseUnicodeClass()


private void __programAddOperatorTail(int current, int value)


private void __programAddTail(int current, int value)


private void __programInsertOperator(char operator, int operand)


private static void __setModifierFlag(char[] flags, char ch)


Pattern compile(char[] pattern)
          Same as calling compile(pattern, Perl5Compiler.DEFAULT_MASK);

Pattern compile(char[] pattern, int options)
          Compiles a Perl5 regular expression into a Perl5Pattern instance that can be used by a Perl5Matcher object to perform pattern matching.

Pattern compile(java.lang.String pattern)
          Same as calling compile(pattern, Perl5Compiler.DEFAULT_MASK);

Pattern compile(java.lang.String pattern, int options)
          Compiles a Perl5 regular expression into a Perl5Pattern instance that can be used by a Perl5Matcher object to perform pattern matching.

static java.lang.String quotemeta(char[] expression)
          Given a character string, returns a Perl5 expression that interprets each character of the original string literally.

static java.lang.String quotemeta(java.lang.String expression)
          Given a character string, returns a Perl5 expression that interprets each character of the original string literally.

Methods inherited from class java.lang.Object

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

Field Detail

__WORSTCASE

private static final int __WORSTCASE

See Also:: Constant Field Values

__NONNULL

private static final int __NONNULL

See Also:: Constant Field Values

__SIMPLE

private static final int __SIMPLE

See Also:: Constant Field Values

__SPSTART

private static final int __SPSTART

See Also:: Constant Field Values

__TRYAGAIN

private static final int __TRYAGAIN

See Also:: Constant Field Values

__CASE_INSENSITIVE

private static final char __CASE_INSENSITIVE

See Also:: Constant Field Values

__GLOBAL

private static final char __GLOBAL

See Also:: Constant Field Values

__KEEP

private static final char __KEEP

See Also:: Constant Field Values

__MULTILINE

private static final char __MULTILINE

See Also:: Constant Field Values

__SINGLELINE

private static final char __SINGLELINE

See Also:: Constant Field Values

__EXTENDED

private static final char __EXTENDED

See Also:: Constant Field Values

__READ_ONLY

private static final char __READ_ONLY

See Also:: Constant Field Values

__HEX_DIGIT

private static final java.lang.String __HEX_DIGIT

See Also:: Constant Field Values

__input

private CharStringPointer __input

__sawBackreference

private boolean __sawBackreference

__modifierFlags

private char[] __modifierFlags

__numParentheses

private int __numParentheses

__programSize

private int __programSize

__cost

private int __cost

__program

private char[] __program

__hashPOSIX

private static final java.util.HashMap __hashPOSIX

Lookup table for POSIX character class names

DEFAULT_MASK

public static final int DEFAULT_MASK

The default mask for the compile 55 methods. It is equal to 0. The default behavior is for a regular expression to be case sensitive and to not specify if it is multiline or singleline. When MULITLINE_MASK and SINGLINE_MASK are not defined, the ^, $, and . metacharacters are interpreted according to the value of isMultiline() in Perl5Matcher. The default behavior of Perl5Matcher is to treat the Perl5Pattern as though MULTILINE_MASK were enabled. If isMultiline() returns false, then the pattern is treated as though SINGLINE_MASK were set. However, compiling a pattern with the MULTILINE_MASK or SINGLELINE_MASK masks will ALWAYS override whatever behavior is specified by the setMultiline() in Perl5Matcher.

See Also:: Constant Field Values

CASE_INSENSITIVE_MASK

public static final int CASE_INSENSITIVE_MASK

A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should be case insensitive.

See Also:: Constant Field Values

MULTILINE_MASK

public static final int MULTILINE_MASK

A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should treat input as having multiple lines. This option affects the interpretation of the ^ and $ metacharacters. When this mask is used, the ^ metacharacter matches at the beginning of every line, and the $ metacharacter matches at the end of every line. Additionally the . metacharacter will not match newlines when an expression is compiled with MULTILINE_MASK , which is its default behavior.

See Also:: Constant Field Values

SINGLELINE_MASK

public static final int SINGLELINE_MASK

A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should treat input as being a single line. This option affects the interpretation of the ^ and $ metacharacters. When this mask is used, the ^ metacharacter matches at the beginning of the input, and the $ metacharacter matches at the end of the input. The ^ and $ metacharacters will not match at the beginning and end of lines occurring between the begnning and end of the input. Additionally, the . metacharacter will match newlines when an expression is compiled with SINGLELINE_MASK , unlike its default behavior.

See Also:: Constant Field Values

EXTENDED_MASK

public static final int EXTENDED_MASK

A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should be treated as a Perl5 extended pattern (i.e., a pattern using the /x modifier). This option tells the compiler to ignore whitespace that is not backslashed or within a character class. It also tells the compiler to treat the # character as a metacharacter introducing a comment as in Perl. In other words, the # character will comment out any text in the regular expression between it and the next newline. The intent of this option is to allow you to divide your patterns into more readable parts. It is provided to maintain compatibility with Perl5 regular expressions, although it will not often make sense to use it in Java.

See Also:: Constant Field Values

READ_ONLY_MASK

public static final int READ_ONLY_MASK

A mask passed as an option to the compile 55 methods to indicate that the resulting Perl5Pattern should be treated as a read only data structure by Perl5Matcher, making it safe to share a single Perl5Pattern instance among multiple threads without needing synchronization. Without this option, Perl5Matcher reserves the right to store heuristic or other information in Perl5Pattern that might accelerate future matches. When you use this option, Perl5Matcher will not store or modify any information in a Perl5Pattern. Use this option when you want to share a Perl5Pattern instance among multiple threads using different Perl5Matcher instances.

See Also:: Constant Field Values

Constructor Detail

Perl5Compiler

public Perl5Compiler()

Method Detail

quotemeta

public static final java.lang.String quotemeta(char[] expression)

Given a character string, returns a Perl5 expression that interprets each character of the original string literally. In other words, all special metacharacters are quoted/escaped. This method is useful for converting user input meant for literal interpretation into a safe regular expression representing the literal input.

In effect, this method is the analog of the Perl5 quotemeta() builtin method.

quotemeta

public static final java.lang.String quotemeta(java.lang.String expression)

In effect, this method is the analog of the Perl5 quotemeta() builtin method.

__isSimpleRepetitionOp

private static boolean __isSimpleRepetitionOp(char ch)

__isComplexRepetitionOp

private static boolean __isComplexRepetitionOp(char[] ch,
                                               int offset)

__parseRepetition

private static boolean __parseRepetition(char[] str,
                                         int offset)

__parseHex

private static int __parseHex(char[] str,
                              int offset,
                              int maxLength,
                              int[] scanned)

__parseOctal

private static int __parseOctal(char[] str,
                                int offset,
                                int maxLength,
                                int[] scanned)

__setModifierFlag

private static void __setModifierFlag(char[] flags,
                                      char ch)

__emitCode

private void __emitCode(char code)

__emitNode

private int __emitNode(char operator)

__emitArgNode

private int __emitArgNode(char operator,
                          char arg)

__programInsertOperator

private void __programInsertOperator(char operator,
                                     int operand)

__programAddTail

private void __programAddTail(int current,
                              int value)

__programAddOperatorTail

private void __programAddOperatorTail(int current,
                                      int value)

__getNextChar

private char __getNextChar()

__parseAlternation

private int __parseAlternation(int[] retFlags)
                        throws MalformedPatternException

__parseAtom

private int __parseAtom(int[] retFlags)
                 throws MalformedPatternException

__parseUnicodeClass

private int __parseUnicodeClass()
                         throws MalformedPatternException

__parsePOSIX

private char __parsePOSIX(boolean[] negFlag)
                   throws MalformedPatternException

Parse POSIX epxression like [:foo:].

__parseBranch

private int __parseBranch(int[] retFlags)
                   throws MalformedPatternException

__parseExpression

private int __parseExpression(boolean isParenthesized,
                              int[] hintFlags)
                       throws MalformedPatternException

compile

public Pattern compile(char[] pattern,
                       int options)
                throws MalformedPatternException

Compiles a Perl5 regular expression into a Perl5Pattern instance that can be used by a Perl5Matcher object to perform pattern matching. Please see the user's guide for more information about Perl5 regular expressions.

Specified by:: compile in interface PatternCompiler

compile

public Pattern compile(char[] pattern)
                throws MalformedPatternException

Same as calling compile(pattern, Perl5Compiler.DEFAULT_MASK);

Specified by:: compile in interface PatternCompiler

compile

public Pattern compile(java.lang.String pattern)
                throws MalformedPatternException

Same as calling compile(pattern, Perl5Compiler.DEFAULT_MASK);

Specified by:: compile in interface PatternCompiler

compile

public Pattern compile(java.lang.String pattern,
                       int options)
                throws MalformedPatternException

Specified by:: compile in interface PatternCompiler

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> org >> apache >> oro >> text >> [ regex overview ]

PREV CLASS NEXT CLASS

SUMMARY:

JAVADOC |

SOURCE |

DOWNLOAD | NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

Field Summary
`private static char`	`__CASE_INSENSITIVE`
`private int`	`__cost`
`private static char`	`__EXTENDED`
`private static char`	`__GLOBAL`
`private static java.util.HashMap`	`__hashPOSIX` Lookup table for POSIX character class names
`private static java.lang.String`	`__HEX_DIGIT`
`private CharStringPointer`	`__input`
`private static char`	`__KEEP`
`private char[]`	`__modifierFlags`
`private static char`	`__MULTILINE`
`private static int`	`__NONNULL`
`private int`	`__numParentheses`
`private char[]`	`__program`
`private int`	`__programSize`
`private static char`	`__READ_ONLY`
`private boolean`	`__sawBackreference`
`private static int`	`__SIMPLE`
`private static char`	`__SINGLELINE`
`private static int`	`__SPSTART`
`private static int`	`__TRYAGAIN`
`private static int`	`__WORSTCASE`
`static int`	`CASE_INSENSITIVE_MASK` A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should be case insensitive.
`static int`	`DEFAULT_MASK` The default mask for the compile 55 methods.
`static int`	`EXTENDED_MASK` A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should be treated as a Perl5 extended pattern (i.e., a pattern using the /x modifier).
`static int`	`MULTILINE_MASK` A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should treat input as having multiple lines.
`static int`	`READ_ONLY_MASK` A mask passed as an option to the compile 55 methods to indicate that the resulting Perl5Pattern should be treated as a read only data structure by Perl5Matcher, making it safe to share a single Perl5Pattern instance among multiple threads without needing synchronization.
`static int`	`SINGLELINE_MASK` A mask passed as an option to the compile 55 methods to indicate a compiled regular expression should treat input as being a single line.

Method Summary
`private int`	`__emitArgNode(char operator, char arg)`
`private void`	`__emitCode(char code)`
`private int`	`__emitNode(char operator)`
`private char`	`__getNextChar()`
`private static boolean`	`__isComplexRepetitionOp(char[] ch, int offset)`
`private static boolean`	`__isSimpleRepetitionOp(char ch)`
`private int`	`__parseAlternation(int[] retFlags)`
`private int`	`__parseAtom(int[] retFlags)`
`private int`	`__parseBranch(int[] retFlags)`
`private int`	`__parseExpression(boolean isParenthesized, int[] hintFlags)`
`private static int`	`__parseHex(char[] str, int offset, int maxLength, int[] scanned)`
`private static int`	`__parseOctal(char[] str, int offset, int maxLength, int[] scanned)`
`private char`	`__parsePOSIX(boolean[] negFlag)` Parse POSIX epxression like [:foo:].
`private static boolean`	`__parseRepetition(char[] str, int offset)`
`private int`	`__parseUnicodeClass()`
`private void`	`__programAddOperatorTail(int current, int value)`
`private void`	`__programAddTail(int current, int value)`
`private void`	`__programInsertOperator(char operator, int operand)`
`private static void`	`__setModifierFlag(char[] flags, char ch)`
`Pattern`	`compile(char[] pattern)` Same as calling compile(pattern, Perl5Compiler.DEFAULT_MASK);
`Pattern`	`compile(char[] pattern, int options)` Compiles a Perl5 regular expression into a Perl5Pattern instance that can be used by a Perl5Matcher object to perform pattern matching.
`Pattern`	`compile(java.lang.String pattern)` Same as calling compile(pattern, Perl5Compiler.DEFAULT_MASK);
`Pattern`	`compile(java.lang.String pattern, int options)` Compiles a Perl5 regular expression into a Perl5Pattern instance that can be used by a Perl5Matcher object to perform pattern matching.
`static java.lang.String`	`quotemeta(char[] expression)` Given a character string, returns a Perl5 expression that interprets each character of the original string literally.
`static java.lang.String`	`quotemeta(java.lang.String expression)` Given a character string, returns a Perl5 expression that interprets each character of the original string literally.

org.apache.oro.text.regex Class Perl5Compiler

__WORSTCASE

__NONNULL

__SIMPLE

__SPSTART

__TRYAGAIN

__CASE_INSENSITIVE

__GLOBAL

__KEEP

__MULTILINE

__SINGLELINE

__EXTENDED

__READ_ONLY

__HEX_DIGIT

__input

__sawBackreference

__modifierFlags

__numParentheses

__programSize

__cost

__program

__hashPOSIX

DEFAULT_MASK

CASE_INSENSITIVE_MASK

MULTILINE_MASK

SINGLELINE_MASK

EXTENDED_MASK

READ_ONLY_MASK

Perl5Compiler

quotemeta

quotemeta

__isSimpleRepetitionOp

__isComplexRepetitionOp

__parseRepetition

__parseHex

__parseOctal

__setModifierFlag

__emitCode

__emitNode

__emitArgNode

__programInsertOperator

__programAddTail

__programAddOperatorTail

__getNextChar

__parseAlternation

__parseAtom

__parseUnicodeClass

__parsePOSIX

__parseBranch

__parseExpression

compile

compile

compile

compile

org.apache.oro.text.regex
Class Perl5Compiler