Examples of Regexp

com.NLP.ReqExp.RegExp
com.bramosystems.oss.player.util.client.RegExp
Utility class for regular expressions @author Sikirulai Braheem @since 1.1
com.dragome.html.dom.RegExp
com.foundationdb.sql.pg.YamlTester.Regexp
com.google.gwt.regexp.shared.RegExp
A class for regular expressions with features like Javascript's RegExp, plus Javascript String's replace and split methods (which can take a RegExp parameter). The pure Java implementation (for server-side use) uses Java's Pattern class, unavailable under GWT. The super-sourced GWT implementation simply calls on to the native Javascript classes.
There are a few small incompatibilities between the two implementations. Java-specific constructs in the regular expression syntax (e.g. [a-z&&[^bc]], (?<=foo), \A, \Q) work only in the pure Java implementation, not the GWT implementation, and are not rejected by either. Also, the Javascript-specific constructs $` and $' in the replacement expression work only in the GWT implementation, not the pure Java implementation, which rejects them.
com.sun.msv.datatype.xsd.regex.RegExp
@author Kohsuke Kawaguchi

dk.brics.automaton.RegExp

Regular Expression extension to Automaton.

Regular expressions are built from the following abstract syntax:

regexp	::=	unionexp
	\|
unionexp	::=	interexp `\|` unionexp	(union)
	\|	interexp
interexp	::=	concatexp `&` interexp	(intersection)	[OPTIONAL]
	\|	concatexp
concatexp	::=	repeatexp concatexp	(concatenation)
	\|	repeatexp
repeatexp	::=	repeatexp `?`	(zero or one occurrence)
	\|	repeatexp `*`	(zero or more occurrences)
	\|	repeatexp `+`	(one or more occurrences)
	\|	repeatexp `{n}`	(`n` occurrences)
	\|	repeatexp `{n,}`	(`n` or more occurrences)
	\|	repeatexp `{n,m}`	(`n` to `m` occurrences, including both)
	\|	complexp
complexp	::=	`~` complexp	(complement)	[OPTIONAL]
	\|	charclassexp
charclassexp	::=	`[` charclasses `]`	(character class)
	\|	`[^` charclasses `]`	(negated character class)
	\|	simpleexp
charclasses	::=	charclass charclasses
	\|	charclass
charclass	::=	charexp `-` charexp	(character range, including end-points)
	\|	charexp
simpleexp	::=	charexp
	\|	`.`	(any single character)
	\|	`#`	(the empty language)	[OPTIONAL]
	\|	`@`	(any string)	[OPTIONAL]
	\|	`"` <Unicode string without double-quotes> `"`	(a string)
	\|	`(` `)`	(the empty string)
	\|	`(` unionexp `)`	(precedence override)
	\|	`<` <identifier> `>`	(named automaton)	[OPTIONAL]
	\|	`<n-m>`	(numerical interval)	[OPTIONAL]
