OpenSource/PaperMC
OpenSource/PaperMC
1
0
Fork 0
mirror of https://github.com/PaperMC/Paper.git synced 2024-12-01 04:31:58 +01:00
Code Issues Projects Releases Packages Wiki Activity
PaperMC/patches/server/0832-Fix-saving-configs-with-more-long-comments.patch
Nassim Jahnke 1cfd363d32
Updated Upstream (Bukkit/CraftBukkit/Spigot) 
Upstream has released updates that appear to apply and compile correctly.
This update has not been tested by PaperMC and as with ANY update, please do your own testing

Bukkit Changes:
fc460d1b PR-735: Add Villager#zombify
c8c8331e PR-690: Add method to read ItemStack input
62845f2f SPIGOT-6829: Add per-player world border API

CraftBukkit Changes:
a459f4d4 PR-1033: Add Villager#zombify
d65d1430 PR-975: Add method to read ItemStack input
b5559f8c SPIGOT-6990: Fix setRepairCost(0) in Anvil
6c308e1b SPIGOT-6829: Add per-player world border API

Spigot Changes:
42b61526 SPIGOT-7000: Generation and /locate issues when using custom structure seeds
2022-04-16 10:29:50 +02:00

1702 lines
63 KiB
Diff
Raw Blame History

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Jake Potrebic <jake.m.potrebic@gmail.com>
Date: Sat, 1 Jan 2022 21:24:50 -0800
Subject: [PATCH] Fix saving configs with more long comments
This is a bug with snakeyaml
PR: https://bitbucket.org/snakeyaml/snakeyaml/pull-requests/3
Issue: https://bitbucket.org/snakeyaml/snakeyaml/issues/518/comments-could-cause-queue-full
Added the entire Emitter class from snakeyaml because
dev-imports doesn't work with non-mojang-added dependencies
Replacement for upstream: https://hub.spigotmc.org/stash/projects/SPIGOT/repos/bukkit/commits/a7505b3cd0498baca152777767f0e4ddebbe4d1a
diff --git a/src/main/java/org/yaml/snakeyaml/emitter/Emitter.java b/src/main/java/org/yaml/snakeyaml/emitter/Emitter.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca32c00775f3d98abea39bbfeb0268bb9efbc12b
--- /dev/null
+++ b/src/main/java/org/yaml/snakeyaml/emitter/Emitter.java
@@ -0,0 +1,1682 @@
+/**
+ * Copyright (c) 2008, SnakeYAML
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.yaml.snakeyaml.emitter;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.ScalarStyle;
+import org.yaml.snakeyaml.DumperOptions.Version;
+import org.yaml.snakeyaml.comments.CommentEventsCollector;
+import org.yaml.snakeyaml.comments.CommentLine;
+import org.yaml.snakeyaml.comments.CommentType;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.events.AliasEvent;
+import org.yaml.snakeyaml.events.CollectionEndEvent;
+import org.yaml.snakeyaml.events.CollectionStartEvent;
+import org.yaml.snakeyaml.events.CommentEvent;
+import org.yaml.snakeyaml.events.DocumentEndEvent;
+import org.yaml.snakeyaml.events.DocumentStartEvent;
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.events.Event.ID;
+import org.yaml.snakeyaml.events.MappingEndEvent;
+import org.yaml.snakeyaml.events.MappingStartEvent;
+import org.yaml.snakeyaml.events.NodeEvent;
+import org.yaml.snakeyaml.events.ScalarEvent;
+import org.yaml.snakeyaml.events.SequenceEndEvent;
+import org.yaml.snakeyaml.events.SequenceStartEvent;
+import org.yaml.snakeyaml.events.StreamEndEvent;
+import org.yaml.snakeyaml.events.StreamStartEvent;
+import org.yaml.snakeyaml.nodes.Tag;
+import org.yaml.snakeyaml.reader.StreamReader;
+import org.yaml.snakeyaml.scanner.Constant;
+import org.yaml.snakeyaml.util.ArrayStack;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayDeque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * <pre>
+ * Emitter expects events obeying the following grammar:
+ * stream ::= STREAM-START document* STREAM-END
+ * document ::= DOCUMENT-START node DOCUMENT-END
+ * node ::= SCALAR | sequence | mapping
+ * sequence ::= SEQUENCE-START node* SEQUENCE-END
+ * mapping ::= MAPPING-START (node node)* MAPPING-END
+ * </pre>
+ */
+public final class Emitter implements Emitable {
+ public static final int MIN_INDENT = 1;
+ public static final int MAX_INDENT = 10;
+ private static final char[] SPACE = {' '};
+
+ private static final Pattern SPACES_PATTERN = Pattern.compile("\\s");
+ private static final Set<Character> INVALID_ANCHOR = new HashSet();
+ static {
+ INVALID_ANCHOR.add('[');
+ INVALID_ANCHOR.add(']');
+ INVALID_ANCHOR.add('{');
+ INVALID_ANCHOR.add('}');
+ INVALID_ANCHOR.add(',');
+ INVALID_ANCHOR.add('*');
+ INVALID_ANCHOR.add('&');
+ }
+
+ private static final Map<Character, String> ESCAPE_REPLACEMENTS = new HashMap<Character, String>();
+ static {
+ ESCAPE_REPLACEMENTS.put('\0', "0");
+ ESCAPE_REPLACEMENTS.put('\u0007', "a");
+ ESCAPE_REPLACEMENTS.put('\u0008', "b");
+ ESCAPE_REPLACEMENTS.put('\u0009', "t");
+ ESCAPE_REPLACEMENTS.put('\n', "n");
+ ESCAPE_REPLACEMENTS.put('\u000B', "v");
+ ESCAPE_REPLACEMENTS.put('\u000C', "f");
+ ESCAPE_REPLACEMENTS.put('\r', "r");
+ ESCAPE_REPLACEMENTS.put('\u001B', "e");
+ ESCAPE_REPLACEMENTS.put('"', "\"");
+ ESCAPE_REPLACEMENTS.put('\\', "\\");
+ ESCAPE_REPLACEMENTS.put('\u0085', "N");
+ ESCAPE_REPLACEMENTS.put('\u00A0', "_");
+ ESCAPE_REPLACEMENTS.put('\u2028', "L");
+ ESCAPE_REPLACEMENTS.put('\u2029', "P");
+ }
+
+ private final static Map<String, String> DEFAULT_TAG_PREFIXES = new LinkedHashMap<String, String>();
+ static {
+ DEFAULT_TAG_PREFIXES.put("!", "!");
+ DEFAULT_TAG_PREFIXES.put(Tag.PREFIX, "!!");
+ }
+ // The stream should have the methods `write` and possibly `flush`.
+ private final Writer stream;
+
+ // Encoding is defined by Writer (cannot be overridden by STREAM-START.)
+ // private Charset encoding;
+
+ // Emitter is a state machine with a stack of states to handle nested
+ // structures.
+ private final ArrayStack<EmitterState> states;
+ private EmitterState state;
+
+ // Current event and the event queue.
+ private final Queue<Event> events;
+ private Event event;
+
+ // The current indentation level and the stack of previous indents.
+ private final ArrayStack<Integer> indents;
+ private Integer indent;
+
+ // Flow level.
+ private int flowLevel;
+
+ // Contexts.
+ private boolean rootContext;
+ private boolean mappingContext;
+ private boolean simpleKeyContext;
+
+ //
+ // Characteristics of the last emitted character:
+ // - current position.
+ // - is it a whitespace?
+ // - is it an indention character
+ // (indentation space, '-', '?', or ':')?
+ // private int line; this variable is not used
+ private int column;
+ private boolean whitespace;
+ private boolean indention;
+ private boolean openEnded;
+
+ // Formatting details.
+ private final Boolean canonical;
+ // pretty print flow by adding extra line breaks
+ private final Boolean prettyFlow;
+
+ private final boolean allowUnicode;
+ private int bestIndent;
+ private final int indicatorIndent;
+ private final boolean indentWithIndicator;
+ private int bestWidth;
+ private final char[] bestLineBreak;
+ private final boolean splitLines;
+ private final int maxSimpleKeyLength;
+ private final boolean emitComments;
+
+ // Tag prefixes.
+ private Map<String, String> tagPrefixes;
+
+ // Prepared anchor and tag.
+ private String preparedAnchor;
+ private String preparedTag;
+
+ // Scalar analysis and style.
+ private ScalarAnalysis analysis;
+ private DumperOptions.ScalarStyle style;
+
+ // Comment processing
+ private final CommentEventsCollector blockCommentsCollector;
+ private final CommentEventsCollector inlineCommentsCollector;
+
+
+ public Emitter(Writer stream, DumperOptions opts) {
+ // The stream should have the methods `write` and possibly `flush`.
+ this.stream = stream;
+ // Emitter is a state machine with a stack of states to handle nested
+ // structures.
+ this.states = new ArrayStack<EmitterState>(100);
+ this.state = new ExpectStreamStart();
+ // Current event and the event queue.
+ this.events = new ArrayDeque<>(100); // Paper - allow more than 100 events (or comments)
+ // this.events = new ArrayBlockingQueue<>(100);
+ this.event = null;
+ // The current indentation level and the stack of previous indents.
+ this.indents = new ArrayStack<Integer>(10);
+ this.indent = null;
+ // Flow level.
+ this.flowLevel = 0;
+ // Contexts.
+ mappingContext = false;
+ simpleKeyContext = false;
+
+ //
+ // Characteristics of the last emitted character:
+ // - current position.
+ // - is it a whitespace?
+ // - is it an indention character
+ // (indentation space, '-', '?', or ':')?
+ column = 0;
+ whitespace = true;
+ indention = true;
+
+ // Whether the document requires an explicit document indicator
+ openEnded = false;
+
+ // Formatting details.
+ this.canonical = opts.isCanonical();
+ this.prettyFlow = opts.isPrettyFlow();
+ this.allowUnicode = opts.isAllowUnicode();
+ this.bestIndent = 2;
+ if ((opts.getIndent() > MIN_INDENT) && (opts.getIndent() < MAX_INDENT)) {
+ this.bestIndent = opts.getIndent();
+ }
+ this.indicatorIndent = opts.getIndicatorIndent();
+ this.indentWithIndicator = opts.getIndentWithIndicator();
+ this.bestWidth = 80;
+ if (opts.getWidth() > this.bestIndent * 2) {
+ this.bestWidth = opts.getWidth();
+ }
+ this.bestLineBreak = opts.getLineBreak().getString().toCharArray();
+ this.splitLines = opts.getSplitLines();
+ this.maxSimpleKeyLength = opts.getMaxSimpleKeyLength();
+ this.emitComments = opts.isProcessComments();
+
+ // Tag prefixes.
+ this.tagPrefixes = new LinkedHashMap<String, String>();
+
+ // Prepared anchor and tag.
+ this.preparedAnchor = null;
+ this.preparedTag = null;
+
+ // Scalar analysis and style.
+ this.analysis = null;
+ this.style = null;
+
+ // Comment processing
+ this.blockCommentsCollector = new CommentEventsCollector(events,
+ CommentType.BLANK_LINE, CommentType.BLOCK);
+ this.inlineCommentsCollector = new CommentEventsCollector(events,
+ CommentType.IN_LINE);
+ }
+
+ public void emit(Event event) throws IOException {
+ this.events.add(event);
+ while (!needMoreEvents()) {
+ this.event = this.events.poll();
+ this.state.expect();
+ this.event = null;
+ }
+ }
+
+ // In some cases, we wait for a few next events before emitting.
+
+ private boolean needMoreEvents() {
+ if (events.isEmpty()) {
+ return true;
+ }
+
+ Iterator<Event> iter = events.iterator();
+ Event event = iter.next(); // FIXME why without check ???
+ while(event instanceof CommentEvent) {
+ if (!iter.hasNext()) {
+ return true;
+ }
+ event = iter.next();
+ }
+
+ if (event instanceof DocumentStartEvent) {
+ return needEvents(iter, 1);
+ } else if (event instanceof SequenceStartEvent) {
+ return needEvents(iter, 2);
+ } else if (event instanceof MappingStartEvent) {
+ return needEvents(iter, 3);
+ } else if (event instanceof StreamStartEvent) {
+ return needEvents(iter, 2);
+ } else if (event instanceof StreamEndEvent) {
+ return false;
+ } else if (emitComments) {
+ return needEvents(iter, 1);
+ }
+ return false;
+ }
+
+ private boolean needEvents(Iterator<Event> iter, int count) {
+ int level = 0;
+ int actualCount = 0;
+ while (iter.hasNext()) {
+ Event event = iter.next();
+ if (event instanceof CommentEvent) {
+ continue;
+ }
+ actualCount++;
+ if (event instanceof DocumentStartEvent || event instanceof CollectionStartEvent) {
+ level++;
+ } else if (event instanceof DocumentEndEvent || event instanceof CollectionEndEvent) {
+ level--;
+ } else if (event instanceof StreamEndEvent) {
+ level = -1;
+ }
+ if (level < 0) {
+ return false;
+ }
+ }
+ return actualCount < count;
+ }
+
+ private void increaseIndent(boolean flow, boolean indentless) {
+ indents.push(indent);
+ if (indent == null) {
+ if (flow) {
+ indent = bestIndent;
+ } else {
+ indent = 0;
+ }
+ } else if (!indentless) {
+ this.indent += bestIndent;
+ }
+ }
+
+ // States
+
+ // Stream handlers.
+
+ private class ExpectStreamStart implements EmitterState {
+ public void expect() throws IOException {
+ if (event instanceof StreamStartEvent) {
+ writeStreamStart();
+ state = new ExpectFirstDocumentStart();
+ } else {
+ throw new EmitterException("expected StreamStartEvent, but got " + event);
+ }
+ }
+ }
+
+ private class ExpectNothing implements EmitterState {
+ public void expect() throws IOException {
+ throw new EmitterException("expecting nothing, but got " + event);
+ }
+ }
+
+ // Document handlers.
+
+ private class ExpectFirstDocumentStart implements EmitterState {
+ public void expect() throws IOException {
+ new ExpectDocumentStart(true).expect();
+ }
+ }
+
+ private class ExpectDocumentStart implements EmitterState {
+ private final boolean first;
+
+ public ExpectDocumentStart(boolean first) {
+ this.first = first;
+ }
+
+ public void expect() throws IOException {
+ if (event instanceof DocumentStartEvent) {
+ DocumentStartEvent ev = (DocumentStartEvent) event;
+ if ((ev.getVersion() != null || ev.getTags() != null) && openEnded) {
+ writeIndicator("...", true, false, false);
+ writeIndent();
+ }
+ if (ev.getVersion() != null) {
+ String versionText = prepareVersion(ev.getVersion());
+ writeVersionDirective(versionText);
+ }
+ tagPrefixes = new LinkedHashMap<String, String>(DEFAULT_TAG_PREFIXES);
+ if (ev.getTags() != null) {
+ Set<String> handles = new TreeSet<String>(ev.getTags().keySet());
+ for (String handle : handles) {
+ String prefix = ev.getTags().get(handle);
+ tagPrefixes.put(prefix, handle);
+ String handleText = prepareTagHandle(handle);
+ String prefixText = prepareTagPrefix(prefix);
+ writeTagDirective(handleText, prefixText);
+ }
+ }
+ boolean implicit = first && !ev.getExplicit() && !canonical
+ && ev.getVersion() == null
+ && (ev.getTags() == null || ev.getTags().isEmpty())
+ && !checkEmptyDocument();
+ if (!implicit) {
+ writeIndent();
+ writeIndicator("---", true, false, false);
+ if (canonical) {
+ writeIndent();
+ }
+ }
+ state = new ExpectDocumentRoot();
+ } else if (event instanceof StreamEndEvent) {
+ writeStreamEnd();
+ state = new ExpectNothing();
+ } else if (event instanceof CommentEvent) {
+ blockCommentsCollector.collectEvents(event);
+ writeBlockComment();
+ // state = state; remains unchanged
+ } else {
+ throw new EmitterException("expected DocumentStartEvent, but got " + event);
+ }
+ }
+ }
+
+ private class ExpectDocumentEnd implements EmitterState {
+ public void expect() throws IOException {
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ writeBlockComment();
+ if (event instanceof DocumentEndEvent) {
+ writeIndent();
+ if (((DocumentEndEvent) event).getExplicit()) {
+ writeIndicator("...", true, false, false);
+ writeIndent();
+ }
+ flushStream();
+ state = new ExpectDocumentStart(false);
+ } else {
+ throw new EmitterException("expected DocumentEndEvent, but got " + event);
+ }
+ }
+ }
+
+ private class ExpectDocumentRoot implements EmitterState {
+ public void expect() throws IOException {
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ if (!blockCommentsCollector.isEmpty()) {
+ writeBlockComment();
+ if (event instanceof DocumentEndEvent) {
+ new ExpectDocumentEnd().expect();
+ return;
+ }
+ }
+ states.push(new ExpectDocumentEnd());
+ expectNode(true, false, false);
+ }
+ }
+
+ // Node handlers.
+
+ private void expectNode(boolean root, boolean mapping, boolean simpleKey) throws IOException {
+ rootContext = root;
+ mappingContext = mapping;
+ simpleKeyContext = simpleKey;
+ if (event instanceof AliasEvent) {
+ expectAlias();
+ } else if (event instanceof ScalarEvent || event instanceof CollectionStartEvent) {
+ processAnchor("&");
+ processTag();
+ if (event instanceof ScalarEvent) {
+ expectScalar();
+ } else if (event instanceof SequenceStartEvent) {
+ if (flowLevel != 0 || canonical || ((SequenceStartEvent) event).isFlow()
+ || checkEmptySequence()) {
+ expectFlowSequence();
+ } else {
+ expectBlockSequence();
+ }
+ } else {// MappingStartEvent
+ if (flowLevel != 0 || canonical || ((MappingStartEvent) event).isFlow()
+ || checkEmptyMapping()) {
+ expectFlowMapping();
+ } else {
+ expectBlockMapping();
+ }
+ }
+ } else {
+ throw new EmitterException("expected NodeEvent, but got " + event);
+ }
+ }
+
+ private void expectAlias() throws IOException {
+ if (!(event instanceof AliasEvent)) {
+ throw new EmitterException("Alias must be provided");
+ }
+ processAnchor("*");
+ state = states.pop();
+ }
+
+ private void expectScalar() throws IOException {
+ increaseIndent(true, false);
+ processScalar();
+ indent = indents.pop();
+ state = states.pop();
+ }
+
+ // Flow sequence handlers.
+
+ private void expectFlowSequence() throws IOException {
+ writeIndicator("[", true, true, false);
+ flowLevel++;
+ increaseIndent(true, false);
+ if (prettyFlow) {
+ writeIndent();
+ }
+ state = new ExpectFirstFlowSequenceItem();
+ }
+
+ private class ExpectFirstFlowSequenceItem implements EmitterState {
+ public void expect() throws IOException {
+ if (event instanceof SequenceEndEvent) {
+ indent = indents.pop();
+ flowLevel--;
+ writeIndicator("]", false, false, false);
+ inlineCommentsCollector.collectEvents();
+ writeInlineComments();
+ state = states.pop();
+ } else if (event instanceof CommentEvent) {
+ blockCommentsCollector.collectEvents(event);
+ writeBlockComment();
+ } else {
+ if (canonical || (column > bestWidth && splitLines) || prettyFlow) {
+ writeIndent();
+ }
+ states.push(new ExpectFlowSequenceItem());
+ expectNode(false, false, false);
+ event = inlineCommentsCollector.collectEvents(event);
+ writeInlineComments();
+ }
+ }
+ }
+
+ private class ExpectFlowSequenceItem implements EmitterState {
+ public void expect() throws IOException {
+ if (event instanceof SequenceEndEvent) {
+ indent = indents.pop();
+ flowLevel--;
+ if (canonical) {
+ writeIndicator(",", false, false, false);
+ writeIndent();
+ } else if (prettyFlow) {
+ writeIndent();
+ }
+ writeIndicator("]", false, false, false);
+ inlineCommentsCollector.collectEvents();
+ writeInlineComments();
+ if (prettyFlow) {
+ writeIndent();
+ }
+ state = states.pop();
+ } else if (event instanceof CommentEvent) {
+ event = blockCommentsCollector.collectEvents(event);
+ } else {
+ writeIndicator(",", false, false, false);
+ writeBlockComment();
+ if (canonical || (column > bestWidth && splitLines) || prettyFlow) {
+ writeIndent();
+ }
+ states.push(new ExpectFlowSequenceItem());
+ expectNode(false, false, false);
+ event = inlineCommentsCollector.collectEvents(event);
+ writeInlineComments();
+ }
+ }
+ }
+
+ // Flow mapping handlers.
+
+ private void expectFlowMapping() throws IOException {
+ writeIndicator("{", true, true, false);
+ flowLevel++;
+ increaseIndent(true, false);
+ if (prettyFlow) {
+ writeIndent();
+ }
+ state = new ExpectFirstFlowMappingKey();
+ }
+
+ private class ExpectFirstFlowMappingKey implements EmitterState {
+ public void expect() throws IOException {
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ writeBlockComment();
+ if (event instanceof MappingEndEvent) {
+ indent = indents.pop();
+ flowLevel--;
+ writeIndicator("}", false, false, false);
+ inlineCommentsCollector.collectEvents();
+ writeInlineComments();
+ state = states.pop();
+ } else {
+ if (canonical || (column > bestWidth && splitLines) || prettyFlow) {
+ writeIndent();
+ }
+ if (!canonical && checkSimpleKey()) {
+ states.push(new ExpectFlowMappingSimpleValue());
+ expectNode(false, true, true);
+ } else {
+ writeIndicator("?", true, false, false);
+ states.push(new ExpectFlowMappingValue());
+ expectNode(false, true, false);
+ }
+ }
+ }
+ }
+
+ private class ExpectFlowMappingKey implements EmitterState {
+ public void expect() throws IOException {
+ if (event instanceof MappingEndEvent) {
+ indent = indents.pop();
+ flowLevel--;
+ if (canonical) {
+ writeIndicator(",", false, false, false);
+ writeIndent();
+ }
+ if (prettyFlow) {
+ writeIndent();
+ }
+ writeIndicator("}", false, false, false);
+ inlineCommentsCollector.collectEvents();
+ writeInlineComments();
+ state = states.pop();
+ } else {
+ writeIndicator(",", false, false, false);
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ writeBlockComment();
+ if (canonical || (column > bestWidth && splitLines) || prettyFlow) {
+ writeIndent();
+ }
+ if (!canonical && checkSimpleKey()) {
+ states.push(new ExpectFlowMappingSimpleValue());
+ expectNode(false, true, true);
+ } else {
+ writeIndicator("?", true, false, false);
+ states.push(new ExpectFlowMappingValue());
+ expectNode(false, true, false);
+ }
+ }
+ }
+ }
+
+ private class ExpectFlowMappingSimpleValue implements EmitterState {
+ public void expect() throws IOException {
+ writeIndicator(":", false, false, false);
+ event = inlineCommentsCollector.collectEventsAndPoll(event);
+ writeInlineComments();
+ states.push(new ExpectFlowMappingKey());
+ expectNode(false, true, false);
+ inlineCommentsCollector.collectEvents(event);
+ writeInlineComments();
+ }
+ }
+
+ private class ExpectFlowMappingValue implements EmitterState {
+ public void expect() throws IOException {
+ if (canonical || (column > bestWidth) || prettyFlow) {
+ writeIndent();
+ }
+ writeIndicator(":", true, false, false);
+ event = inlineCommentsCollector.collectEventsAndPoll(event);
+ writeInlineComments();
+ states.push(new ExpectFlowMappingKey());
+ expectNode(false, true, false);
+ inlineCommentsCollector.collectEvents(event);
+ writeInlineComments();
+ }
+ }
+
+ // Block sequence handlers.
+
+ private void expectBlockSequence() throws IOException {
+ boolean indentless = mappingContext && !indention;
+ increaseIndent(false, indentless);
+ state = new ExpectFirstBlockSequenceItem();
+ }
+
+ private class ExpectFirstBlockSequenceItem implements EmitterState {
+ public void expect() throws IOException {
+ new ExpectBlockSequenceItem(true).expect();
+ }
+ }
+
+ private class ExpectBlockSequenceItem implements EmitterState {
+ private final boolean first;
+
+ public ExpectBlockSequenceItem(boolean first) {
+ this.first = first;
+ }
+
+ public void expect() throws IOException {
+ if (!this.first && event instanceof SequenceEndEvent) {
+ indent = indents.pop();
+ state = states.pop();
+ } else if( event instanceof CommentEvent) {
+ blockCommentsCollector.collectEvents(event);
+ } else {
+ writeIndent();
+ if (!indentWithIndicator || this.first) {
+ writeWhitespace(indicatorIndent);
+ }
+ writeIndicator("-", true, false, true);
+ if (indentWithIndicator && this.first) {
+ indent += indicatorIndent;
+ }
+ if (!blockCommentsCollector.isEmpty()) {
+ increaseIndent(false, false);
+ writeBlockComment();
+ if(event instanceof ScalarEvent) {
+ analysis = analyzeScalar(((ScalarEvent)event).getValue());
+ if (!analysis.isEmpty()) {
+ writeIndent();
+ }
+ }
+ indent = indents.pop();
+ }
+ states.push(new ExpectBlockSequenceItem(false));
+ expectNode(false, false, false);
+ inlineCommentsCollector.collectEvents();
+ writeInlineComments();
+ }
+ }
+ }
+
+ // Block mapping handlers.
+ private void expectBlockMapping() throws IOException {
+ increaseIndent(false, false);
+ state = new ExpectFirstBlockMappingKey();
+ }
+
+ private class ExpectFirstBlockMappingKey implements EmitterState {
+ public void expect() throws IOException {
+ new ExpectBlockMappingKey(true).expect();
+ }
+ }
+
+ private class ExpectBlockMappingKey implements EmitterState {
+ private final boolean first;
+
+ public ExpectBlockMappingKey(boolean first) {
+ this.first = first;
+ }
+
+ public void expect() throws IOException {
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ writeBlockComment();
+ if (!this.first && event instanceof MappingEndEvent) {
+ indent = indents.pop();
+ state = states.pop();
+ } else {
+ writeIndent();
+ if (checkSimpleKey()) {
+ states.push(new ExpectBlockMappingSimpleValue());
+ expectNode(false, true, true);
+ } else {
+ writeIndicator("?", true, false, true);
+ states.push(new ExpectBlockMappingValue());
+ expectNode(false, true, false);
+ }
+ }
+ }
+ }
+
+ private boolean isFoldedOrLiteral(Event event) {
+ if(!event.is(ID.Scalar)) {
+ return false;
+ }
+ ScalarEvent scalarEvent = (ScalarEvent) event;
+ ScalarStyle style = scalarEvent.getScalarStyle();
+ return style == ScalarStyle.FOLDED || style == ScalarStyle.LITERAL;
+ }
+
+ private class ExpectBlockMappingSimpleValue implements EmitterState {
+ public void expect() throws IOException {
+ writeIndicator(":", false, false, false);
+ event = inlineCommentsCollector.collectEventsAndPoll(event);
+ if(!isFoldedOrLiteral(event)) {
+ if(writeInlineComments()) {
+ increaseIndent(true, false);
+ writeIndent();
+ indent = indents.pop();
+ }
+ }
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ if(!blockCommentsCollector.isEmpty()) {
+ increaseIndent(true, false);
+ writeBlockComment();
+ writeIndent();
+ indent = indents.pop();
+ }
+ states.push(new ExpectBlockMappingKey(false));
+ expectNode(false, true, false);
+ inlineCommentsCollector.collectEvents();
+ writeInlineComments();
+ }
+ }
+
+ private class ExpectBlockMappingValue implements EmitterState {
+ public void expect() throws IOException {
+ writeIndent();
+ writeIndicator(":", true, false, true);
+ event = inlineCommentsCollector.collectEventsAndPoll(event);
+ writeInlineComments();
+ event = blockCommentsCollector.collectEventsAndPoll(event);
+ writeBlockComment();
+ states.push(new ExpectBlockMappingKey(false));
+ expectNode(false, true, false);
+ inlineCommentsCollector.collectEvents(event);
+ writeInlineComments();
+ }
+ }
+
+ // Checkers.
+
+ private boolean checkEmptySequence() {
+ return event instanceof SequenceStartEvent && !events.isEmpty() && events.peek() instanceof SequenceEndEvent;
+ }
+
+ private boolean checkEmptyMapping() {
+ return event instanceof MappingStartEvent && !events.isEmpty() && events.peek() instanceof MappingEndEvent;
+ }
+
+ private boolean checkEmptyDocument() {
+ if (!(event instanceof DocumentStartEvent) || events.isEmpty()) {
+ return false;
+ }
+ Event event = events.peek();
+ if (event instanceof ScalarEvent) {
+ ScalarEvent e = (ScalarEvent) event;
+ return e.getAnchor() == null && e.getTag() == null && e.getImplicit() != null && e
+ .getValue().length() == 0;
+ }
+ return false;
+ }
+
+ private boolean checkSimpleKey() {
+ int length = 0;
+ if (event instanceof NodeEvent && ((NodeEvent) event).getAnchor() != null) {
+ if (preparedAnchor == null) {
+ preparedAnchor = prepareAnchor(((NodeEvent) event).getAnchor());
+ }
+ length += preparedAnchor.length();
+ }
+ String tag = null;
+ if (event instanceof ScalarEvent) {
+ tag = ((ScalarEvent) event).getTag();
+ } else if (event instanceof CollectionStartEvent) {
+ tag = ((CollectionStartEvent) event).getTag();
+ }
+ if (tag != null) {
+ if (preparedTag == null) {
+ preparedTag = prepareTag(tag);
+ }
+ length += preparedTag.length();
+ }
+ if (event instanceof ScalarEvent) {
+ if (analysis == null) {
+ analysis = analyzeScalar(((ScalarEvent) event).getValue());
+ }
+ length += analysis.getScalar().length();
+ }
+ return length < maxSimpleKeyLength && (event instanceof AliasEvent
+ || (event instanceof ScalarEvent && !analysis.isEmpty() && !analysis.isMultiline())
+ || checkEmptySequence() || checkEmptyMapping());
+ }
+
+ // Anchor, Tag, and Scalar processors.
+
+ private void processAnchor(String indicator) throws IOException {
+ NodeEvent ev = (NodeEvent) event;
+ if (ev.getAnchor() == null) {
+ preparedAnchor = null;
+ return;
+ }
+ if (preparedAnchor == null) {
+ preparedAnchor = prepareAnchor(ev.getAnchor());
+ }
+ writeIndicator(indicator + preparedAnchor, true, false, false);
+ preparedAnchor = null;
+ }
+
+ private void processTag() throws IOException {
+ String tag = null;
+ if (event instanceof ScalarEvent) {
+ ScalarEvent ev = (ScalarEvent) event;
+ tag = ev.getTag();
+ if (style == null) {
+ style = chooseScalarStyle();
+ }
+ if ((!canonical || tag == null) && ((style == null && ev.getImplicit()
+ .canOmitTagInPlainScalar()) || (style != null && ev.getImplicit()
+ .canOmitTagInNonPlainScalar()))) {
+ preparedTag = null;
+ return;
+ }
+ if (ev.getImplicit().canOmitTagInPlainScalar() && tag == null) {
+ tag = "!";
+ preparedTag = null;
+ }
+ } else {
+ CollectionStartEvent ev = (CollectionStartEvent) event;
+ tag = ev.getTag();
+ if ((!canonical || tag == null) && ev.getImplicit()) {
+ preparedTag = null;
+ return;
+ }
+ }
+ if (tag == null) {
+ throw new EmitterException("tag is not specified");
+ }
+ if (preparedTag == null) {
+ preparedTag = prepareTag(tag);
+ }
+ writeIndicator(preparedTag, true, false, false);
+ preparedTag = null;
+ }
+
+ private DumperOptions.ScalarStyle chooseScalarStyle() {
+ ScalarEvent ev = (ScalarEvent) event;
+ if (analysis == null) {
+ analysis = analyzeScalar(ev.getValue());
+ }
+ if (!ev.isPlain() && ev.getScalarStyle() == DumperOptions.ScalarStyle.DOUBLE_QUOTED || this.canonical) {
+ return DumperOptions.ScalarStyle.DOUBLE_QUOTED;
+ }
+ if (ev.isPlain() && ev.getImplicit().canOmitTagInPlainScalar()) {
+ if (!(simpleKeyContext && (analysis.isEmpty() || analysis.isMultiline()))
+ && ((flowLevel != 0 && analysis.isAllowFlowPlain()) || (flowLevel == 0 && analysis.isAllowBlockPlain()))) {
+ return null;
+ }
+ }
+ if (!ev.isPlain() && (ev.getScalarStyle() == DumperOptions.ScalarStyle.LITERAL || ev.getScalarStyle() == DumperOptions.ScalarStyle.FOLDED)) {
+ if (flowLevel == 0 && !simpleKeyContext && analysis.isAllowBlock()) {
+ return ev.getScalarStyle();
+ }
+ }
+ if (ev.isPlain() || ev.getScalarStyle() == DumperOptions.ScalarStyle.SINGLE_QUOTED) {
+ if (analysis.isAllowSingleQuoted() && !(simpleKeyContext && analysis.isMultiline())) {
+ return DumperOptions.ScalarStyle.SINGLE_QUOTED;
+ }
+ }
+ return DumperOptions.ScalarStyle.DOUBLE_QUOTED;
+ }
+
+ private void processScalar() throws IOException {
+ ScalarEvent ev = (ScalarEvent) event;
+ if (analysis == null) {
+ analysis = analyzeScalar(ev.getValue());
+ }
+ if (style == null) {
+ style = chooseScalarStyle();
+ }
+ boolean split = !simpleKeyContext && splitLines;
+ if (style == null) {
+ writePlain(analysis.getScalar(), split);
+ } else {
+ switch (style) {
+ case DOUBLE_QUOTED:
+ writeDoubleQuoted(analysis.getScalar(), split);
+ break;
+ case SINGLE_QUOTED:
+ writeSingleQuoted(analysis.getScalar(), split);
+ break;
+ case FOLDED:
+ writeFolded(analysis.getScalar(), split);
+ break;
+ case LITERAL:
+ writeLiteral(analysis.getScalar());
+ break;
+ default:
+ throw new YAMLException("Unexpected style: " + style);
+ }
+ }
+ analysis = null;
+ style = null;
+ }
+
+ // Analyzers.
+
+ private String prepareVersion(Version version) {
+ if (version.major() != 1) {
+ throw new EmitterException("unsupported YAML version: " + version);
+ }
+ return version.getRepresentation();
+ }
+
+ private final static Pattern HANDLE_FORMAT = Pattern.compile("^![-_\\w]*!$");
+
+ private String prepareTagHandle(String handle) {
+ if (handle.length() == 0) {
+ throw new EmitterException("tag handle must not be empty");
+ } else if (handle.charAt(0) != '!' || handle.charAt(handle.length() - 1) != '!') {
+ throw new EmitterException("tag handle must start and end with '!': " + handle);
+ } else if (!"!".equals(handle) && !HANDLE_FORMAT.matcher(handle).matches()) {
+ throw new EmitterException("invalid character in the tag handle: " + handle);
+ }
+ return handle;
+ }
+
+ private String prepareTagPrefix(String prefix) {
+ if (prefix.length() == 0) {
+ throw new EmitterException("tag prefix must not be empty");
+ }
+ StringBuilder chunks = new StringBuilder();
+ int start = 0;
+ int end = 0;
+ if (prefix.charAt(0) == '!') {
+ end = 1;
+ }
+ while (end < prefix.length()) {
+ end++;
+ }
+ if (start < end) {
+ chunks.append(prefix, start, end);
+ }
+ return chunks.toString();
+ }
+
+ private String prepareTag(String tag) {
+ if (tag.length() == 0) {
+ throw new EmitterException("tag must not be empty");
+ }
+ if ("!".equals(tag)) {
+ return tag;
+ }
+ String handle = null;
+ String suffix = tag;
+ // shall the tag prefixes be sorted as in PyYAML?
+ for (String prefix : tagPrefixes.keySet()) {
+ if (tag.startsWith(prefix) && ("!".equals(prefix) || prefix.length() < tag.length())) {
+ handle = prefix;
+ }
+ }
+ if (handle != null) {
+ suffix = tag.substring(handle.length());
+ handle = tagPrefixes.get(handle);
+ }
+
+ int end = suffix.length();
+ String suffixText = end > 0 ? suffix.substring(0, end) : "";
+
+ if (handle != null) {
+ return handle + suffixText;
+ }
+ return "!<" + suffixText + ">";
+ }
+
+ static String prepareAnchor(String anchor) {
+ if (anchor.length() == 0) {
+ throw new EmitterException("anchor must not be empty");
+ }
+ for (Character invalid : INVALID_ANCHOR) {
+ if (anchor.indexOf(invalid) > -1) {
+ throw new EmitterException("Invalid character '" + invalid + "' in the anchor: " + anchor);
+ }
+ }
+ Matcher matcher = SPACES_PATTERN.matcher(anchor);
+ if (matcher.find()) {
+ throw new EmitterException("Anchor may not contain spaces: " + anchor);
+ }
+ return anchor;
+ }
+
+ private ScalarAnalysis analyzeScalar(String scalar) {
+ // Empty scalar is a special case.
+ if (scalar.length() == 0) {
+ return new ScalarAnalysis(scalar, true, false, false, true, true, false);
+ }
+ // Indicators and special characters.
+ boolean blockIndicators = false;
+ boolean flowIndicators = false;
+ boolean lineBreaks = false;
+ boolean specialCharacters = false;
+
+ // Important whitespace combinations.
+ boolean leadingSpace = false;
+ boolean leadingBreak = false;
+ boolean trailingSpace = false;
+ boolean trailingBreak = false;
+ boolean breakSpace = false;
+ boolean spaceBreak = false;
+
+ // Check document indicators.
+ if (scalar.startsWith("---") || scalar.startsWith("...")) {
+ blockIndicators = true;
+ flowIndicators = true;
+ }
+ // First character or preceded by a whitespace.
+ boolean preceededByWhitespace = true;
+ boolean followedByWhitespace = scalar.length() == 1 || Constant.NULL_BL_T_LINEBR.has(scalar.codePointAt(1));
+ // The previous character is a space.
+ boolean previousSpace = false;
+
+ // The previous character is a break.
+ boolean previousBreak = false;
+
+ int index = 0;
+
+ while (index < scalar.length()) {
+ int c = scalar.codePointAt(index);
+ // Check for indicators.
+ if (index == 0) {
+ // Leading indicators are special characters.
+ if ("#,[]{}&*!|>'\"%@`".indexOf(c) != -1) {
+ flowIndicators = true;
+ blockIndicators = true;
+ }
+ if (c == '?' || c == ':') {
+ flowIndicators = true;
+ if (followedByWhitespace) {
+ blockIndicators = true;
+ }
+ }
+ if (c == '-' && followedByWhitespace) {
+ flowIndicators = true;
+ blockIndicators = true;
+ }
+ } else {
+ // Some indicators cannot appear within a scalar as well.
+ if (",?[]{}".indexOf(c) != -1) {
+ flowIndicators = true;
+ }
+ if (c == ':') {
+ flowIndicators = true;
+ if (followedByWhitespace) {
+ blockIndicators = true;
+ }
+ }
+ if (c == '#' && preceededByWhitespace) {
+ flowIndicators = true;
+ blockIndicators = true;
+ }
+ }
+ // Check for line breaks, special, and unicode characters.
+ boolean isLineBreak = Constant.LINEBR.has(c);
+ if (isLineBreak) {
+ lineBreaks = true;
+ }
+ if (!(c == '\n' || (0x20 <= c && c <= 0x7E))) {
+ if (c == 0x85 || (c >= 0xA0 && c <= 0xD7FF)
+ || (c >= 0xE000 && c <= 0xFFFD)
+ || (c >= 0x10000 && c <= 0x10FFFF)) {
+ // unicode is used
+ if (!this.allowUnicode) {
+ specialCharacters = true;
+ }
+ } else {
+ specialCharacters = true;
+ }
+ }
+ // Detect important whitespace combinations.
+ if (c == ' ') {
+ if (index == 0) {
+ leadingSpace = true;
+ }
+ if (index == scalar.length() - 1) {
+ trailingSpace = true;
+ }
+ if (previousBreak) {
+ breakSpace = true;
+ }
+ previousSpace = true;
+ previousBreak = false;
+ } else if (isLineBreak) {
+ if (index == 0) {
+ leadingBreak = true;
+ }
+ if (index == scalar.length() - 1) {
+ trailingBreak = true;
+ }
+ if (previousSpace) {
+ spaceBreak = true;
+ }
+ previousSpace = false;
+ previousBreak = true;
+ } else {
+ previousSpace = false;
+ previousBreak = false;
+ }
+
+ // Prepare for the next character.
+ index += Character.charCount(c);
+ preceededByWhitespace = Constant.NULL_BL_T.has(c) || isLineBreak;
+ followedByWhitespace = true;
+ if (index + 1 < scalar.length()) {
+ int nextIndex = index + Character.charCount(scalar.codePointAt(index));
+ if (nextIndex < scalar.length()) {
+ followedByWhitespace = (Constant.NULL_BL_T.has(scalar.codePointAt(nextIndex))) || isLineBreak;
+ }
+ }
+ }
+ // Let's decide what styles are allowed.
+ boolean allowFlowPlain = true;
+ boolean allowBlockPlain = true;
+ boolean allowSingleQuoted = true;
+ boolean allowBlock = true;
+ // Leading and trailing whitespaces are bad for plain scalars.
+ if (leadingSpace || leadingBreak || trailingSpace || trailingBreak) {
+ allowFlowPlain = allowBlockPlain = false;
+ }
+ // We do not permit trailing spaces for block scalars.
+ if (trailingSpace) {
+ allowBlock = false;
+ }
+ // Spaces at the beginning of a new line are only acceptable for block
+ // scalars.
+ if (breakSpace) {
+ allowFlowPlain = allowBlockPlain = allowSingleQuoted = false;
+ }
+ // Spaces followed by breaks, as well as special character are only
+ // allowed for double quoted scalars.
+ if (spaceBreak || specialCharacters) {
+ allowFlowPlain = allowBlockPlain = allowSingleQuoted = allowBlock = false;
+ }
+ // Although the plain scalar writer supports breaks, we never emit
+ // multiline plain scalars in the flow context.
+ if (lineBreaks) {
+ allowFlowPlain = false;
+ }
+ // Flow indicators are forbidden for flow plain scalars.
+ if (flowIndicators) {
+ allowFlowPlain = false;
+ }
+ // Block indicators are forbidden for block plain scalars.
+ if (blockIndicators) {
+ allowBlockPlain = false;
+ }
+
+ return new ScalarAnalysis(scalar, false, lineBreaks, allowFlowPlain, allowBlockPlain,
+ allowSingleQuoted, allowBlock);
+ }
+
+ // Writers.
+
+ void flushStream() throws IOException {
+ stream.flush();
+ }
+
+ void writeStreamStart() {
+ // BOM is written by Writer.
+ }
+
+ void writeStreamEnd() throws IOException {
+ flushStream();
+ }
+
+ void writeIndicator(String indicator, boolean needWhitespace, boolean whitespace,
+ boolean indentation) throws IOException {
+ if (!this.whitespace && needWhitespace) {
+ this.column++;
+ stream.write(SPACE);
+ }
+ this.whitespace = whitespace;
+ this.indention = this.indention && indentation;
+ this.column += indicator.length();
+ openEnded = false;
+ stream.write(indicator);
+ }
+
+ void writeIndent() throws IOException {
+ int indent;
+ if (this.indent != null) {
+ indent = this.indent;
+ } else {
+ indent = 0;
+ }
+
+ if (!this.indention || this.column > indent || (this.column == indent && !this.whitespace)) {
+ writeLineBreak(null);
+ }
+
+ writeWhitespace(indent - this.column);
+ }
+
+ private void writeWhitespace(int length) throws IOException {
+ if (length <= 0) {
+ return;
+ }
+ this.whitespace = true;
+ char[] data = new char[length];
+ for (int i = 0; i < data.length; i++) {
+ data[i] = ' ';
+ }
+ this.column += length;
+ stream.write(data);
+ }
+
+ private void writeLineBreak(String data) throws IOException {
+ this.whitespace = true;
+ this.indention = true;
+ this.column = 0;
+ if (data == null) {
+ stream.write(this.bestLineBreak);
+ } else {
+ stream.write(data);
+ }
+ }
+
+ void writeVersionDirective(String versionText) throws IOException {
+ stream.write("%YAML ");
+ stream.write(versionText);
+ writeLineBreak(null);
+ }
+
+ void writeTagDirective(String handleText, String prefixText) throws IOException {
+ // XXX: not sure 4 invocations better then StringBuilders created by str
+ // + str
+ stream.write("%TAG ");
+ stream.write(handleText);
+ stream.write(SPACE);
+ stream.write(prefixText);
+ writeLineBreak(null);
+ }
+
+ // Scalar streams.
+ private void writeSingleQuoted(String text, boolean split) throws IOException {
+ writeIndicator("'", true, false, false);
+ boolean spaces = false;
+ boolean breaks = false;
+ int start = 0, end = 0;
+ char ch;
+ while (end <= text.length()) {
+ ch = 0;
+ if (end < text.length()) {
+ ch = text.charAt(end);
+ }
+ if (spaces) {
+ if (ch == 0 || ch != ' ') {
+ if (start + 1 == end && this.column > this.bestWidth && split && start != 0
+ && end != text.length()) {
+ writeIndent();
+ } else {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ }
+ start = end;
+ }
+ } else if (breaks) {
+ if (ch == 0 || Constant.LINEBR.hasNo(ch)) {
+ if (text.charAt(start) == '\n') {
+ writeLineBreak(null);
+ }
+ String data = text.substring(start, end);
+ for (char br : data.toCharArray()) {
+ if (br == '\n') {
+ writeLineBreak(null);
+ } else {
+ writeLineBreak(String.valueOf(br));
+ }
+ }
+ writeIndent();
+ start = end;
+ }
+ } else {
+ if (Constant.LINEBR.has(ch, "\0 '")) {
+ if (start < end) {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ start = end;
+ }
+ }
+ }
+ if (ch == '\'') {
+ this.column += 2;
+ stream.write("''");
+ start = end + 1;
+ }
+ if (ch != 0) {
+ spaces = ch == ' ';
+ breaks = Constant.LINEBR.has(ch);
+ }
+ end++;
+ }
+ writeIndicator("'", false, false, false);
+ }
+
+ private void writeDoubleQuoted(String text, boolean split) throws IOException {
+ writeIndicator("\"", true, false, false);
+ int start = 0;
+ int end = 0;
+ while (end <= text.length()) {
+ Character ch = null;
+ if (end < text.length()) {
+ ch = text.charAt(end);
+ }
+ if (ch == null || "\"\\\u0085\u2028\u2029\uFEFF".indexOf(ch) != -1
+ || !('\u0020' <= ch && ch <= '\u007E')) {
+ if (start < end) {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ start = end;
+ }
+ if (ch != null) {
+ String data;
+ if (ESCAPE_REPLACEMENTS.containsKey(ch)) {
+ data = "\\" + ESCAPE_REPLACEMENTS.get(ch);
+ } else if (!this.allowUnicode || !StreamReader.isPrintable(ch)) {
+ // if !allowUnicode or the character is not printable,
+ // we must encode it
+ if (ch <= '\u00FF') {
+ String s = "0" + Integer.toString(ch, 16);
+ data = "\\x" + s.substring(s.length() - 2);
+ } else if (ch >= '\uD800' && ch <= '\uDBFF') {
+ if (end + 1 < text.length()) {
+ Character ch2 = text.charAt(++end);
+ String s = "000" + Long.toHexString(Character.toCodePoint(ch, ch2));
+ data = "\\U" + s.substring(s.length() - 8);
+ } else {
+ String s = "000" + Integer.toString(ch, 16);
+ data = "\\u" + s.substring(s.length() - 4);
+ }
+ } else {
+ String s = "000" + Integer.toString(ch, 16);
+ data = "\\u" + s.substring(s.length() - 4);
+ }
+ } else {
+ data = String.valueOf(ch);
+ }
+ this.column += data.length();
+ stream.write(data);
+ start = end + 1;
+ }
+ }
+ if ((0 < end && end < (text.length() - 1)) && (ch == ' ' || start >= end)
+ && (this.column + (end - start)) > this.bestWidth && split) {
+ String data;
+ if (start >= end) {
+ data = "\\";
+ } else {
+ data = text.substring(start, end) + "\\";
+ }
+ if (start < end) {
+ start = end;
+ }
+ this.column += data.length();
+ stream.write(data);
+ writeIndent();
+ this.whitespace = false;
+ this.indention = false;
+ if (text.charAt(start) == ' ') {
+ data = "\\";
+ this.column += data.length();
+ stream.write(data);
+ }
+ }
+ end += 1;
+ }
+ writeIndicator("\"", false, false, false);
+ }
+
+ private boolean writeCommentLines(List<CommentLine> commentLines) throws IOException {
+ boolean wroteComment = false;
+ if(emitComments) {
+ int indentColumns = 0;
+ boolean firstComment = true;
+ for (CommentLine commentLine : commentLines) {
+ if (commentLine.getCommentType() != CommentType.BLANK_LINE) {
+ if (firstComment) {
+ firstComment = false;
+ writeIndicator("#", commentLine.getCommentType() == CommentType.IN_LINE, false, false);
+ indentColumns = this.column > 0 ? this.column - 1 : 0;
+ } else {
+ writeWhitespace(indentColumns);
+ writeIndicator("#", false, false, false);
+ }
+ stream.write(commentLine.getValue());
+ writeLineBreak(null);
+ } else {
+ writeLineBreak(null);
+ writeIndent();
+ }
+ wroteComment = true;
+ }
+ }
+ return wroteComment;
+ }
+
+ private void writeBlockComment() throws IOException {
+ if(!blockCommentsCollector.isEmpty()) {
+ writeIndent();
+ writeCommentLines(blockCommentsCollector.consume());
+ }
+ }
+
+ private boolean writeInlineComments() throws IOException {
+ return writeCommentLines(inlineCommentsCollector.consume());
+ }
+
+ private String determineBlockHints(String text) {
+ StringBuilder hints = new StringBuilder();
+ if (Constant.LINEBR.has(text.charAt(0), " ")) {
+ hints.append(bestIndent);
+ }
+ char ch1 = text.charAt(text.length() - 1);
+ if (Constant.LINEBR.hasNo(ch1)) {
+ hints.append("-");
+ } else if (text.length() == 1 || Constant.LINEBR.has(text.charAt(text.length() - 2))) {
+ hints.append("+");
+ }
+ return hints.toString();
+ }
+
+ void writeFolded(String text, boolean split) throws IOException {
+ String hints = determineBlockHints(text);
+ writeIndicator(">" + hints, true, false, false);
+ if (hints.length() > 0 && (hints.charAt(hints.length() - 1) == '+')) {
+ openEnded = true;
+ }
+ if(!writeInlineComments()) {
+ writeLineBreak(null);
+ }
+ boolean leadingSpace = true;
+ boolean spaces = false;
+ boolean breaks = true;
+ int start = 0, end = 0;
+ while (end <= text.length()) {
+ char ch = 0;
+ if (end < text.length()) {
+ ch = text.charAt(end);
+ }
+ if (breaks) {
+ if (ch == 0 || Constant.LINEBR.hasNo(ch)) {
+ if (!leadingSpace && ch != 0 && ch != ' ' && text.charAt(start) == '\n') {
+ writeLineBreak(null);
+ }
+ leadingSpace = ch == ' ';
+ String data = text.substring(start, end);
+ for (char br : data.toCharArray()) {
+ if (br == '\n') {
+ writeLineBreak(null);
+ } else {
+ writeLineBreak(String.valueOf(br));
+ }
+ }
+ if (ch != 0) {
+ writeIndent();
+ }
+ start = end;
+ }
+ } else if (spaces) {
+ if (ch != ' ') {
+ if (start + 1 == end && this.column > this.bestWidth && split) {
+ writeIndent();
+ } else {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ }
+ start = end;
+ }
+ } else {
+ if (Constant.LINEBR.has(ch, "\0 ")) {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ if (ch == 0) {
+ writeLineBreak(null);
+ }
+ start = end;
+ }
+ }
+ if (ch != 0) {
+ breaks = Constant.LINEBR.has(ch);
+ spaces = ch == ' ';
+ }
+ end++;
+ }
+ }
+
+ void writeLiteral(String text) throws IOException {
+ String hints = determineBlockHints(text);
+ writeIndicator("|" + hints, true, false, false);
+ if (hints.length() > 0 && (hints.charAt(hints.length() - 1)) == '+') {
+ openEnded = true;
+ }
+ if(!writeInlineComments()) {
+ writeLineBreak(null);
+ }
+ boolean breaks = true;
+ int start = 0, end = 0;
+ while (end <= text.length()) {
+ char ch = 0;
+ if (end < text.length()) {
+ ch = text.charAt(end);
+ }
+ if (breaks) {
+ if (ch == 0 || Constant.LINEBR.hasNo(ch)) {
+ String data = text.substring(start, end);
+ for (char br : data.toCharArray()) {
+ if (br == '\n') {
+ writeLineBreak(null);
+ } else {
+ writeLineBreak(String.valueOf(br));
+ }
+ }
+ if (ch != 0) {
+ writeIndent();
+ }
+ start = end;
+ }
+ } else {
+ if (ch == 0 || Constant.LINEBR.has(ch)) {
+ stream.write(text, start, end - start);
+ if (ch == 0) {
+ writeLineBreak(null);
+ }
+ start = end;
+ }
+ }
+ if (ch != 0) {
+ breaks = Constant.LINEBR.has(ch);
+ }
+ end++;
+ }
+ }
+
+ void writePlain(String text, boolean split) throws IOException {
+ if (rootContext) {
+ openEnded = true;
+ }
+ if (text.length() == 0) {
+ return;
+ }
+ if (!this.whitespace) {
+ this.column++;
+ stream.write(SPACE);
+ }
+ this.whitespace = false;
+ this.indention = false;
+ boolean spaces = false;
+ boolean breaks = false;
+ int start = 0, end = 0;
+ while (end <= text.length()) {
+ char ch = 0;
+ if (end < text.length()) {
+ ch = text.charAt(end);
+ }
+ if (spaces) {
+ if (ch != ' ') {
+ if (start + 1 == end && this.column > this.bestWidth && split) {
+ writeIndent();
+ this.whitespace = false;
+ this.indention = false;
+ } else {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ }
+ start = end;
+ }
+ } else if (breaks) {
+ if (Constant.LINEBR.hasNo(ch)) {
+ if (text.charAt(start) == '\n') {
+ writeLineBreak(null);
+ }
+ String data = text.substring(start, end);
+ for (char br : data.toCharArray()) {
+ if (br == '\n') {
+ writeLineBreak(null);
+ } else {
+ writeLineBreak(String.valueOf(br));
+ }
+ }
+ writeIndent();
+ this.whitespace = false;
+ this.indention = false;
+ start = end;
+ }
+ } else {
+ if (Constant.LINEBR.has(ch, "\0 ")) {
+ int len = end - start;
+ this.column += len;
+ stream.write(text, start, len);
+ start = end;
+ }
+ }
+ if (ch != 0) {
+ spaces = ch == ' ';
+ breaks = Constant.LINEBR.has(ch);
+ }
+ end++;
+ }
+ }
+}
Reference in a new issue View git blame Copy permalink