mirror of
https://projects.vdr-developer.org/git/vdr-plugin-tvguide.git
synced 2023-10-05 13:01:48 +00:00
Some cosmetic changes
This commit is contained in:
kamel5
@@ -22,18 +22,6 @@ cSwitchTimer::cSwitchTimer(const cEvent* Event) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#if VDRVERSNUM >= 20305
|
|
||||||
cSwitchTimer& cSwitchTimer::operator= (const cSwitchTimer &SwitchTimer)
|
|
||||||
{
|
|
||||||
this->eventID = SwitchTimer.eventID;
|
|
||||||
this->startTime = SwitchTimer.startTime;
|
|
||||||
this->channelID = SwitchTimer.channelID;
|
|
||||||
this->switchMinsBefore = SwitchTimer.switchMinsBefore;
|
|
||||||
this->announceOnly = SwitchTimer.announceOnly;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
bool cSwitchTimer::Parse(const char *s) {
|
bool cSwitchTimer::Parse(const char *s) {
|
||||||
char *line;
|
char *line;
|
||||||
char *pos;
|
char *pos;
|
||||||
|
|||||||
@@ -12,7 +12,15 @@ public:
|
|||||||
int announceOnly;
|
int announceOnly;
|
||||||
#if VDRVERSNUM >= 20305
|
#if VDRVERSNUM >= 20305
|
||||||
cSwitchTimer(const cSwitchTimer &SwitchTimer) { *this = SwitchTimer; };
|
cSwitchTimer(const cSwitchTimer &SwitchTimer) { *this = SwitchTimer; };
|
||||||
cSwitchTimer& operator= (const cSwitchTimer &SwitchTimer);
|
cSwitchTimer& operator= (const cSwitchTimer &SwitchTimer)
|
||||||
|
{
|
||||||
|
this->eventID = SwitchTimer.eventID;
|
||||||
|
this->startTime = SwitchTimer.startTime;
|
||||||
|
this->channelID = SwitchTimer.channelID;
|
||||||
|
this->switchMinsBefore = SwitchTimer.switchMinsBefore;
|
||||||
|
this->announceOnly = SwitchTimer.announceOnly;
|
||||||
|
return *this;
|
||||||
|
};
|
||||||
#endif
|
#endif
|
||||||
cSwitchTimer(void);
|
cSwitchTimer(void);
|
||||||
cSwitchTimer(const cEvent* Event);
|
cSwitchTimer(const cEvent* Event);
|
||||||
|
|||||||
@@ -71,7 +71,7 @@ void cTVGuideTimerConflicts::AddConflict(std::string epgSearchConflictLine) {
|
|||||||
splitstring s3(flds2[2].c_str());
|
splitstring s3(flds2[2].c_str());
|
||||||
std::vector<std::string> flds3 = s3.split('#');
|
std::vector<std::string> flds3 = s3.split('#');
|
||||||
std::vector<int> timerIDs;
|
std::vector<int> timerIDs;
|
||||||
for (int k = 0; k < flds3.size(); k++) {
|
for (int k = 0; k < (int)flds3.size(); k++) {
|
||||||
timerIDs.push_back(atoi(flds3[k].c_str()) - 1);
|
timerIDs.push_back(atoi(flds3[k].c_str()) - 1);
|
||||||
}
|
}
|
||||||
conflict->timerIDs = timerIDs;
|
conflict->timerIDs = timerIDs;
|
||||||
@@ -80,18 +80,17 @@ void cTVGuideTimerConflicts::AddConflict(std::string epgSearchConflictLine) {
|
|||||||
|
|
||||||
void cTVGuideTimerConflicts::CalculateConflicts(void) {
|
void cTVGuideTimerConflicts::CalculateConflicts(void) {
|
||||||
numConflicts = conflicts.size();
|
numConflicts = conflicts.size();
|
||||||
// time_t startTime = 0;
|
|
||||||
// time_t endTime = 0;
|
|
||||||
for (int i=0; i < numConflicts; i++) {
|
for (int i=0; i < numConflicts; i++) {
|
||||||
cTimeInterval *unionSet = NULL;
|
cTimeInterval *unionSet = NULL;
|
||||||
int numTimers = conflicts[i]->timerIDs.size();
|
int numTimers = conflicts[i]->timerIDs.size();
|
||||||
for (int j=0; j < numTimers; j++) {
|
|
||||||
#if VDRVERSNUM >= 20301
|
#if VDRVERSNUM >= 20301
|
||||||
LOCK_TIMERS_READ;
|
LOCK_TIMERS_READ;
|
||||||
const cTimer *timer = Timers->Get(conflicts[i]->timerIDs[j]);
|
const cTimers* timers = Timers;
|
||||||
#else
|
#else
|
||||||
const cTimer *timer = Timers.Get(conflicts[i]->timerIDs[j]);
|
const cTimers* timers = &Timers;
|
||||||
#endif
|
#endif
|
||||||
|
for (int j=0; j < numTimers; j++) {
|
||||||
|
const cTimer *timer = timers->Get(conflicts[i]->timerIDs[j]);
|
||||||
if (timer) {
|
if (timer) {
|
||||||
if (!unionSet) {
|
if (!unionSet) {
|
||||||
unionSet = new cTimeInterval(timer->StartTime(), timer->StopTime());
|
unionSet = new cTimeInterval(timer->StartTime(), timer->StopTime());
|
||||||
@@ -110,12 +109,7 @@ void cTVGuideTimerConflicts::CalculateConflicts(void) {
|
|||||||
|
|
||||||
cTimeInterval *intersect = NULL;
|
cTimeInterval *intersect = NULL;
|
||||||
for (int j=0; j < numTimers; j++) {
|
for (int j=0; j < numTimers; j++) {
|
||||||
#if VDRVERSNUM >= 20301
|
const cTimer *timer = timers->Get(conflicts[i]->timerIDs[j]);
|
||||||
LOCK_TIMERS_READ;
|
|
||||||
const cTimer *timer = Timers->Get(conflicts[i]->timerIDs[j]);
|
|
||||||
#else
|
|
||||||
const cTimer *timer = Timers.Get(conflicts[i]->timerIDs[j]);
|
|
||||||
#endif
|
|
||||||
if (timer) {
|
if (timer) {
|
||||||
if (!intersect) {
|
if (!intersect) {
|
||||||
intersect = new cTimeInterval(timer->StartTime(), timer->StopTime());
|
intersect = new cTimeInterval(timer->StartTime(), timer->StopTime());
|
||||||
|
|||||||
426
tools.c
426
tools.c
@@ -144,7 +144,7 @@ std::vector<std::string>& splitstring::split(char delim, int rep) {
|
|||||||
std::string work = data();
|
std::string work = data();
|
||||||
std::string buf = "";
|
std::string buf = "";
|
||||||
int i = 0;
|
int i = 0;
|
||||||
while (i < work.length()) {
|
while (i < (int)work.length()) {
|
||||||
if (work[i] != delim)
|
if (work[i] != delim)
|
||||||
buf += work[i];
|
buf += work[i];
|
||||||
else if (rep == 1) {
|
else if (rep == 1) {
|
||||||
@@ -179,61 +179,61 @@ int FindIgnoreCase(const std::string& expr, const std::string& query)
|
|||||||
* GetAuxValue
|
* GetAuxValue
|
||||||
****************************************************************************************/
|
****************************************************************************************/
|
||||||
char* GetAuxValue(const char* aux, const char* name) {
|
char* GetAuxValue(const char* aux, const char* name) {
|
||||||
if (isempty(aux))
|
if (isempty(aux))
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
||||||
char* descr = strdup(aux);
|
char* descr = strdup(aux);
|
||||||
char* beginaux = strstr(descr, "<epgsearch>");
|
char* beginaux = strstr(descr, "<epgsearch>");
|
||||||
char* endaux = strstr(descr, "</epgsearch>");
|
char* endaux = strstr(descr, "</epgsearch>");
|
||||||
if (!beginaux || !endaux) {
|
if (!beginaux || !endaux) {
|
||||||
free(descr);
|
free(descr);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
beginaux += 11; // strlen("<epgsearch>");
|
beginaux += 11; // strlen("<epgsearch>");
|
||||||
endaux[0] = 0;
|
endaux[0] = 0;
|
||||||
memmove(descr, beginaux, endaux - beginaux + 1);
|
memmove(descr, beginaux, endaux - beginaux + 1);
|
||||||
|
|
||||||
if (strcmp(name, "epgsearch") == 0)
|
if (strcmp(name, "epgsearch") == 0)
|
||||||
return descr; // full aux
|
return descr; // full aux
|
||||||
|
|
||||||
int namelen = strlen(name);
|
int namelen = strlen(name);
|
||||||
char catname[100] = "";
|
char catname[100] = "";
|
||||||
catname[0] = '<';
|
catname[0] = '<';
|
||||||
memcpy(catname + 1, name, namelen);
|
memcpy(catname + 1, name, namelen);
|
||||||
catname[1 + namelen] = '>';
|
catname[1 + namelen] = '>';
|
||||||
catname[2 + namelen] = 0;
|
catname[2 + namelen] = 0;
|
||||||
|
|
||||||
char* cat = strcasestr(descr, catname);
|
char* cat = strcasestr(descr, catname);
|
||||||
if (!cat) {
|
if (!cat) {
|
||||||
free(descr);
|
free(descr);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
cat += namelen + 2;
|
cat += namelen + 2;
|
||||||
char* end = strstr(cat, "</");
|
char* end = strstr(cat, "</");
|
||||||
if (!end) {
|
if (!end) {
|
||||||
free(descr);
|
free(descr);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
end[0] = 0;
|
end[0] = 0;
|
||||||
|
|
||||||
int catlen = end - cat + 1;
|
int catlen = end - cat + 1;
|
||||||
char* value = (char *) malloc(catlen);
|
char* value = (char *) malloc(catlen);
|
||||||
memcpy(value, cat, catlen);
|
memcpy(value, cat, catlen);
|
||||||
|
|
||||||
free(descr);
|
free(descr);
|
||||||
return value;
|
return value;
|
||||||
}
|
}
|
||||||
|
|
||||||
char* GetAuxValue(const cRecording *recording, const char* name) {
|
char* GetAuxValue(const cRecording *recording, const char* name) {
|
||||||
if (!recording || !recording->Info())
|
if (!recording || !recording->Info())
|
||||||
return NULL;
|
return NULL;
|
||||||
return GetAuxValue(recording->Info()->Aux(), name);
|
return GetAuxValue(recording->Info()->Aux(), name);
|
||||||
}
|
}
|
||||||
|
|
||||||
char* GetAuxValue(const cTimer *timer, const char* name) {
|
char* GetAuxValue(const cTimer *timer, const char* name) {
|
||||||
if (!timer || !timer->Aux())
|
if (!timer || !timer->Aux())
|
||||||
return NULL;
|
return NULL;
|
||||||
return GetAuxValue(timer->Aux(), name);
|
return GetAuxValue(timer->Aux(), name);
|
||||||
}
|
}
|
||||||
@@ -244,239 +244,239 @@ char* GetAuxValue(const cTimer *timer, const char* name) {
|
|||||||
|
|
||||||
/******************************************************************************
|
/******************************************************************************
|
||||||
FUNCTION afuzzy_init()
|
FUNCTION afuzzy_init()
|
||||||
Initialization of the fuzzy search routine. This applies to the consequent
|
Initialization of the fuzzy search routine. This applies to the consequent
|
||||||
calls of the afuzzy_CheckRTR (whole string matching) and afuzzy_CheckSUB
|
calls of the afuzzy_CheckRTR (whole string matching) and afuzzy_CheckSUB
|
||||||
(substring match) routines. afuzzy_init() should be called for each
|
(substring match) routines. afuzzy_init() should be called for each
|
||||||
new pattern or error length. The search is case sensitive
|
new pattern or error length. The search is case sensitive
|
||||||
|
|
||||||
ARGUMENTS:
|
ARGUMENTS:
|
||||||
p Pattern
|
p Pattern
|
||||||
kerr Number of possible errors. Shouldn't exceed pattern length
|
kerr Number of possible errors. Shouldn't exceed pattern length
|
||||||
UseFilter Use agrep filter algorithm that speeds up search.
|
UseFilter Use agrep filter algorithm that speeds up search.
|
||||||
fuzzy pointer to the structure that will be later passes to Check*
|
fuzzy pointer to the structure that will be later passes to Check*
|
||||||
(the first 6 elements should be NULLs for the first call)
|
(the first 6 elements should be NULLs for the first call)
|
||||||
|
|
||||||
RETURN VALUE:
|
RETURN VALUE:
|
||||||
none
|
none
|
||||||
|
|
||||||
ALGORITHM
|
ALGORITHM
|
||||||
see. the article on agrep algorithms.
|
see. the article on agrep algorithms.
|
||||||
The only change is accounting transpositions as one edit operation .
|
The only change is accounting transpositions as one edit operation .
|
||||||
******************************************************************************/
|
******************************************************************************/
|
||||||
void afuzzy_init(const char *p, int kerr, int UseFilter, AFUZZY *fuzzy)
|
void afuzzy_init(const char *p, int kerr, int UseFilter, AFUZZY *fuzzy)
|
||||||
{
|
{
|
||||||
int cnt, p_len, i, j, l, d, m, dd;
|
int cnt, p_len, i, j, l, d, m, dd;
|
||||||
char PatFilter[sizeof(Uint)*8 + 1];
|
char PatFilter[sizeof(Uint)*8 + 1];
|
||||||
|
|
||||||
fuzzy->k = kerr;
|
fuzzy->k = kerr;
|
||||||
m = strlen(p);
|
m = strlen(p);
|
||||||
fuzzy->FilterSet = 0;
|
fuzzy->FilterSet = 0;
|
||||||
memset(fuzzy->Map, 0 , sizeof(fuzzy->Map) );
|
memset(fuzzy->Map, 0 , sizeof(fuzzy->Map) );
|
||||||
|
|
||||||
if (fuzzy->S)
|
if (fuzzy->S)
|
||||||
free(fuzzy->S);
|
free(fuzzy->S);
|
||||||
if (fuzzy->R)
|
if (fuzzy->R)
|
||||||
free(fuzzy->R);
|
free(fuzzy->R);
|
||||||
if (fuzzy->R1)
|
if (fuzzy->R1)
|
||||||
free(fuzzy->R1);
|
free(fuzzy->R1);
|
||||||
if (fuzzy->RP)
|
if (fuzzy->RP)
|
||||||
free(fuzzy->RP);
|
free(fuzzy->RP);
|
||||||
if (fuzzy->RI)
|
if (fuzzy->RI)
|
||||||
free(fuzzy->RI);
|
free(fuzzy->RI);
|
||||||
if (fuzzy->FilterS)
|
if (fuzzy->FilterS)
|
||||||
free(fuzzy->FilterS);
|
free(fuzzy->FilterS);
|
||||||
|
|
||||||
fuzzy->FilterS = NULL;
|
fuzzy->FilterS = NULL;
|
||||||
fuzzy->S = (Uint *)calloc(m + 1, sizeof(Uint));
|
fuzzy->S = (Uint *)calloc(m + 1, sizeof(Uint));
|
||||||
fuzzy->R = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
fuzzy->R = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
||||||
fuzzy->R1 = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
fuzzy->R1 = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
||||||
fuzzy->RI = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
fuzzy->RI = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
||||||
fuzzy->RP = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
fuzzy->RP = (Uint *)calloc(fuzzy->k + 1, sizeof(Uint));
|
||||||
|
|
||||||
for (i = 0, cnt = 0; i < m; i++)
|
for (i = 0, cnt = 0; i < m; i++)
|
||||||
{
|
{
|
||||||
l = fuzzy->Map[(unsigned char)p[i]];
|
l = fuzzy->Map[(unsigned char)p[i]];
|
||||||
if (!l)
|
if (!l)
|
||||||
{
|
{
|
||||||
l = fuzzy->Map[(unsigned char)p[i]] = ++cnt;
|
l = fuzzy->Map[(unsigned char)p[i]] = ++cnt;
|
||||||
fuzzy->S[l] = 0;
|
fuzzy->S[l] = 0;
|
||||||
}
|
}
|
||||||
fuzzy->S[l] |= 1 << i;
|
fuzzy->S[l] |= 1 << i;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
for (d = 0; d <= fuzzy->k; d++)
|
for (d = 0; d <= fuzzy->k; d++)
|
||||||
fuzzy->RI[d] = (1 << d) - 1;
|
fuzzy->RI[d] = (1 << d) - 1;
|
||||||
|
|
||||||
fuzzy->mask_ok = (1 << (m - 1));
|
fuzzy->mask_ok = (1 << (m - 1));
|
||||||
fuzzy->r_size = sizeof(Uint) * (fuzzy->k + 1);
|
fuzzy->r_size = sizeof(Uint) * (fuzzy->k + 1);
|
||||||
p_len = m;
|
p_len = m;
|
||||||
|
|
||||||
if (p_len > (int) sizeof(Uint)*8)
|
if (p_len > (int) sizeof(Uint)*8)
|
||||||
p_len = (int) sizeof(Uint)*8;
|
p_len = (int) sizeof(Uint)*8;
|
||||||
|
|
||||||
/* If k is zero then no filter is needed! */
|
/* If k is zero then no filter is needed! */
|
||||||
if (fuzzy->k && (p_len >= 2*(fuzzy->k + 1)) )
|
if (fuzzy->k && (p_len >= 2*(fuzzy->k + 1)) )
|
||||||
{
|
{
|
||||||
if (UseFilter)
|
if (UseFilter)
|
||||||
{
|
{
|
||||||
fuzzy->FilterSet = 1;
|
fuzzy->FilterSet = 1;
|
||||||
memset(fuzzy->FilterMap, 0 , sizeof(fuzzy->FilterMap) );
|
memset(fuzzy->FilterMap, 0 , sizeof(fuzzy->FilterMap) );
|
||||||
fuzzy->FilterS = (Uint *)calloc(m + 1, sizeof(Uint));
|
fuzzy->FilterS = (Uint *)calloc(m + 1, sizeof(Uint));
|
||||||
|
|
||||||
/* Not let's fill the interleaved pattern */
|
/* Not let's fill the interleaved pattern */
|
||||||
dd = p_len / (fuzzy->k + 1);
|
dd = p_len / (fuzzy->k + 1);
|
||||||
p_len = dd * (fuzzy->k + 1);
|
p_len = dd * (fuzzy->k + 1);
|
||||||
|
|
||||||
for (i = 0, cnt = 0; i < dd; i++)
|
for (i = 0, cnt = 0; i < dd; i++)
|
||||||
for (j = 0; j < fuzzy->k + 1; j++, cnt++)
|
for (j = 0; j < fuzzy->k + 1; j++, cnt++)
|
||||||
PatFilter[cnt] = (unsigned char)p[j*dd + i];
|
PatFilter[cnt] = (unsigned char)p[j*dd + i];
|
||||||
PatFilter[p_len] = 0;
|
PatFilter[p_len] = 0;
|
||||||
|
|
||||||
for (i = 0, cnt = 0; i < p_len; i++)
|
for (i = 0, cnt = 0; i < p_len; i++)
|
||||||
{
|
{
|
||||||
l = fuzzy->FilterMap[(unsigned char)PatFilter[i]];
|
l = fuzzy->FilterMap[(unsigned char)PatFilter[i]];
|
||||||
if (!l)
|
if (!l)
|
||||||
{
|
{
|
||||||
l = fuzzy->FilterMap[(unsigned char)PatFilter[i]] = ++cnt;
|
l = fuzzy->FilterMap[(unsigned char)PatFilter[i]] = ++cnt;
|
||||||
fuzzy->FilterS[l] = 0;
|
fuzzy->FilterS[l] = 0;
|
||||||
}
|
}
|
||||||
fuzzy->FilterS[l] |= 1 << i;
|
fuzzy->FilterS[l] |= 1 << i;
|
||||||
}
|
}
|
||||||
fuzzy->filter_ok = 0;
|
fuzzy->filter_ok = 0;
|
||||||
for (i = p_len - fuzzy->k - 1; i <= p_len - 1; i++) /* k+1 times */
|
for (i = p_len - fuzzy->k - 1; i <= p_len - 1; i++) /* k+1 times */
|
||||||
fuzzy->filter_ok |= 1 << i;
|
fuzzy->filter_ok |= 1 << i;
|
||||||
|
|
||||||
/* k+1 first bits set to 1 */
|
/* k+1 first bits set to 1 */
|
||||||
fuzzy->filter_shift = (1 << (fuzzy->k + 2)) - 1;
|
fuzzy->filter_shift = (1 << (fuzzy->k + 2)) - 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/******************************************************************************
|
/******************************************************************************
|
||||||
FUNCTION afuzzy_free()
|
FUNCTION afuzzy_free()
|
||||||
Cleaning up after previous afuzzy_init() call.
|
Cleaning up after previous afuzzy_init() call.
|
||||||
|
|
||||||
ARGUMENTS:
|
ARGUMENTS:
|
||||||
fuzzy pointer to the afuzzy parameters structure
|
fuzzy pointer to the afuzzy parameters structure
|
||||||
|
|
||||||
RETURN VALUE:
|
RETURN VALUE:
|
||||||
none
|
none
|
||||||
******************************************************************************/
|
******************************************************************************/
|
||||||
void afuzzy_free(AFUZZY *fuzzy)
|
void afuzzy_free(AFUZZY *fuzzy)
|
||||||
{
|
{
|
||||||
if (fuzzy->S)
|
if (fuzzy->S)
|
||||||
{
|
{
|
||||||
free(fuzzy->S);
|
free(fuzzy->S);
|
||||||
fuzzy->S = NULL;
|
fuzzy->S = NULL;
|
||||||
}
|
}
|
||||||
if (fuzzy->R)
|
if (fuzzy->R)
|
||||||
{
|
{
|
||||||
free(fuzzy->R);
|
free(fuzzy->R);
|
||||||
fuzzy->R = NULL;
|
fuzzy->R = NULL;
|
||||||
}
|
}
|
||||||
if (fuzzy->R1)
|
if (fuzzy->R1)
|
||||||
{
|
{
|
||||||
free(fuzzy->R1);
|
free(fuzzy->R1);
|
||||||
fuzzy->R1 = NULL;
|
fuzzy->R1 = NULL;
|
||||||
}
|
}
|
||||||
if (fuzzy->RP)
|
if (fuzzy->RP)
|
||||||
{
|
{
|
||||||
free(fuzzy->RP);
|
free(fuzzy->RP);
|
||||||
fuzzy->RP = NULL;
|
fuzzy->RP = NULL;
|
||||||
}
|
}
|
||||||
if (fuzzy->RI)
|
if (fuzzy->RI)
|
||||||
{
|
{
|
||||||
free(fuzzy->RI);
|
free(fuzzy->RI);
|
||||||
fuzzy->RI = NULL;
|
fuzzy->RI = NULL;
|
||||||
}
|
}
|
||||||
if (fuzzy->FilterS)
|
if (fuzzy->FilterS)
|
||||||
{
|
{
|
||||||
free(fuzzy->FilterS);
|
free(fuzzy->FilterS);
|
||||||
fuzzy->FilterS = NULL;
|
fuzzy->FilterS = NULL;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/******************************************************************************
|
/******************************************************************************
|
||||||
FUNCTION afuzzy_CheckSUB()
|
FUNCTION afuzzy_CheckSUB()
|
||||||
Perform a fuzzy pattern substring matching. afuzzy_init() should be
|
Perform a fuzzy pattern substring matching. afuzzy_init() should be
|
||||||
called previously to initialize the pattern and error length.
|
called previously to initialize the pattern and error length.
|
||||||
Positive result means that some part of the string given matches the
|
Positive result means that some part of the string given matches the
|
||||||
pattern with no more than afuzzy->k errors (1 error = 1 letter
|
pattern with no more than afuzzy->k errors (1 error = 1 letter
|
||||||
replacement or transposition)
|
replacement or transposition)
|
||||||
|
|
||||||
ARGUMENTS:
|
ARGUMENTS:
|
||||||
t the string to test
|
t the string to test
|
||||||
fuzzy pointer to the afuzzy parameters structure
|
fuzzy pointer to the afuzzy parameters structure
|
||||||
|
|
||||||
RETURN VALUE:
|
RETURN VALUE:
|
||||||
0 - no match
|
0 - no match
|
||||||
> 0 - strings match
|
> 0 - strings match
|
||||||
|
|
||||||
ALGORITHM
|
ALGORITHM
|
||||||
????????????????
|
????????????????
|
||||||
******************************************************************************/
|
******************************************************************************/
|
||||||
int afuzzy_checkSUB(const char *t, AFUZZY *fuzzy)
|
int afuzzy_checkSUB(const char *t, AFUZZY *fuzzy)
|
||||||
{
|
{
|
||||||
register char c;
|
register char c;
|
||||||
register int j, d;
|
register int j, d;
|
||||||
|
|
||||||
/* For eficciency this case should be little bit optimized */
|
/* For eficciency this case should be little bit optimized */
|
||||||
if (!fuzzy->k)
|
if (!fuzzy->k)
|
||||||
{
|
{
|
||||||
Uint R = 0, R1;
|
Uint R = 0, R1;
|
||||||
|
|
||||||
for (j = 0; (c = t[j]) != '\0'; j++)
|
for (j = 0; (c = t[j]) != '\0'; j++)
|
||||||
{
|
{
|
||||||
R1 = ( ((R<<1) | 1) & fuzzy->S[fuzzy->Map[(unsigned char)c]]);
|
R1 = ( ((R<<1) | 1) & fuzzy->S[fuzzy->Map[(unsigned char)c]]);
|
||||||
R = R1;
|
R = R1;
|
||||||
|
|
||||||
if (R1 & fuzzy->mask_ok)
|
if (R1 & fuzzy->mask_ok)
|
||||||
return 1;
|
return 1;
|
||||||
} /* end for (register int j = 0 ... */
|
} /* end for (register int j = 0 ... */
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (fuzzy->FilterSet && !afuzzy_checkFLT(t, fuzzy))
|
if (fuzzy->FilterSet && !afuzzy_checkFLT(t, fuzzy))
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
memcpy(fuzzy->R, fuzzy->RI, fuzzy->r_size); /* R = RI */
|
memcpy(fuzzy->R, fuzzy->RI, fuzzy->r_size); /* R = RI */
|
||||||
|
|
||||||
for (j = 0; (c = t[j]); j++)
|
for (j = 0; (c = t[j]); j++)
|
||||||
{
|
{
|
||||||
for (d = 0; d <= fuzzy->k; d++)
|
for (d = 0; d <= fuzzy->k; d++)
|
||||||
{
|
{
|
||||||
fuzzy->R1[d] = (((fuzzy->R[d]<<1) | 1) &
|
fuzzy->R1[d] = (((fuzzy->R[d]<<1) | 1) &
|
||||||
fuzzy->S[fuzzy->Map[(unsigned char)c]]);
|
fuzzy->S[fuzzy->Map[(unsigned char)c]]);
|
||||||
if (d > 0)
|
if (d > 0)
|
||||||
fuzzy->R1[d] |= ((fuzzy->R[d-1] | fuzzy->R1[d-1])<<1) | 1 |
|
fuzzy->R1[d] |= ((fuzzy->R[d-1] | fuzzy->R1[d-1])<<1) | 1 |
|
||||||
fuzzy->R[d-1];
|
fuzzy->R[d-1];
|
||||||
}
|
}
|
||||||
if (fuzzy->R1[fuzzy->k] & fuzzy->mask_ok)
|
if (fuzzy->R1[fuzzy->k] & fuzzy->mask_ok)
|
||||||
return j;
|
return j;
|
||||||
|
|
||||||
memcpy(fuzzy->R, fuzzy->R1, fuzzy->r_size);
|
memcpy(fuzzy->R, fuzzy->R1, fuzzy->r_size);
|
||||||
|
|
||||||
} /* end for (register int j = 0 ... */
|
} /* end for (register int j = 0 ... */
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int afuzzy_checkFLT(const char *t, AFUZZY *fuzzy)
|
int afuzzy_checkFLT(const char *t, AFUZZY *fuzzy)
|
||||||
{
|
{
|
||||||
register Uint FilterR = 0;
|
register Uint FilterR = 0;
|
||||||
register Uint FilterR1;
|
register Uint FilterR1;
|
||||||
register int j;
|
register int j;
|
||||||
|
|
||||||
for (j = 0; t[j] != '\0'; j++)
|
for (j = 0; t[j] != '\0'; j++)
|
||||||
{
|
{
|
||||||
FilterR1 = ( ((FilterR<<(fuzzy->k+1)) | fuzzy->filter_shift) &
|
FilterR1 = ( ((FilterR<<(fuzzy->k+1)) | fuzzy->filter_shift) &
|
||||||
fuzzy->FilterS[fuzzy->FilterMap[(unsigned char)t[j]]]);
|
fuzzy->FilterS[fuzzy->FilterMap[(unsigned char)t[j]]]);
|
||||||
if (FilterR1 & fuzzy->filter_ok)
|
if (FilterR1 & fuzzy->filter_ok)
|
||||||
return 1;
|
return 1;
|
||||||
FilterR = FilterR1;
|
FilterR = FilterR1;
|
||||||
} /* end for (register int j = 0 ... */
|
} /* end for (register int j = 0 ... */
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|||||||
28
tools.h
28
tools.h
@@ -45,21 +45,21 @@ typedef unsigned int Uint;
|
|||||||
|
|
||||||
typedef struct
|
typedef struct
|
||||||
{
|
{
|
||||||
Uint *R,
|
Uint *R,
|
||||||
*R1,
|
*R1,
|
||||||
*RP,
|
*RP,
|
||||||
*S,
|
*S,
|
||||||
*RI;
|
*RI;
|
||||||
Uint *FilterS;
|
Uint *FilterS;
|
||||||
|
|
||||||
int Map[256];
|
int Map[256];
|
||||||
int FilterMap[256];
|
int FilterMap[256];
|
||||||
int k;
|
int k;
|
||||||
Uint mask_ok;
|
Uint mask_ok;
|
||||||
Uint filter_ok;
|
Uint filter_ok;
|
||||||
Uint filter_shift;
|
Uint filter_shift;
|
||||||
int r_size;
|
int r_size;
|
||||||
int FilterSet;
|
int FilterSet;
|
||||||
} AFUZZY;
|
} AFUZZY;
|
||||||
|
|
||||||
void afuzzy_init(const char *p, int kerr, int UseFilter, AFUZZY *fuzzy);
|
void afuzzy_init(const char *p, int kerr, int UseFilter, AFUZZY *fuzzy);
|
||||||
|
|||||||
Reference in New Issue
Block a user