Ok...corrected a problem with new block allocation in nids, and it no longer

goes into an infinite loop while doing certain kinds of read.  Also, it zeros
out new blocks to make things easier to cope with in the hex editor, it'll
probably also compress better.

I also fixed Bu::MemBuf so that you can now write to arbitrary places
mid-stream.

1 files changed, 74 insertions, 41 deletions

diff --git a/src/nids.cpp b/src/nids.cpp
index a6596a2..06895ac 100644
--- a/src/nids.cpp
+++ b/src/nids.cpp
@@ -1,3 +1,10 @@
+/*
+ * Copyright (C) 2007-2008 Xagasoft, All rights reserved.
+ *
+ * This file is part of the libbu++ library and is released under the
+ * terms of the license contained in the file LICENSE.
+ */
+
 #include "bu/nids.h"
 #include "bu/stream.h"
 #include "bu/nidsstream.h"
@@ -16,30 +23,6 @@ Bu::Nids::Nids( Bu::Stream &sStore ) :
         iBlocks( 0 ),
         iBlockStart( -1 )
 {
-        printf("blockUnused = %u\n", blockUnused );
-        printf("Stream caps:\n"
-                "  canRead:    %s\n"
-                "  canWrite:   %s\n"
-                "  isReadable: %s\n"
-                "  isWritable: %s\n"
-                "  isSeekable: %s\n"
-                "  isBlocking: %s\n"
-                "  isEOS:      %s\n"
-                "  isOpen:     %s\n",
-                sStore.canRead()?"yes":"no",
-                sStore.canWrite()?"yes":"no",
-                sStore.isReadable()?"yes":"no",
-                sStore.isWritable()?"yes":"no",
-                sStore.isSeekable()?"yes":"no",
-                sStore.isBlocking()?"yes":"no",
-                sStore.isEOS()?"yes":"no",
-                sStore.isOpen()?"yes":"no"
-                );
-        printf("sizeof(Block) = %db\n", sizeof(Block) );
-        printf("Magic:  %02X%02X%02X%02X\n",
-                NIDS_MAGIC_CODE[0], NIDS_MAGIC_CODE[1],
-                NIDS_MAGIC_CODE[2], NIDS_MAGIC_CODE[3]
-                );
 }
 
 Bu::Nids::~Nids()
@@ -49,6 +32,7 @@ Bu::Nids::~Nids()
 void Bu::Nids::initialize()
 {
         unsigned char buf[4];
+        int iUsed;
         if( sStore.read( buf, 4 ) < 4 )
                 throw NidsException("Input stream appears to be empty.");
         if( memcmp( buf, NIDS_MAGIC_CODE, 4 ) )
@@ -56,8 +40,31 @@ void Bu::Nids::initialize()
                 throw NidsException(
                         "Stream does not appear to be a valid NIDS format.");
         }
-
-
+        sStore.read( buf, 2 );
+        if( buf[0] != 0 )
+                throw NidsException(
+                        "We can only handle version 0 for now.");
+        if( buf[1] != 4 )
+                throw NidsException(
+                        "We can only handle 4-byte words at the moment.");
+        sStore.read( &iBlockSize, 4 );
+        sStore.read( &iBlocks, 4 );
+        sStore.read( &iUsed, 4 ); // number of used blocks...
+        sStore.seek( 7 ); // skip reserved space.
+        iBlockStart = sStore.tell();
+
+        //printf("%d blocks, %db each, %db block offset\n",
+        //      iBlocks, iBlockSize, iBlockStart );
+
+        bsBlockUsed.setSize( iBlocks, true );
+        Block bTmp;
+        for( int j = 0; j < iBlocks; j++ )
+        {
+                sStore.seek( iBlockStart+iBlockSize*j );
+                sStore.read( &bTmp, sizeof(bTmp) );
+                if( bTmp.uFirstBlock != blockUnused )
+                        bsBlockUsed.setBit( j );
+        }
 }
 
 void Bu::Nids::initialize( int iBlockSize, int iPreAllocate )
