Subtitle Resynchronizer (II)

It is revealed that this code doesn't worth the time I spent once it is done.
The code of rangemap.h is not provided. It is the most unqualified for being part of the lib.

#include <cassert>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <string>
#include <list>
#include <conio.h>

#include <qtl/ctnr/rangemap.h>

#define GENUSE_BUFSIZE    1024


using namespace std;
using namespace qtl;


typedef unsigned long    movtime_t;

struct TimeMapTraits : public RangeMapTraits<movtime_t>
{
    static bool DoMapSToD (TsCref sIni, TsCref sEnd, TdCref dIni, TdCref dEnd,
        bool rev, TsCref s, TdRef d)
    {
        d = (s - sIni) + dIni;
        return true;
    }

    static bool DoMapDToS (TdCref dIni, TdCref dEnd, TsCref sIni, TsCref sEnd,
        bool rev, TdCref d, TsRef s)
    {
        s = (d - dIni) + sIni;
        return true;
    }
};

struct TimeMap : public SegRangeMap<movtime_t, movtime_t, TimeMapTraits>
{
private:
    typedef SegRangeMap<movtime_t, movtime_t, TimeMapTraits>    MyBase;

public:
    LsItr   recent;

    struct DstRange
    {
        movtime_t   ini, end;
        DstRange (movtime_t i, movtime_t e) : ini(i), end(e) {}
    };

    typedef vector<DstRange>    DrVec;

    TimeMap ()
    {
        Clear();
    }

    void Clear ()
    {
        MyBase::Clear();
        InitRecent();
    }

    void InitRecent()
    {
        recent = listS.begin();
    }

    bool MapSToD (TsCref s, OutVecD &ds)
    {
        LsItr   itr;
        bool    found = false;
        ds.clear();
        LsItr   begin = recent;
        LsItr   end = listS.end();
        movtime_t    d;
        LsItr   newRecent;

        // backward
        for (itr = recent; itr != listS.begin();)
        {
            itr--;
            if (TrySToD(*itr, s, d))
            {
                ds.push_back(d);
                found = true;
                newRecent = recent;
            }
            else if (s >= itr->end)
            {
                break;
            }
        }
        // forward
        for (itr = recent; itr != listS.end(); ++itr)
        {
            if (TrySToD(*itr, s, d))
            {
                ds.push_back(d);
                if (!found)
                {
                    newRecent = recent;
                    found = true;
                }
            }
            else if (s < itr->ini)
            {
                break;
            }
        }

        if (found)
        {
            recent = newRecent;
        }
        return found;
    }

    bool MapRangeSToD (TsCref sIni, TsCref sEnd, DrVec &drs)
    {
        OutVecD ds;
        if (!MapSToD(sIni, ds))
        {
            return false;
        }
        movtime_t d = sEnd - sIni;

        drs.clear();
        for (int i = 0; i < ds.size(); i++)
        {
            movtime_t ini = ds[i];
            movtime_t end = ini + d;
            int j;
            for (j = 0; j < drs.size(); j++)
            {
                if (drs[j].ini > ini)
                {
                    break;
                }
            }
            
            drs.insert(drs.begin() + j, DstRange(ini, end));
        }

        return true;
    }
};

/* Sub to abs time (many to one) mapping */
typedef TimeMap SubToAbsMap;

/* Mov to abs time (one to many) mapping */
typedef TimeMap AbsToMovMap;


struct SubMovMapper
{
    SubToAbsMap        stoa;
    AbsToMovMap        atom;

    typedef AbsToMovMap::OutVecD    OutVec;
    typedef AbsToMovMap::DrVec        DrVec;
    typedef AbsToMovMap::DstRange    DstRange;

    void AddSubToAbs (movtime_t sIni, movtime_t sEnd, movtime_t aIni, movtime_t aEnd)
    {
        stoa.AddMap(sIni, sEnd, aIni, aEnd);
    }

    void AddAbsToMov (movtime_t aIni, movtime_t aEnd, movtime_t mIni, movtime_t mEnd)
    {
        atom.AddMap(aIni, aEnd, mIni, mEnd);
    }

    bool MapSubToAbs (movtime_t s, movtime_t &a)
    {
        SubToAbsMap::OutVecD as;
        if (!stoa.MapSToD(s, as)) return false;
        a = as[0];
        return true;
    }

