RawStr Class Reference

#include <rawstr.h>

Inheritance diagram for RawStr:

Collaboration diagram for RawStr:

Public Member Functions
signed char	findOffset (const char *key, SW_u32 *start, SW_u16 *size, long away=0, SW_u32 *idxoff=0) const
void	getIDXBuf (long ioffset, char **buf) const
void	getIDXBufDat (long ioffset, char **buf) const
	RawStr (const char *ipath, int fileMode=-1, bool caseSensitive=false)
void	readText (SW_u32 start, SW_u16 *size, char **idxbuf, SWBuf &buf) const
virtual	~RawStr ()

Static Public Member Functions
static signed char	createModule (const char *path)

Static Public Attributes
static const char	nl = '\n'

Protected Member Functions
void	doLinkEntry (const char *destkey, const char *srckey)
void	doSetText (const char *key, const char *buf, long len=-1)

Protected Attributes
FileDesc *	datfd
FileDesc *	idxfd

Static Protected Attributes
static const int	IDXENTRYSIZE = 6

Private Attributes
bool	caseSensitive
long	lastoff
char *	path

Static Private Attributes
static int	instance = 0

Detailed Description

Definition at line 35 of file rawstr.h.

Constructor & Destructor Documentation

RawStr::RawStr	(	const char *	ipath,
		int	fileMode = -1,
		bool	caseSensitive = false
	)

Definition at line 59 of file rawstr.cpp.

                                                                  : caseSensitive(caseSensitive)
{
    SWBuf buf;

    lastoff = -1;
    path = 0;
    stdstr(&path, ipath);

    if (fileMode == -1) { // try read/write if possible
        fileMode = FileMgr::RDWR;
    }
        
    buf.setFormatted("%s.idx", path);
    idxfd = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s.dat", path);
    datfd = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    if (!datfd || datfd->getFd() < 0) {
// couldn't find datafile but this might be fine if we're
// merely instantiating a remote InstallMgr SWMgr
SWLOGD("Couldn't open file: %s. errno: %d", buf.c_str(), errno);
    }

    instance++;
}

RawStr::~RawStr ( )

virtual

Definition at line 91 of file rawstr.cpp.

{
    if (path)
        delete [] path;

    --instance;

    FileMgr::getSystemFileMgr()->close(idxfd);
    FileMgr::getSystemFileMgr()->close(datfd);
}

Member Function Documentation

signed char RawStr::createModule ( const char *  path )

static

Definition at line 502 of file rawstr.cpp.

{
    char *path = 0;
    char *buf = new char [ strlen (ipath) + 20 ];
    FileDesc *fd, *fd2;

    stdstr(&path, ipath);

    if ((path[strlen(path)-1] == '/') || (path[strlen(path)-1] == '\\'))
        path[strlen(path)-1] = 0;

    sprintf(buf, "%s.dat", path);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    fd->getFd();
    FileMgr::getSystemFileMgr()->close(fd);

    sprintf(buf, "%s.idx", path);
    FileMgr::removeFile(buf);
    fd2 = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    fd2->getFd();
    FileMgr::getSystemFileMgr()->close(fd2);

    delete [] path;
    
    return 0;
}

void RawStr::doLinkEntry ( const char *  destkey, const char *  srckey  )

protected

Definition at line 488 of file rawstr.cpp.

                                                                {
    char *text = new char [ strlen(destkey) + 7 ];
    sprintf(text, "@LINK %s", destkey);
    doSetText(srckey, text);
    delete [] text;
}

void RawStr::doSetText ( const char *  key, const char *  buf, long  len = -1  )

protected

Definition at line 368 of file rawstr.cpp.

