mirror of
https://gitee.com/Lyon1998/pikapython.git
synced 2025-01-15 17:02:53 +08:00
705 lines
15 KiB
C
705 lines
15 KiB
C
|
|
/* #define PCRE_STATIC */
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "pcre.h"
|
|
#include "cre.h"
|
|
|
|
/// @brief the the number of groups in a re pattern
|
|
/// @param re: re pattern
|
|
/// @param out_groups_number : from 0,1,2,3,4...
|
|
/// @return a array pointer, free if after using
|
|
int *_re_get_vec_table(pcre *re, int *out_groups_number)
|
|
{
|
|
int brackets_number = 0;
|
|
pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &brackets_number);
|
|
brackets_number++;
|
|
|
|
if (out_groups_number)
|
|
*out_groups_number = brackets_number;
|
|
|
|
brackets_number *= 3;
|
|
|
|
int *vec = (int *)malloc(brackets_number * sizeof(int));
|
|
return vec;
|
|
}
|
|
|
|
/*************************************************************************
|
|
|
|
* (https?)://((\w+\.)+)(\w+)
|
|
* hihsid dii https://www.baidu.com, http://glwang.com
|
|
*************************************************************************/
|
|
|
|
int *pcre_match(const char *_pat, const char *s, int len, int *out_vec_number, int opt)
|
|
{
|
|
int *vec = NULL;
|
|
// int group_n = 0;
|
|
//int rc;
|
|
// int start_offset = 0;
|
|
pcre *re = re_get_match_re(_pat, opt);
|
|
if (!re)
|
|
return NULL;
|
|
|
|
vec = re_match2(re, s, len, out_vec_number, opt);
|
|
pcre_free(re);
|
|
return vec;
|
|
}
|
|
int *re_match2(pcre *re, const char *s, int len, int *out_vec_number, int opt)
|
|
{
|
|
int *vec = NULL;
|
|
int group_n = 0;
|
|
int rc;
|
|
int start_offset = 0;
|
|
vec = _re_get_vec_table(re, &group_n);
|
|
if (out_vec_number)
|
|
*out_vec_number = group_n;
|
|
group_n *= 3;
|
|
|
|
if (!vec)
|
|
goto e_er;
|
|
match:
|
|
rc = pcre_exec(re, NULL, s, len, start_offset, 0, vec, group_n);
|
|
if (rc == PCRE_ERROR_NOMATCH)
|
|
{
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
if (rc <= 0)
|
|
goto e_er;
|
|
if (vec[0] == vec[1]) // a empty match
|
|
{
|
|
start_offset++; // advace a position
|
|
if (start_offset >= len)
|
|
goto e_er;
|
|
goto match;
|
|
}
|
|
return vec;
|
|
e_er:
|
|
if (vec)
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
|
|
int *pcre_fullmatch(const char *_pat, const char *s, int len, int *out_vec_number, int opt)
|
|
{
|
|
int *vec = NULL;
|
|
// int group_n = 0;
|
|
//int rc;
|
|
// int start_offset = 0;
|
|
opt &= ~PCRE_MULTILINE;
|
|
pcre *re = re_get_fullmatch_re(_pat, opt);
|
|
if (!re)
|
|
return NULL;
|
|
vec = re_fullmatch2(re, s, len, out_vec_number, opt);
|
|
pcre_free(re);
|
|
return vec;
|
|
}
|
|
int *re_fullmatch2(pcre *re, const char *s, int len, int *out_vec_number, int opt)
|
|
{
|
|
int *vec = NULL;
|
|
int group_n = 0;
|
|
int rc;
|
|
int start_offset = 0;
|
|
vec = _re_get_vec_table(re, &group_n);
|
|
if (out_vec_number)
|
|
*out_vec_number = group_n;
|
|
group_n *= 3;
|
|
|
|
if (!vec)
|
|
goto e_er;
|
|
opt &= ~PCRE_MULTILINE;
|
|
match:
|
|
rc = pcre_exec(re, NULL, s, len, start_offset, 0, vec, group_n);
|
|
if (rc == PCRE_ERROR_NOMATCH)
|
|
{
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
if (rc <= 0)
|
|
goto e_er;
|
|
if (vec[0] == vec[1]) // a empty match
|
|
{
|
|
start_offset++; // advace a position
|
|
if (start_offset >= len)
|
|
goto e_er;
|
|
goto match;
|
|
}
|
|
return vec;
|
|
e_er:
|
|
if (vec)
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
|
|
pcre *re_get_match_re(const char *_pat, int opt)
|
|
{
|
|
const char *pat = _pat;
|
|
if (!*pat)
|
|
{
|
|
return NULL;
|
|
}
|
|
if (*pat != '^')
|
|
{
|
|
int pat_len = strlen(_pat);
|
|
char *p = (char *)pcre_malloc(pat_len + 2);
|
|
if (!p)
|
|
return NULL;
|
|
*p = '^';
|
|
memcpy(p + 1, _pat, pat_len + 1);
|
|
pat = p;
|
|
}
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (pat != _pat)
|
|
free((void *)pat);
|
|
|
|
return re;
|
|
}
|
|
pcre *re_get_fullmatch_re(const char *_pat, int opt)
|
|
{
|
|
const char *pat = _pat;
|
|
if (!*pat)
|
|
{
|
|
return NULL;
|
|
}
|
|
int prefix = 0, suffix = 0;
|
|
|
|
if (*pat != '^')
|
|
{
|
|
prefix = 1;
|
|
}
|
|
int pat_len = strlen(_pat);
|
|
if (_pat[pat_len - 1] != '$')
|
|
suffix = 1;
|
|
else
|
|
{
|
|
int n = pat_len - 2;
|
|
int i = 0;
|
|
while (_pat[n] == '\\')
|
|
{
|
|
i++;
|
|
n--;
|
|
}
|
|
if (i % 2)
|
|
{
|
|
suffix = 1;
|
|
}
|
|
}
|
|
int dn = prefix + suffix;
|
|
if (dn)
|
|
{
|
|
char *q = (char *)malloc(pat_len + dn + 1);
|
|
if (!q)
|
|
return NULL;
|
|
pat = q;
|
|
if (prefix)
|
|
{
|
|
*q = '^';
|
|
q++;
|
|
}
|
|
memcpy(q, _pat, pat_len);
|
|
q += pat_len;
|
|
if (suffix)
|
|
{
|
|
*q = '$';
|
|
q++;
|
|
}
|
|
*q = '\0';
|
|
}
|
|
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (pat != _pat)
|
|
free((void *)pat);
|
|
return re;
|
|
}
|
|
|
|
/* the following functions return (a) vector/table in heap, which means it need to be freed after using*/
|
|
|
|
int *pcre_search(const char *pat, const char *s, int len, int *out_vec_number, int opt)
|
|
{
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (!re)
|
|
return NULL;
|
|
int *res = re_search2(re, s, len, out_vec_number, opt);
|
|
pcre_free(re);
|
|
return res;
|
|
}
|
|
int *re_search2(pcre *re, const char *s, int len, int *out_vec_number, int opt)
|
|
{
|
|
int *vec = NULL;
|
|
int group_n = 0;
|
|
int rc;
|
|
int start_offset = 0;
|
|
vec = _re_get_vec_table(re, &group_n);
|
|
if (out_vec_number)
|
|
*out_vec_number = group_n;
|
|
group_n *= 3;
|
|
|
|
if (!vec)
|
|
goto e_er;
|
|
match:
|
|
rc = pcre_exec(re, NULL, s, len, start_offset, 0, vec, group_n);
|
|
if (rc == PCRE_ERROR_NOMATCH)
|
|
{
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
if (rc <= 0)
|
|
goto e_er;
|
|
if (vec[0] == vec[1]) // a empty match
|
|
{
|
|
start_offset++; // advace a position
|
|
if (start_offset >= len)
|
|
goto e_er;
|
|
goto match;
|
|
}
|
|
return vec;
|
|
e_er:
|
|
if (vec)
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
|
|
int **re_searchall(const char *pat, const char *s, int len, int *out_number, int *out_vec_number, int opt)
|
|
{
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (!re)
|
|
return NULL;
|
|
int **res = re_searchall2(re, s, len, out_number, out_vec_number, opt);
|
|
pcre_free(re);
|
|
return res;
|
|
}
|
|
/// @brief find all match in a string
|
|
/// @param re: re pattern
|
|
/// @param s : string searching in
|
|
/// @param out_number : the number of matches
|
|
/// @return a vector table, vrc[n] is the nth matchs,
|
|
/// vrc[group_n][i*2] - vrc[group_n][i*2+1] is the begining-offset and ending-offset of group i.
|
|
/// Use re_free_searchall() to free the memory
|
|
int **re_searchall2(pcre *re, const char *s, int len, int *out_number, int *out_vec_number, int opt)
|
|
{
|
|
int start_offset = 0;
|
|
int **vecs = NULL; // to store vec
|
|
int vec_cap = 4;
|
|
int vec_n = 0;
|
|
int *vec = NULL;
|
|
int group_n = 0;
|
|
|
|
while (1)
|
|
{
|
|
if (group_n)
|
|
vec = (int *)malloc(group_n * sizeof(int));
|
|
else
|
|
{
|
|
vec = _re_get_vec_table(re, &group_n);
|
|
if (out_vec_number)
|
|
*out_vec_number = group_n;
|
|
group_n *= 3;
|
|
}
|
|
if (!vec){
|
|
goto e_er;
|
|
}
|
|
int rc;
|
|
match:
|
|
rc = pcre_exec(re, NULL, s, len, start_offset, 0, vec, group_n);
|
|
if (rc == PCRE_ERROR_NOMATCH)
|
|
{
|
|
if (out_number)
|
|
*out_number = vec_n;
|
|
free(vec);
|
|
return vecs;
|
|
}
|
|
if (rc <= 0)
|
|
goto e_er;
|
|
if (vec[0] == vec[1]) // a empty match
|
|
{
|
|
start_offset++; // advace a position
|
|
if (start_offset >= len)
|
|
goto e_er;
|
|
goto match;
|
|
}
|
|
//to sotre vec
|
|
if (!vecs)
|
|
{
|
|
vecs = (int **)malloc(sizeof(int *) * vec_cap);
|
|
if (!vecs)
|
|
goto e_er;
|
|
}
|
|
|
|
if (vec_n >= vec_cap) // need to recap this list
|
|
{
|
|
vec_cap *= 2;
|
|
void *p = realloc(vecs, vec_cap * sizeof(int *));
|
|
if (!p)
|
|
goto e_er;
|
|
// if (p != vecs) // move data
|
|
// {
|
|
// memmove(p, vecs, vec_n * sizeof(int*));
|
|
vecs = (int **)p;
|
|
// }
|
|
}
|
|
vecs[vec_n++] = vec;
|
|
start_offset = vec[1];
|
|
}
|
|
e_er:
|
|
if (vec)
|
|
free(vec); // the latest vec table
|
|
if (!vecs)
|
|
return NULL;
|
|
for (int j = 0; j < vec_n; j++)
|
|
{
|
|
if (vecs[j])
|
|
free((void *)(vecs[j])); // free vec table
|
|
}
|
|
free(vecs); // free the table list
|
|
return NULL;
|
|
}
|
|
void re_free_searchall(int **vecs, int n)
|
|
{
|
|
if (!vecs)
|
|
return;
|
|
for (int j = 0; j < n; j++)
|
|
{
|
|
if (vecs[j])
|
|
free((void *)(vecs[j])); // free vec table
|
|
}
|
|
free(vecs); // free the table list
|
|
}
|
|
|
|
/* the following functions return (a) string in heap, which means it need to be freed after using*/
|
|
char **_re_extract_substring(const char *s, int **vecs, int n)
|
|
{
|
|
if (!vecs)
|
|
return NULL;
|
|
int c = 0;
|
|
char **res = (char **)pcre_malloc(sizeof(char *) * n);
|
|
if (!res)
|
|
return NULL;
|
|
for (int j = 0; j < n; j++)
|
|
{
|
|
int *v = vecs[j];
|
|
int len = v[1] - v[0];
|
|
char *p = (char *)pcre_malloc(len + 1);
|
|
if (!p)
|
|
goto e_er;
|
|
res[c++] = p;
|
|
memcpy(p, s + v[0], len);
|
|
p[len] = 0;
|
|
}
|
|
return res;
|
|
e_er:
|
|
if (!res)
|
|
return NULL;
|
|
for (int i = 0; i < c; i++)
|
|
{
|
|
free(res[i]);
|
|
}
|
|
free(res);
|
|
return NULL;
|
|
}
|
|
|
|
char *re_find(const char *pat, const char *s, int len, int opt)
|
|
{
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (!re)
|
|
return NULL;
|
|
char *res = re_find2(re, s, len, opt);
|
|
pcre_free(re);
|
|
return res;
|
|
}
|
|
char *re_find2(pcre *re, const char *s, int len, int opt)
|
|
{
|
|
int *vec = NULL;
|
|
int group_n = 0;
|
|
int rc;
|
|
int start_offset = 0;
|
|
char *res_s = NULL;
|
|
vec = _re_get_vec_table(re, &group_n);
|
|
|
|
if (!vec)
|
|
goto e_er;
|
|
group_n *= 3;
|
|
match:
|
|
rc = pcre_exec(re, NULL, s, len, start_offset, 0, vec, group_n);
|
|
if (rc == PCRE_ERROR_NOMATCH)
|
|
{
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
if (rc <= 0)
|
|
goto e_er;
|
|
if (vec[0] == vec[1]) // a empty match
|
|
{
|
|
start_offset++; // advace a position
|
|
if (start_offset >= len)
|
|
goto e_er;
|
|
goto match;
|
|
}
|
|
len = vec[1] - vec[0];
|
|
if (!len)
|
|
goto e_er;
|
|
res_s = (char *)malloc(len + 1);
|
|
if (!res_s)
|
|
goto e_er;
|
|
memcpy(res_s, s + vec[0], len);
|
|
res_s[len] = 0;
|
|
if (vec)
|
|
free(vec);
|
|
return res_s;
|
|
e_er:
|
|
if (vec)
|
|
free(vec);
|
|
return NULL;
|
|
}
|
|
|
|
char **pcre_findall(const char *pat, const char *s, int len, int *out_number, int opt)
|
|
{
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (!re)
|
|
return NULL;
|
|
char **res = re_findall2(re, s, len, out_number, opt);
|
|
pcre_free(re);
|
|
return res;
|
|
}
|
|
char **re_findall2(pcre *re, const char *s, int len, int *out_number, int opt)
|
|
{
|
|
int out_vec_number;
|
|
int **vecs;
|
|
char **res;
|
|
vecs = re_searchall2(re, s, len, out_number, &out_vec_number, opt);
|
|
if (!vecs)
|
|
goto e_er;
|
|
res = _re_extract_substring(s, vecs, *out_number);
|
|
if (!res)
|
|
goto e_er;
|
|
re_free_searchall(vecs, *out_number);
|
|
return res;
|
|
e_er:
|
|
if (vecs)
|
|
re_free_searchall(vecs, *out_number);
|
|
return NULL;
|
|
}
|
|
void re_free_findall(char **ss, int n)
|
|
{
|
|
if (!ss)
|
|
return;
|
|
for (int j = 0; j < n; j++)
|
|
{
|
|
if (ss[j])
|
|
free((void *)(ss[j])); // free vec table
|
|
}
|
|
free(ss); // free the table list
|
|
}
|
|
|
|
char *pcre_sub(const char *pat, const char *to, const char *s, int len, int opt)
|
|
{
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (!re)
|
|
return NULL;
|
|
char *res = re_sub2(re, to, s, len, opt);
|
|
pcre_free(re);
|
|
return res;
|
|
}
|
|
char *pcre_subn(const char *pat, const char *to, const char *s, int len, int n, int opt)
|
|
{
|
|
const char *error;
|
|
int erroffset;
|
|
pcre *re = pcre_compile(pat, opt, &error, &erroffset, NULL);
|
|
if (!re)
|
|
return NULL;
|
|
char *res = re_subn2(re, to, s, len, n, opt);
|
|
pcre_free(re);
|
|
return res;
|
|
}
|
|
/// @brief substitute a string with a pattern expression, given replacement limit
|
|
/// @param re : re pattern for matching
|
|
/// @param to : re pattern to replacement
|
|
/// @param s : string searching in
|
|
/// @param len : length of <s>
|
|
/// @param n : the replacement number
|
|
/// @return if no replacement, return s exactly, otherwise return a new string, free it after using
|
|
char *re_subn2(pcre *re, const char *to, const char *s, int len, int n, int opt)
|
|
{
|
|
int group_n = 0;
|
|
// int group_n2 = 0;
|
|
// int *vec = NULL;
|
|
// int *vec2 = NULL;
|
|
pcre *re2 = NULL;
|
|
int vcs1_n = 0, vcs2_n = 0;
|
|
int **vcs1 = re_searchall2(re, s, len, &vcs1_n, &group_n, opt);
|
|
int **vcs2 = NULL;
|
|
int match_limit = 0;
|
|
if (!vcs1_n)
|
|
{
|
|
//no match, no replacement
|
|
return (char *)s;
|
|
}
|
|
//to determine '\\' and group like: '\group_n'
|
|
//3 groups, 0, 1, 2->\\, 3->\group_n, if any
|
|
const char *p2 = "(\\\\\\\\|\\\\\\d{1,2})";
|
|
int erroffset;
|
|
const char *error;
|
|
int len_to, remain_size, remain_length2, pi = 0, qi = 0;
|
|
char *new_s = NULL;
|
|
|
|
re2 = pcre_compile(p2, 0, &error, &erroffset, NULL);
|
|
if (!re2)
|
|
goto exit_error;
|
|
//match <to>
|
|
len_to = strlen(to);
|
|
vcs2 = re_searchall2(re2, to, len_to, &vcs2_n, NULL, 0);
|
|
//if (!vcs2)
|
|
//{
|
|
// //goto exit_error;
|
|
// vcs2_n = 0;
|
|
//}
|
|
|
|
pcre_free(re2);
|
|
re2 = NULL;
|
|
//note that re2 is no use after this, onece we get vcs2
|
|
remain_length2 = len_to; // the remain length in 'to' exclude from all '\\' and all '\n'
|
|
for (int i = 0; i < vcs2_n; i++)
|
|
{
|
|
int *vc = vcs2[i]; // (0,1)->'\\'or'\n', (2,3)->'\\', (4,5)->'\n', (6,7,8)
|
|
int vc0 = vc[0] + 1;
|
|
if (to[vc0] == '\\')
|
|
{
|
|
vc[2] = 0;
|
|
remain_length2 -= 2;
|
|
}
|
|
else // \n,
|
|
{
|
|
int wanted_number = 0;
|
|
//vc[1]--;
|
|
int l_n = vc[1] - vc0;
|
|
if (l_n == 1)
|
|
{
|
|
wanted_number = to[vc0] - '0';
|
|
remain_length2 -= 2;
|
|
}
|
|
else // if(l_n==2)
|
|
{
|
|
wanted_number = (to[vc0] - '0') * 10 + to[vc0 + 1] - '0';
|
|
remain_length2 -= 3;
|
|
}
|
|
if (wanted_number <= 0 || wanted_number >= group_n)
|
|
goto exit_error;
|
|
//store it in vc[2]
|
|
vc[2] = wanted_number;
|
|
}
|
|
}
|
|
//now that vcs2 stores data of which group is used in replacement
|
|
//Nx9, N is the number of groups used in every one replcaement,
|
|
//while vcs2[2] is the exact group number used in replacement
|
|
|
|
//parse 'to'
|
|
//get the remian size
|
|
match_limit = n ? (n <= vcs1_n ? n : vcs1_n) : vcs1_n;
|
|
remain_size = len + remain_length2 * match_limit;
|
|
//match times
|
|
for (int i = 0; i < match_limit; i++)
|
|
{
|
|
int *vc = vcs1[i];
|
|
//vc[1]-vc[0] is the match sequence which need to be replaced, while the following are groups
|
|
remain_size -= vc[1] - vc[0];
|
|
// the replcaements
|
|
// 'to' e.g.: \\ \1, \2, ....\x
|
|
for (int j = 0; j < vcs2_n; j++)
|
|
{
|
|
int *v2 = vcs2[j];
|
|
if (v2[2])
|
|
{
|
|
//replaced to a group
|
|
remain_size += GetGroupLen(vc, v2[2]);
|
|
}
|
|
else
|
|
{
|
|
//replaced to a '/'
|
|
remain_size++;
|
|
}
|
|
}
|
|
}
|
|
new_s = (char *)malloc(remain_size + 1);
|
|
if (!new_s)
|
|
goto exit_error;
|
|
for (int i = 0; i < match_limit; i++)
|
|
{
|
|
int *vc = vcs1[i];
|
|
memcpy(new_s + pi, s + qi, vc[0] - qi);
|
|
pi += vc[0] - qi;
|
|
int m_start = 0, m_len = 0;
|
|
for (int j = 0; j < vcs2_n; j++)
|
|
{
|
|
int *v2 = vcs2[j];
|
|
m_len = v2[0] - m_start;
|
|
memcpy(new_s + pi, to + m_start, m_len);
|
|
pi += m_len;
|
|
|
|
int to_group = v2[2];
|
|
if (to_group)
|
|
{
|
|
int to_group_at = vc[to_group * 2];
|
|
int to_group_end = vc[to_group * 2 + 1];
|
|
int g_l = to_group_end - to_group_at;
|
|
//replaced to a group
|
|
memcpy(new_s + pi, s + to_group_at, g_l);
|
|
pi += g_l;
|
|
}
|
|
else
|
|
{
|
|
//replaced to a '/'
|
|
new_s[pi++] = '\\';
|
|
}
|
|
m_start = v2[1];
|
|
}
|
|
m_len = len_to - m_start;
|
|
memcpy(new_s + pi, to + m_start, m_len);
|
|
pi += m_len;
|
|
// end of one match
|
|
qi = vc[1];
|
|
}
|
|
if (vcs1)
|
|
re_free_searchall(vcs1, vcs1_n);
|
|
if (vcs2)
|
|
re_free_searchall(vcs2, vcs2_n);
|
|
len -= qi;
|
|
if (len)
|
|
memcpy(new_s + pi, s + qi, len);
|
|
pi += len;
|
|
new_s[pi] = '\0';
|
|
return new_s;
|
|
|
|
exit_error:
|
|
if (vcs1)
|
|
re_free_searchall(vcs1, vcs1_n);
|
|
if (vcs2)
|
|
re_free_searchall(vcs2, vcs2_n);
|
|
if (re2)
|
|
pcre_free(re2);
|
|
return NULL;
|
|
}
|
|
/// @brief substitute a string with a pattern expression
|
|
/// @param re : re pattern for matching
|
|
/// @param to : re pattern to replacement
|
|
/// @param s : string searching in
|
|
/// @param len : length of <s>
|
|
/// @return if no replacement, return s exactly, otherwise return a new string, free it after using
|
|
char *re_sub2(pcre *re, const char *to, const char *s, int len, int opt)
|
|
{
|
|
return re_subn2(re, to, s, len, 0, opt);
|
|
}
|