use std::ops::Range;
pub(super) fn for_value(text: &str) -> Option<(&str, &str)> {
split(text, "in")
}
pub(super) fn if_let_value(text: &str) -> Option<(&str, &str)> {
let mut offset = 0;
let keyword = token(text, &mut offset)?;
if &text[keyword] != "let" {
return None;
}
split(&text[offset..], "=")
}
fn split<'a>(text: &'a str, separator: &str) -> Option<(&'a str, &'a str)> {
let mut offset = 0;
let first = token(text, &mut offset)?;
let mut end = first.end;
while let Some(next) = token(text, &mut offset) {
if &text[next.clone()] == separator {
let right = token(text, &mut offset)?;
let mut right_end = right.end;
while let Some(next) = token(text, &mut offset) {
right_end = next.end;
}
return Some((&text[first.start..end], &text[right.start..right_end]));
}
end = next.end;
}
None
}
fn token(text: &str, offset: &mut usize) -> Option<Range<usize>> {
let bytes = text.as_bytes();
loop {
match bytes.get(*offset)? {
byte if byte.is_ascii_whitespace() => *offset += 1,
b'/' if bytes.get(*offset + 1) == Some(&b'/') => {
*offset += 2;
while bytes
.get(*offset)
.is_some_and(|b| !matches!(b, b'\n' | b'\r'))
{
*offset += 1;
}
}
b'/' if bytes.get(*offset + 1) == Some(&b'*') => {
*offset += 2;
let mut depth = 1;
while depth > 0 {
match bytes.get(*offset..*offset + 2)? {
b"/*" => {
depth += 1;
*offset += 2;
}
b"*/" => {
depth -= 1;
*offset += 2;
}
_ => *offset += 1,
}
}
}
_ => break,
}
}
let start = *offset;
let raw_start = if matches!(bytes[start], b'b' | b'c') {
start + 1
} else {
start
};
if bytes.get(raw_start) == Some(&b'r') {
let mut quote = raw_start + 1;
while bytes.get(quote) == Some(&b'#') {
quote += 1;
}
if bytes.get(quote) == Some(&b'"') {
*offset = string_end(bytes, quote, Some(quote - raw_start - 1))?;
return Some(start..*offset);
}
}
let quoted = if matches!(bytes[start], b'b' | b'c') {
start + 1
} else {
start
};
if bytes.get(quoted) == Some(&b'"') {
*offset = string_end(bytes, quoted, None)?;
} else if bytes.get(quoted) == Some(&b'\'') {
let inner = quoted + 1;
if bytes.get(inner) == Some(&b'\\') {
let mut end = inner + 2;
while *bytes.get(end)? != b'\'' {
end += 1;
}
*offset = end + 1;
} else {
let character = text.get(inner..)?.chars().next()?;
*offset = if bytes.get(inner + character.len_utf8()) == Some(&b'\'') {
inner + character.len_utf8() + 1
} else {
quoted + 1
};
}
} else if let Some(close) = match bytes[start] {
b'(' => Some(b')'),
b'[' => Some(b']'),
b'{' => Some(b'}'),
_ => None,
} {
*offset += 1;
loop {
let nested = token(text, offset)?;
if bytes[nested.start] == close {
break;
}
}
} else if identifier(bytes[start]) {
*offset += if bytes[start..].starts_with(b"r#") {
2
} else {
1
};
while bytes.get(*offset).is_some_and(|byte| identifier(*byte)) {
*offset += 1;
}
} else {
let operators = [
"<<=", ">>=", "..=", "==", "=>", "<=", ">=", "!=", "+=", "-=", "*=", "/=", "%=", "^=",
"&=", "|=",
];
*offset += operators
.iter()
.find(|op| text[start..].starts_with(**op))
.map_or(1, |op| op.len());
}
Some(start..*offset)
}
fn identifier(byte: u8) -> bool {
byte.is_ascii_alphanumeric() || byte == b'_' || !byte.is_ascii()
}
fn string_end(bytes: &[u8], quote: usize, hashes: Option<usize>) -> Option<usize> {
let mut i = quote + 1;
while i < bytes.len() {
match bytes[i] {
b'\\' if hashes.is_none() => i += 2,
b'"' => {
i += 1;
let count = hashes.unwrap_or(0);
if bytes.get(i..i + count)?.iter().all(|byte| *byte == b'#') {
return Some(i + count);
}
}
_ => i += 1,
}
}
None
}