    bool MapAbsToMov (movtime_t a, OutVec &m)
    {
        return atom.MapSToD(a, m);
    }

    bool MapSubToMov (movtime_t s, OutVec &m)
    {
        movtime_t a;
        if (!MapSubToAbs(s, a)) return false;
        return MapAbsToMov(a, m);
    }

    bool MapRangeSubToAbs (movtime_t sIni, movtime_t sEnd, movtime_t &dIni, movtime_t &dEnd)
    {
        SubToAbsMap::DrVec  drs;
        if (!stoa.MapRangeSToD(sIni, sEnd, drs)) return false;
        dIni = drs[0].ini;
        dEnd = drs[0].end;
        return true;
    }

    bool MapRangeAbsToMov (movtime_t sIni, movtime_t sEnd, DrVec &drs)
    {
        return atom.MapRangeSToD(sIni, sEnd, drs);
    }

    void Clear ()
    {
        stoa.Clear();
        atom.Clear();
    }

    void InitRecent ()
    {
        stoa.InitRecent();
        atom.InitRecent();
    }
};


struct CommonParser
{
    static int ReadAsManyDigits (const char *&psz, unsigned long &val)
    {
        int r;
        val = 0;
        if (psz[0] == 0)
        {
            return 0;
        }
        for (r = 0 ; psz[0] >= '0' && psz[0] <= '9'; ++psz)
        {
            val *= 10;
            val += psz[0] - '0';
            r++;
        }
        return r;
    }

    static bool GoUntil (const char *&psz, const char *csz)
    {
        const char *pcsz = csz;
        for ( ; *psz != 0 && *pcsz != 0; psz++)
        {
            if (*psz == *pcsz)
            {
                pcsz++;
            }
            else
            {    /* unfortunately it's not kmp */
                psz -= pcsz - csz;
                pcsz = csz;
            }
        }

        return *pcsz == 0;
    }

    static void SkipBlanks (const char *&psz)
    {
        for ( ; psz[0] == ' ' || psz[0] == '/t'; ++psz);
    }

    static bool Pass (const char *&psz, const char *csz)
    {
        SkipBlanks(psz);
        for ( ; *csz != 0 && *psz == *csz; psz++, csz++);
        SkipBlanks(psz);
        return (*csz == 0);
    }
};

struct TmapParser : public CommonParser
{
    typedef vector<movtime_t>    TimeVec;

    TimeVec        baseTime;
    TimeVec        volDur;            // explicitly indicated volumn duration
    movtime_t    oldst, olddt;

    enum PlusType
    {
        k_ptNormal,
        k_ptPrevious,
        k_ptExpected,
    };

    TmapParser ()
    {
        SetNumVols(0);
    }

    static bool ParseDigitalTime (const char *&psz, movtime_t &ot, int *pVol = 0)
    {
        unsigned long val;
        unsigned long hr, min, sec, msec;
        int vol = -1;
        int len = ReadAsManyDigits(psz, val);
        if (len == 0) return false;
        if (psz[0] == '.')
        {
            if (val == 0)
            {
                return false;
            }
            vol = val - 1;    // volumne number starts from 1
        }
        else if (psz[0] == ':')
        {
            hr = val;
        }
        else
        {
            ot = val;
            return true;
        }

        if (vol >= 0)
        {
            psz++;
            len = ReadAsManyDigits(psz, hr);
            if (len == 0 || psz[0] != ':') return false;
        }

        psz++;
        len = ReadAsManyDigits(psz, min);
        if (len == 0 || psz[0] != ':') return false;
        psz++;
        len = ReadAsManyDigits(psz, sec);
        if (len == 0) return false;
        if (psz[0] == ',')
        {
            psz++;
            len = ReadAsManyDigits(psz, msec);
        }

        ot = ((hr * 60+min)*60+sec)*1000+msec;

        if (pVol)
        {
            *pVol = vol;
        }

        return true;
    }

