import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
private Parser<SelectStatement> selectStatement()
{
  return Scanners.stringCaseInsensitive("select")
      .next(WHITESPACE)
      .next(queryExpression())
      .map(query -> new SelectStatement(Main.current.helper().searcher().search(query.substring(1, query.length()-1))));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
private Parser<FindStatement> findStatement()
{
  return Scanners.stringCaseInsensitive("find")
      .next(WHITESPACE)
      .next(queryExpression())
      .map(query -> new FindStatement(Main.current.helper().searcher().search(query.substring(1, query.length()-1))));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
/** Parses {@code string} to a {@link TypeToken}. */
public TypeToken<?> parse(String string) throws ParserException {
  Parser.Reference<Type> ref = Parser.newReference();
  Parser<Type> type = Parsers.or(
      wildcardType(ref.lazy()), parameterizedType(ref.lazy()), arrayClass(), rawType());
  ref.set(type.postfix(TERMS.phrase("[", "]").retn(Types::newArrayType)));
  return TypeToken.of(
      ref.get().from(TERMS.tokenizer(), Scanners.WHITESPACES.optional()).parse(string));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
protected Parser<Integer> regexIntegerPair(String keyword, boolean isCaseSensitive) {
	return paddedRegex(keyword, false, isCaseSensitive).next(Scanners.INTEGER)
			.map(new Map<String, Integer>() {
				@Override
				public Integer map(String arg0) {
					return Integer.parseInt(arg0);
				}
			});
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
@Override
public int match(String input) {
  Parser<List<List<String>>> p = ((Scanners.isChar('a').many1().followedBy(Scanners.isChar('b')).source()).many1()
      .followedBy(Scanners.isChar('c'))).many1();
  List<List<String>> out = p.parse(input);
  return out.size();
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
private Parser<String> queryExpression() { 
return Parsers.or(
  Scanners.SINGLE_QUOTE_STRING
); }
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
protected Parser<String> regex(String pattern, String name, boolean isCaseSensitive) {
	Pattern p = Pattern.compile(pattern, isCaseSensitive ? 0 : CASE_INSENSITIVE);
	return Scanners.pattern(Patterns.regex(p), name).source();
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Any> any() {
  return Scanners.isChar('.').map(Maps.constant(new Any()));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Eos> eos() {
  final Parser<Void> p = Scanners.isChar('$');
  return p.map(Maps.constant(new Node.Eos()));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Group> group() {
  final Parser<Regex> p =
      Parsers.between(Scanners.isChar('('), regexRef.lazy(), Scanners.isChar(')'));
  return p.map(fromConstructor(Group.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Node.NegativeSet> negativeSet() {
  final Parser<List<SetItem>> p =
      Parsers.between(Scanners.string("[^"), setItems(), Scanners.isChar(']'));
  return p.map(fromConstructor(Node.NegativeSet.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Node.Optional> optional() {
  final Parser<? extends Elementary> p = elementary().followedBy(Scanners.isChar('?'));
  return p.map(fromConstructor(Node.Optional.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Node.Plus> plus() {
  final Parser<? extends Elementary> p = elementary().followedBy(Scanners.isChar('+'));
  return p.map(fromConstructor(Node.Plus.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Node.PositiveSet> positiveSet() {
  final Parser<List<SetItem>> p =
      Parsers.between(Scanners.isChar('['), setItems(), Scanners.isChar(']'));
  return p.map(fromConstructor(Node.PositiveSet.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Node.Star> star() {
  final Parser<? extends Elementary> p = elementary().followedBy(Scanners.isChar('*'));
  return p.map(fromConstructor(Node.Star.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
Parser<Node.NonGreedyStar> nonGreedyStar() {
  final Parser<? extends Elementary> p = elementary().followedBy(Scanners.string("*?"));
  return p.map(fromConstructor(Node.NonGreedyStar.class));
}
 

import org.codehaus.jparsec.Scanners; //导入依赖的package包/类
/**
 * All added whitespace is optional. To require white space, you should add it to your parser inline.
 * @param parser The parser to wrap in optional white space.
 * @param leadingWhitespaces If optional white space should prepend the provided parser.
 * @return The parser that was wrapped in optional white space.
 */
protected <T> Parser<T> padWithWhitespace(Parser<T> parser, boolean leadingWhitespaces) {
	return leadingWhitespaces 
			? Scanners.WHITESPACES.optional().next(parser).followedBy(Scanners.WHITESPACES.optional())
			: parser.followedBy(Scanners.WHITESPACES.optional());
}