wldcrd_mtchr.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008-2009.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#include <ders/wldcrd_mtchr.hpp>
#include <ders/mem.hpp>

namespace ders {  // ::ders

using namespace std;

void wldcrd_mtchr::add_sg()
{
 sav_sgs.push_back(segm());
 sgs.push_back(&sav_sgs.back());
}

bool wldcrd_mtchr::eq(const char* str, const segm& sg, int beg) const
{
 for (int i=beg, end=sg.wds.size(); i<end; i++) {
     const ch_rng& wstr=sg.wds[i].str;
     if (memcmp(str+sg.wds[i].off, wstr.beg, wstr.size())) return false;
 }

 return true;
}

const char* wldcrd_mtchr::fnd(const ch_rng& str, const segm& sg) const
{
 if (sg.wds.size()==0) return (str.size()>=sg.len) ? str.beg : 0;

 const word& wd=sg.wds.front();
 for (ch_rng s=str; s.size()>=sg.len; ) {
     const char* ptr=static_cast<const char*>(mem_find(s.beg+wd.off, s.size()-
       sg.len+wd.str.size(), wd.str.beg, wd.str.size()));
     if (!ptr) return 0;

     ptr-=wd.off;
     if (eq(ptr, sg, 1)) return ptr;

     s.beg=ptr+1;
 }

 return 0;
}

wldcrd_mtchr::wldcrd_mtchr(mem_pool& m, const ch_rng& mask) :
  mp(m), len(0), sav_msk(nt(m, mask)), sav_sgs(stl_allocator<segm>(mp))
{
 for (char* ptr=sav_msk->begin(); ptr<sav_msk->end(); ptr++) {
     switch (*ptr) {
            case '*': {
                 if (sgs.size()==0 || sgs.back()) sgs.push_back(0);
                 break;
            }
            case '?': {
                 if (sgs.size()==0 || !sgs.back()) add_sg();
                 sgs.back()->len++;

                 break;
            }
            default: {
                     if (sgs.size()==0 || !sgs.back()) add_sg();
                     segm& bs=*sgs.back();

                     if (*ptr=='\\' && ptr+1<sav_msk->end()) {
                        ptr++;
                        bs.wds.push_back(word(bs.len, ch_rng(ptr, ptr+1)));
                     }
                     else {
                          if (bs.wds.size()==0 || bs.len!=bs.wds.back().off+
                              bs.wds.back().str.size())
                             bs.wds.push_back(word(bs.len, ch_rng(ptr, ptr+1)));
                          else bs.wds.back().str.end++;
                     }

                     bs.len++;
            }
     }
 }

 for (int i=0, end=sgs.size(); i<end; i++)
     if (sgs[i]) len+=sgs[i]->len;
}

bool wldcrd_mtchr::match(const ch_rng& str) const
{
 if (str.size()<len) return false;

 int sgfr=0, sgbk=sgs.size()-1;
 if (sgfr>sgbk) return true;

 ch_rng s=str;
 if (sgs[sgfr]) {
    if (!eq(s.beg, *sgs[sgfr])) return false;

    s.beg+=sgs[sgfr]->len;
    sgfr++;
 }

 if (sgfr<=sgbk && sgs[sgbk]) {
    if (!eq(s.end-sgs[sgbk]->len, *sgs[sgbk])) return false;

    s.end-=sgs[sgbk]->len;
    sgbk--;
 }

 if (sgfr>sgbk) return s.beg==s.end;

 assert(!sgs[sgbk]);
 for (int i=sgfr; i<sgbk; i++) {
     if (sgs[i]) {
        s.beg=fnd(s, *sgs[i]);
        if (!s.beg) return false;

        s.beg+=sgs[i]->len;
     }
 }

 return true;
}

sh_wldcrd_mtchr new_wldcrd_mtchr(mem_pool& mp, const ch_rng& mask)
{
 mp_newbuf<wldcrd_mtchr> buf(mp);
 return sh_wldcrd_mtchr(buf.pool(), buf.rls(::new(buf.get()) wldcrd_mtchr(mp,
   mask)));
}

}  // namespace ::ders

---