@Override public void writeSemantic(EObject grammarElement, String value) throws IOException { addLineEntry(grammarElement, value, false); } }
protected Line createLine(List<LineEntry> entries) { return createLine(entries, 0); }
protected int countExistingLeadingNewlines() { if (leadingWS == null) return -1; int c = 0, i = -1; while ((i = leadingWS.indexOf(getLineSeparator(), i + 1)) >= 0) c++; return c; }
protected void addLineEntry(EObject grammarElement, String value, boolean isHidden) throws IOException { Pair<Integer, RuleCall> hiddenTokenDefCall1 = findTopmostHiddenTokenDef(); Set<ElementLocator> locators = collectLocators(grammarElement); // System.out.println(locators + " --> " + value.replaceAll("\n", "\\n") + " -> '" // + (preservedWS != null ? preservedWS.replaceAll("\n", "\\n") : "") + "'"); Pair<Integer, RuleCall> hiddenTokenDefCall2 = findTopmostHiddenTokenDef(); ParserRule hiddenTokenDef = null; if (hiddenTokenDefCall1 != null && hiddenTokenDefCall2 != null) { if (hiddenTokenDefCall1.getFirst() < hiddenTokenDefCall2.getFirst()) hiddenTokenDef = (ParserRule) hiddenTokenDefCall1.getSecond().getRule(); else hiddenTokenDef = (ParserRule) hiddenTokenDefCall2.getSecond().getRule(); } LineEntry e = createLineEntry(grammarElement, value, true, locators, preservedWS, indentationLevel, hiddenTokenDef); preservedWS = null; if (currentLine == null) currentLine = createLine(); Line newLine = currentLine.add(e); if (newLine != null) currentLine = newLine; }
@Override public ITokenStream createFormatterStream(String indent, ITokenStream out, boolean preserveWhitespaces) { return new FormattingConfigBasedStream(out, indent, getConfig(), createMatcher(), hiddenTokenHelper, preserveWhitespaces); }
protected Set<ElementLocator> collectLocators(EObject ele) { Set<ElementLocator> result = Sets.newHashSet(activeRangeLocators); Collection<ElementLocator> loc = Sets.newHashSet(); if (ele instanceof AbstractElement) for (ElementPattern pattern : matcher.matchNext((AbstractElement) ele)) loc.add(pattern.getLocator()); if ((last instanceof AbstractRule && hiddenTokenHelper.isComment((AbstractRule) last)) || (ele instanceof AbstractRule && hiddenTokenHelper.isComment((AbstractRule) ele))) loc = collectLocatorsForComments(loc, last, ele); last = ele; for (ElementLocator locator : loc) if (locator.getType() == LocatorType.RANGE && !activeRangeLocators.add(locator)) activeRangeLocators.remove(locator); result.addAll(loc); for (ElementLocator locator : result) { if (locator instanceof IndentationLocatorStart) indentationLevel++; else if (locator instanceof IndentationLocatorEnd) indentationLevel--; } return result; }
@Override public void writeSemantic(EObject grammarElement, String value) throws IOException { if (getRule(grammarElement) == grammarAccess.getJAVADOC_COMMENTRule()) { // format value value = formatJavaDoc(value, indentationLevel); } if (grammarElement == grammarAccess.getIncludedPropertiesAccess().getCommaKeyword_2_0_6_0_0() || grammarElement == grammarAccess.getIncludedPropertiesAccess().getCommaKeyword_2_1_3_5_0_0() || grammarElement == grammarAccess.getIncludedPropertiesAccess().getCommaKeyword_2_1_4_5_0_0() || grammarElement == grammarAccess.getAnonimousLinkDescriptorAccess().getCommaKeyword_3_3_0_0_0()) { value = getLineSeparator() + Strings.repeat(cfg.getIndentationSpace(), indentationLevel > 0 ? indentationLevel : 0); } super.writeSemantic(grammarElement, value); }
/** * @since 2.3 */ @Override public ITokenStream createFormatterStream(EObject context, String indent, ITokenStream out, boolean preserveWhitespaces) { if(context != null && context.eResource() != null && context.eResource().getURI() != null) { contextResourceURI = EcoreUtil2.getPlatformResourceOrNormalizedURI(context).trimFragment(); } return new FormattingConfigBasedStream(out, indent, getConfig(), createMatcher(), hiddenTokenHelper, preserveWhitespaces); }
protected int countCharactersInLastLine() { int lastNLIndex = value.lastIndexOf(getLineSeparator()); if (lastNLIndex >= 0) return (value.length() - lastNLIndex) - getLineSeparator().length(); if (preserveSpaces && leadingWS != null) { int lastNLIndexInLeadingWs = leadingWS.lastIndexOf(getLineSeparator()); if (lastNLIndexInLeadingWs >= 0) // TODO Moritz: replaced -1 by -getLineSeparator.length() // is that correct? return ((leadingWS.length() - lastNLIndexInLeadingWs) + value.length()) - getLineSeparator().length(); } return -1; }
protected Line createLine() { return createLine(null); }
@Override @SuppressWarnings("deprecation") public void writeHidden(EObject grammarElement, String value) throws IOException { boolean isWhitespace = grammarElement instanceof AbstractRule && hiddenTokenHelper.isWhitespace((AbstractRule) grammarElement); if (isWhitespace || cfg.getWhitespaceRule() == grammarElement) { if (preservedWS == null) preservedWS = value; else preservedWS += value; } else addLineEntry(grammarElement, value, true); }
protected String wrap(int lines, String indent) { StringBuffer result = new StringBuffer(lines + indent.length()); for (int i = 0; i < lines; i++) result.append(getLineSeparator()); // do not indent too deep as there would be no space left // for semantic information int indentLength = indent.length(); while ((cfg.getCharsPerLine() * 2 / 3) < indentLength) { indentLength = indentLength - cfg.getCharsPerLine() / 2; } if (indentLength != indent.length()) indent = indent.substring(0, indentLength); result.append(indent); return result.toString(); }
protected Line createLine(int leftover) { return createLine(null, leftover); }
protected boolean isBreakable() { if (leadingLocators == null) return false; for (ElementLocator e : leadingLocators) { if (e instanceof LinewrapLocator && ((LinewrapLocator) e).getMaxWrap() == 0) return false; if (e instanceof SpaceLocator) return false; } return hiddenTokenHelper.getWhitespaceRuleFor(hiddenTokenDefinition, getLineSeparator()) != null; }
protected Line flushLine() throws IOException { flush(out, lastBreakableEntryIndex); // TokenStringBuffer b = new TokenStringBuffer(); // flush(b, lastBreakable); // System.out.println("WrapLine: \"" + b + "\""); return createLine(Lists.newArrayList(entries.subList(lastBreakableEntryIndex, entries.size()))); }
protected void addSpacesToTotalLength(LineEntry lineEntry, boolean first) { Pair<AbstractRule, String> spaces = getSpaces(lineEntry, first); if (spaces != null) { int lastIndexOfNL = spaces.getSecond().lastIndexOf(getLineSeparator()); if (lastIndexOfNL >= 0) totalLength += spaces.getSecond().length() - lastIndexOfNL; else totalLength += spaces.getSecond().length(); } }
public Line add(LineEntry lineEntry) throws IOException { entries.add(lineEntry); if (indent == null) { indent = getIndentation(entries.get(0).indent); } addSpacesToTotalLength(lineEntry, entries.size() == 1); int lastLineLength = lineEntry.countCharactersInLastLine(); if (lastLineLength >= 0) { flush(); return createLine(lastLineLength); } if (lineEntry.isBreakable()) lastBreakableEntryIndex = entries.size() - 1; totalLength += lineEntry.value.length(); if (lineEntry.isBreak()) { lastBreakableEntryIndex = entries.size() - 1; return flushLine(); } if (totalLength > cfg.getCharsPerLine() && lastBreakableEntryIndex > 0) { LineEntry lastEntry = entries.get(lastBreakableEntryIndex); lastEntry.indent = lastEntry.indent + cfg.getWrappedLineIndentation(); return flushLine(); } return null; }