//! Layer 0 table-driven guard and rule expression parser to `Term` (`INV-627`).
use crate::layer0::guard_grammar::{ASSOC_LEFT, ASSOC_NONASSOC, INFIX_OPERATORS, PARSE_ERR_CHAINED_CMP, PARSE_ERR_EMPTY_CMP_RHS, PARSE_ERR_EMPTY_EXPRESSION, PARSE_ERR_EMPTY_PREFIX_TARGET, PARSE_ERR_EMPTY_SEGMENT, PARSE_ERR_EXPECTED_FIELD, PARSE_ERR_EXPECTED_PRIMARY, PARSE_ERR_INT_OVERFLOW, PARSE_ERR_INVALID_CMP_RHS, PARSE_ERR_INVALID_NUM_SUFFIX, PARSE_ERR_MISSING_RHS, PARSE_ERR_TRAILING_BACKSLASH, PARSE_ERR_TRAILING_INPUT, PARSE_ERR_UNBALANCED_SEG, PARSE_ERR_UNBALANCED_SEGMENT, PARSE_ERR_UNCLOSED_BRACKET, PARSE_ERR_UNCLOSED_DELIM, PARSE_ERR_UNCLOSED_PAREN, PARSE_ERR_UNCLOSED_STRING, PARSE_ERR_UNEXPECTED_CHAR, PARSE_ERR_UNEXPECTED_END, PREC_CMP, PREC_SUM, PREC_TOP, PREFIX_OPERATORS, PREFIX_TAIL_PUNCT, PRIM_AND, PRIM_CALL, PRIM_COMPARE, PRIM_COMPARE_PREFIX, PRIM_EXPLICIT_REF, PRIM_FIELD, PRIM_GATE, PRIM_GATE_CALL, PRIM_IN, PRIM_INDEX, PRIM_LIST, PRIM_LIT_BOOL, PRIM_METHOD_PREFIX, PRIM_NOT, PRIM_NOT_IN, PRIM_OR, PRIM_REF, PRIM_RLCD_PROP, PRIM_UNKNOWN_ATOM, PROFILE_GUARD, PROFILE_RELEASE_A_SPLIT, PROFILE_RULE, STRING_ESCAPES};
use crate::layer0::guard_term_scan::{find_matching, is_ident_byte, is_ident_start_byte, match_word, mk_prim, prof_has, scan_segment_end, skip_ws};
use crate::layer0::limits::{SPEC_ESCAPE_SEQ_CHARS, SPEC_QUOTE_DELIMITER_PAIR_CHARS};
use crate::layer0::term::{Lit, ParseFailure, Term};
use crate::layer0::vocabulary::{GUARD_ARITH_DIV, GUARD_BACKSLASH, GUARD_COLON, GUARD_COMMA, GUARD_DOLLAR, GUARD_DOT, GUARD_DQUOTE, GUARD_EQ_SIGN, GUARD_FUNC_LEN, GUARD_FUNC_RLCD, GUARD_FUNC_SIZE, GUARD_LIT_FALSE, GUARD_LIT_FALSE_CAP, GUARD_LIT_NONE, GUARD_LIT_NONE_CAP, GUARD_LIT_NULL, GUARD_LIT_TRUE, GUARD_LIT_TRUE_CAP, GUARD_LPAREN, GUARD_OP_AND, GUARD_OP_NOT, GUARD_OP_OR, GUARD_OUTCOME_FAIL, GUARD_OUTCOME_PASS, GUARD_PREFIX_EXISTS, GUARD_PREFIX_TYPE, GUARD_RPAREN, GUARD_SQUOTE, GUARD_WORD_IN, TERM_SYNTAX_LIST_CLOSE, TERM_SYNTAX_LIST_OPEN, TERM_SYNTAX_SPACE};
#[inline] fn fail(message: &str, position: usize) -> ParseFailure { ParseFailure { message: message.to_string(), position } }
struct TableParser<'a> { src: &'a str, bytes: &'a [u8], pos: usize, end: usize, profile: &'a str, prose: bool, allow_null: bool }
impl<'a> TableParser<'a> {
fn new(src: &'a str, start: usize, end: usize, profile: &'a str, prose: bool, allow_null: bool) -> Self {
Self { src, bytes: src.as_bytes(), pos: start, end, profile, prose, allow_null: allow_null || profile == PROFILE_RULE }
}
fn parse_all(&mut self) -> Result<Term, ParseFailure> {
self.pos = skip_ws(self.bytes, self.pos, self.end);
if self.pos >= self.end { return Err(fail(PARSE_ERR_EMPTY_EXPRESSION, self.pos)); }
let term = self.parse_prec(PREC_TOP)?;
self.pos = skip_ws(self.bytes, self.pos, self.end);
if self.pos == self.end { Ok(term) } else { Err(fail(PARSE_ERR_TRAILING_INPUT, self.pos)) }
}
fn match_infix(&self, pos: usize, min_prec: u8) -> Option<(usize, String, u8, &'static str, &'static str)> {
for &(tok1, tok2, prec, assoc, profs, prim, is_word) in INFIX_OPERATORS {
if prec < min_prec || !prof_has(profs, self.profile) { continue; }
if !tok2.is_empty() {
if let Some(e1) = match_word(self.bytes, pos, self.end, tok1.as_bytes()) {
let ws = skip_ws(self.bytes, e1, self.end);
if ws > e1 && let Some(e2) = match_word(self.bytes, ws, self.end, tok2.as_bytes()) {
return Some((e2, [tok1, TERM_SYNTAX_SPACE, tok2].concat(), prec, assoc, prim));
}
}
} else if is_word {
if let Some(nxt) = match_word(self.bytes, pos, self.end, tok1.as_bytes()) {
return Some((nxt, tok1.to_string(), prec, assoc, prim));
}
} else {
let n = tok1.len();
if pos + n <= self.end && &self.bytes[pos..pos + n] == tok1.as_bytes() {
if tok1 == GUARD_ARITH_DIV && pos + 1 < self.end && self.bytes[pos + 1] == GUARD_ARITH_DIV.as_bytes()[0] {
continue;
}
return Some((pos + n, tok1.to_string(), prec, assoc, prim));
}
}
}
None
}
fn match_prefix(&self, pos: usize) -> Option<(usize, u8, &'static str)> {
for &(tok, prec, profs, prim, is_word) in PREFIX_OPERATORS {
if !prof_has(profs, self.profile) { continue; }
if is_word {
if let Some(nxt) = match_word(self.bytes, pos, self.end, tok.as_bytes()) {
let ws = skip_ws(self.bytes, nxt, self.end);
if self.profile == PROFILE_RULE && ws > nxt && match_word(self.bytes, ws, self.end, GUARD_WORD_IN.as_bytes()).is_some() {
continue;
}
return Some((nxt, prec, prim));
}
} else if !(tok == GUARD_OP_NOT && pos + 1 < self.end && self.bytes[pos + 1] == GUARD_EQ_SIGN.as_bytes()[0]) {
let n = tok.len();
if pos + n <= self.end && &self.bytes[pos..pos + n] == tok.as_bytes() {
return Some((pos + n, prec, prim));
}
}
}
None
}
fn parse_prec(&mut self, min_prec: u8) -> Result<Term, ParseFailure> {
let lhs_start = skip_ws(self.bytes, self.pos, self.end);
self.pos = lhs_start;
if self.prose && min_prec >= PREC_CMP {
let seg_end = scan_segment_end(self.src, lhs_start, self.end, false)
.ok_or_else(|| fail(PARSE_ERR_UNBALANCED_SEGMENT, lhs_start))?;
let raw_seg = self.src[lhs_start..seg_end].trim();
if raw_seg.is_empty() { return Err(fail(PARSE_ERR_EMPTY_SEGMENT, lhs_start)); }
let mut sub = TableParser::new(self.src, lhs_start, seg_end, PROFILE_GUARD, false, self.allow_null);
let parsed = sub.parse_prec(PREC_CMP);
self.pos = seg_end;
return match parsed {
Ok(t) if skip_ws(self.bytes, sub.pos, seg_end) == seg_end => Ok(t),
_ => Ok(mk_prim(PRIM_UNKNOWN_ATOM, vec![Term::Lit(Lit::string(raw_seg))])),
};
}
let mut left = self.parse_unary()?;
let mut lhs_end = self.pos;
while let Some((after_op, op_sym, prec, assoc, prim)) = self.match_infix(skip_ws(self.bytes, self.pos, self.end), min_prec) {
self.pos = after_op;
let rhs_start = skip_ws(self.bytes, self.pos, self.end);
if rhs_start >= self.end { return Err(fail(PARSE_ERR_MISSING_RHS, self.pos)); }
let is_cmp = prim.starts_with(PRIM_COMPARE_PREFIX);
let right = if is_cmp { self.parse_cmp_rhs(rhs_start)? } else { self.parse_prec(if assoc == ASSOC_LEFT || assoc == ASSOC_NONASSOC { prec + 1 } else { prec })? };
let rhs_end = self.pos;
if assoc == ASSOC_NONASSOC && let Some((_, _, nxt_prec, _, _)) = self.match_infix(skip_ws(self.bytes, self.pos, self.end), prec) && nxt_prec == prec { return Err(fail(PARSE_ERR_CHAINED_CMP, self.pos)); }
let lhs_raw = self.src[lhs_start..lhs_end].trim();
let rhs_raw = self.src[rhs_start..rhs_end].trim();
let span = self.src[lhs_start..rhs_end].trim();
left = if is_cmp {
mk_prim(PRIM_COMPARE, vec![left, Term::Lit(Lit::string(op_sym)), right, Term::Lit(Lit::string(lhs_raw)), Term::Lit(Lit::string(rhs_raw)), Term::Lit(Lit::string(span))])
} else if prim == PRIM_IN || prim == PRIM_NOT_IN {
mk_prim(prim, vec![left, right, Term::Lit(Lit::string(span))])
} else {
mk_prim(prim, vec![left, right])
};
lhs_end = rhs_end;
}
Ok(left)
}
fn parse_cmp_rhs(&mut self, rhs_start: usize) -> Result<Term, ParseFailure> {
if self.profile != PROFILE_GUARD {
return self.parse_prec(PREC_SUM);
}
let scan_end = scan_segment_end(self.src, rhs_start, self.end, true)
.filter(|&e| e > rhs_start)
.ok_or_else(|| fail(PARSE_ERR_INVALID_CMP_RHS, rhs_start))?;
let raw_rhs = self.src[rhs_start..scan_end].trim();
if raw_rhs.is_empty() {
return Err(fail(PARSE_ERR_EMPTY_CMP_RHS, rhs_start));
}
if let Some(stripped) = raw_rhs.strip_prefix(GUARD_DOLLAR) {
self.pos = scan_end;
return Ok(mk_prim(PRIM_EXPLICIT_REF, vec![Term::Lit(Lit::string(stripped)), Term::Lit(Lit::string(raw_rhs))]));
}
let mut sub = TableParser::new(self.src, rhs_start, scan_end, PROFILE_GUARD, false, true);
if let Ok(parsed) = sub.parse_prec(PREC_SUM) && skip_ws(self.bytes, sub.pos, scan_end) == scan_end {
self.pos = scan_end;
return Ok(match parsed {
Term::Prim(ref name, _) if name == PRIM_REF => Term::Lit(Lit::string(raw_rhs)),
other => other,
});
}
if raw_rhs.contains(GUARD_LPAREN) && raw_rhs.contains(GUARD_RPAREN) {
self.pos = scan_end;
return Ok(Term::Lit(Lit::string(raw_rhs)));
}
Err(fail(PARSE_ERR_INVALID_CMP_RHS, rhs_start))
}
fn parse_unary(&mut self) -> Result<Term, ParseFailure> {
self.pos = skip_ws(self.bytes, self.pos, self.end);
if self.pos >= self.end {
return Err(fail(PARSE_ERR_UNEXPECTED_END, self.pos));
}
if let Some((after_op, prec, prim)) = self.match_prefix(self.pos) {
self.pos = after_op;
let op_start = skip_ws(self.bytes, self.pos, self.end);
let grouped = op_start < self.end && self.bytes[op_start] == GUARD_LPAREN.as_bytes()[0];
let operand = self.parse_prec(prec)?;
if prim == PRIM_NOT {
let is_compound = grouped || matches!(&operand, Term::Prim(n, _) if n == PRIM_AND || n == PRIM_OR || n == PRIM_NOT);
let label = if is_compound { GUARD_OP_NOT } else { self.src[op_start..self.pos].trim() };
return Ok(mk_prim(PRIM_NOT, vec![operand, Term::Lit(Lit::string(label))]));
}
return Ok(mk_prim(prim, vec![operand]));
}
self.parse_postfix()
}
fn parse_postfix(&mut self) -> Result<Term, ParseFailure> {
let start = skip_ws(self.bytes, self.pos, self.end);
self.pos = start;
let mut base = self.parse_primary()?;
loop {
let nxt = skip_ws(self.bytes, self.pos, self.end);
if nxt < self.end && self.bytes[nxt] == GUARD_DOT.as_bytes()[0] {
let id_s = skip_ws(self.bytes, nxt + 1, self.end);
if id_s >= self.end || !is_ident_start_byte(self.bytes[id_s]) {
return Err(fail(PARSE_ERR_EXPECTED_FIELD, nxt));
}
let mut id_e = id_s + 1;
while id_e < self.end && is_ident_byte(self.bytes[id_e]) { id_e += 1; }
let ident = &self.src[id_s..id_e];
self.pos = id_e;
let call_p = skip_ws(self.bytes, self.pos, self.end);
if call_p < self.end && self.bytes[call_p] == GUARD_LPAREN.as_bytes()[0] {
let mut args = self.parse_list(call_p, GUARD_LPAREN.as_bytes()[0], GUARD_RPAREN.as_bytes()[0])?;
let mut all_args = vec![base];
all_args.append(&mut args);
all_args.push(Term::Lit(Lit::string(self.src[start..self.pos].trim())));
base = mk_prim(&[PRIM_METHOD_PREFIX, ident].concat(), all_args);
} else if let Term::Prim(ref n, ref a) = base && n == PRIM_REF && let Some(Term::Lit(Lit::String(prev))) = a.first() {
base = mk_prim(PRIM_REF, vec![Term::Lit(Lit::string([prev.as_str(), GUARD_DOT, ident].concat()))]);
} else if let Term::Prim(ref n, ref a) = base && n == PRIM_EXPLICIT_REF
&& let (Some(Term::Lit(Lit::String(p0))), Some(Term::Lit(Lit::String(p1)))) = (a.first(), a.get(1))
{
base = mk_prim(PRIM_EXPLICIT_REF, vec![Term::Lit(Lit::string([p0.as_str(), GUARD_DOT, ident].concat())), Term::Lit(Lit::string([p1.as_str(), GUARD_DOT, ident].concat()))]);
} else if let Term::Prim(ref n, ref a) = base && n == PRIM_CALL
&& let (Some(Term::Lit(Lit::String(fn_n))), Some(Term::Prim(_, inner_a))) = (a.first(), a.get(1))
&& fn_n == GUARD_FUNC_RLCD && inner_a.len() == 1
&& let Some(Term::Prim(rn, ra)) = inner_a.first() && rn == PRIM_REF
&& let Some(Term::Lit(Lit::String(target_s))) = ra.first()
{
base = mk_prim(PRIM_RLCD_PROP, vec![Term::Lit(Lit::string(target_s.clone())), Term::Lit(Lit::string(ident)), Term::Lit(Lit::string(self.src[start..self.pos].trim()))]);
} else {
base = mk_prim(PRIM_FIELD, vec![base, Term::Lit(Lit::string(ident))]);
}
} else if self.profile == PROFILE_RULE && nxt < self.end && self.bytes[nxt] == TERM_SYNTAX_LIST_OPEN.as_bytes()[0] {
let close_b = find_matching(self.bytes, nxt, self.end, TERM_SYNTAX_LIST_OPEN.as_bytes()[0], TERM_SYNTAX_LIST_CLOSE.as_bytes()[0])
.ok_or_else(|| fail(PARSE_ERR_UNCLOSED_BRACKET, nxt))?;
let idx_t = TableParser::new(self.src, nxt + 1, close_b, self.profile, false, true).parse_all()?;
self.pos = close_b + 1;
base = mk_prim(PRIM_INDEX, vec![base, idx_t]);
} else {
break;
}
}
Ok(base)
}
fn parse_list(&mut self, open_p: usize, open_b: u8, close_b: u8) -> Result<Vec<Term>, ParseFailure> {
let close_p = find_matching(self.bytes, open_p, self.end, open_b, close_b)
.ok_or_else(|| fail(PARSE_ERR_UNCLOSED_DELIM, open_p))?;
let ws = skip_ws(self.bytes, open_p + 1, close_p);
if ws >= close_p {
self.pos = close_p + 1;
return Ok(Vec::new());
}
let mut items = Vec::new();
let (mut seg, mut dp, mut db, mut quote, mut i) = (ws, 0i32, 0i32, 0u8, ws);
let (bs, sq, dq, cm) = (GUARD_BACKSLASH.as_bytes()[0], GUARD_SQUOTE.as_bytes()[0], GUARD_DQUOTE.as_bytes()[0], GUARD_COMMA.as_bytes()[0]);
let (lp, rp, lb, rb) = (GUARD_LPAREN.as_bytes()[0], GUARD_RPAREN.as_bytes()[0], TERM_SYNTAX_LIST_OPEN.as_bytes()[0], TERM_SYNTAX_LIST_CLOSE.as_bytes()[0]);
while i <= close_p {
let c = if i < close_p { self.bytes[i] } else { cm };
if i < close_p {
if quote != 0 {
if c == bs { i += SPEC_ESCAPE_SEQ_CHARS as usize; continue; }
if c == quote { quote = 0; }
i += 1;
continue;
}
if c == sq || c == dq { quote = c; }
else if c == lp { dp += 1; }
else if c == rp { dp -= 1; }
else if c == lb { db += 1; }
else if c == rb { db -= 1; }
}
if i == close_p || (c == cm && dp == 0 && db == 0) {
items.push(TableParser::new(self.src, seg, i, self.profile, false, true).parse_all()?);
seg = i + 1;
}
i += 1;
}
self.pos = close_p + 1;
Ok(items)
}
fn parse_primary(&mut self) -> Result<Term, ParseFailure> {
let p = skip_ws(self.bytes, self.pos, self.end);
self.pos = p;
if p >= self.end {
return Err(fail(PARSE_ERR_EXPECTED_PRIMARY, p));
}
let b = self.bytes[p];
if b == GUARD_LPAREN.as_bytes()[0] {
let close_p = find_matching(self.bytes, p, self.end, GUARD_LPAREN.as_bytes()[0], GUARD_RPAREN.as_bytes()[0])
.ok_or_else(|| fail(PARSE_ERR_UNCLOSED_PAREN, p))?;
if self.prose {
let after = skip_ws(self.bytes, close_p + 1, self.end);
let is_group = after >= self.end || self.bytes[after] == GUARD_RPAREN.as_bytes()[0]
|| self.src[after..self.end].starts_with(GUARD_OP_OR) || self.src[after..self.end].starts_with(GUARD_OP_AND);
if !is_group {
let seg_end = scan_segment_end(self.src, p, self.end, false)
.ok_or_else(|| fail(PARSE_ERR_UNBALANCED_SEG, p))?;
let mut sub = TableParser::new(self.src, p, seg_end, PROFILE_GUARD, false, self.allow_null);
let parsed = sub.parse_prec(PREC_CMP);
self.pos = seg_end;
return match parsed {
Ok(t) if skip_ws(self.bytes, sub.pos, seg_end) == seg_end => Ok(t),
_ => Ok(mk_prim(PRIM_UNKNOWN_ATOM, vec![Term::Lit(Lit::string(self.src[p..seg_end].trim()))])),
};
}
}
let inner = TableParser::new(self.src, p + 1, close_p, self.profile, self.prose, self.allow_null).parse_all()?;
self.pos = close_p + 1;
return Ok(inner);
}
if self.profile == PROFILE_RULE && b == TERM_SYNTAX_LIST_OPEN.as_bytes()[0] {
let elts = self.parse_list(p, TERM_SYNTAX_LIST_OPEN.as_bytes()[0], TERM_SYNTAX_LIST_CLOSE.as_bytes()[0])?;
return Ok(mk_prim(PRIM_LIST, elts));
}
if b == GUARD_SQUOTE.as_bytes()[0] || b == GUARD_DQUOTE.as_bytes()[0] { return self.parse_string(p); }
if b.is_ascii_digit() { return self.parse_number(p); }
if b == GUARD_DOLLAR.as_bytes()[0] {
let after = p + 1;
if after < self.end && is_ident_start_byte(self.bytes[after]) {
let mut ie = after + 1;
while ie < self.end && is_ident_byte(self.bytes[ie]) { ie += 1; }
self.pos = ie;
return Ok(mk_prim(PRIM_EXPLICIT_REF, vec![Term::Lit(Lit::string(&self.src[after..ie])), Term::Lit(Lit::string(&self.src[p..ie]))]));
}
if after < self.end && self.bytes[after].is_ascii_digit() {
let mut ne = after + 1;
while ne < self.end && (self.bytes[ne].is_ascii_digit() || self.bytes[ne] == GUARD_DOT.as_bytes()[0]) { ne += 1; }
self.pos = ne;
return Ok(mk_prim(PRIM_EXPLICIT_REF, vec![Term::Lit(Lit::string(&self.src[after..ne])), Term::Lit(Lit::string(&self.src[p..ne]))]));
}
self.pos = after;
return Ok(mk_prim(PRIM_EXPLICIT_REF, vec![Term::Lit(Lit::string("")), Term::Lit(Lit::string(GUARD_DOLLAR))]));
}
if is_ident_start_byte(b) {
let mut ie = p + 1;
while ie < self.end && is_ident_byte(self.bytes[ie]) { ie += 1; }
let ident = &self.src[p..ie];
let lower = ident.to_ascii_lowercase();
if ie < self.end && self.bytes[ie] == GUARD_COLON.as_bytes()[0] { return self.parse_prefix_atom(p, &lower, ie + 1); }
let ws = skip_ws(self.bytes, ie, self.end);
if ws < self.end && self.bytes[ws] == GUARD_LPAREN.as_bytes()[0] {
let cp = find_matching(self.bytes, ws, self.end, GUARD_LPAREN.as_bytes()[0], GUARD_RPAREN.as_bytes()[0]).unwrap_or(ws);
let raw_inner = if cp > ws { self.src[ws + 1..cp].trim() } else { "" };
let mut args = self.parse_list(ws, GUARD_LPAREN.as_bytes()[0], GUARD_RPAREN.as_bytes()[0])?;
if (ident == GUARD_FUNC_SIZE || ident == GUARD_FUNC_LEN) && args.len() == 1 {
return Ok(mk_prim(ident, vec![args.remove(0), Term::Lit(Lit::string(raw_inner))]));
}
return Ok(mk_prim(PRIM_CALL, vec![Term::Lit(Lit::string(ident)), mk_prim(PRIM_LIST, args), Term::Lit(Lit::string(self.src[p..self.pos].trim()))]));
}
if !(ws < self.end && self.bytes[ws] == GUARD_DOT.as_bytes()[0]) {
let is_bool = ident == GUARD_LIT_TRUE || ident == GUARD_LIT_TRUE_CAP || ident == GUARD_OUTCOME_PASS
|| ident == GUARD_LIT_FALSE || ident == GUARD_LIT_FALSE_CAP || ident == GUARD_OUTCOME_FAIL
|| lower == GUARD_LIT_TRUE || lower == GUARD_LIT_FALSE;
if is_bool {
self.pos = ie;
if self.profile == PROFILE_RULE && (ident == GUARD_OUTCOME_PASS || ident == GUARD_OUTCOME_FAIL) {
return Ok(mk_prim(PRIM_REF, vec![Term::Lit(Lit::string(ident))]));
}
let bv = ident == GUARD_LIT_TRUE || ident == GUARD_LIT_TRUE_CAP || ident == GUARD_OUTCOME_PASS || lower == GUARD_LIT_TRUE;
return Ok(mk_prim(PRIM_LIT_BOOL, vec![Term::Lit(Lit::Boolean(bv)), Term::Lit(Lit::string(ident))]));
}
if self.allow_null && (ident == GUARD_LIT_NULL || ident == GUARD_LIT_NONE || ident == GUARD_LIT_NONE_CAP || lower == GUARD_LIT_NULL || lower == GUARD_LIT_NONE) {
self.pos = ie;
return Ok(Term::Lit(Lit::Null));
}
}
self.pos = ie;
return Ok(mk_prim(PRIM_REF, vec![Term::Lit(Lit::string(ident))]));
}
Err(fail(PARSE_ERR_UNEXPECTED_CHAR, p))
}
fn parse_prefix_atom(&mut self, start: usize, lower_prefix: &str, after_colon: usize) -> Result<Term, ParseFailure> {
let ts = skip_ws(self.bytes, after_colon, self.end);
let mut i = ts;
while i < self.end && (is_ident_byte(self.bytes[i]) || PREFIX_TAIL_PUNCT.iter().any(|p| p.as_bytes()[0] == self.bytes[i])) {
i += 1;
}
if i == ts {
return Err(fail(PARSE_ERR_EMPTY_PREFIX_TARGET, after_colon));
}
let tail = &self.src[ts..i];
self.pos = i;
let ws = skip_ws(self.bytes, self.pos, self.end);
if ws < self.end && self.bytes[ws] == GUARD_LPAREN.as_bytes()[0] {
let args = self.parse_list(ws, GUARD_LPAREN.as_bytes()[0], GUARD_RPAREN.as_bytes()[0])?;
return Ok(mk_prim(PRIM_GATE_CALL, vec![Term::Lit(Lit::string([lower_prefix, GUARD_COLON, tail].concat())), mk_prim(PRIM_LIST, args), Term::Lit(Lit::string(self.src[start..self.pos].trim()))]));
}
let span = self.src[start..i].trim();
let pref_tok = [lower_prefix, GUARD_COLON].concat();
if pref_tok == GUARD_PREFIX_EXISTS || pref_tok == GUARD_PREFIX_TYPE {
return Ok(mk_prim(&pref_tok, vec![Term::Lit(Lit::string(tail)), Term::Lit(Lit::string(span))]));
}
Ok(mk_prim(PRIM_GATE, vec![Term::Lit(Lit::string([lower_prefix, GUARD_COLON, &tail.to_ascii_lowercase()].concat())), Term::Lit(Lit::string(span))]))
}
fn parse_string(&mut self, start: usize) -> Result<Term, ParseFailure> {
let quote_ch = self.src[start..self.end].chars().next().unwrap();
let bs_ch = GUARD_BACKSLASH.chars().next().unwrap();
let sq_ch = GUARD_SQUOTE.chars().next().unwrap();
let mut out = String::new();
let mut chars = self.src[start + quote_ch.len_utf8()..self.end].char_indices().peekable();
let base = start + quote_ch.len_utf8();
while let Some((rel, ch)) = chars.next() {
if ch == bs_ch {
let Some((_, nxt)) = chars.next() else {
return Err(fail(PARSE_ERR_TRAILING_BACKSLASH, base + rel));
};
let ns = nxt.to_string();
if let Some(&(_, rep)) = STRING_ESCAPES.iter().find(|&&(k, _)| k == ns) { out.push_str(rep); } else { out.push(nxt); }
} else if ch == quote_ch {
if quote_ch == sq_ch && chars.peek().is_some_and(|&(_, pk)| pk == sq_ch) {
let _ = chars.next();
out.push(sq_ch);
} else {
self.pos = base + rel + ch.len_utf8();
return Ok(Term::Lit(Lit::String(out)));
}
} else {
out.push(ch);
}
}
let _ = SPEC_QUOTE_DELIMITER_PAIR_CHARS;
Err(fail(PARSE_ERR_UNCLOSED_STRING, start))
}
fn parse_number(&mut self, start: usize) -> Result<Term, ParseFailure> {
let (mut i, mut is_dec) = (start, false);
while i < self.end && self.bytes[i].is_ascii_digit() { i += 1; }
if i + 1 < self.end && self.bytes[i] == GUARD_DOT.as_bytes()[0] && self.bytes[i + 1].is_ascii_digit() {
is_dec = true;
i += 1;
while i < self.end && self.bytes[i].is_ascii_digit() { i += 1; }
}
if i < self.end && is_ident_start_byte(self.bytes[i]) {
return Err(fail(PARSE_ERR_INVALID_NUM_SUFFIX, i));
}
self.pos = i;
let raw = &self.src[start..i];
if is_dec {
Ok(Term::Lit(Lit::decimal(raw)))
} else {
let n = raw.parse::<i64>().map_err(|_| fail(PARSE_ERR_INT_OVERFLOW, start))?;
Ok(Term::Lit(Lit::Integer(n)))
}
}
}
pub fn parse_expression_term(source: &str, profile: &str) -> Result<Term, ParseFailure> {
TableParser::new(source, 0, source.len(), profile, false, false).parse_all()
}
pub fn compile_guard_term(source: &str, profile: &str) -> Result<Term, ParseFailure> {
if profile == PROFILE_RELEASE_A_SPLIT {
let trimmed = source.trim();
if trimmed.contains(GUARD_OP_AND) {
let mut it = trimmed.split(GUARD_OP_AND).map(|p| compile_guard_term(p, PROFILE_RELEASE_A_SPLIT).unwrap());
let first = it.next().unwrap();
return Ok(it.fold(first, |acc, nxt| mk_prim(PRIM_AND, vec![acc, nxt])));
}
if trimmed.contains(GUARD_OP_OR) {
let mut it = trimmed.split(GUARD_OP_OR).map(|p| compile_guard_term(p, PROFILE_RELEASE_A_SPLIT).unwrap());
let first = it.next().unwrap();
return Ok(it.fold(first, |acc, nxt| mk_prim(PRIM_OR, vec![acc, nxt])));
}
if trimmed.is_empty() || trimmed.starts_with(GUARD_OP_NOT) {
return Ok(mk_prim(PRIM_UNKNOWN_ATOM, vec![Term::Lit(Lit::string(trimmed))]));
}
return Ok(parse_expression_term(trimmed, PROFILE_GUARD).unwrap_or_else(|_| mk_prim(PRIM_UNKNOWN_ATOM, vec![Term::Lit(Lit::string(trimmed))])));
}
if profile == PROFILE_RULE {
return parse_expression_term(source, PROFILE_RULE);
}
TableParser::new(source, 0, source.len(), PROFILE_GUARD, true, false).parse_all()
}