    bool ParseTime (const char *&psz, movtime_t &ot, PlusType &plus)
    {
        int vol = -1, hr, min, sec, msec;

        int len;
        movtime_t            t;
        vector<movtime_t>    vt;
        vector<bool>        st;
        int                    sig = 1;
        bool                expectnote= true;
        bool                expectval = true;

        plus = k_ptNormal;

        // overflow doesn't fail the result
        ot = 0;
        while (1)
        {
            SkipBlanks(psz);
            if (psz[0] == '+' && expectnote)
            {
                sig = 1;
                expectnote = false; expectval = true;
                psz++;
            }
            else if (psz[0] == '-' && expectnote)
            {
                sig = -1;
                expectnote = false; expectval = true;
                psz++;
            }
            else if ((psz[0] == '^' || psz[0] == '*') && expectval)
            {
                if (sig < 0) { return false; }
                if (plus != k_ptNormal)
                {
                    return false;
                }
                plus = psz[0] == '^'? k_ptPrevious : k_ptExpected;
                expectval = false; expectnote = true;
                ++psz;
            }
            else if (expectval)
            {
                if (!ParseDigitalTime(psz, t, &vol))
                {
                    return false;
                }

                if (vol >= 0)
                {
                    int    numVols = baseTime.size();
                    if (vol >= numVols)
                    {
                        return false;
                    }
                    t += baseTime[vol];

                    if (vol + 1 < numVols && baseTime[vol+1] < t)
                    {
                        baseTime[vol+1] = t;    // default base time for next volume
                        if (baseTime[vol+1] - baseTime[vol] < volDur[vol])
                        {
                            baseTime[vol+1] = baseTime[vol] + volDur[vol];
                        }
                    }
                }

                printf("t=%d/n", t);
                st.push_back(sig);
                vt.push_back(t);
                if (sig>0)
                {
                    ot += t;
                }
                else
                {
                    ot -= t;
                }
                expectval = false; expectnote = true;
            }
            else
            {
                break;
            }
        }
        if (expectval == true)
        {    // syntax error
            return false;
        }
        
        return true;
    }

    bool ParseTmapLine (const char *szLine, movtime_t &st1, movtime_t &st2,
            movtime_t &dt1, movtime_t &dt2)
    {
        int val;
        const char *psz = szLine;
        PlusType plus[4];

        if (!ParseTime(psz, st1, plus[0])) return false;
        if (plus[0] == k_ptPrevious)
        {
            st1 += oldst;
        }
        if (!Pass(psz, "~")) return false;
        if (!ParseTime(psz, st2, plus[1])) return false;
        if (plus[1] == k_ptPrevious)
        {
            st2 += oldst;
        }

        
        if (!Pass(psz, "=>")) return false;

        if (!ParseTime(psz, dt1, plus[2])) return false;
        if (plus[2] == k_ptPrevious)
        {
            dt1 += olddt;
        }
        if (!Pass(psz, "~")) return false;
        if (!ParseTime(psz, dt2, plus[3])) return false;
        if (plus[3] == k_ptPrevious)
        {
            dt2 += olddt;
        }

        int plusexp, i;
        for (plusexp = 0, i = 0; i < 4; i++)
        {
            if (plus[i] == k_ptExpected)
            {
                plusexp++;
            }
        }
        if (plusexp > 1)
        {
            return false;
        }

        if (plus[0] == k_ptExpected)
        {
            st1 += st2 - (dt2 - dt1);
        }
        else if (plus[1] == k_ptExpected)
        {
            st2 += st1 + (dt2 - dt1);
        }
        else if (plus[2] == k_ptExpected)
        {
            dt1 += dt2 - (st2 - st1);
        }
        else if (plus[3] == k_ptExpected)
        {
            dt2 += dt1 + (st2 - st1);
        }

        oldst = st2;
        olddt = dt2;

        return true;
    }

    void SetNumVols (int n)
    {
        baseTime.resize(n, 0);
        volDur.resize(n, 0);
        oldst = olddt = 0;
    }

    void SetVolDur (int i, movtime_t d)
    {
        volDur[i] = d;
    }

};

struct StResync
{
    struct Item
    {
        movtime_t    absini;
        movtime_t    absend;
        char        strbuf[GENUSE_BUFSIZE];
    };

    SubMovMapper    mapper;

    struct In
    {
        TmapParser        parser;
        SubMovMapper    *pMapper;

        vector<FILE *>    files;
        int                fvidx;

        bool            isEnd;
        
        int                sn;

        In (SubMovMapper *pm) : pMapper(pm)
        {
            Clear();
        }

        ~In ()
        {
            for (int i = 0; i < files.size(); i++)
            {
                if (files[i])
                {
                    fclose(files[i]);
                }
            }
        }

