import org.parboiled.errors.ParseError; //导入依赖的package包/类
public void setUp() {
    String input = getFile("src/test/resources/test.query");
    System.out.println(input);
    DELPParser parser = Parboiled.createParser(DELPParser.class);

    parser.setResolver(IRIResolver.create());

    ParsingResult<OBEPQuery> result = new ReportingParseRunner(parser.Query()).run(input);

    if (result.hasErrors()) {
        System.out.println("Errors have been found!");
        for (ParseError arg : result.parseErrors) {
            System.out.println(input.substring(0, arg.getStartIndex()) + "|->" + input.substring(arg.getStartIndex(), arg.getEndIndex()) + "<-|" + input.substring(arg.getEndIndex(), input.length() - 1));
        }
    }

    OBEPQueryImpl q = (OBEPQueryImpl) result.resultValue;
    for (EventDecl event : q.getEventCalculusDecls()) {
        EventCalculusDecl ecd = (EventCalculusDecl) event;
        System.out.println(ecd);
    }
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
public void setUp() {
    testEngine = new OBEPTestEngine();

    cep = new EventProcessorImpl();
    cep.init(testEngine);
    String input = getFile("src/test/resources/test2.query");
    DELPParser parser = Parboiled.createParser(DELPParser.class);

    parser.setResolver(IRIResolver.create());

    ParsingResult<OBEPQuery> result = new ReportingParseRunner(parser.Query()).run(input);

    if (result.hasErrors()) {
        System.out.println("Errors have been found!");
        for (ParseError arg : result.parseErrors) {
            System.out.println(input.substring(0, arg.getStartIndex()) + "|->" + input.substring(arg.getStartIndex(), arg.getEndIndex()) + "<-|" + input.substring(arg.getEndIndex(), input.length() - 1));
        }
    }

    OBEPQuery q = result.resultValue;
    cep.registerQuery(q);
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
protected void parseMatch(String input) {
    ParsingResult<?> result = reportingRunner.run(input);
    if (result.matched) {
        System.out.println(ParseTreeUtils.printNodeTree(result));
        final Properties pp = parser.getParsedProps();
        if (!pp.isEmpty()) {
            listPropsOrdered(pp);
        }
    } else {
        result = tracingRunner.run(input);
        System.out.println("\n\nParser did not match input:");
        for (ParseError pe : result.parseErrors) {
            System.out.format("\t%s%n", ErrorUtils.printParseError(pe));
        }
    }
    assertTrue(result.matched);
    assertFalse(result.hasErrors());
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
private static <T> void checkErrors(ParsingResult<T> result) {
		if (result.hasErrors()) {
			java.util.List<ParseError> errors=result.parseErrors;
			StringBuilder sb=new StringBuilder();
			for (ParseError error: errors) {
				InputBuffer ib=error.getInputBuffer();
				int start=error.getStartIndex();
				int end=error.getEndIndex();
				sb.append("Parse error at "+ib.getPosition(error.getStartIndex())+": "+ib.extract(start, end)+" ERR: "+ error.getErrorMessage()+ "IB:"+ib.extractLine(1));
//				sb.append("Parse error at "+ib.getPosition(0)+": "+ib.extract(start, end)+" ERR: "+ error.getErrorMessage());
//				sb.append(result.parseTreeRoot);
			}
			throw new Error(sb.toString());
		}
		
	}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected <T> T parse(Rule rule, String input) {
    ParsingResult<?> result;
    if (trace) {
        result = new TracingParseRunner<Object>(rule).run(input);
    } else {
        result = new ReportingParseRunner(rule).run(input);
    }

    if (!result.parseErrors.isEmpty()) {
        for (ParseError parseError : result.parseErrors) {
            System.out.println(ErrorUtils.printParseError(parseError));
        }
    } else if (trace) {
        System.out.println(printNodeTree(result) + '\n');
    }

    return (T) result.valueStack.pop();
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
@Override
protected void internalRun(CfgPropsParser.CfgPropsParserResult cfgResult, SchedulerEvent se, Document document, List<ErrorDescription> errors, Severity severity) {
    logger.fine("Highlighting syntax errors");
    try {
        final InputBuffer ibuf = cfgResult.getParbResult().inputBuffer;
        final List<ParseError> parseErrors = cfgResult.getParbResult().parseErrors;
        for (ParseError error : parseErrors) {
            String message = error.getErrorMessage() != null
                    ? error.getErrorMessage()
                    : error instanceof InvalidInputError
                            ? formatter.format((InvalidInputError) error)
                            : error.getClass().getSimpleName();
            ErrorDescription errDesc = ErrorDescriptionFactory.createErrorDescription(
                    severity,
                    message,
                    document,
                    document.createPosition(ibuf.getOriginalIndex(error.getStartIndex())),
                    document.createPosition(ibuf.getOriginalIndex(error.getEndIndex()))
            );
            errors.add(errDesc);
            if (canceled) {
                break;
            }
        }
    } catch (BadLocationException | ParseException ex) {
        Exceptions.printStackTrace(ex);
    }
    if (!errors.isEmpty()) {
        logger.log(Level.FINE, "Found {0} syntax errors", errors.size());
    }
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
@Test
    public void testCompareProps() throws IOException, URISyntaxException {
        System.out.println("\n--- compare props");
        try (InputStream is = getClass().getResourceAsStream("/load.properties")) {
            System.out.println("\nLOADED");
            Properties loaded = new Properties();
            loaded.load(is);
            listPropsOrdered(loaded);
            System.out.println("\nPARSED");
            final String strFile = readResource("/load.properties");
            ParsingResult pr = reportingRunner.run(strFile);
            final Properties parsed = parser.getParsedProps();
            listPropsOrdered(parsed);
            if (!pr.matched) {
//                pr = tracingRunner.run(strFile);
                System.out.println("\n\nParser did not match input:");
                for (Object err : reportingRunner.getParseErrors()) {
                    ParseError pe = (ParseError) err;
                    System.out.format("\t%s%n", ErrorUtils.printParseError(pe));
                }
            }
            assertTrue("Failed parsing", pr.matched);
            assertEquals("Different loaded/parsed sizes", loaded.size(), parsed.size());
            for (Map.Entry<Object, Object> entry : loaded.entrySet()) {
                assertTrue("Missing key in parsed", parsed.containsKey(entry.getKey()));
                assertEquals("Different loaded-parsed value", entry.getValue(), parsed.get(entry.getKey().toString()));
            }
        }
    }
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
private String toMessage(List<ParseError> parseErrors) {
    return StringUtils.join(Collections2.transform(parseErrors, new Function<ParseError, String>() {
        @Override
        public String apply(ParseError input) {
            return String.format("%d, %d -> %s", input.getStartIndex(), input.getEndIndex(), input.getErrorMessage());
        }
    }), "\n");
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
private void postProcess() {
	for (ParseError error : parsingResult.parseErrors) {
		int errStart = error.getStartIndex();
		int errEnd = error.getEndIndex();
		problems.add(new ParseProblem(new Position(mapPosition(errStart), mapPosition(errEnd)), error.toString()));
	}
	
	if (parsingResult.parseTreeRoot != null) {
		nodes.add(parsingResult.parseTreeRoot.getValue());
		gatherComments(parsingResult.parseTreeRoot);
	}
	
	comments = Collections.unmodifiableList(comments);
	nodes = Collections.unmodifiableList(nodes);
	problems = Collections.unmodifiableList(problems);
	
	rtrimPositions(nodes, comments);
	
	//TODO Write test case with javadoc intermixed with empty declares.
	//TODO test javadoc on a package declaration.
	//TODO javadoc in between keywords.
	
	associateJavadoc(comments, nodes);
	
	fixPositions(nodes);
	fixPositions(comments);
	
	parsed = true;
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
@Test
public void twoBounds() {
    DomainParserGrammar.DomainGrammar parser = Parboiled.createParser(DomainParserGrammar.DomainGrammar.class);
    ReportingParseRunner<?> runner = new ReportingParseRunner(parser.Domain());
    ParsingResult<?> result = runner.run("R(1.0:2.0),R(1.0:5.0)");

    if (result.hasErrors()) {
        for (ParseError e : result.parseErrors) {
            Assert.fail();
        }
    }
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
@Override
public String toString() {
    StringBuilder sb = new StringBuilder();

    sb.append(getMessage() + "\n");

    for (ParseError e : parseErrors) {
        sb.append("(at position " + e.getStartIndex() + ")");
    }

    return sb.toString();
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
private MatcherContext(InputBuffer inputBuffer, ValueStack<V> valueStack, List<ParseError> parseErrors,
                       MatchHandler matchHandler, MatcherContext<V> parent, int level, boolean fastStringMatching,
                       Set<MatcherPosition> memoizedMismatches) {
    this.inputBuffer = inputBuffer;
    this.valueStack = valueStack;
    this.parseErrors = parseErrors;
    this.matchHandler = matchHandler;
    this.parent = parent;
    this.level = level;
    this.fastStringMatching = fastStringMatching;
    this.memoizedMismatches = memoizedMismatches;
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
/**
 * Creates a new ParsingResult.
 *
 * @param matched       true if the rule matched the input
 * @param parseTreeRoot the parse tree root node
 * @param valueStack    the value stack of the parsing run
 * @param parseErrors   the list of parse errors
 * @param inputBuffer   the input buffer
 */
public ParsingResult(boolean matched, Node<V> parseTreeRoot, ValueStack<V> valueStack, List<ParseError> parseErrors,
                     InputBuffer inputBuffer) {
    this.matched = matched;
    this.parseTreeRoot = parseTreeRoot;
    this.valueStack = checkArgNotNull(valueStack, "valueStack");
    this.resultValue = valueStack.isEmpty() ? null : valueStack.peek();
    this.parseErrors = checkArgNotNull(parseErrors, "parseErrors");
    this.inputBuffer = checkArgNotNull(inputBuffer, "inputBuffer");
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
/**
     * Parse the provided domain string and return the constructed representation.
     * @param <E> The structured type.
     * @param domain The string to parse.
     * @return A {@code TypeList} is returned by default, but if the type is defined
     *         to consist of {@code Numeric} types, a {@code Vector} instance is returned.
     */
    public synchronized static <E extends StructuredType<? extends Type>> E parse(String domain) {
    	
        final ReportingParseRunner<String> expander = new ReportingParseRunner<String>(EXPANDING_PARSER.Expansion());
        final ParsingResult<String> d = expander.run(domain.replaceAll(" ", ""));
        
        if (d.hasErrors()) {
            StringBuilder strBuilder = new StringBuilder();
            for (ParseError e : d.parseErrors) {
                strBuilder.append(e.getInputBuffer().extract(e.getStartIndex(), e.getEndIndex()));
            }
            throw new RuntimeException("Error in expanding domain: " + domain + " near: " + strBuilder.toString());
        }
        
//        System.out.println(d.valueStack.size());
//        System.out.println("Creating vector");
        Vector.Builder builder = Vector.newBuilder();
        for (int i = 0; i < d.valueStack.size(); i++) {
			builder.add(Real.valueOf(0));
		}
        Vector myVector = builder.build();
//        System.out.println("Created vector of size: " + myVector.size());
        
        return (E) myVector;
//        .add(Real.valueOf(1.0)).add(Real.valueOf(2.0)).add(Real.valueOf(3.0));
//        tmpVector = builder.build();
        
//        System.out.println(d.valueStack.peek());
//        final String expanded = Joiner.on(",").join(d.valueStack);
//        final ReportingParseRunner<?> runner = new ReportingParseRunner(DOMAIN_PARSER.Domain());
//        
//        System.out.println("Before Fail");
//        System.out.println(expanded);
//        final ParsingResult<Type> result = (ParsingResult<Type>) runner.run(expanded);
//        System.out.println("in parser");
//        if (result.hasErrors()) {
//            StringBuilder strBuilder = new StringBuilder();
//            for (ParseError e : result.parseErrors) {
//                strBuilder.append(e.getInputBuffer().extract(e.getStartIndex(), e.getEndIndex()));
//            }
//            throw new RuntimeException("Error in parsing domain: " + expanded +
//                    ". Ensure that the domain is a valid domain string and contains no whitespace.\nError occurred near: " + strBuilder.toString());
//        }
//        System.out.println(result.valueStack.size());
//        System.out.println(result.valueStack.peek());
//        System.out.println(result.valueStack.peek(1));
//        System.out.println("in parser");
//        System.out.println(result.valueStack);
//        List<Type> l = Lists.newArrayList(result.valueStack);
//        System.out.println("in parser");
//        if (isVector(l)) {
//        	System.out.println("is vector");
//            @SuppressWarnings("unchecked")
//            E vector = (E) toVector(l);
//            return vector;
//        }
//
//        return (E) toTypeList(l);
    }
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
public EqlParseException(String msg, List<ParseError> parseErrors) {
    super(msg);

    this.parseErrors = new ArrayList<ParseError>(parseErrors.size());
    this.parseErrors.addAll(parseErrors);
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
public List<ParseError> getParseErrors() {
    return parseErrors;
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
public ParseRunner<V> withParseErrors(List<ParseError> parseErrors) {
    this.parseErrors = parseErrors;
    return this;
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
public List<ParseError> getParseErrors() {
    if (parseErrors == null) {
        withParseErrors(new ArrayList<ParseError>());
    }
    return parseErrors;
}
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
/**
 * Returns the list of parse errors for the entire parsing run.
 *
 * @return the list of parse errors
 */
List<ParseError> getParseErrors();
 

import org.parboiled.errors.ParseError; //导入依赖的package包/类
/**
 * Initializes the parse runner with the given error list.
 *
 * @param parseErrors the error list to start off with
 * @return this instance
 */
ParseRunner<V> withParseErrors(List<ParseError> parseErrors);