step2vpl.cpp File Reference

#include <iostream>
#include <string>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <io.h>
#include <filemgr.h>
#include <lzsscomprs.h>

Include dependency graph for step2vpl.cpp:

Go to the source code of this file.

Classes
struct	SectionLevelInfo
struct	SectionsHeader
struct	Version
struct	ViewableBlock
struct	ViewableHeader
struct	VSyncBooksInfo
struct	VSyncHeader
struct	VSyncPoint

Functions
void	cleanBuf (char *buf)
void	displayBook (int fdbook, int fdviewable, int fdvsync, int fdsections, VSyncBooksInfo *vSyncBooksInfo)
void	extractVerseText (int fdviewable, int fdbook, SectionLevelInfo *sectionLevelInfo, char **verseText)
int	main (int argc, char **argv)
void	readHeaderControlWordAreaText (int fd, char **buf)
void	readSectionLevelInfo (int fd, SectionLevelInfo *sli)
void	readSectionName (int fd, SectionLevelInfo *sli, char **name)
void	readSectionsHeader (int fd, SectionsHeader *sectionsHeaderRecord)
void	readVersion (int fd, Version *versionRecord)
void	readViewableBlock (int fd, ViewableBlock *vb)
void	readViewableBlockText (int fd, ViewableBlock *vb, char **buf)
void	readViewableHeader (int fd, ViewableHeader *viewableHeaderRecord)
void	readVSyncBooksInfo (int fd, VSyncHeader *, VSyncBooksInfo **vSyncBooksInfo)
void	readVSyncHeader (int fd, VSyncHeader *vSyncHeaderRecord)

Variables
SWCompress *	compress = 0
long	SECTIONSLEVELSIZE = 29
long	SECTIONSLEVELSTART = 38
long	VIEWABLEBLOCKSIZE = 0
long	VIEWABLEBLOCKSTART = 0

Function Documentation

void cleanBuf

(

char *

buf

)

Definition at line 443 of file step2vpl.cpp.

                         {
    char *from = buf;
    char *to = buf;

    while (*from) {
        if ((*from != 10) && (*from != 13)) {
            *to++ = *from++;
        }
        else {
            from++;
        }
    }
    *to = 0;
}

void displayBook	(	int	fdbook,
		int	fdviewable,
		int	fdvsync,
		int	fdsections,
		VSyncBooksInfo *	vSyncBooksInfo
	)

Definition at line 353 of file step2vpl.cpp.

                                                                                                          {
    VSyncPoint vSyncPoint;

    lseek(fdvsync, vSyncBooksInfo->offset, SEEK_SET);

    for (int i = 0; i < vSyncBooksInfo->count; i++) {

        SectionLevelInfo sectionLevelInfo;
        char *sectionName;
        char *verseText;

        read(fdvsync, &(vSyncPoint.chapter), 2);
        read(fdvsync, &(vSyncPoint.verse), 2);
        read(fdvsync, &(vSyncPoint.offset), 4);
        vSyncPoint.offset = SECTIONSLEVELSTART + (vSyncPoint.offset * SECTIONSLEVELSIZE);
        lseek(fdsections, vSyncPoint.offset, SEEK_SET);
        readSectionLevelInfo(fdsections, &sectionLevelInfo);
        readSectionName(fdsections, &sectionLevelInfo, &sectionName);
        cout << sectionName << " ";
        delete [] sectionName;
        extractVerseText(fdviewable, fdbook, &sectionLevelInfo, &verseText);
        cleanBuf(verseText);
        cout << verseText << "\n";
        delete [] verseText;
    }
}

void extractVerseText	(	int	fdviewable,
		int	fdbook,
		SectionLevelInfo *	sectionLevelInfo,
		char **	verseText
	)

