public Rule SingleQuoted() { return NodeSequence( !Character.isLetter(getContext().getInputBuffer().charAt(getContext().getCurrentIndex() - 1)), '\'', push(new QuotedNode(QuotedNode.Type.Single)), OneOrMore(TestNot(SingleQuoteEnd()), Inline(), addAsChild()), SingleQuoteEnd() ); }
public Rule TableRow() { Var<Boolean> leadingPipe = new Var<Boolean>(Boolean.FALSE); return NodeSequence( push(new TableRowNode()), Optional('|', leadingPipe.set(Boolean.TRUE)), OneOrMore(TableCell(), addAsChild()), leadingPipe.get() || ((Node) peek()).getChildren().size() > 1 || getContext().getInputBuffer().charAt(matchEnd() - 1) == '|', Sp(), Newline() ); }
public void advanceIndex(int delta) { currentIndex += delta; currentChar = inputBuffer.charAt(currentIndex); }
public char charAt(int index) { int j = Arrays.binarySearch(inserts, index); if (j >= 0) return chars[j]; return buffer.charAt(index + (j + 1)); }
public void setCurrentIndex(int currentIndex) { checkArgument(currentIndex >= 0); this.currentIndex = currentIndex; currentChar = inputBuffer.charAt(currentIndex); }
/** * Collects the actual input text the input buffer provides into a String. * This is especially useful for IndentDedentInputBuffers created by "transformIndents". * @param buf the input buffer to collect from * @return a string containing the content of the given input buffer */ public static String collectContent(InputBuffer buf) { StringBuilder sb = new StringBuilder(); int ix = 0; loop: while (true) { char c = buf.charAt(ix++); switch (c) { case INDENT: sb.append('\u00bb'); // right pointed double angle quotation mark break; case DEDENT: sb.append('\u00ab'); // left pointed double angle quotation mark break; case EOI: break loop; default: sb.append(c); } } return sb.toString(); } }
public char getFirstMatchChar() { checkActionContext(); int ix = subContext.startIndex; if (subContext.currentIndex <= ix) { throw new GrammarException("getFirstMatchChar called but previous rule did not match anything"); } return inputBuffer.charAt(ix); }
public String format(InvalidInputError error) { if (error == null) return ""; int len = error.getEndIndex() - error.getStartIndex(); StringBuilder sb = new StringBuilder(); if (len > 0) { char c = error.getInputBuffer().charAt(error.getStartIndex()); if (c == Chars.EOI) { sb.append("Unexpected end of input"); } else { sb.append("Invalid input '") .append(StringUtils.escape(String.valueOf(c))); if (len > 1) sb.append("..."); sb.append('\''); } } else { sb.append("Invalid input"); } String expectedString = getExpectedString(error); if (StringUtils.isNotEmpty(expectedString)) { sb.append(", expected ").append(expectedString); } return sb.toString(); }
@Override public String format(final InvalidInputError error) { if (error == null) { return ""; } int len = error.getEndIndex() - error.getStartIndex(); StringBuilder sb = new StringBuilder("found"); if (len > 0) { sb.append(" '") .append( StringUtils.escape(String.valueOf(error.getInputBuffer().charAt( error.getStartIndex())))); if (len > 1) { sb.append("..."); } sb.append('\''); } String expectedString = getExpectedString(error); if (StringUtils.isNotEmpty(expectedString)) { sb.append(", expected: ").append(expectedString); } return sb.toString(); }
/** * Initializes a new root MatcherContext. * * @param inputBuffer the InputBuffer for the parsing run * @param valueStack the ValueStack instance to use for the parsing run * @param parseErrors the parse error list to create ParseError objects in * @param matchHandler the MatcherHandler to use for the parsing run * @param matcher the root matcher * @param fastStringMatching <p>Fast string matching "short-circuits" the default practice of treating string rules * as simple Sequence of character rules. When fast string matching is enabled strings are * matched at once, without relying on inner CharacterMatchers. Even though this can lead * to significant increases of parsing performance it does not play well with error * reporting and recovery, which relies on character level matches. * Therefore the {@link org.parboiled.parserunners.ReportingParseRunner} and {@link org.parboiled.parserunners.RecoveringParseRunner} * implementations only enable fast string matching during their basic first parsing run * and disable it once the input has proven to contain errors.</p> */ public MatcherContext(InputBuffer inputBuffer, ValueStack<V> valueStack, List<ParseError> parseErrors, MatchHandler matchHandler, Matcher matcher, boolean fastStringMatching) { this(checkArgNotNull(inputBuffer, "inputBuffer"), checkArgNotNull(valueStack, "valueStack"), checkArgNotNull(parseErrors, "parseErrors"), checkArgNotNull(matchHandler, "matchHandler"), null, 0, fastStringMatching, new HashSet<MatcherPosition>()); this.currentChar = inputBuffer.charAt(0); this.matcher = ProxyMatcher.unwrap(checkArgNotNull(matcher, "matcher")); this.nodeSuppressed = matcher.isNodeSuppressed(); }
endIx = ix; c = buffer.charAt(ix); continue loop;