int retval = YAFFS_OK;
        __u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
        yaffs_ExtendedTags tags;
-       int result;
 
-       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
+       yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
 
        if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
                retval = YAFFS_FAIL;
 
        int prevChunkId;
        int retVal = 0;
-       int result = 0;
 
        int newChunkId;
        yaffs_ExtendedTags newTags;
                prevChunkId = in->chunkId;
 
                if (prevChunkId >= 0) {
-                       result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
+                       yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
                                                        buffer, &oldTags);
 
                        yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
        yaffs_Object *theObj;
        int usage;
        int i;
-       int pushout;
 
        if (dev->nShortOpCaches > 0) {
                /* Try find a non-dirty one... */
                        theObj = NULL;
                        usage = -1;
                        cache = NULL;
-                       pushout = -1;
 
                        for (i = 0; i < dev->nShortOpCaches; i++) {
                                if (dev->srCache[i].object &&
                                        usage = dev->srCache[i].lastUse;
                                        theObj = dev->srCache[i].object;
                                        cache = &dev->srCache[i];
-                                       pushout = i;
                                }
                        }
 
        int startIterator;
        int endIterator;
        int nBlocksToScan = 0;
-       int result;
 
        int chunk;
        int c;
                        /* Read the tags and decide what to do */
                        chunk = blk * dev->nChunksPerBlock + c;
 
-                       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
+                       yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
                                                        &tags);
 
                        /* Let's have a good look at this chunk... */
                                yaffs_SetChunkBit(dev, blk, c);
                                bi->pagesInUse++;
 
-                               result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk,
+                               yaffs_ReadChunkWithTagsFromNAND(dev, chunk,
                                                                chunkData,
                                                                NULL);
 
        yaffs_ObjectHeader *oh;
        yaffs_Device *dev = in->myDev;
        yaffs_ExtendedTags tags;
-       int result;
-       int alloc_failed = 0;
 
        if(!in)
                return;
                in->lazyLoaded = 0;
                chunkData = yaffs_GetTempBuffer(dev, __LINE__);
 
-               result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
+               yaffs_ReadChunkWithTagsFromNAND(dev, in->chunkId,
+                                               chunkData, &tags);
                oh = (yaffs_ObjectHeader *) chunkData;
 
                in->yst_mode = oh->yst_mode;
                if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
                         in->variant.symLinkVariant.alias =
                                                    yaffs_CloneString(oh->alias);
-                       if(!in->variant.symLinkVariant.alias)
-                               alloc_failed = 1; /* Not returned to caller */
                }
 
                yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
        int nBlocksToScan = 0;
 
        int chunk;
-       int result;
        int c;
-       int deleted;
        yaffs_BlockState state;
        yaffs_Object *hardList = NULL;
        yaffs_BlockInfo *bi;
 
                state = bi->blockState;
 
-               deleted = 0;
-
                /* For each chunk in each block that needs scanning.... */
                foundChunksInBlock = 0;
                for (c = dev->nChunksPerBlock - 1;
 
                        chunk = blk * dev->nChunksPerBlock + c;
 
-                       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
+                       yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
                                                        &tags);
 
                        /* Let's have a good look at this chunk... */
                                         * living with invalid data until needed.
                                         */
 
-                                       result = yaffs_ReadChunkWithTagsFromNAND(dev,
+                                       yaffs_ReadChunkWithTagsFromNAND(dev,
                                                                        chunk,
                                                                        chunkData,
                                                                        NULL);
        }
 #endif
        else {
-               int result;
                __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__);
 
                yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer;
                memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
 
                if (obj->chunkId >= 0) {
-                       result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
+                       yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
                                                        obj->chunkId, buffer,
                                                        NULL);
                }