static <T> Segment<T> newSegment(T source, int start, int length) {
Segment segment = new Segment();
segment.source = source;
segment.start = start;
segment.length = length;
return segment;
}
private int totalSize(List<Segment> unsortedSegments) {
int totalSize = 0;
for (Segment segment : unsortedSegments) {
totalSize += segment.length();
}
return totalSize;
}
public void reset(int pos, char[] buffer) {
if (pos < 0 && activeSegments.size() == 1) {
return;
}
while (true) {
Segment<T> lastActiveSegment = activeSegments.peekLast();
if (pos < lastActiveSegment.start - 1) {
// segment is removed if root, and last suspended segment is merged
// with last active segment if it is the same source
if (lastActiveSegment.root) {
activeSegments.removeLast();
activeLength -= lastActiveSegment.length;
freeLength += lastActiveSegment.length;
lastActiveSegment = activeSegments.peekLast();
Segment<T> lastSuspendedSegment = suspendedSegments.peekLast();
if (lastSuspendedSegment != null
&& lastSuspendedSegment.source.equals(lastActiveSegment.source)) {
lastActiveSegment.length += lastSuspendedSegment.length;
// move data in buffer : suspended space -> active space
System.arraycopy(
buffer,
lastSuspendedSegment.start,
buffer,
activeLength,
lastSuspendedSegment.length);
suspendedSegments.removeLast();
activeLength += lastSuspendedSegment.length;
suspendedLength -= lastSuspendedSegment.length;
}
continue;
}
// segment is suspended if not root
activeSegments.removeLast();
suspendedSegments.addLast(lastActiveSegment);
int startInSuspendedSpace = size - suspendedLength - lastActiveSegment.length;
// move data in buffer : active space -> suspended space
System.arraycopy(
buffer,
lastActiveSegment.start,
buffer,
startInSuspendedSpace,
lastActiveSegment.length);
lastActiveSegment.start = startInSuspendedSpace;
activeLength -= lastActiveSegment.length;
suspendedLength += lastActiveSegment.length;
} else {
break;
}
}
}
public void newDataAdded(int size) {
this.activeLength += size;
this.freeLength -= size;
Segment<T> lastSource = activeSegments.peekLast();
if (lastSource != null) {
lastSource.length += size;
}
}
private void validateRegions() {
if (region_map == null) return;
synchronized (region_map) {
if (regions_valid) return;
Segment s = new Segment();
region_map.clear();
for (BaleRegion br : fragment_regions) {
RegionData rd = new RegionData(indent_size);
region_map.put(br, rd);
int soff = br.getStart();
int eoff = br.getEnd();
if (eoff < soff) continue;
try {
base_document.getText(soff, eoff - soff, s);
} catch (BadLocationException e) {
BoardLog.logE("BALE", "Problem getting region indentation", e);
continue;
}
int ln = s.length();
LineData ld;
boolean sol = true;
for (int i = 0; i < ln; ++i) {
char c = s.charAt(i);
if (sol) {
ld = computeLineData(i, s);
rd.add(ld);
sol = false;
}
if (c == '\n') sol = true;
}
if (!sol) {
ld = computeLineData(ln, s);
rd.add(ld);
++ln;
}
}
regions_valid = true;
}
}
public void consume(int size) {
this.activeLength -= size;
this.freeLength += size;
// remove from active segments
int removed = 0;
for (Iterator<Segment<T>> it = activeSegments.iterator(); it.hasNext(); ) {
Segment<T> segment = it.next();
int remaining = size - removed;
int sizeToRemove = Math.min(remaining, segment.length);
segment.length -= sizeToRemove;
segment.start -= removed;
removed += sizeToRemove;
if (segment.length == 0 && activeSegments.size() > 1) {
it.remove();
}
}
}
/** ***************************************************************************** */
private LineData computeLineData(int offset, Segment s) {
int delchar = 0;
int addchar = 0;
int indent = 0;
int ln = s.length();
boolean havetab = false;
for (int i = offset; indent < indent_size; ++i) {
char c = (i < ln ? s.charAt(i) : '\n');
if (c == ' ') {
++indent;
++delchar;
} else if (c == '\t') {
havetab = true;
indent = nextTabPosition(indent);
if (indent > indent_size) {
delchar = (i - offset + 1);
addchar = indent - indent_size;
break;
} else {
++delchar;
}
} else if (c == '\n') {
if (havetab) {
delchar = (i - offset);
addchar = indent_size;
} else {
addchar = indent_size - (i - offset);
}
break;
} else {
BoardLog.logE("BALE", "Minimum space compute incorrectly");
break;
}
}
return new LineData(offset, addchar, delchar);
}
// segment is divided into two segments :
// the first one remains in active space, but its length is adjusted
// to current position; the second one is added to suspended space
private void suspendSegmentAtPosition(Segment<T> segment, int position, char[] buffer) {
if (segment != null) {
// length of two segments
int len1 = position - segment.start + 1;
int len2 = segment.length - len1;
// don't create suspended segment if no data to suspend
if (len2 == 0) return;
// start of second segment (in suspended space)
int start2 = size - suspendedLength - len2;
segment.length = len1;
suspendedSegments.add(segment.childSegment(start2, len2));
activeLength -= len2;
suspendedLength += len2;
if (len2 > 0) {
System.arraycopy(buffer, position + 1, buffer, start2, len2);
}
}
}
// Documentation inherited from CharStreamSource
public long getEstimatedMaximumOutputLength() {
return segment.length() * 2;
}
boolean getText(Segment brtext, int voff, int len, Segment s) {
s.array = new char[len + 1];
s.count = 0;
s.offset = 0;
if (len == 0) return false;
int spos = 0;
int line = 0;
// first find the line where the data starts
for (int i = 1; i < num_lines; ++i) {
int npos =
spos
+ line_data[i].getOffset()
- line_data[i - 1].getOffset()
+ line_data[i - 1].getViewDelta();
if (voff < npos) break;
spos = npos;
line = i;
}
// now add the data
int pos = spos;
for (int i = line + 1; i < num_lines; ++i) {
int rpos = line_data[i - 1].getOffset();
rpos += line_data[i - 1].getDelete();
int npos =
spos
+ line_data[i].getOffset()
- line_data[i - 1].getOffset()
+ line_data[i - 1].getViewDelta();
int addct = (line_data[i - 1].getDelete() > 0 ? line_data[i - 1].getAdd() : 0);
while (pos < npos) {
char c;
if (pos - spos < addct) c = ' ';
else c = brtext.charAt(rpos + pos - spos - addct);
if (pos >= voff) s.array[s.count++] = c;
if (s.count == len) break;
++pos;
}
spos = npos;
if (s.count == len) break;
}
boolean lastbad = false;
if (s.count < len && num_lines > 0) {
if (pos < voff) pos = voff;
int rpos = line_data[num_lines - 1].getOffset();
rpos += line_data[num_lines - 1].getDelete();
int addct = line_data[num_lines - 1].getAdd();
while (s.count < len) {
char c;
int idx = rpos + pos - spos - addct;
if (pos - spos < addct) c = ' ';
else if (idx < brtext.length()) c = brtext.charAt(idx);
else {
lastbad = true;
c = '\n';
}
s.array[s.count++] = c;
++pos;
}
} else if (s.count < len) {
while (s.count < len) {
s.array[s.count++] = '\n';
}
lastbad = true;
}
return lastbad;
}
/** ***************************************************************************** */
private void setupSpacing() {
// get the tab_size from appropriate property
BoardProperties bp = BoardProperties.getProperties("Bale");
String v = bp.getProperty("indent.tabulation.size");
if (v == null)
v = BumpClient.getBump().getOption("org.eclipse.jdt.core.formatter.tabulation.size");
if (v == null) v = bp.getProperty("Bale.tabsize");
tab_size = 8;
try {
if (v != null) tab_size = Integer.parseInt(v);
} catch (NumberFormatException e) {
}
region_map = null;
regions_valid = true;
indent_size = 0;
indent_string = null;
// determine minimum indent
Segment s = new Segment();
int minsp = -1;
for (BaleRegion br : fragment_regions) {
int soff = br.getStart();
int eoff = br.getEnd();
try {
base_document.getText(soff, eoff - soff, s);
} catch (BadLocationException e) {
BoardLog.logE(
"BALE",
"Problem getting region text "
+ soff
+ " "
+ eoff
+ " "
+ s.length()
+ " "
+ base_document.getLength(),
e);
// should this be "throw e;"
continue;
}
int ln = s.length();
boolean sol = true;
int ind = 0;
for (int i = 0; i < ln && (minsp < 0 || minsp >= MIN_INDENT); ++i) {
char c = s.charAt(i);
if (sol) {
switch (c) {
case ' ':
ind += 1;
break;
case '\t':
ind = nextTabPosition(ind);
break;
case '\n':
ind = 0;
break;
default:
if (minsp < 0 || minsp > ind) minsp = ind;
sol = false;
break;
}
} else if (c == '\n') {
sol = true;
ind = 0;
}
}
if (minsp >= 0 && minsp < MIN_INDENT) break;
}
if (minsp <= 0 || minsp < MIN_INDENT) return;
indent_size = minsp;
indent_string = "";
for (int i = 0; i < minsp; ++i) indent_string += " ";
region_map = new HashMap<BaleRegion, RegionData>();
regions_valid = false;
for (BaleRegion br : fragment_regions) {
for (int i = getRegionLength(br) - 1; i >= 0; --i) {
fixupOffset(br, i, true);
}
}
}