Java Code Examples for java.util.regex.Pattern#MULTILINE

private static int toPatternFlags(int mask) {
    int flags = 0;
    if ((mask & Flags.IGNORE_CASE) != 0) {
        flags |= Pattern.CASE_INSENSITIVE;
    }
    if ((mask & Flags.UNICODE) != 0) {
        flags |= Pattern.UNICODE_CASE;
    }
    if ((mask & Flags.MULTILINE) != 0) {
        flags |= Pattern.MULTILINE;
    }
    if ((mask & Flags.DOTALL) != 0) {
        flags |= Pattern.DOTALL;
    }
    return flags;
}
 

/**
 * Creates a pattern element from the pattern string which is either a reg-ex expression or in
 * our old 'StringMatcher' format.
 *
 * @param pattern The search pattern
 * @param isRegex <code>true</code> if the passed string already is a reg-ex pattern
 * @param isStringMatcher <code>true</code> if the passed string is in the StringMatcher format.
 * @param isCaseSensitive Set to <code>true</code> to create a case insensitive pattern
 * @param isWholeWord <code>true</code> to create a pattern that requires a word boundary at the
 *            beginning and the end.
 * @return The created pattern
 * @throws PatternSyntaxException if "\R" is at an illegal position
 */
public static Pattern createPattern(String pattern, boolean isRegex, boolean isStringMatcher, boolean isCaseSensitive, boolean isWholeWord) throws PatternSyntaxException {
	if (isRegex) {
		pattern= substituteLinebreak(pattern);
		Assert.isTrue(!isWholeWord, "isWholeWord unsupported together with isRegex"); //$NON-NLS-1$
	} else {
		int len= pattern.length();
		StringBuilder buffer= new StringBuilder(len + 10);
		// don't add a word boundary if the search text does not start with
		// a word char. (this works around a user input error).
		if (isWholeWord && len > 0 && isWordChar(pattern.charAt(0))) {
			buffer.append("\\b"); //$NON-NLS-1$
		}
		appendAsRegEx(isStringMatcher, pattern, buffer);
		if (isWholeWord && len > 0 && isWordChar(pattern.charAt(len - 1))) {
			buffer.append("\\b"); //$NON-NLS-1$
		}
		pattern= buffer.toString();
	}

	int regexOptions= Pattern.MULTILINE;
	if (!isCaseSensitive) {
		regexOptions|= Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;
	}
	return Pattern.compile(pattern, regexOptions);
}
 

/**
 * Converts a string containing JS regex flag characters into an integer
 * with the corresponding bits set, according to the Pattern enum.
 */
private static int parseRegexFlags(String flagsString) {
    int regexFlags = 0;

    if (flagsString.contains("s")) {
        regexFlags |= Pattern.DOTALL;
    }

    if (flagsString.contains("i")) {
        regexFlags |= Pattern.CASE_INSENSITIVE;
    }

    if (flagsString.contains("m")) {
        regexFlags |= Pattern.MULTILINE;
    }

    return regexFlags;
}
 

void updatePattern() {
    reset();
    String p = bar.getPattern();
    if (!bar.getRegularExpression()) {
        p = Pattern.quote(p);
        if (bar.getWholeWords()) {
            p="\\b"+p+"\\b"; // NOI18N
        }
    }
    int flags = Pattern.MULTILINE;
    if (!bar.getMatchCase()) {
        flags |= Pattern.CASE_INSENSITIVE;
    }
    try {
        pattern = Pattern.compile(p, flags);
    } catch (PatternSyntaxException psex) {
        String message = NbBundle.getMessage(FindSupport.class, "FindBar.invalidExpression"); // NOI18N
        StatusDisplayer.getDefault().setStatusText(message, StatusDisplayer.IMPORTANCE_FIND_OR_REPLACE);
    }
    findNext();
    if (bar.getHighlightResults()) {
        highlight(tc, false);
    }
}
 

