path.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008.
 *
 * 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/path.hpp>

namespace {

using namespace ders;

inline bool sepr(char ch)
{
 return ch=='\\' || ch=='/';
}

ch_rng fname(const char* beg, const char* end)
{
 const char* ptr=beg;
 for ( ; ptr<end && !sepr(*ptr); ptr++)
     ;

 return ch_rng(beg, ptr);
}

ch_rng fsepr(const char* beg, const char* end)
{
 const char* ptr=beg;
 for ( ; ptr<end && sepr(*ptr); ptr++)
     ;

 return ch_rng(beg, ptr);
}

}  // unnamed

namespace ders {  // ::ders

void parse_path(mem_pool&, const ch_rng& path, std::vector<path_elmt>& ret)
{
 ret.clear();

 const char* ptr=path.beg;

 if (path.end-ptr>=5) {  // "\\a\b"
    ch_rng spr=fsepr(ptr, path.end);
    if (spr.size()==2) {
       ch_rng srv=fname(spr.end, path.end);
       if (srv.size()>0) {
          ch_rng spr2=fsepr(srv.end, path.end);
          if (spr2.size()==1) {
             ch_rng shr=fname(spr2.end, path.end);
             if (shr.size()>0) {
                ret.push_back(path_elmt(path_elmt::share, ch_rng(ptr,
                  shr.end)));
                ptr=fsepr(shr.end, path.end).end;
             }
          }
       }
    }
 }

 if (path.end-ptr>=2) {  // "A:"
    ch_rng nm=fname(ptr, path.end);
    if (nm.size()>=2 && nm.beg[1]==':') {
       nm.end=nm.beg+2;
       ret.push_back(path_elmt(path_elmt::drive, nm));
       ptr=nm.end;
    }
 }

 ch_rng spr=fsepr(ptr, path.end);
 if (spr.size()>0) {  // "\"
    ret.push_back(path_elmt(path_elmt::root, ch_rng(ptr, ptr+1)));
    ptr=spr.end;
 }

 for (;;) {
     ch_rng nm=fname(ptr, path.end);
     if (nm.size()<=0) break;

     ret.push_back(path_elmt(path_elmt::name, nm));
     ptr=fsepr(nm.end, path.end).end;
 }
}

sh_text make_path(mem_pool& mp, const path_elmt* beg, const path_elmt* end, char
  spr)
{
 sh_text ret(nt(mp));
 ret->reserve(512);

 for (const path_elmt* ptr=beg; ptr<end; ptr++) {
     switch (ptr->tp) {
            case path_elmt::drive: {
                 assert(ptr==beg);

                 ret->append(ptr->nm);
                 break;
            }
            case path_elmt::name: {
                 if (ptr>beg && (ptr[-1].tp==path_elmt::name ||
                     ptr[-1].tp==path_elmt::share))
                    ret->append(spr);

                 ret->append(ptr->nm);
                 break;
            }
            case path_elmt::root: {
                 assert(ptr==beg || ptr==beg+1&&beg->tp==path_elmt::drive);
                 assert(ptr->nm.size()==1);

                 ret->append(spr);
                 break;
            }
            case path_elmt::share: {
                 assert(ptr==beg);

                 ret->append(ptr->nm);
                 break;
            }
            default: assert(false);
     }
 }

 return ret;
}

sh_text normalize_path(mem_pool& mp, const ch_rng& path)
{
 std::vector<path_elmt> vpe;
 parse_path(mp, path, vpe);
 return make_path(mp, &*vpe.begin(), &*vpe.end());
}

sh_text get_path(mem_pool& mp, const ch_rng& path)
{
 std::vector<path_elmt> vpe;
 parse_path(mp, path, vpe);

 const path_elmt *beg=&*vpe.begin(), *end=&*vpe.end();
 if (end>beg && (end-1)->tp==path_elmt::name) end--;

 return make_path(mp, beg, end);
}

sh_text get_name(mem_pool& mp, const ch_rng& path)
{
 std::vector<path_elmt> vpe;
 parse_path(mp, path, vpe);

 if (vpe.size() && vpe.back().tp==path_elmt::name) return nt(mp, vpe.back().nm);
 return nt(mp);
}

}  // namespace ::ders

---