Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * To change this template, choose Tools | Templates
   * and open the template in the editor.
   */
  package ch.nerdin.generators.testdata.framework.re;
  
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;

Parses a regular expression in separate expressions. TODO add escaped char like \. \t \b and fix the or expression.

Author(s):
Erik Jan de Wit
 
 public class REParser {
 
 
     public Map<IntegerReverseRExpressionparseRE(String expression) {
         char[] mask = expression.trim().toCharArray();
         int cl = 0; // mask.length;
         int start = 1;
         while (cl < mask.length) {
             int newcl = parseSubexpression(startmaskcl);
             if (newcl <= cl) {
                 break;
             }
             cl = newcl;
             start++;
         }
 
         return ;
     }

    
Method parseSubexpression.

Parameters:
nr
mask
startIndex
Returns:
int
 
     private int parseSubexpression(int nrchar[] maskint startIndex) {
         int r = startIndex;
         switch (mask[startIndex]) {
             case '[':
                 r = createRangeExpresssion(nrmaskstartIndex + 1);
                 break;
             case '{':
                 r = parseLengthExpresssion(nrmaskstartIndex + 1);
                 break;
             case '.':
                 r = parseAnyExpression(nrmaskstartIndex);
                 break;
             case '?':
                 r = parseGreedyExpression(nrmaskstartIndex);
                 break;
             case '+':
                 r = parseGreedyExpression(nrmaskstartIndex);
                 break;
             case '*':
                 r = parseGreedyExpression(nrmaskstartIndex);
                 break;
             case '|':
                 r = parseOrExpression(nrstartIndex);
                 break;
             case '(':
                 r = parseGroupExpression(nrstartIndextrue);
                 break;
             case ')':
                 r = parseGroupExpression(nrstartIndexfalse);
                 break;
             default:
                 r = parseCharExpression(nrmaskstartIndex);
         }
         return r;
     }
 
     private int parseGroupExpression(int nrint startIndexboolean start) {
         this..put(nrexpression);
         return startIndex + 1;
     }
 
     private int parseOrExpression(int nrint startIndex) {
         ReverseRExpression expression = new ReverseOrExpression(.);
         this..put(nrexpression);
         return startIndex + 1;
     }
 
     private int parseCharExpression(int nrchar[] maskint startIndex) {
         ReverseRExpression expression = new ReverseRExpression(.);
         expression.generationInstruction = mask[startIndex];
         this..put(nrexpression);
         return startIndex + 1;
     }

    
Method parseAnyExpression.

Parameters:
nr
mask
startIndex
Returns:
    private int parseAnyExpression(int nrchar[] maskint startIndex) {
        this..put(nr.);
        return startIndex + 1;
    }

    
Method parseAnyExpression.

Parameters:
nr
mask
startIndex
Returns:
    private int parseGreedyExpression(int nrchar[] maskint startIndex) {
        ReverseRExpression expression = new ReverseGreedyExpression(mask[startIndex]);
        this..put(nrexpression);
        return startIndex + 1;
    }

    
Method parseCountExpresssion.

Parameters:
nr
mask
startIndex
Returns:
    private int parseLengthExpresssion(int nrchar[] maskint startIndex) {
        int currentIndex = startIndex;
        StringBuilder startLengthString = new StringBuilder();
        StringBuilder endLengthString = new StringBuilder();
        boolean startMode = true;
        while (mask[currentIndex] != '}' && currentIndex < mask.length) {
            if (Character.isDigit(mask[currentIndex])) {
                if (startMode) {
                    startLengthString.append(mask[currentIndex]);
                    currentIndex++;
                } else {
                    endLengthString.append(mask[currentIndex]);
                    currentIndex++;
                }
            } else if (mask[currentIndex] == ',' && startMode) {
                // between sign
                currentIndex++;
                // switch to end mode
                startMode = false;
            }
        }
        if (mask[currentIndex] == '}') {
            currentIndex++;
        }
        long startLength = Long.parseLong(startLengthString.toString());
        long endLength;
        // is there an end length defined?
        if (!startMode) {
            endLength = Long.parseLong(endLengthString.toString());
        } else {
            endLength = startLength;
        }
        this..put(nrnew ReverseLengthRExpression(startLengthendLength));
        return currentIndex;
    }

    
Method parseRangeExpresssion.

Parameters:
nr
mask
startIndex
Returns:
    private int createRangeExpresssion(int nrchar[] maskint startIndex) {
        int currentIndex = startIndex;
        HashSet<CharacterrangeSet = new HashSet<Character>();
        // sub
        while (mask[currentIndex] != ']' && currentIndex < mask.length) {
            char beginChar = mask[currentIndex];
            // TODO test for a nonalpanumeric
            if (currentIndex + 1 < mask.length) {
                // if -
                if (mask[currentIndex + 1] == '-' && currentIndex + 2 < mask.length) {
                    char endChar = mask[currentIndex + 2];
                    // TODO test for a nonalpanumeric
                    addCharacterRange(rangeSetbeginCharendChar);
                    currentIndex += 3;
                } else {
                    // otherwise begin is a simple char add it to the set and loop!
                    currentIndex++;
                    rangeSet.add(beginChar);
                }
            } else {
                // otherwise begin is a simple char add it to the set and loop!
                currentIndex++;
                rangeSet.add(beginChar);
            }
        }
        if (mask[currentIndex] == ']') {
            currentIndex++;
        }
        this..put(nrnew ReverseRangeRExpression(rangeSet));
        return currentIndex;
    }

    
Method addCharacterRange.

Parameters:
rangeSet
beginChar
endChar
    private void addCharacterRange(HashSet<CharacterrangeSetchar beginCharchar endChar) {
        // Numbers
        if (Character.isDigit(beginChar) && Character.isDigit(endChar)) {
            addRange(rangeSetbeginCharendChar);
        } else if ((Character.isLetter(beginChar) && Character.isDigit(endChar)) || (Character.isDigit(beginChar) && Character.isLetter(endChar))) {
            // todo prio 2 exception when an illegal character range
        } // alphabetic characters taking in account case
        else if ((Character.isLowerCase(beginChar) && Character.isLowerCase(endChar)) || (Character.isUpperCase(beginChar) && Character.isUpperCase(endChar))) {
            addRange(rangeSetbeginCharendChar);
        } else if (Character.isLowerCase(beginChar) && Character.isUpperCase(endChar)) {
            addRange(rangeSetbeginChar'z');
            addRange(rangeSet'A'endChar);
        } else if (Character.isUpperCase(beginChar) && Character.isLowerCase(endChar)) {
            addRange(rangeSetbeginChar'Z');
            addRange(rangeSet'a'endChar);
        } else {
            // todo prio 2 exception when an illegal character range
        }
    }
    private void addRange(HashSet<CharacterrangeSetchar beginCharchar endChar) {
        for (char ci = beginCharci <= endCharci++) {
            rangeSet.add(ci);
        }
    }
New to GrepCode? Check out our FAQ X