private static int parseOptionFlags(String opts) {
    int flags = 0;
    for(int i = 0; i < opts.length(); ++i) {
        switch(opts.charAt(i)) {
            // Standard 'special construct match flags'
            case 'i': flags |= Pattern.CASE_INSENSITIVE; break;
            case 'd': flags |= Pattern.UNIX_LINES; break;
            case 'm': flags |= Pattern.MULTILINE; break;
            case 's': flags |= Pattern.DOTALL; break;
            case 'u': flags |= Pattern.UNICODE_CASE; break;
            case 'x': flags |= Pattern.COMMENTS; break;
            // And pick a letters for remaining flags
            case 'l': flags |= Pattern.LITERAL; break;
            case 'c': flags |= Pattern.CANON_EQ; break;
            default:
                throw new InvalidParameterValueException("Invalid option: " + opts.charAt(i));
        }
    }
    return flags;
}
 

int getCompileFlags(ProcessContext context) {
    int flags = (context.getProperty(UNIX_LINES).asBoolean() ? Pattern.UNIX_LINES : 0)
            | (context.getProperty(CASE_INSENSITIVE).asBoolean() ? Pattern.CASE_INSENSITIVE : 0)
            | (context.getProperty(COMMENTS).asBoolean() ? Pattern.COMMENTS : 0)
            | (context.getProperty(MULTILINE).asBoolean() ? Pattern.MULTILINE : 0)
            | (context.getProperty(LITERAL).asBoolean() ? Pattern.LITERAL : 0)
            | (context.getProperty(DOTALL).asBoolean() ? Pattern.DOTALL : 0)
            | (context.getProperty(UNICODE_CASE).asBoolean() ? Pattern.UNICODE_CASE : 0)
            | (context.getProperty(CANON_EQ).asBoolean() ? Pattern.CANON_EQ : 0)
            | (context.getProperty(UNICODE_CHARACTER_CLASS).asBoolean() ? Pattern.UNICODE_CHARACTER_CLASS : 0);
    return flags;
}
 

private static EcmaPattern ecmaToJavaRegexp(String ecmaPattern, String options) {
    int flags = 0;

    if ( options.contains("i") ) {
        flags |= Pattern.CASE_INSENSITIVE;
    }

    if ( options.contains("m") ) {
        flags |= Pattern.MULTILINE;
    }

    return new EcmaPattern(Pattern.compile(ecmaPattern, flags));
}
 

@Test
public void testReadRegexArgument_String() {
    TestAction instance = new TestActionImpl();
    
    instance.writeArgument("regex1", "/aaa\\d{3}bbb/sim");
            
    Pattern result3 = instance.readRegexArgument("regex1");

    int expectedFlags = Pattern.DOTALL | Pattern.CASE_INSENSITIVE | Pattern.MULTILINE;
    assertTrue(result3.flags() == expectedFlags);
    assertTrue(result3.pattern().equals("aaa\\d{3}bbb"));
    assertTrue(result3.matcher("aaa123bbb").find() == true);
    assertTrue(result3.matcher("aaa12bbb").find() == false);
}
 

public static int parseFlags(@Nullable BytesRef flagsString) {
    int flags = 0;
    if (flagsString == null) {
        return flags;
    }
    for (char flag : flagsString.utf8ToString().toCharArray()) {
        switch (flag) {
            case 'i':
                flags = flags | Pattern.CASE_INSENSITIVE;
                break;
            case 'u':
                flags = flags | Pattern.UNICODE_CASE;
                break;
            case 'U':
                flags = flags | Pattern.UNICODE_CHARACTER_CLASS;
                break;
            case 's':
                flags = flags | Pattern.DOTALL;
                break;
            case 'm':
                flags = flags | Pattern.MULTILINE;
                break;
            case 'x':
                flags = flags | Pattern.COMMENTS;
                break;
            case 'd':
                flags = flags | Pattern.UNIX_LINES;
                break;
            default:
                break;
        }
    }

    return flags;
}
 