@@ -88,11 +95,11 @@ void Bu::Nids::initialize( int iBlockSize, int iPreAllocate )
         this->iBlockSize = iBlockSize;
         this->iBlocks = iPreAllocate;
         this->iBlockStart = sStore.tell();
-        printf("iBlockStart = %d\n", this->iBlockStart );
+        //printf("iBlockStart = %d\n", this->iBlockStart );
         bsBlockUsed.setSize( iPreAllocate, true );
 
-        printf("%d blocks, %db each, %db block offset\n",
-                iBlocks, iBlockSize, iBlockStart );
+        //printf("%d blocks, %db each, %db block offset\n",
+        //      iBlocks, iBlockSize, iBlockStart );
 
         Block *block = (Block *)new char[iBlockSize];
         memset( block, 0, iBlockSize );
@@ -104,6 +111,26 @@ void Bu::Nids::initialize( int iBlockSize, int iPreAllocate )
         delete[] (char *)block;
 }
 
+void Bu::Nids::initBlock( uint32_t uPos, uint32_t uFirstBlock,
+        uint32_t uPrevBlock, bool bNew )
+{
+        Block b = { uPos, blockUnused, uPrevBlock, 0, 0, { } };
+        if( uFirstBlock != blockUnused )
+                b.uFirstBlock = uFirstBlock;
+        bsBlockUsed.setBit( uPos );
+        sStore.setPos( iBlockStart+(iBlockSize*uPos) );
+        sStore.write( &b, sizeof(Block) );
+        if( bNew )
+        {
+                // It's a new one, at the end, write some zeros.
+                int iSize = iBlockSize-sizeof(Block);
+                char *buf = new char[iSize];
+                memset( buf, 0, iSize );
+                sStore.write( buf, iSize );
+                delete[] buf;
+        }
+}
+
 uint32_t Bu::Nids::createBlock( uint32_t uFirstBlock, uint32_t uPrevBlock,
         int /*iPreAllocate*/ )
 {
@@ -111,16 +138,15 @@ uint32_t Bu::Nids::createBlock( uint32_t uFirstBlock, uint32_t uPrevBlock,
         {
                 if( !bsBlockUsed.getBit( j ) )
                 {
-                        Block b = { j, blockUnused, uPrevBlock, 0, 0, { } };
-                        if( uFirstBlock != blockUnused )
-                                b.uFirstBlock = uFirstBlock;
-                        bsBlockUsed.setBit( j );
-                        sStore.setPos( iBlockStart+(iBlockSize*j) );
-                        sStore.write( &b, sizeof(b) );
+                        initBlock( j, uFirstBlock, uPrevBlock );
                         return j;
                 }
         }
-        return blockUnused;
+        // Oh, we don't have any blocks left...allocate a new one.
+        iBlocks++;
+        bsBlockUsed.setSize( iBlocks, false );
+        initBlock( iBlocks-1, uFirstBlock, uPrevBlock, true );
+        return iBlocks-1;
 }
 
 int Bu::Nids::createStream( int iPreAllocate )
@@ -169,15 +195,22 @@ void Bu::Nids::updateStreamSize( uint32_t uIndex, uint32_t uSize )
 }
 
 uint32_t Bu::Nids::getNextBlock( uint32_t uIndex,
-        struct Bu::Nids::Block *pBlock )
+        struct Bu::Nids::Block *pBlock, bool bCreate )
 {
         uint32_t uNew;
         if( pBlock->uNextBlock == blockUnused )
         {
-                uNew = createBlock( pBlock->uFirstBlock, uIndex );
-                sStore.setPos( iBlockStart + (iBlockSize*uIndex)+1*4 );
-                sStore.write( &uNew, 4 );
-                getBlock( uNew, pBlock );
+                if( bCreate )
+                {
+                        uNew = createBlock( pBlock->uFirstBlock, uIndex );
+                        sStore.setPos( iBlockStart + (iBlockSize*uIndex)+1*4 );
+                        sStore.write( &uNew, 4 );
+                        getBlock( uNew, pBlock );
+                }
+                else
+                {
+                        throw Bu::NidsException("Reached end of stream.");
+                }
         }
         else
         {