Subversion Repositories autosfx

#include "stdafx.h"

#pragma hdrstop

#include "DZRaw.h"

#include <assert.h>

#include "dz_errs.h"

#undef _DZ_FILE_

#define _DZ_FILE_ DZ_DZRAW_CPP

/* DZRaw.cpp * Copyright (C)  2009 Russell Peters

* Permission is granted to any individual or institution to use, copy, or

* redistribute this software so long as all of the original files are included,

* that it is not sold for profit, and that this copyright notice is retained.

** distributed under LGPL license

** see license.txt for details

************************************************************************

 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify

    it under the terms of the GNU Lesser General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License

    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).

    updates: http://www.delphizip.org

    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip

************************************************************************/

dzraw_imp* __fastcall DZRawData::NewImp(unsigned siz)

{

    unsigned rawsize = sizeof(dzraw_imp) + siz - (8 * sizeof(char));

    if (rawsize & 63)

        rawsize = (rawsize | 63) + 1;

    if (rawsize > 0xFFF0)

        rawsize = 0xFFF0;

    dzraw_imp* _imp = (dzraw_imp*) (new char[rawsize]);

    if (! _imp)

        throw DZException(DZ_ERM_MEMORY);

    _imp->refs      = 1;

        _imp->capacity  = (WORD)((rawsize - sizeof(dzraw_imp)) + (8 * sizeof(char)));

        _imp->len       = 0;

    return _imp;

}

dzraw_imp* DZRawData::NewImp(const unsigned char* src, int Len, int Space)

{

    if (!src)

        Len = 0;

    if (Space >= 0 && Len > Space)

        Len = Space;

    int siz = (Space >= 0) ? Space : Len;

    if (!siz)

        return NULL;    // empty

    dzraw_imp* nimp = NewImp(siz); // make new

    if (src && Len)

    {

        memcpy(nimp->data, src, Len);

        nimp->len = (WORD)Len;

    }

    return nimp;

}

void __fastcall DZRawData::Release(void)

{

    if (imp)

    {

        if (!DecRefs())

        {

            void *_imp = imp;

            imp = NULL;

//            free(_imp);

            delete[] _imp;

        }

        imp = NULL;

    }

}

int __fastcall DZRawData::IncRefs(void)

{

    if (imp)

        return InterlockedIncrement(&(imp->refs));

    return 0;

}

int __fastcall DZRawData::DecRefs(void)

{

    if (imp && imp->refs)

        return InterlockedDecrement(&(imp->refs));

    return -1;

}

void __fastcall DZRawData::Append(const unsigned char* src, int Len)

{

    if (!src)

        Len = 0;

    // check something to append

    if (Len)

    {

        if (!imp)

            imp = NewImp(src, Len);

        else

        {

            unsigned nlen = imp->len + Len;

            if (nlen > 0xFFF0)

                return;

            // do we need a new one

            if (imp->refs > 1 || (WORD)nlen > imp->capacity)

            {

                // need new imp - make copy with enough space

                dzraw_imp* nimp = NewImp(imp->data, imp->len, nlen);

                Release();      // out with the old

                imp = nimp;     // in with the new

            }

            // append data

            unsigned char *bf = &imp->data[imp->len];

            memcpy(bf, src, Len);

            imp->len = (WORD)nlen;

        }

    }

}

void __fastcall DZRawData::Assign(const unsigned char* src, int Len)

{

    Release();

    imp = NewImp(src, Len);

}

unsigned char * __fastcall DZRawData::GetBuffer(unsigned size)

{

    Release();

    imp = NewImp(size);

        imp->len = (WORD)size;

    return imp->data;

}

void __fastcall DZRawData::SetLength(unsigned Len)

{

    if (!Len)

        Release();

        else

    {

        dzraw_imp* nimp;

        // do we need a new one

        if (!imp || imp->refs > 1 || (WORD)Len > imp->capacity)

        {

            // need new imp - make copy with enough space

            if (!imp)

                nimp = NewImp(Len);

            else

                nimp = NewImp(imp->data, imp->len, Len);

            Release();      // out with the old

            imp = nimp;     // in with the new

        }

        imp->len = (WORD)Len;

    }

}