{

    SW_u32 start, outstart;
    SW_u32 idxoff;
    SW_u32 endoff;
    SW_s32 shiftSize;
    SW_u16 size;
    SW_u16 outsize;
    char *tmpbuf = 0;
    char *key = 0;
    char *dbKey = 0;
    char *idxBytes = 0;
    char *outbuf = 0;
    char *ch = 0;

    char errorStatus = findOffset(ikey, &start, &size, 0, &idxoff);
    stdstr(&key, ikey, 2);
    if (!caseSensitive) toupperstr_utf8(key, (unsigned int)(strlen(key)*2));

    len = (len < 0) ? strlen(buf) : len;

    getIDXBufDat(start, &dbKey);

    if (strcmp(key, dbKey) < 0) {
    }
    else if (strcmp(key, dbKey) > 0) {
        if (errorStatus != (char)-2)    // not a new file
            idxoff += 6;
        else idxoff = 0;
    }
    else if ((!strcmp(key, dbKey)) && (len>0 /*we're not deleting*/)) { // got absolute entry
        do {
            tmpbuf = new char [ size + 2 ];
            memset(tmpbuf, 0, size + 2);
            datfd->seek(start, SEEK_SET);
            datfd->read(tmpbuf, (int)(size - 1));

            for (ch = tmpbuf; *ch; ch++) {      // skip over index string
                if (*ch == 10) {
                    ch++;
                    break;
                }
            }
            memmove(tmpbuf, ch, size - (unsigned short)(ch-tmpbuf));

            // resolve link
            if (!strncmp(tmpbuf, "@LINK", 5) && (len)) {
                for (ch = tmpbuf; *ch; ch++) {      // null before nl
                    if (*ch == 10) {
                        *ch = 0;
                        break;
                    }
                }
                findOffset(tmpbuf + 6, &start, &size, 0, &idxoff);
            }
            else break;
        }
        while (true);   // while we're resolving links
    }

    endoff = (SW_u32)idxfd->seek(0, SEEK_END);

    shiftSize = endoff - idxoff;

    if (shiftSize > 0) {
        idxBytes = new char [ shiftSize ];
        idxfd->seek(idxoff, SEEK_SET);
        idxfd->read(idxBytes, shiftSize);
    }

    outbuf = new char [ len + strlen(key) + 5 ];
    sprintf(outbuf, "%s%c%c", key, 13, 10);
    size = strlen(outbuf);
    memcpy(outbuf + size, buf, len);
    size = outsize = size + (len);

    start = outstart = (SW_u32)datfd->seek(0, SEEK_END);

    outstart = archtosword32(start);
    outsize  = archtosword16(size);

    idxfd->seek(idxoff, SEEK_SET);
    if (len > 0) {
        datfd->seek(start, SEEK_SET);
        datfd->write(outbuf, (int)size);

        // add a new line to make data file easier to read in an editor
        datfd->write(&nl, 1);
        
        idxfd->write(&outstart, 4);
        idxfd->write(&outsize, 2);
        if (idxBytes) {
            idxfd->write(idxBytes, shiftSize);
            delete [] idxBytes;
        }
    }
    else {  // delete entry
        if (idxBytes) {
            idxfd->write(idxBytes+6, shiftSize-6);
            idxfd->seek(-1, SEEK_CUR);  // last valid byte
            FileMgr::getSystemFileMgr()->trunc(idxfd);  // truncate index
            delete [] idxBytes;
        }
    }

    delete [] key;
    delete [] outbuf;
    free(dbKey);
}

signed char RawStr::findOffset	(	const char *	key,
		SW_u32 *	start,
		SW_u16 *	size,
		long	away = 0,
		SW_u32 *	idxoff = 0
	)		const

Definition at line 173 of file rawstr.cpp.

{
    char *trybuf, *maxbuf, *key = 0, quitflag = 0;
    signed char retval = -1;
    long headoff, tailoff, tryoff = 0, maxoff = 0;
    int diff = 0;
    bool awayFromSubstrCheck = false;   

    if (idxfd->getFd() >=0) {
        tailoff = maxoff = idxfd->seek(0, SEEK_END) - 6;
        retval = (tailoff >= 0) ? 0 : -2;   // if NOT new file
        if (*ikey && retval != -2) {
            headoff = 0;

            stdstr(&key, ikey, 3);
            if (!caseSensitive) toupperstr_utf8(key, (unsigned int)(strlen(key)*3));

            int keylen = (int)strlen(key);
            bool substr = false;

            trybuf = maxbuf = 0;
            getIDXBuf(maxoff, &maxbuf);
                        
            while (headoff < tailoff) {
                tryoff = (lastoff == -1) ? headoff + ((((tailoff / 6) - (headoff / 6))) / 2) * 6 : lastoff;
                lastoff = -1;
                getIDXBuf(tryoff, &trybuf);

                if (!*trybuf && tryoff) {       // In case of extra entry at end of idx (not first entry)
                    tryoff += (tryoff > (maxoff / 2))?-6:6;
                    retval = -1;
                    break;
                }

                diff = strcmp(key, trybuf);

                if (!diff)
                    break;

                if (!strncmp(trybuf, key, keylen)) substr = true;

                if (diff < 0)
                    tailoff = (tryoff == headoff) ? headoff : tryoff;
                else headoff = tryoff;

                if (tailoff == headoff + 6) {
                    if (quitflag++)
                        headoff = tailoff;
                }
            }

            // didn't find exact match
            if (headoff >= tailoff) {
                tryoff = headoff;
                if (!substr && ((tryoff != maxoff)||(strncmp(key, maxbuf, keylen)<0))) {
                    awayFromSubstrCheck = true;
                    away--; // if our entry doesn't startwith our key, prefer the previous entry over the next
                }
            }
            if (trybuf)
                free(trybuf);
            delete [] key;
                        if (maxbuf)
                            free(maxbuf);
        }
        else    tryoff = 0;

        idxfd->seek(tryoff, SEEK_SET);

        SW_u32 tmpStart;
        SW_u16 tmpSize;
        *start = *size = tmpStart = tmpSize = 0;
        idxfd->read(&tmpStart, 4);
        idxfd->read(&tmpSize, 2);
        if (idxoff)
            *idxoff = (SW_u32)tryoff;

        *start = swordtoarch32(tmpStart);
        *size  = swordtoarch16(tmpSize);

        while (away) {
            unsigned long laststart = *start;
            unsigned short lastsize = *size;
            long lasttry = tryoff;
            tryoff += (away > 0) ? 6 : -6;
        
            bool bad = false;
            if (((tryoff + (away*6)) < -6) || (tryoff + (away*6) > (maxoff+6)))
                bad = true;
            else if (idxfd->seek(tryoff, SEEK_SET) < 0)
                bad = true;
            if (bad) {
                if(!awayFromSubstrCheck)
                    retval = -1;
                *start = (SW_u32)laststart;
                *size = lastsize;
                tryoff = lasttry;
                if (idxoff)
                    *idxoff = (SW_u32)tryoff;
                break;
            }
            idxfd->read(&tmpStart, 4);
            idxfd->read(&tmpSize, 2);
            if (idxoff)
                *idxoff = (SW_u32)tryoff;

            *start = swordtoarch32(tmpStart);
            *size  = swordtoarch16(tmpSize);

            if (((laststart != *start) || (lastsize != *size)) && (*size))
                away += (away < 0) ? 1 : -1;
        }
    
        lastoff = tryoff;
    }
    else {
        *start = 0;
        *size  = 0;
        if (idxoff)
            *idxoff = 0;
        retval = -1;
    }
    return retval;
}