        void Clear ()
        {
            fvidx = 0;
            isEnd = false;
            sn = -1;
            parser.SetNumVols(0);
            files.clear();
        }

        bool IsSn (const char *buf, int &sn) const
        {
            const char *psz = buf;
            unsigned long val;
            int len = CommonParser::ReadAsManyDigits(psz, val);
            if (len == 0 || psz[0] != 0)
            {
                return false;
            }
            sn = val;
            return true;
        }

        bool Get (Item &item)
        {
            char    buf[GENUSE_BUFSIZE];

        __again:
            if (sn < 0)
            {
                do
                {
                    if (!StResync::GetLine(buf, GENUSE_BUFSIZE, files[fvidx])) return false;
                } while (!IsSn(buf, sn));
            }

            if (!StResync::GetLine(buf, GENUSE_BUFSIZE, files[fvidx])) return false;

            movtime_t ini, end;
            const char *psz = buf;    // use it at present for holding data
            TmapParser::SkipBlanks(psz);
            if (!TmapParser::ParseDigitalTime(psz, ini)) return false;
            TmapParser::SkipBlanks(psz);
            TmapParser::Pass(psz, "-->");
            TmapParser::SkipBlanks(psz);
            if (!TmapParser::ParseDigitalTime(psz, end)) return false;
            TmapParser::SkipBlanks(psz);


            ini += parser.baseTime[fvidx];
            end += parser.baseTime[fvidx];
    

            if (!pMapper->MapRangeSubToAbs(ini, end, item.absini, item.absend)) return false;

            sn = -1;
            item.strbuf[0] = 0;
            int fileCount = files.size();
            while (1)
            {    /* content */
                if (!StResync::GetLine(buf, GENUSE_BUFSIZE, files[fvidx]))
                {
                    fvidx++;
                    if (fvidx < fileCount) continue;
                    isEnd = true;
                    return false;
                }

                if (IsSn(buf, sn))
                {
                    break;
                }

                strcat(item.strbuf, buf);
                strcat(item.strbuf, "/n");
            }

            if (item.absini == item.absend)
            {
                goto __again;
            }

            return true;
        }

        bool IsEnd ()
        {
            return isEnd;
        }

        void SetNumVols (int n)
        {
            parser.SetNumVols(n);
            files.resize(n);
            fvidx = 0;
        }

        void AddFile (int i, FILE *f, movtime_t dur)
        {
            files[i] = f;
            parser.SetVolDur(i, dur);
        }
    };

    struct Out
    {
        TmapParser            parser;
        SubMovMapper        *pMapper;

        vector<FILE *>        files;
        vector<movtime_t>    baseTime;
        vector<int>            sns;
        int                    fvidx;

        Out (SubMovMapper *pm) : pMapper(pm)
        {
            Clear();
        }

        ~Out ()
        {
            for (int i = 0; i < files.size(); i++)
            {
                if (files[i])
                {
                    fclose(files[i]);
                }
            }
        }

        void Clear ()
        {
            SetNumVols(0);
        }

        static void AnalyseTime (movtime_t t, int &h, int &m, int &s, int &ms)
        {
            ms = t % 1000;
            t /= 1000;
            s = t % 60;
            t /= 60;
            m = t % 60;
            t /= 60;
            h = t;
        }