charexp	::=	<Unicode character>	(a single non-reserved character)
	\|	`\` <Unicode character>	(a single character)

The productions marked [OPTIONAL] are only allowed if specified by the syntax flags passed to the RegExp constructor. The reserved characters used in the (enabled) syntax must be escaped with backslash (\) or double-quotes ("..."). (In contrast to other regexp syntaxes, this is required also in character classes.) Be aware that dash (-) has a special meaning in charclass expressions. An identifier is a string not containing right angle bracket (>) or dash (-). Numerical intervals are specified by non-negative decimal integers and include both end points, and if n and m have the same number of digits, then the conforming strings must have that length (i.e. prefixed by 0's). @author Anders Møller <amoeller@cs.au.dk>

eas.math.fundamentalAlgorithms.regExp.RegExp
@author lko
fr.norsys.mapper.console.mapping.RegExp
hampi.constraints.Regexp
A regular expression.
jflex.RegExp
Stores a regular expression of rules section in a JFlex-specification. This base class has no content other than its type. @author Gerwin Klein @version JFlex 1.3.5, $Revision: 1.12 $, $Date: 2001/10/08 10:08:03 $
net.percederberg.grammatica.parser.re.RegExp
A regular expression. This class creates and holds an internal data structure representing a regular expression. It also allows creating matchers. This class is thread-safe. Multiple matchers may operate simultanously on the same regular expression. @author Per Cederberg, @version 1.5

org.apache.lucene.util.automaton.RegExp

Regular Expression extension to Automaton.

Regular expressions are built from the following abstract syntax:

regexp	::=	unionexp
	\|
unionexp	::=	interexp `\|` unionexp	(union)
	\|	interexp
interexp	::=	concatexp `&` interexp	(intersection)	[OPTIONAL]
	\|	concatexp
concatexp	::=	repeatexp concatexp	(concatenation)
	\|	repeatexp
repeatexp	::=	repeatexp `?`	(zero or one occurrence)
	\|	repeatexp `*`	(zero or more occurrences)
	\|	repeatexp `+`	(one or more occurrences)
	\|	repeatexp `{n}`	(`n` occurrences)
	\|	repeatexp `{n,}`	(`n` or more occurrences)
	\|	repeatexp `{n,m}`	(`n` to `m` occurrences, including both)
	\|	complexp
complexp	::=	`~` complexp	(complement)	[OPTIONAL]
	\|	charclassexp
charclassexp	::=	`[` charclasses `]`	(character class)
	\|	`[^` charclasses `]`	(negated character class)
	\|	simpleexp
charclasses	::=	charclass charclasses
	\|	charclass
charclass	::=	charexp `-` charexp	(character range, including end-points)
	\|	charexp
simpleexp	::=	charexp
	\|	`.`	(any single character)
	\|	`#`	(the empty language)	[OPTIONAL]
	\|	`@`	(any string)	[OPTIONAL]
	\|	`"` <Unicode string without double-quotes> `"`	(a string)
	\|	`(` `)`	(the empty string)
	\|	`(` unionexp `)`	(precedence override)
	\|	`<` <identifier> `>`	(named automaton)	[OPTIONAL]
	\|	`<n-m>`	(numerical interval)	[OPTIONAL]
charexp	::=	<Unicode character>	(a single non-reserved character)
	\|	`\` <Unicode character>	(a single character)

org.apache.tapestry.validator.Regexp
org.apache.tapestry5.validator.Regexp
Enforces that the input matches a provided regular expression.
Starting in 5.4, this always writes the pattern and title attribute, even when client validation is not enabled. The title attribute is used specially by modern browsers, in concert with pattern.
org.apache.tools.ant.util.regexp.Regexp
Interface which represents a regular expression, and the operations that can be performed on it. @author Matthew Inger
org.jostraca.util.RegExp
Facade for regular expression implementations. Contracts: RejectBadArgs
org.jruby.compiler.ir.operands.Regexp
org.jruby.ir.operands.Regexp
org.springmodules.validation.bean.conf.loader.annotation.handler.RegExp
org.stjs.javascript.RegExp
sun.misc.Regexp
A class to represent a regular expression. Only handles '*'s. @author James Gosling
sunlabs.brazil.util.regexp.Regexp
criptics.com">tcl8.0. Much of the description below is copied verbatim from the tcl8.0 regsub manual entry.
REGULAR EXPRESSIONS
A regular expression is zero or more branches, separated by "|". It matches anything that matches one of the branches.
A branch is zero or more pieces, concatenated. It matches a match for the first piece, followed by a match for the second piece, etc.
A piece is an atom, possibly followed by "*", "+", or "?".
- An atom followed by "*" matches a sequence of 0 or more matches of the atom.
- An atom followed by "+" matches a sequence of 1 or more matches of the atom.
- An atom followed by "?" matches either 0 or 1 matches of the atom.
An atom is
- a regular expression in parentheses (matching a match for the regular expression)
- a range (see below)
- "." (matching any single character)
- "^" (matching the null string at the beginning of the input string)
- "$" (matching the null string at the end of the input string)
- a "\" followed by a single character (matching that character)
- a single character with no other significance (matching that character).
A range is a sequence of characters enclosed in "[]". The range normally matches any single character from the sequence. If the sequence begins with "^", the range matches any single character not from the rest of the sequence. If two characters in the sequence are separated by "-", this is shorthand for the full list of characters between them (e.g. "[0-9]" matches any decimal digit). To include a literal "]" in the sequence, make it the first character (following a possible "^"). To include a literal "-", make it the first or last character.
In general there may be more than one way to match a regular expression to an input string. For example, consider the command
```
 String[] match = new String[2]; Regexp.match("(a*)b*", "aabaaabb", match); 