public static int flagsFromString(String flags) {
    int pFlags = 0;
    for (String s : Strings.delimitedListToStringArray(flags, "|")) {
        if (s.isEmpty()) {
            continue;
        }
        s = s.toUpperCase(Locale.ROOT);
        if ("CASE_INSENSITIVE".equals(s)) {
            pFlags |= Pattern.CASE_INSENSITIVE;
        } else if ("MULTILINE".equals(s)) {
            pFlags |= Pattern.MULTILINE;
        } else if ("DOTALL".equals(s)) {
            pFlags |= Pattern.DOTALL;
        } else if ("UNICODE_CASE".equals(s)) {
            pFlags |= Pattern.UNICODE_CASE;
        } else if ("CANON_EQ".equals(s)) {
            pFlags |= Pattern.CANON_EQ;
        } else if ("UNIX_LINES".equals(s)) {
            pFlags |= Pattern.UNIX_LINES;
        } else if ("LITERAL".equals(s)) {
            pFlags |= Pattern.LITERAL;
        } else if ("COMMENTS".equals(s)) {
            pFlags |= Pattern.COMMENTS;
        } else if ("UNICODE_CHAR_CLASS".equals(s)) {
            pFlags |= UNICODE_CHARACTER_CLASS;
        } else {
            throw new IllegalArgumentException("Unknown regex flag [" + s + "]");
        }
    }
    return pFlags;
}
 

public static String flagsToString(int flags) {
    StringBuilder sb = new StringBuilder();
    if ((flags & Pattern.CASE_INSENSITIVE) != 0) {
        sb.append("CASE_INSENSITIVE|");
    }
    if ((flags & Pattern.MULTILINE) != 0) {
        sb.append("MULTILINE|");
    }
    if ((flags & Pattern.DOTALL) != 0) {
        sb.append("DOTALL|");
    }
    if ((flags & Pattern.UNICODE_CASE) != 0) {
        sb.append("UNICODE_CASE|");
    }
    if ((flags & Pattern.CANON_EQ) != 0) {
        sb.append("CANON_EQ|");
    }
    if ((flags & Pattern.UNIX_LINES) != 0) {
        sb.append("UNIX_LINES|");
    }
    if ((flags & Pattern.LITERAL) != 0) {
        sb.append("LITERAL|");
    }
    if ((flags & Pattern.COMMENTS) != 0) {
        sb.append("COMMENTS|");
    }
    if ((flags & UNICODE_CHARACTER_CLASS) != 0) {
        sb.append("UNICODE_CHAR_CLASS|");
    }
    return sb.toString();
}
 

@Test
public void testRegexpFlagParsing() {
    ModifiableSolrParams params = new ModifiableSolrParams();
    params.add(TermsParams.TERMS_REGEXP_FLAG, "case_insensitive", "literal", "comments", "multiline", "unix_lines",
            "unicode_case", "dotall", "canon_eq");
    try (TermsComponent termsComponent = new TermsComponent()) {
      int flags = termsComponent.resolveRegexpFlags(params);
      int expected = Pattern.CASE_INSENSITIVE | Pattern.LITERAL | Pattern.COMMENTS | Pattern.MULTILINE | Pattern.UNIX_LINES
          | Pattern.UNICODE_CASE | Pattern.DOTALL | Pattern.CANON_EQ;
      assertEquals(expected, flags);
    } catch (IOException e) {
      fail("Error closing TermsComponent");
    }
}
 

public Pattern toPattern() {
	if (pattern == null) {
		int flags = Pattern.MULTILINE;
		if (!caseSensitive) {
			flags = flags | Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;
		}
		StringBuilder builder = new StringBuilder();
		builder.append("^.*((");
		String tagNames = taskTags.stream().map(it -> Pattern.quote(it.getName())).collect(joining("|"));
		builder.append(tagNames);
		builder.append(")(.*)?)$");
		pattern = Pattern.compile(builder.toString(), flags);
	}
	return pattern;
}
 

int getCompileFlags(ProcessContext context) {
    int flags = (context.getProperty(UNIX_LINES).asBoolean() ? Pattern.UNIX_LINES : 0)
            | (context.getProperty(CASE_INSENSITIVE).asBoolean() ? Pattern.CASE_INSENSITIVE : 0)
            | (context.getProperty(COMMENTS).asBoolean() ? Pattern.COMMENTS : 0)
            | (context.getProperty(MULTILINE).asBoolean() ? Pattern.MULTILINE : 0)
            | (context.getProperty(LITERAL).asBoolean() ? Pattern.LITERAL : 0)
            | (context.getProperty(DOTALL).asBoolean() ? Pattern.DOTALL : 0)
            | (context.getProperty(UNICODE_CASE).asBoolean() ? Pattern.UNICODE_CASE : 0)
            | (context.getProperty(CANON_EQ).asBoolean() ? Pattern.CANON_EQ : 0)
            | (context.getProperty(UNICODE_CHARACTER_CLASS).asBoolean() ? Pattern.UNICODE_CHARACTER_CLASS : 0);
    return flags;
}
 

