Clean up code formatting
authorcharles <charles>
Mon, 19 Oct 2009 23:42:55 +0000 (23:42 +0000)
committercharles <charles>
Mon, 19 Oct 2009 23:42:55 +0000 (23:42 +0000)
direct/yaffsfs.c

index c6eb37b..f0e1f45 100644 (file)
@@ -24,7 +24,7 @@
 #endif
 
 
-const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.27 2009-10-08 01:57:59 charles Exp $";
+const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.28 2009-10-19 23:42:55 charles Exp $";
 
 // configurationList is the list of devices that are supported
 static yaffsfs_DeviceConfiguration *yaffsfs_configurationList;
@@ -41,8 +41,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj);
 
 unsigned int yaffs_wr_attempts;
 
-typedef struct
-{
+typedef struct{
        __u8  inUse:1;          // this handle is in use
        __u8  readOnly:1;       // this handle is read only
        __u8  append:1;         // append only
@@ -60,8 +59,7 @@ static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES];
 static int yaffsfs_InitHandles(void)
 {
        int i;
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
-       {
+       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
                yaffsfs_handle[i].inUse = 0;
                yaffsfs_handle[i].obj = NULL;
        }
@@ -71,9 +69,7 @@ static int yaffsfs_InitHandles(void)
 yaffsfs_Handle *yaffsfs_GetHandlePointer(int h)
 {
        if(h < 0 || h >= YAFFSFS_N_HANDLES)
-       {
                return NULL;
-       }
 
        return &yaffsfs_handle[h];
 }
@@ -83,9 +79,7 @@ yaffs_Object *yaffsfs_GetHandleObject(int handle)
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
 
        if(h && h->inUse)
-       {
                return h->obj;
-       }
 
        return NULL;
 }
@@ -100,15 +94,12 @@ static int yaffsfs_GetHandle(void)
        int i;
        yaffsfs_Handle *h;
 
-       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
-       {
+       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
                h = yaffsfs_GetHandlePointer(i);
-               if(!h)
-               {
+               if(!h){
                        // todo bug: should never happen
                }
-               if(!h->inUse)
-               {
+               if(!h->inUse){
                        memset(h,0,sizeof(yaffsfs_Handle));
                        h->inUse=1;
                        return i;
@@ -124,8 +115,7 @@ static int yaffsfs_PutHandle(int handle)
 {
        yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle);
 
-       if(h)
-       {
+       if(h){
                h->inUse = 0;
                h->obj = NULL;
        }
@@ -174,8 +164,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
        // Check all configs, choose the one that:
        // 1) Actually matches a prefix (ie /a amd /abc will not match
        // 2) Matches the longest.
-       while(cfg && cfg->prefix && cfg->dev)
-       {
+       while(cfg && cfg->prefix && cfg->dev){
                leftOver = path;
                p = cfg->prefix;
                thisMatchLength = 0;
@@ -210,8 +199,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
                      leftOver++;
                
 
-               if( matching && (thisMatchLength > longestMatch))
-               {
+               if( matching && (thisMatchLength > longestMatch)){
                        // Matched prefix
                        *restOfPath = (YCHAR *)leftOver;
                        retval = cfg->dev;
@@ -236,8 +224,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
        // Check all configs, choose the one that:
        // 1) Actually matches a prefix (ie /a amd /abc will not match
        // 2) Matches the longest.
-       while(cfg && cfg->prefix && cfg->dev)
-       {
+       while(cfg && cfg->prefix && cfg->dev){
                leftOver = path;
                p = cfg->prefix;
                thisMatchLength = 0;
@@ -245,8 +232,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
                while(*p &&  //unmatched part of prefix
                      !(yaffsfs_IsPathDivider(*p) && (p[1] == 0)) && // the rest of the prefix is not / (to catch / at end)
                      *leftOver &&
-                     yaffsfs_Match(*p,*leftOver))
-               {
+                     yaffsfs_Match(*p,*leftOver)){
                        p++;
                        leftOver++;
                        thisMatchLength++;
@@ -255,8 +241,7 @@ static yaffs_Device *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath)
 
                if((!*p || (yaffsfs_IsPathDivider(*p) && (p[1] == 0))) &&      // end of prefix
                   (!*leftOver || yaffsfs_IsPathDivider(*leftOver)) && // no more in this path name part
-                  (thisMatchLength > longestMatch))
-               {
+                  (thisMatchLength > longestMatch)){
                        // Matched prefix
                        *restOfPath = (YCHAR *)leftOver;
                        retval = cfg->dev;
@@ -274,8 +259,7 @@ static yaffs_Object *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
        yaffs_Device *dev;
 
        dev= yaffsfs_FindDevice(path,restOfPath);
-       if(dev && dev->isMounted)
-       {
+       if(dev && dev->isMounted){
                return dev->rootDir;
        }
        return NULL;
@@ -284,20 +268,15 @@ static yaffs_Object *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath)
 static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth)
 {
 
-       while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-       {
+       while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
                YCHAR *alias = obj->variant.symLinkVariant.alias;
 
                if(yaffsfs_IsPathDivider(*alias))
-               {
                        // Starts with a /, need to scan from root up
                        obj = yaffsfs_FindObject(NULL,alias,symDepth++);
-               }
                else
-               {
                        // Relative to here, so use the parent of the symlink as a start
                        obj = yaffsfs_FindObject(obj->parent,alias,symDepth++);
-               }
        }
        return obj;
 }
@@ -315,37 +294,27 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
        int i;
 
        if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES)
-       {
                return NULL;
-       }
 
-       if(startDir)
-       {
+       if(startDir){
                dir = startDir;
                restOfPath = (YCHAR *)path;
        }
        else
-       {
                dir = yaffsfs_FindRoot(path,&restOfPath);
-       }
 
-       while(dir)
-       {
+       while(dir){
                // parse off /.
                // curve ball: also throw away surplus '/'
                // eg. "/ram/x////ff" gets treated the same as "/ram/x/ff"
                while(yaffsfs_IsPathDivider(*restOfPath))
-               {
                        restOfPath++; // get rid of '/'
-               }
 
                *name = restOfPath;
                i = 0;
 
-               while(*restOfPath && !yaffsfs_IsPathDivider(*restOfPath))
-               {
-                       if (i < YAFFS_MAX_NAME_LENGTH)
-                       {
+               while(*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)){
+                       if (i < YAFFS_MAX_NAME_LENGTH){
                                str[i] = *restOfPath;
                                str[i+1] = '\0';
                                i++;
@@ -354,35 +323,24 @@ static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const YCHAR
                }
 
                if(!*restOfPath)
-               {
                        // got to the end of the string
                        return dir;
-               }
-               else
-               {
+               else{
                        if(yaffs_strcmp(str,_Y(".")) == 0)
                        {
                                // Do nothing
                        }
                        else if(yaffs_strcmp(str,_Y("..")) == 0)
-                       {
                                dir = dir->parent;
-                       }
-                       else
-                       {
+                       else{
                                dir = yaffs_FindObjectByName(dir,str);
 
                                while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-                               {
-
                                        dir = yaffsfs_FollowLink(dir,symDepth);
 
-                               }
 
                                if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
-                               {
                                        dir = NULL;
-                               }
                        }
                }
        }
@@ -405,9 +363,7 @@ static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const Y
        dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth);
 
        if(dir && *name)
-       {
                return yaffs_FindObjectByName(dir,name);
-       }
 
        return dir;
 }
@@ -464,8 +420,7 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
 
        handle = yaffsfs_GetHandle();
 
-       if(handle >= 0)
-       {
+       if(handle >= 0){
 
                h = yaffsfs_GetHandlePointer(handle);
 
@@ -474,44 +429,31 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                obj = yaffsfs_FindObject(NULL,path,0);
 
                if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-               {
-
                        obj = yaffsfs_FollowLink(obj,symDepth++);
-               }
 
                if(obj && obj->variantType != YAFFS_OBJECT_TYPE_FILE)
-               {
                        obj = NULL;
-               }
 
-               if(obj)
-               {
+               if(obj){
                        // Check if the object is already in use
                        alreadyOpen = alreadyExclusive = 0;
 
-                       for(i = 0; i < YAFFSFS_N_HANDLES; i++)
-                       {
+                       for(i = 0; i < YAFFSFS_N_HANDLES; i++){
 
                                if(i != handle &&
                                   yaffsfs_handle[i].inUse &&
-                                   obj == yaffsfs_handle[i].obj)
-                                {
+                                   obj == yaffsfs_handle[i].obj){
                                        alreadyOpen = 1;
                                        if(yaffsfs_handle[i].exclusive)
-                                       {
                                                alreadyExclusive = 1;
-                                       }
                                 }
                        }
 
                        if(((oflag & O_EXCL) && alreadyOpen) || alreadyExclusive)
-                       {
                                openDenied = 1;
-                       }
 
                        // Open should fail if O_CREAT and O_EXCL are specified
-                       if((oflag & O_EXCL) && (oflag & O_CREAT))
-                       {
+                       if((oflag & O_EXCL) && (oflag & O_CREAT)){
                                openDenied = 1;
                                yaffsfs_SetError(-EEXIST);
                                errorReported = 1;
@@ -520,66 +462,46 @@ int yaffs_open(const YCHAR *path, int oflag, int mode)
                        // Check file permissions
                        if( (oflag & (O_RDWR | O_WRONLY)) == 0 &&     // ie O_RDONLY
                           !(obj->yst_mode & S_IREAD))
-                       {
                                openDenied = 1;
-                       }
 
                        if( (oflag & O_RDWR) &&
                           !(obj->yst_mode & S_IREAD))
-                       {
                                openDenied = 1;
-                       }
 
                        if( (oflag & (O_RDWR | O_WRONLY)) &&
                           !(obj->yst_mode & S_IWRITE))
-                       {
                                openDenied = 1;
-                       }
-
-               }
 
-               else if((oflag & O_CREAT))
-               {
+               } else if((oflag & O_CREAT)) {
                        // Let's see if we can create this file
                        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
                        if(dir)
-                       {
                                obj = yaffs_MknodFile(dir,name,mode,0,0);
-                       }
-                       else
-                       {
+                       else {
                                yaffsfs_SetError(-ENOTDIR);
                                errorReported = 1;
                        }
                }
 
-               if(obj && !openDenied)
-               {
+               if(obj && !openDenied) {
                        h->obj = obj;
                        h->inUse = 1;
-               h->readOnly = (oflag & (O_WRONLY | O_RDWR)) ? 0 : 1;
+                       h->readOnly = (oflag & (O_WRONLY | O_RDWR)) ? 0 : 1;
                        h->append =  (oflag & O_APPEND) ? 1 : 0;
                        h->exclusive = (oflag & O_EXCL) ? 1 : 0;
                        h->position = 0;
 
                         obj->inUse++;
                         if((oflag & O_TRUNC) && !h->readOnly)
-                        {
                                 yaffs_ResizeFile(obj,0);
-                        }
-
-               }
-               else
-               {
+               } else {
                        yaffsfs_PutHandle(handle);
-                       if(!errorReported)
-                       {
+                       if(!errorReported) {
                                yaffsfs_SetError(-EACCES);
                                errorReported = 1;
                        }
                        handle = -1;
                }
-
        }
 
        yaffsfs_Unlock();
@@ -597,12 +519,9 @@ int yaffs_Dofsync(int fd,int datasync)
        h = yaffsfs_GetHandlePointer(fd);
 
        if(h && h->inUse)
-       {
                // flush the file
                yaffs_FlushFile(h->obj,1,datasync);
-       }
-       else
-       {
+       else {
                // bad handle
                yaffsfs_SetError(-EBADF);
                retVal = -1;
@@ -637,20 +556,16 @@ int yaffs_close(int fd)
 
        h = yaffsfs_GetHandlePointer(fd);
 
-       if(h && h->inUse)
-       {
+       if(h && h->inUse) {
                // clean up
                yaffs_FlushFile(h->obj,1,0);
                h->obj->inUse--;
                if(h->obj->inUse <= 0 && h->obj->unlinked)
-               {
                        yaffs_DeleteObject(h->obj);
-               }
+
                yaffsfs_PutHandle(fd);
                retVal = 0;
-       }
-       else
-       {
+       } else {
                // bad handle
                yaffsfs_SetError(-EBADF);
                retVal = -1;
@@ -674,44 +589,29 @@ int yaffs_read(int fd, void *buf, unsigned int nbyte)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
-       else if( h && obj)
-       {
+
+       else if( h && obj){
                pos=  h->position;
                if(yaffs_GetObjectFileLength(obj) > pos)
-               {
                        maxRead = yaffs_GetObjectFileLength(obj) - pos;
-               }
                else
-               {
                        maxRead = 0;
-               }
 
                if(nbyte > maxRead)
-               {
                        nbyte = maxRead;
-               }
 
 
-               if(nbyte > 0)
-               {
+               if(nbyte > 0) {
                        nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
                        if(nRead >= 0)
-                       {
                                h->position = pos + nRead;
-                       }
-                       else
-                       {
+                       else {
                                //todo error
                        }
-               }
-               else
-               {
+               } else
                        nRead = 0;
-               }
 
        }
 
@@ -735,37 +635,23 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
-       else if( h && obj)
-       {
+       else if( h && obj) {
                pos= offset;
                if(yaffs_GetObjectFileLength(obj) > pos)
-               {
                        maxRead = yaffs_GetObjectFileLength(obj) - pos;
-               }
                else
-               {
                        maxRead = 0;
-               }
 
                if(nbyte > maxRead)
-               {
                        nbyte = maxRead;
-               }
 
 
                if(nbyte > 0)
-               {
                        nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte);
-               }
                else
-               {
                        nRead = 0;
-               }
-
        }
 
        yaffsfs_Unlock();
@@ -788,33 +674,21 @@ int yaffs_write(int fd, const void *buf, unsigned int nbyte)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
-       else if( h && obj && h->readOnly)
-       {
+       else if( h && obj && h->readOnly){
                // todo error
-       }
-       else if( h && obj)
-       {
+       } else if( h && obj){
                if(h->append)
-               {
                        pos =  yaffs_GetObjectFileLength(obj);
-               }
                else
-               {
                        pos = h->position;
-               }
 
                nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
 
                if(nWritten >= 0)
-               {
                        h->position = pos + nWritten;
-               }
-               else
-               {
+               else {
                        //todo error
                }
 
@@ -840,16 +714,12 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
-       else if( h && obj && h->readOnly)
-       {
+       else if( h && obj && h->readOnly){
                // todo error
        }
-       else if( h && obj)
-       {
+       else if( h && obj){
                pos = offset;
 
                 nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough);
@@ -879,17 +749,11 @@ int yaffs_truncate(const YCHAR *path,off_t newSize)
                obj = yaffs_GetEquivalentObject(obj);
 
        if(!obj)
-       {
                yaffsfs_SetError(-ENOENT);
-       }
        else if(obj->variantType != YAFFS_OBJECT_TYPE_FILE)
-       {
                yaffsfs_SetError(-EISDIR);
-       }
        else
-       {
                result = yaffs_ResizeFile(obj,newSize);
-       }
 
        yaffsfs_Unlock();
 
@@ -908,15 +772,11 @@ int yaffs_ftruncate(int fd, off_t newSize)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
        else
-       {
                // resize the file
                result = yaffs_ResizeFile(obj,newSize);
-       }
        yaffsfs_Unlock();
 
 
@@ -936,39 +796,25 @@ off_t yaffs_lseek(int fd, off_t offset, int whence)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(!h || !obj)
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
-       else if(whence == SEEK_SET)
-       {
+       else if(whence == SEEK_SET){
                if(offset >= 0)
-               {
                        pos = offset;
-               }
        }
-       else if(whence == SEEK_CUR)
-       {
+       else if(whence == SEEK_CUR) {
                if( (h->position + offset) >= 0)
-               {
                        pos = (h->position + offset);
-               }
        }
-       else if(whence == SEEK_END)
-       {
+       else if(whence == SEEK_END) {
                fSize = yaffs_GetObjectFileLength(obj);
                if(fSize >= 0 && (fSize + offset) >= 0)
-               {
                        pos = fSize + offset;
-               }
        }
 
        if(pos >= 0)
-       {
                h->position = pos;
-       }
-       else
-       {
+       else {
                // todo error
        }
 
@@ -991,29 +837,18 @@ int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory)
        obj = yaffsfs_FindObject(NULL,path,0);
        dir = yaffsfs_FindDirectory(NULL,path,&name,0);
        if(!dir)
-       {
                yaffsfs_SetError(-ENOTDIR);
-       }
        else if(!obj)
-       {
                yaffsfs_SetError(-ENOENT);
-       }
        else if(!isDirectory && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
                yaffsfs_SetError(-EISDIR);
-       }
        else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
                yaffsfs_SetError(-ENOTDIR);
-       }
-       else
-       {
+       else {
                result = yaffs_Unlink(dir,name);
 
                if(result == YAFFS_FAIL && isDirectory)
-               {
                        yaffsfs_SetError(-ENOTEMPTY);
-               }
        }
 
        yaffsfs_Unlock();
@@ -1050,42 +885,33 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath)
        newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0);
        obj = yaffsfs_FindObject(NULL,oldPath,0);
 
-       if(!olddir || !newdir || !obj)
-       {
+       if(!olddir || !newdir || !obj) {
                // bad file
                yaffsfs_SetError(-EBADF);
                renameAllowed = 0;
-       }
-       else if(olddir->myDev != newdir->myDev)
-       {
+       } else if(olddir->myDev != newdir->myDev) {
                // oops must be on same device
                // todo error
                yaffsfs_SetError(-EXDEV);
                renameAllowed = 0;
-       }
-       else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
+       } else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) {
                // It is a directory, check that it is not being renamed to
                // being its own decendent.
                // Do this by tracing from the new directory back to the root, checking for obj
 
                yaffs_Object *xx = newdir;
 
-               while( renameAllowed && xx)
-               {
+               while( renameAllowed && xx){
                        if(xx == obj)
-                       {
                                renameAllowed = 0;
-                       }
                        xx = xx->parent;
                }
-               if(!renameAllowed) yaffsfs_SetError(-EACCES);
+               if(!renameAllowed)
+                       yaffsfs_SetError(-EACCES);
        }
 
        if(renameAllowed)
-       {
                result = yaffs_RenameObject(olddir,oldname,newdir,newname);
-       }
 
        yaffsfs_Unlock();
 
@@ -1098,36 +924,27 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
        int retVal = -1;
 
        if(obj)
-       {
                obj = yaffs_GetEquivalentObject(obj);
-       }
 
-       if(obj && buf)
-       {
-       buf->st_dev = (int)obj->myDev->genericDevice;
-       buf->st_ino = obj->objectId;
-       buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits
+       if(obj && buf){
+               buf->st_dev = (int)obj->myDev->genericDevice;
+               buf->st_ino = obj->objectId;
+               buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits
 
-               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-               {
+               if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
                        buf->st_mode |= S_IFDIR;
-               }
                else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK)
-               {
                        buf->st_mode |= S_IFLNK;
-               }
                else if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
-               {
                        buf->st_mode |= S_IFREG;
-               }
 
-       buf->st_nlink = yaffs_GetObjectLinkCount(obj);
-       buf->st_uid = 0;
-       buf->st_gid = 0;;
-       buf->st_rdev = obj->yst_rdev;
-       buf->st_size = yaffs_GetObjectFileLength(obj);
-               buf->st_blksize = obj->myDev->nDataBytesPerChunk;
-       buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
+               buf->st_nlink = yaffs_GetObjectLinkCount(obj);
+               buf->st_uid = 0;
+               buf->st_gid = 0;;
+               buf->st_rdev = obj->yst_rdev;
+               buf->st_size = yaffs_GetObjectFileLength(obj);
+               buf->st_blksize = obj->myDev->nDataBytesPerChunk;
+               buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize;
 #if CONFIG_YAFFS_WINCE
                buf->yst_wince_atime[0] = obj->win_atime[0];
                buf->yst_wince_atime[1] = obj->win_atime[1];
@@ -1136,9 +953,9 @@ static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf)
                buf->yst_wince_mtime[0] = obj->win_mtime[0];
                buf->yst_wince_mtime[1] = obj->win_mtime[1];
 #else
-       buf->yst_atime = obj->yst_atime;
-       buf->yst_ctime = obj->yst_ctime;
-       buf->yst_mtime = obj->yst_mtime;
+               buf->yst_atime = obj->yst_atime;
+               buf->yst_ctime = obj->yst_ctime;
+               buf->yst_mtime = obj->yst_mtime;
 #endif
                retVal = 0;
        }
@@ -1155,19 +972,13 @@ static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int d
        obj = yaffsfs_FindObject(NULL,path,0);
 
        if(!doLStat && obj)
-       {
                obj = yaffsfs_FollowLink(obj,0);
-       }
 
        if(obj)
-       {
                retVal = yaffsfs_DoStat(obj,buf);
-       }
        else
-       {
                // todo error not found
                yaffsfs_SetError(-ENOENT);
-       }
 
        yaffsfs_Unlock();
 
@@ -1195,14 +1006,10 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(obj)
-       {
                retVal = yaffsfs_DoStat(obj,buf);
-       }
        else
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
 
        yaffsfs_Unlock();
 
@@ -1219,8 +1026,7 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
        yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
 
-       if(obj)
-       {
+       if(obj){
 
                if(wctime){
                        wctime[0] = obj->win_ctime[0];
@@ -1237,12 +1043,9 @@ int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *
 
 
                retVal = 0;
-       }
-       else
-       {
+       } else
                // bad handle
                yaffsfs_SetError(-EBADF);               
-       }
        
        yaffsfs_Unlock();
        
@@ -1262,8 +1065,7 @@ int yaffs_set_wince_times(int fd,
         yaffsfs_Lock();
        obj = yaffsfs_GetHandleObject(fd);
 
-       if(obj)
-       {
+       if(obj){
 
                if(wctime){
                        obj->win_ctime[0] = wctime[0];
@@ -1281,12 +1083,9 @@ int yaffs_set_wince_times(int fd,
                 obj->dirty = 1;
                 result = yaffs_FlushFile(obj,0,0);
                 retVal = 0;
-        }
-        else
-       {
+        } else
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
 
        yaffsfs_Unlock();
 
@@ -1301,12 +1100,9 @@ static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode)
        int result = -1;
 
        if(obj)
-       {
                obj = yaffs_GetEquivalentObject(obj);
-       }
 
-       if(obj)
-       {
+       if(obj) {
                obj->yst_mode = mode;
                obj->dirty = 1;
                result = yaffs_FlushFile(obj,0,0);
@@ -1325,8 +1121,7 @@ int yaffs_access(const YCHAR *path, int amode)
        yaffsfs_Lock();
        obj = yaffsfs_FindObject(NULL,path,0);
 
-       if(obj)
-       {
+       if(obj) {
                int access_ok = 1;
 
                if((amode & R_OK) && !(obj->yst_mode & S_IREAD))
@@ -1340,9 +1135,7 @@ int yaffs_access(const YCHAR *path, int amode)
                        yaffsfs_SetError(-EACCES);
                        retval = -1;
                }
-       }
-       else
-       {
+       } else {
                // todo error not found
                yaffsfs_SetError(-ENOENT);
                retval = -1;
@@ -1365,14 +1158,10 @@ int yaffs_chmod(const YCHAR *path, mode_t mode)
        obj = yaffsfs_FindObject(NULL,path,0);
 
        if(obj)
-       {
                retVal = yaffsfs_DoChMod(obj,mode);
-       }
        else
-       {
                // todo error not found
                yaffsfs_SetError(-ENOENT);
-       }
 
        yaffsfs_Unlock();
 
@@ -1391,14 +1180,10 @@ int yaffs_fchmod(int fd, mode_t mode)
        obj = yaffsfs_GetHandleObject(fd);
 
        if(obj)
-       {
                retVal = yaffsfs_DoChMod(obj,mode);
-       }
        else
-       {
                // bad handle
                yaffsfs_SetError(-EBADF);
-       }
 
        yaffsfs_Unlock();
 
@@ -1418,17 +1203,12 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode)
        if(parent)
                dir = yaffs_MknodDirectory(parent,name,mode,0,0);
        if(dir)
-       {
                retVal = 0;
-       }
-       else
-       {
-               if(!parent){
+       else {
+               if(!parent)
                        yaffsfs_SetError(-ENOENT); // missing path
-               }
-               else if (yaffs_FindObjectByName(parent,name)){
+               else if (yaffs_FindObjectByName(parent,name))
                        yaffsfs_SetError(-EEXIST); // the name already exists
-               }
                else
                        yaffsfs_SetError(-ENOSPC); // just assume no space
                retVal = -1;
@@ -1450,30 +1230,22 @@ int yaffs_mount(const YCHAR *path)
 
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev)
-       {
-               if(!dev->isMounted)
-               {
+       if(dev){
+               if(!dev->isMounted){
                        result = yaffs_GutsInitialise(dev);
                        if(result == YAFFS_FAIL)
-                       {
                                // todo error - mount failed
                                yaffsfs_SetError(-ENOMEM);
-                       }
                        retVal = result ? 0 : -1;
 
                }
                else
-               {
                        //todo error - already mounted.
                        yaffsfs_SetError(-EBUSY);
-               }
-       }
-       else
-       {
+       } else
                // todo error - no device
                yaffsfs_SetError(-ENODEV);
-       }
+
        yaffsfs_Unlock();
        return retVal;
 
@@ -1487,28 +1259,21 @@ int yaffs_sync(const YCHAR *path)
         
         yaffsfs_Lock();
         dev = yaffsfs_FindDevice(path,&dummy);
-        if(dev)
-        {
-                if(dev->isMounted)
-                {
+        if(dev){
+                if(dev->isMounted){
                         
                         yaffs_FlushEntireDeviceCache(dev);
                         yaffs_CheckpointSave(dev);
                         
                         
-                }
-                else
-                {
+                } else
                         //todo error - not mounted.
                         yaffsfs_SetError(-EINVAL);
                         
-                }
-        }
-        else
-        {
+        }else
                 // todo error - no device
                 yaffsfs_SetError(-ENODEV);
-        }       
+
         yaffsfs_Unlock();
         return retVal;  
 }
@@ -1522,49 +1287,36 @@ int yaffs_unmount(const YCHAR *path)
 
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev)
-       {
-               if(dev->isMounted)
-               {
+       if(dev){
+               if(dev->isMounted){
                        int i;
                        int inUse;
 
                        yaffs_FlushEntireDeviceCache(dev);
                        yaffs_CheckpointSave(dev);
 
-                       for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++)
-                       {
+                       for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++){
                                if(yaffsfs_handle[i].inUse && yaffsfs_handle[i].obj->myDev == dev)
-                               {
                                        inUse = 1; // the device is in use, can't unmount
-                               }
                        }
 
-                       if(!inUse)
-                       {
+                       if(!inUse){
                                yaffs_Deinitialise(dev);
 
                                retVal = 0;
-                       }
-                       else
-                       {
+                       } else
                                // todo error can't unmount as files are open
                                yaffsfs_SetError(-EBUSY);
-                       }
 
-               }
-               else
-               {
+               } else
                        //todo error - not mounted.
                        yaffsfs_SetError(-EINVAL);
 
-               }
        }
        else
-       {
                // todo error - no device
                yaffsfs_SetError(-ENODEV);
-       }
+
        yaffsfs_Unlock();
        return retVal;
 
@@ -1578,16 +1330,12 @@ loff_t yaffs_freespace(const YCHAR *path)
 
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev  && dev->isMounted)
-       {
+       if(dev  && dev->isMounted){
                retVal = yaffs_GetNumberOfFreeChunks(dev);
                retVal *= dev->nDataBytesPerChunk;
 
-       }
-       else
-       {
+       } else
                yaffsfs_SetError(-EINVAL);
-       }
 
        yaffsfs_Unlock();
        return retVal;
@@ -1601,17 +1349,13 @@ loff_t yaffs_totalspace(const YCHAR *path)
 
        yaffsfs_Lock();
        dev = yaffsfs_FindDevice(path,&dummy);
-       if(dev  && dev->isMounted)
-       {
+       if(dev  && dev->isMounted){
                retVal = (dev->endBlock - dev->startBlock + 1) - dev->nReservedBlocks;
                retVal *= dev->nChunksPerBlock;
                retVal *= dev->nDataBytesPerChunk;
 
-       }
-       else
-       {
+       } else
                yaffsfs_SetError(-EINVAL);
-       }
 
        yaffsfs_Unlock();
        return retVal;
@@ -1631,9 +1375,8 @@ int yaffs_inodecount(const YCHAR *path)
                retVal = nObjects - dev->nHardLinks;
        }
        
-       if(retVal < 0){
+       if(retVal < 0)
                yaffsfs_SetError(-EINVAL);
-       }
        
        yaffsfs_Unlock();
        return retVal;  
@@ -1652,8 +1395,7 @@ void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList)
 
        cfg = yaffsfs_configurationList;
 
-       while(cfg && cfg->prefix && cfg->dev)
-       {
+       while(cfg && cfg->prefix && cfg->dev){
                cfg->dev->isMounted = 0;
                cfg->dev->removeObjectCallback = yaffsfs_RemoveObjectCallback;
                cfg++;
@@ -1696,12 +1438,11 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc)
 
            dsc->offset = 0;
 
-           if( ylist_empty(&dsc->dirObj->variant.directoryVariant.children)){
+           if( ylist_empty(&dsc->dirObj->variant.directoryVariant.children))
                 dsc->nextReturn = NULL;
-           } else {
+           else
                 dsc->nextReturn = ylist_entry(dsc->dirObj->variant.directoryVariant.children.next,
                                                 yaffs_Object,siblings);
-           }
         } else {
                /* Hey someone isn't playing nice! */
        }
@@ -1714,9 +1455,9 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc)
            dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
 
            if( dsc->nextReturn == NULL ||
-               ylist_empty(&dsc->dirObj->variant.directoryVariant.children)){
+               ylist_empty(&dsc->dirObj->variant.directoryVariant.children))
                 dsc->nextReturn = NULL;
-           else {
+           else {
                    struct ylist_head *next = dsc->nextReturn->siblings.next;
 
                    if( next == &dsc->dirObj->variant.directoryVariant.children)
@@ -1763,13 +1504,12 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
 
        obj = yaffsfs_FindObject(NULL,dirname,0);
 
-       if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY)
-       {
+       if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){
 
                dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext));
                dir = (yaffs_DIR *)dsc;
-               if(dsc)
-               {
+
+               if(dsc){
                        memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext));
                         dsc->magic = YAFFS_MAGIC;
                         dsc->dirObj = obj;
@@ -1780,7 +1520,8 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname)
                                 YINIT_LIST_HEAD(&search_contexts);
 
                         ylist_add(&dsc->others,&search_contexts);       
-                        yaffsfs_SetDirRewound(dsc);             }
+                        yaffsfs_SetDirRewound(dsc);
+               }
 
         }
 
@@ -1813,11 +1554,8 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp)
                        yaffsfs_DirAdvance(dsc);
                } else
                        retVal = NULL;
-       }
-       else
-       {
+       } else
                yaffsfs_SetError(-EBADF);
-       }
 
        yaffsfs_Unlock();
 
@@ -1866,11 +1604,8 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath)
        if(parent){
                obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath);
                if(obj)
-               {
                        retVal = 0;
-               }
-               else
-               {
+               else{
                        yaffsfs_SetError(-ENOSPC); // just assume no space for now
                        retVal = -1;
                }
@@ -1895,18 +1630,13 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz)
 
        obj = yaffsfs_FindObject(NULL,path,0);
 
-       if(!obj)
-       {
+       if(!obj) {
                yaffsfs_SetError(-ENOENT);
                retVal = -1;
-       }
-       else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK)
-       {
+       } else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK) {
                yaffsfs_SetError(-EINVAL);
                retVal = -1;
-       }
-       else
-       {
+       } else {
                YCHAR *alias = obj->variant.symLinkVariant.alias;
                memset(buf,0,bufsiz);
                yaffs_strncpy(buf,alias,bufsiz - 1);
@@ -1929,18 +1659,13 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
        obj = yaffsfs_FindObject(NULL,oldpath,0);
        target = yaffsfs_FindObject(NULL,newpath,0);
 
-       if(!obj)
-       {
+       if(!obj) {
                yaffsfs_SetError(-ENOENT);
                retVal = -1;
-       }
-       else if(target)
-       {
+       } else if(target) {
                yaffsfs_SetError(-EEXIST);
                retVal = -1;
-       }
-       else
-       {
+       } else {
                yaffs_Object *newdir = NULL;
                yaffs_Object *link = NULL;
 
@@ -1948,23 +1673,19 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath)
 
                newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0);
 
-               if(!newdir)
-               {
+               if(!newdir){
                        yaffsfs_SetError(-ENOTDIR);
                        retVal = -1;
-               }
-               else if(newdir->myDev != obj->myDev)
-               {
+               }else if(newdir->myDev != obj->myDev){
                        yaffsfs_SetError(-EXDEV);
                        retVal = -1;
                }
-               if(newdir && yaffs_strlen(newname) > 0)
-               {
+
+               if(newdir && yaffs_strlen(newname) > 0) {
                        link = yaffs_Link(newdir,newname,obj);
                        if(link)
                                retVal = 0;
-                       else
-                       {
+                       else{
                                yaffsfs_SetError(-ENOSPC);
                                retVal = -1;
                        }
@@ -1988,8 +1709,7 @@ int yaffs_DumpDevStruct(const YCHAR *path)
 
        yaffs_Object *obj = yaffsfs_FindRoot(path,&rest);
 
-       if(obj)
-       {
+       if(obj){
                yaffs_Device *dev = obj->myDev;
 
                printf("\n"