```
Considering only the rules given so far, match[0] and match[1] could end up with the values
- "aabb" and "aa"
- "aaab" and "aaa"
- "ab" and "a"
or any of several other combinations. To resolve this potential ambiguity, Regexp chooses among alternatives using the rule "first then longest". In other words, it considers the possible matches in order working from left to right across the input string and the pattern, and it attempts to match longer pieces of the input string before shorter ones. More specifically, the following rules apply in decreasing order of priority:
1. If a regular expression could match two different parts of an input string then it will match the one that begins earliest.
2. If a regular expression contains "|" operators then the leftmost matching sub-expression is chosen.
3. In "*", "+", and "?" constructs, longer matches are chosen in preference to shorter ones.
4. In sequences of expression components the components are considered from left to right.
In the example from above, "(a*)b*" therefore matches exactly "aab"; the "(a*)" portion of the pattern is matched first and it consumes the leading "aa", then the "b*" portion of the pattern consumes the next "b". Or, consider the following example:
```
 String match = new String[3]; Regexp.match("(ab|a)(b*)c", "abc", match); 
```
After this command, match[0] will be "abc", match[1] will be "ab", and match[2] will be an empty string. Rule 4 specifies that the "(ab|a)" component gets first shot at the input string and Rule 2 specifies that the "ab" sub-expression is checked before the "a" sub-expression. Thus the "b" has already been claimed before the "(b*)" component is checked and therefore "(b*)" must match an empty string.
REGULAR EXPRESSION SUBSTITUTION
Regular expression substitution matches a string against a regular expression, transforming the string by replacing the matched region(s) with new substring(s).
What gets substituted into the result is controlled by a subspec. The subspec is a formatting string that specifies what portions of the matched region should be substituted into the result.
- "&" or "\0" is replaced with a copy of the entire matched region.
- "\n", where n is a digit from 1 to 9, is replaced with a copy of the nth subexpression.
- "\&" or "\\" are replaced with just "&" or "\" to escape their special meaning.
- any other character is passed through.
In the above, strings like "\2" represents the two characters backslash and "2", not the Unicode character 0002.
Here is an example of how to use Regexp
```
 public static void main(String[] args) throws Exception { Regexp re; String[] matches; String s; / * A regular expression to match the first line of a HTTP request. * * 1. ^               - starting at the beginning of the line * 2. ([A-Z]+)        - match and remember some upper case characters * 3. [ \t]+          - skip blank space * 4. ([^ \t]*)       - match and remember up to the next blank space * 5. [ \t]+          - skip more blank space * 6. (HTTP/1\\.[01]) - match and remember HTTP/1.0 or HTTP/1.1 * 7. $		      - end of string - no chars left. */ s = "GET http://a.b.com:1234/index.html HTTP/1.1"; re = new Regexp("^([A-Z]+)[ \t]+([^ \t]+)[ \t]+(HTTP/1\\.[01])$"); matches = new String[4]; if (re.match(s, matches)) { System.out.println("METHOD  " + matches[1]); System.out.println("URL     " + matches[2]); System.out.println("VERSION " + matches[3]); } / * A regular expression to extract some simple comma-separated data, * reorder some of the columns, and discard column 2. */ s = "abc,def,ghi,klm,nop,pqr"; re = new Regexp("^([^,]+),([^,]+),([^,]+),(.*)"); System.out.println(re.sub(s, "\\3,\\1,\\4")); } 
