自学教程：C++ FullTextMatch函数代码示例

int MatchInAlphaList(AlphaList *al, char *string){    Item *ip;    int i = (int) *string;    if (isalnum(i) || *string == '_')    {        for (ip = al->list[i]; ip != NULL; ip = ip->next)        {            if (FullTextMatch(string, ip->name))            {                return true;            }        }    }    else    {        // We don't know what the correct hash is because the pattern in vague        for (i = 0; i < CF_ALPHABETSIZE; i++)        {            for (ip = al->list[i]; ip != NULL; ip = ip->next)            {                if (FullTextMatch(string, ip->name))                {                    return true;                }            }        }    }    return false;}

void DefaultVarPromise(Promise *pp){    char *regex = GetConstraintValue("if_match_regex", pp, CF_SCALAR);    Rval rval;    enum cfdatatype dt;    Rlist *rp;    bool okay = true;    dt = GetVariable("this", pp->promiser, &rval);    switch (dt)    {    case cf_str:    case cf_int:    case cf_real:        if (regex && !FullTextMatch(regex,rval.item))        {            return;        }        if (regex == NULL)        {            return;        }        break;    case cf_slist:    case cf_ilist:    case cf_rlist:        if (regex)        {            for (rp = (Rlist *) rval.item; rp != NULL; rp = rp->next)            {                if (FullTextMatch(regex,rp->item))                {                    okay = false;                    break;                }            }            if (okay)            {                return;            }        }        break;    default:        break;    }    DeleteScalar(pp->bundle, pp->promiser);    ConvergeVarHashPromise(pp->bundle, pp, true);}

static int SelectOwnerMatch(char *path, struct stat *lstatptr, Rlist *crit){    AlphaList leafattrib;    Rlist *rp;    char ownerName[CF_BUFSIZE];    int gotOwner;    InitAlphaList(&leafattrib);#ifndef MINGW                   // no uids on Windows    char buffer[CF_SMALLBUF];    sprintf(buffer, "%jd", (uintmax_t) lstatptr->st_uid);    PrependAlphaList(&leafattrib, buffer);#endif /* MINGW */    gotOwner = GetOwnerName(path, lstatptr, ownerName, sizeof(ownerName));    if (gotOwner)    {        PrependAlphaList(&leafattrib, ownerName);    }    else    {        PrependAlphaList(&leafattrib, "none");    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, &leafattrib))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }        if (gotOwner && FullTextMatch((char *) rp->item, ownerName))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }#ifndef MINGW        if (FullTextMatch((char *) rp->item, buffer))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }#endif /* NOT MINGW */    }    DeleteAlphaList(&leafattrib);    return false;}

static int SelectOwnerMatch(EvalContext *ctx, char *path, struct stat *lstatptr, Rlist *crit){    Rlist *rp;    char ownerName[CF_BUFSIZE];    int gotOwner;    StringSet *leafattrib = StringSetNew();#ifndef __MINGW32__                   // no uids on Windows    char buffer[CF_SMALLBUF];    snprintf(buffer, CF_SMALLBUF, "%jd", (uintmax_t) lstatptr->st_uid);    StringSetAdd(leafattrib, xstrdup(buffer));#endif /* __MINGW32__ */    gotOwner = GetOwnerName(path, lstatptr, ownerName, sizeof(ownerName));    if (gotOwner)    {        StringSetAdd(leafattrib, xstrdup(ownerName));    }    else    {        StringSetAdd(leafattrib, xstrdup("none"));    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, leafattrib))        {            Log(LOG_LEVEL_DEBUG, "Select owner match");            StringSetDestroy(leafattrib);            return true;        }        if (gotOwner && (FullTextMatch(ctx, RlistScalarValue(rp), ownerName)))        {            Log(LOG_LEVEL_DEBUG, "Select owner match");            StringSetDestroy(leafattrib);            return true;        }#ifndef __MINGW32__        if (FullTextMatch(ctx, RlistScalarValue(rp), buffer))        {            Log(LOG_LEVEL_DEBUG, "Select owner match");            StringSetDestroy(leafattrib);            return true;        }#endif /* !__MINGW32__ */    }    StringSetDestroy(leafattrib);    return false;}

static int SelectGroupMatch(struct stat *lstatptr, Rlist *crit){    AlphaList leafattrib;    char buffer[CF_SMALLBUF];    struct group *gr;    Rlist *rp;    InitAlphaList(&leafattrib);    sprintf(buffer, "%jd", (uintmax_t) lstatptr->st_gid);    PrependAlphaList(&leafattrib, buffer);    if ((gr = getgrgid(lstatptr->st_gid)) != NULL)    {        PrependAlphaList(&leafattrib, gr->gr_name);    }    else    {        PrependAlphaList(&leafattrib, "none");    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, &leafattrib))        {            CfDebug(" - ? Select group match/n");            DeleteAlphaList(&leafattrib);            return true;        }        if (gr && FullTextMatch((char *) rp->item, gr->gr_name))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }        if (FullTextMatch((char *) rp->item, buffer))        {            CfDebug(" - ? Select owner match/n");            DeleteAlphaList(&leafattrib);            return true;        }    }    DeleteAlphaList(&leafattrib);    return false;}

static int SelectIsSymLinkTo(char *filename,struct Rlist *crit){#ifndef MINGW  char buffer[CF_BUFSIZE];  struct Rlist *rp;for (rp = crit; rp != NULL; rp = rp->next)   {   memset(buffer,0,CF_BUFSIZE);      if (readlink(filename,buffer,CF_BUFSIZE-1) == -1)      {      CfOut(cf_error,"readlink","Unable to read link %s in filter",filename);      return false;            }   if (FullTextMatch(rp->item,buffer))      {      return true;      }   }#endif  /* NOT MINGW */return false;      }

int CheckParseClass(char *lval, char *s, const char *range){    char output[CF_BUFSIZE];    if (s == NULL)    {        return false;    }    CfDebug("/nCheckParseClass(%s => %s/%s)/n", lval, s, range);    if (strlen(range) == 0)    {        return true;    }    if (FullTextMatch(range, s))    {        return true;    }    snprintf(output, CF_BUFSIZE, "Class item on rhs of lval /'%s/' given as { %s } is out of bounds (should match %s)",             lval, s, range);    ReportError(output);    return false;}

int IsMatchItemIn(EvalContext *ctx, Item *list, const char *item)/* Solve for possible regex/fuzzy models unified */{    Item *ptr;    if ((item == NULL) || (strlen(item) == 0))    {        return true;    }    for (ptr = list; ptr != NULL; ptr = ptr->next)    {        if (FuzzySetMatch(ptr->name, item) == 0)        {            return (true);        }        if (IsRegex(ptr->name))        {            if (FullTextMatch(ctx, ptr->name, item))            {                return (true);            }        }    }    return (false);}

int SelectLastItemMatching(EvalContext *ctx, const char *regexp, Item *begin, Item *end, Item **match, Item **prev){    Item *ip, *ip_last = NULL, *ip_prev = CF_UNDEFINED_ITEM;    *match = CF_UNDEFINED_ITEM;    *prev = CF_UNDEFINED_ITEM;    for (ip = begin; ip != end; ip = ip->next)    {        if (ip->name == NULL)        {            continue;        }        if (FullTextMatch(ctx, regexp, ip->name))        {            *prev = ip_prev;            ip_last = ip;        }        ip_prev = ip;    }    if (ip_last)    {        *match = ip_last;        return true;    }    return false;}

int SelectNextItemMatching(const char *regexp, Item *begin, Item *end, Item **match, Item **prev){    Item *ip_prev = CF_UNDEFINED_ITEM;    *match = CF_UNDEFINED_ITEM;    *prev = CF_UNDEFINED_ITEM;    for (Item *ip = begin; ip != end; ip = ip->next)    {        if (ip->name == NULL)        {            continue;        }        if (FullTextMatch(regexp, ip->name))        {            *match = ip;            *prev = ip_prev;            return true;        }        ip_prev = ip;    }    return false;}

static int SelectExecRegexMatch(char *filename, char *crit, char *prog){    char line[CF_BUFSIZE];    FILE *pp;    char buf[CF_MAXVARSIZE];// insert real value of $(this.promiser) in command    ReplaceStr(prog, buf, sizeof(buf), "$(this.promiser)", filename);    ReplaceStr(prog, buf, sizeof(buf), "${this.promiser}", filename);    if ((pp = cf_popen(buf, "r")) == NULL)    {        CfOut(cf_error, "cf_popen", "Couldn't open pipe to command %s/n", buf);        return false;    }    while (!feof(pp))    {        line[0] = '/0';        CfReadLine(line, CF_BUFSIZE, pp);       /* One buffer only */        if (FullTextMatch(crit, line))        {            cf_pclose(pp);            return true;        }    }    cf_pclose(pp);    return false;}

static int SelectGroupMatch(EvalContext *ctx, struct stat *lstatptr, Rlist *crit){    char buffer[CF_SMALLBUF];    struct group *gr;    Rlist *rp;    StringSet *leafattrib = StringSetNew();    snprintf(buffer, CF_SMALLBUF, "%jd", (uintmax_t) lstatptr->st_gid);    StringSetAdd(leafattrib, xstrdup(buffer));    if ((gr = getgrgid(lstatptr->st_gid)) != NULL)    {        StringSetAdd(leafattrib, xstrdup(gr->gr_name));    }    else    {        StringSetAdd(leafattrib, xstrdup("none"));    }    for (rp = crit; rp != NULL; rp = rp->next)    {        if (EvalFileResult((char *) rp->item, leafattrib))        {            Log(LOG_LEVEL_DEBUG, "Select group match");            StringSetDestroy(leafattrib);            return true;        }        if (gr && (FullTextMatch(ctx, (char *) rp->item, gr->gr_name)))        {            Log(LOG_LEVEL_DEBUG, "Select group match");            StringSetDestroy(leafattrib);            return true;        }        if (FullTextMatch(ctx, (char *) rp->item, buffer))        {            Log(LOG_LEVEL_DEBUG, "Select group match");            StringSetDestroy(leafattrib);            return true;        }    }    StringSetDestroy(leafattrib);    return false;}

int MatchRegion(EvalContext *ctx, const char *chunk, const Item *begin, const Item *end, bool regex)/*  Match a region in between the selection delimiters. It is  called after SelectRegion. The end delimiter will be visible  here so we have to check for it. Can handle multi-line chunks*/{    const Item *ip = begin;    char buf[CF_BUFSIZE];    int lines = 0;    for (const char *sp = chunk; sp <= chunk + strlen(chunk); sp++)    {        memset(buf, 0, CF_BUFSIZE);        sscanf(sp, "%[^/n]", buf);        sp += strlen(buf);        if (ip == NULL)        {            return false;        }        if (!regex && strcmp(buf, ip->name) != 0)        {            return false;        }        if (regex && !FullTextMatch(ctx, buf, ip->name))        {            return false;        }        lines++;        // We have to manually exclude the marked terminator        if (ip == end)        {            return false;        }        // Now see if there is more        if (ip->next)        {            ip = ip->next;        }        else                    // if the region runs out before the end        {            if (++sp <= chunk + strlen(chunk))            {                return false;            }            break;        }    }    return lines;}

void CFulEditCtrl::Colorize(const tstring& aLine, int begin) {	CHARFORMAT2 cf;	cf.cbSize = sizeof(CHARFORMAT2);		ColorList *cList = HighlightManager::getInstance()->getList();	int end = GetTextLengthEx(GTL_NUMCHARS);		SetSel(begin, end);	//otroligt fulhack, m
C++ FunctionCall1函数代码示例
C++ FullCircles函数代码示例