void RawStr::getIDXBuf	(	long	ioffset,
		char **	buf
	)		const

Definition at line 146 of file rawstr.cpp.

{
    SW_u32 offset;
    
    if (idxfd && idxfd->getFd() >= 0) {
        idxfd->seek(ioffset, SEEK_SET);
        idxfd->read(&offset, 4);

        offset = swordtoarch32(offset);

        getIDXBufDat(offset, buf);
    }
}

void RawStr::getIDXBufDat	(	long	ioffset,
		char **	buf
	)		const

Definition at line 112 of file rawstr.cpp.

{
    int size;
    char ch;
    if (datfd && datfd->getFd() >= 0) {
        datfd->seek(ioffset, SEEK_SET);
        for (size = 0; datfd->read(&ch, 1) == 1; size++) {
            if ((ch == '\\') || (ch == 10) || (ch == 13))
                break;
        }
        *buf = (*buf) ? (char *)realloc(*buf, size*2 + 1) : (char *)malloc(size*2 + 1);
        if (size) {
            datfd->seek(ioffset, SEEK_SET);
            datfd->read(*buf, size);
        }
        (*buf)[size] = 0;
        if (!caseSensitive) toupperstr_utf8(*buf, size*2);
    }
    else {
        *buf = (*buf) ? (char *)realloc(*buf, 1) : (char *)malloc(1);
        **buf = 0;
    }
}

void RawStr::readText	(	SW_u32	start,
		SW_u16 *	size,
		char **	idxbuf,
		SWBuf &	buf
	)		const

Definition at line 309 of file rawstr.cpp.

{
    unsigned int ch;
    char *idxbuflocal = 0;
    getIDXBufDat(istart, &idxbuflocal);
    SW_u32 start = istart;

    do {
        if (*idxbuf)
            delete [] *idxbuf;

        buf = "";
        buf.setFillByte(0);
        buf.setSize(++(*isize));

        *idxbuf = new char [ (*isize) ];

        datfd->seek(start, SEEK_SET);
        datfd->read(buf.getRawData(), (int)((*isize) - 1));

        for (ch = 0; buf[ch]; ch++) {       // skip over index string
            if (buf[ch] == 10) {
                ch++;
                break;
            }
        }
        buf = SWBuf(buf.c_str()+ch);
        // resolve link
        if (!strncmp(buf.c_str(), "@LINK", 5)) {
            for (ch = 0; buf[ch]; ch++) {       // null before nl
                if (buf[ch] == 10) {
                    buf[ch] = 0;
                    break;
                }
            }
            findOffset(buf.c_str() + 6, &start, isize);
        }
        else break;
    }
    while (true);   // while we're resolving links

    if (idxbuflocal) {
        int localsize = (int)strlen(idxbuflocal);
        localsize = (localsize < (*isize - 1)) ? localsize : (*isize - 1);
        strncpy(*idxbuf, idxbuflocal, localsize);
        (*idxbuf)[localsize] = 0;
        free(idxbuflocal);
    }
}

Member Data Documentation

bool RawStr::caseSensitive

private

Definition at line 40 of file rawstr.h.

FileDesc* RawStr::datfd

protected

Definition at line 46 of file rawstr.h.

const int RawStr::IDXENTRYSIZE = 6

staticprotected

Definition at line 49 of file rawstr.h.

FileDesc* RawStr::idxfd

protected

Definition at line 45 of file rawstr.h.

SWORD_NAMESPACE_START int RawStr::instance = 0

staticprivate

Definition at line 38 of file rawstr.h.

long RawStr::lastoff

mutableprivate

Definition at line 41 of file rawstr.h.

const char RawStr::nl = '\n'

static

Definition at line 52 of file rawstr.h.

char* RawStr::path

private

Definition at line 39 of file rawstr.h.

---

The documentation for this class was generated from the following files:

• include/rawstr.h
• src/modules/common/rawstr.cpp