/**
 * @param obj1
 * @param obj2
 * @return true x matches Javascript pattern y
 * @throws BirtException
 * @throws DataException
 */
private static boolean match( Object obj1, Object obj2 )
		throws BirtException
{
	if ( obj2 == null )
	{
		return false;
	}
	if ( obj1 == null )
	{
		return false;
	}
	String sourceStr = obj1.toString( );
	String pattern = obj2.toString( );
	
	// Pattern can be one of the following:
	// (1)Java regular expression pattern
	// (2)JavaScript RegExp construction syntax: "/RegExpr/[flags]", where flags 
	// can be a combination of 'g', 'm', 'i'
	Matcher jsReExprMatcher = getJSReExprPatternMatcher( pattern ); 
	int flags = 0;
	if ( jsReExprMatcher.matches( ) )
	{
		// This is a Javascript syntax
		// Get the flags; we only expect "m", "i", "g"
		String flagStr = pattern.substring( jsReExprMatcher.start( 2 ),
				jsReExprMatcher.end( 2 ) );
		for ( int i = 0; i < flagStr.length( ); i++ )
		{
			switch ( flagStr.charAt( i ) )
			{
				case 'm' :
					flags |= Pattern.MULTILINE;
					break;
				case 'i' :
					flags |= Pattern.CASE_INSENSITIVE;
					break;
				case 'g' :
					break; // this flag has no effect

				default :
					throw new BirtException( PLUGIN_ID,
							ResourceConstants.INVALID_REGULAR_EXPRESSION,
							pattern );
			}
		}
		pattern = pattern.substring( jsReExprMatcher.start( 1 ),
				jsReExprMatcher.end( 1 ) );
	}

	try
	{
		Matcher m = Pattern.compile( pattern, flags ).matcher( sourceStr );
		return m.find( );
	}
	catch ( PatternSyntaxException e )
	{
		throw new BirtException( PLUGIN_ID,
				ResourceConstants.INVALID_REGULAR_EXPRESSION,
				e );
	}
}
 

private static Pattern getPattern(final Value parg, final Value farg)
            throws IllegalArgumentException {
        
        if (debug) {
            log.debug("regex pattern: " + parg);
            log.debug("regex flags: " + farg);
        }
        
        //BLZG-1200 Literals with language types are not included in REGEX
        if (QueryEvaluationUtil.isPlainLiteral(parg)
                && (farg == null || QueryEvaluationUtil.isPlainLiteral(farg))) {

            final String ptn = ((Literal) parg).getLabel();
            String flags = "";
            if (farg != null) {
                flags = ((Literal)farg).getLabel();
            }
            int f = 0;
            for (char c : flags.toCharArray()) {
                // See https://www.w3.org/TR/xpath-functions/#flags
                switch (c) {
                    case 's':
                        f |= Pattern.DOTALL;
                        break;
                    case 'm':
                        f |= Pattern.MULTILINE;
                        break;
                    case 'i': {
                    /*
                     * The SPARQL REGEX operator is based on the XQuery REGEX
                     * operator. That operator should be Unicode clean by
                     * default. Therefore, when case-folding is specified, we
                     * also need to include the UNICODE_CASE option.
                     * 
                     * @see <a
                     * href="https://sourceforge.net/apps/trac/bigdata/ticket/655"
                     * > SPARQL REGEX operator does not perform case-folding
                     * correctly for Unicode data </a>
                     */
                        f |= Pattern.CASE_INSENSITIVE;
                        f |= Pattern.UNICODE_CASE;
                        break;
                    }
                    case 'x':
                        f |= Pattern.COMMENTS;
                        break;
                    case 'd':
                        f |= Pattern.UNIX_LINES;
                        break;
                    case 'u': // Implicit with 'i' flag.
//                      f |= Pattern.UNICODE_CASE;
                        break;
                    case 'q':
                        f |= Pattern.LITERAL;
                        break;
                    default:
                        throw new IllegalArgumentException();
                }
            }
            final Pattern pattern = Pattern.compile(ptn, f);
            return pattern;
        }
        
        throw new IllegalArgumentException();
        
    }
 

