initial commit
This commit is contained in:
commit
816fd0db2c
14
Cargo.toml
Normal file
14
Cargo.toml
Normal file
|
@ -0,0 +1,14 @@
|
|||
[package]
|
||||
name = "lua-patterns"
|
||||
version = "0.1.0"
|
||||
authors = ["steve donovan <steve.j.donovan@gmail.com>"]
|
||||
links = "foo"
|
||||
build = "build.rs"
|
||||
|
||||
[dependencies]
|
||||
libc="0.2.0"
|
||||
|
||||
[build-dependencies]
|
||||
gcc="0.3"
|
||||
|
||||
|
5
build.rs
Normal file
5
build.rs
Normal file
|
@ -0,0 +1,5 @@
|
|||
extern crate gcc;
|
||||
|
||||
fn main() {
|
||||
gcc::compile_library("liblua-str.a", &["src/lua-str.c"]);
|
||||
}
|
36
examples/iter.rs
Normal file
36
examples/iter.rs
Normal file
|
@ -0,0 +1,36 @@
|
|||
extern crate lua_patterns as lp;
|
||||
|
||||
|
||||
|
||||
fn main() {
|
||||
let mut m = lp::LuaPattern::new("(%a+)");
|
||||
let mut iter = m.gmatch("one two three");
|
||||
assert_eq!(iter.next(), Some("one"));
|
||||
assert_eq!(iter.next(), Some("two"));
|
||||
assert_eq!(iter.next(), Some("three"));
|
||||
assert_eq!(iter.next(), None);
|
||||
|
||||
let mut m = lp::LuaPattern::new("(%a+)");
|
||||
let split: Vec<_> = m.gmatch("dog cat leopard wolf").collect();
|
||||
assert_eq!(split,&["dog","cat","leopard","wolf"]);
|
||||
|
||||
let mut m = lp::LuaPattern::new("(%S+)%s*=%s*(.+)");
|
||||
let cc = m.captures(" hello= bonzo dog");
|
||||
assert_eq!(cc[0], "hello= bonzo dog");
|
||||
assert_eq!(cc[1],"hello");
|
||||
assert_eq!(cc[2],"bonzo dog");
|
||||
|
||||
let captures = m.match_captures(" frodo = baggins");
|
||||
for s in captures {
|
||||
println!("{:?}",s);
|
||||
}
|
||||
|
||||
|
||||
let mut m = lp::LuaPattern::new("%$(%S+)");
|
||||
let res = m.gsub("hello $dolly you're so $fine",
|
||||
|cc| cc.get(1).to_uppercase()
|
||||
);
|
||||
assert_eq!(res,"hello DOLLY you're so FINE");
|
||||
|
||||
|
||||
}
|
261
src/lib.rs
Normal file
261
src/lib.rs
Normal file
|
@ -0,0 +1,261 @@
|
|||
extern crate libc;
|
||||
use libc::{size_t,c_int};
|
||||
use std::ptr;
|
||||
use std::ops;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(PartialEq,Eq,Debug)]
|
||||
struct LuaMatch {
|
||||
start: c_int,
|
||||
end: c_int
|
||||
}
|
||||
|
||||
static LUA_MAXCAPTURES: usize = 32;
|
||||
|
||||
// int str_match (const char *s, size_t ls, const char *p, size_t lp, char **err_msg, LuaMatch *mm)
|
||||
#[link(name = "lua-str", kind="static")]
|
||||
extern {
|
||||
fn str_match (s: *const u8, ls: size_t, p: *const u8, lp: size_t,
|
||||
//err_msg: *mut *const u8,
|
||||
err_msg: *const u8,
|
||||
mm: *mut LuaMatch) -> c_int;
|
||||
}
|
||||
|
||||
pub struct LuaPattern<'a> {
|
||||
patt: &'a [u8],
|
||||
matches: Vec<LuaMatch>,
|
||||
n_match: usize
|
||||
}
|
||||
|
||||
impl <'a> LuaPattern<'a> {
|
||||
pub fn new(patt: &'a str) -> LuaPattern<'a> {
|
||||
LuaPattern::from_bytes(patt.as_bytes())
|
||||
}
|
||||
|
||||
pub fn from_bytes (bytes: &'a [u8]) -> LuaPattern<'a> {
|
||||
let mut matches: Vec<LuaMatch> = Vec::with_capacity(LUA_MAXCAPTURES);
|
||||
unsafe {matches.set_len(LUA_MAXCAPTURES);}
|
||||
LuaPattern{patt: bytes, matches: matches, n_match: 0}
|
||||
}
|
||||
|
||||
pub fn matches_bytes(&mut self, s: &[u8]) -> bool {
|
||||
let err_msg: *const u8 = ptr::null();
|
||||
|
||||
unsafe {
|
||||
self.n_match = str_match(s.as_ptr(),s.len() as size_t,
|
||||
self.patt.as_ptr(),self.patt.len() as size_t,
|
||||
err_msg, self.matches.as_mut_ptr()) as usize;
|
||||
}
|
||||
self.n_match > 0
|
||||
}
|
||||
|
||||
pub fn matches(&mut self, text: &str) -> bool {
|
||||
self.matches_bytes(text.as_bytes())
|
||||
}
|
||||
|
||||
|
||||
pub fn captures<'b>(&mut self, text: &'b str) -> Vec<&'b str> {
|
||||
let mut res = Vec::new();
|
||||
self.capture_into(text, &mut res);
|
||||
res
|
||||
}
|
||||
|
||||
pub fn match_captures<'b>(&'a mut self, text: &'b str) -> Captures<'a,'b> {
|
||||
self.matches(text);
|
||||
Captures {m: self, text: text}
|
||||
}
|
||||
|
||||
pub fn capture_into<'b>(&mut self, text: &'b str, vec: &mut Vec<&'b str>) -> bool {
|
||||
self.matches(text);
|
||||
vec.clear();
|
||||
for i in 0..self.n_match {
|
||||
vec.push(&text[self.bounds(i)]);
|
||||
}
|
||||
self.n_match > 0
|
||||
}
|
||||
|
||||
pub fn range(&self) -> ops::Range<usize> {
|
||||
self.bounds(0)
|
||||
}
|
||||
|
||||
pub fn bounds(&self, i: usize) -> ops::Range<usize> {
|
||||
ops::Range{
|
||||
start: self.matches[i].start as usize,
|
||||
end: self.matches[i].end as usize
|
||||
}
|
||||
}
|
||||
|
||||
pub fn first_match<'b>(&mut self, text: &'b str) -> Option<&'b str> {
|
||||
self.matches(text);
|
||||
if self.n_match > 0 {
|
||||
Some(&text[self.bounds(if self.n_match > 1 {1} else {0})])
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
pub fn gmatch<'b>(&'a mut self, text: &'b str) -> GMatch<'a,'b> {
|
||||
GMatch{m: self, text: text}
|
||||
}
|
||||
|
||||
pub fn gsub <F> (&mut self, text: &str, lookup: F) -> String
|
||||
where F: Fn(Captures)-> String {
|
||||
let mut slice = text;
|
||||
let mut res = String::new();
|
||||
while self.matches(slice) {
|
||||
// full range of match
|
||||
let all = self.bounds(0);
|
||||
let captures = Captures{m: self, text: slice};
|
||||
let repl = lookup(captures);
|
||||
// append everything up to match
|
||||
res.push_str(&slice[0..all.start]);
|
||||
res.push_str(&repl);
|
||||
slice = &slice[all.end..];
|
||||
}
|
||||
res.push_str(slice);
|
||||
res
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
pub struct Captures<'a,'b> {
|
||||
m: &'a LuaPattern<'a>,
|
||||
text: &'b str
|
||||
}
|
||||
|
||||
impl <'a,'b> Captures<'a,'b> {
|
||||
pub fn get(&self, i: usize) -> &'b str {
|
||||
&self.text[self.m.bounds(i)]
|
||||
}
|
||||
|
||||
pub fn num_matches(&self) -> usize {
|
||||
self.m.n_match
|
||||
}
|
||||
}
|
||||
|
||||
pub struct CaptureIter<'a,'b> {
|
||||
cc: Captures<'a,'b>,
|
||||
idx: usize,
|
||||
top: usize
|
||||
}
|
||||
|
||||
impl <'a,'b>Iterator for CaptureIter<'a,'b> {
|
||||
type Item = &'b str;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.idx < self.top {
|
||||
let res = self.cc.get(self.idx);
|
||||
self.idx += 1;
|
||||
Some(res)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl <'a,'b> IntoIterator for Captures<'a,'b> {
|
||||
type Item = &'b str;
|
||||
type IntoIter = CaptureIter<'a,'b>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
CaptureIter{idx: 0, top: self.num_matches(),cc: self}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
pub struct GMatch<'a,'b> {
|
||||
m: &'a mut LuaPattern<'a>,
|
||||
text: &'b str
|
||||
}
|
||||
|
||||
impl <'a,'b>Iterator for GMatch<'a,'b> {
|
||||
type Item = &'b str;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if ! self.m.matches(self.text) {
|
||||
None
|
||||
} else {
|
||||
let first = if self.m.n_match > 1 {1} else {0};
|
||||
let slice = &self.text[self.m.bounds(first)];
|
||||
self.text = &self.text[self.m.range().end..];
|
||||
Some(slice)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
|
||||
#[test]
|
||||
fn captures_and_matching() {
|
||||
let mut m = LuaPattern::new("(one).+");
|
||||
assert_eq!(m.captures(" one two"),&["one two","one"]);
|
||||
let empty: &[&str] = &[];
|
||||
assert_eq!(m.captures("four"),empty);
|
||||
|
||||
assert_eq!(m.matches("one dog"),true);
|
||||
assert_eq!(m.matches("dog one "),true);
|
||||
assert_eq!(m.matches("dog one"),false);
|
||||
|
||||
let text = "one dog";
|
||||
let mut m = LuaPattern::new("^(%a+)");
|
||||
assert_eq!(m.matches(text),true);
|
||||
assert_eq!(&text[m.bounds(1)], "one");
|
||||
assert_eq!(m.matches(" one dog"),false);
|
||||
|
||||
// captures without allocation
|
||||
let captures = m.match_captures(text);
|
||||
assert_eq!(captures.get(0),"one");
|
||||
assert_eq!(captures.get(1),"one");
|
||||
|
||||
let mut m = LuaPattern::new("(%S+)%s*=%s*(.+)");
|
||||
|
||||
// captures as Vec
|
||||
let cc = m.captures(" hello= bonzo dog");
|
||||
assert_eq!(cc[0], "hello= bonzo dog");
|
||||
assert_eq!(cc[1],"hello");
|
||||
assert_eq!(cc[2],"bonzo dog");
|
||||
|
||||
// captures as iterator
|
||||
let mut iter = m.match_captures(" frodo = baggins").into_iter();
|
||||
assert_eq!(iter.next(), Some("frodo = baggins"));
|
||||
assert_eq!(iter.next(), Some("frodo"));
|
||||
assert_eq!(iter.next(), Some("baggins"));
|
||||
assert_eq!(iter.next(), None);
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gmatch() {
|
||||
let mut m = LuaPattern::new("%a+");
|
||||
let mut iter = m.gmatch("one two three");
|
||||
assert_eq!(iter.next(), Some("one"));
|
||||
assert_eq!(iter.next(), Some("two"));
|
||||
assert_eq!(iter.next(), Some("three"));
|
||||
assert_eq!(iter.next(), None);
|
||||
|
||||
let mut m = LuaPattern::new("(%a+)");
|
||||
let mut iter = m.gmatch("one two three");
|
||||
assert_eq!(iter.next(), Some("one"));
|
||||
assert_eq!(iter.next(), Some("two"));
|
||||
assert_eq!(iter.next(), Some("three"));
|
||||
assert_eq!(iter.next(), None);
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn gsub() {
|
||||
let mut m = LuaPattern::new("%$(%S+)");
|
||||
let res = m.gsub("hello $dolly you're so $fine!",
|
||||
|cc| cc.get(1).to_uppercase()
|
||||
);
|
||||
assert_eq!(res,"hello DOLLY you're so FINE!");
|
||||
|
||||
|
||||
}
|
||||
}
|
415
src/lua-str.c
Normal file
415
src/lua-str.c
Normal file
|
@ -0,0 +1,415 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stddef.h>
|
||||
#include <ctype.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <stdarg.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
typedef struct LuaMatch {
|
||||
int start;
|
||||
int end;
|
||||
} LuaMatch;
|
||||
|
||||
|
||||
// not thread safe (yet)
|
||||
static jmp_buf s_jmp_buf;
|
||||
static char s_msg_buff[256];
|
||||
|
||||
|
||||
/* macro to `unsign' a character */
|
||||
#define uchar(c) ((unsigned char)(c))
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** PATTERN MATCHING
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
#define LUA_MAXCAPTURES 32
|
||||
|
||||
/* maximum recursion depth for 'match' */
|
||||
#define MAXCCALLS 200
|
||||
|
||||
#define CAP_UNFINISHED (-1)
|
||||
#define CAP_POSITION (-2)
|
||||
|
||||
typedef struct MatchState {
|
||||
int matchdepth; /* control for recursive depth (to avoid C stack overflow) */
|
||||
const char *src_init; /* init of source string */
|
||||
const char *src_end; /* end ('\0') of source string */
|
||||
const char *p_end; /* end ('\0') of pattern */
|
||||
int level; /* total number of captures (finished or unfinished) */
|
||||
struct {
|
||||
const char *init;
|
||||
ptrdiff_t len;
|
||||
} capture[LUA_MAXCAPTURES];
|
||||
} MatchState;
|
||||
|
||||
/* recursive function */
|
||||
static const char *match (MatchState *ms, const char *s, const char *p);
|
||||
|
||||
#define L_ESC '%'
|
||||
#define SPECIALS "^$*+?.([%-"
|
||||
|
||||
// error handling, hm?? NB
|
||||
|
||||
static int throw_error(const char *fmt,...) {
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
vsnprintf(s_msg_buff,sizeof(s_msg_buff),fmt,ap);
|
||||
va_end(ap);
|
||||
longjmp(s_jmp_buf,1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int check_capture (MatchState *ms, int l) {
|
||||
l -= '1';
|
||||
if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
|
||||
return throw_error("invalid capture index %%%d", l + 1);
|
||||
return l;
|
||||
}
|
||||
|
||||
static int capture_to_close (MatchState *ms) {
|
||||
int level = ms->level;
|
||||
for (level--; level>=0; level--)
|
||||
if (ms->capture[level].len == CAP_UNFINISHED) return level;
|
||||
return throw_error("invalid pattern capture");
|
||||
}
|
||||
|
||||
|
||||
static const char *classend (MatchState *ms, const char *p) {
|
||||
switch (*p++) {
|
||||
case L_ESC: {
|
||||
if (p == ms->p_end)
|
||||
throw_error("malformed pattern (ends with '%')");
|
||||
return p+1;
|
||||
}
|
||||
case '[': {
|
||||
if (*p == '^') p++;
|
||||
do { /* look for a `]' */
|
||||
if (p == ms->p_end)
|
||||
throw_error("malformed pattern (missing ']')");
|
||||
if (*(p++) == L_ESC && p < ms->p_end)
|
||||
p++; /* skip escapes (e.g. `%]') */
|
||||
} while (*p != ']');
|
||||
return p+1;
|
||||
}
|
||||
default: {
|
||||
return p;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int match_class (int c, int cl) {
|
||||
int res;
|
||||
switch (tolower(cl)) {
|
||||
case 'a' : res = isalpha(c); break;
|
||||
case 'c' : res = iscntrl(c); break;
|
||||
case 'd' : res = isdigit(c); break;
|
||||
case 'g' : res = isgraph(c); break;
|
||||
case 'l' : res = islower(c); break;
|
||||
case 'p' : res = ispunct(c); break;
|
||||
case 's' : res = isspace(c); break;
|
||||
case 'u' : res = isupper(c); break;
|
||||
case 'w' : res = isalnum(c); break;
|
||||
case 'x' : res = isxdigit(c); break;
|
||||
case 'z' : res = (c == 0); break; /* deprecated option */
|
||||
default: return (cl == c);
|
||||
}
|
||||
return (islower(cl) ? res : !res);
|
||||
}
|
||||
|
||||
|
||||
static int matchbracketclass (int c, const char *p, const char *ec) {
|
||||
int sig = 1;
|
||||
if (*(p+1) == '^') {
|
||||
sig = 0;
|
||||
p++; /* skip the `^' */
|
||||
}
|
||||
while (++p < ec) {
|
||||
if (*p == L_ESC) {
|
||||
p++;
|
||||
if (match_class(c, uchar(*p)))
|
||||
return sig;
|
||||
}
|
||||
else if ((*(p+1) == '-') && (p+2 < ec)) {
|
||||
p+=2;
|
||||
if (uchar(*(p-2)) <= c && c <= uchar(*p))
|
||||
return sig;
|
||||
}
|
||||
else if (uchar(*p) == c) return sig;
|
||||
}
|
||||
return !sig;
|
||||
}
|
||||
|
||||
|
||||
static int singlematch (MatchState *ms, const char *s, const char *p,
|
||||
const char *ep) {
|
||||
if (s >= ms->src_end)
|
||||
return 0;
|
||||
else {
|
||||
int c = uchar(*s);
|
||||
switch (*p) {
|
||||
case '.': return 1; /* matches any char */
|
||||
case L_ESC: return match_class(c, uchar(*(p+1)));
|
||||
case '[': return matchbracketclass(c, p, ep-1);
|
||||
default: return (uchar(*p) == c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const char *matchbalance (MatchState *ms, const char *s,
|
||||
const char *p) {
|
||||
if (p >= ms->p_end - 1)
|
||||
throw_error("malformed pattern "
|
||||
"(missing arguments to '%b')");
|
||||
if (*s != *p) return NULL;
|
||||
else {
|
||||
int b = *p;
|
||||
int e = *(p+1);
|
||||
int cont = 1;
|
||||
while (++s < ms->src_end) {
|
||||
if (*s == e) {
|
||||
if (--cont == 0) return s+1;
|
||||
}
|
||||
else if (*s == b) cont++;
|
||||
}
|
||||
}
|
||||
return NULL; /* string ends out of balance */
|
||||
}
|
||||
|
||||
|
||||
static const char *max_expand (MatchState *ms, const char *s,
|
||||
const char *p, const char *ep) {
|
||||
ptrdiff_t i = 0; /* counts maximum expand for item */
|
||||
while (singlematch(ms, s + i, p, ep))
|
||||
i++;
|
||||
/* keeps trying to match with the maximum repetitions */
|
||||
while (i>=0) {
|
||||
const char *res = match(ms, (s+i), ep+1);
|
||||
if (res) return res;
|
||||
i--; /* else didn't match; reduce 1 repetition to try again */
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static const char *min_expand (MatchState *ms, const char *s,
|
||||
const char *p, const char *ep) {
|
||||
for (;;) {
|
||||
const char *res = match(ms, s, ep+1);
|
||||
if (res != NULL)
|
||||
return res;
|
||||
else if (singlematch(ms, s, p, ep))
|
||||
s++; /* try with one more repetition */
|
||||
else return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const char *start_capture (MatchState *ms, const char *s,
|
||||
const char *p, int what) {
|
||||
const char *res;
|
||||
int level = ms->level;
|
||||
if (level >= LUA_MAXCAPTURES) throw_error("too many captures");
|
||||
ms->capture[level].init = s;
|
||||
ms->capture[level].len = what;
|
||||
ms->level = level+1;
|
||||
if ((res=match(ms, s, p)) == NULL) /* match failed? */
|
||||
ms->level--; /* undo capture */
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
static const char *end_capture (MatchState *ms, const char *s,
|
||||
const char *p) {
|
||||
int l = capture_to_close(ms);
|
||||
const char *res;
|
||||
ms->capture[l].len = s - ms->capture[l].init; /* close capture */
|
||||
if ((res = match(ms, s, p)) == NULL) /* match failed? */
|
||||
ms->capture[l].len = CAP_UNFINISHED; /* undo capture */
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
static const char *match_capture (MatchState *ms, const char *s, int l) {
|
||||
size_t len;
|
||||
l = check_capture(ms, l);
|
||||
len = ms->capture[l].len;
|
||||
if ((size_t)(ms->src_end-s) >= len &&
|
||||
memcmp(ms->capture[l].init, s, len) == 0)
|
||||
return s+len;
|
||||
else return NULL;
|
||||
}
|
||||
|
||||
static const char *match (MatchState *ms, const char *s, const char *p) {
|
||||
if (ms->matchdepth-- == 0)
|
||||
throw_error("pattern too complex");
|
||||
init: /* using goto's to optimize tail recursion */
|
||||
if (p != ms->p_end) { /* end of pattern? */
|
||||
switch (*p) {
|
||||
case '(': { /* start capture */
|
||||
if (*(p + 1) == ')') /* position capture? */
|
||||
s = start_capture(ms, s, p + 2, CAP_POSITION);
|
||||
else
|
||||
s = start_capture(ms, s, p + 1, CAP_UNFINISHED);
|
||||
break;
|
||||
}
|
||||
case ')': { /* end capture */
|
||||
s = end_capture(ms, s, p + 1);
|
||||
break;
|
||||
}
|
||||
case '$': {
|
||||
if ((p + 1) != ms->p_end) /* is the `$' the last char in pattern? */
|
||||
goto dflt; /* no; go to default */
|
||||
s = (s == ms->src_end) ? s : NULL; /* check end of string */
|
||||
break;
|
||||
}
|
||||
case L_ESC: { /* escaped sequences not in the format class[*+?-]? */
|
||||
switch (*(p + 1)) {
|
||||
case 'b': { /* balanced string? */
|
||||
s = matchbalance(ms, s, p + 2);
|
||||
if (s != NULL) {
|
||||
p += 4; goto init; /* return match(ms, s, p + 4); */
|
||||
} /* else fail (s == NULL) */
|
||||
break;
|
||||
}
|
||||
case 'f': { /* frontier? */
|
||||
const char *ep; char previous;
|
||||
p += 2;
|
||||
if (*p != '[')
|
||||
throw_error("missing '[' after '%f' in pattern");
|
||||
ep = classend(ms, p); /* points to what is next */
|
||||
previous = (s == ms->src_init) ? '\0' : *(s - 1);
|
||||
if (!matchbracketclass(uchar(previous), p, ep - 1) &&
|
||||
matchbracketclass(uchar(*s), p, ep - 1)) {
|
||||
p = ep; goto init; /* return match(ms, s, ep); */
|
||||
}
|
||||
s = NULL; /* match failed */
|
||||
break;
|
||||
}
|
||||
case '0': case '1': case '2': case '3':
|
||||
case '4': case '5': case '6': case '7':
|
||||
case '8': case '9': { /* capture results (%0-%9)? */
|
||||
s = match_capture(ms, s, uchar(*(p + 1)));
|
||||
if (s != NULL) {
|
||||
p += 2; goto init; /* return match(ms, s, p + 2) */
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: goto dflt;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: dflt: { /* pattern class plus optional suffix */
|
||||
const char *ep = classend(ms, p); /* points to optional suffix */
|
||||
/* does not match at least once? */
|
||||
if (!singlematch(ms, s, p, ep)) {
|
||||
if (*ep == '*' || *ep == '?' || *ep == '-') { /* accept empty? */
|
||||
p = ep + 1; goto init; /* return match(ms, s, ep + 1); */
|
||||
}
|
||||
else /* '+' or no suffix */
|
||||
s = NULL; /* fail */
|
||||
}
|
||||
else { /* matched once */
|
||||
switch (*ep) { /* handle optional suffix */
|
||||
case '?': { /* optional */
|
||||
const char *res;
|
||||
if ((res = match(ms, s + 1, ep + 1)) != NULL)
|
||||
s = res;
|
||||
else {
|
||||
p = ep + 1; goto init; /* else return match(ms, s, ep + 1); */
|
||||
}
|
||||
break;
|
||||
}
|
||||
case '+': /* 1 or more repetitions */
|
||||
s++; /* 1 match already done */
|
||||
/* go through */
|
||||
case '*': /* 0 or more repetitions */
|
||||
s = max_expand(ms, s, p, ep);
|
||||
break;
|
||||
case '-': /* 0 or more repetitions (minimum) */
|
||||
s = min_expand(ms, s, p, ep);
|
||||
break;
|
||||
default: /* no suffix */
|
||||
s++; p = ep; goto init; /* return match(ms, s + 1, ep); */
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
ms->matchdepth++;
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void push_onecapture (MatchState *ms, int i, const char *s,
|
||||
const char *e, LuaMatch *mm) {
|
||||
if (i >= ms->level) {
|
||||
if (i == 0) { /* ms->level == 0, too */
|
||||
mm->start = 0;
|
||||
mm->end = e - s ;
|
||||
//lua_pushlstring(ms->L, s, e - s); /* add whole match */
|
||||
} else
|
||||
throw_error("invalid capture index");
|
||||
}
|
||||
else {
|
||||
ptrdiff_t l = ms->capture[i].len;
|
||||
if (l == CAP_UNFINISHED) throw_error("unfinished capture");
|
||||
if (l == CAP_POSITION) {
|
||||
mm[i].start = ms->capture[i].init - ms->src_init + 1;
|
||||
mm[i].end = mm[i].start;
|
||||
} else {
|
||||
mm[i].start = ms->capture[i].init - ms->src_init;
|
||||
mm[i].end = mm[i].start + l;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int push_captures (MatchState *ms, const char *s, const char *e, LuaMatch *mm) {
|
||||
int i;
|
||||
int nlevels = (ms->level == 0 && s) ? 1 : ms->level;
|
||||
for (i = 0; i < nlevels; i++)
|
||||
push_onecapture(ms, i, s, e, mm);
|
||||
return nlevels; /* number of strings pushed */
|
||||
}
|
||||
|
||||
|
||||
int str_match (const char *s, size_t ls, const char *p, size_t lp, char **err_msg, LuaMatch *mm) {
|
||||
const char *s1 = s;
|
||||
MatchState ms;
|
||||
int anchor = (*p == '^');
|
||||
if (anchor) {
|
||||
p++; lp--; /* skip anchor character */
|
||||
}
|
||||
ms.matchdepth = MAXCCALLS;
|
||||
ms.src_init = s;
|
||||
ms.src_end = s + ls;
|
||||
ms.p_end = p + lp;
|
||||
do {
|
||||
const char *res;
|
||||
ms.level = 0;
|
||||
if ((res=match(&ms, s1, p)) != NULL) {
|
||||
mm[0].start = s1 - s; /* start */
|
||||
mm[0].end = res - s; /* end */
|
||||
return push_captures(&ms, NULL, 0, mm+1) + 1;
|
||||
}
|
||||
} while (s1++ < ms.src_end && !anchor);
|
||||
|
||||
if (setjmp(s_jmp_buf) != 0) {
|
||||
if (err_msg != NULL) *err_msg = s_msg_buff;
|
||||
} else {
|
||||
if (err_msg != NULL) *err_msg = NULL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
Loading…
Reference in a new issue