        bool Set (Item &item)
        {
            char tempbuf[64] = {0, };
            char outbuf[GENUSE_BUFSIZE] = {0, };

            SubMovMapper::DrVec    movrs;

            if (!pMapper->MapRangeAbsToMov(item.absini, item.absend, movrs))
            {   // no matching time segment in the movie
                return false;
            }

            int n = movrs.size();
            int fn = files.size();

            static int lastI;

            for (int i = 0; i < n; i++)
            {
                movtime_t ini = movrs[i].ini;
                movtime_t end = movrs[i].end;
                int fvibegin = fvidx;
                int fviend = fvidx;

                for (fvibegin = 0; fvibegin < fn && ini < baseTime[fvibegin]; fvibegin++)
                {
                }
                for ( ; fvibegin + 1 < fn && ini >= baseTime[fvibegin + 1]; fvibegin++)
                {
                }

                ini -= baseTime[fvibegin];
                fviend = fvibegin;  // can only be too small

                for ( ; fviend+1 < fn && end > baseTime[fviend+1]; fviend++)
                {
                }
                /*
                for ( ; fviend > 0 && end <= baseTime[fviend]; fvend--)
                {
                }
                */
                end -= baseTime[fviend];

                for (int i = fvibegin; i <= fviend; i++)
                {
                    movtime_t vi, ve;
                    if (i == fvibegin)
                    {
                        vi = ini;
                    }
                    else
                    {
                        vi = 0;
                    }
                    if (i == fviend)
                    {
                        ve = end;
                    }
                    else
                    {
                        ve = baseTime[i + 1] - baseTime[i];
                    }


                    // SN
                    sprintf(outbuf, "%d/n", ++sns[i]);

                    // Time stamp
                    int h, m, s, ms;
                    AnalyseTime(vi, h, m, s, ms);
                    sprintf(tempbuf, "%02d:%02d:%02d,%03d", h, m, s, ms);
                    strcat(outbuf, tempbuf);
                    AnalyseTime(ve, h, m, s, ms);
                    sprintf(tempbuf, " --> %02d:%02d:%02d,%03d/n", h, m, s, ms);
                    strcat(outbuf, tempbuf);

                    // Text
                    strcat(outbuf, item.strbuf);

                    fprintf(files[i], "%s", outbuf);        
                }
            }

            return true;
        }

        void SetNumVols (int n)
        {
            files.resize(n, 0);
            baseTime.resize(n, 0);
            sns.resize(n, 0);
            parser.SetNumVols(n);
            fvidx = 0;
        }

        void AddFile (int i, FILE *f, movtime_t dur)
        {
            files[i] = f;
            if (i == 0)
            {
                baseTime[i] = 0;
            }
            if (i < baseTime.size() - 1)
            {
                baseTime[i+1] = baseTime[i] + dur;
            }
            parser.SetVolDur(i, dur);
        }

    };

    In    in;
    Out    out;

    StResync () : in(&mapper), out(&mapper)
    {
    }

    static bool GetLine (char *buf, int bufsize, FILE *f)
    {
        if (feof(f))
        {
            return false;
        }
        buf[0] = 0;
        fgets(buf, bufsize, f);
        int len = strlen(buf);
        if (len>0 && buf[len-1]==0xa) len--;
        if (len>0 && buf[len-1]==0xd) len--;
        buf[len] = 0;
        return true;
    }

    static const char *ProcessFileInfo(char *buf, movtime_t &dur)
    {
        const char *psz = buf;
        CommonParser::SkipBlanks(psz);
        const char *psz2 = psz;
        if (CommonParser::GoUntil(psz2, ">>"))
        {
            const char *psz3 = psz2;
            psz2 -= 2;
            if (psz == psz2)
            {
                return 0;
            }
            for ( ; psz2[-1] == ' ' || psz2[-1] == '/t'; psz2--)
            {
            }
            char *psz4 = const_cast<char *>(psz2);
            psz4[0] = 0;
            
            CommonParser::SkipBlanks(psz3);
            if (!TmapParser::ParseDigitalTime(psz3, dur))
            {
                return 0;
            }
        }

        return psz;
    }

    static bool IsEmptyLine (const char *buf)
    {
        const char *psz = buf;
        CommonParser::SkipBlanks(psz);
        return psz[0] == 0;
    }

    static bool IsSepLine (const char *buf)
    {
        const char *psz = buf;
        CommonParser::SkipBlanks(psz);
        return (psz[0] == '*' && psz[1] == '*' && psz[1] == '*');
    }