private Pattern compilePattern(String sectionName) {
    int flags = Pattern.DOTALL | Pattern.MULTILINE;
    return Pattern.compile(".*^\\s*?//\\s*?KEEP " + sectionName + ".*?\n(.*?)^\\s*// KEEP " + sectionName
            + " END.*?\n", flags);
}
 

@Override
public Object call(String methodName, List<Object> args) {
    int flags = 0;
    for (char c : modifier.toCharArray()) {
        switch (c) {
            case 'g':
                //global (??)
                break;
            case 'i':
                flags |= Pattern.CASE_INSENSITIVE;
                break;
            case 's':
                flags |= Pattern.DOTALL;
                break;
            case 'm':
                flags |= Pattern.MULTILINE;
                break;
            case 'x':
                flags |= Pattern.COMMENTS; //?
                break;
            default:
                //?
                break;
        }
    }
    Pattern p = Pattern.compile(pattern, flags);
    switch (methodName) {
        case "exec":
            String estr = EcmaScript.toString(args.get(0));
            Matcher m = p.matcher(estr);
            if (m.find()) {
                List<Object> avals = new ArrayList<>();
                for (int i = 0; i <= m.groupCount(); i++) {
                    avals.add(m.group(i));
                }
                ArrayType a = new ArrayType(avals);
                a.setAttribute("input", estr);
                a.setAttribute("index", m.start());
                return a;
            } else {
                return Null.INSTANCE;
            }
        case "test":
            String tstr = EcmaScript.toString(args.get(0));
            return p.matcher(tstr).find(); //boolean
    }
    return Undefined.INSTANCE; //?
}
 

/**
 * Determines whether the two operands match according to the <code>regex</code> operator.
 *
 * @return <tt>true</tt> if the operands match according to the <tt>regex</tt> operator, <tt>false</tt> otherwise.
 */
public Value evaluate(Regex node, BindingSet bindings)
		throws QueryEvaluationException {
	Value arg = evaluate(node.getArg(), bindings);
	Value parg = evaluate(node.getPatternArg(), bindings);
	Value farg = null;
	ValueExpr flagsArg = node.getFlagsArg();
	if (flagsArg != null) {
		farg = evaluate(flagsArg, bindings);
	}

	if (QueryEvaluationUtil.isStringLiteral(arg) && QueryEvaluationUtil.isSimpleLiteral(parg)
			&& (farg == null || QueryEvaluationUtil.isSimpleLiteral(farg))) {
		String text = ((Literal) arg).getLabel();
		String ptn = ((Literal) parg).getLabel();
		String flags = "";
		if (farg != null) {
			flags = ((Literal) farg).getLabel();
		}
		// TODO should this Pattern be cached?
		int f = 0;
		for (char c : flags.toCharArray()) {
			switch (c) {
			case 's':
				f |= Pattern.DOTALL;
				break;
			case 'm':
				f |= Pattern.MULTILINE;
				break;
			case 'i':
				f |= Pattern.CASE_INSENSITIVE;
				f |= Pattern.UNICODE_CASE;
				break;
			case 'x':
				f |= Pattern.COMMENTS;
				break;
			case 'd':
				f |= Pattern.UNIX_LINES;
				break;
			case 'u':
				f |= Pattern.UNICODE_CASE;
				break;
			case 'q':
				f |= Pattern.LITERAL;
				break;
			default:
				throw new ValueExprEvaluationException(flags);
			}
		}
		Pattern pattern = Pattern.compile(ptn, f);
		boolean result = pattern.matcher(text).find();
		return BooleanLiteral.valueOf(result);
	}

	throw new ValueExprEvaluationException();
}
 

private boolean isSingleLinePattern(Pattern pattern) {
  return (pattern.flags() & Pattern.MULTILINE) == 0;
}