```
@author Colin Stevens (colin.stevens@sun.com) @version 2.3 @see Regsub

Examples of org.apache.tools.ant.util.regexp.Regexp

            } else {
                final int regexpsSize = regexps.size();
                for (int i = 0; i < regexpsSize; i++) {
                    RegularExpression regexp = (RegularExpression)
                                                        regexps.elementAt(i);
                    Regexp re = regexp.getRegexp(getProject());
                    boolean matches = re.matches(line);
                    if (!matches) {
                        line = null;
                        break;
                    }
                }

View Full Code Here

Examples of org.apache.tools.ant.util.regexp.Regexp

    protected String doReplace(RegularExpression r,
                               Substitution s,
                               String input,
                               int options) {
        String res = input;
        Regexp regexp = r.getRegexp(project);


        if (regexp.matches(input, options)) {
            res = regexp.substitute(input, s.getExpression(project), options);
        }


        return res;
    }

View Full Code Here

Examples of org.jostraca.util.RegExp

        includeBlockMatch = allincludeblocks[ includeBlockI ];
        includeBlockText  = includeBlockMatch.match();
        includeBlockFile  = includeBlockMatch.matchFirstSub();
        includeBlockMark  = includeBlockMatch.matchSecondSub();


        RegExp markRegExp = RegExp.make( includeBlockMark, RegExp.ModeSet.DotMatchesNewline );


        // include the file block
        String  includeFileContent  = FileUtil.readFile( pIncludeBase + File.separatorChar + includeBlockFile );        
        String  includeBlockContent = markRegExp.match( includeFileContent );


        // very important - prevent data loss
        if( Standard.EMPTY.equals( includeBlockContent ) ) {
          throw new TemplateException( TemplateException.CODE_includeblock_find, 
                                       new ValueSet( ValueCode.FILE, includeBlockFile, ValueCode.VALUE, includeBlockMark ) );

View Full Code Here

Examples of org.jruby.compiler.ir.operands.Regexp

    public Operand buildDRegexp(DRegexpNode dregexpNode, IRScope s) {
        List<Operand> strPieces = new ArrayList<Operand>();
        for (Node n : dregexpNode.childNodes())
            strPieces.add(build(n, s));


        return new Regexp(new CompoundString(strPieces), dregexpNode.getOptions());
    }

View Full Code Here

Examples of org.jruby.ir.operands.Regexp

        List<Operand> strPieces = new ArrayList<Operand>();
        for (Node n : dregexpNode.childNodes()) {
            strPieces.add(dynamicPiece(n, s));
        }


        return copyAndReturnValue(s, new Regexp(new CompoundString(strPieces), dregexpNode.getOptions()));
    }

View Full Code Here

Examples of org.springmodules.validation.bean.conf.loader.annotation.handler.RegExp

        super(RegExp.class);
    }


    @Override
    public String convertToValang(String fieldName, Annotation a, MessageSourceAccessor messages) {
        RegExp annotation = (RegExp) a;


        String errMsg = messages.getMessage(annotation.errorCode(), annotation.message());
        String applyIfValang = valangToJS(annotation.applyIf());
        StringBuffer sb = new StringBuffer();


        sb.append(" function() {return this.equals((this.RegExFunction(");
        sb.append(wrapAndEscapeJsString(annotation.value())); // regex
        sb.append(",this.getPropertyValue(");
        sb.append(wrapAndEscapeJsString(fieldName)); // value name
        sb.append("))), (true))}");


        return buildBasicRule(fieldName, errMsg, sb.toString(), applyIfValang, a);

View Full Code Here

Examples of org.stjs.javascript.RegExp


import org.stjs.javascript.RegExp;


public class GlobalScope5 {
  public void test() {
    replace("a", new RegExp("abc"), "a" + "b" + "c");
  }

View Full Code Here

Examples of sun.misc.Regexp

    }


    @Test
    @SuppressWarnings("deprecation")
    public void shouldDistinguishByRegexpMatchInBody() {
        Condition condition = Condition.withPostBodyContaining(new Regexp("[0-9]+"));


        when(call.getPostBody()).thenReturn("331102");
        assertTrue(condition.check(call));


        condition = Condition.withPostBodyContaining(new Regexp("[a-z]+"));
        assertFalse(condition.check(call));
    }

View Full Code Here

Examples of sun.misc.Regexp

        Condition condition = Condition.withPostBodyContaining(Pattern.compile("[0-9]+"));


        when(call.getPostBody()).thenReturn("331102");
        assertTrue(condition.check(call));


        condition = Condition.withPostBodyContaining(new Regexp("[a-z]+"));
        assertFalse(condition.check(call));
    }

View Full Code Here

Examples of sunlabs.brazil.util.regexp.Regexp

  mustExist = props.getProperty(propsPrefix + EXIST) != null;
  persist = props.getProperty(propsPrefix + PERSIST) != null;
  session = props.getProperty(propsPrefix + PROPERTY, session);
  urlPrefix = props.getProperty(propsPrefix + URLPREFIX, "/");


  cookie = new Regexp("(^|; *)" + cookieName + "=([^;]*)");
        return true;
    }

View Full Code Here

0 1 2 3 4 5 6

TOP

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.