import org.joni.Option; //导入依赖的package包/类
private int patternToJoniFlags(int flags) {
  int newFlags = 0;
  if ((flags & Pattern.CASE_INSENSITIVE) != 0) {
    newFlags |= Option.IGNORECASE;
  }
  if ((flags & Pattern.DOTALL) != 0) {
    // This does NOT mean Pattern.MULTILINE
    newFlags |= Option.MULTILINE;
  }
  if ((flags & Pattern.MULTILINE) != 0) {
    // This is what Java 8's Nashorn engine does when using joni and
    // translating Pattern's MULTILINE flag
    newFlags &= ~Option.SINGLELINE;
    newFlags |= Option.NEGATE_SINGLELINE;
  }
  return newFlags;
}
 

import org.joni.Option; //导入依赖的package包/类
@SuppressWarnings("unchecked")
Grok(Map<String, String> patternBank, String grokPattern, boolean namedCaptures) {
    this.patternBank = patternBank;
    this.namedCaptures = namedCaptures;

    this.expression = toRegex(grokPattern);
    byte[] expressionBytes = expression.getBytes(StandardCharsets.UTF_8);
    this.compiledExpression = new Regex(expressionBytes, 0, expressionBytes.length, Option.DEFAULT, UTF8Encoding.INSTANCE);
}
 

import org.joni.Option; //导入依赖的package包/类
/**
 * converts a grok expression into a named regex expression
 *
 * @return named regex expression
 */
public String toRegex(String grokPattern) {
    byte[] grokPatternBytes = grokPattern.getBytes(StandardCharsets.UTF_8);
    Matcher matcher = GROK_PATTERN_REGEX.matcher(grokPatternBytes);

    int result = matcher.search(0, grokPatternBytes.length, Option.NONE);
    if (result != -1) {
        Region region = matcher.getEagerRegion();
        String namedPatternRef = groupMatch(NAME_GROUP, region, grokPattern);
        String subName = groupMatch(SUBNAME_GROUP, region, grokPattern);
        // TODO(tal): Support definitions
        String definition = groupMatch(DEFINITION_GROUP, region, grokPattern);
        String patternName = groupMatch(PATTERN_GROUP, region, grokPattern);
        String pattern = patternBank.get(patternName);

        String grokPart;
        if (namedCaptures && subName != null) {
            grokPart = String.format(Locale.US, "(?<%s>%s)", namedPatternRef, pattern);
        } else if (!namedCaptures) {
            grokPart = String.format(Locale.US, "(?<%s>%s)", patternName + "_" + String.valueOf(result), pattern);
        } else {
            grokPart = String.format(Locale.US, "(?:%s)", pattern);
        }

        String start = new String(grokPatternBytes, 0, result, StandardCharsets.UTF_8);
        String rest = new String(grokPatternBytes, region.end[0], grokPatternBytes.length - region.end[0], StandardCharsets.UTF_8);
        return start + toRegex(grokPart + rest);
    }

    return grokPattern;
}
 

import org.joni.Option; //导入依赖的package包/类
/**
 * Matches and returns any named captures within a compiled grok expression that matched
 * within the provided text.
 *
 * @param text the text to match and extract values from.
 * @return a map containing field names and their respective coerced values that matched.
 */
public Map<String, Object> captures(String text) {
    byte[] textAsBytes = text.getBytes(StandardCharsets.UTF_8);
    Map<String, Object> fields = new HashMap<>();
    Matcher matcher = compiledExpression.matcher(textAsBytes);
    int result = matcher.search(0, textAsBytes.length, Option.DEFAULT);
    if (result != -1 && compiledExpression.numberOfNames() > 0) {
        Region region = matcher.getEagerRegion();
        for (Iterator<NameEntry> entry = compiledExpression.namedBackrefIterator(); entry.hasNext();) {
            NameEntry e = entry.next();
            String groupName = new String(e.name, e.nameP, e.nameEnd - e.nameP, StandardCharsets.UTF_8);
            for (int number : e.getBackRefs()) {
                if (region.beg[number] >= 0) {
                    String matchValue = new String(textAsBytes, region.beg[number], region.end[number] - region.beg[number],
                        StandardCharsets.UTF_8);
                    GrokMatchGroup match = new GrokMatchGroup(groupName, matchValue);
                    fields.put(match.getName(), match.getValue());
                    break;
                }
            }

        }
        return fields;
    } else if (result != -1) {
        return fields;
    }
    return null;
}
 

import org.joni.Option; //导入依赖的package包/类
private int joniToPatternFlags(int flags) {
  int newFlags = 0;
  if ((flags & Option.IGNORECASE) != 0) {
    newFlags |= Pattern.CASE_INSENSITIVE;
  }
  // This does NOT mean Pattern.MULTILINE, this is equivalent to Pattern.DOTALL
  if ((flags & Option.MULTILINE) != 0) {
    newFlags |= Pattern.DOTALL;
  }
  // This means Pattern.MULTILINE. Nice
  if ((flags & Option.NEGATE_SINGLELINE) != 0) {
    newFlags |= Pattern.MULTILINE;
  }
  return newFlags;
}
 

