/**
* This function composes the perl regular expression to perform pattern matching with negative
* look ahead. This becomes handy when a replacement string includes some string that is also a
* pattern. i.e.) pattern - ", & replacement - ", & original input - I didn't &0 to say
* "GOO".
*
* <p>After the first substitution with " and ": processed input - I didn't &0 to say
* "GOO".
*
* <p>When we do the second substitution with '&', we do not want to perform the pattern matching
* on the '&' of """ since it is already a replacement. If we give the pattern like this with
* perl's negative look-ahead functionality:
*
* <p>not-negative look-ahead pattern - & negative look-ahead pattern - &(?!quot)
*
* <p>After the second substitution with & and & with non-negative look-ahead: processed input
* - I didn't &0 to say &quotGOO&quot.
*
* <p>After the second substitution with & and & with negative look-ahead: processed input - I
* didn't &0 to say "GOO".
*
* @param pattern - pattern string to match
* @param replacement - replacement
* @return returns the format pattern for perl5 negative look-ahead
* @exception throws a FrameworkException when the input/pattern/replacement is null.
*/
private static String makePerl5MatchPatternNegativeLookAhead(String pattern, String replacement)
throws FrameworkException {
if (pattern == null || replacement == null) {
throw new FrameworkException(
"RegexUtils: makePerl5MatchPatternNegativeLookAhead: pattern or replacement is null."
+ "\npattern = "
+ pattern
+ "\nreplacement = "
+ replacement);
}
String result = pattern;
StringBuffer patternBuffer = new StringBuffer();
Perl5Util util = new Perl5Util();
String formatPattern = makePerl5MatchPattern(pattern);
// check if the pattern string is a part of the replacement string
if (util.match(formatPattern, replacement)) {
if (replacement.startsWith(pattern)) {
result = util.postMatch();
patternBuffer.append(pattern);
patternBuffer.append("(?!");
patternBuffer.append(result);
patternBuffer.append(")");
result = patternBuffer.toString();
} else {
throw new FrameworkException(
"ERROR: RegexUtils: makePerl5MatchPatternNegativeLookAhead: The pattern in the "
+ "replacement string should be at the beginning.");
}
}
return result;
}
/**
* This function composes the perl regular expression to perform pattern matching with negative
* look ahead. This becomes handy when a replacement string includes some string that is also a
* pattern.
*
* <p>i.e.) pattern - & replacement - ", &
*
* @param pattern - pattern string to match
* @param replacements - an array of replacement strings
* @return returns the format pattern for perl5 negative look-ahead
* @exception throws a FrameworkException when the pattern/replacement is null.
*/
private static String makePerl5MatchPatternNegativeLookAhead(
String pattern, String replacements[]) throws FrameworkException {
if (pattern == null || replacements.length < 0) {
throw new FrameworkException(
"RegexUtils: makePerl5MatchPatternNegativeLookAhead: pattern or replacement is null."
+ "\npattern = "
+ pattern
+ "\nreplacements.length = "
+ replacements.length);
}
String result = null;
StringBuffer patternBuffer = new StringBuffer();
Perl5Util util = new Perl5Util();
String formatPattern = makePerl5MatchPattern(pattern);
for (int i = 0; i < replacements.length; i++) {
if (util.match(formatPattern, replacements[i])) {
if (replacements[i].startsWith(pattern)) {
result = util.postMatch();
// very first one
if (i == 0) {
patternBuffer.append(pattern);
patternBuffer.append("(?!");
}
patternBuffer.append(result);
// the last one
if (i == (replacements.length - 1)) {
patternBuffer.append(")");
} else // not the last one, cat the perl5 separater
{
patternBuffer.append("|");
}
} else {
throw new FrameworkException(
"ERROR: RegexUtils: makePerl5MatchPatternNegativeLookAhead: The pattern in the "
+ "replacement string should be at the beginning.");
}
} else // no match found meaning invalid use of this function
{
throw new FrameworkException(
"ERROR: RegexUtils: makePerl5MatchPatternNegativeLookAhead: "
+ "Invalid use of the function.");
}
}
if (Debug.isLevelEnabled(Debug.MSG_STATUS)) {
Debug.log(
Debug.MSG_STATUS,
"RegexUtils: makePerl5MatchPatternNegativeLookAhead: patternBuffer.toString() = "
+ patternBuffer.toString());
}
return patternBuffer.toString();
}
/**
* This function replace only the first pattern matched with the replacement.
*
* @param pattern pattern string to match
* @param input input string
* @param replacement replacement string
* @return returns the processed string
* @exception throws a FrameworkException when the pattern/replacement is null.
*/
public static String replaceLast(String pattern, String input, String replacement)
throws FrameworkException {
if ((pattern == null) || (input == null) || (replacement == null)) {
throw new FrameworkException(
"RegexUtil: replaceLast(): pattern or input cannot be null. "
+ "pattern = "
+ pattern
+ "input = "
+ input
+ "replacement = "
+ replacement);
}
Perl5Util util = new Perl5Util();
MatchResult matchResult = null;
String result = null;
String pre = null;
String post = null;
StringBuffer resultBuffer = new StringBuffer();
int length = input.length();
String regex = makePerl5SubstitutionPattern(pattern, replacement);
pattern = makePerl5MatchPattern(pattern);
// counts the number of match and grab the last one
while (util.match(pattern, input)) {
// getting the string before match
pre = util.preMatch();
resultBuffer.append(pre);
// get the matched string
matchResult = util.getMatch();
resultBuffer.append(matchResult.toString());
// get the post string after the match
post = util.postMatch();
// the post becomes the new input
input = post;
}
// get the last match found
matchResult = util.getMatch();
// do the string replacement on the pattern found
result = util.substitute(regex, matchResult.toString());
resultBuffer.append(result);
resultBuffer.append(post);
return resultBuffer.toString();
}
/**
* The function checks and handles the situation where another begin token is found in between the
* first begin token and the first end token. Such first beginToken is ignored. The current input
* to be passed in to the replacement function will be the string between the LAST begin token and
* the FIRST end token found.
*
* @param beginToken the pattern to look for
* @param current input string
* @param resultBuffer the buffer to hold the result
* @return returns a Vector containing the substrings of the input that occur
*/
private static final String skipOrphanedBeginToken(
String beginToken, String current, StringBuffer resultBuffer) {
Perl5Util util = new Perl5Util();
boolean nextBeginTokenMatch = true;
MatchResult matchResult = null;
String remainderStr = null;
String subCurrent = null;
StringBuffer currentBuffer = new StringBuffer();
String pre = null;
// subCurrent is copy of the current to check if there is any next beginTokens
subCurrent = current;
while (nextBeginTokenMatch) {
nextBeginTokenMatch = util.match(beginToken, subCurrent);
if (nextBeginTokenMatch == true) {
// pre is the string before the beginToken
pre = util.preMatch();
currentBuffer.append(pre);
// get the matched beginToken
matchResult = util.getMatch();
currentBuffer.append(matchResult.toString());
// get the remaining string after the beginToken
remainderStr = util.postMatch();
subCurrent = remainderStr;
} else // there is no match
{
// appending the string before the last begin token to the result
resultBuffer.append(currentBuffer.toString());
// finally get the string to perform the substitution on
current = subCurrent;
break;
}
} // while
return current;
}