Definition at line 381 of file step2vpl.cpp.

                                                                                                        {
    char numberBuf[16];
    string startToken;
    ViewableBlock vb;
    int len = 0;
    static long lastEntryOffset = -1;
    static class FreeCachedEntryText {
    public:
        char *entryText;
        FreeCachedEntryText() { entryText = 0; }
        ~FreeCachedEntryText() { if (entryText) delete [] entryText; }
    } _freeCachedEntryText;

    if (sectionLevelInfo->viewableOffset != lastEntryOffset) {
        if (_freeCachedEntryText.entryText)
            delete [] _freeCachedEntryText.entryText;
    
        lseek(fdviewable, sectionLevelInfo->viewableOffset, SEEK_SET);
        readViewableBlock(fdviewable, &vb);
        readViewableBlockText(fdbook, &vb, &(_freeCachedEntryText.entryText));
        lastEntryOffset = sectionLevelInfo->viewableOffset;
    }
    sprintf(numberBuf, "%d", sectionLevelInfo->startLevel);
    startToken = "\\stepstartlevel";
    startToken += numberBuf;
    char *start = strstr(_freeCachedEntryText.entryText, startToken.c_str());
    if (start) {
        start += strlen(startToken.c_str());
        char *end = strstr(start, "\\stepstartlevel");
        if (end)
            len = end - start;
        else len = strlen(start);
    }
    *verseText = new char [ len + 1 ];
    strncpy(*verseText, start, len);
    (*verseText)[len] = 0;
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 142 of file step2vpl.cpp.

                                {

    compress = new LZSSCompress();
    char *buf;
    Version versionRecord;
    VSyncHeader vSyncHeaderRecord;
    VSyncBooksInfo *vSyncBooksInfo;
    SectionsHeader sectionsHeaderRecord;
    ViewableHeader viewableHeaderRecord;
    

    if (argc < 2) {
        cerr << "usage: "<< *argv << " <database to step module>\n";
        exit (-1);
    }

    string bookpath = argv[1];
    string fileName;

    if ((argv[1][strlen(argv[1])-1] != '/') &&
        (argv[1][strlen(argv[1])-1] != '\\'))
        bookpath += "/";

    fileName = bookpath + "Book.dat";
    int fdbook = FileMgr::openFileReadOnly(fileName.c_str());

    if (fdbook < 1) {
        cerr << "error, couldn't open file: " << fileName << "\n";
        exit (-2);
    }

    readVersion(fdbook, &versionRecord);
    readHeaderControlWordAreaText(fdbook, &buf);
    delete [] buf;


    fileName = bookpath + "Viewable.idx";
    int fdviewable = FileMgr::openFileReadOnly(fileName.c_str());

    if (fdviewable < 1) {
        cerr << "error, couldn't open file: " << fileName << "\n";
        exit (-3);
    }

    readVersion(fdviewable, &versionRecord);
    readViewableHeader(fdviewable, &viewableHeaderRecord);

    VIEWABLEBLOCKSTART = lseek(fdviewable, 0, SEEK_CUR);
    VIEWABLEBLOCKSIZE = viewableHeaderRecord.blockEntriesSize;


    fileName = bookpath + "Vsync.idx";
    int fdvsync = FileMgr::openFileReadOnly(fileName.c_str());

    if (fdvsync < 1) {
        cerr << "error, couldn't open file: " << fileName << "\n";
        exit (-4);
    }

    fileName = bookpath + "Sections.idx";
    int fdsections = FileMgr::openFileReadOnly(fileName.c_str());

    if (fdsections < 1) {
        cerr << "error, couldn't open file: " << fileName << "\n";
        exit (-4);
    }
    readVersion(fdsections, &versionRecord);
    readSectionsHeader(fdsections, &sectionsHeaderRecord);
    SECTIONSLEVELSTART = lseek(fdsections, 0, SEEK_CUR);
    SECTIONSLEVELSIZE = sectionsHeaderRecord.levelEntriesSize;

    readVersion(fdvsync, &versionRecord);
    readVSyncHeader(fdvsync, &vSyncHeaderRecord);
    readVSyncBooksInfo(fdvsync, &vSyncHeaderRecord, &vSyncBooksInfo);
    int bookCount = vSyncHeaderRecord.endBookNumber - vSyncHeaderRecord.startBookNumber;
    for (int i = 0; i <= bookCount; i++) {
        displayBook(fdbook, fdviewable, fdvsync, fdsections, &vSyncBooksInfo[i]);
    }
        
    close(fdviewable);
    close(fdvsync);
    close(fdsections);
    close(fdbook);

}

void readHeaderControlWordAreaText	(	int	fd,
		char **	buf
	)

Definition at line 332 of file step2vpl.cpp.

                                                       {
    long headerControlWordAreaSize;
    read(fd, &headerControlWordAreaSize, 4);

    *buf = new char [headerControlWordAreaSize + 1];

    read(fd, *buf, headerControlWordAreaSize);
    (*buf)[headerControlWordAreaSize] = 0;

}

void readSectionLevelInfo	(	int	fd,
		SectionLevelInfo *	sli
	)

Definition at line 429 of file step2vpl.cpp.

                                                         {

    read(fd, &(sli->parentOffset), 4);
    read(fd, &(sli->previousOffset), 4);
    read(fd, &(sli->nextOffset), 4);
    read(fd, &(sli->viewableOffset), 4);
    sli->viewableOffset = VIEWABLEBLOCKSTART + (VIEWABLEBLOCKSIZE * sli->viewableOffset);
    read(fd, &(sli->startLevel), 2);
    read(fd, &(sli->level), 1);
    read(fd, &(sli->nameOffset), 4);
    read(fd, &(sli->outSync_1), 4);
    read(fd, &(sli->outSync_2), 2);
}

void readSectionName	(	int	fd,
		SectionLevelInfo *	sli,
		char **	name
	)

Definition at line 420 of file step2vpl.cpp.

                                                                 {
    short size;
    lseek(fd, sli->nameOffset, SEEK_SET);
    read(fd, &size, 2);
    *name = new char [ size + 1 ];
    read(fd, *name, size);
    (*name)[size] = 0;
}

void readSectionsHeader	(	int	fd,
		SectionsHeader *	sectionsHeaderRecord
	)

Definition at line 254 of file step2vpl.cpp.

                                                                      {

    read(fd, &(sectionsHeaderRecord->sectionsHeaderRecordSize), 2);
    read(fd, &(sectionsHeaderRecord->levelEntriesCount), 4);
    read(fd, &(sectionsHeaderRecord->glossEntriesCount), 4);
    read(fd, &(sectionsHeaderRecord->levelEntriesSize), 2);
    read(fd, &(sectionsHeaderRecord->reserved), 4);

    int skip = sectionsHeaderRecord->sectionsHeaderRecordSize - 16/*sizeof(struct ViewableHeader)*/;

    if (skip) {
        char *skipbuf = new char[skip];
        read(fd, skipbuf, skip);
        delete [] skipbuf;
    }
}

void readVersion	(	int	fd,
		Version *	versionRecord
	)

Definition at line 230 of file step2vpl.cpp.

                                                 {

    read(fd, &(versionRecord->versionRecordSize), 2);
    read(fd, &(versionRecord->publisherID), 2);
    read(fd, &(versionRecord->bookID), 2);
    read(fd, &(versionRecord->setID), 2);
    read(fd, &(versionRecord->conversionProgramVerMajor), 1);
    read(fd, &(versionRecord->conversionProgramVerMinor), 1);
    read(fd, &(versionRecord->leastCompatSTEPVerMajor), 1);
    read(fd, &(versionRecord->leastCompatSTEPVerMinor), 1);
    read(fd, &(versionRecord->encryptionType), 1);
    read(fd, &(versionRecord->editionID), 1);
    read(fd, &(versionRecord->modifiedBy), 2);

    int skip = versionRecord->versionRecordSize - 16/*sizeof(struct Version*/;

    if (skip) {
        char *skipbuf = new char[skip];
        read(fd, skipbuf, skip);
        delete [] skipbuf;
    }
}

void readViewableBlock	(	int	fd,
		ViewableBlock *	vb
	)

Definition at line 324 of file step2vpl.cpp.

                                                  {

    read(fd, &(vb->offset), 4);
    read(fd, &(vb->uncompressedSize), 4);
    read(fd, &(vb->size), 4);
}

void readViewableBlockText	(	int	fd,
		ViewableBlock *	vb,
		char **	buf
	)

Definition at line 312 of file step2vpl.cpp.

                                                                  {
    unsigned long size = vb->size;

    *buf = new char [ ((vb->size > vb->uncompressedSize) ? vb->size : vb->uncompressedSize) + 1 ];
    lseek(fd, vb->offset, SEEK_SET);
    read(fd, *buf, vb->size);

    compress->setCompressedBuf(&size, *buf);
    strcpy(*buf, compress->getUncompressedBuf());
}

void readViewableHeader	(	int	fd,
		ViewableHeader *	viewableHeaderRecord
	)

Definition at line 272 of file step2vpl.cpp.

                                                                      {

    read(fd, &(viewableHeaderRecord->viewableHeaderRecordSize), 2);
    read(fd, &(viewableHeaderRecord->viewableBlocksCount), 4);
    read(fd, &(viewableHeaderRecord->glossBlocksCount), 4);
    read(fd, &(viewableHeaderRecord->compressionType), 1);
    read(fd, &(viewableHeaderRecord->reserved1), 1);
    read(fd, &(viewableHeaderRecord->blockEntriesSize), 2);
    read(fd, &(viewableHeaderRecord->reserved2), 2);

    int skip = viewableHeaderRecord->viewableHeaderRecordSize - 16/*sizeof(struct ViewableHeader)*/;

    if (skip) {
        char *skipbuf = new char[skip];
        read(fd, skipbuf, skip);
        delete [] skipbuf;
    }
}

void readVSyncBooksInfo	(	int	fd,
		VSyncHeader *	vSyncHeaderRecord,
		VSyncBooksInfo **	vSyncBooksInfo
	)

Definition at line 343 of file step2vpl.cpp.

                                                                                                 {

    int bookCount = vSyncHeaderRecord->endBookNumber - vSyncHeaderRecord->startBookNumber;
    *vSyncBooksInfo = new VSyncBooksInfo[bookCount];
    for (int i = 0; i <= bookCount; i++) {
        read(fd, &(*vSyncBooksInfo)[i].offset, 4);
        read(fd, &(*vSyncBooksInfo)[i].count, 2);
    }
}

void readVSyncHeader	(	int	fd,
		VSyncHeader *	vSyncHeaderRecord
	)

Definition at line 292 of file step2vpl.cpp.

                                                             {

    read(fd, &(vSyncHeaderRecord->vSyncHeaderRecordSize), 2);
    read(fd, &(vSyncHeaderRecord->startBookNumber), 2);
    read(fd, &(vSyncHeaderRecord->endBookNumber), 2);
    read(fd, &(vSyncHeaderRecord->bookPointerEntriesSize), 2);
    read(fd, &(vSyncHeaderRecord->syncPointEntriesSize), 2);
    read(fd, &(vSyncHeaderRecord->reserved1_1), 4);
    read(fd, &(vSyncHeaderRecord->reserved1_2), 2);

    int skip = vSyncHeaderRecord->vSyncHeaderRecordSize - 16/*sizeof(VSyncHeader)*/;

    if (skip) {
        char *skipbuf = new char[skip];
        read(fd, skipbuf, skip);
        delete [] skipbuf;
    }
}

Variable Documentation

SWCompress* compress = 0

Definition at line 140 of file step2vpl.cpp.

long SECTIONSLEVELSIZE = 29

Definition at line 50 of file step2vpl.cpp.

long SECTIONSLEVELSTART = 38

Definition at line 49 of file step2vpl.cpp.

long VIEWABLEBLOCKSIZE = 0

Definition at line 53 of file step2vpl.cpp.

long VIEWABLEBLOCKSTART = 0

Definition at line 52 of file step2vpl.cpp.