32709a56ca
Lots of changes this time. Worked around what looks like a rustfmt bug in parse_inst_operands where a large match was nested inside Ok().
519 lines
19 KiB
Rust
519 lines
19 KiB
Rust
//! Pattern matching for a single directive.
|
|
|
|
use error::{Error, Result};
|
|
use variable::{varname_prefix, VariableMap, Value};
|
|
use std::str::FromStr;
|
|
use std::fmt::{self, Display, Formatter, Write};
|
|
use regex::{Regex, RegexBuilder, quote};
|
|
|
|
/// A pattern to match as specified in a directive.
|
|
///
|
|
/// Each pattern is broken into a sequence of parts that must match in order. The kinds of parts
|
|
/// are:
|
|
///
|
|
/// 1. Plain text match.
|
|
/// 2. Variable match, `$FOO` or `$(FOO)`. The variable `FOO` may expand to plain text or a regex.
|
|
/// 3. Variable definition from literal regex, `$(foo=.*)`. Match the regex and assign matching text
|
|
/// to variable `foo`.
|
|
/// 4. Variable definition from regex variable, `$(foo=$RX)`. Lookup variable `RX` which should
|
|
/// expand to a regex, match the regex, and assign matching text to variable `foo`.
|
|
///
|
|
pub struct Pattern {
|
|
parts: Vec<Part>,
|
|
// Variables defined by this pattern.
|
|
defs: Vec<String>,
|
|
}
|
|
|
|
/// One atomic part of a pattern.
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub enum Part {
|
|
/// Match a plain string.
|
|
Text(String),
|
|
/// Match a regular expression. The regex has already been wrapped in a non-capturing group if
|
|
/// necessary, so it is safe to concatenate.
|
|
Regex(String),
|
|
/// Match the contents of a variable, which can be plain text or regex.
|
|
Var(String),
|
|
/// Match literal regex, then assign match to variable.
|
|
/// The regex has already been wrapped in a named capture group.
|
|
DefLit { def: usize, regex: String },
|
|
/// Lookup variable `var`, match resulting regex, assign matching text to variable `defs[def]`.
|
|
DefVar { def: usize, var: String },
|
|
}
|
|
|
|
impl Part {
|
|
/// Get the variabled referenced by this part, if any.
|
|
pub fn ref_var(&self) -> Option<&str> {
|
|
match *self {
|
|
Part::Var(ref var) => Some(var),
|
|
Part::DefVar { ref var, .. } => Some(var),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Pattern {
|
|
/// Create a new blank pattern. Use the `FromStr` trait to generate Patterns with content.
|
|
fn new() -> Pattern {
|
|
Pattern {
|
|
parts: Vec::new(),
|
|
defs: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Check if the variable `v` is defined by this pattern.
|
|
pub fn defines_var(&self, v: &str) -> bool {
|
|
self.defs.iter().any(|d| d == v)
|
|
}
|
|
|
|
/// Add a definition of a new variable.
|
|
/// Return the allocated def number.
|
|
fn add_def(&mut self, v: &str) -> Result<usize> {
|
|
if self.defines_var(v) {
|
|
Err(Error::DuplicateDef(format!("duplicate definition of ${} in same pattern", v)))
|
|
} else {
|
|
let idx = self.defs.len();
|
|
self.defs.push(v.to_string());
|
|
Ok(idx)
|
|
}
|
|
}
|
|
|
|
/// Parse a `Part` from a prefix of `s`.
|
|
/// Return the part and the number of bytes consumed from `s`.
|
|
/// Adds defined variables to `self.defs`.
|
|
fn parse_part(&mut self, s: &str) -> Result<(Part, usize)> {
|
|
let dollar = s.find('$');
|
|
if dollar != Some(0) {
|
|
// String doesn't begin with a dollar sign, so match plain text up to the dollar sign.
|
|
let end = dollar.unwrap_or(s.len());
|
|
return Ok((Part::Text(s[0..end].to_string()), end));
|
|
}
|
|
|
|
// String starts with a dollar sign. Look for these possibilities:
|
|
//
|
|
// 1. `$$`.
|
|
// 2. `$var`.
|
|
// 3. `$(var)`.
|
|
// 4. `$(var=regex)`. Where `regex` is a regular expression possibly containing matching
|
|
// braces.
|
|
// 5. `$(var=$VAR)`.
|
|
|
|
// A doubled dollar sign matches a single dollar sign.
|
|
if s.starts_with("$$") {
|
|
return Ok((Part::Text("$".to_string()), 2));
|
|
}
|
|
|
|
// Look for `$var`.
|
|
let varname_end = 1 + varname_prefix(&s[1..]);
|
|
if varname_end != 1 {
|
|
return Ok((Part::Var(s[1..varname_end].to_string()), varname_end));
|
|
}
|
|
|
|
// All remaining possibilities start with `$(`.
|
|
if s.len() < 2 || !s.starts_with("$(") {
|
|
return Err(Error::Syntax("pattern syntax error, use $$ to match a single $"
|
|
.to_string()));
|
|
}
|
|
|
|
// Match the variable name, allowing for an empty varname in `$()`, or `$(=...)`.
|
|
let varname_end = 2 + varname_prefix(&s[2..]);
|
|
let varname = s[2..varname_end].to_string();
|
|
|
|
match s[varname_end..].chars().next() {
|
|
None => {
|
|
return Err(Error::Syntax(format!("unterminated $({}...", varname)));
|
|
}
|
|
Some(')') => {
|
|
let part = if varname.is_empty() {
|
|
// Match `$()`, turn it into an empty text match.
|
|
Part::Text(varname)
|
|
} else {
|
|
// Match `$(var)`.
|
|
Part::Var(varname)
|
|
};
|
|
return Ok((part, varname_end + 1));
|
|
}
|
|
Some('=') => {
|
|
// Variable definition. Fall through.
|
|
}
|
|
Some(ch) => {
|
|
return Err(Error::Syntax(format!("syntax error in $({}... '{}'", varname, ch)));
|
|
}
|
|
}
|
|
|
|
// This is a variable definition of the form `$(var=...`.
|
|
|
|
// Allocate a definition index.
|
|
let def = if varname.is_empty() {
|
|
None
|
|
} else {
|
|
Some(self.add_def(&varname)?)
|
|
};
|
|
|
|
// Match `$(var=$PAT)`.
|
|
if s[varname_end + 1..].starts_with('$') {
|
|
let refname_begin = varname_end + 2;
|
|
let refname_end = refname_begin + varname_prefix(&s[refname_begin..]);
|
|
if refname_begin == refname_end {
|
|
return Err(Error::Syntax(format!("expected variable name in $({}=$...", varname)));
|
|
}
|
|
if !s[refname_end..].starts_with(')') {
|
|
return Err(Error::Syntax(format!("expected ')' after $({}=${}...",
|
|
varname,
|
|
&s[refname_begin..refname_end])));
|
|
}
|
|
let refname = s[refname_begin..refname_end].to_string();
|
|
return if let Some(defidx) = def {
|
|
Ok((Part::DefVar {
|
|
def: defidx,
|
|
var: refname,
|
|
},
|
|
refname_end + 1))
|
|
} else {
|
|
Err(Error::Syntax(format!("expected variable name in $(=${})", refname)))
|
|
};
|
|
}
|
|
|
|
// Last case: `$(var=...)` where `...` is a regular expression, possibly containing matched
|
|
// parentheses.
|
|
let rx_begin = varname_end + 1;
|
|
let rx_end = rx_begin + regex_prefix(&s[rx_begin..]);
|
|
if s[rx_end..].starts_with(')') {
|
|
let part = if let Some(defidx) = def {
|
|
// Wrap the regex in a named capture group.
|
|
Part::DefLit {
|
|
def: defidx,
|
|
regex: format!("(?P<{}>{})", varname, &s[rx_begin..rx_end]),
|
|
}
|
|
} else {
|
|
// When the varname is empty just match the regex, don't capture any variables.
|
|
// This is `$(=[a-z])`.
|
|
// Wrap the regex in a non-capturing group to make it concatenation-safe.
|
|
Part::Regex(format!("(?:{})", &s[rx_begin..rx_end]))
|
|
};
|
|
Ok((part, rx_end + 1))
|
|
} else {
|
|
Err(Error::Syntax(format!("missing ')' after regex in $({}={}",
|
|
varname,
|
|
&s[rx_begin..rx_end])))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Compute the length of a regular expression terminated by `)` or `}`.
|
|
/// Handle nested and escaped parentheses in the rx, but don't actualy parse it.
|
|
/// Return the position of the terminating brace or the length of the string.
|
|
fn regex_prefix(s: &str) -> usize {
|
|
// The prevous char was a backslash.
|
|
let mut escape = false;
|
|
// State around parsing charsets.
|
|
enum State {
|
|
Normal, // Outside any charset.
|
|
Curly, // Inside curly braces.
|
|
CSFirst, // Immediately after opening `[`.
|
|
CSNeg, // Immediately after `[^`.
|
|
CSBody, // Inside `[...`.
|
|
}
|
|
let mut state = State::Normal;
|
|
|
|
// Current nesting level of parens.
|
|
let mut nest = 0usize;
|
|
|
|
for (idx, ch) in s.char_indices() {
|
|
if escape {
|
|
escape = false;
|
|
continue;
|
|
} else if ch == '\\' {
|
|
escape = true;
|
|
continue;
|
|
}
|
|
match state {
|
|
State::Normal => {
|
|
match ch {
|
|
'[' => state = State::CSFirst,
|
|
'{' => state = State::Curly,
|
|
'(' => nest += 1,
|
|
')' if nest > 0 => nest -= 1,
|
|
')' | '}' => return idx,
|
|
_ => {}
|
|
}
|
|
}
|
|
State::Curly => {
|
|
if ch == '}' {
|
|
state = State::Normal;
|
|
}
|
|
}
|
|
State::CSFirst => {
|
|
state = match ch {
|
|
'^' => State::CSNeg,
|
|
_ => State::CSBody,
|
|
}
|
|
}
|
|
State::CSNeg => state = State::CSBody,
|
|
State::CSBody => {
|
|
if ch == ']' {
|
|
state = State::Normal;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
s.len()
|
|
}
|
|
|
|
impl FromStr for Pattern {
|
|
type Err = Error;
|
|
|
|
fn from_str(s: &str) -> Result<Pattern> {
|
|
// Always remove leading and trailing whitespace.
|
|
// Use `$()` to actually include that in a match.
|
|
let s = s.trim();
|
|
let mut pat = Pattern::new();
|
|
let mut pos = 0;
|
|
while pos < s.len() {
|
|
let (part, len) = pat.parse_part(&s[pos..])?;
|
|
if let Some(v) = part.ref_var() {
|
|
if pat.defines_var(v) {
|
|
return Err(Error::Backref(format!("unsupported back-reference to '${}' \
|
|
defined in same pattern",
|
|
v)));
|
|
}
|
|
}
|
|
pat.parts.push(part);
|
|
pos += len;
|
|
}
|
|
Ok(pat)
|
|
}
|
|
}
|
|
|
|
impl Pattern {
|
|
/// Get a list of parts in this pattern.
|
|
pub fn parts(&self) -> &[Part] {
|
|
&self.parts
|
|
}
|
|
|
|
/// Get a list of variable names defined when this pattern matches.
|
|
pub fn defs(&self) -> &[String] {
|
|
&self.defs
|
|
}
|
|
|
|
/// Resolve all variable references in this pattern, turning it into a regular expression.
|
|
pub fn resolve(&self, vmap: &VariableMap) -> Result<Regex> {
|
|
let mut out = String::new();
|
|
|
|
// Add a word boundary check `\b` to the beginning of the regex, but only if the first part
|
|
// is a plain text match that starts with a word character.
|
|
//
|
|
// This behavior can be disabled by starting the pattern with `$()`.
|
|
if let Some(&Part::Text(ref s)) = self.parts.first() {
|
|
if s.starts_with(char::is_alphanumeric) {
|
|
out.push_str(r"\b");
|
|
}
|
|
}
|
|
|
|
for part in &self.parts {
|
|
match *part {
|
|
Part::Text(ref s) => {
|
|
out.push_str("e(s));
|
|
}
|
|
Part::Regex(ref rx) => out.push_str(rx),
|
|
Part::Var(ref var) => {
|
|
// Resolve the variable. We can handle a plain text expansion.
|
|
match vmap.lookup(var) {
|
|
None => {
|
|
return Err(Error::UndefVariable(format!("undefined variable ${}", var)))
|
|
}
|
|
Some(Value::Text(s)) => out.push_str("e(&s)),
|
|
// Wrap regex in non-capturing group for safe concatenation.
|
|
Some(Value::Regex(rx)) => write!(out, "(?:{})", rx).unwrap(),
|
|
}
|
|
}
|
|
Part::DefLit { ref regex, .. } => out.push_str(regex),
|
|
Part::DefVar { def, ref var } => {
|
|
// Wrap regex in a named capture group.
|
|
write!(out, "(?P<{}>", self.defs[def]).unwrap();
|
|
match vmap.lookup(var) {
|
|
None => {
|
|
return Err(Error::UndefVariable(format!("undefined variable ${}", var)))
|
|
}
|
|
Some(Value::Text(s)) => write!(out, "{})", quote(&s[..])).unwrap(),
|
|
Some(Value::Regex(rx)) => write!(out, "{})", rx).unwrap(),
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Add a word boundary check `\b` to the end of the regex, but only if the final part
|
|
// is a plain text match that ends with a word character.
|
|
//
|
|
// This behavior can be disabled by ending the pattern with `$()`.
|
|
if let Some(&Part::Text(ref s)) = self.parts.last() {
|
|
if s.ends_with(char::is_alphanumeric) {
|
|
out.push_str(r"\b");
|
|
}
|
|
}
|
|
|
|
Ok(RegexBuilder::new(&out).multi_line(true).compile()?)
|
|
}
|
|
}
|
|
|
|
impl Display for Pattern {
|
|
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
|
for part in &self.parts {
|
|
use self::Part::*;
|
|
match *part {
|
|
Text(ref txt) if txt == "" => write!(f, "$()"),
|
|
Text(ref txt) if txt == "$" => write!(f, "$$"),
|
|
Text(ref txt) => write!(f, "{}", txt),
|
|
Regex(ref rx) => write!(f, "$(={})", rx),
|
|
Var(ref var) => write!(f, "$({})", var),
|
|
DefLit { def, ref regex } => {
|
|
let defvar = &self.defs[def];
|
|
// (?P<defvar>...).
|
|
let litrx = ®ex[5 + defvar.len()..regex.len() - 1];
|
|
write!(f, "$({}={})", defvar, litrx)
|
|
}
|
|
DefVar { def, ref var } => write!(f, "$({}=${})", self.defs[def], var),
|
|
}?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
#[test]
|
|
fn regex() {
|
|
use super::regex_prefix;
|
|
|
|
assert_eq!(regex_prefix(""), 0);
|
|
assert_eq!(regex_prefix(")"), 0);
|
|
assert_eq!(regex_prefix(")c"), 0);
|
|
assert_eq!(regex_prefix("x"), 1);
|
|
assert_eq!(regex_prefix("x)x"), 1);
|
|
|
|
assert_eq!(regex_prefix("x(c))x"), 4);
|
|
assert_eq!(regex_prefix("()x(c))x"), 6);
|
|
assert_eq!(regex_prefix("()x(c)"), 6);
|
|
|
|
assert_eq!(regex_prefix("x([)]))x"), 6);
|
|
assert_eq!(regex_prefix("x[)])x"), 4);
|
|
assert_eq!(regex_prefix("x[^)])x"), 5);
|
|
assert_eq!(regex_prefix("x[^])x"), 6);
|
|
}
|
|
|
|
#[test]
|
|
fn part() {
|
|
use super::{Pattern, Part};
|
|
let mut pat = Pattern::new();
|
|
|
|
// This is dubious, should we panic instead?
|
|
assert_eq!(pat.parse_part("").unwrap(), (Part::Text("".to_string()), 0));
|
|
|
|
assert_eq!(pat.parse_part("x").unwrap(),
|
|
(Part::Text("x".to_string()), 1));
|
|
assert_eq!(pat.parse_part("x2").unwrap(),
|
|
(Part::Text("x2".to_string()), 2));
|
|
assert_eq!(pat.parse_part("x$").unwrap(),
|
|
(Part::Text("x".to_string()), 1));
|
|
assert_eq!(pat.parse_part("x$$").unwrap(),
|
|
(Part::Text("x".to_string()), 1));
|
|
|
|
assert_eq!(pat.parse_part("$").unwrap_err().to_string(),
|
|
"pattern syntax error, use $$ to match a single $");
|
|
|
|
assert_eq!(pat.parse_part("$$").unwrap(),
|
|
(Part::Text("$".to_string()), 2));
|
|
assert_eq!(pat.parse_part("$$ ").unwrap(),
|
|
(Part::Text("$".to_string()), 2));
|
|
|
|
assert_eq!(pat.parse_part("$0").unwrap(),
|
|
(Part::Var("0".to_string()), 2));
|
|
assert_eq!(pat.parse_part("$xx=").unwrap(),
|
|
(Part::Var("xx".to_string()), 3));
|
|
assert_eq!(pat.parse_part("$xx$").unwrap(),
|
|
(Part::Var("xx".to_string()), 3));
|
|
|
|
assert_eq!(pat.parse_part("$(0)").unwrap(),
|
|
(Part::Var("0".to_string()), 4));
|
|
assert_eq!(pat.parse_part("$()").unwrap(),
|
|
(Part::Text("".to_string()), 3));
|
|
|
|
assert_eq!(pat.parse_part("$(0").unwrap_err().to_string(),
|
|
("unterminated $(0..."));
|
|
assert_eq!(pat.parse_part("$(foo:").unwrap_err().to_string(),
|
|
("syntax error in $(foo... ':'"));
|
|
assert_eq!(pat.parse_part("$(foo =").unwrap_err().to_string(),
|
|
("syntax error in $(foo... ' '"));
|
|
assert_eq!(pat.parse_part("$(eo0=$bar").unwrap_err().to_string(),
|
|
("expected ')' after $(eo0=$bar..."));
|
|
assert_eq!(pat.parse_part("$(eo1=$bar}").unwrap_err().to_string(),
|
|
("expected ')' after $(eo1=$bar..."));
|
|
assert_eq!(pat.parse_part("$(eo2=$)").unwrap_err().to_string(),
|
|
("expected variable name in $(eo2=$..."));
|
|
assert_eq!(pat.parse_part("$(eo3=$-)").unwrap_err().to_string(),
|
|
("expected variable name in $(eo3=$..."));
|
|
}
|
|
|
|
#[test]
|
|
fn partdefs() {
|
|
use super::{Pattern, Part};
|
|
let mut pat = Pattern::new();
|
|
|
|
assert_eq!(pat.parse_part("$(foo=$bar)").unwrap(),
|
|
(Part::DefVar {
|
|
def: 0,
|
|
var: "bar".to_string(),
|
|
},
|
|
11));
|
|
assert_eq!(pat.parse_part("$(foo=$bar)").unwrap_err().to_string(),
|
|
"duplicate definition of $foo in same pattern");
|
|
|
|
assert_eq!(pat.parse_part("$(fxo=$bar)x").unwrap(),
|
|
(Part::DefVar {
|
|
def: 1,
|
|
var: "bar".to_string(),
|
|
},
|
|
11));
|
|
|
|
assert_eq!(pat.parse_part("$(fo2=[a-z])").unwrap(),
|
|
(Part::DefLit {
|
|
def: 2,
|
|
regex: "(?P<fo2>[a-z])".to_string(),
|
|
},
|
|
12));
|
|
assert_eq!(pat.parse_part("$(fo3=[a-)])").unwrap(),
|
|
(Part::DefLit {
|
|
def: 3,
|
|
regex: "(?P<fo3>[a-)])".to_string(),
|
|
},
|
|
12));
|
|
assert_eq!(pat.parse_part("$(fo4=)").unwrap(),
|
|
(Part::DefLit {
|
|
def: 4,
|
|
regex: "(?P<fo4>)".to_string(),
|
|
},
|
|
7));
|
|
|
|
assert_eq!(pat.parse_part("$(=.*)").unwrap(),
|
|
(Part::Regex("(?:.*)".to_string()), 6));
|
|
|
|
assert_eq!(pat.parse_part("$(=)").unwrap(),
|
|
(Part::Regex("(?:)".to_string()), 4));
|
|
assert_eq!(pat.parse_part("$()").unwrap(),
|
|
(Part::Text("".to_string()), 3));
|
|
}
|
|
|
|
#[test]
|
|
fn pattern() {
|
|
use super::Pattern;
|
|
|
|
let p: Pattern = " Hello world! ".parse().unwrap();
|
|
assert_eq!(format!("{:?}", p.parts), "[Text(\"Hello world!\")]");
|
|
|
|
let p: Pattern = " $foo=$(bar) ".parse().unwrap();
|
|
assert_eq!(format!("{:?}", p.parts),
|
|
"[Var(\"foo\"), Text(\"=\"), Var(\"bar\")]");
|
|
}
|
|
}
|