d5ed27cce6
Often, an implementation of VariableMap can return references to internal strings, and Cow::Borrow() allows that without making any copies. We still want to allow VariableMap implementations to return owned strings in case they have to manufacture variable values on demand. The Cow::Owned() variant does exactly that. Switch the internal VariableMap implementations over to Cows. It turns out they can simply store references to substrings of the input test, completely avoiding string allocation for script-defined variables.
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(try!(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) = try!(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(try!(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::*;
|
|
try!(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\")]");
|
|
}
|
|
}
|