use crate::error::ParseError;
pub(crate) struct Cursor<'a> {
source: &'a str,
pos: usize,
}
impl<'a> Cursor<'a> {
pub(crate) fn new(source: &'a str) -> Self {
Cursor { source, pos: 0 }
}
pub(crate) fn pos(&self) -> usize {
self.pos
}
pub(crate) fn source(&self) -> &'a str {
self.source
}
pub(crate) fn peek(&self) -> Option<char> {
self.source[self.pos..].chars().next()
}
pub(crate) fn peek_byte_ahead(&self, n: usize) -> Option<char> {
self.source[self.pos + n..].chars().next()
}
pub(crate) fn starts_with(&self, s: &str) -> bool {
self.source[self.pos..].starts_with(s)
}
pub(crate) fn bump(&mut self) -> Option<char> {
let c = self.peek()?;
self.pos += c.len_utf8();
Some(c)
}
pub(crate) fn set_pos(&mut self, pos: usize) {
self.pos = pos.min(self.source.len());
}
pub(crate) fn consume_if(&mut self, c: char) -> bool {
if self.peek() == Some(c) {
self.bump();
true
} else {
false
}
}
pub(crate) fn error_at(&self, pos: usize, msg: impl Into<String>) -> ParseError {
ParseError::at(self.source, pos, msg)
}
pub(crate) fn error(&self, msg: impl Into<String>) -> ParseError {
ParseError::at(self.source, self.pos, msg)
}
pub(crate) fn skip_trivia(&mut self) {
loop {
match self.peek() {
Some(c) if c.is_whitespace() => {
self.bump();
}
Some('#') if !self.starts_with("#include") => {
while let Some(c) = self.peek() {
if c == '\n' {
break;
}
self.bump();
}
}
_ => break,
}
}
}
pub(crate) fn read_plain_word(&mut self) -> Option<String> {
let start = self.pos;
while let Some(c) = self.peek() {
if c.is_whitespace()
|| matches!(c, '(' | ')' | ',' | '{' | '}' | '<' | '>' | '"' | '#' | '=')
{
break;
}
if c == '+' && self.peek_byte_ahead(1) == Some('=') {
break;
}
if c == '-' && self.peek_byte_ahead(1) == Some('>') {
break;
}
self.bump();
}
if self.pos == start {
None
} else {
Some(self.source[start..self.pos].to_string())
}
}
pub(crate) fn read_value(&mut self) -> Result<Option<String>, ParseError> {
match self.peek() {
None => Ok(None),
Some('"') => {
let s = self.read_quoted()?;
Ok(Some(s))
}
Some('<') => {
let start = self.pos;
self.bump();
loop {
match self.peek() {
Some('>') => {
self.bump();
break;
}
None => {
return Err(self.error_at(start, "unterminated magic path `<...>`"));
}
Some(_) => {
self.bump();
}
}
}
Ok(Some(self.source[start..self.pos].to_string()))
}
Some('}') => Ok(None),
_ => {
let start = self.pos;
let mut depth = 0usize;
while let Some(c) = self.peek() {
match c {
c if c.is_whitespace() => break,
',' | '(' | ')' => {
if depth == 0 {
break;
}
self.bump();
}
'"' | '#' => break,
'}' => {
if depth == 0 {
break;
}
depth -= 1;
self.bump();
}
'{' => {
depth += 1;
self.bump();
}
'\\' => {
self.bump();
self.bump();
}
_ => {
self.bump();
}
}
}
if depth != 0 {
return Err(self.error_at(start, "unterminated `{...}` in value"));
}
if self.pos == start {
Ok(None)
} else {
Ok(Some(self.source[start..self.pos].to_string()))
}
}
}
}
pub(crate) fn read_quoted(&mut self) -> Result<String, ParseError> {
let start = self.pos;
debug_assert_eq!(self.peek(), Some('"'));
self.bump();
let mut out = String::new();
loop {
match self.peek() {
None => {
return Err(self.error_at(start, "unterminated quoted string"));
}
Some('"') => {
self.bump();
break;
}
Some('\\') => {
self.bump();
match self.bump() {
None => {
return Err(self.error_at(start, "trailing backslash in quoted string"));
}
Some(c) => out.push(c),
}
}
Some(c) => {
out.push(c);
self.bump();
}
}
}
Ok(out)
}
pub(crate) fn read_raw_until_terminator(&mut self) -> String {
let start = self.pos;
let mut brace = 0usize;
let mut paren = 0usize;
while let Some(c) = self.peek() {
match c {
'{' => {
brace += 1;
self.bump();
}
'}' => {
if brace == 0 {
break;
}
brace -= 1;
self.bump();
}
'(' => {
paren += 1;
self.bump();
}
')' => {
paren = paren.saturating_sub(1);
self.bump();
}
',' if brace == 0 && paren == 0 => {
let text = self.source[start..self.pos].trim().to_string();
self.bump();
return text;
}
'\n' if paren == 0 => {
break;
}
'"' => {
self.bump();
while let Some(q) = self.peek() {
if q == '"' || q == '\n' {
break;
}
self.bump();
}
if self.peek() == Some('"') {
self.bump();
}
}
_ => {
self.bump();
}
}
}
self.source[start..self.pos].trim().to_string()
}
}
#[cfg(test)]
mod tests {
use super::Cursor;
fn words(src: &str) -> Vec<String> {
let mut c = Cursor::new(src);
let mut out = Vec::new();
loop {
c.skip_trivia();
let Some(w) = c.read_plain_word() else { break };
out.push(w);
}
out
}
#[test]
fn plain_words() {
assert_eq!(words("capability setuid,"), vec!["capability", "setuid"]);
assert_eq!(words("deny /x r,"), vec!["deny", "/x", "r"]);
}
#[test]
fn plain_word_stops_at_structurals() {
assert_eq!(words("flags=(complain)"), vec!["flags"]);
assert_eq!(words("profile foo {"), vec!["profile", "foo"]);
}
#[test]
fn plain_word_stops_at_arrow() {
assert_eq!(words("->"), Vec::<String>::new());
let mut c = Cursor::new("foo -> bar");
assert_eq!(c.read_plain_word().as_deref(), Some("foo"));
c.skip_trivia();
assert_eq!(c.read_plain_word(), None); c.bump();
c.bump();
c.skip_trivia();
assert_eq!(c.read_plain_word().as_deref(), Some("bar"));
}
#[test]
fn trivia_skips_comments_but_not_include() {
let mut c = Cursor::new("# comment\n#include <tunables/global>\ncapability");
c.skip_trivia();
assert!(c.starts_with("#include"));
}
#[test]
fn hash_include_with_space_is_comment() {
let mut c = Cursor::new("# include foo\ncapability");
c.skip_trivia();
assert!(c.starts_with("capability"));
}
#[test]
fn read_value_balanced_braces() {
let mut c = Cursor::new("/dir{,1,2}/** r,");
assert_eq!(c.read_value().unwrap().as_deref(), Some("/dir{,1,2}/**"));
c.skip_trivia();
assert_eq!(c.read_value().unwrap().as_deref(), Some("r"));
}
#[test]
fn read_value_stops_at_block_brace() {
let mut c = Cursor::new("foo {");
assert_eq!(c.read_value().unwrap().as_deref(), Some("foo"));
c.skip_trivia();
assert_eq!(c.peek(), Some('{'));
}
#[test]
fn read_value_quoted() {
let mut c = Cursor::new("\"/usr/bin/my app\" r,");
assert_eq!(c.read_value().unwrap().as_deref(), Some("/usr/bin/my app"));
}
#[test]
fn read_value_variable() {
let mut c = Cursor::new("@{HOME}/** r,");
assert_eq!(c.read_value().unwrap().as_deref(), Some("@{HOME}/**"));
}
#[test]
fn read_value_magic() {
let mut c = Cursor::new("<tunables/global>");
assert_eq!(
c.read_value().unwrap().as_deref(),
Some("<tunables/global>")
);
}
#[test]
fn read_value_unterminated_brace_errors() {
let mut c = Cursor::new("/dir/{a,b");
let e = c.read_value().unwrap_err();
assert!(e.message.contains("unterminated"));
}
#[test]
fn read_raw_until_terminator() {
let mut c = Cursor::new("some weird rule with {braces} and more, next");
assert_eq!(
c.read_raw_until_terminator(),
"some weird rule with {braces} and more"
);
}
#[test]
fn read_raw_stops_at_block_close() {
let mut c = Cursor::new("weird rule }\n");
assert_eq!(c.read_raw_until_terminator(), "weird rule");
}
}