    bool ParseConfig (FILE *fConfig)
    {
        char buf[GENUSE_BUFSIZE];
        const char *psz;
        int len;
        unsigned long n;

        in.Clear();
        out.Clear();
        mapper.Clear();

        // 1. first go the file names of input subtitle files and its length if available
        if (!GetLine(buf, GENUSE_BUFSIZE, fConfig))
        {
            printf("! Unexpected end of file./n");
            return false;
        }

        psz = buf;
        CommonParser::SkipBlanks(psz);
        len = CommonParser::ReadAsManyDigits(psz, n);
        if (len == 0)
        {
            printf("! The number of input subtitle files unspecified./n");
            return false;
        }
        in.SetNumVols(n);
        for (int i = 0; i < n; i++)
        {
            // format:
            // abc.srt -- 00:59:28,600
            // or
            // abc.srt -- 3568600
            movtime_t    dur;
            FILE        *fIn;

            GetLine(buf, GENUSE_BUFSIZE, fConfig);
            const char *pfn = ProcessFileInfo(buf, dur);

            fIn = fopen(pfn, "r");
            if (fIn == 0)
            {
                printf("! The input file '%s' cannot be opened./n", pfn);
                return false;
            }
            else
            {
                int hr, min, sec, msec;
                Out::AnalyseTime(dur, hr, min, sec, msec);
                printf(": The input file '%s' has successfully been loaded with duration claimed to be %02d:%02d:%02d,%03d/n", pfn, hr, min, sec, msec);
            }
            
            in.AddFile(i, fIn, dur);
        }

        // 2. then come the file names of output subtitle files and its length according to the movie files if available
        if (!GetLine(buf, GENUSE_BUFSIZE, fConfig))
        {
            printf("! Unexpected end of file./n");
            return false;
        }

        psz = buf;
        CommonParser::SkipBlanks(psz);
        len = CommonParser::ReadAsManyDigits(psz, n);
        if (len == 0)
        {
            printf("! The number of output subtitle files unspecified./n");
            return false;
        }
        out.SetNumVols(n);
        for (int i = 0; i < n; i++)
        {
            // format, same as input
            movtime_t    dur;
            FILE        *fOut;

            if (!GetLine(buf, GENUSE_BUFSIZE, fConfig))
            {
                printf("! Unexpected end of file./n");
                return false;
            }
            const char *pfn = ProcessFileInfo(buf, dur);

            fOut = fopen(pfn, "w");
            if (fOut == 0)
            {
                printf("! The output file '%s' cannot be opened./n", pfn);
                return false;
            }
            else
            {
                int hr, min, sec, msec;
                Out::AnalyseTime(dur, hr, min, sec, msec);
                printf(": The output file '%s' has successfully been loaded with duration claimed to be %02d:%02d:%02d,%03d/n", pfn, hr, min, sec, msec);
            }
        
            out.AddFile(i, fOut, dur);
        }

        movtime_t st1, st2, dt1, dt2;
        // 3. here is the original subtitle temporal description
        printf(": Loading mapping from original subtitle to absolute timeaxis./n");
        while (1)
        {
            // format: time~time-->abstime~abstime
            if (!GetLine(buf, GENUSE_BUFSIZE, fConfig))
            {
                printf("! Unexpected end of file./n");
                return false;
            }
            printf("%s/n", buf);
            if (IsEmptyLine(buf))
            {
                continue;
            }
            else if (IsSepLine(buf))
            {
                break;
            }
            if (!in.parser.ParseTmapLine(buf, st1, st2, dt1, dt2))
            {
                printf("! Time syntax error./n");
                return false;
            }
            mapper.AddSubToAbs(st1, st2, dt1, dt2);
            printf(": successfully mapped %d~%d to %d~%d./n", st1, st2, dt1, dt2);
        }


        // 4. the movie temporal description
        bool noout = true;
        printf(": Loading mapping from absolute timeaxis to movie./n");
        while (1)
        {
            // format: abstime~abstime-->time~time
            if (!GetLine(buf, GENUSE_BUFSIZE, fConfig))
            {
                if (noout)
                {
                    printf("! Unexpected end of file./n");
                    return false;
                }
                else
                {
                    mapper.InitRecent();
                    return true;
                }
            }

            if (IsEmptyLine(buf))
            {
                continue;
            }

            if (!out.parser.ParseTmapLine(buf, st1, st2, dt1, dt2))
            {
                printf("! Time syntax error./n");
                return false;
            }

            mapper.AddAbsToMov(st1, st2, dt1, dt2);
            printf(": successfully mapped %d~%d to %d~%d./n", st1, st2, dt1, dt2);

            noout = false;

        }

        return false;
    }

    bool Rectify ()
    {
        Item item;
        while (in.Get(item))
        {
            out.Set(item);
        }
        return in.IsEnd();
    }
};


int main (void)
{
    FILE *fConfig = fopen("stresync_config.txt", "r");
    StResync    resync;
    if (!resync.ParseConfig(fConfig))
    {
        return 0;
    }
    if (!resync.Rectify())
    {
        return 0;
    }
    printf(": Conversion was successfully made./n");

    return 0;
}