import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<List<EnumMemberExp>> enumMembersMany() {
       return enumMembers00().many().sepBy(term(","))
               .map(new org.codehaus.jparsec.functors.Map<List<List<EnumMemberExp>>, List<EnumMemberExp>>() {
                   @Override
                   public List<EnumMemberExp> map(List<List<EnumMemberExp>> arg0) {
					List<EnumMemberExp> cc = new ArrayList<>();
					for(List<EnumMemberExp> sub: arg0) {
						if (sub.size() > 1) {
							throw new IllegalArgumentException("Enum members must be separated by commas");
						}
						for(EnumMemberExp re: sub) {
							cc.add(re);
						}
					}
					return cc;
                   }
               });    
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<PackageExp> packageDecl() {
    return Parsers.sequence(term("package"), VarParser.ident().many().sepBy(term(".")).
            map(new org.codehaus.jparsec.functors.Map<List<List<IdentExp>>, PackageExp>() {
                @Override
                public PackageExp map(List<List<IdentExp>> arg0) {
                    StringBuilder sb = new StringBuilder();
                    boolean flag = false;
                    if (! arg0.isEmpty()) {
                        for(List<IdentExp> sublist : arg0) {
                            if (! sublist.isEmpty()) {
                                if (flag) {
                                    sb.append('.');
                                }
                                sb.append(sublist.get(0).val);
                                flag = true;
                            }
                        }
                    }
                    return new PackageExp(sb.toString());
                }
            }));
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<ImportExp> importDecl() {
    return Parsers.sequence(term("import"), VarParser.ident().many().sepBy(term(".")).
            map(new org.codehaus.jparsec.functors.Map<List<List<IdentExp>>, ImportExp>() {
                @Override
                public ImportExp map(List<List<IdentExp>> arg0) {
                    StringBuilder sb = new StringBuilder();
                    boolean flag = false;
                    if (! arg0.isEmpty()) {
                        for(List<IdentExp> sublist : arg0) {
                            if (! sublist.isEmpty()) {
                                if (flag) {
                                    sb.append('.');
                                }
                                sb.append(sublist.get(0).val);
                                flag = true;
                            }
                        }
                    }
                    return new ImportExp(sb.toString());
                }
            }));
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<List<StructMemberExp>> structMembersMany() {
       return structMembers00().many().sepBy(term(","))
               .map(new org.codehaus.jparsec.functors.Map<List<List<StructMemberExp>>, List<StructMemberExp>>() {
                   @Override
                   public List<StructMemberExp> map(List<List<StructMemberExp>> arg0) {
					List<StructMemberExp> cc = new ArrayList<>();
					for(List<StructMemberExp> sub: arg0) {
						if (sub.size() > 1) {
							throw new IllegalArgumentException("Struct members must be separated by commas");
						}
						for(StructMemberExp re: sub) {
							cc.add(re);
						}
					}
					return cc;
                   }
               });    
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<ListAssignExp> listvalueassign() {
	return Parsers.between(term("["), listmemberRef.lazy().many().sepBy(term(",")), term("]")).
			map(new org.codehaus.jparsec.functors.Map<List<List<Exp>>, ListAssignExp>() {
				@Override
				public ListAssignExp map(List<List<Exp>> arg0) {
					List<Exp> list = new ArrayList<>();
					if (! arg0.isEmpty()) {
						for(List<Exp> sublist : arg0) {
							if (! sublist.isEmpty()) {
								list.add(sublist.get(0));
							}
						}
					}
					return new ListAssignExp(list);
				}
			});
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<StructAssignExp> structvalueassign() {
	return Parsers.between(term("{"), 
			structmemberRef.lazy().many().sepBy(term(",")), term("}")).
			map(new org.codehaus.jparsec.functors.Map<List<List<Exp>>, StructAssignExp>() {
				@Override
				public StructAssignExp map(List<List<Exp>> arg0) {
					List<Exp> list = new ArrayList<>();
					for(List<Exp> sublist : arg0) {
						if (! sublist.isEmpty()) {
							list.add(sublist.get(0));
						}
					}
					return new StructAssignExp(list);
				}
			});
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<List<ViewMemberExp>> memberMany() {
       return member().many().sepBy(term(","))
               .map(new org.codehaus.jparsec.functors.Map<List<List<ViewMemberExp>>, List<ViewMemberExp>>() {
                   @Override
                   public List<ViewMemberExp> map(List<List<ViewMemberExp>> arg0) {
					List<ViewMemberExp> cc = new ArrayList<>();
					for(List<ViewMemberExp> sub: arg0) {
						if (sub.size() > 1) {
							throw new IllegalArgumentException("View members must be separated by commas");
						}
						for(ViewMemberExp re: sub) {
							cc.add(re);
						}
					}
					return cc;
                   }
               });    
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public static Parser<List<RuleExp>> ruleMany() {
       return ruleExpr().many().sepBy(term(","))
               .map(new org.codehaus.jparsec.functors.Map<List<List<RuleExp>>, List<RuleExp>>() {
                   @Override
                   public List<RuleExp> map(List<List<RuleExp>> arg0) {
					List<RuleExp> cc = new ArrayList<>();
					for(List<RuleExp> sub: arg0) {
						if (sub.size() > 1) {
							throw new IllegalArgumentException("Rules must be separated by commas");
						}
						for(RuleExp re: sub) {
							cc.add(re);
						}
					}
					return cc;
                   }
               });    
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
static Parser<Expression> arithmetic(Parser<Expression> atom) {
  Reference<Expression> reference = Parser.newReference();
  Parser<Expression> operand =
      Parsers.or(paren(reference.lazy()), functionCall(reference.lazy()), atom);
  Parser<Expression> parser = new OperatorTable<Expression>()
      .infixl(binary("/", Op.AGG_DIV), 5)
      .infixl(binary("<", Op.LESS), 7)
      .infixl(binary("<=", Op.LESS_EQ), 7)
      .infixl(binary("=", Op.EQ), 7)
      .infixl(binary("!=", Op.NOT_EQ), 7)
      .infixl(binary(">", Op.GREATER), 7)
      .infixl(binary(">=", Op.GREATER_EQ), 7)
      .infixl(binary("+", Op.PLUS), 10)
      .infixl(binary("-", Op.MINUS), 10)
      .infixl(binary("*", Op.MUL), 20)
      .infixl(binary("\\", Op.DIV), 20)
      .infixl(binary("%", Op.MOD), 20)
      .prefix(unary("-", Op.NEG), 30)
      .build(operand);
  reference.set(parser);
  return parser;
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
/**
 * Parser for internal array class names such as {@code [Z}, {@code [[[Ljava.lang.String;} etc.
 *
 * <p>.java files can only use {@code int[]} format, not the internal format. But we have to
 * be able to parse from internal format because {@link Type#toString} can produce it.
 */
private Parser<Class<?>> arrayClass() {
  Parser<Class<?>> arrayType = FQN.next(name -> {
      // Only invoked when we already see a "[" at the beginning.
      Class<?> primitiveArray = PRIMITIVE_ARRAY_TYPES.get("[" + name);
      if (primitiveArray != null) return Parsers.constant(primitiveArray);
      if (name.startsWith("L") && name.endsWith(";")) {
        String className = name.substring(1, name.length() - 1);
        return Parsers.constant(Types.newArrayType(loadClass(className)));
      } else {
        return Parsers.expect("array class internal name");
      }
    });
  return TERMS.token("[") // must be an array internal format from this point on.
      .next(arrayType.prefix(TERMS.token("[").retn(Types::newArrayType)));
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
static <T extends ExprNode> Parser<ExprNode> paren (Parser<T> e)
{
    return new Mapper<ExprNode>() {
        @SuppressWarnings("unused")
        public ExprNode map (T node)
        {
            ExprNode r = node;

            if (r == null) {
                r = new ConsNode.Tuple(Collections.<ExprNode>emptyList());
            } else if (!(r instanceof ConsNode.Tuple) && !(r instanceof PNode)) {
                r = new PNode(node);
            }

            return r;
        }
    }.sequence(any(e).optional().between(term("("), term(")")));
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
static <T extends ExprNode> Parser<InvArgListNode> argumentList (Parser<T> e)
{
    Parser<InvArgNode> namedArg = Mapper.<InvArgNode>curry(InvArgNode.Named.class).sequence(NAME_PARSER, term("="), e);
    Parser<InvArgNode> arg = namedArg.or(Mapper.curry(InvArgNode.Positional.class).sequence(e));

    Parser<InvArgNode> manyArgs = Mapper.<InvArgNode>curry(InvArgNode.ManyArgs.class).sequence(term("*"), e);
    Parser<InvArgNode> keywordArgs = Mapper.<InvArgNode>curry(InvArgNode.KeywordArgs.class).sequence(term("**"), e);

    /* Gleefully stolen from the Python grammar file. */
    Parser<List<InvArgNode>> parser;
    parser = Parsers2.collect(
            arg.sepEndBy(term(",")),
            Parsers.or(
                    Parsers2.collectN1(manyArgs, term(",").next(namedArg.sepBy1(term(","))).atomic().optional(), term(",").next(keywordArgs).optional()),
                    Parsers2.list(keywordArgs),
                    Parsers2.list(arg.followedBy(term(",")).optional())));
    parser = Parsers2.filter(parser, Predicates.<InvArgNode>notNull());

    return Mapper.curry(InvArgListNode.class).sequence(parser);
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
Parser<DataNode> data ()
{
    return Marker.mark(Mapper.curry(DataNode.class).sequence(
            new Mapper<String>()
            {
                public String map(Stripping stripLeading, List<String> bodies, Stripping stripTrailing)
                {
                    String body = Joiner.on("").join(bodies);

                    if (stripLeading == Stripping.ALL)
                        body = CharMatcher.WHITESPACE.trimLeadingFrom(body);

                    if (stripTrailing == Stripping.ALL)
                        body = CharMatcher.WHITESPACE.trimTrailingFrom(body);
                    else if (stripTrailing == Stripping.LINE)
                        body = LINE_STRIP_PATTERN.matcher(body).replaceFirst("");

                    return body;
                }
            }.sequence(strip().optional(Stripping.NONE), Parsers.or(TagParsers.data(), Parsers.EOF.retn("")).many1(), strip().optional(Stripping.NONE))));
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
@SafeVarargs
public final <U extends T> Parser<?> parserOf (final U... expected)
{
    if (expected.length == 0) {
        return Parsers.never();
    } else if (expected.length == 1) {
        return parserOf(expected[0]);
    }

    Parser<?>[] parsers = new Parser<?>[expected.length];
    for (int i = 0; i < expected.length; i++)
    {
        parsers[i] = parserOf(expected[i]);
    }
    return Parsers.sequence(parsers);
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
public <T extends StmtNode> StatementParser mapWith (final Map<ContentMatchMap, T> map)
{
    checkNotNull(map);

    return new StatementParser()
    {
        @Override
        public String getPackage()
        {
            return callables.getPackageName();
        }

        @Override
        public String getName ()
        {
            return callables.getName();
        }

        @Override
        public Parser<T> parser (Cont cont)
        {
            ContentParserBuilder content = contents.getContent();
            return cont.name().next(content.parser().map(map));
        }
    };
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
private Parser<Void> indexsetCommand() {
	return Parsers.sequence(token("indexset"), STRING, STRING,
			token("list").next(token("(")).next(STRING.sepBy(token(",")))
					.followedBy(token(")")),
			new Map4<Token, String, String, List<String>, Void>() {
				public Void map(Token id, String full, String name,
						List<String> set) {
					if (indexSets.containsKey(full)) {
						throw createException("Redefining index set '%s'",
								name);
					}
					indexSets.put(full, new IndexSet(name, set));
					return null;
				}
			});
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
private static Parser<Expression> applicationDebugParser(
		Parser<Expression> expParser) {
	return Parsers
			.sequence(
					token("application_debug").next(token("("))
							.next(STRING),
					token(",").next(STRING),
					token(",").next(STRING),
					token(",").next(expParser),
					token(",").next(expParser).many()
							.followedBy(token(")")),
					new Map5<String, String, String, Expression, List<Expression>, Expression>() {
						public Expression map(String text, String fullText,
								String trace, Expression fun,
								List<Expression> args) {
							return new ApplicationDebug(text, fullText,
									trace.equals("true"), fun, args);
						}
					});
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
protected Parser<QlField> fieldOrFunctionParser() {
	Parser.Reference<QlField> fieldOrFuncParserRef = Parser.newReference();
	Parser<Tuple3<String, QlField, Boolean>> simpleParser = simpleFieldParser();
	Parser<Tuple3<String, QlField, Boolean>> fieldParser = fieldParser(fieldOrFuncParserRef);
	Parser<QlField> fieldOrFuncParser = 
			Parsers.or(functionParser(fieldOrFuncParserRef), fieldParser, 
					simpleParser).map(
			new Map<Tuple3<String, QlField, Boolean>, QlField>() {
				@Override
				public QlField map(Tuple3<String, QlField, Boolean> fieldInfo) {
					return QlField.create(null, fieldInfo.a, fieldInfo.b,
							fieldInfo.c);
				}
			});
	fieldOrFuncParserRef.lazySet(fieldOrFuncParser);
	return fieldOrFuncParser;
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
protected Parser<QlField> qualifiedFieldOrFunctionParser() {
	Parser.Reference<QlField> fieldOrFuncParserRef = Parser.newReference();
	Parser<Tuple3<String, QlField, Boolean>> simpleParser = simpleFieldParser();
	Parser<Tuple3<String, QlField, Boolean>> fieldParser = fieldParser(fieldOrFuncParserRef);
	Parser<String> qualifierParser = regex("[a-zA-Z]+\\s+", false)
			.followedBy(regex("from", false).not().peek()).atomic().optional(null);
	Parser<QlField> fieldOrFuncParser = Parsers.pair(qualifierParser,
			Parsers.or(functionParser(fieldOrFuncParserRef), fieldParser, 
					simpleParser)).map(
			new Map<Pair<String, Tuple3<String, QlField, Boolean>>, QlField>() {
				@Override
				public QlField map(
						Pair<String, Tuple3<String, QlField, Boolean>> fieldInfo) {
					String qualifier = fieldInfo.a == null ? null : fieldInfo.a.trim();
					return QlField.create(qualifier, fieldInfo.b.a, fieldInfo.b.b,
							fieldInfo.b.c);
				}
			});
	fieldOrFuncParserRef.lazySet(fieldOrFuncParser);
	return fieldOrFuncParser;
}
 

import org.codehaus.jparsec.Parser; //导入依赖的package包/类
private static Parser<ExpressionNode> letParser(
        Parser<ExpressionNode> expParser) {
    return Parsers
            .sequence(
            token("let"),
            letBindingParser(expParser).sepBy(token(",")),
            token("in").next(expParser).followedBy(token("end")),
            new Map3<Token, List<Callback<ExpressionNode, ExpressionNode>>, ExpressionNode, ExpressionNode>() {
        public ExpressionNode map(
                Token let,
                List<Callback<ExpressionNode, ExpressionNode>> bindings,
                ExpressionNode body) {
            ExpressionNode expr = body;
            for (int i = bindings.size() - 1; 0 <= i; i--) {
                expr = bindings.get(i).call(expr);
            }
            return expr;
        }
    });
}