Cosmetics.

6 files changed, 105 insertions, 129 deletions

diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/IPDOM.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/IPDOM.java
index 57e668b3735..26e417acd8c 100644
--- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/IPDOM.java
+++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/IPDOM.java
@@ -6,7 +6,7 @@
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
- *    Markus Schorn - initial API and implementation
+ *     Markus Schorn - initial API and implementation
  *******************************************************************************/ 
 package org.eclipse.cdt.internal.core.pdom;
 
@@ -23,5 +23,4 @@ public interface IPDOM extends IIndexFragment {
 	void addListener(PDOM.IListener listener);
 
 	void removeListener(PDOM.IListener indexView);
-
 }
diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Chunk.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Chunk.java
index a7402792bfd..d4342da6751 100644
--- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Chunk.java
+++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Chunk.java
@@ -6,9 +6,9 @@
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
- *    QNX - Initial API and implementation
- *    Markus Schorn (Wind River Systems)
- *    IBM Corporation
+ *     QNX - Initial API and implementation
+ *     Markus Schorn (Wind River Systems)
+ *     IBM Corporation
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.pdom.db;
 
@@ -26,9 +26,9 @@ final class Chunk {
 	final Database fDatabase;
 	final int fSequenceNumber;
 	
-	boolean fCacheHitFlag= false;
-	boolean fDirty= false;
-	boolean fLocked= false;	// locked chunks must not be released from cache.
+	boolean fCacheHitFlag;
+	boolean fDirty;
+	boolean fLocked;	// locked chunks must not be released from cache.
 	int fCacheIndex= -1;
 		
 	Chunk(Database db, int sequenceNumber) {
@@ -39,7 +39,7 @@ final class Chunk {
 	void read() throws CoreException {
 		try {
 			final ByteBuffer buf= ByteBuffer.wrap(fBuffer);
-			fDatabase.read(buf, (long)fSequenceNumber*Database.CHUNK_SIZE);
+			fDatabase.read(buf, (long) fSequenceNumber*Database.CHUNK_SIZE);
 		} catch (IOException e) {
 			throw new CoreException(new DBStatus(e));
 		}
@@ -48,52 +48,52 @@ final class Chunk {
 	void flush() throws CoreException {
 		try {
 			final ByteBuffer buf= ByteBuffer.wrap(fBuffer);
-			fDatabase.write(buf, (long)fSequenceNumber*Database.CHUNK_SIZE);
+			fDatabase.write(buf, (long) fSequenceNumber*Database.CHUNK_SIZE);
 		} catch (IOException e) {
 			throw new CoreException(new DBStatus(e));
 		}
 		fDirty= false;
 	}
-	private static int recPtrToIndex( final long offset ) {
-		return (int)(offset & Database.OFFSET_IN_CHUNK_MASK );
+
+	private static int recPtrToIndex(final long offset) {
+		return (int) (offset & Database.OFFSET_IN_CHUNK_MASK);
 	}
 
 	public void putByte(final long offset, final byte value) {
 		assert fLocked;
 		fDirty= true;
-		fBuffer[recPtrToIndex( offset )]= value;
+		fBuffer[recPtrToIndex(offset)]= value;
 	}
 	
 	public byte getByte(final long offset) {
-		return fBuffer[recPtrToIndex( offset )];
+		return fBuffer[recPtrToIndex(offset)];
 	}
 	
 	public byte[] getBytes(final long offset, final int length) {
 		final byte[] bytes = new byte[length];
-		System.arraycopy(fBuffer, recPtrToIndex( offset ), bytes, 0, length);
+		System.arraycopy(fBuffer, recPtrToIndex(offset), bytes, 0, length);
 		return bytes;
 	}
 	
 	public void putBytes(final long offset, final byte[] bytes) {
 		assert fLocked;
 		fDirty= true;
-		System.arraycopy(bytes, 0, fBuffer, recPtrToIndex( offset ), bytes.length);
+		System.arraycopy(bytes, 0, fBuffer, recPtrToIndex(offset), bytes.length);
 	}
 	
 	public void putInt(final long offset, final int value) {
 		assert fLocked;
 		fDirty= true;
-		int idx= recPtrToIndex( offset );
+		int idx= recPtrToIndex(offset);
 		putInt(value, fBuffer, idx);
 	}
 
 	static final void putInt(final int value, final byte[] buffer, int idx) {
-		buffer[idx]=   (byte)(value >> 24);
-		buffer[++idx]= (byte)(value >> 16);
-		buffer[++idx]= (byte)(value >> 8);
-		buffer[++idx]= (byte)(value);
+		buffer[idx]=   (byte) (value >> 24);
+		buffer[++idx]= (byte) (value >> 16);
+		buffer[++idx]= (byte) (value >> 8);
+		buffer[++idx]= (byte) (value);
 	}
-
 	
 	public int getInt(final long offset) {
 		return getInt(fBuffer, recPtrToIndex(offset));
@@ -106,7 +106,6 @@ final class Chunk {
 			((buffer[++idx] & 0xff) <<  0);
 	}
 
-
 	/**
 	 * A free Record Pointer is a pointer to a raw block, i.e. the
 	 * pointer is not moved past the BLOCK_HEADER_SIZE.
@@ -119,8 +118,8 @@ final class Chunk {
 	}
 	
 	/**
-	 * A free Record Pointer is a pointer to a raw block, i.e. the
-	 * pointer is not moved past the BLOCK_HEADER_SIZE.
+	 * A free Record Pointer is a pointer to a raw block,
+	 * i.e. the pointer is not moved past the BLOCK_HEADER_SIZE.
 	 */
 	private static long expandToFreeRecPtr(int value) {
 		/*
@@ -134,7 +133,6 @@ final class Chunk {
 		return address << Database.BLOCK_SIZE_DELTA_BITS;
 	}
 
-
 	/**
 	 * A Record Pointer is a pointer as returned by Database.malloc().
 	 * This is a pointer to a block + BLOCK_HEADER_SIZE.
@@ -164,11 +162,10 @@ final class Chunk {
 		int idx = recPtrToIndex(offset);
 		putRecPtr(value, fBuffer, idx);
 	}
-
 	
 	/**
-	 * A free Record Pointer is a pointer to a raw block, i.e. the
-	 * pointer is not moved past the BLOCK_HEADER_SIZE.
+	 * A free Record Pointer is a pointer to a raw block,
+	 * i.e. the pointer is not moved past the BLOCK_HEADER_SIZE.
 	 */
 	public void putFreeRecPtr(final long offset, final long value) {
 		assert fLocked;
@@ -191,14 +188,14 @@ final class Chunk {
 	public void put3ByteUnsignedInt(final long offset, final int value) {
 		assert fLocked;
 		fDirty= true;
-		int idx= recPtrToIndex( offset );
-		fBuffer[idx]= (byte)(value >> 16);
-		fBuffer[++idx]= (byte)(value >> 8);
-		fBuffer[++idx]= (byte)(value);
+		int idx= recPtrToIndex(offset);
+		fBuffer[idx]= (byte) (value >> 16);
+		fBuffer[++idx]= (byte) (value >> 8);
+		fBuffer[++idx]= (byte) (value);
 	}
 	
 	public int get3ByteUnsignedInt(final long offset) {
-		int idx= recPtrToIndex( offset );
+		int idx= recPtrToIndex(offset);
 		return ((fBuffer[idx] & 0xff) << 16) |
 			((fBuffer[++idx] & 0xff) <<  8) |
 			((fBuffer[++idx] & 0xff) <<  0);
@@ -207,60 +204,60 @@ final class Chunk {
 	public void putShort(final long offset, final short value) {
 		assert fLocked;
 		fDirty= true;
-		int idx= recPtrToIndex( offset );
-		fBuffer[idx]= (byte)(value >> 8);
-		fBuffer[++idx]= (byte)(value);
+		int idx= recPtrToIndex(offset);
+		fBuffer[idx]= (byte) (value >> 8);
+		fBuffer[++idx]= (byte) (value);
 	}
 	
 	public short getShort(final long offset) {
-		int idx= recPtrToIndex( offset );
+		int idx= recPtrToIndex(offset);
 		return (short) (((fBuffer[idx] << 8) | (fBuffer[++idx] & 0xff)));
 	}
 
 	public long getLong(final long offset) {
-		int idx= recPtrToIndex( offset );
-		return ((((long)fBuffer[idx] & 0xff) << 56) |
-				(((long)fBuffer[++idx] & 0xff) << 48) |
-				(((long)fBuffer[++idx] & 0xff) << 40) |
-				(((long)fBuffer[++idx] & 0xff) << 32) |
-				(((long)fBuffer[++idx] & 0xff) << 24) |
-				(((long)fBuffer[++idx] & 0xff) << 16) |
-				(((long)fBuffer[++idx] & 0xff) <<  8) |
-				(((long)fBuffer[++idx] & 0xff) <<  0));
+		int idx= recPtrToIndex(offset);
+		return ((((long) fBuffer[idx] & 0xff) << 56) |
+				(((long) fBuffer[++idx] & 0xff) << 48) |
+				(((long) fBuffer[++idx] & 0xff) << 40) |
+				(((long) fBuffer[++idx] & 0xff) << 32) |
+				(((long) fBuffer[++idx] & 0xff) << 24) |
+				(((long) fBuffer[++idx] & 0xff) << 16) |
+				(((long) fBuffer[++idx] & 0xff) <<  8) |
+				(((long) fBuffer[++idx] & 0xff) <<  0));
 	}
 
 	public void putLong(final long offset, final long value) {
 		assert fLocked;
 		fDirty= true;
-		int idx= recPtrToIndex( offset );
+		int idx= recPtrToIndex(offset);
 
-		fBuffer[idx]=   (byte)(value >> 56);
-		fBuffer[++idx]= (byte)(value >> 48);
-		fBuffer[++idx]= (byte)(value >> 40);
-		fBuffer[++idx]= (byte)(value >> 32);
-		fBuffer[++idx]= (byte)(value >> 24);
-		fBuffer[++idx]= (byte)(value >> 16);
-		fBuffer[++idx]= (byte)(value >> 8);
-		fBuffer[++idx]= (byte)(value);
+		fBuffer[idx]=   (byte) (value >> 56);
+		fBuffer[++idx]= (byte) (value >> 48);
+		fBuffer[++idx]= (byte) (value >> 40);
+		fBuffer[++idx]= (byte) (value >> 32);
+		fBuffer[++idx]= (byte) (value >> 24);
+		fBuffer[++idx]= (byte) (value >> 16);
+		fBuffer[++idx]= (byte) (value >> 8);
+		fBuffer[++idx]= (byte) (value);
 	}
 	
 	public void putChar(final long offset, final char value) {
 		assert fLocked;
 		fDirty= true;
-		int idx= recPtrToIndex( offset );
-		fBuffer[idx]= (byte)(value >> 8);
-		fBuffer[++idx]= (byte)(value);
+		int idx= recPtrToIndex(offset);
+		fBuffer[idx]= (byte) (value >> 8);
+		fBuffer[++idx]= (byte) (value);
 	}
 	
 	public void putChars(final long offset, char[] chars, int start, int len) {
 		assert fLocked;
 		fDirty= true;
 		int idx= recPtrToIndex(offset)-1;
-		final int end= start+len;
+		final int end= start + len;
 		for (int i = start; i < end; i++) {
 			char value= chars[i];
-			fBuffer[++idx]= (byte)(value >> 8);
-			fBuffer[++idx]= (byte)(value);
+			fBuffer[++idx]= (byte) (value >> 8);
+			fBuffer[++idx]= (byte) (value);
 		}
 	}
 
@@ -268,28 +265,28 @@ final class Chunk {
 		assert fLocked;
 		fDirty= true;
 		int idx= recPtrToIndex(offset)-1;
-		final int end= start+len;
+		final int end= start + len;
 		for (int i = start; i < end; i++) {
 			char value= chars[i];
-			fBuffer[++idx]= (byte)(value);
+			fBuffer[++idx]= (byte) (value);
 		}
 	}
 
 	public char getChar(final long offset) {
-		int idx= recPtrToIndex( offset );
+		int idx= recPtrToIndex(offset);
 		return (char) (((fBuffer[idx] << 8) | (fBuffer[++idx] & 0xff)));
 	}
 
 	public void getChars(final long offset, final char[] result, int start, int len) {
 		final ByteBuffer buf= ByteBuffer.wrap(fBuffer);
-		buf.position(recPtrToIndex( offset ));
+		buf.position(recPtrToIndex(offset));
 		buf.asCharBuffer().get(result, start, len);
 	}
 
 	public void getCharsFromBytes(final long offset, final char[] result, int start, int len) {
 		final int pos = recPtrToIndex(offset);
 		for (int i = 0; i < len; i++) {
-			result[start+i] =  (char) (fBuffer[pos+i] & 0xff);
+			result[start + i] =  (char) (fBuffer[pos + i] & 0xff);
 		}
 	}
 
@@ -307,8 +304,8 @@ final class Chunk {
 		assert fLocked;
 		fDirty= true;
 		int idx = recPtrToIndex(offset);
-		int i=0;
-		while (i<len) {
+		int i= 0;
+		while (i < len) {
 			fBuffer[idx++]= data[i++];
 		}
 	}
diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/ChunkCache.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/ChunkCache.java
index 84dded98fe3..19af4eb2cf1 100644
--- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/ChunkCache.java
+++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/ChunkCache.java
@@ -6,24 +6,23 @@
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
- *    Markus Schorn - initial API and implementation
+ *     Markus Schorn - initial API and implementation
  *******************************************************************************/ 
-
 package org.eclipse.cdt.internal.core.pdom.db;
 
 public final class ChunkCache {
 	private static ChunkCache sSharedInstance= new ChunkCache();
 	
 	private Chunk[] fPageTable;
-	private boolean fTableIsFull= false;
-	private int fPointer= 0;
+	private boolean fTableIsFull;
+	private int fPointer;
 	
 	public static ChunkCache getSharedInstance() {
 		return sSharedInstance;
 	}
 
 	public ChunkCache() {
-		this(5*1024*1024);
+		this(5 * 1024 * 1024);
 	}
 	
 	public ChunkCache(long maxSize) {
@@ -42,8 +41,7 @@ public final class ChunkCache {
 			evictChunk();
 			chunk.fCacheIndex= fPointer;
 			fPageTable[fPointer]= chunk;
-		}
-		else {
+		} else {
 			chunk.fCacheIndex= fPointer;
 			fPageTable[fPointer]= chunk;
 
@@ -88,8 +86,7 @@ public final class ChunkCache {
 			if (fTableIsFull) {
 				fPointer= fPageTable.length-1;
 				fTableIsFull= false;
-			}
-			else {
+			} else {
 				fPointer--;
 			}
 			chunk.fCacheIndex= -1;
@@ -121,9 +118,8 @@ public final class ChunkCache {
 			fTableIsFull= false;
 			fPointer= oldLength;
 			fPageTable= newTable;
-		}
-		else {
-			for (int i=newLength; i<oldLength; i++) {
+		} else {
+			for (int i= newLength; i < oldLength; i++) {
 				final Chunk chunk= fPageTable[i];
 				chunk.fDatabase.releaseChunk(chunk);
 				chunk.fCacheIndex= -1;
diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Database.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Database.java
index 4c883a97467..33248fba103 100644
--- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Database.java
+++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Database.java
@@ -29,7 +29,6 @@ import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.osgi.util.NLS;
 
-
 /**
  * Database encapsulates access to a flat binary format file with a memory-manager-like API for
  * obtaining and releasing areas of storage (memory).
@@ -126,8 +125,7 @@ public class Database {
 				fVersion= version;
 				fChunks= new Chunk[1];
 				fChunksUsed = fChunksAllocated = fChunks.length;
-			}
-			else {
+			} else {
 				fHeaderChunk.read();
 				fVersion= fHeaderChunk.getInt(VERSION_OFFSET);
 				fChunks = new Chunk[nChunksOnDisk];	// chunk[0] is unused.
@@ -148,8 +146,7 @@ public class Database {
 			try {
 				fFile.getChannel().read(buf, position);
 				return;
-			}
-			catch (ClosedChannelException e) {
+			} catch (ClosedChannelException e) {
 				// bug 219834 file may have be closed by interrupting a thread during an I/O operation.
 				reopen(e, ++retries);
 			} 
@@ -158,16 +155,15 @@ public class Database {
 
 	void write(ByteBuffer buf, long position) throws IOException {
 		int retries= 0;
-		do {
+		while (true) {
 			try {
 				fFile.getChannel().write(buf, position);
 				return;
-			}
-			catch (ClosedChannelException e) {
+			} catch (ClosedChannelException e) {
 				// bug 219834 file may have be closed by interrupting a thread during an I/O operation.
 				reopen(e, ++retries);
 			} 
-		} while(true);
+		}
 	}
 
 	private void reopen(ClosedChannelException e, int attempt) throws ClosedChannelException, FileNotFoundException {
@@ -178,7 +174,6 @@ public class Database {
 		openFile();
 	}
 
-
 	public void transferTo(FileChannel target) throws IOException {
 		assert fLocked;
         final FileChannel from= fFile.getChannel();
@@ -222,8 +217,7 @@ public class Database {
 		try {
 			fHeaderChunk.flush();	// zero out header chunk
 			fFile.getChannel().truncate(CHUNK_SIZE);	// truncate database
-		}
-		catch (IOException e) {
+		} catch (IOException e) {
 			CCorePlugin.log(e);
 		}
 		malloced = freed = 0;
@@ -236,17 +230,17 @@ public class Database {
 		 * 8388608 for a file starting at 32G
 		 * 
 		 */
-		long setasideChunks = Long.getLong("org.eclipse.cdt.core.parser.pdom.dense.recptr.setaside.chunks", 0 ); //$NON-NLS-1$
-		if( setasideChunks != 0 ) {
-			setVersion( getVersion() );
-			createNewChunks( (int) setasideChunks );
+		long setasideChunks = Long.getLong("org.eclipse.cdt.core.parser.pdom.dense.recptr.setaside.chunks", 0); //$NON-NLS-1$
+		if (setasideChunks != 0) {
+			setVersion(getVersion());
+			createNewChunks((int) setasideChunks);
 			flush();
 		}
 	}
 
 	private void removeChunksFromCache() {
 		synchronized (fCache) {
-			for (int i=1; i < fChunks.length; i++) {
+			for (int i= 1; i < fChunks.length; i++) {
 				Chunk chunk= fChunks[i];
 				if (chunk != null) {
 					fCache.remove(chunk);
@@ -256,7 +250,6 @@ public class Database {
 		}
 	}
 	
-	
 	/**
 	 * Return the Chunk that contains the given offset.
 	 * @throws CoreException 
@@ -268,7 +261,7 @@ public class Database {
 		long long_index = offset / CHUNK_SIZE;
 		assert long_index < Integer.MAX_VALUE; 
 
-		synchronized(fCache) {
+		synchronized (fCache) {
 			assert fLocked;
 			final int index = (int)long_index;
 			Chunk chunk= fChunks[index];
@@ -276,8 +269,7 @@ public class Database {
 				cacheMisses++;
 				chunk = fChunks[index] = new Chunk(this, index);
 				chunk.read();
-			}
-			else {
+			} else {
 				cacheHits++;
 			}
 			fCache.add(chunk, fExclusiveLock);
@@ -359,7 +351,7 @@ public class Database {
 			long address = (long) newChunkIndex * CHUNK_SIZE;
 
 			/*
-			 * non-dense pointers are at most 31 bits dense pointers are at most 35 bits Check the sizes here
+			 * Non-dense pointers are at most 31 bits dense pointers are at most 35 bits Check the sizes here
 			 * and throw an exception if the address is too large. By throwing the CoreException with the
 			 * special status, the indexing operation should be stopped. This is desired since generally, once
 			 * the max size is exceeded, there are lots of errors.
@@ -375,7 +367,7 @@ public class Database {
 	}
 
 	/**
-	 * for testing purposes, only.
+	 * For testing purposes, only.
 	 */
 	private long createNewChunks(int numChunks) throws CoreException {
 		assert fExclusiveLock;
@@ -383,7 +375,7 @@ public class Database {
 			final int oldLen= fChunks.length;
 			Chunk[] newchunks = new Chunk[oldLen+numChunks];
 			System.arraycopy(fChunks, 0, newchunks, 0, oldLen);
-			for( int i = oldLen; i < oldLen + numChunks; i++ ) {
+			for (int i = oldLen; i < oldLen + numChunks; i++) {
 				newchunks[i]= null;
 			}
 			final Chunk chunk= new Chunk(this, oldLen + numChunks - 1);
@@ -393,7 +385,7 @@ public class Database {
 			fCache.add(chunk, true);
 			fChunksAllocated=oldLen+numChunks;
 			fChunksUsed=oldLen+numChunks;
-			return (long)(oldLen + numChunks - 1) * CHUNK_SIZE;
+			return (long) (oldLen + numChunks - 1) * CHUNK_SIZE;
 		}
 	}
 	
@@ -411,10 +403,11 @@ public class Database {
 		assert fExclusiveLock;
 		long prevblock = chunk.getFreeRecPtr(block + BLOCK_PREV_OFFSET);
 		long nextblock = chunk.getFreeRecPtr(block + BLOCK_NEXT_OFFSET);
-		if (prevblock != 0)
+		if (prevblock != 0) {
 			putFreeRecPtr(prevblock + BLOCK_NEXT_OFFSET, nextblock);
-		else // we were the head
+		} else { // we were the head
 			setFirstBlock(blocksize, nextblock);
+		}
 			
 		if (nextblock != 0)
 			putFreeRecPtr(nextblock + BLOCK_PREV_OFFSET, prevblock);
@@ -543,10 +536,11 @@ public class Database {
 			bytelen= 2*len;
 		}
 		
-		if (bytelen > ShortString.MAX_BYTE_LENGTH)
+		if (bytelen > ShortString.MAX_BYTE_LENGTH) {
 			return new LongString(this, chars, useBytes);
-		else
+		} else {
 			return new ShortString(this, chars, useBytes);
+		}
 	}
 	
 	private boolean useBytes(char[] chars) {
@@ -557,11 +551,9 @@ public class Database {
 		return true;
 	}
 
-
-
 	public IString getString(long offset) throws CoreException {
 		final int l = getInt(offset);
-		int bytelen= l<0 ? -l : 2*l;
+		int bytelen= l < 0 ? -l : 2 * l;
 		if (bytelen > ShortString.MAX_BYTE_LENGTH) {
 			return new LongString(this, offset);
 		}
@@ -661,24 +653,20 @@ public class Database {
 								// locked chunk that has been removed from cache.
 								if (chunk.fDirty) {
 									dirtyChunks.add(chunk); // keep in fChunks until it is flushed.
-								}
-								else {
+								} else {
 									chunk.fLocked= false;
 									fChunks[i]= null;
 								}
-							}
-							else if (chunk.fLocked) {
+							} else if (chunk.fLocked) {
 								// locked chunk, still in cache.
 								if (chunk.fDirty) {
 									if (flush) {
 										dirtyChunks.add(chunk);
 									}
-								}
-								else {
+								} else {
 									chunk.fLocked= false;
 								}
-							}
-							else {
+							} else {
 								assert !chunk.fDirty; // dirty chunks must be locked.
 							}
 						}
@@ -698,8 +686,7 @@ public class Database {
 		if (fExclusiveLock) {
 			try {
 				giveUpExclusiveLock(true);
-			}
-			finally {
+			} finally {
 				setExclusiveLock();
 			}
 			return;
diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/IBTreeComparator.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/IBTreeComparator.java
index 530b8d11c24..e1a7d24fb7a 100644
--- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/IBTreeComparator.java
+++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/IBTreeComparator.java
@@ -6,7 +6,7 @@
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
- * QNX - Initial API and implementation
+ *     QNX - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.pdom.db;
 
@@ -14,13 +14,10 @@ import org.eclipse.core.runtime.CoreException;
 
 /**
  * @author Doug Schaefer
- *
  */
 public interface IBTreeComparator {
-
 	/**
 	 * Compare two records. Used for insert.
 	 */
 	public abstract int compare(long record1, long record2) throws CoreException;
-	
 }
diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMInclude.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMInclude.java
index c95429ef55a..c5c086d5257 100644
--- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMInclude.java
+++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMInclude.java
@@ -53,8 +53,8 @@ public class PDOMInclude implements IIndexFragmentInclude {
 	// Cached fields
 	private String fName;
 
-	public PDOMInclude(PDOMLinkage pdom, long record) {
-		this.linkage = pdom;
+	public PDOMInclude(PDOMLinkage linkage, long record) {
+		this.linkage = linkage;
 		this.record = record;
 	}