mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-04-29 19:45:01 +02:00
Code Issues Wiki Activity

Cosmetics.

Browse source
This commit is contained in:
Sergey Prigogin 2012-05-03 20:05:12 -07:00
parent d2c19fcd47
commit fac58cefa1
6 changed files with 105 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/IPDOM.java
View file

@ -6,7 +6,7 @@
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* Markus Schorn - initial API and implementation * Markus Schorn - initial API and implementation
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom; package org.eclipse.cdt.internal.core.pdom;
@ -23,5 +23,4 @@ public interface IPDOM extends IIndexFragment {
void addListener(PDOM.IListener listener); void addListener(PDOM.IListener listener);
void removeListener(PDOM.IListener indexView); void removeListener(PDOM.IListener indexView);
} }

131
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Chunk.java
View file

@ -6,9 +6,9 @@
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* QNX - Initial API and implementation * QNX - Initial API and implementation
* Markus Schorn (Wind River Systems) * Markus Schorn (Wind River Systems)
* IBM Corporation * IBM Corporation
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom.db; package org.eclipse.cdt.internal.core.pdom.db;
@ -26,9 +26,9 @@ final class Chunk {
final Database fDatabase; final Database fDatabase;
final int fSequenceNumber; final int fSequenceNumber;
boolean fCacheHitFlag= false; boolean fCacheHitFlag;
boolean fDirty= false; boolean fDirty;
boolean fLocked= false; // locked chunks must not be released from cache. boolean fLocked; // locked chunks must not be released from cache.
int fCacheIndex= -1; int fCacheIndex= -1;
Chunk(Database db, int sequenceNumber) { Chunk(Database db, int sequenceNumber) {
@ -39,7 +39,7 @@ final class Chunk {
void read() throws CoreException { void read() throws CoreException {
try { try {
final ByteBuffer buf= ByteBuffer.wrap(fBuffer); 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) { } catch (IOException e) {
throw new CoreException(new DBStatus(e)); throw new CoreException(new DBStatus(e));
} }
@ -48,52 +48,52 @@ final class Chunk {
void flush() throws CoreException { void flush() throws CoreException {
try { try {
final ByteBuffer buf= ByteBuffer.wrap(fBuffer); 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) { } catch (IOException e) {
throw new CoreException(new DBStatus(e)); throw new CoreException(new DBStatus(e));
} }
fDirty= false; 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) { public void putByte(final long offset, final byte value) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
fBuffer[recPtrToIndex( offset )]= value; fBuffer[recPtrToIndex(offset)]= value;
} }
public byte getByte(final long offset) { public byte getByte(final long offset) {
return fBuffer[recPtrToIndex( offset )]; return fBuffer[recPtrToIndex(offset)];
} }
public byte[] getBytes(final long offset, final int length) { public byte[] getBytes(final long offset, final int length) {
final byte[] bytes = new byte[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; return bytes;
} }
public void putBytes(final long offset, final byte[] bytes) { public void putBytes(final long offset, final byte[] bytes) {
assert fLocked; assert fLocked;
fDirty= true; 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) { public void putInt(final long offset, final int value) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
putInt(value, fBuffer, idx); putInt(value, fBuffer, idx);
} }
static final void putInt(final int value, final byte[] buffer, int idx) { static final void putInt(final int value, final byte[] buffer, int idx) {
buffer[idx]= (byte)(value >> 24); buffer[idx]= (byte) (value >> 24);
buffer[++idx]= (byte)(value >> 16); buffer[++idx]= (byte) (value >> 16);
buffer[++idx]= (byte)(value >> 8); buffer[++idx]= (byte) (value >> 8);
buffer[++idx]= (byte)(value); buffer[++idx]= (byte) (value);
} }
public int getInt(final long offset) { public int getInt(final long offset) {
return getInt(fBuffer, recPtrToIndex(offset)); return getInt(fBuffer, recPtrToIndex(offset));
@ -106,7 +106,6 @@ final class Chunk {
((buffer[++idx] & 0xff) << 0); ((buffer[++idx] & 0xff) << 0);
} }
/** /**
* A free Record Pointer is a pointer to a raw block, i.e. the * A free Record Pointer is a pointer to a raw block, i.e. the
* pointer is not moved past the BLOCK_HEADER_SIZE. * 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 * A free Record Pointer is a pointer to a raw block,
* pointer is not moved past the BLOCK_HEADER_SIZE. * i.e. the pointer is not moved past the BLOCK_HEADER_SIZE.
*/ */
private static long expandToFreeRecPtr(int value) { private static long expandToFreeRecPtr(int value) {
/* /*
@ -134,7 +133,6 @@ final class Chunk {
return address << Database.BLOCK_SIZE_DELTA_BITS; return address << Database.BLOCK_SIZE_DELTA_BITS;
} }
/** /**
* A Record Pointer is a pointer as returned by Database.malloc(). * A Record Pointer is a pointer as returned by Database.malloc().
* This is a pointer to a block + BLOCK_HEADER_SIZE. * This is a pointer to a block + BLOCK_HEADER_SIZE.
@ -164,11 +162,10 @@ final class Chunk {
int idx = recPtrToIndex(offset); int idx = recPtrToIndex(offset);
putRecPtr(value, fBuffer, idx); putRecPtr(value, fBuffer, idx);
} }
/** /**
* A free Record Pointer is a pointer to a raw block, i.e. the * A free Record Pointer is a pointer to a raw block,
* pointer is not moved past the BLOCK_HEADER_SIZE. * i.e. the pointer is not moved past the BLOCK_HEADER_SIZE.
*/ */
public void putFreeRecPtr(final long offset, final long value) { public void putFreeRecPtr(final long offset, final long value) {
assert fLocked; assert fLocked;
@ -191,14 +188,14 @@ final class Chunk {
public void put3ByteUnsignedInt(final long offset, final int value) { public void put3ByteUnsignedInt(final long offset, final int value) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
fBuffer[idx]= (byte)(value >> 16); fBuffer[idx]= (byte) (value >> 16);
fBuffer[++idx]= (byte)(value >> 8); fBuffer[++idx]= (byte) (value >> 8);
fBuffer[++idx]= (byte)(value); fBuffer[++idx]= (byte) (value);
} }
public int get3ByteUnsignedInt(final long offset) { public int get3ByteUnsignedInt(final long offset) {
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
return ((fBuffer[idx] & 0xff) << 16) | return ((fBuffer[idx] & 0xff) << 16) |
((fBuffer[++idx] & 0xff) << 8) | ((fBuffer[++idx] & 0xff) << 8) |
((fBuffer[++idx] & 0xff) << 0); ((fBuffer[++idx] & 0xff) << 0);
@ -207,60 +204,60 @@ final class Chunk {
public void putShort(final long offset, final short value) { public void putShort(final long offset, final short value) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
fBuffer[idx]= (byte)(value >> 8); fBuffer[idx]= (byte) (value >> 8);
fBuffer[++idx]= (byte)(value); fBuffer[++idx]= (byte) (value);
} }
public short getShort(final long offset) { public short getShort(final long offset) {
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
return (short) (((fBuffer[idx] << 8) | (fBuffer[++idx] & 0xff))); return (short) (((fBuffer[idx] << 8) | (fBuffer[++idx] & 0xff)));
} }
public long getLong(final long offset) { public long getLong(final long offset) {
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
return ((((long)fBuffer[idx] & 0xff) << 56) | return ((((long) fBuffer[idx] & 0xff) << 56) |
(((long)fBuffer[++idx] & 0xff) << 48) | (((long) fBuffer[++idx] & 0xff) << 48) |
(((long)fBuffer[++idx] & 0xff) << 40) | (((long) fBuffer[++idx] & 0xff) << 40) |
(((long)fBuffer[++idx] & 0xff) << 32) | (((long) fBuffer[++idx] & 0xff) << 32) |
(((long)fBuffer[++idx] & 0xff) << 24) | (((long) fBuffer[++idx] & 0xff) << 24) |
(((long)fBuffer[++idx] & 0xff) << 16) | (((long) fBuffer[++idx] & 0xff) << 16) |
(((long)fBuffer[++idx] & 0xff) << 8) | (((long) fBuffer[++idx] & 0xff) << 8) |
(((long)fBuffer[++idx] & 0xff) << 0)); (((long) fBuffer[++idx] & 0xff) << 0));
} }
public void putLong(final long offset, final long value) { public void putLong(final long offset, final long value) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
fBuffer[idx]= (byte)(value >> 56); fBuffer[idx]= (byte) (value >> 56);
fBuffer[++idx]= (byte)(value >> 48); fBuffer[++idx]= (byte) (value >> 48);
fBuffer[++idx]= (byte)(value >> 40); fBuffer[++idx]= (byte) (value >> 40);
fBuffer[++idx]= (byte)(value >> 32); fBuffer[++idx]= (byte) (value >> 32);
fBuffer[++idx]= (byte)(value >> 24); fBuffer[++idx]= (byte) (value >> 24);
fBuffer[++idx]= (byte)(value >> 16); fBuffer[++idx]= (byte) (value >> 16);
fBuffer[++idx]= (byte)(value >> 8); fBuffer[++idx]= (byte) (value >> 8);
fBuffer[++idx]= (byte)(value); fBuffer[++idx]= (byte) (value);
} }
public void putChar(final long offset, final char value) { public void putChar(final long offset, final char value) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
fBuffer[idx]= (byte)(value >> 8); fBuffer[idx]= (byte) (value >> 8);
fBuffer[++idx]= (byte)(value); fBuffer[++idx]= (byte) (value);
} }
public void putChars(final long offset, char[] chars, int start, int len) { public void putChars(final long offset, char[] chars, int start, int len) {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex(offset)-1; int idx= recPtrToIndex(offset)-1;
final int end= start+len; final int end= start + len;
for (int i = start; i < end; i++) { for (int i = start; i < end; i++) {
char value= chars[i]; char value= chars[i];
fBuffer[++idx]= (byte)(value >> 8); fBuffer[++idx]= (byte) (value >> 8);
fBuffer[++idx]= (byte)(value); fBuffer[++idx]= (byte) (value);
} }
} }
@ -268,28 +265,28 @@ final class Chunk {
assert fLocked; assert fLocked;
fDirty= true; fDirty= true;
int idx= recPtrToIndex(offset)-1; int idx= recPtrToIndex(offset)-1;
final int end= start+len; final int end= start + len;
for (int i = start; i < end; i++) { for (int i = start; i < end; i++) {
char value= chars[i]; char value= chars[i];
fBuffer[++idx]= (byte)(value); fBuffer[++idx]= (byte) (value);
} }
} }
public char getChar(final long offset) { public char getChar(final long offset) {
int idx= recPtrToIndex( offset ); int idx= recPtrToIndex(offset);
return (char) (((fBuffer[idx] << 8) | (fBuffer[++idx] & 0xff))); return (char) (((fBuffer[idx] << 8) | (fBuffer[++idx] & 0xff)));
} }
public void getChars(final long offset, final char[] result, int start, int len) { public void getChars(final long offset, final char[] result, int start, int len) {
final ByteBuffer buf= ByteBuffer.wrap(fBuffer); final ByteBuffer buf= ByteBuffer.wrap(fBuffer);
buf.position(recPtrToIndex( offset )); buf.position(recPtrToIndex(offset));
buf.asCharBuffer().get(result, start, len); buf.asCharBuffer().get(result, start, len);
} }
public void getCharsFromBytes(final long offset, final char[] result, int start, int len) { public void getCharsFromBytes(final long offset, final char[] result, int start, int len) {
final int pos = recPtrToIndex(offset); final int pos = recPtrToIndex(offset);
for (int i = 0; i < len; i++) { 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; assert fLocked;
fDirty= true; fDirty= true;
int idx = recPtrToIndex(offset); int idx = recPtrToIndex(offset);
int i=0; int i= 0;
while (i<len) { while (i < len) {
fBuffer[idx++]= data[i++]; fBuffer[idx++]= data[i++];
} }
} }

20
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/ChunkCache.java
View file

@ -6,24 +6,23 @@
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* Markus Schorn - initial API and implementation * Markus Schorn - initial API and implementation
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom.db; package org.eclipse.cdt.internal.core.pdom.db;
public final class ChunkCache { public final class ChunkCache {
private static ChunkCache sSharedInstance= new ChunkCache(); private static ChunkCache sSharedInstance= new ChunkCache();
private Chunk[] fPageTable; private Chunk[] fPageTable;
private boolean fTableIsFull= false; private boolean fTableIsFull;
private int fPointer= 0; private int fPointer;
public static ChunkCache getSharedInstance() { public static ChunkCache getSharedInstance() {
return sSharedInstance; return sSharedInstance;
} }
public ChunkCache() { public ChunkCache() {
this(5*1024*1024); this(5 * 1024 * 1024);
} }
public ChunkCache(long maxSize) { public ChunkCache(long maxSize) {
@ -42,8 +41,7 @@ public final class ChunkCache {
evictChunk(); evictChunk();
chunk.fCacheIndex= fPointer; chunk.fCacheIndex= fPointer;
fPageTable[fPointer]= chunk; fPageTable[fPointer]= chunk;
} } else {
else {
chunk.fCacheIndex= fPointer; chunk.fCacheIndex= fPointer;
fPageTable[fPointer]= chunk; fPageTable[fPointer]= chunk;
@ -88,8 +86,7 @@ public final class ChunkCache {
if (fTableIsFull) { if (fTableIsFull) {
fPointer= fPageTable.length-1; fPointer= fPageTable.length-1;
fTableIsFull= false; fTableIsFull= false;
} } else {
else {
fPointer--; fPointer--;
} }
chunk.fCacheIndex= -1; chunk.fCacheIndex= -1;
@ -121,9 +118,8 @@ public final class ChunkCache {
fTableIsFull= false; fTableIsFull= false;
fPointer= oldLength; fPointer= oldLength;
fPageTable= newTable; fPageTable= newTable;
} } else {
else { for (int i= newLength; i < oldLength; i++) {
for (int i=newLength; i<oldLength; i++) {
final Chunk chunk= fPageTable[i]; final Chunk chunk= fPageTable[i];
chunk.fDatabase.releaseChunk(chunk); chunk.fDatabase.releaseChunk(chunk);
chunk.fCacheIndex= -1; chunk.fCacheIndex= -1;

71
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/Database.java
View file

@ -29,7 +29,6 @@ import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.Status;
import org.eclipse.osgi.util.NLS; import org.eclipse.osgi.util.NLS;
/** /**
* Database encapsulates access to a flat binary format file with a memory-manager-like API for * Database encapsulates access to a flat binary format file with a memory-manager-like API for
* obtaining and releasing areas of storage (memory). * obtaining and releasing areas of storage (memory).
@ -126,8 +125,7 @@ public class Database {
fVersion= version; fVersion= version;
fChunks= new Chunk[1]; fChunks= new Chunk[1];
fChunksUsed = fChunksAllocated = fChunks.length; fChunksUsed = fChunksAllocated = fChunks.length;
} } else {
else {
fHeaderChunk.read(); fHeaderChunk.read();
fVersion= fHeaderChunk.getInt(VERSION_OFFSET); fVersion= fHeaderChunk.getInt(VERSION_OFFSET);
fChunks = new Chunk[nChunksOnDisk]; // chunk[0] is unused. fChunks = new Chunk[nChunksOnDisk]; // chunk[0] is unused.
@ -148,8 +146,7 @@ public class Database {
try { try {
fFile.getChannel().read(buf, position); fFile.getChannel().read(buf, position);
return; return;
} } catch (ClosedChannelException e) {
catch (ClosedChannelException e) {
// bug 219834 file may have be closed by interrupting a thread during an I/O operation. // bug 219834 file may have be closed by interrupting a thread during an I/O operation.
reopen(e, ++retries); reopen(e, ++retries);
} }
@ -158,16 +155,15 @@ public class Database {
void write(ByteBuffer buf, long position) throws IOException { void write(ByteBuffer buf, long position) throws IOException {
int retries= 0; int retries= 0;
do { while (true) {
try { try {
fFile.getChannel().write(buf, position); fFile.getChannel().write(buf, position);
return; return;
} } catch (ClosedChannelException e) {
catch (ClosedChannelException e) {
// bug 219834 file may have be closed by interrupting a thread during an I/O operation. // bug 219834 file may have be closed by interrupting a thread during an I/O operation.
reopen(e, ++retries); reopen(e, ++retries);
} }
} while(true); }
} }
private void reopen(ClosedChannelException e, int attempt) throws ClosedChannelException, FileNotFoundException { private void reopen(ClosedChannelException e, int attempt) throws ClosedChannelException, FileNotFoundException {
@ -178,7 +174,6 @@ public class Database {
openFile(); openFile();
} }
public void transferTo(FileChannel target) throws IOException { public void transferTo(FileChannel target) throws IOException {
assert fLocked; assert fLocked;
final FileChannel from= fFile.getChannel(); final FileChannel from= fFile.getChannel();
@ -222,8 +217,7 @@ public class Database {
try { try {
fHeaderChunk.flush(); // zero out header chunk fHeaderChunk.flush(); // zero out header chunk
fFile.getChannel().truncate(CHUNK_SIZE); // truncate database fFile.getChannel().truncate(CHUNK_SIZE); // truncate database
} } catch (IOException e) {
catch (IOException e) {
CCorePlugin.log(e); CCorePlugin.log(e);
} }
malloced = freed = 0; malloced = freed = 0;
@ -236,17 +230,17 @@ public class Database {
* 8388608 for a file starting at 32G * 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$ long setasideChunks = Long.getLong("org.eclipse.cdt.core.parser.pdom.dense.recptr.setaside.chunks", 0); //$NON-NLS-1$
if( setasideChunks != 0 ) { if (setasideChunks != 0) {
setVersion( getVersion() ); setVersion(getVersion());
createNewChunks( (int) setasideChunks ); createNewChunks((int) setasideChunks);
flush(); flush();
} }
} }
private void removeChunksFromCache() { private void removeChunksFromCache() {
synchronized (fCache) { synchronized (fCache) {
for (int i=1; i < fChunks.length; i++) { for (int i= 1; i < fChunks.length; i++) {
Chunk chunk= fChunks[i]; Chunk chunk= fChunks[i];
if (chunk != null) { if (chunk != null) {
fCache.remove(chunk); fCache.remove(chunk);
@ -256,7 +250,6 @@ public class Database {
} }
} }
/** /**
* Return the Chunk that contains the given offset. * Return the Chunk that contains the given offset.
* @throws CoreException * @throws CoreException
@ -268,7 +261,7 @@ public class Database {
long long_index = offset / CHUNK_SIZE; long long_index = offset / CHUNK_SIZE;
assert long_index < Integer.MAX_VALUE; assert long_index < Integer.MAX_VALUE;
synchronized(fCache) { synchronized (fCache) {
assert fLocked; assert fLocked;
final int index = (int)long_index; final int index = (int)long_index;
Chunk chunk= fChunks[index]; Chunk chunk= fChunks[index];
@ -276,8 +269,7 @@ public class Database {
cacheMisses++; cacheMisses++;
chunk = fChunks[index] = new Chunk(this, index); chunk = fChunks[index] = new Chunk(this, index);
chunk.read(); chunk.read();
} } else {
else {
cacheHits++; cacheHits++;
} }
fCache.add(chunk, fExclusiveLock); fCache.add(chunk, fExclusiveLock);
@ -359,7 +351,7 @@ public class Database {
long address = (long) newChunkIndex * CHUNK_SIZE; 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 * 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 * special status, the indexing operation should be stopped. This is desired since generally, once
* the max size is exceeded, there are lots of errors. * 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 { private long createNewChunks(int numChunks) throws CoreException {
assert fExclusiveLock; assert fExclusiveLock;
@ -383,7 +375,7 @@ public class Database {
final int oldLen= fChunks.length; final int oldLen= fChunks.length;
Chunk[] newchunks = new Chunk[oldLen+numChunks]; Chunk[] newchunks = new Chunk[oldLen+numChunks];
System.arraycopy(fChunks, 0, newchunks, 0, oldLen); 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; newchunks[i]= null;
} }
final Chunk chunk= new Chunk(this, oldLen + numChunks - 1); final Chunk chunk= new Chunk(this, oldLen + numChunks - 1);
@ -393,7 +385,7 @@ public class Database {
fCache.add(chunk, true); fCache.add(chunk, true);
fChunksAllocated=oldLen+numChunks; fChunksAllocated=oldLen+numChunks;
fChunksUsed=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; assert fExclusiveLock;
long prevblock = chunk.getFreeRecPtr(block + BLOCK_PREV_OFFSET); long prevblock = chunk.getFreeRecPtr(block + BLOCK_PREV_OFFSET);
long nextblock = chunk.getFreeRecPtr(block + BLOCK_NEXT_OFFSET); long nextblock = chunk.getFreeRecPtr(block + BLOCK_NEXT_OFFSET);
if (prevblock != 0) if (prevblock != 0) {
putFreeRecPtr(prevblock + BLOCK_NEXT_OFFSET, nextblock); putFreeRecPtr(prevblock + BLOCK_NEXT_OFFSET, nextblock);
else // we were the head } else { // we were the head
setFirstBlock(blocksize, nextblock); setFirstBlock(blocksize, nextblock);
}
if (nextblock != 0) if (nextblock != 0)
putFreeRecPtr(nextblock + BLOCK_PREV_OFFSET, prevblock); putFreeRecPtr(nextblock + BLOCK_PREV_OFFSET, prevblock);
@ -543,10 +536,11 @@ public class Database {
bytelen= 2*len; bytelen= 2*len;
} }
if (bytelen > ShortString.MAX_BYTE_LENGTH) if (bytelen > ShortString.MAX_BYTE_LENGTH) {
return new LongString(this, chars, useBytes); return new LongString(this, chars, useBytes);
else } else {
return new ShortString(this, chars, useBytes); return new ShortString(this, chars, useBytes);
}
} }
private boolean useBytes(char[] chars) { private boolean useBytes(char[] chars) {
@ -557,11 +551,9 @@ public class Database {
return true; return true;
} }
public IString getString(long offset) throws CoreException { public IString getString(long offset) throws CoreException {
final int l = getInt(offset); 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) { if (bytelen > ShortString.MAX_BYTE_LENGTH) {
return new LongString(this, offset); return new LongString(this, offset);
} }
@ -661,24 +653,20 @@ public class Database {
// locked chunk that has been removed from cache. // locked chunk that has been removed from cache.
if (chunk.fDirty) { if (chunk.fDirty) {
dirtyChunks.add(chunk); // keep in fChunks until it is flushed. dirtyChunks.add(chunk); // keep in fChunks until it is flushed.
} } else {
else {
chunk.fLocked= false; chunk.fLocked= false;
fChunks[i]= null; fChunks[i]= null;
} }
} } else if (chunk.fLocked) {
else if (chunk.fLocked) {
// locked chunk, still in cache. // locked chunk, still in cache.
if (chunk.fDirty) { if (chunk.fDirty) {
if (flush) { if (flush) {
dirtyChunks.add(chunk); dirtyChunks.add(chunk);
} }
} } else {
else {
chunk.fLocked= false; chunk.fLocked= false;
} }
} } else {
else {
assert !chunk.fDirty; // dirty chunks must be locked. assert !chunk.fDirty; // dirty chunks must be locked.
} }
} }
@ -698,8 +686,7 @@ public class Database {
if (fExclusiveLock) { if (fExclusiveLock) {
try { try {
giveUpExclusiveLock(true); giveUpExclusiveLock(true);
} } finally {
finally {
setExclusiveLock(); setExclusiveLock();
} }
return; return;

5
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/db/IBTreeComparator.java
View file

@ -6,7 +6,7 @@
* http://www.eclipse.org/legal/epl-v10.html * http://www.eclipse.org/legal/epl-v10.html
* *
* Contributors: * Contributors:
* QNX - Initial API and implementation * QNX - Initial API and implementation
*******************************************************************************/ *******************************************************************************/
package org.eclipse.cdt.internal.core.pdom.db; package org.eclipse.cdt.internal.core.pdom.db;
@ -14,13 +14,10 @@ import org.eclipse.core.runtime.CoreException;
/** /**
* @author Doug Schaefer * @author Doug Schaefer
*
*/ */
public interface IBTreeComparator { public interface IBTreeComparator {
/** /**
* Compare two records. Used for insert. * Compare two records. Used for insert.
*/ */
public abstract int compare(long record1, long record2) throws CoreException; public abstract int compare(long record1, long record2) throws CoreException;
} }

4
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/PDOMInclude.java
View file

@ -53,8 +53,8 @@ public class PDOMInclude implements IIndexFragmentInclude {
// Cached fields // Cached fields
private String fName; private String fName;
public PDOMInclude(PDOMLinkage pdom, long record) { public PDOMInclude(PDOMLinkage linkage, long record) {
this.linkage = pdom; this.linkage = linkage;
this.record = record; this.record = record;
} }