// Port of `LossyUtf8` and `format_sexp` from tree-sitter
// lib/binding_rust/lib.rs.
///|
/// An iterator over the UTF-8 decoded chunks of a byte string, yielding
/// `"\u{FFFD}"` for each invalid sequence.
pub struct LossyUtf8 {
priv mut bytes : BytesView
priv mut in_replacement : Bool
}
///|
/// Create a lossy UTF-8 iterator over `bytes`.
pub fn LossyUtf8::new(bytes : BytesView) -> LossyUtf8 {
{ bytes, in_replacement: false, }
}
///|
/// The next chunk: a maximal valid run of text, or a replacement character.
pub fn LossyUtf8::next(self : LossyUtf8) -> String? {
if self.bytes.length() == 0 {
return None
}
if self.in_replacement {
self.in_replacement = false
return Some("\u{fffd}")
}
try @hir.from_utf8(self.bytes) catch {
Utf8Error(valid_up_to=error_start, error_len~) =>
match error_len {
Some(error_len) =>
if error_start > 0 {
let result = @utf8.decode_lossy(self.bytes[:error_start])
self.bytes = self.bytes[error_start + error_len:]
self.in_replacement = true
Some(result)
} else {
self.bytes = self.bytes[error_len:]
Some("\u{fffd}")
}
None => None
}
} noraise {
_ => {
let valid = @utf8.decode_lossy(self.bytes)
self.bytes = b""[:]
Some(valid)
}
}
}
///|
/// Iterate the remaining chunks.
pub fn LossyUtf8::iter(self : LossyUtf8) -> Iter[String] {
Iter::new(() => self.next())
}
///|
/// Pretty-print an S-expression produced by [`Node::to_sexp`], one node per
/// line, indenting nested nodes by two spaces per level starting at
/// `initial_indent_level` (upstream's `{:#}` formatting of a node).
pub fn format_sexp(sexp : String, initial_indent_level : Int32) -> String {
let chars = sexp.iter().to_array()
let mut pos = 0
let mut indent_level = initial_indent_level
let formatted = StringBuilder()
let mut has_field = false
let mut quote = '\u{0}'
let mut saw_paren = false
let mut did_last = false
let scratch = StringBuilder()
let peek = () => if pos < chars.length() { Some(chars[pos]) } else { None }
let fetch_next_str = () => {
scratch.reset()
while pos < chars.length() {
let c = chars[pos]
pos += 1
if c == '\'' || c == '"' {
quote = c
} else if c == ' ' || (c == ')' && quote != '\u{0}') {
if peek() is Some(next_c) && next_c == quote {
scratch.write_char(c)
scratch.write_char(next_c)
pos += 1
quote = '\u{0}'
continue
}
break
}
if c == ')' {
saw_paren = true
break
}
scratch.write_char(c)
}
// at the end
if peek() is None && scratch.is_empty() {
if saw_paren {
// but did we see a ) before ending?
saw_paren = false
return true
}
if !did_last {
// but did we account for the end empty string as if we're splitting?
did_last = true
return true
}
return false
}
true
}
let indent = () => {
for _ in 0.. 0 {
// ")"
indent_level -= 1
formatted.write_string(")")
} else if s.has_prefix("(") {
if has_field {
has_field = false
} else {
if indent_level > 0 {
formatted.write_string("\n")
indent()
}
indent_level += 1
}
// "(node_name"
formatted.write_string(s)
// "(MISSING node_name" or "(UNEXPECTED 'x'"
if s.has_prefix("(MISSING") || s.has_prefix("(UNEXPECTED") {
guard fetch_next_str() else { abort("unexpected end of S-expression") }
let next = scratch.to_string()
if next.is_empty() {
while indent_level > 0 {
indent_level -= 1
formatted.write_string(")")
}
} else {
formatted.write_string(" \{next}")
}
}
} else if s.has_suffix(":") {
// "field:"
formatted.write_string("\n")
indent()
formatted.write_string("\{s} ")
has_field = true
indent_level += 1
}
}
formatted.to_string()
}