1 files changed, 539 insertions, 539 deletions

diff --git a/src/unstable/myriadfs.cpp b/src/unstable/myriadfs.cpp
index 6ed176d..3680c3f 100644
--- a/src/unstable/myriadfs.cpp
+++ b/src/unstable/myriadfs.cpp
@@ -19,686 +19,686 @@ using Bu::Fmt;
 
 namespace Bu { subExceptionDef( MyriadFsException ) }
 
-#define Myriad_Fs_MAGIC_CODE            ((char *)"\xa7\x18\x8b\x39")
+#define Myriad_Fs_MAGIC_CODE        ((char *)"\xa7\x18\x8b\x39")
 
 Bu::MyriadFs::MyriadFs( Bu::Stream &rStore, int iBlockSize ) :
-        rStore( rStore ),
-        mStore( rStore, iBlockSize ),
-        iUser( 0 ),
-        iGroup( 0 )
+    rStore( rStore ),
+    mStore( rStore, iBlockSize ),
+    iUser( 0 ),
+    iGroup( 0 )
 {
 #ifndef WIN32
-        iUser = getuid();
-        iGroup = getgid();
+    iUser = getuid();
+    iGroup = getgid();
 #endif
 
-        if( mStore.hasStream( 1 ) )
-        {
-                // Check to see if this is a MyriadFs stream.
-                Bu::MyriadStream ms = mStore.openStream( 1 );
-                char sMagic[4];
-                if( ms.read( sMagic, 4 ) < 4 )
-                        throw MyriadFsException("The provided stream does not appear to be "
-                                "a MyriadFs stream.");
-                if( ::strncmp( sMagic, Myriad_Fs_MAGIC_CODE, 4 ) )
-                        throw MyriadFsException("The provided stream does not appear to be "
-                                "a MyriadFs stream.");
-        
-                int8_t iVer;
-                ms.read( &iVer, 1 );
-
-                int32_t iNumNodes;
-                ms.read( &iNumNodes, 4 );
-                for( int32_t j = 0; j < iNumNodes; j++ )
-                {
-                        int32_t iNode;
-                        int32_t iPos;
-                        ms.read( &iNode, 4 );
-                        ms.read( &iPos, 4 );
-                        hNodeIndex.insert( iNode, iPos );
-                }
-        }
-        else
-        {
-                // Create initial header stream
-                {
-                        mStore.createStream( 1 );
-                        Bu::MyriadStream ms = mStore.openStream( 1 );
-                        ms.write( Myriad_Fs_MAGIC_CODE, 4 );
-                        int8_t iVer = 1;
-                        int32_t iTmp = 1;
-                        ms.write( &iVer, 1 );
-                        ms.write( &iTmp, 4 ); // iNumNodes
-                        iTmp = 0;
-                        ms.write( &iTmp, 4 ); // iInode
-                        ms.write( &iTmp, 4 ); // iPosition
-                        hNodeIndex.insert( 0, 0 );
-                }
-
-                // Create initial inode stream, with one root node.
-                {
-                        mStore.createStream( 2 );
-                        Bu::MyriadStream ms = mStore.openStream( 2 );
-                        RawStat rs;
-                        rs.iNode = 0;
-                        rs.iUser = iUser;
-                        rs.iGroup = iGroup;
-                        rs.uPerms = 0755|typeDir;
-                        rs.iLinks = 1;
-                        rs.uStreamIndex = 3;
-                        rs.iCTime = rs.iMTime = rs.iATime = time(NULL);
-                        ms.write( &rs, sizeof(RawStat) );
-                }
-
-                // Create inode 0's storage stream.
-                {
-                        mStore.createStream( 3 );
-                        Bu::MyriadStream ms = mStore.openStream( 3 );
-                        int32_t iTmp32 = 0;
-                        ms.write( &iTmp32, 4 );         // iChildCount
-                }
-        }
+    if( mStore.hasStream( 1 ) )
+    {
+        // Check to see if this is a MyriadFs stream.
+        Bu::MyriadStream ms = mStore.openStream( 1 );
+        char sMagic[4];
+        if( ms.read( sMagic, 4 ) < 4 )
+            throw MyriadFsException("The provided stream does not appear to be "
+                "a MyriadFs stream.");
+        if( ::strncmp( sMagic, Myriad_Fs_MAGIC_CODE, 4 ) )
+            throw MyriadFsException("The provided stream does not appear to be "
+                "a MyriadFs stream.");
+    
+        int8_t iVer;
+        ms.read( &iVer, 1 );
+
+        int32_t iNumNodes;
+        ms.read( &iNumNodes, 4 );
+        for( int32_t j = 0; j < iNumNodes; j++ )
+        {
+            int32_t iNode;
+            int32_t iPos;
+            ms.read( &iNode, 4 );
+            ms.read( &iPos, 4 );
+            hNodeIndex.insert( iNode, iPos );
+        }
+    }
+    else
+    {
+        // Create initial header stream
+        {
+            mStore.createStream( 1 );
+            Bu::MyriadStream ms = mStore.openStream( 1 );
+            ms.write( Myriad_Fs_MAGIC_CODE, 4 );
+            int8_t iVer = 1;
+            int32_t iTmp = 1;
+            ms.write( &iVer, 1 );
+            ms.write( &iTmp, 4 ); // iNumNodes
+            iTmp = 0;
+            ms.write( &iTmp, 4 ); // iInode
+            ms.write( &iTmp, 4 ); // iPosition
+            hNodeIndex.insert( 0, 0 );
+        }
+
+        // Create initial inode stream, with one root node.
+        {
+            mStore.createStream( 2 );
+            Bu::MyriadStream ms = mStore.openStream( 2 );
+            RawStat rs;
+            rs.iNode = 0;
+            rs.iUser = iUser;
+            rs.iGroup = iGroup;
+            rs.uPerms = 0755|typeDir;
+            rs.iLinks = 1;
+            rs.uStreamIndex = 3;
+            rs.iCTime = rs.iMTime = rs.iATime = time(NULL);
+            ms.write( &rs, sizeof(RawStat) );
+        }
+
+        // Create inode 0's storage stream.
+        {
+            mStore.createStream( 3 );
+            Bu::MyriadStream ms = mStore.openStream( 3 );
+            int32_t iTmp32 = 0;
+            ms.write( &iTmp32, 4 );     // iChildCount
+        }
+    }
 }
 
 Bu::MyriadFs::~MyriadFs()
 {
-        writeHeader();
+    writeHeader();
 }
 
 void Bu::MyriadFs::stat( const Bu::String &sPath, Bu::MyriadFs::Stat &rBuf )
 {
-        int32_t iParent;
-        int32_t iNode = lookupInode( sPath, iParent );
-        Bu::MyriadStream is = mStore.openStream( 2 );
-        stat( iNode, rBuf, is );
+    int32_t iParent;
+    int32_t iNode = lookupInode( sPath, iParent );
+    Bu::MyriadStream is = mStore.openStream( 2 );
+    stat( iNode, rBuf, is );
 }
 
 Bu::MyriadStream Bu::MyriadFs::open( const Bu::String &sPath, int /*iMode*/,
-                uint16_t uPerms )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        try
-        {
-                iNode = lookupInode( sPath, iParent );
-                sio << "File found." << sio.nl;
-                // The file was found
-                return openByInode( iNode );
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                iNode = create( iParent, sName, (uPerms&permMask)|typeRegFile, 0 );
-                sio << "New iNode: " << iNode << sio.nl;
-                return openByInode( iNode );
-        }
+        uint16_t uPerms )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    try
+    {
+        iNode = lookupInode( sPath, iParent );
+        sio << "File found." << sio.nl;
+        // The file was found
+        return openByInode( iNode );
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        iNode = create( iParent, sName, (uPerms&permMask)|typeRegFile, 0 );
+        sio << "New iNode: " << iNode << sio.nl;
+        return openByInode( iNode );
+    }
 }
 
 void Bu::MyriadFs::create( const Bu::String &sPath, uint16_t iPerms )
 {
-        create( sPath, iPerms, 0 );
+    create( sPath, iPerms, 0 );
 }
 
 void Bu::MyriadFs::create( const Bu::String &sPath, uint16_t iPerms,
-                uint16_t iDevHi, uint16_t iDevLo )
+        uint16_t iDevHi, uint16_t iDevLo )
 {
-        create( sPath, iPerms, ((uint32_t)iDevHi<<16)|(uint32_t)iDevLo );
+    create( sPath, iPerms, ((uint32_t)iDevHi<<16)|(uint32_t)iDevLo );
 }
 
 void Bu::MyriadFs::create( const Bu::String &sPath, uint16_t iPerms,
-                uint32_t uSpecial )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        try
-        {
-                iNode = lookupInode( sPath, iParent );
-                sio << "File found." << sio.nl;
-                // The file was found
-                throw Bu::MyriadFsException("Path already exists.");
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                iNode = create( iParent, sName, iPerms, uSpecial );
-                sio << "New iNode: " << iNode << sio.nl;
-        }
+        uint32_t uSpecial )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    try
+    {
+        iNode = lookupInode( sPath, iParent );
+        sio << "File found." << sio.nl;
+        // The file was found
+        throw Bu::MyriadFsException("Path already exists.");
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        iNode = create( iParent, sName, iPerms, uSpecial );
+        sio << "New iNode: " << iNode << sio.nl;
+    }
 }
 
 void Bu::MyriadFs::mkDir( const Bu::String &sPath, uint16_t iPerms )
 {
-        create( sPath, (iPerms&permMask)|typeDir, 0 );
+    create( sPath, (iPerms&permMask)|typeDir, 0 );
 }
 
 void Bu::MyriadFs::mkSymLink( const Bu::String &sTarget,
-                const Bu::String &sPath )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        try
-        {
-                iNode = lookupInode( sPath, iParent );
-                throw Bu::MyriadFsException("Path already exists.");
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                iNode = create( iParent, sName, 0777|typeSymLink, 0 );
-                sio << "New iNode: " << iNode << sio.nl;
-                MyriadStream ms = openByInode( iNode );
-                ms.write( sTarget );
-        }
+        const Bu::String &sPath )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    try
+    {
+        iNode = lookupInode( sPath, iParent );
+        throw Bu::MyriadFsException("Path already exists.");
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        iNode = create( iParent, sName, 0777|typeSymLink, 0 );
+        sio << "New iNode: " << iNode << sio.nl;
+        MyriadStream ms = openByInode( iNode );
+        ms.write( sTarget );
+    }
 }
 
 void Bu::MyriadFs::mkHardLink( const Bu::String &sTarget,
-                const Bu::String &sPath )
-{
-        int32_t iParent = -1;
-        int32_t iNode;
-        
-        iNode = lookupInode( sTarget, iParent );
-
-        try
-        {
-                lookupInode( sPath, iParent );
-                throw Bu::MyriadFsException("Path already exists.");
-        }
-        catch( Bu::MyriadFsException &e )
-        {
-                if( iParent < 0 )
-                        throw;
-
-                // This means that an intermediate path component couldn't be found
-                if( e.getErrorCode() == 1 )
-                        throw;
-
-                // The file wasn't found, but the path leading up to it was.
-                // first, figure out the final path element...
-                Bu::String sName = filePart( sPath );
-                sio << "End filename: " << sName << sio.nl;
-                sio << "Parent inode: " << iParent << sio.nl;
-                addToDir( iParent, iNode, sName );
-                MyriadStream is = mStore.openStream( 2 );
-                RawStat rs;
-                readInode( iNode, rs, is );
-                rs.iLinks++;
-                writeInode( rs, is );
-        }
+        const Bu::String &sPath )
+{
+    int32_t iParent = -1;
+    int32_t iNode;
+    
+    iNode = lookupInode( sTarget, iParent );
+
+    try
+    {
+        lookupInode( sPath, iParent );
+        throw Bu::MyriadFsException("Path already exists.");
+    }
+    catch( Bu::MyriadFsException &e )
+    {
+        if( iParent < 0 )
+            throw;
+
+        // This means that an intermediate path component couldn't be found
+        if( e.getErrorCode() == 1 )
+            throw;
+
+        // The file wasn't found, but the path leading up to it was.
+        // first, figure out the final path element...
+        Bu::String sName = filePart( sPath );
+        sio << "End filename: " << sName << sio.nl;
+        sio << "Parent inode: " << iParent << sio.nl;
+        addToDir( iParent, iNode, sName );
+        MyriadStream is = mStore.openStream( 2 );
+        RawStat rs;
+        readInode( iNode, rs, is );
+        rs.iLinks++;
+        writeInode( rs, is );
+    }
 }
 
 Bu::String Bu::MyriadFs::readSymLink( const Bu::String &sPath )
 {
-        int32_t iParent = -1;
-        int32_t iNode;
-        iNode = lookupInode( sPath, iParent );
-        MyriadStream ms = openByInode( iNode );
-        Bu::String sRet;
-        sRet.setSize( ms.getSize() );
-        ms.read( sRet.getStr(), ms.getSize() );
-        return sRet;
+    int32_t iParent = -1;
+    int32_t iNode;
+    iNode = lookupInode( sPath, iParent );
+    MyriadStream ms = openByInode( iNode );
+    Bu::String sRet;
+    sRet.setSize( ms.getSize() );
+    ms.read( sRet.getStr(), ms.getSize() );
+    return sRet;
 }
 
 Bu::MyriadFs::Dir Bu::MyriadFs::readDir( const Bu::String &sPath )
 {
-        int32_t iParent = -1;
-        int32_t iNode = lookupInode( sPath, iParent );
-        return readDir( iNode );
+    int32_t iParent = -1;
+    int32_t iNode = lookupInode( sPath, iParent );
+    return readDir( iNode );
 }
 
 void Bu::MyriadFs::setTimes( const Bu::String &sPath, int64_t iATime,
-                int64_t iMTime )
+        int64_t iMTime )
 {
-        int32_t iParent = -1;
-        int32_t iNode;
+    int32_t iParent = -1;
+    int32_t iNode;
 
-        iNode = lookupInode( sPath, iParent );
-        
-        setTimes( iNode, iATime, iMTime );
+    iNode = lookupInode( sPath, iParent );
+    
+    setTimes( iNode, iATime, iMTime );
 }
 
 void Bu::MyriadFs::unlink( const Bu::String &sPath )
 {
-        int32_t iParent = -1;
-//      int32_t iNode;
-
-        /*iNode =*/ lookupInode( sPath, iParent );
-
-        Dir lDir = readDir( iParent );
-
-        Bu::String sName = filePart( sPath );
-
-        for( Dir::iterator i = lDir.begin(); i; i++ )
-        {
-                if( sName == (*i).sName )
-                {
-                        RawStat rs;
-                        readInode( (*i).iNode, rs );
-                        if( (rs.uPerms&typeMask) == typeDir )
-                        {
-                                MyriadStream msDir = mStore.openStream( rs.uStreamIndex );
-                                int32_t iCount;
-                                msDir.read( &iCount, 4 );
-                                if( iCount > 0 )
-                                {
-                                        throw Bu::MyriadFsException("Directory not empty.");
-                                }
-                        }
-                        if( --rs.iLinks == 0 )
-                        {
-                                destroyNode( (*i).iNode );
-                        }
-                        else
-                        {
-                                writeInode( rs );
-                        }
-                        lDir.erase( i );
-                        break;
-                }
-        }
-        
-        Bu::MyriadStream ms = openByInode( iParent );
-        int32_t iNumChildren = lDir.getSize();
-        ms.write( &iNumChildren, 4 );
-        for( Dir::iterator i = lDir.begin(); i; i++ )
-        {
-                ms.write( &(*i).iNode, 4 );
-                uint8_t iSize = (*i).sName.getSize();
-                ms.write( &iSize, 1 );
-                ms.write( (*i).sName.getStr(), iSize );
-        }
-        ms.setSize( ms.tell() );
+    int32_t iParent = -1;
+//  int32_t iNode;
+
+    /*iNode =*/ lookupInode( sPath, iParent );
+
+    Dir lDir = readDir( iParent );
+
+    Bu::String sName = filePart( sPath );
+
+    for( Dir::iterator i = lDir.begin(); i; i++ )
+    {
+        if( sName == (*i).sName )
+        {
+            RawStat rs;
+            readInode( (*i).iNode, rs );
+            if( (rs.uPerms&typeMask) == typeDir )
+            {
+                MyriadStream msDir = mStore.openStream( rs.uStreamIndex );
+                int32_t iCount;
+                msDir.read( &iCount, 4 );
+                if( iCount > 0 )
+                {
+                    throw Bu::MyriadFsException("Directory not empty.");
+                }
+            }
+            if( --rs.iLinks == 0 )
+            {
+                destroyNode( (*i).iNode );
+            }
+            else
+            {
+                writeInode( rs );
+            }
+            lDir.erase( i );
+            break;
+        }
+    }
+    
+    Bu::MyriadStream ms = openByInode( iParent );
+    int32_t iNumChildren = lDir.getSize();
+    ms.write( &iNumChildren, 4 );
+    for( Dir::iterator i = lDir.begin(); i; i++ )
+    {
+        ms.write( &(*i).iNode, 4 );
+        uint8_t iSize = (*i).sName.getSize();
+        ms.write( &iSize, 1 );
+        ms.write( (*i).sName.getStr(), iSize );
+    }
+    ms.setSize( ms.tell() );
 }
 
 void Bu::MyriadFs::setFileSize( const Bu::String &sPath, int32_t iSize )
 {
-        int32_t iParent = -1;
-        int32_t iNode;
-        iNode = lookupInode( sPath, iParent );
-        MyriadStream ms = openByInode( iNode );
-        ms.setSize( iSize );
+    int32_t iParent = -1;
+    int32_t iNode;
+    iNode = lookupInode( sPath, iParent );
+    MyriadStream ms = openByInode( iNode );
+    ms.setSize( iSize );
 }
 
 void Bu::MyriadFs::rename( const Bu::String &sFrom, const Bu::String &sTo )
 {
-        mkHardLink( sFrom, sTo );
-        unlink( sFrom );
+    mkHardLink( sFrom, sTo );
+    unlink( sFrom );
 }
 
 dev_t Bu::MyriadFs::devToSys( uint32_t uDev )
 {
-        return (((uDev&0xFFFF0000)>>8)&0xFF00) | ((uDev&0xFF));
+    return (((uDev&0xFFFF0000)>>8)&0xFF00) | ((uDev&0xFF));
 }
 
 uint32_t Bu::MyriadFs::sysToDev( dev_t uDev )
 {
-        return (((uint32_t)uDev&0xFF00)<<8) | ((uint32_t)uDev&0xFF);
+    return (((uint32_t)uDev&0xFF00)<<8) | ((uint32_t)uDev&0xFF);
 }
 
 int32_t Bu::MyriadFs::lookupInode( const Bu::String &sPath, int32_t &iParent )
 {
-        if( sPath == "/" )
-        {
-                return 0;
-        }
-        if( sPath[0] == '/' )
-        {
-                // Absolute lookup
-                return lookupInode( sPath.begin()+1, 0, iParent );
-        }
-        else
-        {
-                // Relative lookup
-                throw Bu::ExceptionBase(
-                        "Relative lookups in MyriadFs are not working yet.");
-        }
+    if( sPath == "/" )
+    {
+        return 0;
+    }
+    if( sPath[0] == '/' )
+    {
+        // Absolute lookup
+        return lookupInode( sPath.begin()+1, 0, iParent );
+    }
+    else
+    {
+        // Relative lookup
+        throw Bu::ExceptionBase(
+            "Relative lookups in MyriadFs are not working yet.");
+    }
 }
 
 int32_t Bu::MyriadFs::lookupInode( Bu::String::const_iterator iStart,
-                int32_t iNode, int32_t &iParent )
-{
-        iParent = iNode;
-
-        Bu::String::const_iterator iEnd = iStart.find('/');
-        Bu::String sTok( iStart, iEnd );
-
-//      sio << "Direcotry component: " << sTok << sio.nl;
-
-        Dir lDir = readDir( iNode );
-
-        for( Dir::iterator i = lDir.begin(); i; i++ )
-        {
-                if( (*i).sName == sTok )
-                {
-                        // We found an item
-                        if( !iEnd )
-                        {
-                                // It's the last one in the requested path, return it
-                                return (*i).iNode;
-                        }
-                        else
-                        {
-                                // Not the last one in our path, double check it's a dir
-                                if( ((*i).uPerms&typeMask) == typeDir )
-                                {
-                                        return lookupInode( iEnd+1, (*i).iNode, iParent );
-                                }
-                                else
-                                {
-                                        iParent = -1;
-                                        throw Bu::MyriadFsException(
-                                                "Element '%s' in given path is not a directory.",
-                                                sTok.getStr() );
-                                }
-                        }
-                }
-        }
-
-        if( iEnd )
-                throw Bu::MyriadFsException( 1, "Path not found");
-        else
-                throw Bu::MyriadFsException( 2, "Path not found");
+        int32_t iNode, int32_t &iParent )
+{
+    iParent = iNode;
+
+    Bu::String::const_iterator iEnd = iStart.find('/');
+    Bu::String sTok( iStart, iEnd );
+
+//  sio << "Direcotry component: " << sTok << sio.nl;
+
+    Dir lDir = readDir( iNode );
+
+    for( Dir::iterator i = lDir.begin(); i; i++ )
+    {
+        if( (*i).sName == sTok )
+        {
+            // We found an item
+            if( !iEnd )
+            {
+                // It's the last one in the requested path, return it
+                return (*i).iNode;
+            }
+            else
+            {
+                // Not the last one in our path, double check it's a dir
+                if( ((*i).uPerms&typeMask) == typeDir )
+                {
+                    return lookupInode( iEnd+1, (*i).iNode, iParent );
+                }
+                else
+                {
+                    iParent = -1;
+                    throw Bu::MyriadFsException(
+                        "Element '%s' in given path is not a directory.",
+                        sTok.getStr() );
+                }
+            }
+        }
+    }
+
+    if( iEnd )
+        throw Bu::MyriadFsException( 1, "Path not found");
+    else
+        throw Bu::MyriadFsException( 2, "Path not found");
 }
 
 void Bu::MyriadFs::readInode( int32_t iNode, RawStat &rs, MyriadStream &rIs )
 {
-        rIs.setPos( hNodeIndex.get( iNode )*sizeof(RawStat) );
-        if( rIs.read( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
-                throw Bu::MyriadFsException("Filesystem corruption detected.");
-        if( rs.iNode != iNode )
-                throw Bu::MyriadFsException("Filesystem corruption detected.");
+    rIs.setPos( hNodeIndex.get( iNode )*sizeof(RawStat) );
+    if( rIs.read( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
+        throw Bu::MyriadFsException("Filesystem corruption detected.");
+    if( rs.iNode != iNode )
+        throw Bu::MyriadFsException("Filesystem corruption detected.");
 }
 
 void Bu::MyriadFs::readInode( int32_t iNode, RawStat &rs )
 {
-        MyriadStream ms = mStore.openStream( 2 );
-        readInode( iNode, rs, ms );
+    MyriadStream ms = mStore.openStream( 2 );
+    readInode( iNode, rs, ms );
 }
 
 void Bu::MyriadFs::writeInode( const RawStat &rs,
-                MyriadStream &rOs )
+        MyriadStream &rOs )
 {
-        rOs.setSize( hNodeIndex.getSize()*sizeof(RawStat) );
-        rOs.setPos( hNodeIndex.get( rs.iNode )*sizeof(RawStat) );
-        if( rOs.write( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
-                throw Bu::MyriadFsException("Error writing inode to header stream.");
+    rOs.setSize( hNodeIndex.getSize()*sizeof(RawStat) );
+    rOs.setPos( hNodeIndex.get( rs.iNode )*sizeof(RawStat) );
+    if( rOs.write( &rs, sizeof(RawStat) ) < (int)sizeof(RawStat) )
+        throw Bu::MyriadFsException("Error writing inode to header stream.");
 }
 
 void Bu::MyriadFs::writeInode( const RawStat &rs )
 {
-        MyriadStream ms = mStore.openStream( 2 );
-        writeInode( rs, ms );
+    MyriadStream ms = mStore.openStream( 2 );
+    writeInode( rs, ms );
 }
 
 Bu::MyriadFs::Dir Bu::MyriadFs::readDir( int32_t iNode )
 {
-        Bu::MyriadStream ms = openByInode( iNode );
-        int32_t iNumChildren = 0;
-        ms.read( &iNumChildren, 4 );
-        
-        Bu::MyriadStream is = mStore.openStream( 2 );
-        Dir lDir;
-//      sio << "Reading dir, " << iNumChildren << " entries:" << sio.nl;
-        for( int32_t j = 0; j < iNumChildren; j++ )
-        {
-                int32_t iChildNode;
-                ms.read( &iChildNode, 4 );
-                Stat s;
-                stat( iChildNode, s, is );
-                uint8_t uLen;
-                ms.read( &uLen, 1 );
-                s.sName.setSize( uLen );
-                ms.read( s.sName.getStr(), uLen );
-                lDir.append( s );
-
-//              sio << "    " << s.sName << sio.nl;
-        }
-
-        return lDir;
+    Bu::MyriadStream ms = openByInode( iNode );
+    int32_t iNumChildren = 0;
+    ms.read( &iNumChildren, 4 );
+    
+    Bu::MyriadStream is = mStore.openStream( 2 );
+    Dir lDir;
+//  sio << "Reading dir, " << iNumChildren << " entries:" << sio.nl;
+    for( int32_t j = 0; j < iNumChildren; j++ )
+    {
+        int32_t iChildNode;
+        ms.read( &iChildNode, 4 );
+        Stat s;
+        stat( iChildNode, s, is );
+        uint8_t uLen;
+        ms.read( &uLen, 1 );
+        s.sName.setSize( uLen );
+        ms.read( s.sName.getStr(), uLen );
+        lDir.append( s );
+
+//      sio << "    " << s.sName << sio.nl;
+    }
+
+    return lDir;
 }
 
 Bu::MyriadStream Bu::MyriadFs::openByInode( int32_t iNode )
 {
-        RawStat rs;
-        readInode( iNode, rs );
-        switch( (rs.uPerms&typeMask) )
-        {
-                case typeDir:
-                case typeSymLink:
-                case typeRegFile:
-                        return mStore.openStream( rs.uStreamIndex );
+    RawStat rs;
+    readInode( iNode, rs );
+    switch( (rs.uPerms&typeMask) )
+    {
+        case typeDir:
+        case typeSymLink:
+        case typeRegFile:
+            return mStore.openStream( rs.uStreamIndex );
 
-                default:
-                        throw Bu::MyriadFsException(
-                                "inode incorrect type for low-level openByInode.");
-        }
+        default:
+            throw Bu::MyriadFsException(
+                "inode incorrect type for low-level openByInode.");
+    }
 }
 
 void Bu::MyriadFs::addToDir( int32_t iDir, int32_t iNode,
-                const Bu::String &sName )
-{
-        if( sName.getSize() > 255 )
-        {
-                throw Bu::MyriadFsException("Filename too long, max is 255 bytes.");
-        }
-        Bu::MyriadStream ms = openByInode( iDir );
-        int32_t iNumChildren = 0;
-        ms.read( &iNumChildren, 4 );
-        iNumChildren++;
-        ms.setPos( 0 );
-        ms.write( &iNumChildren, 4 );
-        ms.setPosEnd( 0 );
-        ms.write( &iNode, 4 );
-        uint8_t uLen = sName.getSize();
-        ms.write( &uLen, 1 );
-        ms.write( sName.getStr(), uLen );
+        const Bu::String &sName )
+{
+    if( sName.getSize() > 255 )
+    {
+        throw Bu::MyriadFsException("Filename too long, max is 255 bytes.");
+    }
+    Bu::MyriadStream ms = openByInode( iDir );
+    int32_t iNumChildren = 0;
+    ms.read( &iNumChildren, 4 );
+    iNumChildren++;
+    ms.setPos( 0 );
+    ms.write( &iNumChildren, 4 );
+    ms.setPosEnd( 0 );
+    ms.write( &iNode, 4 );
+    uint8_t uLen = sName.getSize();
+    ms.write( &uLen, 1 );
+    ms.write( sName.getStr(), uLen );
 }
 
 int32_t Bu::MyriadFs::create( int32_t iParent, const Bu::String &sName,
-                uint16_t uPerms, uint32_t uSpecial )
+        uint16_t uPerms, uint32_t uSpecial )
 {
-        int32_t iNode = allocInode( uPerms, uSpecial );
-        addToDir( iParent, iNode, sName );
-        return iNode;
+    int32_t iNode = allocInode( uPerms, uSpecial );
+    addToDir( iParent, iNode, sName );
+    return iNode;
 }
 
 int32_t Bu::MyriadFs::allocInode( uint16_t uPerms, uint32_t uSpecial )
 {
-        int32_t iNode = 0;
-        for(; iNode < 0xfffffff; iNode++ )
-        {
-                if( !hNodeIndex.has( iNode ) )
-                {
-                        hNodeIndex.insert( iNode, hNodeIndex.getSize() );
-                        RawStat rs;
-                        rs.iNode = iNode;
-                        rs.iUser = iUser;
-                        rs.iGroup = iGroup;
-                        rs.uPerms = uPerms;
-                        rs.iLinks = 1;
-                        switch( (uPerms&typeMask) )
-                        {
-                                case typeRegFile:
-                                case typeSymLink:
-                                        rs.uStreamIndex = mStore.createStream();
-                                        break;
-                                
-                                case typeDir:
-                                        rs.uStreamIndex = mStore.createStream();
-                                        sio << "Creating directory node, storage: "
-                                                << rs.uStreamIndex << sio.nl;
-                                        {
-                                                Bu::MyriadStream msDir = mStore.openStream(
-                                                        rs.uStreamIndex
-                                                        );
-                                                uint32_t uSize = 0;
-                                                msDir.write( &uSize, 4 );
-                                        }
-                                        break;
-
-                                case typeChrDev:
-                                case typeBlkDev:
-                                        rs.uStreamIndex = uSpecial;
-                                        break;
-
-                                default:
-                                        rs.uStreamIndex = 0;
-                                        break;
-                        }
-                        rs.iATime = time(NULL);
-                        rs.iMTime = time(NULL);
-                        rs.iCTime = time(NULL);
-                        writeInode( rs );
-
-                        return iNode;
-                }
-        }
-
-        throw Bu::MyriadFsException(
-                "No inode could be allocated.  You've run out!");
+    int32_t iNode = 0;
+    for(; iNode < 0xfffffff; iNode++ )
+    {
+        if( !hNodeIndex.has( iNode ) )
+        {
+            hNodeIndex.insert( iNode, hNodeIndex.getSize() );
+            RawStat rs;
+            rs.iNode = iNode;
+            rs.iUser = iUser;
+            rs.iGroup = iGroup;
+            rs.uPerms = uPerms;
+            rs.iLinks = 1;
+            switch( (uPerms&typeMask) )
+            {
+                case typeRegFile:
+                case typeSymLink:
+                    rs.uStreamIndex = mStore.createStream();
+                    break;
+                
+                case typeDir:
+                    rs.uStreamIndex = mStore.createStream();
+                    sio << "Creating directory node, storage: "
+                        << rs.uStreamIndex << sio.nl;
+                    {
+                        Bu::MyriadStream msDir = mStore.openStream(
+                            rs.uStreamIndex
+                            );
+                        uint32_t uSize = 0;
+                        msDir.write( &uSize, 4 );
+                    }
+                    break;
+
+                case typeChrDev:
+                case typeBlkDev:
+                    rs.uStreamIndex = uSpecial;
+                    break;
+
+                default:
+                    rs.uStreamIndex = 0;
+                    break;
+            }
+            rs.iATime = time(NULL);
+            rs.iMTime = time(NULL);
+            rs.iCTime = time(NULL);
+            writeInode( rs );
+
+            return iNode;
+        }
+    }
+
+    throw Bu::MyriadFsException(
+        "No inode could be allocated.  You've run out!");
 }
 
 void Bu::MyriadFs::stat( int32_t iNode, Stat &rBuf, MyriadStream &rIs )
 {
-        RawStat rs;
-        readInode( iNode, rs, rIs );
-        rBuf.iNode = iNode;
-        rBuf.iUser = rs.iUser;
-        rBuf.iGroup = rs.iGroup;
-        rBuf.uPerms = rs.uPerms;
-        rBuf.iLinks = rs.iLinks;
-        rBuf.iATime = rs.iATime;
-        rBuf.iMTime = rs.iMTime;
-        rBuf.iCTime = rs.iCTime;
-        rBuf.uDev = 0;
-        rBuf.iSize = 0;
-        switch( (rBuf.uPerms&typeMask) )
-        {
-                case typeRegFile:
-                case typeSymLink:
-                        rBuf.iSize = mStore.getStreamSize( rs.uStreamIndex );
-                        break;
-
-                case typeChrDev:
-                case typeBlkDev:
-                        rBuf.uDev = rs.uStreamIndex;
-                        break;
-
-                default:
-                        rBuf.iSize = 0;
-                        break;
-        }
+    RawStat rs;
+    readInode( iNode, rs, rIs );
+    rBuf.iNode = iNode;
+    rBuf.iUser = rs.iUser;
+    rBuf.iGroup = rs.iGroup;
+    rBuf.uPerms = rs.uPerms;
+    rBuf.iLinks = rs.iLinks;
+    rBuf.iATime = rs.iATime;
+    rBuf.iMTime = rs.iMTime;
+    rBuf.iCTime = rs.iCTime;
+    rBuf.uDev = 0;
+    rBuf.iSize = 0;
+    switch( (rBuf.uPerms&typeMask) )
+    {
+        case typeRegFile:
+        case typeSymLink:
+            rBuf.iSize = mStore.getStreamSize( rs.uStreamIndex );
+            break;
+
+        case typeChrDev:
+        case typeBlkDev:
+            rBuf.uDev = rs.uStreamIndex;
+            break;
+
+        default:
+            rBuf.iSize = 0;
+            break;
+    }
 }
 
 void Bu::MyriadFs::writeHeader()
 {
-        Bu::MyriadStream ms = mStore.openStream( 1 );
-        ms.write( Myriad_Fs_MAGIC_CODE, 4 );
-        int8_t iVer = 1;
-        int32_t iNumNodes = hNodeIndex.getSize();
-        ms.write( &iVer, 1 );
-        ms.write( &iNumNodes, 4 ); // iNumNodes
-        for( NodeIndex::iterator i = hNodeIndex.begin(); i; i++ )
-        {
-                int32_t iNode = i.getKey();
-                int32_t iPosition = i.getValue();
-                ms.write( &iNode, 4 );
-                ms.write( &iPosition, 4 );
-        }
+    Bu::MyriadStream ms = mStore.openStream( 1 );
+    ms.write( Myriad_Fs_MAGIC_CODE, 4 );
+    int8_t iVer = 1;
+    int32_t iNumNodes = hNodeIndex.getSize();
+    ms.write( &iVer, 1 );
+    ms.write( &iNumNodes, 4 ); // iNumNodes
+    for( NodeIndex::iterator i = hNodeIndex.begin(); i; i++ )
+    {
+        int32_t iNode = i.getKey();
+        int32_t iPosition = i.getValue();
+        ms.write( &iNode, 4 );
+        ms.write( &iPosition, 4 );
+    }
 
-        // Truncate the stream afterwards so we don't use up too much space.
-        ms.setSize( ms.tell() );
+    // Truncate the stream afterwards so we don't use up too much space.
+    ms.setSize( ms.tell() );
 }
 
 void Bu::MyriadFs::setTimes( int32_t iNode, int64_t iATime, int64_t iMTime )
 {
-        RawStat rs;
-        Bu::MyriadStream is = mStore.openStream( 2 );
+    RawStat rs;
+    Bu::MyriadStream is = mStore.openStream( 2 );
 
-        readInode( iNode, rs, is );
-        rs.iATime = iATime;
-        rs.iMTime = iMTime;
-        writeInode( rs, is );
+    readInode( iNode, rs, is );
+    rs.iATime = iATime;
+    rs.iMTime = iMTime;
+    writeInode( rs, is );
 }
 
 void Bu::MyriadFs::destroyNode( int32_t iNode )
 {
-        if( iNode == 0 )
-                throw Bu::MyriadFsException("You cannot destroy the root.");
+    if( iNode == 0 )
+        throw Bu::MyriadFsException("You cannot destroy the root.");
 
-        Bu::MyriadStream is = mStore.openStream( 2 );
+    Bu::MyriadStream is = mStore.openStream( 2 );
 
-        // This will be overwritten with the last node
-        uint32_t iPosition = hNodeIndex.get( iNode );
-        RawStat rsOld;
-        readInode( iNode, rsOld, is );
-        switch( (rsOld.uPerms&typeMask) )
-        {
-                case typeRegFile:
-                case typeDir:
-                case typeSymLink:
-                        mStore.deleteStream( rsOld.uStreamIndex );
-                        break;
-        }
+    // This will be overwritten with the last node
+    uint32_t iPosition = hNodeIndex.get( iNode );
+    RawStat rsOld;
+    readInode( iNode, rsOld, is );
+    switch( (rsOld.uPerms&typeMask) )
+    {
+        case typeRegFile:
+        case typeDir:
+        case typeSymLink:
+            mStore.deleteStream( rsOld.uStreamIndex );
+            break;
+    }
 
-        hNodeIndex.erase( iNode );
+    hNodeIndex.erase( iNode );
 
-        // Read the last node, can't use the helpers, because we don't know the
-        // iNode yet.
-        if( iPosition != hNodeIndex.getSize() )
-        {
-                // If this is the last node, then we don't need to do anything, but
-                // this case handles what to do if we aren't on the last node
-                RawStat rs;
-                is.setPos( (hNodeIndex.getSize())*sizeof(RawStat) );
-                is.read( &rs, sizeof(RawStat) );
+    // Read the last node, can't use the helpers, because we don't know the
+    // iNode yet.
+    if( iPosition != hNodeIndex.getSize() )
+    {
+        // If this is the last node, then we don't need to do anything, but
+        // this case handles what to do if we aren't on the last node
+        RawStat rs;
+        is.setPos( (hNodeIndex.getSize())*sizeof(RawStat) );
+        is.read( &rs, sizeof(RawStat) );
 
-                hNodeIndex.get( rs.iNode ) = iPosition;
-                writeInode( rs, is );
-        }
+        hNodeIndex.get( rs.iNode ) = iPosition;
+        writeInode( rs, is );
+    }
 
-        is.setSize( hNodeIndex.getSize() * sizeof(RawStat) );
+    is.setSize( hNodeIndex.getSize() * sizeof(RawStat) );
 }
 
 Bu::String Bu::MyriadFs::filePart( const Bu::String &sPath )
 {
-        Bu::String::const_iterator iStart = sPath.begin();
-        if( *iStart == '/' )
-                iStart++;
-        for( Bu::String::const_iterator iEnd = iStart.find('/'); iEnd;
-                 iStart = iEnd+1, iEnd = iStart.find('/') ) { }
-        return Bu::String( iStart, sPath.end() );
+    Bu::String::const_iterator iStart = sPath.begin();
+    if( *iStart == '/' )
+        iStart++;
+    for( Bu::String::const_iterator iEnd = iStart.find('/'); iEnd;
+         iStart = iEnd+1, iEnd = iStart.find('/') ) { }
+    return Bu::String( iStart, sPath.end() );
 }