/** * @return true if problems were found during parsing */ public boolean foundProblems() { return tokenStream.containsProblems(); }
/** * @return the list of problems that occurred during parsing */ public List<ManifestProblem> getProblems() { return tokenStream.getProblems(); }
/** * Record a problem with parsing. * * @param parseProblem the kind of problem that occurred * @param startOffset the start offset of the problem * @param endOffset the end offset of the problem * @param inserts the inserts for the problem message text */ private void recordProblem(ManifestProblemKind parseProblem, int startOffset, int endOffset, String... inserts) { tokenStream .recordProblem(new ManifestProblem(parseProblem, tokenStream.getSourceContext(), startOffset, endOffset, inserts)); }
public void eatNewline() { assert tokenStream.hasMore(); Token t = tokenStream.next(); assert t.getKind() == TokenKind.NEWLINE; // if (tokenStream.hasMore()) { // Token t = tokenStream.peek(); // if (TokenKind.isNewline(t)) { // tokenStream.next(); // return; // } else { // recordProblem(ManifestProblemKind.EXPECTED_NEWLINE, // t.getStartOffset(), t.getEndOffset(), new String(t.value())); // } // } else { // recordProblem(ManifestProblemKind.UNEXPECTED_EOM, // tokenStream.peekLast().getStartOffset(), tokenStream.peekLast() // .getEndOffset(), "newline"); // } }
/** * Expects to eat "Name" ":" "<value>" * @return continue? */ public boolean eatNameAttribute() { boolean cont; if (maybeEatHeaderName("Name")) { eatColon(); Token valueToken = tokenStream.next(); tokenStream.next(); // newline cont = visitor.visitSection(false, valueToken.value()); if (!cont) { return false; } visitor.visitHeader(NAME_HEADER, valueToken.value()); } else { Token token = tokenStream.peek(); // ERROR: they didn't supply a Name. Report an error and treat this // as a regular attribute cont = visitor.visitSection(false, null); // still the start of a // section, just has no // name recordProblem(ManifestProblemKind.MISSING_NAME_HEADER, token.getStartOffset(), token.getEndOffset(), token.value()); } return cont; }
public void eatAttribute(boolean isMain) { Token nameToken = tokenStream.next(); // Token colonToken = tokenStream.next(); Token valueToken = tokenStream.next(); // Token newlineToken = tokenStream.next(); // This gives the visitor a chance to decide what it wants to do about // the value visitor.visitHeader(nameToken.value(), valueToken.value()); }
/** * Consume a specific Name token from the token stream, report an error if * it is the wrong kind or the wrong name. * * @param expectedName * @return */ private boolean maybeEatHeaderName(String expectedName) { Token t = tokenStream.peek(); if (TokenKind.isName(t)) { if (t.value().equals(expectedName)) { tokenStream.next(); return true; } else { recordProblem(ManifestProblemKind.UNEXPECTED_NAME, t.getStartOffset(), t.getEndOffset(), expectedName, t.value()); return false; } } else { recordProblem(ManifestProblemKind.UNEXPECTED_TOKEN_KIND, t.getStartOffset(), t.getEndOffset(), "Name", t.getKind() .getTokenString()); return false; } }
public void eatColon() { Token t = tokenStream.next(); assert t.getKind() == TokenKind.COLON; }
ManifestContents parseManifest() { checkForRogueNewlinesProceedingInput(); boolean cont = eatSection(true); // cont indicates whether the visitor // decided to stop processing early while (tokenStream.hasMore() && cont) { cont = eatSection(false); } if (cont) { confirmEnd(); } return visitor.getManifestContents(); }
public void eatVersionNumber() { Token tok = tokenStream.next(); assert tok.getKind() == TokenKind.VALUE; visitor.visitManifestVersion(tok.value()); }