__fastcall DZRawData::DZRawData(const DZRawData& other)

{

    imp = NULL;

    if (!other.IsEmpty())

    {

        imp = other.imp;

        IncRefs();

    }

}

__fastcall DZRawData::DZRawData(unsigned size)

{

    imp = NULL;

    if (size)

        imp = NewImp(size);

}

__fastcall DZRawData::DZRawData(const unsigned char* str, unsigned len)

{

    imp = NULL;

    if (str && len)

    {

        imp = NewImp(str, len);

    }

}

unsigned __fastcall DZRawData::Capacity(void) const

{

    if (imp)

        return imp->capacity;

    return NULL;

}

unsigned __fastcall DZRawData::Length(void) const

{

    if (imp)

        return imp->len;

    return 0;

}

const unsigned char* DZRawData::begin(void) const

{

    if (imp)

        return imp->data;

    return NULL;

}

const unsigned char* DZRawData::end(void) const

{

    if (imp)

        return imp->data + imp->len;

    return NULL;

}

const unsigned char* DZRawData::Find(WORD tag) const

{

    if (Length() < sizeof(XWord))

        return NULL;

    const unsigned char *p = begin();

    const unsigned char *q;

    const unsigned char *e = end();

    XWord tg, sz;

    while (p + 3 < e)

    {

        q = p;

        tg.b[0] = *p++;

        tg.b[1] = *p++;

        if (tg.w == tag)

            return q;   // found

        sz.b[0] = *p++;

        sz.b[1] = *p++;

        p += sz.w;

    }

    return NULL;

}

DZRawData& __fastcall DZRawData::operator =(const DZRawData& other)

{

    if (this != &other)

    {

        Release();

        if (!other.IsEmpty())

        {

            imp = other.imp;

            IncRefs();

        }

    }

    return *this;

}

DZRawData __fastcall DZRawData::operator +(const DZRawData& other)

{

    DZRawData res(*this);

    res.Append(other.begin(), other.Length());

    return res;

}

DZRawData& __fastcall DZRawData::operator +=(const DZRawData& other)

{

    Append(other.begin(), other.Length());

    return *this;

}

DZRawData& __fastcall DZRawData::operator +=(unsigned char ch)

{

    Append(&ch, 1);

    return *this;

}

DZRawData& __fastcall DZRawData::operator +=(WORD w)

{

    Append((const unsigned char*)&w, sizeof(WORD));

    return *this;

}

//unsigned char __fastcall DZRawData::operator [](unsigned idx) const

//{

//    if (!imp || idx >= Length())

//        return 0;

//    return *(imp + idx);

//}

WORD  __fastcall DZRawData::operator [](unsigned idx) const

{

    unsigned widx = idx * sizeof(WORD);

    if (!imp || widx >= Length() - (sizeof(WORD)-1))

        return 0;

    return ((WORD*)idx)[idx];

}

DZRawData __fastcall DZRawData::operator -(WORD tag)

{

    DZRawData res(Capacity());

    if (imp)

    {

        const unsigned char *p = begin();

        const unsigned char *e = end();

        XWord tg, sz;

        while (p + 3 < e)

        {

            tg.b[0] = *p++;

            tg.b[1] = *p++;

            sz.b[0] = *p++;

            sz.b[1] = *p++;

            if (tg.w != tag)

            {

                res += tg.w;

                res += sz.w;

                while (p < e && sz.w-- > 0)

                    res += *p++;

            }

            else

                p += sz.w;

        }

        while (p < e)

            res += *p++;

    }

    return res;

}

DZRawData& __fastcall DZRawData::operator -=(WORD tag)

{

    if (Find(tag))

    {

        DZRawData tmp = (*this) - tag;

        (*this) = tmp;

    }

    return *this;

}