import org.joni.Option; //导入依赖的package包/类
public OnigRegExp(String source) {
	lastSearchStrUniqueId = null;
	lastSearchPosition = -1;
	lastSearchResult = null;
	byte[] pattern = source.getBytes(StandardCharsets.UTF_8);
	this.regex = new Regex(pattern, 0, pattern.length, Option.CAPTURE_GROUP, UTF8Encoding.INSTANCE, Syntax.DEFAULT,
			WarnCallback.DEFAULT);
}
 

import org.joni.Option; //导入依赖的package包/类
private OnigResult Search(byte[] data, int position, int end) {
	Matcher matcher = regex.matcher(data);
	int status = matcher.search(position, end, Option.DEFAULT);
	if (status != Matcher.FAILED) {
		Region region = matcher.getEagerRegion();
		return new OnigResult(region, -1);
	}
	return null;
}
 

import org.joni.Option; //导入依赖的package包/类
public RegexpOpExp(ParserLiteral left, ParserLiteral right, int operator)
{
    super(left, right, operator);

    byte[] pattern = (((StringLiteral)right).val).getBytes(StandardCharsets.UTF_8);
    this.regex = new Regex(pattern, 0, pattern.length, Option.NONE, UTF8Encoding.INSTANCE);

    if (! left.isString()) {
        throw new ConfigException(String.format("\"%s\" is not a String column", ((IdentifierLiteral)left).name));
    }
}
 

import org.joni.Option; //导入依赖的package包/类
public boolean eval(PageReader pageReader)
{
    byte[] l = left.getString(pageReader).getBytes(StandardCharsets.UTF_8);
    Matcher matcher = regex.matcher(l);
    int result = matcher.search(0, l.length, Option.DEFAULT);
    return result != -1;
}
 

import org.joni.Option; //导入依赖的package包/类
private List<Module> getSingleModuleForPath(File child) {
    if(child.getName().endsWith(".rb")) {
        try {
            @SuppressWarnings("unchecked")
            List<String> lines = FileUtils.readLines(child);
            if(lines.size() > 1) {
                String regex = lines.get(0);
                regex = regex.substring(1, regex.length()).trim();

                String triggers = lines.get(1);
                triggers = triggers.substring(1, triggers.length()).trim();

                String filename = child.getName();
                String name = filename.substring(0, filename.length() - 3);
                MewtwoMain.mewtwoLogger.info("Adding module " + name + " - regex = " + regex +
                        ", triggers = "+ triggers);

                Module m = new Module(
                        new Regex(regex.getBytes(), 0, regex.length(), Option.NONE, UTF8Encoding.INSTANCE),
                        Arrays.asList(triggers.split(",")), filename.substring(0, filename.length() - 3),
                        filename);

                return Arrays.asList(m);
            } else MewtwoMain.mewtwoLogger.info("Skipping file " + child.getAbsolutePath() + " - shorter than two lines!");
        } catch (Throwable t) {
            MewtwoMain.mewtwoLogger.error("Exception while parsing modules for " + child.getAbsolutePath() + "! ", t);
        }

    } else MewtwoMain.mewtwoLogger.info("Skipping file " + child.getAbsolutePath() + " - not a ruby file!");

    return Arrays.asList();
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
protected Regex generate(String i) {
    byte[] pattern = getBytesUTF16LE(i);
    return new Regex(pattern, 0, pattern.length, Option.NONE, UTF16LEEncoding.INSTANCE);
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
protected boolean match(Regex pattern, String searched) {
    byte[] str = getBytesUTF16LE(searched);
    Matcher matcher = pattern.matcher(str);
    return matcher.search(0, str.length, Option.DEFAULT) != -1;
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
protected Regex generate(String i) {
    byte[] pattern = getBytesAscii(i);
    return new Regex(pattern, 0, pattern.length, Option.NONE, ASCIIEncoding.INSTANCE);
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
protected boolean match(Regex pattern, String searched) {
    byte[] str = getBytesAscii(searched);
    Matcher matcher = pattern.matcher(str);
    return matcher.search(0, str.length, Option.DEFAULT) != -1;
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
protected Regex generate(String i) {
    byte[] pattern = i.getBytes();
    return new Regex(pattern, 0, pattern.length, Option.NONE, UTF8Encoding.INSTANCE);
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
protected boolean match(Regex pattern, String searched) {
    byte[] str = searched.getBytes();
    Matcher matcher = pattern.matcher(str);
    return matcher.search(0, str.length, Option.DEFAULT) != -1;
}
 

import org.joni.Option; //导入依赖的package包/类
public boolean activatesOn(String message, String trigger) {
    return (regex.matcher(message.getBytes()).search(0, message.length(), Option.DEFAULT) == 0)
            && triggers.contains(trigger);
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
public boolean find(int start) {
    return update(matcher.search(byteIndex(start), byteLength, Option.NONE));
}
 

import org.joni.Option; //导入依赖的package包/类
@Override
public boolean matches(int start) {
    return update(matcher.match(byteIndex(start), byteLength, Option.NONE));
}
 

import org.joni.Option; //导入依赖的package包/类
/**
 * Checks whether a specific text matches the defined grok expression.
 *
 * @param text the string to match
 * @return true if grok expression matches text, false otherwise.
 */
public boolean match(String text) {
    Matcher matcher = compiledExpression.matcher(text.getBytes(StandardCharsets.UTF_8));
    int result = matcher.search(0, text.length(), Option.DEFAULT);
    return (result != -1);
}