int main(int argc, char *argv[]){
char *regex=argv[1];
char *haystack=argv[2];
regex_t preg; /* Compiled pattern to search for. */
//errcode = tre_regcomp(&preg, regexp, comp_flags);
int search_str_len=strlen(regex);
int cflags= REG_ICASE;
ret = tre_compile(&preg, (const tre_char_t *)regex, search_str_len, cflags);
//extern int
// tre_reganexec(const regex_t *preg, const char *string, size_t len,
// regamatch_t *match, regaparams_t params, int eflags);
tre_reganexec(&preg,haystack,strlen(haystack));
int errcode;
regamatch_t match;
regmatch_t pmatch[1];
memset(&match, 0, sizeof(match));
regaparams_t match_params;
memset(&match_params,0,sizeof(match_params));
}
static int generic_atfind (lua_State *L, int tfind) {
int res;
TArgExec argE;
TPosix *ud;
regaparams_t argP;
regamatch_t res_match;
checkarg_atfind (L, &argE, &ud, &argP);
if (argE.startoffset > (int)argE.textlen)
return lua_pushnil(L), 1;
argE.text += argE.startoffset;
res_match.nmatch = ALG_NSUB(ud) + 1;
res_match.pmatch = ud->match;
/* execute the search */
res = tre_reganexec (&ud->r, argE.text, argE.textlen - argE.startoffset,
&res_match, argP, argE.eflags);
if (ALG_ISMATCH (res)) {
ALG_PUSHOFFSETS (L, ud, argE.startoffset, 0);
if (tfind)
push_substring_table (L, ud, argE.text);
else
push_offset_table (L, ud, argE.startoffset);
/* set values in the dictionary part of the table */
set_int_field (L, "cost", res_match.cost);
set_int_field (L, "num_ins", res_match.num_ins);
set_int_field (L, "num_del", res_match.num_del);
set_int_field (L, "num_subst", res_match.num_subst);
return 3;
}
else if (ALG_NOMATCH (res))
return lua_pushnil (L), 1;
else
return generate_error (L, ud, res);
}
int
tre_regaexec(const regex_t *preg, const char *str,
regamatch_t *match, regaparams_t params, int eflags)
{
return tre_reganexec(preg, str, (unsigned)-1, match, params, eflags);
}
static VALUE
tre_traverse(VALUE pattern, VALUE string, long char_offset, VALUE params,
VALUE ignore_case, VALUE multi_line, int num_captures, VALUE repeat) {
// Compile once
regex_t preg;
tre_compile_regex(&preg, pattern, ignore_case, multi_line);
// Build regaparams
regaparams_t aparams;
tre_build_aparams(&aparams, params);
// Match data
regamatch_t match;
regmatch_t pmatch[num_captures + 1];
// memset(&match, 0, sizeof(match));
match.nmatch = num_captures + 1;
match.pmatch = pmatch;
// Scan
VALUE arr = rb_ary_new();
long char_offset_acc = char_offset;
// rb_global_variable(&arr);
while (1) {
// Get substring to start with
long char_len = CHAR_LENGTH(string) - char_offset;
if (char_len <= 0) break;
string = rb_str_substr(string, char_offset, char_len);
int result = tre_reganexec(&preg, StringValuePtr(string),
RSTRING_LEN(string), &match, aparams, 0);
if (result == REG_NOMATCH) break;
// Fill in array with ranges
VALUE subarr;
if (match.nmatch == 1)
subarr = arr; // Faking.. kind of.
else {
subarr = rb_ary_new();
// rb_global_variable(&subarr);
}
unsigned int i;
for (i = 0; i < match.nmatch; ++i)
// No match
if (match.pmatch[i].rm_so == -1)
rb_ary_push(subarr, Qnil);
// Match => Range
else {
VALUE range = rb_range_new(
LONG2NUM( char_offset_acc + BYTE_TO_CHAR(string, match.pmatch[i].rm_so) ),
LONG2NUM( char_offset_acc + BYTE_TO_CHAR(string, match.pmatch[i].rm_eo) ),
1);
// rb_global_variable(&range);
rb_ary_push(subarr, range);
}
if (match.nmatch > 1) rb_ary_push(arr, subarr);
// Stop or proceed
if (repeat == Qfalse)
break;
else {
char_offset = BYTE_TO_CHAR(string, match.pmatch[0].rm_eo);
if (char_offset == 0) char_offset = 1; // Weird case
char_offset_acc += char_offset;
}
}
// Free once
tre_regfree(&preg);
return arr;
}
