Examples of sunlabs.brazil.util.regexp.Regexp

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

        continue;
    }
    sb.append(line).append('|');
      }
      sb.setLength(sb.length() - 1);
      return new Regexp(sb.toString());
  } catch (Exception e) {
      return null;
  }
    }

View Full Code Here

      patternMap.removeElementAt(index);
      patternMap.removeElementAt(index);
      patternMap.removeElementAt(index);
  } else if (index > 0) {
      patternMap.setElementAt(replacement, ++index);
      patternMap.setElementAt(new Regexp(pattern), ++index);
  } else if (replacement != null) {
      patternMap.addElement(pattern);
      patternMap.addElement(replacement);
      patternMap.addElement(new Regexp(pattern));
  }
    }

View Full Code Here

  /*
   * check the regexp patterns
   */


  for (int i = 0; i<patternMap.size(); i+= 3) {
      Regexp exp = (Regexp) patternMap.elementAt(i+2);
      String replace = exp.sub(fix, (String) patternMap.elementAt(i+1));
      if (replace != null) { 
    count++;
    return replace;
      }
  }

View Full Code Here


  match = server.props.getProperty(prefix + "match");
  re = null;
  if (match != null) {
      try {
    re = new Regexp(match, true);
      } catch (Exception e) {
    server.log(Server.LOG_WARNING, prefix, "Bad expression:" + e);
      }
  }

View Full Code Here


  public
  ReStringTokenizer(String str, String re)
  throws IllegalArgumentException {
      super(str, re);
      rs = new Regsub((new Regexp(re)), str);
  }

View Full Code Here

      extract = (exp!=null  && rpl!=null );
      init = false;
      hr.request.log(Server.LOG_DIAGNOSTIC, hr.prefix, 
      "extracting content from: " + urlPrefix +
      " with: " + exp);
      re = new Regexp(exp);
  }
  return super.init(hr);
    }

View Full Code Here

    return false;
      }
  } else if (!lastExp.equals(exp)) {
      lastExp = exp;
      matchCase = (props.getProperty(hr.prefix + MATCHCASE) != null);
      re = new Regexp(exp, !matchCase);
      String tag = props.getProperty(hr.prefix + TAG, "font");
      String options = props.getProperty(hr.prefix + OPTIONS,
    "color=red");
      sub = props.getProperty(hr.prefix + SUBSTITUTE);
      if (sub == null) {

View Full Code Here

  String str = server.props.getProperty(prefix + "ssl");
  protocol = server.props.getProperty(prefix + "protocol", "https");
  this.prefix = prefix;
  if (str != null) {
     try {
       ssl = new Regexp(str);
     } catch (Exception e) {
         server.log(Server.LOG_WARNING, prefix,
       "Invalid regular expression for \"ssl\" gateway");
         return false;
     }

View Full Code Here

    static Class[] types = new Class[] {String.class, Properties.class};


    public boolean
    init(Server server, String prefix) {
  isMine = new MatchString(prefix, server.props);
  matchRe = new Regexp(server.props.getProperty(prefix + "match",
    "(^[a-z]+)\\(([^)]+)\\)$"));
  keySub = server.props.getProperty(prefix + "key", "\\2");
  tokenSub=server.props.getProperty(prefix + "token", "\\1");
  StringTokenizer st = new StringTokenizer(
    server.props.getProperty(prefix + "tokens"));

View Full Code Here

  String sub = null;


  public boolean init(String prefix, Properties p) {
      String matchStr=p.getProperty(prefix + "match");
      sub = p.getProperty(prefix + "sub");
      match = new Regexp(matchStr);
      if (match==null || sub == null) {
    System.out.println("Missing 'match' and 'sub'");
    return false;
      }
      return true;

View Full Code Here

0 1 2

TOP

Related Classes of sunlabs.brazil.util.regexp.Regexp

sunlabs.brazil.filter.ExecFilter

sunlabs.brazil.filter.ReFilter

sunlabs.brazil.filter.SessionFilter

sunlabs.brazil.handler.AclSwitchHandler

sunlabs.brazil.handler.CookieSessionHandler

sunlabs.brazil.handler.MapPage

sunlabs.brazil.handler.MatchString

sunlabs.brazil.handler.PollHandler

sunlabs.brazil.handler.RePollHandler$Extract

sunlabs.brazil.handler.RestrictClientHandler

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.